X-Git-Url: https://git.saurik.com/wxWidgets.git/blobdiff_plain/1b66e7e5ab419c5f91fc799c50addc42ef36e23b..c801d85f158c4cba50b588807daabdcbd0ed3853:/src/gdk_imlib/utils.c

diff --git a/src/gdk_imlib/utils.c b/src/gdk_imlib/utils.c
new file mode 100644
index 0000000000..961ec908f4
--- /dev/null
+++ b/src/gdk_imlib/utils.c
@@ -0,0 +1,1518 @@
+#define _GNU_SOURCE
+
+#include "gdk_imlib.h"
+#include "gdk_imlib_private.h"
+
+void
+gcalc_map_tables(GdkImlibImage * im)
+{
+   int                 i;
+   double              g, b, c, ii, v;
+
+   if (!im)
+      return;
+
+   g = ((double)im->mod.gamma) / 256;
+   b = ((double)im->mod.brightness) / 256;
+   c = ((double)im->mod.contrast) / 256;
+   if (g < 0.01)
+      g = 0.01;
+
+   for (i = 0; i < 256; i++)
+     {
+	ii = ((double)i) / 256;
+	v = ((ii - 0.5) * c) + 0.5 + (b - 1);
+	if (v > 0)
+	   v = pow(((ii - 0.5) * c) + 0.5 + (b - 1), 1 / g) * 256;
+	else
+	   v = 0;
+	if (v > 255)
+	   v = 255;
+	else if (v < 0)
+	   v = 0;
+	im->rmap[i] = (unsigned char)v;
+	im->gmap[i] = (unsigned char)v;
+	im->bmap[i] = (unsigned char)v;
+     }
+   g = ((double)im->rmod.gamma) / 256;
+   b = ((double)im->rmod.brightness) / 256;
+   c = ((double)im->rmod.contrast) / 256;
+   if (g < 0.01)
+      g = 0.01;
+
+   for (i = 0; i < 256; i++)
+     {
+	ii = ((double)im->rmap[i]) / 256;
+	v = ((ii - 0.5) * c) + 0.5 + (b - 1);
+	if (v > 0)
+	   v = pow(((ii - 0.5) * c) + 0.5 + (b - 1), 1 / g) * 256;
+	else
+	   v = 0;
+	if (v > 255)
+	   v = 255;
+	else if (v < 0)
+	   v = 0;
+	im->rmap[i] = (unsigned char)v;
+     }
+   g = ((double)im->gmod.gamma) / 256;
+   b = ((double)im->gmod.brightness) / 256;
+   c = ((double)im->gmod.contrast) / 256;
+   if (g < 0.01)
+      g = 0.01;
+
+   for (i = 0; i < 256; i++)
+     {
+	ii = ((double)im->gmap[i]) / 256;
+	v = ((ii - 0.5) * c) + 0.5 + (b - 1);
+	if (v > 0)
+	   v = pow(((ii - 0.5) * c) + 0.5 + (b - 1), 1 / g) * 256;
+	else
+	   v = 0;
+	if (v > 255)
+	   v = 255;
+	else if (v < 0)
+	   v = 0;
+	im->gmap[i] = (unsigned char)v;
+     }
+   g = ((double)im->bmod.gamma) / 256;
+   b = ((double)im->bmod.brightness) / 256;
+   c = ((double)im->bmod.contrast) / 256;
+   if (g < 0.01)
+      g = 0.01;
+   for (i = 0; i < 256; i++)
+     {
+	ii = ((double)im->bmap[i]) / 256;
+	v = ((ii - 0.5) * c) + 0.5 + (b - 1);
+	if (v > 0)
+	   v = pow(((ii - 0.5) * c) + 0.5 + (b - 1), 1 / g) * 256;
+	else
+	   v = 0;
+	if (v > 255)
+	   v = 255;
+	else if (v < 0)
+	   v = 0;
+	im->bmap[i] = (unsigned char)v;
+     }
+   gdirty_pixmaps(im);
+}
+
+gint
+gdk_imlib_load_file_to_pixmap(char *filename, GdkPixmap ** pmap, GdkBitmap ** mask)
+{
+   GdkImlibImage      *im;
+
+   im = gdk_imlib_load_image(filename);
+   if (!im)
+     {
+	if (pmap)
+	   *pmap = NULL;
+	if (mask)
+	   *mask = NULL;
+	return 0;
+     }
+   if (!gdk_imlib_render(im, im->rgb_width, im->rgb_height))
+     {
+	gdk_imlib_destroy_image(im);
+	if (pmap)
+	   *pmap = NULL;
+	if (mask)
+	   *mask = NULL;
+	return 0;
+     }
+   if (pmap)
+      *pmap = gdk_imlib_move_image(im);
+   if (mask)
+      *mask = gdk_imlib_move_mask(im);
+   gdk_imlib_destroy_image(im);
+   return 1;
+}
+
+void
+gdk_imlib_set_image_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod)
+{
+   if (!im || !mod)
+      return;
+   im->mod.gamma = mod->gamma;
+   im->mod.brightness = mod->brightness;
+   im->mod.contrast = mod->contrast;
+   gcalc_map_tables(im);
+}
+
+void
+gdk_imlib_set_image_red_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod)
+{
+   if (!im || !mod)
+      return;
+   im->rmod.gamma = mod->gamma;
+   im->rmod.brightness = mod->brightness;
+   im->rmod.contrast = mod->contrast;
+   gcalc_map_tables(im);
+}
+
+void
+gdk_imlib_set_image_green_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod)
+{
+   if (!im || !mod)
+      return;
+   im->gmod.gamma = mod->gamma;
+   im->gmod.brightness = mod->brightness;
+   im->gmod.contrast = mod->contrast;
+   gcalc_map_tables(im);
+}
+
+void
+gdk_imlib_set_image_blue_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod)
+{
+   if (!im | !mod)
+      return;
+   im->bmod.gamma = mod->gamma;
+   im->bmod.brightness = mod->brightness;
+   im->bmod.contrast = mod->contrast;
+   gcalc_map_tables(im);
+}
+
+void
+gdk_imlib_get_image_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod)
+{
+   if (!im || !mod)
+      return;
+   mod->gamma = im->mod.gamma;
+   mod->brightness = im->mod.brightness;
+   mod->contrast = im->mod.contrast;
+   gcalc_map_tables(im);
+}
+
+void
+gdk_imlib_get_image_red_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod)
+{
+   if (!im || !mod)
+      return;
+   mod->gamma = im->rmod.gamma;
+   mod->brightness = im->rmod.brightness;
+   mod->contrast = im->rmod.contrast;
+}
+
+void
+gdk_imlib_get_image_green_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod)
+{
+   if (!im || !mod)
+      return;
+   mod->gamma = im->gmod.gamma;
+   mod->brightness = im->gmod.brightness;
+   mod->contrast = im->gmod.contrast;
+}
+
+void
+gdk_imlib_get_image_blue_modifier(GdkImlibImage * im, GdkImlibColorModifier * mod)
+{
+   if (!im || !mod)
+      return;
+   mod->gamma = im->bmod.gamma;
+   mod->brightness = im->bmod.brightness;
+   mod->contrast = im->bmod.contrast;
+}
+
+void
+gdk_imlib_set_image_red_curve(GdkImlibImage * im, unsigned char *mod)
+{
+   int                 i;
+
+   if (!im || !mod)
+      return;
+   for (i = 0; i < 256; i++)
+      im->rmap[i] = mod[i];
+   gdirty_pixmaps(im);
+   im->mod.contrast = 257;
+}
+
+void
+gdk_imlib_set_image_green_curve(GdkImlibImage * im, unsigned char *mod)
+{
+   int                 i;
+
+   if (!im || !mod)
+      return;
+   for (i = 0; i < 256; i++)
+      im->gmap[i] = mod[i];
+   gdirty_pixmaps(im);
+   im->mod.contrast = 257;
+}
+
+void
+gdk_imlib_set_image_blue_curve(GdkImlibImage * im, unsigned char *mod)
+{
+   int                 i;
+
+   if (!im || !mod)
+      return;
+   for (i = 0; i < 256; i++)
+      im->bmap[i] = mod[i];
+   gdirty_pixmaps(im);
+   im->mod.contrast = 257;
+}
+
+void
+gdk_imlib_get_image_red_curve(GdkImlibImage * im, unsigned char *mod)
+{
+   int                 i;
+
+   if ((!im) || (!mod))
+      return;
+   for (i = 0; i < 256; i++)
+      mod[i] = im->rmap[i];
+}
+
+void
+gdk_imlib_get_image_green_curve(GdkImlibImage * im, unsigned char *mod)
+{
+   int                 i;
+
+   if (!im || !mod)
+      return;
+   for (i = 0; i < 256; i++)
+      mod[i] = im->gmap[i];
+}
+
+void
+gdk_imlib_get_image_blue_curve(GdkImlibImage * im, unsigned char *mod)
+{
+   int                 i;
+
+   if (!im || !mod)
+      return;
+   for (i = 0; i < 256; i++)
+      mod[i] = im->bmap[i];
+}
+
+void
+gdk_imlib_apply_modifiers_to_rgb(GdkImlibImage * im)
+{
+   int                 x, y;
+   unsigned char      *ptr;
+
+   if (!im)
+      return;
+   ptr = im->rgb_data;
+   for (y = 0; y < im->rgb_height; y++)
+     {
+	for (x = 0; x < im->rgb_width; x++)
+	  {
+	     *ptr = im->rmap[*ptr];
+	     ptr++;
+	     *ptr = im->gmap[*ptr];
+	     ptr++;
+	     *ptr = im->bmap[*ptr];
+	     ptr++;
+	  }
+     }
+   im->mod.gamma = 256;
+   im->mod.brightness = 256;
+   im->mod.contrast = 256;
+   im->rmod.gamma = 256;
+   im->rmod.brightness = 256;
+   im->rmod.contrast = 256;
+   im->gmod.gamma = 256;
+   im->gmod.brightness = 256;
+   im->gmod.contrast = 256;
+   im->bmod.gamma = 256;
+   im->bmod.brightness = 256;
+   im->bmod.contrast = 256;
+   gcalc_map_tables(im);
+   gdirty_images(im);
+   gdirty_pixmaps(im);
+}
+
+void
+gdk_imlib_crop_image(GdkImlibImage * im, gint x, gint y, gint w, gint h)
+{
+   unsigned char      *data;
+   int                 xx, yy, w3, w4;
+   unsigned char      *ptr1, *ptr2;
+
+   if (!im)
+      return;
+   if (x < 0)
+     {
+	w += x;
+	x = 0;
+     }
+   if (y < 0)
+     {
+	h += y;
+	y = 0;
+     }
+   if (x >= im->rgb_width)
+      return;
+   if (y >= im->rgb_height)
+      return;
+   if (w <= 0)
+      return;
+   if (h <= 0)
+      return;
+   if (x + w > im->rgb_width)
+      w = im->rgb_width - x;
+   if (y + h > im->rgb_height)
+      h = im->rgb_height - y;
+   if (w <= 0)
+      return;
+   if (h <= 0)
+      return;
+
+   w3 = im->rgb_width * 3;
+   w4 = (im->rgb_width - w) * 3;
+   data = malloc(w * h * 3);
+   if (data == NULL)
+      return;
+   ptr1 = im->rgb_data + (y * w3) + (x * 3);
+   ptr2 = data;
+   for (yy = 0; yy < h; yy++)
+     {
+	for (xx = 0; xx < w; xx++)
+	  {
+	     *ptr2++ = *ptr1++;
+	     *ptr2++ = *ptr1++;
+	     *ptr2++ = *ptr1++;
+	  }
+	ptr1 += w4;
+     }
+   free(im->rgb_data);
+   im->rgb_data = data;
+   if (im->border.left > x)
+      im->border.left = im->border.left - x;
+   else
+      im->border.left = 0;
+   if (im->border.top > y)
+      im->border.top = im->border.top - y;
+   else
+      im->border.top = 0;
+   if (im->rgb_width - im->border.right < x + w)
+      im->border.right = im->border.right - (im->rgb_width - (x + w));
+   else
+      im->border.right = 0;
+   if (im->rgb_height - im->border.bottom < y + h)
+      im->border.bottom = im->border.bottom - (im->rgb_height - (y + h));
+   else
+      im->border.bottom = 0;
+   im->rgb_width = w;
+   im->rgb_height = h;
+   gdirty_images(im);
+   gdirty_pixmaps(im);
+}
+
+void
+gdk_imlib_changed_image(GdkImlibImage * im)
+{
+   if (!im)
+      return;
+   gdirty_images(im);
+   gdirty_pixmaps(im);
+}
+
+void
+gdk_imlib_apply_image(GdkImlibImage * im, GdkWindow * p)
+{
+   GdkPixmap          *pp, *mm;
+   int                 w, h;
+
+   if (!im || !p)
+      return;
+   gdk_window_get_size(p, &w, &h);
+   if (w <= 0 || h <= 0)
+      return;
+   gdk_imlib_render(im, w, h);
+   pp = gdk_imlib_move_image(im);
+   mm = gdk_imlib_move_mask(im);
+   gdk_window_set_back_pixmap(p, pp, 0);
+   if (mm)
+      gdk_window_shape_combine_mask(p, mm, 0, 0);
+   gdk_window_clear(p);
+   gdk_imlib_free_pixmap(pp);
+}
+
+void
+gdk_imlib_paste_image(GdkImlibImage * im, GdkWindow * p, gint x, gint y, gint w, gint h)
+{
+   GdkGC              *gc;
+   GdkPixmap          *pp, *mm;
+
+   if (!im || !p)
+      return;
+   if ((w <= 0) || (h <= 0))
+      return;
+   gc = gdk_gc_new(p);
+   gdk_imlib_render(im, w, h);
+   pp = gdk_imlib_move_image(im);
+   mm = gdk_imlib_move_mask(im);
+   if (mm)
+     {
+	gdk_gc_set_clip_mask(gc, mm);
+	gdk_gc_set_clip_origin(gc, x, y);
+     }
+   gdk_draw_pixmap(p, gc, pp, 0, 0, x, y, w, h);
+   gdk_imlib_free_pixmap(pp);
+   gdk_gc_destroy(gc);
+}
+
+void
+gdk_imlib_paste_image_border(GdkImlibImage * im, GdkWindow * p, gint x, gint y, gint w, gint h)
+{
+   GdkGC              *gc;
+   GdkPixmap          *pp, *mm;
+
+   if (!im)
+      return;
+
+   if (w <= 0 || h <= 0)
+      return;
+   gc = gdk_gc_new(p);
+   gdk_imlib_render(im, w, h);
+   pp = gdk_imlib_move_image(im);
+   mm = gdk_imlib_move_mask(im);
+   if (mm)
+     {
+	gdk_gc_set_clip_mask(gc, mm);
+	gdk_gc_set_clip_origin(gc, x, y);
+     }
+   if ((w <= (im->border.left + im->border.right)) ||
+       (h <= (im->border.top + im->border.bottom)))
+      gdk_draw_pixmap(p, gc, pp, 0, 0, x, y, w, h);
+   else
+     {
+	gdk_draw_pixmap(p, gc, pp, 0, 0, x, y, w, im->border.top);
+	gdk_draw_pixmap(p, gc, pp, 0, h - im->border.bottom,
+			x, y + (h - im->border.bottom),
+			w, im->border.bottom);
+	gdk_draw_pixmap(p, gc, pp, 0, im->border.top,
+			x, y + im->border.top,
+		   im->border.left, h - (im->border.top + im->border.bottom));
+	gdk_draw_pixmap(p, gc, pp, w - im->border.right, h - im->border.bottom,
+		      x + (w - im->border.right), y + (h - im->border.bottom),
+		  im->border.right, h - (im->border.top + im->border.bottom));
+     }
+   gdk_imlib_free_pixmap(pp);
+   gdk_gc_destroy(gc);
+}
+
+void
+gdk_imlib_flip_image_horizontal(GdkImlibImage * im)
+{
+   unsigned char      *ptr1, *ptr2, r, rr;
+   int                 x, y;
+   int                 w3;
+
+   if (!im)
+      return;
+   w3 = im->rgb_width * 3;
+   for (y = 0; y < im->rgb_height; y++)
+     {
+	ptr1 = im->rgb_data + (y * w3);
+	ptr2 = im->rgb_data + (y * w3) + w3 - 3;
+	for (x = 0; x < im->rgb_width >> 1; x++)
+	  {
+	     r = *ptr1;
+	     rr = *ptr2;
+	     *ptr2++ = r;
+	     *ptr1++ = rr;
+
+	     r = *ptr1;
+	     rr = *ptr2;
+	     *ptr2++ = r;
+	     *ptr1++ = rr;
+
+	     r = *ptr1;
+	     rr = *ptr2;
+	     *ptr2 = r;
+	     *ptr1++ = rr;
+
+	     ptr2 -= 5;
+	  }
+     }
+   w3 = im->border.left;
+   im->border.left = im->border.right;
+   im->border.right = w3;
+   gdirty_images(im);
+   gdirty_pixmaps(im);
+}
+
+void
+gdk_imlib_flip_image_vertical(GdkImlibImage * im)
+{
+   unsigned char      *ptr1, *ptr2, r, rr;
+   int                 x, y, yy;
+   int                 w3;
+
+   if (!im)
+      return;
+
+   w3 = im->rgb_width * 3;
+   for (yy = im->rgb_height - 1, y = 0; y < im->rgb_height >> 1; y++, yy--)
+     {
+	ptr1 = im->rgb_data + (y * w3);
+	ptr2 = im->rgb_data + (yy * w3);
+	for (x = 0; x < im->rgb_width; x++)
+	  {
+	     r = *ptr1;
+	     rr = *ptr2;
+	     *ptr2++ = r;
+	     *ptr1++ = rr;
+	     r = *ptr1;
+	     rr = *ptr2;
+	     *ptr2++ = r;
+	     *ptr1++ = rr;
+	     r = *ptr1;
+	     rr = *ptr2;
+	     *ptr2++ = r;
+	     *ptr1++ = rr;
+	  }
+     }
+   w3 = im->border.top;
+   im->border.top = im->border.bottom;
+   im->border.bottom = w3;
+   gdirty_images(im);
+   gdirty_pixmaps(im);
+}
+
+void
+gdk_imlib_rotate_image(GdkImlibImage * im, gint d)
+{
+   unsigned char      *data;
+   int                 x, y, w3, w4;
+   unsigned char      *ptr1, *ptr2;
+
+   if (!im)
+      return;
+   w3 = im->rgb_width * 3;
+   w4 = im->rgb_height * 3;
+
+   data = malloc(im->rgb_width * im->rgb_height * 3);
+   if (data == NULL)
+      return;
+
+   for (y = 0; y < im->rgb_height; y++)
+     {
+	ptr1 = im->rgb_data + (y * w3);
+	ptr2 = data + (y * 3);
+	for (x = 0; x < im->rgb_width; x++)
+	  {
+	     *ptr2++ = *ptr1++;
+	     *ptr2++ = *ptr1++;
+	     *ptr2 = *ptr1++;
+	     ptr2 += w4 - 2;
+	  }
+     }
+   free(im->rgb_data);
+   im->rgb_data = data;
+   w3 = im->rgb_width;
+   im->rgb_width = im->rgb_height;
+   im->rgb_height = w3;
+   w3 = im->border.top;
+   im->border.top = im->border.left;
+   im->border.left = w3;
+   w3 = im->border.bottom;
+   im->border.bottom = im->border.right;
+   im->border.right = w3;
+   gdirty_images(im);
+   gdirty_pixmaps(im);
+}
+
+GdkImlibImage      *
+gdk_imlib_create_image_from_data(unsigned char *data, unsigned char *alpha, gint w, gint h)
+{
+   GdkImlibImage      *im;
+   char                s[128];
+
+   if (!data || w <= 0 || h <= 0)
+      return NULL;
+
+   im = malloc(sizeof(GdkImlibImage));
+   if (!im)
+      return NULL;
+
+   im->rgb_width = w;
+   im->rgb_height = h;
+   im->rgb_data = malloc(im->rgb_width * im->rgb_height * 3);
+   if (!im->rgb_data)
+     {
+	free(im);
+	return NULL;
+     }
+
+   memcpy(im->rgb_data, data, im->rgb_width * im->rgb_height * 3);
+/*      im->alpha_data=alpha; */
+   im->alpha_data = NULL;
+   g_snprintf(s, sizeof(s), "creat_%x_%x", (int)time(NULL), (int)rand());
+   im->filename = malloc(strlen(s) + 1);
+   if (im->filename)
+      strcpy(im->filename, s);
+   im->width = 0;
+   im->height = 0;
+   im->shape_color.r = -1;
+   im->shape_color.g = -1;
+   im->shape_color.b = -1;
+   im->border.left = 0;
+   im->border.right = 0;
+   im->border.top = 0;
+   im->border.bottom = 0;
+   im->pixmap = NULL;
+   im->shape_mask = NULL;
+   im->cache = 1;
+   im->mod.gamma = id->mod.gamma;
+   im->mod.brightness = id->mod.brightness;
+   im->mod.contrast = id->mod.contrast;
+   im->rmod.gamma = id->rmod.gamma;
+   im->rmod.brightness = id->rmod.brightness;
+   im->rmod.contrast = id->rmod.contrast;
+   im->gmod.gamma = id->gmod.gamma;
+   im->gmod.brightness = id->gmod.brightness;
+   im->gmod.contrast = id->gmod.contrast;
+   im->bmod.gamma = id->bmod.gamma;
+   im->bmod.brightness = id->bmod.brightness;
+   im->bmod.contrast = id->bmod.contrast;
+   if (id->cache.on_image)
+      gadd_image(im, im->filename);
+   gcalc_map_tables(im);
+   return im;
+}
+
+GdkImlibImage      *
+gdk_imlib_clone_image(GdkImlibImage * im)
+{
+   GdkImlibImage      *im2;
+   char               *s;
+
+   if (!im)
+      return NULL;
+   im2 = malloc(sizeof(GdkImlibImage));
+   if (!im2)
+      return NULL;
+   im2->rgb_width = im->rgb_width;
+   im2->rgb_height = im->rgb_height;
+   im2->rgb_data = malloc(im2->rgb_width * im2->rgb_height * 3);
+   if (!im2->rgb_data)
+     {
+	free(im2);
+	return NULL;
+     }
+
+   memcpy(im2->rgb_data, im->rgb_data, im2->rgb_width * im2->rgb_height * 3);
+   if (im->alpha_data)
+     {
+	im2->alpha_data = malloc(im2->rgb_width * im2->rgb_height);
+	if (!im2->alpha_data)
+	  {
+	     free(im2->rgb_data);
+	     free(im2);
+	     return NULL;
+	  }
+	memcpy(im2->alpha_data, im->alpha_data, im2->rgb_width * im2->rgb_height);
+     }
+   else
+      im2->alpha_data = NULL;
+   s = malloc(strlen(im->filename) + 320);
+   if (s)
+     {
+	g_snprintf(s, sizeof(s), "%s_%x_%x", im->filename, (int)time(NULL), (int)rand());
+	im2->filename = malloc(strlen(s) + 1);
+	if (im2->filename)
+	   strcpy(im2->filename, s);
+	free(s);
+     }
+   else
+      im2->filename = NULL;
+   im2->width = 0;
+   im2->height = 0;
+   im2->shape_color.r = im->shape_color.r;
+   im2->shape_color.g = im->shape_color.g;
+   im2->shape_color.b = im->shape_color.b;
+   im2->border.left = im->border.left;
+   im2->border.right = im->border.right;
+   im2->border.top = im->border.top;
+   im2->border.bottom = im->border.bottom;
+   im2->pixmap = NULL;
+   im2->shape_mask = NULL;
+   im2->cache = 1;
+   im2->mod.gamma = im->mod.gamma;
+   im2->mod.brightness = im->mod.brightness;
+   im2->mod.contrast = im->mod.contrast;
+   im2->rmod.gamma = im->rmod.gamma;
+   im2->rmod.brightness = im->rmod.brightness;
+   im2->rmod.contrast = im->rmod.contrast;
+   im2->gmod.gamma = im->gmod.gamma;
+   im2->gmod.brightness = im->gmod.brightness;
+   im2->gmod.contrast = im->gmod.contrast;
+   im2->bmod.gamma = im->bmod.gamma;
+   im2->bmod.brightness = im->bmod.brightness;
+   im2->bmod.contrast = im->bmod.contrast;
+   gcalc_map_tables(im2);
+   if (id->cache.on_image)
+      gadd_image(im2, im2->filename);
+   return im2;
+}
+
+GdkImlibImage      *
+gdk_imlib_clone_scaled_image(GdkImlibImage * im, int w, int h)
+{
+   GdkImlibImage      *im2;
+   char               *s;
+
+   if (!im || w <= 0 || h <= 0)
+      return NULL;
+
+   im2 = malloc(sizeof(GdkImlibImage));
+   if (!im2)
+      return NULL;
+   im2->rgb_width = w;
+   im2->rgb_height = h;
+   im2->rgb_data = malloc(w * h * 3);
+   if (!im2->rgb_data)
+     {
+	free(im2);
+	return NULL;
+     }
+   {
+      int                 x, y, *xarray;
+      unsigned char     **yarray, *ptr, *ptr2, *ptr22;
+      int                 l, r, m, pos, inc, w3;
+
+      xarray = malloc(sizeof(int) * w);
+
+      if (!xarray)
+	{
+	   fprintf(stderr, "ERROR: Cannot allocate X co-ord buffer\n");
+	   free(im2->rgb_data);
+	   free(im2);
+	   return NULL;
+	}
+      yarray = malloc(sizeof(unsigned char *) * h);
+
+      if (!yarray)
+	{
+	   fprintf(stderr, "ERROR: Cannot allocate Y co-ord buffer\n");
+	   free(xarray);
+	   free(im2->rgb_data);
+	   free(im2);
+	   return NULL;
+	}
+      ptr22 = im->rgb_data;
+      w3 = im->rgb_width * 3;
+      inc = 0;
+      if (w < im->border.left + im->border.right)
+	{
+	   l = w >> 1;
+	   r = w - l;
+	   m = 0;
+	}
+      else
+	{
+	   l = im->border.left;
+	   r = im->border.right;
+	   m = w - l - r;
+	}
+      if (m > 0)
+	 inc = ((im->rgb_width - im->border.left - im->border.right) << 16) / m;
+      pos = 0;
+      if (l)
+	{
+	   for (x = 0; x < l; x++)
+	     {
+		xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16);
+		pos += 0x10000;
+	     }
+	}
+      if (m)
+	{
+	   for (x = l; x < l + m; x++)
+	     {
+		xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16);
+		pos += inc;
+	     }
+	}
+      pos = (im->rgb_width - r) << 16;
+      for (x = w - r; x < w; x++)
+	{
+	   xarray[x] = (pos >> 16) + (pos >> 16) + (pos >> 16);
+	   pos += 0x10000;
+	}
+
+      if (h < im->border.top + im->border.bottom)
+	{
+	   l = h >> 1;
+	   r = h - l;
+	   m = 0;
+	}
+      else
+	{
+	   l = im->border.top;
+	   r = im->border.bottom;
+	   m = h - l - r;
+	}
+      if (m > 0)
+	 inc = ((im->rgb_height - im->border.top - im->border.bottom) << 16) / m;
+      pos = 0;
+      for (x = 0; x < l; x++)
+	{
+	   yarray[x] = ptr22 + ((pos >> 16) * w3);
+	   pos += 0x10000;
+	}
+      if (m)
+	{
+	   for (x = l; x < l + m; x++)
+	     {
+		yarray[x] = ptr22 + ((pos >> 16) * w3);
+		pos += inc;
+	     }
+	}
+      pos = (im->rgb_height - r) << 16;
+      for (x = h - r; x < h; x++)
+	{
+	   yarray[x] = ptr22 + ((pos >> 16) * w3);
+	   pos += 0x10000;
+	}
+
+      ptr = im2->rgb_data;
+      for (y = 0; y < h; y++)
+	{
+	   for (x = 0; x < w; x++)
+	     {
+		ptr2 = yarray[y] + xarray[x];
+		*ptr++ = (int)*ptr2++;
+		*ptr++ = (int)*ptr2++;
+		*ptr++ = (int)*ptr2;
+	     }
+	}
+   }
+   if (im->alpha_data)
+     {
+	im2->alpha_data = NULL;
+	/* yet to be filled in */
+     }
+   else
+      im2->alpha_data = NULL;
+
+   s = malloc(strlen(im->filename) + 320);
+   if (s)
+     {
+	g_snprintf(s, sizeof(s), "%s_%x_%x_%x_%x", im->filename, (int)time(NULL), w, h, (int)rand());
+	im2->filename = malloc(strlen(s) + 1);
+	if (im2->filename)
+	   strcpy(im2->filename, s);
+	free(s);
+     }
+   else
+      im2->filename = NULL;
+   im2->width = 0;
+   im2->height = 0;
+   im2->shape_color.r = im->shape_color.r;
+   im2->shape_color.g = im->shape_color.g;
+   im2->shape_color.b = im->shape_color.b;
+   im2->border.left = im->border.left;
+   im2->border.right = im->border.right;
+   im2->border.top = im->border.top;
+   im2->border.bottom = im->border.bottom;
+   im2->pixmap = NULL;
+   im2->shape_mask = NULL;
+   im2->cache = 1;
+   im2->mod.gamma = im->mod.gamma;
+   im2->mod.brightness = im->mod.brightness;
+   im2->mod.contrast = im->mod.contrast;
+   im2->rmod.gamma = im->rmod.gamma;
+   im2->rmod.brightness = im->rmod.brightness;
+   im2->rmod.contrast = im->rmod.contrast;
+   im2->gmod.gamma = im->gmod.gamma;
+   im2->gmod.brightness = im->gmod.brightness;
+   im2->gmod.contrast = im->gmod.contrast;
+   im2->bmod.gamma = im->bmod.gamma;
+   im2->bmod.brightness = im->bmod.brightness;
+   im2->bmod.contrast = im->bmod.contrast;
+   gcalc_map_tables(im2);
+   if (id->cache.on_image)
+      gadd_image(im2, im2->filename);
+   return im2;
+}
+
+GdkImlibImage      *
+gdk_imlib_create_image_from_xpm_data(char **data)
+{
+   GdkImlibImage      *im;
+   unsigned char      *ptr;
+   int                 pc, c, i, j, k, ncolors, cpp, comment, transp, quote,
+                       context, len, count, done;
+   int                 w, h;
+   char               *line, s[65536], tok[65536], col[65536];
+   XColor              xcol;
+   struct _cmap
+     {
+	char                str[8];
+	char                transp;
+	int                 r, g, b;
+     }
+                      *cmap;
+   int                 lookup[128][128];
+
+   if (!data)
+      return NULL;
+   im = malloc(sizeof(GdkImlibImage));
+   if (!im)
+      return NULL;
+   count = 0;
+   transp = 0;
+   done = 0;
+
+   c = ' ';
+   comment = 0;
+   quote = 0;
+   context = 0;
+   ptr = NULL;
+
+   while (!done)
+     {
+	line = data[count++];
+	if (context == 0)
+	  {
+	     /* Header */
+	     sscanf(line, "%i %i %i %i", &w, &h, &ncolors, &cpp);
+	     if (cpp > 7)
+	       {
+		  fprintf(stderr, "gdk_imlib ERROR: XPM data with characters per pixel > 7 not supported\n");
+		  free(im);
+		  return NULL;
+	       }
+	     if (w > 32767)
+	       {
+		  fprintf(stderr, "gdk_imlib ERROR: Image width > 32767 pixels for data\n");
+		  free(im);
+		  return NULL;
+	       }
+	     if (h > 32767)
+	       {
+		  fprintf(stderr, "gdk_imlib ERROR: Image height > 32767 pixels for data\n");
+		  free(im);
+		  return NULL;
+	       }
+	     cmap = malloc(sizeof(struct _cmap) * ncolors);
+
+	     if (!cmap)
+	       {
+		  free(im);
+		  return NULL;
+	       }
+	     im->rgb_width = w;
+	     im->rgb_height = h;
+	     im->rgb_data = malloc(im->rgb_width * im->rgb_height * 3);
+	     if (!im->rgb_data)
+	       {
+		  free(cmap);
+		  free(im);
+		  return NULL;
+	       }
+	     im->alpha_data = NULL;
+	     g_snprintf(s, sizeof(s), "creat_%x_%x", (int)time(NULL), (int)rand());
+	     im->filename = malloc(strlen(s) + 1);
+	     if (im->filename)
+		strcpy(im->filename, s);
+	     im->width = 0;
+	     im->height = 0;
+	     im->border.left = 0;
+	     im->border.right = 0;
+	     im->border.top = 0;
+	     im->border.bottom = 0;
+	     im->pixmap = NULL;
+	     im->shape_mask = NULL;
+	     im->cache = 1;
+	     im->mod.gamma = id->mod.gamma;
+	     im->mod.brightness = id->mod.brightness;
+	     im->mod.contrast = id->mod.contrast;
+	     im->rmod.gamma = id->rmod.gamma;
+	     im->rmod.brightness = id->rmod.brightness;
+	     im->rmod.contrast = id->rmod.contrast;
+	     im->gmod.gamma = id->gmod.gamma;
+	     im->gmod.brightness = id->gmod.brightness;
+	     im->gmod.contrast = id->gmod.contrast;
+	     im->bmod.gamma = id->bmod.gamma;
+	     im->bmod.brightness = id->bmod.brightness;
+	     im->bmod.contrast = id->bmod.contrast;
+	     ptr = im->rgb_data;
+	     j = 0;
+	     context++;
+	  }
+	else if (context == 1)
+	  {
+	     int                 colptr;
+
+	     /* Color Table */
+	     if (j < ncolors)
+	       {
+		  tok[0] = 0;
+		  col[0] = 0;
+		  s[0] = 0;
+		  colptr = 0;
+		  len = strlen(line);
+		  strncpy(cmap[j].str, line, cpp);
+		  cmap[j].str[cpp] = 0;
+		  cmap[j].r = -1;
+		  cmap[j].transp = 0;
+		  for (k = cpp; k < len; k++)
+		    {
+		       if (line[k] != ' ')
+			 {
+			    sscanf(&line[k], "%65536s", s);
+			    k += strlen(s);
+			    if ((!strcmp(s, "m")) || (!strcmp(s, "s")) ||
+				(!strcmp(s, "g4")) || (!strcmp(s, "g")) ||
+				(!strcmp(s, "c")) || (k >= len))
+			      {
+				 if (k >= len)
+				   {
+				      int                 ls;
+
+				      ls = strlen(s);
+
+				      if (col[0] && colptr < sizeof(col))
+					{
+					   strcpy(col + colptr, " ");
+					   colptr++;
+					}
+				      if (colptr + ls <= sizeof(col))
+					{
+					   strcpy(col + colptr, s);
+					   colptr += ls;
+					}
+
+				   }
+				 if (col[0])
+				   {
+				      if (!strcasecmp(col, "none"))
+					{
+					   transp = 1;
+					   cmap[j].transp = 1;
+					}
+				      else
+					{
+					   if ((cmap[j].r < 0) ||
+					       (!strcmp(tok, "c")))
+					     {
+						XParseColor(id->x.disp,
+							    id->x.root_cmap,
+							    col, &xcol);
+						cmap[j].r = xcol.red >> 8;
+						cmap[j].g = xcol.green >> 8;
+						cmap[j].b = xcol.blue >> 8;
+						if ((cmap[j].r == 255) &&
+						    (cmap[j].g == 0) &&
+						    (cmap[j].b == 255))
+						   cmap[j].r = 254;
+					     }
+					}
+				   }
+				 if (strlen(s) < sizeof(tok))
+				    strcpy(tok, s);
+				 col[0] = 0;
+			      }
+			    else
+			      {
+				 int                 ls;
+
+				 ls = strlen(s);
+
+				 if (col[0] && colptr < sizeof(col))
+				   {
+				      strcpy(col + colptr, " ");
+				      colptr++;
+				   }
+				 if (ls + colptr < sizeof(col))
+				   {
+				      strcpy(col + colptr, s);
+				      colptr += ls;
+				   }
+			      }
+			 }
+		    }
+	       }
+	     j++;
+	     if (j >= ncolors)
+	       {
+		  if (cpp == 1)
+		     for (i = 0; i < ncolors; i++)
+			lookup[cmap[i].str[0]][cmap[i].str[1]] = i;
+		  if (cpp == 2)
+		     for (i = 0; i < ncolors; i++)
+			lookup[cmap[i].str[0]][cmap[i].str[1]] = i;
+		  context++;
+	       }
+	  }
+	else
+	  {
+	     /* Image Data */
+	     i = 0;
+	     if (cpp == 0)
+	       {
+	       }
+	     else if (cpp == 1)
+	       {
+		  if (transp)
+		    {
+		       for (i = 0; ((i < 65536) && (line[i])); i++)
+			 {
+			    col[0] = line[i];
+			    if (cmap[lookup[col[0]][0]].transp)
+			      {
+				 *ptr++ = 255;
+				 *ptr++ = 0;
+				 *ptr++ = 255;
+			      }
+			    else
+			      {
+				 *ptr++ = (unsigned char)cmap[lookup[col[0]][0]].r;
+				 *ptr++ = (unsigned char)cmap[lookup[col[0]][0]].g;
+				 *ptr++ = (unsigned char)cmap[lookup[col[0]][0]].b;
+			      }
+			 }
+		    }
+		  else
+		    {
+		       for (i = 0; ((i < 65536) && (line[i])); i++)
+			 {
+			    col[0] = line[i];
+			    *ptr++ = (unsigned char)cmap[lookup[col[0]][0]].r;
+			    *ptr++ = (unsigned char)cmap[lookup[col[0]][0]].g;
+			    *ptr++ = (unsigned char)cmap[lookup[col[0]][0]].b;
+			 }
+		    }
+	       }
+	     else if (cpp == 2)
+	       {
+		  if (transp)
+		    {
+		       for (i = 0; ((i < 65536) && (line[i])); i++)
+			 {
+			    col[0] = line[i++];
+			    col[1] = line[i];
+			    if (cmap[lookup[col[0]][col[1]]].transp)
+			      {
+				 *ptr++ = 255;
+				 *ptr++ = 0;
+				 *ptr++ = 255;
+			      }
+			    else
+			      {
+				 *ptr++ = (unsigned char)cmap[lookup[col[0]][col[1]]].r;
+				 *ptr++ = (unsigned char)cmap[lookup[col[0]][col[1]]].g;
+				 *ptr++ = (unsigned char)cmap[lookup[col[0]][col[1]]].b;
+			      }
+			 }
+		    }
+		  else
+		    {
+		       for (i = 0; ((i < 65536) && (line[i])); i++)
+			 {
+			    col[0] = line[i++];
+			    col[1] = line[i];
+			    *ptr++ = (unsigned char)cmap[lookup[col[0]][col[1]]].r;
+			    *ptr++ = (unsigned char)cmap[lookup[col[0]][col[1]]].g;
+			    *ptr++ = (unsigned char)cmap[lookup[col[0]][col[1]]].b;
+			 }
+		    }
+	       }
+	     else
+	       {
+		  if (transp)
+		    {
+		       for (i = 0; ((i < 65536) && (line[i])); i++)
+			 {
+			    for (j = 0; j < cpp; j++, i++)
+			      {
+				 col[j] = line[i];
+			      }
+			    col[j] = 0;
+			    i--;
+			    for (j = 0; j < ncolors; j++)
+			      {
+				 if (!strcmp(col, cmap[j].str))
+				   {
+				      if (cmap[j].transp)
+					{
+					   *ptr++ = 255;
+					   *ptr++ = 0;
+					   *ptr++ = 255;
+					}
+				      else
+					{
+					   *ptr++ = (unsigned char)cmap[j].r;
+					   *ptr++ = (unsigned char)cmap[j].g;
+					   *ptr++ = (unsigned char)cmap[j].b;
+					}
+				      j = ncolors;
+				   }
+			      }
+			 }
+		    }
+		  else
+		    {
+		       for (i = 0; ((i < 65536) && (line[i])); i++)
+			 {
+			    for (j = 0; j < cpp; j++, i++)
+			      {
+				 col[j] = line[i];
+			      }
+			    col[j] = 0;
+			    i--;
+			    for (j = 0; j < ncolors; j++)
+			      {
+				 if (!strcmp(col, cmap[j].str))
+				   {
+				      *ptr++ = (unsigned char)cmap[j].r;
+				      *ptr++ = (unsigned char)cmap[j].g;
+				      *ptr++ = (unsigned char)cmap[j].b;
+				      j = ncolors;
+				   }
+			      }
+			 }
+		    }
+	       }
+	  }
+	if ((ptr) && ((ptr - im->rgb_data) >= w * h * 3))
+	   done = 1;
+     }
+   if (!transp)
+     {
+	im->shape_color.r = -1;
+	im->shape_color.g = -1;
+	im->shape_color.b = -1;
+     }
+   else
+     {
+	im->shape_color.r = 255;
+	im->shape_color.g = 0;
+	im->shape_color.b = 255;
+     }
+   if (id->cache.on_image)
+      gadd_image(im, im->filename);
+   gcalc_map_tables(im);
+   free(cmap);
+   return im;
+}
+
+gint
+gdk_imlib_data_to_pixmap(char **data, GdkPixmap ** pmap, GdkBitmap ** mask)
+{
+   GdkImlibImage      *im;
+
+   im = gdk_imlib_create_image_from_xpm_data(data);
+   if (!im)
+     {
+	if (pmap)
+	   *pmap = NULL;
+	if (mask)
+	   *mask = NULL;
+	return 0;
+     }
+   if (!gdk_imlib_render(im, im->rgb_width, im->rgb_height))
+     {
+	gdk_imlib_destroy_image(im);
+	if (pmap)
+	   *pmap = NULL;
+	if (mask)
+	   *mask = NULL;
+	return 0;
+     }
+   if (pmap)
+      *pmap = gdk_imlib_move_image(im);
+   if (mask)
+      *mask = gdk_imlib_move_mask(im);
+   gdk_imlib_kill_image(im);
+   return 1;
+}
+
+#include <signal.h>
+#include <sys/wait.h>
+
+/*
+ *    Helper library
+ */
+
+static int          hpid;
+void               *oldpiper;	/* actually sighandler_t but BSD uses sig_t. */
+
+FILE               *
+open_helper(const char *instring, const char *fn, const char *mode)
+{
+   char                buf[256];	/* This is safe since our input strings
+
+					 * 
+					 * * are bounded */
+   static char        *vec[16];
+   char               *p = strdup(instring);
+   char               *pp;
+   char               *ep;
+   int                 vn = 0;
+   int                 pid;
+   FILE               *fp = NULL;
+   char               *ofil = NULL;
+   int                 ofd = -1;
+
+   int                 pfd[2];
+
+   if (p == NULL)
+      return NULL;
+
+   if (strncmp(instring, "%Q", 2) == 0)
+     {
+	/*
+	 *    Generate a quanting pipeline
+	 */
+	fprintf(stderr, "Not currently supported: install ImageMagic.\n");
+	return NULL;
+     }
+   /*
+    *    Ok split the instring on spaces and translate
+    *      %C %P %F and %s
+    *
+    *      FIXME: We need to handle a format string that begins
+    *      %Q to indicate an 8bit quant in the pipeline first.
+    */
+
+   pp = p;
+
+   while (vn < 15)
+     {
+	while (*pp && isspace(*pp))
+	   pp++;
+	ep = pp;
+	while (*ep && !isspace(*ep))
+	   ep++;
+	if (*pp == 0)
+	   break;
+	/* pp->ep is now the input string block */
+	if (*ep)
+	   *ep++ = 0;
+
+	if (strcmp(pp, "%s") == 0)
+	   vec[vn] = strdup(fn);
+	else if (strncmp(pp, "%P/", 3) == 0)
+	  {
+	     strcpy(buf, NETPBM_PATH);
+	     strcat(buf, pp + 2);
+	     if ((vec[vn] = strdup(buf)) == NULL)
+		break;
+	  }
+	else if (strncmp(pp, "%J", 3) == 0)
+	  {
+	     if ((vec[vn] = strdup(DJPEG_PROG)) == NULL)
+		break;
+	  }
+	else if (strncmp(pp, "%H", 3) == 0)
+	  {
+	     if ((vec[vn] = strdup(CJPEG_PROG)) == NULL)
+		break;
+	  }
+	else if (strncmp(pp, "%C/", 3) == 0)
+	  {
+	     strcpy(buf, CONVERT_PATH);
+	     strcat(buf, pp + 2);
+	     if ((vec[vn] = strdup(buf)) == NULL)
+		break;
+	  }
+	else if (strncmp(pp, ">%s", 3) == 0)
+	  {
+	     ofil = pp;
+	     vn++;
+	     pp = ep;
+	     continue;
+	  }
+	else
+	  {
+	     if ((vec[vn] = strdup(pp)) == NULL)
+		break;
+	  }
+	vn++;
+	pp = ep;
+     }
+
+   vec[vn] = NULL;
+
+   if (pipe(pfd) == -1)
+      goto oops;
+
+   if (*mode == 'r')
+     {
+	fp = fdopen(pfd[0], "r");
+	if (fp == NULL)
+	   goto oops;
+     }
+   else if (*mode == 'w')
+     {
+	fp = fdopen(pfd[1], "w");
+	if (fp == NULL)
+	   goto oops;
+     }
+   else
+      goto oops;
+
+   if (ofil != NULL)
+      if ((ofd = open(ofil, O_WRONLY | O_TRUNC | O_CREAT)) == -1)
+	 goto oops;
+
+   switch (pid = fork())
+     {
+     case -1:
+	break;
+     case 0:
+	signal(SIGPIPE, SIG_DFL);
+	if (*mode == 'r')
+	   dup2(pfd[1], 1);
+	if (*mode == 'w')
+	  {
+	     dup2(pfd[0], 0);
+	     if (ofd != -1)
+	       {
+		  dup2(ofd, 1);
+		  close(1);
+	       }
+	  }
+	close(pfd[0]);
+	close(pfd[1]);
+	execv(vec[0], vec);
+	perror(vec[0]);
+	/*
+	 *    This MUST be _exit or we will hit the SIGPIPE
+	 *      handler in ways we dont want. We want our parent
+	 *      to flush the inherited file buffers not us.
+	 */
+	_exit(1);
+     default:
+	hpid = pid;
+
+	if (ofd != -1)
+	   close(ofd);
+	if (*mode == 'r')
+	   close(pfd[1]);
+	else
+	   close(pfd[0]);
+     }
+   for (vn = 0; vn < 16; vn++)
+      if (vec[vn])
+	 free(vec[vn]);
+   oldpiper = signal(SIGPIPE, SIG_IGN);
+   return fp;
+
+ oops:
+   if (ofd != -1)
+      close(ofd);
+   if (fp)
+      fclose(fp);
+   for (vn = 0; vn < 16; vn++)
+      if (vec[vn])
+	 free(vec[vn]);
+   return NULL;
+}
+
+int
+close_helper(FILE * fp)
+{
+   int                 info;
+
+   fclose(fp);
+   signal(SIGPIPE, oldpiper);
+   waitpid(hpid, &info, 0);
+   return WEXITSTATUS(info);
+}