#define _GNU_SOURCE
#include <config.h>
#include "gdk_imlib.h"
#define id _gdk_imlib_data
#include "gdk_imlib_private.h"

GdkPixmap          *
gdk_imlib_pixmap_foreign_new(gint width, gint height,
			     gint depth, Pixmap pmap)
{
  GdkPixmap          *pixmap;
  GdkWindowPrivate   *private;
  GdkWindowPrivate   *window_private;

  private = g_new0(GdkWindowPrivate, 1);
  pixmap = (GdkPixmap *) private;

  window_private = (GdkWindowPrivate *) id->x.gdk_win;

  private->xdisplay = window_private->xdisplay;
  private->window_type = GDK_WINDOW_PIXMAP;
  private->xwindow = pmap;
  private->colormap = id->x.gdk_cmap;
  private->children = NULL;
  private->parent = NULL;
  private->x = 0;
  private->y = 0;
  private->width = width;
  private->height = height;
  private->resize_count = 0;
  private->ref_count = 1;
  private->destroyed = 0;

  gdk_xid_table_insert(&private->xwindow, pixmap);

  return pixmap;
}

gint
gdk_imlib_best_color_match(gint * r, gint * g, gint * b)
{
  int                 i;
  int                 dif;
  int                 dr, dg, db;
  int                 col;
  int                 mindif = 0x7fffffff;

  col = 0;
  g_return_val_if_fail(id->x.disp, -1);
  if ((id->render_type == RT_PLAIN_TRUECOL) ||
      (id->render_type == RT_DITHER_TRUECOL))
    {
      dr = *r;
      dg = *g;
      db = *b;
      switch (id->x.depth)
	{
        case 12:
          *r = dr - (dr & 0xf0);
          *g = dg - (dg & 0xf0);
          *b = db - (db & 0xf0);
          return ((dr & 0xf0) << 8) | ((dg & 0xf0) << 3) | ((db & 0xf0) >> 3);
          break;
	case 15:
	  *r = dr - (dr & 0xf8);
	  *g = dg - (dg & 0xf8);
	  *b = db - (db & 0xf8);
	  return ((dr & 0xf8) << 7) | ((dg & 0xf8) << 2) | ((db & 0xf8) >> 3);
	  break;
	case 16:
	  *r = dr - (dr & 0xf8);
	  *g = dg - (dg & 0xfc);
	  *b = db - (db & 0xf8);
	  return ((dr & 0xf8) << 8) | ((dg & 0xfc) << 3) | ((db & 0xf8) >> 3);
	  break;
	case 24:
	case 32:
	  *r = 0;
	  *g = 0;
	  *b = 0;
	  switch (id->byte_order)
	    {
	    case BYTE_ORD_24_RGB:
	      return ((dr & 0xff) << 16) | ((dg & 0xff) << 8) | (db & 0xff);
	      break;
	    case BYTE_ORD_24_RBG:
	      return ((dr & 0xff) << 16) | ((db & 0xff) << 8) | (dg & 0xff);
	      break;
	    case BYTE_ORD_24_BRG:
	      return ((db & 0xff) << 16) | ((dr & 0xff) << 8) | (dg & 0xff);
	      break;
	    case BYTE_ORD_24_BGR:
	      return ((db & 0xff) << 16) | ((dg & 0xff) << 8) | (dr & 0xff);
	      break;
	    case BYTE_ORD_24_GRB:
	      return ((dg & 0xff) << 16) | ((dr & 0xff) << 8) | (db & 0xff);
	      break;
	    case BYTE_ORD_24_GBR:
	      return ((dg & 0xff) << 16) | ((db & 0xff) << 8) | (dr & 0xff);
	      break;
	    default:
	      return 0;
	      break;
	    }
	  break;
	default:
	  return 0;
	  break;
	}
      return 0;
    }
  for (i = 0; i < id->num_colors; i++)
    {
      dr = *r - id->palette[i].r;
      if (dr < 0)
	dr = -dr;
      dg = *g - id->palette[i].g;
      if (dg < 0)
	dg = -dg;
      db = *b - id->palette[i].b;
      if (db < 0)
	db = -db;
      dif = dr + dg + db;
      if (dif < mindif)
	{
	  mindif = dif;
	  col = i;
	}
    }
  *r -= id->palette[col].r;
  *g -= id->palette[col].g;
  *b -= id->palette[col].b;
  col = id->palette[col].pixel;
  return col;
}

gint
_gdk_imlib_index_best_color_match(gint * r, gint * g, gint * b)
{
  int                 i;
  int                 dif;
  int                 dr, dg, db;
  int                 col;
  int                 mindif = 0x7fffffff;

  col = 0;
  g_return_val_if_fail(id->x.disp, -1);
  if ((id->render_type == RT_PLAIN_TRUECOL) ||
      (id->render_type == RT_DITHER_TRUECOL))
    {
      dr = *r;
      dg = *g;
      db = *b;
      switch (id->x.depth)
	{
        case 12:
          *r = dr - (dr & 0xf0);
          *g = dg - (dg & 0xf0);
          *b = db - (db & 0xf0);
          return ((dr & 0xf0) << 8) | ((dg & 0xf0) << 3) | ((db & 0xf0) >> 3);
          break;
 	case 15:
	  *r = dr - (dr & 0xf8);
	  *g = dg - (dg & 0xf8);
	  *b = db - (db & 0xf8);
	  return ((dr & 0xf8) << 7) | ((dg & 0xf8) << 2) | ((db & 0xf8) >> 3);
	  break;
	case 16:
	  *r = dr - (dr & 0xf8);
	  *g = dg - (dg & 0xfc);
	  *b = db - (db & 0xf8);
	  return ((dr & 0xf8) << 8) | ((dg & 0xfc) << 3) | ((db & 0xf8) >> 3);
	  break;
	case 24:
	case 32:
	  *r = 0;
	  *g = 0;
	  *b = 0;
	  switch (id->byte_order)
	    {
	    case BYTE_ORD_24_RGB:
	      return ((dr & 0xff) << 16) | ((dg & 0xff) << 8) | (db & 0xff);
	      break;
	    case BYTE_ORD_24_RBG:
	      return ((dr & 0xff) << 16) | ((db & 0xff) << 8) | (dg & 0xff);
	      break;
	    case BYTE_ORD_24_BRG:
	      return ((db & 0xff) << 16) | ((dr & 0xff) << 8) | (dg & 0xff);
	      break;
	    case BYTE_ORD_24_BGR:
	      return ((db & 0xff) << 16) | ((dg & 0xff) << 8) | (dr & 0xff);
	      break;
	    case BYTE_ORD_24_GRB:
	      return ((dg & 0xff) << 16) | ((dr & 0xff) << 8) | (db & 0xff);
	      break;
	    case BYTE_ORD_24_GBR:
	      return ((dg & 0xff) << 16) | ((db & 0xff) << 8) | (dr & 0xff);
	      break;
	    default:
	      return 0;
	      break;
	    }
	  break;
	default:
	  return 0;
	  break;
	}
      return 0;
    }
  for (i = 0; i < id->num_colors; i++)
    {
      dr = *r - id->palette[i].r;
      if (dr < 0)
	dr = -dr;
      dg = *g - id->palette[i].g;
      if (dg < 0)
	dg = -dg;
      db = *b - id->palette[i].b;
      if (db < 0)
	db = -db;
      dif = dr + dg + db;
      if (dif < mindif)
	{
	  mindif = dif;
	  col = i;
	}
    }
  *r -= id->palette[col].r;
  *g -= id->palette[col].g;
  *b -= id->palette[col].b;
  return col;
}

static void
grender_shaped_15_fast_dither(GdkImlibImage * im, int w, int h, XImage * xim,
			      XImage * sxim, int *er1, int *er2, int *xarray,
			      unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      img++;
	      ex += 3;
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      er = r + er1[ex++];
	      eg = g + er1[ex++];
	      eb = b + er1[ex++];
	      if (er > 255)
		er = 255;
	      if (eg > 255)
		eg = 255;
	      if (eb > 255)
		eb = 255;
	      val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
	      er = er & 0x07;
	      eg = eg & 0x07;
	      eb = eb & 0x07;
	      DITHER_ERROR(er1, er2, ex, er, eg, eb);
	      *img++ = val;
	    }
	}
      img += jmp;
    }
}

static void
grender_shaped_15_fast_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			       XImage * sxim, int *er1, int *er2, int *xarray,
				      unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;

  unsigned char       dither[4][4] =
  {
    {0, 4, 1, 5},
    {6, 2, 7, 3},
    {1, 5, 0, 4},
    {7, 3, 6, 2}
  };
  int                 dithy, dithx;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      img++;
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      er = r & 0x07;
	      eg = g & 0x07;
	      eb = b & 0x07;
	      dithx = x & 0x3;
	      if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
		r += 8;
	      if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
		g += 8;
	      if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
		b += 8;
	      val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	      *img++ = val;
	    }
	}
      img += jmp;
    }
}

static void
grender_15_fast_dither(GdkImlibImage * im, int w, int h, XImage * xim,
		       XImage * sxim, int *er1, int *er2, int *xarray,
		       unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  er = r + er1[ex++];
	  eg = g + er1[ex++];
	  eb = b + er1[ex++];
	  if (er > 255)
	    er = 255;
	  if (eg > 255)
	    eg = 255;
	  if (eb > 255)
	    eb = 255;
	  val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
	  er = er & 0x07;
	  eg = eg & 0x07;
	  eb = eb & 0x07;
	  DITHER_ERROR(er1, er2, ex, er, eg, eb);
	  *img++ = val;
	}
      img += jmp;
    }
}

static void
grender_15_fast_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			       XImage * sxim, int *er1, int *er2, int *xarray,
			       unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;

  unsigned short     *img;
  int                 jmp;

  unsigned char       dither[4][4] =
  {
    {0, 4, 1, 5},
    {6, 2, 7, 3},
    {1, 5, 0, 4},
    {7, 3, 6, 2}
  };
  int                 dithy, dithx;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  er = r & 0x07;
	  eg = g & 0x07;
	  eb = b & 0x07;
	  dithx = x & 0x3;
	  if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
	    r += 8;
	  if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
	    g += 8;
	  if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
	    b += 8;
	  val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	  *img++ = val;
	}
      img += jmp;
    }
}

static void
grender_shaped_16_fast_dither(GdkImlibImage * im, int w, int h, XImage * xim,
			      XImage * sxim, int *er1, int *er2, int *xarray,
			      unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      img++;
	      ex += 3;
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      er = r + er1[ex++];
	      eg = g + er1[ex++];
	      eb = b + er1[ex++];
	      if (er > 255)
		er = 255;
	      if (eg > 255)
		eg = 255;
	      if (eb > 255)
		eb = 255;
	      val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
	      er = er & 0x07;
	      eg = eg & 0x03;
	      eb = eb & 0x07;
	      DITHER_ERROR(er1, er2, ex, er, eg, eb);
	      *img++ = val;
	    }
	}
      img += jmp;
    }
}

static void
grender_shaped_16_fast_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			       XImage * sxim, int *er1, int *er2, int *xarray,
				      unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;

  unsigned char       dither[4][4] =
  {
    {0, 4, 1, 5},
    {6, 2, 7, 3},
    {1, 5, 0, 4},
    {7, 3, 6, 2}
  };
  int                 dithy, dithx;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      img++;
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      er = r & 0x07;
	      eg = g & 0x03;
	      eb = b & 0x07;
	      dithx = x & 0x3;
	      if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
		r += 8;
	      if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
		g += 4;
	      if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
		b += 8;
	      val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	      *img++ = val;
	    }
	}
      img += jmp;
    }
}

static void
grender_16_fast_dither(GdkImlibImage * im, int w, int h, XImage * xim,
		       XImage * sxim, int *er1, int *er2, int *xarray,
		       unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;

  unsigned short     *img;
  int                 jmp;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  er = r + er1[ex++];
	  eg = g + er1[ex++];
	  eb = b + er1[ex++];
	  if (er > 255)
	    er = 255;
	  if (eg > 255)
	    eg = 255;
	  if (eb > 255)
	    eb = 255;
	  val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
	  er = er & 0x07;
	  eg = eg & 0x03;
	  eb = eb & 0x07;
	  DITHER_ERROR(er1, er2, ex, er, eg, eb);
	  *img++ = val;
	}
      img += jmp;
    }
}

static void
grender_16_fast_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			       XImage * sxim, int *er1, int *er2, int *xarray,
			       unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;

  unsigned short     *img;
  int                 jmp;

  unsigned char       dither[4][4] =
  {
    {0, 4, 1, 5},
    {6, 2, 7, 3},
    {1, 5, 0, 4},
    {7, 3, 6, 2}
  };
  int                 dithy, dithx;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  er = r & 0x07;
	  eg = g & 0x03;
	  eb = b & 0x07;
	  dithx = x & 0x3;
	  if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
	    r += 8;
	  if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
	    g += 4;
	  if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
	    b += 8;
	  val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	  *img++ = val;
	}
      img += jmp;
    }
}

static void
grender_shaped_15_dither(GdkImlibImage * im, int w, int h, XImage * xim,
			 XImage * sxim, int *er1, int *er2, int *xarray,
			 unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;

  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      ex += 3;
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      er = r + er1[ex++];
	      eg = g + er1[ex++];
	      eb = b + er1[ex++];
	      if (er > 255)
		er = 255;
	      if (eg > 255)
		eg = 255;
	      if (eb > 255)
		eb = 255;
	      val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
	      er = er & 0x07;
	      eg = eg & 0x07;
	      eb = eb & 0x07;
	      if (er > 255)
		er = 255;
	      else if (er < 0)
		er = 0;
	      if (eg > 255)
		eg = 255;
	      else if (eg < 0)
		eg = 0;
	      if (eb > 255)
		eb = 255;
	      else if (eb < 0)
		eb = 0;
	      val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	      er = r & 0x07;
	      eg = g & 0x07;
	      eb = b & 0x07;
	      DITHER_ERROR(er1, er2, ex, er, eg, eb);
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_shaped_15_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			       XImage * sxim, int *er1, int *er2, int *xarray,
				 unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;

  unsigned char       dither[4][4] =
  {
    {0, 4, 1, 5},
    {6, 2, 7, 3},
    {1, 5, 0, 4},
    {7, 3, 6, 2}
  };
  int                 dithy, dithx;

  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      er = r & 0x07;
	      eg = g & 0x07;
	      eb = b & 0x07;
	      dithx = x & 0x3;
	      if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
		r += 8;
	      if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
		g += 8;
	      if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
		b += 8;
	      val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_15_dither(GdkImlibImage * im, int w, int h, XImage * xim,
		  XImage * sxim, int *er1, int *er2, int *xarray,
		  unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;

  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  er = r + er1[ex++];
	  eg = g + er1[ex++];
	  eb = b + er1[ex++];
	  if (er > 255)
	    er = 255;
	  if (eg > 255)
	    eg = 255;
	  if (eb > 255)
	    eb = 255;
	  val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
	  er = er & 0x07;
	  eg = eg & 0x07;
	  eb = eb & 0x07;
	  DITHER_ERROR(er1, er2, ex, er, eg, eb);
	  XPutPixel(xim, x, y, val);
	}
    }
}

static void
grender_15_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			  XImage * sxim, int *er1, int *er2, int *xarray,
			  unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;

  unsigned char       dither[4][4] =
  {
    {0, 4, 6, 5},
    {6, 2, 7, 3},
    {2, 6, 1, 5},
    {7, 4, 7, 3}
  };
  int                 dithy, dithx;

  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  er = r & 0x07;
	  eg = g & 0x07;
	  eb = b & 0x07;
	  dithx = x & 0x3;
	  if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
	    r += 8;
	  if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
	    g += 8;
	  if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
	    b += 8;
	  val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	  XPutPixel(xim, x, y, val);
	}
    }
}

static void
grender_shaped_16_dither(GdkImlibImage * im, int w, int h, XImage * xim,
			 XImage * sxim, int *er1, int *er2, int *xarray,
			 unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;

  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      ex += 3;
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      er = r + er1[ex++];
	      eg = g + er1[ex++];
	      eb = b + er1[ex++];
	      if (er > 255)
		er = 255;
	      if (eg > 255)
		eg = 255;
	      if (eb > 255)
		eb = 255;
	      val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
	      er = er & 0x07;
	      eg = eg & 0x03;
	      eb = eb & 0x07;
	      DITHER_ERROR(er1, er2, ex, er, eg, eb);
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_shaped_16_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			       XImage * sxim, int *er1, int *er2, int *xarray,
				 unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;

  unsigned char       dither[4][4] =
  {
    {0, 4, 6, 5},
    {6, 2, 7, 3},
    {2, 6, 1, 5},
    {7, 4, 7, 3}
  };
  int                 dithy, dithx;

  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      er = r & 0x07;
	      eg = g & 0x03;
	      eb = b & 0x07;
	      dithx = x & 0x3;
	      if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
		r += 8;
	      if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
		g += 4;
	      if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
		b += 8;
	      val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_16_dither(GdkImlibImage * im, int w, int h, XImage * xim,
		  XImage * sxim, int *er1, int *er2, int *xarray,
		  unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;

  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  er = r + er1[ex++];
	  eg = g + er1[ex++];
	  eb = b + er1[ex++];
	  if (er > 255)
	    er = 255;
	  if (eg > 255)
	    eg = 255;
	  if (eb > 255)
	    eb = 255;
	  val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
	  er = er & 0x07;
	  eg = eg & 0x03;
	  eb = eb & 0x07;
	  DITHER_ERROR(er1, er2, ex, er, eg, eb);
	  XPutPixel(xim, x, y, val);
	}
    }
}

static void
grender_16_dither_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			  XImage * sxim, int *er1, int *er2, int *xarray,
			  unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;

  unsigned char       dither[4][4] =
  {
    {0, 4, 6, 5},
    {6, 2, 7, 3},
    {2, 6, 1, 5},
    {7, 4, 7, 3}
  };
  int                 dithy, dithx;

  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  er = r & 0x07;
	  eg = g & 0x03;
	  eb = b & 0x07;
	  dithx = x & 0x3;
	  if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
	    r += 8;
	  if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
	    g += 4;
	  if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
	    b += 8;
	  val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	  XPutPixel(xim, x, y, val);
	}
    }
}

static void
grender_shaped_15_fast(GdkImlibImage * im, int w, int h, XImage * xim,
		       XImage * sxim, int *er1, int *er2, int *xarray,
		       unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      img++;
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	      *img++ = val;
	    }
	}
      img += jmp;
    }
}

static void
grender_15_fast(GdkImlibImage * im, int w, int h, XImage * xim,
		XImage * sxim, int *er1, int *er2, int *xarray,
		unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	  *img++ = val;
	}
      img += jmp;
    }
}

static void
grender_shaped_16_fast(GdkImlibImage * im, int w, int h, XImage * xim,
		       XImage * sxim, int *er1, int *er2, int *xarray,
		       unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      img++;
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	      *img++ = val;
	    }
	}
      img += jmp;
    }
}

static void
grender_16_fast(GdkImlibImage * im, int w, int h, XImage * xim,
		XImage * sxim, int *er1, int *er2, int *xarray,
		unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;

  unsigned short     *img;
  int                 jmp;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	  *img++ = val;
	}
      img += jmp;
    }
}

static void
grender_shaped_24_fast(GdkImlibImage * im, int w, int h, XImage * xim,
		       XImage * sxim, int *er1, int *er2, int *xarray,
		       unsigned char **yarray)
{
  int                 x, y, r, g, b;
  unsigned char      *ptr2;
  unsigned char      *img;
  int                 jmp;

  jmp = (xim->bytes_per_line) - w * 3;
  img = (unsigned char *)xim->data;
  if (id->x.byte_order == MSBFirst)
    {
      if (id->byte_order == BYTE_ORD_24_RGB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = r;
		      *img++ = g;
		      *img++ = b;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_RBG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = r;
		      *img++ = b;
		      *img++ = g;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BRG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = b;
		      *img++ = r;
		      *img++ = g;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BGR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = b;
		      *img++ = g;
		      *img++ = r;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GRB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = g;
		      *img++ = r;
		      *img++ = b;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GBR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = g;
		      *img++ = b;
		      *img++ = r;
		    }
		}
	      img += jmp;
	    }
	}
    }
  else
    {
      if (id->byte_order == BYTE_ORD_24_RGB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = b;
		      *img++ = g;
		      *img++ = r;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_RBG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = g;
		      *img++ = b;
		      *img++ = r;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BRG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = g;
		      *img++ = r;
		      *img++ = b;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BGR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = r;
		      *img++ = g;
		      *img++ = b;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GRB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = b;
		      *img++ = r;
		      *img++ = g;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GBR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = r;
		      *img++ = b;
		      *img++ = g;
		    }
		}
	      img += jmp;
	    }
	}
    }
}

static void
grender_24_fast(GdkImlibImage * im, int w, int h, XImage * xim,
		XImage * sxim, int *er1, int *er2, int *xarray,
		unsigned char **yarray)
{
  int                 x, y, r, g, b;
  unsigned char      *ptr2;
  unsigned char      *img;
  int                 jmp;

  jmp = (xim->bytes_per_line) - w * 3;
  img = (unsigned char *)xim->data;

  if (id->byte_order == MSBFirst)
    {
      if (id->byte_order == BYTE_ORD_24_RGB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  *img++ = r;
		  *img++ = g;
		  *img++ = b;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_RBG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  *img++ = r;
		  *img++ = b;
		  *img++ = g;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BRG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  *img++ = b;
		  *img++ = r;
		  *img++ = g;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BGR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  *img++ = b;
		  *img++ = g;
		  *img++ = r;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GRB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  *img++ = g;
		  *img++ = r;
		  *img++ = b;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GBR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  *img++ = g;
		  *img++ = b;
		  *img++ = r;
		}
	      img += jmp;
	    }
	}
    }
  else
    {
      if (id->byte_order == BYTE_ORD_24_RGB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  *img++ = b;
		  *img++ = g;
		  *img++ = r;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_RBG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  *img++ = g;
		  *img++ = b;
		  *img++ = r;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BRG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  *img++ = g;
		  *img++ = r;
		  *img++ = b;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BGR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  *img++ = r;
		  *img++ = g;
		  *img++ = b;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GRB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  *img++ = b;
		  *img++ = r;
		  *img++ = g;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GBR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  *img++ = r;
		  *img++ = b;
		  *img++ = g;
		}
	      img += jmp;
	    }
	}
    }
}

static void
grender_shaped_32_fast(GdkImlibImage * im, int w, int h, XImage * xim,
		       XImage * sxim, int *er1, int *er2, int *xarray,
		       unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  unsigned int       *img;
  int                 jmp;

  jmp = (xim->bytes_per_line >> 2) - w;
  img = (unsigned int *)xim->data;
  if (id->byte_order == BYTE_ORD_24_RGB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		{
		  XPutPixel(sxim, x, y, 0);
		  img++;
		}
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  val = (r << 16) | (g << 8) | b;
		  *img++ = val;
		}
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_RBG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		{
		  XPutPixel(sxim, x, y, 0);
		  img++;
		}
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  val = (r << 16) | (b << 8) | g;
		  *img++ = val;
		}
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BRG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		{
		  XPutPixel(sxim, x, y, 0);
		  img++;
		}
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  val = (b << 16) | (r << 8) | g;
		  *img++ = val;
		}
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BGR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		{
		  XPutPixel(sxim, x, y, 0);
		  img++;
		}
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  val = (b << 16) | (g << 8) | r;
		  *img++ = val;
		}
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GRB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		{
		  XPutPixel(sxim, x, y, 0);
		  img++;
		}
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  val = (g << 16) | (r << 8) | b;
		  *img++ = val;
		}
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GBR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		{
		  XPutPixel(sxim, x, y, 0);
		  img++;
		}
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  val = (g << 16) | (b << 8) | r;
		  *img++ = val;
		}
	    }
	  img += jmp;
	}
    }
}

static void
grender_32_fast(GdkImlibImage * im, int w, int h, XImage * xim,
		XImage * sxim, int *er1, int *er2, int *xarray,
		unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  unsigned int       *img;
  int                 jmp;

  jmp = (xim->bytes_per_line >> 2) - w;
  img = (unsigned int *)xim->data;
  if (id->byte_order == BYTE_ORD_24_RGB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      val = (r << 16) | (g << 8) | b;
	      *img++ = val;
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_RBG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      val = (r << 16) | (b << 8) | g;
	      *img++ = val;
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BRG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      val = (b << 16) | (r << 8) | g;
	      *img++ = val;
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BGR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      val = (b << 16) | (g << 8) | r;
	      *img++ = val;
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GRB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      val = (g << 16) | (r << 8) | b;
	      *img++ = val;
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GBR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      val = (g << 16) | (b << 8) | r;
	      *img++ = val;
	    }
	  img += jmp;
	}
    }
}

static void
grender_shaped_15(GdkImlibImage * im, int w, int h, XImage * xim,
		  XImage * sxim, int *er1, int *er2, int *xarray,
		  unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;

  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    XPutPixel(sxim, x, y, 0);
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_15(GdkImlibImage * im, int w, int h, XImage * xim,
	   XImage * sxim, int *er1, int *er2, int *xarray,
	   unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;

  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	  XPutPixel(xim, x, y, val);
	}
    }
}

static void
grender_shaped_16(GdkImlibImage * im, int w, int h, XImage * xim,
		  XImage * sxim, int *er1, int *er2, int *xarray,
		  unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;

  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    XPutPixel(sxim, x, y, 0);
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_16(GdkImlibImage * im, int w, int h, XImage * xim,
	   XImage * sxim, int *er1, int *er2, int *xarray,
	   unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;

  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	  XPutPixel(xim, x, y, val);
	}
    }
}

static void
grender_shaped_12(GdkImlibImage * im, int w, int h, XImage * xim,
                  XImage * sxim, int *er1, int *er2, int *xarray,
                  unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;

  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
        {
          ptr2 = yarray[y] + xarray[x];
          r = (int)*ptr2++;
          g = (int)*ptr2++;
          b = (int)*ptr2;
          if ((r == im->shape_color.r) &&
              (g == im->shape_color.g) &&
              (b == im->shape_color.b))
            XPutPixel(sxim, x, y, 0);
          else
            {
              XPutPixel(sxim, x, y, 1);
              val = ((r & 0xf0) << 8) | ((g & 0xf0) << 3) | ((b & 0xf0) >> 3);
              XPutPixel(xim, x, y, val);
            }
        }
    }
}

static void
grender_12(GdkImlibImage * im, int w, int h, XImage * xim,
           XImage * sxim, int *er1, int *er2, int *xarray,
           unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;

  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
        {
          ptr2 = yarray[y] + xarray[x];
          r = (int)*ptr2++;
          g = (int)*ptr2++;
          b = (int)*ptr2;
          val = ((r & 0xf0) << 8) | ((g & 0xf0) << 3) | ((b & 0xf0) >> 3);
          XPutPixel(xim, x, y, val);
        }
    }
}

static void
grender_shaped_24(GdkImlibImage * im, int w, int h, XImage * xim,
		  XImage * sxim, int *er1, int *er2, int *xarray,
		  unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;

  if (id->byte_order == BYTE_ORD_24_RGB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		XPutPixel(sxim, x, y, 0);
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  val = (r << 16) | (g << 8) | b;
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_RBG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		XPutPixel(sxim, x, y, 0);
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  val = (r << 16) | (b << 8) | g;
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BRG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		XPutPixel(sxim, x, y, 0);
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  val = (b << 16) | (r << 8) | g;
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BGR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		XPutPixel(sxim, x, y, 0);
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  val = (b << 16) | (g << 8) | r;
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GRB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		XPutPixel(sxim, x, y, 0);
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  val = (g << 16) | (r << 8) | b;
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GBR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		XPutPixel(sxim, x, y, 0);
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  val = (g << 16) | (b << 8) | r;
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
    }
}

static void
grender_24(GdkImlibImage * im, int w, int h, XImage * xim,
	   XImage * sxim, int *er1, int *er2, int *xarray,
	   unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;

  if (id->byte_order == BYTE_ORD_24_RGB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      val = (r << 16) | (g << 8) | b;
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_RBG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      val = (r << 16) | (b << 8) | g;
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BRG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      val = (b << 16) | (r << 8) | g;
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BGR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      val = (b << 16) | (g << 8) | r;
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GRB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      val = (g << 16) | (r << 8) | b;
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GBR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      val = (g << 16) | (b << 8) | r;
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_shaped(GdkImlibImage * im, int w, int h, XImage * xim,
	       XImage * sxim, int *er1, int *er2, int *xarray,
	       unsigned char **yarray, int bpp)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;
  unsigned char      *img;
  int                 jmp;

  jmp = (xim->bytes_per_line) - w * (bpp >> 3);
  img = (unsigned char *)xim->data;
  switch (id->render_type)
    {
    case RT_PLAIN_PALETTE:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img++;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      val = gdk_imlib_best_color_match(&r, &g, &b);
		      *img++ = val;
		    }
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    XPutPixel(sxim, x, y, 0);
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      val = gdk_imlib_best_color_match(&r, &g, &b);
		      XPutPixel(xim, x, y, val);
		    }
		}
	    }
	}
      break;
    case RT_PLAIN_PALETTE_FAST:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img++;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
		      *img++ = val;
		    }
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    XPutPixel(sxim, x, y, 0);
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
		      XPutPixel(xim, x, y, val);
		    }
		}
	    }
	}
      break;
    case RT_DITHER_PALETTE:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      {
			XPutPixel(sxim, x, y, 0);
			img++;
		      }
		      ex += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      er = r + er1[ex++];
		      eg = g + er1[ex++];
		      eb = b + er1[ex++];
		      if (er > 255)
			er = 255;
		      else if (er < 0)
			er = 0;
		      if (eg > 255)
			eg = 255;
		      else if (eg < 0)
			eg = 0;
		      if (eb > 255)
			eb = 255;
		      else if (eb < 0)
			eb = 0;
		      val = gdk_imlib_best_color_match(&er, &eg, &eb);
		      DITHER_ERROR(er1, er2, ex, er, eg, eb);
		      *img++ = val;
		    }
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      ex += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      er = r + er1[ex++];
		      eg = g + er1[ex++];
		      eb = b + er1[ex++];
		      if (er > 255)
			er = 255;
		      else if (er < 0)
			er = 0;
		      if (eg > 255)
			eg = 255;
		      else if (eg < 0)
			eg = 0;
		      if (eb > 255)
			eb = 255;
		      else if (eb < 0)
			eb = 0;
		      val = gdk_imlib_best_color_match(&er, &eg, &eb);
		      DITHER_ERROR(er1, er2, ex, er, eg, eb);
		      XPutPixel(xim, x, y, val);
		    }
		}
	    }
	}
      break;
    case RT_DITHER_PALETTE_FAST:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      {
			XPutPixel(sxim, x, y, 0);
			img++;
		      }
		      ex += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      er = r + er1[ex++];
		      eg = g + er1[ex++];
		      eb = b + er1[ex++];
		      if (er > 255)
			er = 255;
		      else if (er < 0)
			er = 0;
		      if (eg > 255)
			eg = 255;
		      else if (eg < 0)
			eg = 0;
		      if (eb > 255)
			eb = 255;
		      else if (eb < 0)
			eb = 0;
		      val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
		      er = ERROR_RED(er, val);
		      eg = ERROR_GRN(eg, val);
		      eb = ERROR_BLU(eb, val);
		      DITHER_ERROR(er1, er2, ex, er, eg, eb);
		      *img++ = COLOR_INDEX(val);
		    }
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      ex += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      er = r + er1[ex++];
		      eg = g + er1[ex++];
		      eb = b + er1[ex++];
		      if (er > 255)
			er = 255;
		      else if (er < 0)
			er = 0;
		      if (eg > 255)
			eg = 255;
		      else if (eg < 0)
			eg = 0;
		      if (eb > 255)
			eb = 255;
		      else if (eb < 0)
			eb = 0;
		      val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
		      er = ERROR_RED(er, val);
		      eg = ERROR_GRN(eg, val);
		      eb = ERROR_BLU(eb, val);
		      DITHER_ERROR(er1, er2, ex, er, eg, eb);
		      XPutPixel(xim, x, y, COLOR_INDEX(val));
		    }
		}
	    }
	}
      break;
    default:
      if (id->fastrend)
	{
	  switch (bpp)
	    {
	    case 8:
	      break;
            case 12:
              printf("iPAQ1\n");
              break;
            case 15:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_shaped_15_fast_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_shaped_15_fast_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_shaped_15_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 16:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_shaped_16_fast_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_shaped_16_fast_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_shaped_16_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 24:
	    case 32:
	      if (xim->bits_per_pixel == 24)
		grender_shaped_24_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      else
		grender_shaped_32_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    default:
	      break;
	    }
	}
      else
	{
	  switch (bpp)
	    {
	    case 8:
	      break;
            case 12:
              grender_shaped_12(im, w, h, xim, sxim, er1, er2, xarray, yarray);
              break;       
            case 15:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_shaped_15_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_shaped_15_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_shaped_15(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 16:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_shaped_16_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_shaped_16_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_shaped_16(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 24:
	      grender_shaped_24(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	    case 32:
	      grender_shaped_24(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    default:
	      break;
	    }
	}
      break;
    }
}

static void
grender(GdkImlibImage * im, int w, int h, XImage * xim,
	XImage * sxim, int *er1, int *er2, int *xarray,
	unsigned char **yarray, int bpp)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;
  unsigned char      *img;
  int                 jmp;

  jmp = (xim->bytes_per_line) - w * (bpp >> 3);
  img = (unsigned char *)xim->data;
  switch (id->render_type)
    {
    case RT_PLAIN_PALETTE:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  val = gdk_imlib_best_color_match(&r, &g, &b);
		  *img++ = val;
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  val = gdk_imlib_best_color_match(&r, &g, &b);
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
      break;
    case RT_PLAIN_PALETTE_FAST:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
		  *img++ = val;
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
      break;
    case RT_DITHER_PALETTE:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  er = r + er1[ex++];
		  eg = g + er1[ex++];
		  eb = b + er1[ex++];
		  if (er > 255)
		    er = 255;
		  else if (er < 0)
		    er = 0;
		  if (eg > 255)
		    eg = 255;
		  else if (eg < 0)
		    eg = 0;
		  if (eb > 255)
		    eb = 255;
		  else if (eb < 0)
		    eb = 0;
		  val = gdk_imlib_best_color_match(&er, &eg, &eb);
		  DITHER_ERROR(er1, er2, ex, er, eg, eb);
		  *img++ = val;
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  er = r + er1[ex++];
		  eg = g + er1[ex++];
		  eb = b + er1[ex++];
		  if (er > 255)
		    er = 255;
		  else if (er < 0)
		    er = 0;
		  if (eg > 255)
		    eg = 255;
		  else if (eg < 0)
		    eg = 0;
		  if (eb > 255)
		    eb = 255;
		  else if (eb < 0)
		    eb = 0;
		  val = gdk_imlib_best_color_match(&er, &eg, &eb);
		  DITHER_ERROR(er1, er2, ex, er, eg, eb);
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
      break;
    case RT_DITHER_PALETTE_FAST:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  er = r + er1[ex++];
		  eg = g + er1[ex++];
		  eb = b + er1[ex++];
		  if (er > 255)
		    er = 255;
		  else if (er < 0)
		    er = 0;
		  if (eg > 255)
		    eg = 255;
		  else if (eg < 0)
		    eg = 0;
		  if (eb > 255)
		    eb = 255;
		  else if (eb < 0)
		    eb = 0;
		  val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
		  er = ERROR_RED(er, val);
		  eg = ERROR_GRN(eg, val);
		  eb = ERROR_BLU(eb, val);
		  DITHER_ERROR(er1, er2, ex, er, eg, eb);
		  *img++ = COLOR_INDEX(val);
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  er = r + er1[ex++];
		  eg = g + er1[ex++];
		  eb = b + er1[ex++];
		  if (er > 255)
		    er = 255;
		  else if (er < 0)
		    er = 0;
		  if (eg > 255)
		    eg = 255;
		  else if (eg < 0)
		    eg = 0;
		  if (eb > 255)
		    eb = 255;
		  else if (eb < 0)
		    eb = 0;
		  val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
		  er = ERROR_RED(er, val);
		  eg = ERROR_GRN(eg, val);
		  eb = ERROR_BLU(eb, val);
		  DITHER_ERROR(er1, er2, ex, er, eg, eb);
		  XPutPixel(xim, x, y, COLOR_INDEX(val));
		}
	    }
	}
      break;
    default:
      if (id->fastrend)
	{
	  switch (bpp)
	    {
	    case 8:
	      break;
            case 12:
              printf("iPAQ3\n");
              break;
	    case 15:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_15_fast_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_15_fast_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_15_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 16:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_16_fast_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_16_fast_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_16_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 24:
	    case 32:
	      if (xim->bits_per_pixel == 24)
		grender_24_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      else
		grender_32_fast(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    default:
	      break;
	    }
	}
      else
	{
	  switch (bpp)
	    {
	    case 8:
	      break;
            case 12:
              grender_12(im, w, h, xim, sxim, er1, er2, xarray, yarray);
              break;
	    case 15:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_15_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_15_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_15(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 16:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_16_dither_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_16_dither(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_16(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 24:
	      grender_24(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 32:
	      grender_24(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    default:
	      break;
	    }
	  break;
	}
    }
}

static void
grender_shaped_15_fast_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim,
				  XImage * sxim, int *er1, int *er2, int *xarray,
				  unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;
  
  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      img++;
	      ex += 3;
	    }
	  else
	    {
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      XPutPixel(sxim, x, y, 1);
	      er = r + er1[ex++];
	      eg = g + er1[ex++];
	      eb = b + er1[ex++];
	      if (er > 255)
		er = 255;
	      if (eg > 255)
		eg = 255;
	      if (eb > 255)
		eb = 255;
	      val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
	      er = er & 0x07;
	      eg = eg & 0x07;
	      eb = eb & 0x07;
	      DITHER_ERROR(er1, er2, ex, er, eg, eb);
	      *img++ = val;
	    }
	}
      img += jmp;
    }
}

static void
grender_shaped_15_fast_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
					  XImage * sxim, int *er1, int *er2, int *xarray,
					  unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  unsigned char       dither[4][4] =
  {
    {0, 4, 6, 5},
    {6, 2, 7, 3},
    {2, 6, 1, 5},
    {7, 4, 7, 3}
  };
  int                 dithy, dithx;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      img++;
	    }
	  else
	    {
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      XPutPixel(sxim, x, y, 1);
	      er = r & 0x07;
	      eg = g & 0x07;
	      eb = b & 0x07;
	      dithx = x & 0x3;
	      if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
		r += 8;
	      if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
		g += 8;
	      if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
		b += 8;
	      val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	      *img++ = val;
	    }
	}
      img += jmp;
    }
}

static void
grender_15_fast_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim,
			   XImage * sxim, int *er1, int *er2, int *xarray,
			   unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er = 0, eg = 0, eb = 0;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  r = map->rmap[r];
	  g = map->gmap[g];
	  b = map->bmap[b];
	  er = r + er1[ex++];
	  eg = g + er1[ex++];
	  eb = b + er1[ex++];
	  if (er > 255)
	    er = 255;
	  if (eg > 255)
	    eg = 255;
	  if (eb > 255)
	    eb = 255;
	  val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
	  er = er & 0x07;
	  eg = eg & 0x07;
	  eb = eb & 0x07;
	  DITHER_ERROR(er1, er2, ex, er, eg, eb);
	  *img++ = val;
	}
      img += jmp;
    }
}

static void
grender_15_fast_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
				   XImage * sxim, int *er1, int *er2, int *xarray,
				   unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;

  unsigned short     *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  unsigned char       dither[4][4] =
  {
    {0, 4, 6, 5},
    {6, 2, 7, 3},
    {2, 6, 1, 5},
    {7, 4, 7, 3}
  };
  int                 dithy, dithx;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  r = map->rmap[r];
	  g = map->gmap[g];
	  b = map->bmap[b];
	  er = r & 0x07;
	  eg = g & 0x07;
	  eb = b & 0x07;
	  dithx = x & 0x3;
	  if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
	    r += 8;
	  if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
	    g += 8;
	  if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
	    b += 8;
	  val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	  *img++ = val;
	}
      img += jmp;
    }
}

static void
grender_shaped_16_fast_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim,
				  XImage * sxim, int *er1, int *er2, int *xarray,
				  unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;
  
  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      img++;
	      ex += 3;
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      er = r + er1[ex++];
	      eg = g + er1[ex++];
	      eb = b + er1[ex++];
	      if (er > 255)
		er = 255;
	      if (eg > 255)
		eg = 255;
	      if (eb > 255)
		eb = 255;
	      val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
	      er = er & 0x07;
	      eg = eg & 0x03;
	      eb = eb & 0x07;
	      DITHER_ERROR(er1, er2, ex, er, eg, eb);
	      *img++ = val;
	    }
	}
      img += jmp;
    }
}

static void
grender_shaped_16_fast_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			       XImage * sxim, int *er1, int *er2, int *xarray,
					  unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  unsigned char       dither[4][4] =
  {
    {0, 4, 6, 5},
    {6, 2, 7, 3},
    {2, 6, 1, 5},
    {7, 4, 7, 3}
  };
  int                 dithy, dithx;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      img++;
	    }
	  else
	    {
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      XPutPixel(sxim, x, y, 1);
	      er = r & 0x07;
	      eg = g & 0x03;
	      eb = b & 0x07;
	      dithx = x & 0x3;
	      if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
		r += 8;
	      if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
		g += 4;
	      if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
		b += 8;
	      val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	      *img++ = val;
	    }
	}
      img += jmp;
    }
}

static void
grender_16_fast_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim,
			   XImage * sxim, int *er1, int *er2, int *xarray,
			   unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;

  unsigned short     *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  r = map->rmap[r];
	  g = map->gmap[g];
	  b = map->bmap[b];
	  er = r + er1[ex++];
	  eg = g + er1[ex++];
	  eb = b + er1[ex++];
	  if (er > 255)
	    er = 255;
	  if (eg > 255)
	    eg = 255;
	  if (eb > 255)
	    eb = 255;
	  val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
	  er = er & 0x07;
	  eg = eg & 0x03;
	  eb = eb & 0x07;
	  DITHER_ERROR(er1, er2, ex, er, eg, eb);
	  *img++ = val;
	}
      img += jmp;
    }
}

static void
grender_16_fast_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			       XImage * sxim, int *er1, int *er2, int *xarray,
				   unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;

  unsigned short     *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  unsigned char       dither[4][4] =
  {
    {0, 4, 6, 5},
    {6, 2, 7, 3},
    {2, 6, 1, 5},
    {7, 4, 7, 3}
  };
  int                 dithy, dithx;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  r = map->rmap[r];
	  g = map->gmap[g];
	  b = map->bmap[b];
	  er = r & 0x07;
	  eg = g & 0x03;
	  eb = b & 0x07;
	  dithx = x & 0x3;
	  if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
	    r += 8;
	  if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
	    g += 4;
	  if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
	    b += 8;
	  val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	  *img++ = val;
	}
      img += jmp;
    }
}

static void
grender_shaped_15_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			       XImage * sxim, int *er1, int *er2, int *xarray,
				     unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  unsigned char       dither[4][4] =
  {
    {0, 4, 6, 5},
    {6, 2, 7, 3},
    {2, 6, 1, 5},
    {7, 4, 7, 3}
  };
  int                 dithy, dithx;

  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	    }
	  else
	    {
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      XPutPixel(sxim, x, y, 1);
	      er = r & 0x07;
	      eg = g & 0x07;
	      eb = b & 0x07;
	      dithx = x & 0x3;
	      if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
		r += 8;
	      if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
		g += 8;
	      if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
		b += 8;
	      val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_15_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			      XImage * sxim, int *er1, int *er2, int *xarray,
			      unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  unsigned char       dither[4][4] =
  {
    {0, 4, 6, 5},
    {6, 2, 7, 3},
    {2, 6, 1, 5},
    {7, 4, 7, 3}
  };
  int                 dithy, dithx;

  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  r = map->rmap[r];
	  g = map->gmap[g];
	  b = map->bmap[b];
	  er = r & 0x07;
	  eg = g & 0x07;
	  eb = b & 0x07;
	  dithx = x & 0x3;
	  if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
	    r += 8;
	  if ((dither[dithy][dithx] < eg) && (g < (256 - 8)))
	    g += 8;
	  if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
	    b += 8;
	  val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	  XPutPixel(xim, x, y, val);
	}
    }
}

static void
grender_shaped_16_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			       XImage * sxim, int *er1, int *er2, int *xarray,
				     unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  unsigned char       dither[4][4] =
  {
    {0, 4, 6, 5},
    {6, 2, 7, 3},
    {2, 6, 1, 5},
    {7, 4, 7, 3}
  };
  int                 dithy, dithx;

  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	    }
	  else
	    {
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      XPutPixel(sxim, x, y, 1);
	      er = r & 0x07;
	      eg = g & 0x03;
	      eb = b & 0x07;
	      dithx = x & 0x3;
	      if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
		r += 8;
	      if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
		g += 4;
	      if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
		b += 8;
	      val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_16_dither_mod_ordered(GdkImlibImage * im, int w, int h, XImage * xim,
			      XImage * sxim, int *er1, int *er2, int *xarray,
			      unsigned char **yarray)
{
  int                 x, y, val, r, g, b, er, eg, eb;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  unsigned char       dither[4][4] =
  {
    {0, 4, 6, 5},
    {6, 2, 7, 3},
    {2, 6, 1, 5},
    {7, 4, 7, 3}
  };
  int                 dithy, dithx;

  for (y = 0; y < h; y++)
    {
      dithy = y & 0x3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  r = map->rmap[r];
	  g = map->gmap[g];
	  b = map->bmap[b];
	  er = r & 0x07;
	  eg = g & 0x03;
	  eb = b & 0x07;
	  dithx = x & 0x3;
	  if ((dither[dithy][dithx] < er) && (r < (256 - 8)))
	    r += 8;
	  if ((dither[dithy][dithx] < (eg << 1)) && (g < (256 - 4)))
	    g += 4;
	  if ((dither[dithy][dithx] < eb) && (b < (256 - 8)))
	    b += 8;
	  val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	  XPutPixel(xim, x, y, val);
	}
    }
}

static void
grender_shaped_15_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim,
			     XImage * sxim, int *er1, int *er2, int *xarray,
			     unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      ex += 3;
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      er = r + er1[ex++];
	      eg = g + er1[ex++];
	      eb = b + er1[ex++];
	      if (er > 255)
		er = 255;
	      if (eg > 255)
		eg = 255;
	      if (eb > 255)
		eb = 255;
	      val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
	      er = er & 0x07;
	      eg = eg & 0x07;
	      eb = eb & 0x07;
	      if (er > 255)
		er = 255;
	      else if (er < 0)
		er = 0;
	      if (eg > 255)
		eg = 255;
	      else if (eg < 0)
		eg = 0;
	      if (eb > 255)
		eb = 255;
	      else if (eb < 0)
		eb = 0;
	      val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	      er = r & 0x07;
	      eg = g & 0x07;
	      eb = b & 0x07;
	      DITHER_ERROR(er1, er2, ex, er, eg, eb);
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_15_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim,
		      XImage * sxim, int *er1, int *er2, int *xarray,
		      unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  r = map->rmap[r];
	  g = map->gmap[g];
	  b = map->bmap[b];
	  er = r + er1[ex++];
	  eg = g + er1[ex++];
	  eb = b + er1[ex++];
	  if (er > 255)
	    er = 255;
	  if (eg > 255)
	    eg = 255;
	  if (eb > 255)
	    eb = 255;
	  val = ((er & 0xf8) << 7) | ((eg & 0xf8) << 2) | ((eb & 0xf8) >> 3);
	  er = er & 0x07;
	  eg = eg & 0x07;
	  eb = eb & 0x07;
	  DITHER_ERROR(er1, er2, ex, er, eg, eb);
	  XPutPixel(xim, x, y, val);
	}
    }
}

static void
grender_shaped_16_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim,
			     XImage * sxim, int *er1, int *er2, int *xarray,
			     unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      ex += 3;
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      er = r + er1[ex++];
	      eg = g + er1[ex++];
	      eb = b + er1[ex++];
	      if (er > 255)
		er = 255;
	      if (eg > 255)
		eg = 255;
	      if (eb > 255)
		eb = 255;
	      val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
	      er = er & 0x07;
	      eg = eg & 0x03;
	      eb = eb & 0x07;
	      DITHER_ERROR(er1, er2, ex, er, eg, eb);
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_16_dither_mod(GdkImlibImage * im, int w, int h, XImage * xim,
		      XImage * sxim, int *er1, int *er2, int *xarray,
		      unsigned char **yarray)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  for (y = 0; y < h; y++)
    {
      ter = er1;
      er1 = er2;
      er2 = ter;
      for (ex = 0; ex < (w + 2) * 3; ex++)
	er2[ex] = 0;
      ex = 3;
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  r = map->rmap[r];
	  g = map->gmap[g];
	  b = map->bmap[b];
	  er = r + er1[ex++];
	  eg = g + er1[ex++];
	  eb = b + er1[ex++];
	  if (er > 255)
	    er = 255;
	  if (eg > 255)
	    eg = 255;
	  if (eb > 255)
	    eb = 255;
	  val = ((er & 0xf8) << 8) | ((eg & 0xfc) << 3) | ((eb & 0xf8) >> 3);
	  er = er & 0x07;
	  eg = eg & 0x03;
	  eb = eb & 0x07;
	  DITHER_ERROR(er1, er2, ex, er, eg, eb);
	  XPutPixel(xim, x, y, val);
	}
    }
}

static void
grender_shaped_15_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim,
			   XImage * sxim, int *er1, int *er2, int *xarray,
			   unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      img++;
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	      *img++ = val;
	    }
	}
      img += jmp;
    }
}

static void
grender_15_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim,
		    XImage * sxim, int *er1, int *er2, int *xarray,
		    unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  r = map->rmap[r];
	  g = map->gmap[g];
	  b = map->bmap[b];
	  val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	  *img++ = val;
	}
      img += jmp;
    }
}

static void
grender_shaped_16_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim,
			   XImage * sxim, int *er1, int *er2, int *xarray,
			   unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  unsigned short     *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    {
	      XPutPixel(sxim, x, y, 0);
	      img++;
	    }
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	      *img++ = val;
	    }
	}
      img += jmp;
    }
}

static void
grender_16_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim,
		    XImage * sxim, int *er1, int *er2, int *xarray,
		    unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;
  unsigned short     *img;
  int                 jmp;

  jmp = (xim->bytes_per_line >> 1) - w;
  img = (unsigned short *)xim->data;
  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  r = map->rmap[r];
	  g = map->gmap[g];
	  b = map->bmap[b];
	  val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	  *img++ = val;
	}
      img += jmp;
    }
}

static void
grender_shaped_24_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim,
			   XImage * sxim, int *er1, int *er2, int *xarray,
			   unsigned char **yarray)
{
  int                 x, y, r, g, b;
  unsigned char      *ptr2;
  unsigned char      *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  jmp = (xim->bytes_per_line) - w * 3;
  img = (unsigned char *)xim->data;
  if (id->x.byte_order == MSBFirst)
    {
      if (id->byte_order == BYTE_ORD_24_RGB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      *img++ = r;
		      *img++ = g;
		      *img++ = b;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_RBG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      *img++ = r;
		      *img++ = b;
		      *img++ = g;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BRG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      *img++ = b;
		      *img++ = r;
		      *img++ = g;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BGR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      *img++ = b;
		      *img++ = g;
		      *img++ = r;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GRB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = g;
		      *img++ = r;
		      *img++ = b;
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GBR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = g;
		      *img++ = b;
		      *img++ = r;
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		    }
		}
	      img += jmp;
	    }
	}
    }
  else
    {
      if (id->byte_order == BYTE_ORD_24_RGB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      *img++ = b;
		      *img++ = g;
		      *img++ = r;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_RBG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      *img++ = g;
		      *img++ = b;
		      *img++ = r;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BRG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      *img++ = g;
		      *img++ = r;
		      *img++ = b;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BGR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      *img++ = r;
		      *img++ = g;
		      *img++ = b;
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GRB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = b;
		      *img++ = r;
		      *img++ = g;
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		    }
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GBR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      *img++ = r;
		      *img++ = b;
		      *img++ = g;
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		    }
		}
	      img += jmp;
	    }
	}
    }
}

static void
grender_24_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim,
		    XImage * sxim, int *er1, int *er2, int *xarray,
		    unsigned char **yarray)
{
  int                 x, y, r, g, b;
  unsigned char      *ptr2;
  unsigned char      *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  jmp = (xim->bytes_per_line) - w * 3;
  img = (unsigned char *)xim->data;

  if (id->x.byte_order == MSBFirst)
    {
      if (id->byte_order == BYTE_ORD_24_RGB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  *img++ = r;
		  *img++ = g;
		  *img++ = b;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_RBG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  *img++ = r;
		  *img++ = b;
		  *img++ = g;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BRG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  *img++ = b;
		  *img++ = r;
		  *img++ = g;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BGR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  *img++ = b;
		  *img++ = g;
		  *img++ = r;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GRB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  *img++ = g;
		  *img++ = r;
		  *img++ = b;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GBR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  *img++ = g;
		  *img++ = b;
		  *img++ = r;
		}
	      img += jmp;
	    }
	}
    }
  else
    {
      if (id->byte_order == BYTE_ORD_24_RGB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  *img++ = b;
		  *img++ = g;
		  *img++ = r;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_RBG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  *img++ = g;
		  *img++ = b;
		  *img++ = r;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BRG)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  *img++ = g;
		  *img++ = r;
		  *img++ = b;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_BGR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  *img++ = r;
		  *img++ = g;
		  *img++ = b;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GRB)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  *img++ = b;
		  *img++ = r;
		  *img++ = g;
		}
	      img += jmp;
	    }
	}
      else if (id->byte_order == BYTE_ORD_24_GBR)
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  *img++ = r;
		  *img++ = b;
		  *img++ = g;
		}
	      img += jmp;
	    }
	}
    }
}

static void
grender_shaped_32_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim,
			   XImage * sxim, int *er1, int *er2, int *xarray,
			   unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  unsigned int       *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  jmp = (xim->bytes_per_line >> 2) - w;
  img = (unsigned int *)xim->data;
  if (id->byte_order == BYTE_ORD_24_RGB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		{
		  XPutPixel(sxim, x, y, 0);
		  img++;
		}
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = (r << 16) | (g << 8) | b;
		  *img++ = val;
		}
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_RBG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		{
		  XPutPixel(sxim, x, y, 0);
		  img++;
		}
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = (r << 16) | (b << 8) | g;
		  *img++ = val;
		}
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BRG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		{
		  XPutPixel(sxim, x, y, 0);
		  img++;
		}
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = (b << 16) | (r << 8) | g;
		  *img++ = val;
		}
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BGR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		{
		  XPutPixel(sxim, x, y, 0);
		  img++;
		}
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = (b << 16) | (g << 8) | r;
		  *img++ = val;
		}
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GRB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		{
		  XPutPixel(sxim, x, y, 0);
		  img++;
		}
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = (g << 16) | (r << 8) | b;
		  *img++ = val;
		}
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GBR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		{
		  XPutPixel(sxim, x, y, 0);
		  img++;
		}
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = (g << 16) | (b << 8) | r;
		  *img++ = val;
		}
	    }
	  img += jmp;
	}
    }
}

static void
grender_32_fast_mod(GdkImlibImage * im, int w, int h, XImage * xim,
		    XImage * sxim, int *er1, int *er2, int *xarray,
		    unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  unsigned int       *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  jmp = (xim->bytes_per_line >> 2) - w;
  img = (unsigned int *)xim->data;
  if (id->byte_order == BYTE_ORD_24_RGB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = (r << 16) | (g << 8) | b;
	      *img++ = val;
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_RBG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = (r << 16) | (b << 8) | g;
	      *img++ = val;
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BRG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = (b << 16) | (r << 8) | g;
	      *img++ = val;
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BGR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = (b << 16) | (g << 8) | r;
	      *img++ = val;
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GRB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = (g << 16) | (r << 8) | b;
	      *img++ = val;
	    }
	  img += jmp;
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GBR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = (g << 16) | (b << 8) | r;
	      *img++ = val;
	    }
	  img += jmp;
	}
    }
}

static void
grender_shaped_15_mod(GdkImlibImage * im, int w, int h, XImage * xim,
		      XImage * sxim, int *er1, int *er2, int *xarray,
		      unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    XPutPixel(sxim, x, y, 0);
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_15_mod(GdkImlibImage * im, int w, int h, XImage * xim,
	       XImage * sxim, int *er1, int *er2, int *xarray,
	       unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  r = map->rmap[r];
	  g = map->gmap[g];
	  b = map->bmap[b];
	  val = ((r & 0xf8) << 7) | ((g & 0xf8) << 2) | ((b & 0xf8) >> 3);
	  XPutPixel(xim, x, y, val);
	}
    }
}

static void
grender_shaped_16_mod(GdkImlibImage * im, int w, int h, XImage * xim,
		      XImage * sxim, int *er1, int *er2, int *xarray,
		      unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  if ((r == im->shape_color.r) &&
	      (g == im->shape_color.g) &&
	      (b == im->shape_color.b))
	    XPutPixel(sxim, x, y, 0);
	  else
	    {
	      XPutPixel(sxim, x, y, 1);
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_16_mod(GdkImlibImage * im, int w, int h, XImage * xim,
	       XImage * sxim, int *er1, int *er2, int *xarray,
	       unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
	{
	  ptr2 = yarray[y] + xarray[x];
	  r = (int)*ptr2++;
	  g = (int)*ptr2++;
	  b = (int)*ptr2;
	  r = map->rmap[r];
	  g = map->gmap[g];
	  b = map->bmap[b];
	  val = ((r & 0xf8) << 8) | ((g & 0xfc) << 3) | ((b & 0xf8) >> 3);
	  XPutPixel(xim, x, y, val);
	}
    }
}

static void
grender_12_mod(GdkImlibImage * im, int w, int h, XImage * xim,
               XImage * sxim, int *er1, int *er2, int *xarray,
               unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  for (y = 0; y < h; y++)
    {
      for (x = 0; x < w; x++)
        {
          ptr2 = yarray[y] + xarray[x];
          r = (int)*ptr2++;
          g = (int)*ptr2++;
          b = (int)*ptr2;
          r = map->rmap[r];
          g = map->gmap[g];
          b = map->bmap[b];
          val = ((r & 0xf0) << 8) | ((g & 0xf0) << 3) | ((b & 0xf0) >> 3);
          XPutPixel(xim, x, y, val);
        }
    }
}

static void
grender_shaped_24_mod(GdkImlibImage * im, int w, int h, XImage * xim,
		      XImage * sxim, int *er1, int *er2, int *xarray,
		      unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  if (id->byte_order == BYTE_ORD_24_RGB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		XPutPixel(sxim, x, y, 0);
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = (r << 16) | (g << 8) | b;
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_RBG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		XPutPixel(sxim, x, y, 0);
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = (r << 16) | (b << 8) | g;
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BRG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		XPutPixel(sxim, x, y, 0);
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = (b << 16) | (r << 8) | g;
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BGR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		XPutPixel(sxim, x, y, 0);
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = (b << 16) | (g << 8) | r;
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GRB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		XPutPixel(sxim, x, y, 0);
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = (g << 16) | (r << 8) | b;
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GBR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      if ((r == im->shape_color.r) &&
		  (g == im->shape_color.g) &&
		  (b == im->shape_color.b))
		XPutPixel(sxim, x, y, 0);
	      else
		{
		  XPutPixel(sxim, x, y, 1);
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = (g << 16) | (b << 8) | r;
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
    }
}

static void
grender_24_mod(GdkImlibImage * im, int w, int h, XImage * xim,
	       XImage * sxim, int *er1, int *er2, int *xarray,
	       unsigned char **yarray)
{
  int                 x, y, val, r, g, b;
  unsigned char      *ptr2;
  GdkImlibModifierMap *map = im->map;

  if (id->byte_order == BYTE_ORD_24_RGB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = (r << 16) | (g << 8) | b;
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_RBG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = (r << 16) | (b << 8) | g;
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BRG)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = (b << 16) | (r << 8) | g;
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_BGR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = (b << 16) | (g << 8) | r;
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GRB)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = (g << 16) | (r << 8) | b;
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
  else if (id->byte_order == BYTE_ORD_24_GBR)
    {
      for (y = 0; y < h; y++)
	{
	  for (x = 0; x < w; x++)
	    {
	      ptr2 = yarray[y] + xarray[x];
	      r = (int)*ptr2++;
	      g = (int)*ptr2++;
	      b = (int)*ptr2;
	      r = map->rmap[r];
	      g = map->gmap[g];
	      b = map->bmap[b];
	      val = (g << 16) | (b << 8) | r;
	      XPutPixel(xim, x, y, val);
	    }
	}
    }
}

static void
grender_shaped_mod(GdkImlibImage * im, int w, int h, XImage * xim,
		   XImage * sxim, int *er1, int *er2, int *xarray,
		   unsigned char **yarray, int bpp)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;
  unsigned char      *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  jmp = (xim->bytes_per_line) - w * (bpp >> 3);
  img = (unsigned char *)xim->data;
  switch (id->render_type)
    {
    case RT_PLAIN_PALETTE:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img++;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      val = gdk_imlib_best_color_match(&r, &g, &b);
		      *img++ = val;
		    }
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    XPutPixel(sxim, x, y, 0);
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      val = gdk_imlib_best_color_match(&r, &g, &b);
		      XPutPixel(xim, x, y, val);
		    }
		}
	    }
	}
      break;
    case RT_PLAIN_PALETTE_FAST:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      img++;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
		      *img++ = val;
		    }
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    XPutPixel(sxim, x, y, 0);
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
		      XPutPixel(xim, x, y, val);
		    }
		}
	    }
	}
      break;
    case RT_DITHER_PALETTE:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      {
			XPutPixel(sxim, x, y, 0);
			img++;
		      }
		      ex += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      er = r + er1[ex++];
		      eg = g + er1[ex++];
		      eb = b + er1[ex++];
		      if (er > 255)
			er = 255;
		      else if (er < 0)
			er = 0;
		      if (eg > 255)
			eg = 255;
		      else if (eg < 0)
			eg = 0;
		      if (eb > 255)
			eb = 255;
		      else if (eb < 0)
			eb = 0;
		      val = gdk_imlib_best_color_match(&er, &eg, &eb);
		      DITHER_ERROR(er1, er2, ex, er, eg, eb);
		      *img++ = val;
		    }
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      ex += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      er = r + er1[ex++];
		      eg = g + er1[ex++];
		      eb = b + er1[ex++];
		      if (er > 255)
			er = 255;
		      else if (er < 0)
			er = 0;
		      if (eg > 255)
			eg = 255;
		      else if (eg < 0)
			eg = 0;
		      if (eb > 255)
			eb = 255;
		      else if (eb < 0)
			eb = 0;
		      val = gdk_imlib_best_color_match(&er, &eg, &eb);
		      DITHER_ERROR(er1, er2, ex, er, eg, eb);
		      XPutPixel(xim, x, y, val);
		    }
		}
	    }
	}
      break;
    case RT_DITHER_PALETTE_FAST:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      {
			XPutPixel(sxim, x, y, 0);
			img++;
		      }
		      ex += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      er = r + er1[ex++];
		      eg = g + er1[ex++];
		      eb = b + er1[ex++];
		      if (er > 255)
			er = 255;
		      else if (er < 0)
			er = 0;
		      if (eg > 255)
			eg = 255;
		      else if (eg < 0)
			eg = 0;
		      if (eb > 255)
			eb = 255;
		      else if (eb < 0)
			eb = 0;
		      val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
		      er = ERROR_RED(er, val);
		      eg = ERROR_GRN(eg, val);
		      eb = ERROR_BLU(eb, val);
		      DITHER_ERROR(er1, er2, ex, er, eg, eb);
		      *img++ = COLOR_INDEX(val);
		    }
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  if ((r == im->shape_color.r) &&
		      (g == im->shape_color.g) &&
		      (b == im->shape_color.b))
		    {
		      XPutPixel(sxim, x, y, 0);
		      ex += 3;
		    }
		  else
		    {
		      XPutPixel(sxim, x, y, 1);
		      r = map->rmap[r];
		      g = map->gmap[g];
		      b = map->bmap[b];
		      er = r + er1[ex++];
		      eg = g + er1[ex++];
		      eb = b + er1[ex++];
		      if (er > 255)
			er = 255;
		      else if (er < 0)
			er = 0;
		      if (eg > 255)
			eg = 255;
		      else if (eg < 0)
			eg = 0;
		      if (eb > 255)
			eb = 255;
		      else if (eb < 0)
			eb = 0;
		      val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
		      er = ERROR_RED(er, val);
		      eg = ERROR_GRN(eg, val);
		      eb = ERROR_BLU(eb, val);
		      DITHER_ERROR(er1, er2, ex, er, eg, eb);
		      XPutPixel(xim, x, y, COLOR_INDEX(val));
		    }
		}
	    }
	}
      break;
    default:
      if (id->fastrend)
	{
	  switch (bpp)
	    {
	    case 8:
	      break;
            case 12:
              printf("iPAQ5\n");
              break;
	    case 15:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_shaped_15_fast_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_shaped_15_fast_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_shaped_15_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 16:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_shaped_16_fast_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_shaped_16_fast_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_shaped_16_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 24:
	    case 32:
	      if (xim->bits_per_pixel == 24)
		grender_shaped_24_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      else
		grender_shaped_32_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    default:
	      break;
	    }
	}
      else
	{
	  switch (bpp)
	    {
	    case 8:
	      break;
            case 12:
              printf("iPAQ6\n");
              break;
	    case 15:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_shaped_15_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  grender_shaped_15_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_shaped_15_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 16:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_shaped_16_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_shaped_16_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_shaped_16_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 24:
	      grender_shaped_24_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	    case 32:
	      grender_shaped_24_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    default:
	      break;
	    }
	}
      break;
    }
}

static void
grender_mod(GdkImlibImage * im, int w, int h, XImage * xim,
	    XImage * sxim, int *er1, int *er2, int *xarray,
	    unsigned char **yarray, int bpp)
{
  int                 x, y, val, r, g, b, *ter, ex, er, eg, eb;
  unsigned char      *ptr2;
  unsigned char      *img;
  int                 jmp;
  GdkImlibModifierMap *map = im->map;

  jmp = (xim->bytes_per_line) - w * (bpp >> 3);
  img = (unsigned char *)xim->data;
  switch (id->render_type)
    {
    case RT_PLAIN_PALETTE:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = gdk_imlib_best_color_match(&r, &g, &b);
		  *img++ = val;
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = gdk_imlib_best_color_match(&r, &g, &b);
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
      break;
    case RT_PLAIN_PALETTE_FAST:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
		  *img++ = val;
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  val = COLOR_RGB(r >> 3, g >> 3, b >> 3);
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
      break;
    case RT_DITHER_PALETTE:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  er = r + er1[ex++];
		  eg = g + er1[ex++];
		  eb = b + er1[ex++];
		  if (er > 255)
		    er = 255;
		  else if (er < 0)
		    er = 0;
		  if (eg > 255)
		    eg = 255;
		  else if (eg < 0)
		    eg = 0;
		  if (eb > 255)
		    eb = 255;
		  else if (eb < 0)
		    eb = 0;
		  val = gdk_imlib_best_color_match(&er, &eg, &eb);
		  DITHER_ERROR(er1, er2, ex, er, eg, eb);
		  *img++ = val;
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  er = r + er1[ex++];
		  eg = g + er1[ex++];
		  eb = b + er1[ex++];
		  if (er > 255)
		    er = 255;
		  else if (er < 0)
		    er = 0;
		  if (eg > 255)
		    eg = 255;
		  else if (eg < 0)
		    eg = 0;
		  if (eb > 255)
		    eb = 255;
		  else if (eb < 0)
		    eb = 0;
		  val = gdk_imlib_best_color_match(&er, &eg, &eb);
		  DITHER_ERROR(er1, er2, ex, er, eg, eb);
		  XPutPixel(xim, x, y, val);
		}
	    }
	}
      break;
    case RT_DITHER_PALETTE_FAST:
      if ((id->fastrend) && (xim->bits_per_pixel == 8))
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  er = r + er1[ex++];
		  eg = g + er1[ex++];
		  eb = b + er1[ex++];
		  if (er > 255)
		    er = 255;
		  else if (er < 0)
		    er = 0;
		  if (eg > 255)
		    eg = 255;
		  else if (eg < 0)
		    eg = 0;
		  if (eb > 255)
		    eb = 255;
		  else if (eb < 0)
		    eb = 0;
		  val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
		  er = ERROR_RED(er, val);
		  eg = ERROR_GRN(eg, val);
		  eb = ERROR_BLU(eb, val);
		  DITHER_ERROR(er1, er2, ex, er, eg, eb);
		  *img++ = COLOR_INDEX(val);
		}
	      img += jmp;
	    }
	}
      else
	{
	  for (y = 0; y < h; y++)
	    {
	      ter = er1;
	      er1 = er2;
	      er2 = ter;
	      for (ex = 0; ex < (w + 2) * 3; ex++)
		er2[ex] = 0;
	      ex = 3;
	      for (x = 0; x < w; x++)
		{
		  ptr2 = yarray[y] + xarray[x];
		  r = (int)*ptr2++;
		  g = (int)*ptr2++;
		  b = (int)*ptr2;
		  r = map->rmap[r];
		  g = map->gmap[g];
		  b = map->bmap[b];
		  er = r + er1[ex++];
		  eg = g + er1[ex++];
		  eb = b + er1[ex++];
		  if (er > 255)
		    er = 255;
		  else if (er < 0)
		    er = 0;
		  if (eg > 255)
		    eg = 255;
		  else if (eg < 0)
		    eg = 0;
		  if (eb > 255)
		    eb = 255;
		  else if (eb < 0)
		    eb = 0;
		  val = INDEX_RGB(er >> 3, eg >> 3, eb >> 3);
		  er = ERROR_RED(er, val);
		  eg = ERROR_GRN(eg, val);
		  eb = ERROR_BLU(eb, val);
		  DITHER_ERROR(er1, er2, ex, er, eg, eb);
		  XPutPixel(xim, x, y, COLOR_INDEX(val));
		}
	    }
	}
      break;
    default:
      if (id->fastrend)
	{
	  switch (bpp)
	    {
	    case 8:
	      break;
            case 12:
              printf("iPAQ7\n");
              break;
	    case 15:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_15_fast_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_15_fast_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_15_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 16:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_16_fast_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_16_fast_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_16_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 24:
	    case 32:
	      if (xim->bits_per_pixel == 24)
		grender_24_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      else
		grender_32_fast_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    default:
	      break;
	    }
	}
      else
	{
	  switch (bpp)
	    {
	    case 8:
	      break;
            case 12:
              grender_12_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
              break;
	    case 15:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_15_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_15_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_15_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 16:
	      if (id->render_type == RT_DITHER_TRUECOL)
		{
		  if (id->ordered_dither)
		    grender_16_dither_mod_ordered(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		  else
		    grender_16_dither_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
		}
	      else
		grender_16_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 24:
	      grender_24_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    case 32:
	      grender_24_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray);
	      break;
	    default:
	      break;
	    }
	  break;
	}
    }
}

gint
gdk_imlib_render(GdkImlibImage * im, gint w, gint h)
{
  XImage             *xim, *sxim;
  GC                  tgc, stgc;
  XGCValues           gcv;
  unsigned char      *tmp, *stmp, **yarray, *ptr22;
  int                 w3, x, inc, pos, *error, *er1, *er2, *xarray, ex, bpp,
                      huge;
  Pixmap              pmap, mask;
  GdkPixmap          *pm, *mm;
  int                 shared_pixmap, shared_image, ok;

  sxim = NULL;
  xim = NULL;
  tmp = NULL;
  stmp = NULL;
  pmap = 0;
  mask = 0;
  tgc = 0;
  stgc = 0;
  inc = 0;
  if (!im)
    return 0;
  if (w <= 0)
    return 0;
  if (h <= 0)
    return 0;
  gcv.graphics_exposures = False;

/* look for the pixmap in cache first */
  if (id->cache.on_pixmap)
    {
      pmap = 0;
      _gdk_imlib_find_pixmap(im, w, h, &pm, &mm);
      if (pm)
	{
	  im->width = w;
	  im->height = h;
	  im->pixmap = pm;
	  if (mm)
	    im->shape_mask = mm;
	  else
	    im->shape_mask = NULL;
	  return 1;
	}
    }
  if (im->pixmap)
    _gdk_imlib_free_pixmappmap(im->pixmap);
  im->pixmap = NULL;
  im->shape_mask = NULL;
/* setup stuff */
  huge = 0;
  if (id->x.depth <= 8)
    bpp = 1;
  else if (id->x.depth <= 16)
    bpp = 2;
  else if (id->x.depth <= 24)
    bpp = 3;
  else
    bpp = 4;
  if ((id->max_shm) && ((bpp * w * h) > id->max_shm))
    huge = 1;
  im->width = w;
  im->height = h;

/* dithering array */
  error = (int *)malloc(sizeof(int) * (w + 2) * 2 * 3);

  if (!error)
    {
      fprintf(stderr, "ERROR: Cannot allocate RAM for image dither buffer\n");
      return 0;
    }
/* setup pointers to point right */
  er1 = error;
  er2 = error + ((w + 2) * 3);
  w3 = im->rgb_width * 3;
  ptr22 = im->rgb_data;

/* setup coord-mapping array (specially for border scaling) */
  xarray = malloc(sizeof(int) * w);

  if (!xarray)
    {
      fprintf(stderr, "ERROR: Cannot allocate X co-ord buffer\n");
      free(error);
      return 0;
    }
  yarray = malloc(sizeof(unsigned char *) * h);

  if (!yarray)
    {
      fprintf(stderr, "ERROR: Cannot allocate Y co-ord buffer\n");
      free(xarray);
      free(error);
      return 0;
    }
  for (ex = 0; ex < ((w + 2) * 3 * 2); ex++)
    error[ex] = 0;
  {
    int                 l, r, m;

    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;
      }
  }

/* work out if we should use shared pixmap. images etc */
  shared_pixmap = 0;
  shared_image = 0;
  if ((id->x.shmp) && (id->x.shm) && (!huge))
    {
      shared_pixmap = 1;
      shared_image = 0;
    }
  else if ((id->x.shm) && (!huge))
    {
      shared_pixmap = 0;
      shared_image = 1;
    }
  else
    {
      shared_pixmap = 0;
      shared_image = 0;
    }

/* init images and pixmaps */
  ok = 1;
#ifdef HAVE_SHM
  if (shared_pixmap)
    {
      xim = XShmCreateImage(id->x.disp, id->x.visual, id->x.depth, ZPixmap, NULL, &id->x.last_shminfo, w, h);
      if (!xim)
	{
	  fprintf(stderr, "IMLIB ERROR: Mit-SHM can't create XImage for Shared Pixmap Wrapper\n");
	  fprintf(stderr, "             Falling back on Shared XImages\n");
	  shared_pixmap = 0;
	  shared_image = 1;
	  ok = 0;
	}
      if (ok)
	{
	  id->x.last_shminfo.shmid = shmget(IPC_PRIVATE, xim->bytes_per_line * xim->height, IPC_CREAT | 0777);
	  if (id->x.last_shminfo.shmid == -1)
	    {
	      fprintf(stderr, "IMLIB ERROR: SHM can't get SHM Identifier for Shared Pixmap Wrapper\n");
	      fprintf(stderr, "             Falling back on Shared XImages\n");
	      XDestroyImage(xim);
	      shared_pixmap = 0;
	      shared_image = 1;
	      ok = 0;
	    }
	  if (ok)
	    {
	      id->x.last_shminfo.shmaddr = xim->data = shmat(id->x.last_shminfo.shmid, 0, 0);
	      if (xim->data == (char *)-1)
		{
		  fprintf(stderr, "IMLIB ERROR: SHM can't attach SHM Segment for Shared Pixmap Wrapper\n");
		  fprintf(stderr, "             Falling back on Shared XImages\n");
		  XDestroyImage(xim);
		  shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
		  shared_pixmap = 0;
		  shared_image = 1;
		  ok = 0;
		}
	      if (ok)
		{
		  id->x.last_shminfo.readOnly = False;
		  XShmAttach(id->x.disp, &id->x.last_shminfo);
		  tmp = (unsigned char *)xim->data;
		  id->x.last_xim = xim;
		  pmap = XShmCreatePixmap(id->x.disp, id->x.base_window,
					  id->x.last_shminfo.shmaddr,
				      &id->x.last_shminfo, w, h, id->x.depth);
		  tgc = XCreateGC(id->x.disp, pmap, GCGraphicsExposures, &gcv);
		  if ((im->shape_color.r >= 0) && (im->shape_color.g >= 0) && (im->shape_color.b >= 0))
		    {
		      sxim = XShmCreateImage(id->x.disp, id->x.visual, 1, ZPixmap, NULL, &id->x.last_sshminfo, w, h);
		      if (!sxim)
			{
			  fprintf(stderr, "IMLIB ERROR: Mit-SHM can't create XImage for Shared Pixmap mask Wrapper\n");
			  fprintf(stderr, "             Falling back on Shared XImages\n");
			  XShmDetach(id->x.disp, &id->x.last_shminfo);
			  XDestroyImage(xim);
			  shmdt(id->x.last_shminfo.shmaddr);
			  shared_pixmap = 0;
			  shared_image = 1;
			  ok = 0;
			}
		      if (ok)
			{
			  id->x.last_sshminfo.shmid = shmget(IPC_PRIVATE, sxim->bytes_per_line * sxim->height, IPC_CREAT | 0777);
			  if (id->x.last_sshminfo.shmid == -1)
			    {
			      fprintf(stderr, "IMLIB ERROR: SHM can't get SHM Identifier for Shared Pixmap mask Wrapper\n");
			      fprintf(stderr, "             Falling back on Shared XImages\n");
			      XShmDetach(id->x.disp, &id->x.last_shminfo);
			      XDestroyImage(xim);
			      shmdt(xim->data);
			      /* missing shmctl(RMID) */
			      XDestroyImage(sxim);
			      shared_pixmap = 0;
			      shared_image = 1;
			      ok = 0;
			    }
			  if (ok)
			    {
			      id->x.last_sshminfo.shmaddr = sxim->data = shmat(id->x.last_sshminfo.shmid, 0, 0);
			      if (sxim->data == (char *)-1)
				{
				  fprintf(stderr, "IMLIB ERROR: SHM can't attach SHM Segment for Shared Pixmap mask Wrapper\n");
				  fprintf(stderr, "             Falling back on Shared XImages\n");
				  XShmDetach(id->x.disp, &id->x.last_shminfo);
				  XDestroyImage(xim);
				  shmdt(xim->data);
				  /* missing shmctl(RMID) */
				  XDestroyImage(sxim);
				  shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
				  shared_pixmap = 0;
				  shared_image = 1;
				  ok = 0;
				}
			      if (ok)
				{
				  id->x.last_sshminfo.readOnly = False;
				  XShmAttach(id->x.disp, &id->x.last_sshminfo);
				  stmp = (unsigned char *)sxim->data;
				  id->x.last_sxim = sxim;
				  mask = XShmCreatePixmap(id->x.disp, id->x.base_window,
						  id->x.last_sshminfo.shmaddr,
					       &id->x.last_sshminfo, w, h, 1);
				  stgc = XCreateGC(id->x.disp, mask, GCGraphicsExposures, &gcv);
				}
			    }
			}
		    }
		}
	    }
	}
    }
  ok = 1;
  if (shared_image)
    {
      xim = XShmCreateImage(id->x.disp, id->x.visual, id->x.depth, ZPixmap, NULL, &id->x.last_shminfo, w, h);
      if (!xim)
	{
	  fprintf(stderr, "IMLIB ERROR: Mit-SHM can't create Shared XImage\n");
	  fprintf(stderr, "             Falling back on XImages\n");
	  shared_pixmap = 0;
	  shared_image = 0;
	  ok = 0;
	}
      if (ok)
	{
	  id->x.last_shminfo.shmid = shmget(IPC_PRIVATE, xim->bytes_per_line * xim->height, IPC_CREAT | 0777);
	  if (id->x.last_shminfo.shmid == -1)
	    {
	      fprintf(stderr, "IMLIB ERROR: SHM can't get SHM Identifier for Shared XImage\n");
	      fprintf(stderr, "             Falling back on XImages\n");
	      XDestroyImage(xim);
	      shared_pixmap = 0;
	      shared_image = 0;
	      ok = 0;
	    }
	  if (ok)
	    {
	      id->x.last_shminfo.shmaddr = xim->data = shmat(id->x.last_shminfo.shmid, 0, 0);

	      if (xim->data == (char *)-1)
		{
		  fprintf(stderr, "IMLIB ERROR: SHM can't attach SHM Segment for Shared XImage\n");
		  fprintf(stderr, "             Falling back on XImages\n");
		  XDestroyImage(xim);
		  shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
		  shared_pixmap = 0;
		  shared_image = 0;
		  ok = 0;
		}
	      if (ok)
		{
		  id->x.last_shminfo.readOnly = False;
		  XShmAttach(id->x.disp, &id->x.last_shminfo);
		  tmp = (unsigned char *)xim->data;
		  id->x.last_xim = xim;
		  pmap = XCreatePixmap(id->x.disp, id->x.base_window, w, h, id->x.depth);
		  tgc = XCreateGC(id->x.disp, pmap, GCGraphicsExposures, &gcv);
		  if ((im->shape_color.r >= 0) && (im->shape_color.g >= 0) && (im->shape_color.b >= 0))
		    {
		      sxim = XShmCreateImage(id->x.disp, id->x.visual, 1, ZPixmap, NULL, &id->x.last_sshminfo, w, h);
		      if (!sxim)
			{
			  fprintf(stderr, "IMLIB ERROR: Mit-SHM can't create Shared XImage mask\n");
			  fprintf(stderr, "             Falling back on XImages\n");
			  XShmDetach(id->x.disp, &id->x.last_shminfo);
			  XDestroyImage(xim);
			  shmdt(id->x.last_shminfo.shmaddr);
			  shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
			  shared_pixmap = 0;
			  shared_image = 0;
			  ok = 0;
			}
		      if (ok)
			{
			  id->x.last_sshminfo.shmid = shmget(IPC_PRIVATE, sxim->bytes_per_line * sxim->height, IPC_CREAT | 0777);
			  if (id->x.last_sshminfo.shmid == -1)
			    {
			      fprintf(stderr, "Imlib ERROR: SHM can't get SHM Identifier for Shared XImage mask\n");
			      fprintf(stderr, "             Falling back on XImages\n");
			      XShmDetach(id->x.disp, &id->x.last_shminfo);
			      XDestroyImage(xim);
			      shmdt(xim->data);
			      /* missing shmctl(RMID) */
			      XDestroyImage(sxim);
			      shared_pixmap = 0;
			      shared_image = 0;
			      ok = 0;
			    }
			  if (ok)
			    {
			      id->x.last_sshminfo.shmaddr = sxim->data = shmat(id->x.last_sshminfo.shmid, 0, 0);
			      if (sxim->data == (char *)-1)
				{
				  fprintf(stderr, "Imlib ERROR: SHM can't attach SHM Segment for Shared XImage mask\n");
				  fprintf(stderr, "             Falling back on XImages\n");
				  XShmDetach(id->x.disp, &id->x.last_shminfo);
				  XDestroyImage(xim);
				  shmdt(xim->data);
				  /* missing shmctl(RMID) */
				  XDestroyImage(sxim);
				  shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
				  shared_pixmap = 0;
				  shared_image = 0;
				  ok = 0;
				}

			      if (ok)
				{
				  id->x.last_sshminfo.readOnly = False;
				  XShmAttach(id->x.disp, &id->x.last_sshminfo);
				  stmp = (unsigned char *)sxim->data;
				  id->x.last_sxim = sxim;
				  mask = XCreatePixmap(id->x.disp, id->x.base_window, w, h, 1);
				  stgc = XCreateGC(id->x.disp, mask, GCGraphicsExposures, &gcv);
				}
			    }
			}
		    }
		}
	    }
	}
    }
  ok = 1;
  if ((!shared_pixmap) && (!shared_image))
#endif /* HAVE_SHM */
    {
      tmp = (unsigned char *)malloc(w * h * bpp);
      if (!tmp)
	{
	  fprintf(stderr, "IMLIB ERROR: Cannot allocate RAM for XImage data\n");
	  free(xarray);
	  free(yarray);
	  free(error);
	  return 0;
	}
      xim = XCreateImage(id->x.disp, id->x.visual, id->x.depth, ZPixmap, 0, (char *)tmp, w, h, 8, 0);
      if (!xim)
	{
	  fprintf(stderr, "IMLIB ERROR: Cannot allocate XImage buffer\n");
	  free(xarray);
	  free(yarray);
	  free(error);
	  free(tmp);
	  return 0;
	}
      if (xim->bits_per_pixel != bpp)
	xim->data = realloc(xim->data, xim->bytes_per_line * xim->height);
      pmap = XCreatePixmap(id->x.disp, id->x.base_window, w, h, id->x.depth);
      if (!pmap)
	{
	  fprintf(stderr, "IMLIB ERROR: Cannot create pixmap\n");
	  free(xarray);
	  free(yarray);
	  free(error);
	  XDestroyImage(xim);
	  return 0;
	}
      tgc = XCreateGC(id->x.disp, pmap, GCGraphicsExposures, &gcv);
      if ((im->shape_color.r >= 0) && (im->shape_color.g >= 0) && (im->shape_color.b >= 0))
	{
	  stmp = (unsigned char *)malloc(((w >> 3) + 8) * h);
	  if (!stmp)
	    {
	      fprintf(stderr, "IMLIB ERROR: Cannot allocate RAM for shape XImage data\n");
	      free(xarray);
	      free(yarray);
	      free(error);
	      XDestroyImage(xim);
	      return 0;
	    }
	  sxim = XCreateImage(id->x.disp, id->x.visual, 1, ZPixmap, 0, (char *)stmp, w, h, 8, 0);
	  if (!sxim)
	    {
	      fprintf(stderr, "IMLIB ERROR: Cannot allocate XImage shape buffer\n");
	      free(xarray);
	      free(yarray);
	      free(error);
	      free(stmp);
	      XDestroyImage(xim);
	      return 0;
	    }
	  mask = XCreatePixmap(id->x.disp, id->x.base_window, w, h, 1);
	  if (!mask)
	    {
	      fprintf(stderr, "IMLIB ERROR: Cannot create shape pixmap\n");
	      free(xarray);
	      free(yarray);
	      free(error);
	      XDestroyImage(sxim);
	      XDestroyImage(xim);
	      return 0;
	    }
	  stgc = XCreateGC(id->x.disp, mask, GCGraphicsExposures, &gcv);
	}
    }
/* copy XImage to the pixmap, if not a shared pixmap */
  if ((im->shape_color.r >= 0) && (im->shape_color.g >= 0) && (im->shape_color.b >= 0))
    {
      if (!im->map)
	{
	  if (id->x.depth <= 8)
	    grender_shaped(im, w, h, xim, sxim, er1, er2, xarray, yarray, 8);
	  else
	    grender_shaped(im, w, h, xim, sxim, er1, er2, xarray, yarray, id->x.render_depth);
	}
      else
	{
	  if (id->x.depth <= 8)
	    grender_shaped_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray, 8);
	  else
	    grender_shaped_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray, id->x.render_depth);
	}
#ifdef HAVE_SHM
      if (shared_image)
	{
	  XShmPutImage(id->x.disp, pmap, tgc, xim, 0, 0, 0, 0, w, h, False);
	  XShmPutImage(id->x.disp, mask, stgc, sxim, 0, 0, 0, 0, w, h, False);
	  XSync(id->x.disp, False);
	  im->pixmap = gdk_imlib_pixmap_foreign_new(w, h, id->x.depth, pmap);
	  im->shape_mask = gdk_imlib_pixmap_foreign_new(w, h, 1, mask);
	  XShmDetach(id->x.disp, &id->x.last_shminfo);
	  XDestroyImage(xim);
	  shmdt(id->x.last_shminfo.shmaddr);
	  shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
	  XShmDetach(id->x.disp, &id->x.last_sshminfo);
	  XDestroyImage(sxim);
	  shmdt(id->x.last_sshminfo.shmaddr);
	  shmctl(id->x.last_sshminfo.shmid, IPC_RMID, 0);
	  id->x.last_xim = NULL;
	  id->x.last_sxim = NULL;
	  xim = NULL;
	  sxim = NULL;
	  XFreeGC(id->x.disp, tgc);
	  XFreeGC(id->x.disp, stgc);
	}
      else if (shared_pixmap)
	{
	  Pixmap              p2, m2;

	  p2 = XCreatePixmap(id->x.disp, id->x.base_window, w, h, id->x.depth);
	  m2 = XCreatePixmap(id->x.disp, id->x.base_window, w, h, 1);
	  XCopyArea(id->x.disp, pmap, p2, tgc, 0, 0, w, h, 0, 0);
	  XCopyArea(id->x.disp, mask, m2, stgc, 0, 0, w, h, 0, 0);
	  im->pixmap = gdk_imlib_pixmap_foreign_new(w, h, id->x.depth, p2);
	  im->shape_mask = gdk_imlib_pixmap_foreign_new(w, h, 1, m2);
	  XFreeGC(id->x.disp, tgc);
	  XFreeGC(id->x.disp, stgc);
	  XFreePixmap(id->x.disp, pmap);
	  XFreePixmap(id->x.disp, mask);
	  XSync(id->x.disp, False);
	  XShmDetach(id->x.disp, &id->x.last_shminfo);
	  XDestroyImage(xim);
	  shmdt(id->x.last_shminfo.shmaddr);
	  shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
	  XShmDetach(id->x.disp, &id->x.last_sshminfo);
	  XDestroyImage(sxim);
	  shmdt(id->x.last_sshminfo.shmaddr);
	  shmctl(id->x.last_sshminfo.shmid, IPC_RMID, 0);
	  id->x.last_xim = NULL;
	  id->x.last_sxim = NULL;
	  xim = NULL;
	  sxim = NULL;
	}
      else
#endif /* HAVE_SHM */
	{
	  XPutImage(id->x.disp, pmap, tgc, xim, 0, 0, 0, 0, w, h);
	  XPutImage(id->x.disp, mask, stgc, sxim, 0, 0, 0, 0, w, h);
	  im->pixmap = gdk_imlib_pixmap_foreign_new(w, h, id->x.depth, pmap);
	  im->shape_mask = gdk_imlib_pixmap_foreign_new(w, h, 1, mask);
	  XDestroyImage(xim);
	  XDestroyImage(sxim);
	  xim = NULL;
	  sxim = NULL;
	  XFreeGC(id->x.disp, tgc);
	  XFreeGC(id->x.disp, stgc);
	}
    }
  else
    {
      if (!im->map)
	{
	  if (id->x.depth <= 8)
	    grender(im, w, h, xim, sxim, er1, er2, xarray, yarray, 8);
	  else
	    grender(im, w, h, xim, sxim, er1, er2, xarray, yarray, id->x.render_depth);
	}
      else
	{
	  if (id->x.depth <= 8)
	    grender_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray, 8);
	  else
	    grender_mod(im, w, h, xim, sxim, er1, er2, xarray, yarray, id->x.render_depth);
	}
#ifdef HAVE_SHM
      if (shared_image)
	{
	  XShmPutImage(id->x.disp, pmap, tgc, xim, 0, 0, 0, 0, w, h, False);
	  im->pixmap = gdk_imlib_pixmap_foreign_new(w, h, id->x.depth, pmap);
	  im->shape_mask = NULL;
	  XSync(id->x.disp, False);
	  XShmDetach(id->x.disp, &id->x.last_shminfo);
	  XDestroyImage(xim);
	  shmdt(id->x.last_shminfo.shmaddr);
	  shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
	  id->x.last_xim = NULL;
	  xim = NULL;
	  sxim = NULL;
	  XFreeGC(id->x.disp, tgc);
	}
      else if (shared_pixmap)
	{
	  Pixmap              p2;

	  p2 = XCreatePixmap(id->x.disp, id->x.base_window, w, h, id->x.depth);
	  XCopyArea(id->x.disp, pmap, p2, tgc, 0, 0, w, h, 0, 0);
	  im->pixmap = gdk_imlib_pixmap_foreign_new(w, h, id->x.depth, p2);
	  im->shape_mask = NULL;
	  XFreeGC(id->x.disp, tgc);
	  XFreePixmap(id->x.disp, pmap);
	  XSync(id->x.disp, False);
	  XShmDetach(id->x.disp, &id->x.last_shminfo);
	  XDestroyImage(xim);
	  shmdt(id->x.last_shminfo.shmaddr);
	  shmctl(id->x.last_shminfo.shmid, IPC_RMID, 0);
	  id->x.last_xim = NULL;
	  xim = NULL;
	  sxim = NULL;
	}
      else
#endif /* HAVE_SHM */
	{
	  XPutImage(id->x.disp, pmap, tgc, xim, 0, 0, 0, 0, w, h);
	  im->pixmap = gdk_imlib_pixmap_foreign_new(w, h, id->x.depth, pmap);
	  im->shape_mask = NULL;
	  XDestroyImage(xim);
	  xim = NULL;
	  sxim = NULL;
	  XFreeGC(id->x.disp, tgc);
	}
    }

/* cleanup */
  XSync(id->x.disp, False);
  free(error);
  free(xarray);
  free(yarray);

/* add this pixmap to the cache */
  _gdk_imlib_add_pixmap(im, w, h, xim, sxim);
  return 1;
}