/* GTK+ Pixbuf Engine

 * Copyright (C) 1998-2000 Red Hat, Inc.

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public

 * License along with this library; if not, write to the

 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,

 * Boston, MA 02111-1307, USA.

 *

 * Written by Owen Taylor <otaylor@redhat.com>, based on code by

 * Carsten Haitzler <raster@rasterman.com>

 */

#include <string.h>

#include "pixbuf.h"

#include <gdk-pixbuf/gdk-pixbuf.h>

static GCache *pixbuf_cache = NULL;

static GdkPixbuf *

bilinear_gradient (GdkPixbuf    *src,

		   gint          src_x,

		   gint          src_y,

		   gint          width,

		   gint          height)

{

  guint n_channels = gdk_pixbuf_get_n_channels (src);

  guint src_rowstride = gdk_pixbuf_get_rowstride (src);

  guchar *src_pixels = gdk_pixbuf_get_pixels (src);

  guchar *p1, *p2, *p3, *p4;

  guint dest_rowstride;

  guchar *dest_pixels;

  GdkPixbuf *result;

  int i, j, k;

  if (src_x == 0 || src_y == 0)

    {

      g_warning ("invalid source position for bilinear gradient");

      return NULL;

    }

  p1 = src_pixels + (src_y - 1) * src_rowstride + (src_x - 1) * n_channels;

  p2 = p1 + n_channels;

  p3 = src_pixels + src_y * src_rowstride + (src_x - 1) * n_channels;

  p4 = p3 + n_channels;

  result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, n_channels == 4, 8,

			   width, height);

  if (result == NULL)

    {

      g_warning ("failed to create a %dx%d pixbuf", width, height);

      return NULL;

    }

  dest_rowstride = gdk_pixbuf_get_rowstride (result);

  dest_pixels = gdk_pixbuf_get_pixels (result);

  for (i = 0; i < height; i++)

    {

      guchar *p = dest_pixels + dest_rowstride *i;

      guint v[4];

      gint dv[4];

      for (k = 0; k < n_channels; k++)

	{

	  guint start = ((height - i) * p1[k] + (1 + i) * p3[k]) / (height + 1);

	  guint end = ((height -  i) * p2[k] + (1 + i) * p4[k]) / (height + 1);

	  dv[k] = (((gint)end - (gint)start) << 16) / (width + 1);

	  v[k] = (start << 16) + dv[k] + 0x8000;

	}

      for (j = width; j; j--)

	{

	  for (k = 0; k < n_channels; k++)

	    {

	      *(p++) = v[k] >> 16;

	      v[k] += dv[k];

	    }

	}

    }

  return result;

}

static GdkPixbuf *

horizontal_gradient (GdkPixbuf    *src,

		     gint          src_x,

		     gint          src_y,

		     gint          width,

		     gint          height)

{

  guint n_channels = gdk_pixbuf_get_n_channels (src);

  guint src_rowstride = gdk_pixbuf_get_rowstride (src);

  guchar *src_pixels = gdk_pixbuf_get_pixels (src);

  guint dest_rowstride;

  guchar *dest_pixels;

  GdkPixbuf *result;

  int i, j, k;

  if (src_x == 0)

    {

      g_warning ("invalid source position for horizontal gradient");

      return NULL;

    }

  result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, n_channels == 4, 8,

			   width, height);

  if (result == NULL)

    {

      g_warning ("failed to create a %dx%d pixbuf", width, height);

      return NULL;

    }

  dest_rowstride = gdk_pixbuf_get_rowstride (result);

  dest_pixels = gdk_pixbuf_get_pixels (result);

  for (i = 0; i < height; i++)

    {

      guchar *p = dest_pixels + dest_rowstride *i;

      guchar *p1 = src_pixels + (src_y + i) * src_rowstride + (src_x - 1) * n_channels;

      guchar *p2 = p1 + n_channels;

      guint v[4];

      gint dv[4];

      for (k = 0; k < n_channels; k++)

	{

	  dv[k] = (((gint)p2[k] - (gint)p1[k]) << 16) / (width + 1);

	  v[k] = (p1[k] << 16) + dv[k] + 0x8000;

	}

      for (j = width; j; j--)

	{

	  for (k = 0; k < n_channels; k++)

	    {

	      *(p++) = v[k] >> 16;

	      v[k] += dv[k];

	    }

	}

    }

  return result;

}

static GdkPixbuf *

vertical_gradient (GdkPixbuf    *src,

		   gint          src_x,

		   gint          src_y,

		   gint          width,

		   gint          height)

{

  guint n_channels = gdk_pixbuf_get_n_channels (src);

  guint src_rowstride = gdk_pixbuf_get_rowstride (src);

  guchar *src_pixels = gdk_pixbuf_get_pixels (src);

  guchar *top_pixels, *bottom_pixels;

  guint dest_rowstride;

  guchar *dest_pixels;

  GdkPixbuf *result;

  int i, j;

  if (src_y == 0)

    {

      g_warning ("invalid source position for vertical gradient");

      return NULL;

    }

  top_pixels = src_pixels + (src_y - 1) * src_rowstride + (src_x) * n_channels;

  bottom_pixels = top_pixels + src_rowstride;

  result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, n_channels == 4, 8,

			   width, height);

  if (result == NULL)

    {

      g_warning ("failed to create a %dx%d pixbuf", width, height);

      return NULL;

    }

  dest_rowstride = gdk_pixbuf_get_rowstride (result);

  dest_pixels = gdk_pixbuf_get_pixels (result);

  for (i = 0; i < height; i++)

    {

      guchar *p = dest_pixels + dest_rowstride *i;

      guchar *p1 = top_pixels;

      guchar *p2 = bottom_pixels;

      for (j = width * n_channels; j; j--)

	*(p++) = ((height - i) * *(p1++) + (1 + i) * *(p2++)) / (height + 1);

    }

  return result;

}

static GdkPixbuf *

replicate_single (GdkPixbuf    *src,

		  gint          src_x,

		  gint          src_y,

		  gint          width,

		  gint          height)

{

  guint n_channels = gdk_pixbuf_get_n_channels (src);

  guchar *pixels = (gdk_pixbuf_get_pixels (src) +

		    src_y * gdk_pixbuf_get_rowstride (src) +

		    src_x * n_channels);

  guchar r = *(pixels++);

  guchar g = *(pixels++);

  guchar b = *(pixels++);

  guint dest_rowstride;

  guchar *dest_pixels;

  guchar a = 0;

  GdkPixbuf *result;

  int i, j;

  if (n_channels == 4)

    a = *(pixels++);

  result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, n_channels == 4, 8,

			   width, height);

  if (result == NULL)

    {

      g_warning ("failed to create a %dx%d pixbuf", width, height);

      return NULL;

    }

  dest_rowstride = gdk_pixbuf_get_rowstride (result);

  dest_pixels = gdk_pixbuf_get_pixels (result);

  for (i = 0; i < height; i++)

    {

      guchar *p = dest_pixels + dest_rowstride *i;

      for (j = 0; j < width; j++)

	{

	  *(p++) = r;

	  *(p++) = g;

	  *(p++) = b;

	  if (n_channels == 4)

	    *(p++) = a;

	}

    }

  return result;

}

static GdkPixbuf *

replicate_rows (GdkPixbuf    *src,

		gint          src_x,

		gint          src_y,

		gint          width,

		gint          height)

{

  guint n_channels = gdk_pixbuf_get_n_channels (src);

  guint src_rowstride = gdk_pixbuf_get_rowstride (src);

  guchar *pixels = (gdk_pixbuf_get_pixels (src) + src_y * src_rowstride + src_x * n_channels);

  guchar *dest_pixels;

  GdkPixbuf *result;

  guint dest_rowstride;

  int i;

  result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, n_channels == 4, 8,

			   width, height);

  if (result == NULL)

    {

      g_warning ("failed to create a %dx%d pixbuf", width, height);

      return NULL;

    }

  dest_rowstride = gdk_pixbuf_get_rowstride (result);

  dest_pixels = gdk_pixbuf_get_pixels (result);

  for (i = 0; i < height; i++)

    memcpy (dest_pixels + dest_rowstride * i, pixels, n_channels * width);

  return result;

}

static GdkPixbuf *

replicate_cols (GdkPixbuf    *src,

		gint          src_x,

		gint          src_y,

		gint          width,

		gint          height)

{

  guint n_channels = gdk_pixbuf_get_n_channels (src);

  guint src_rowstride = gdk_pixbuf_get_rowstride (src);

  guchar *pixels = (gdk_pixbuf_get_pixels (src) + src_y * src_rowstride + src_x * n_channels);

  guchar *dest_pixels;

  GdkPixbuf *result;

  guint dest_rowstride;

  int i, j;

  result = gdk_pixbuf_new (GDK_COLORSPACE_RGB, n_channels == 4, 8,

			   width, height);

  if (result == NULL)

    {

      g_warning ("failed to create a %dx%d pixbuf", width, height);

      return NULL;

    }

  dest_rowstride = gdk_pixbuf_get_rowstride (result);

  dest_pixels = gdk_pixbuf_get_pixels (result);

  for (i = 0; i < height; i++)

    {

      guchar *p = dest_pixels + dest_rowstride * i;

      guchar *q = pixels + src_rowstride * i;

      guchar r = *(q++);

      guchar g = *(q++);

      guchar b = *(q++);

      guchar a = 0;

      if (n_channels == 4)

	a = *(q++);

      for (j = 0; j < width; j++)

	{

	  *(p++) = r;

	  *(p++) = g;

	  *(p++) = b;

	  if (n_channels == 4)

	    *(p++) = a;

	}

    }

  return result;

}

/* Scale the rectangle (src_x, src_y, src_width, src_height)

 * onto the rectangle (dest_x, dest_y, dest_width, dest_height)

 * of the destination, clip by clip_rect and render

 */

static void

pixbuf_render (GdkPixbuf    *src,

	       guint         hints,

	       GdkWindow    *window,

	       GdkBitmap    *mask,

	       GdkRectangle *clip_rect,

	       gint          src_x,

	       gint          src_y,

	       gint          src_width,

	       gint          src_height,

	       gint          dest_x,

	       gint          dest_y,

	       gint          dest_width,

	       gint          dest_height)

{

  GdkPixbuf *tmp_pixbuf = NULL;

  GdkRectangle rect;

  int x_offset, y_offset;

  gboolean has_alpha = gdk_pixbuf_get_has_alpha (src);

  gint src_rowstride = gdk_pixbuf_get_rowstride (src);

  gint src_n_channels = gdk_pixbuf_get_n_channels (src);

  if (dest_width <= 0 || dest_height <= 0)

    return;

  rect.x = dest_x;

  rect.y = dest_y;

  rect.width = dest_width;

  rect.height = dest_height;

  if (hints & THEME_MISSING)

    return;

  /* FIXME: Because we use the mask to shape windows, we don't use

   * clip_rect to clip what we draw to the mask, only to clip

   * what we actually draw. But this leads to the horrible ineffiency

   * of scale the whole image to get a little bit of it.

   */

  if (!mask && clip_rect)

    {

      if (!gdk_rectangle_intersect (clip_rect, &rect, &rect))

	return;

    }

  if (dest_width == src_width && dest_height == src_height)

    {

      tmp_pixbuf = g_object_ref (src);

      x_offset = src_x + rect.x - dest_x;

      y_offset = src_y + rect.y - dest_y;

    }

  else if (src_width == 0 && src_height == 0)

    {

      tmp_pixbuf = bilinear_gradient (src, src_x, src_y, dest_width, dest_height);      

      x_offset = rect.x - dest_x;

      y_offset = rect.y - dest_y;

    }

  else if (src_width == 0 && dest_height == src_height)

    {

      tmp_pixbuf = horizontal_gradient (src, src_x, src_y, dest_width, dest_height);      

      x_offset = rect.x - dest_x;

      y_offset = rect.y - dest_y;

    }

  else if (src_height == 0 && dest_width == src_width)

    {

      tmp_pixbuf = vertical_gradient (src, src_x, src_y, dest_width, dest_height);

      x_offset = rect.x - dest_x;

      y_offset = rect.y - dest_y;

    }

  else if ((hints & THEME_CONSTANT_COLS) && (hints & THEME_CONSTANT_ROWS))

    {

      tmp_pixbuf = replicate_single (src, src_x, src_y, dest_width, dest_height);

      x_offset = rect.x - dest_x;

      y_offset = rect.y - dest_y;

    }

  else if (dest_width == src_width && (hints & THEME_CONSTANT_COLS))

    {

      tmp_pixbuf = replicate_rows (src, src_x, src_y, dest_width, dest_height);

      x_offset = rect.x - dest_x;

      y_offset = rect.y - dest_y;

    }

  else if (dest_height == src_height && (hints & THEME_CONSTANT_ROWS))

    {

      tmp_pixbuf = replicate_cols (src, src_x, src_y, dest_width, dest_height);

      x_offset = rect.x - dest_x;

      y_offset = rect.y - dest_y;

    }

  else if (src_width > 0 && src_height > 0)

    {

      double x_scale = (double)dest_width / src_width;

      double y_scale = (double)dest_height / src_height;

      guchar *pixels;

      GdkPixbuf *partial_src;

      pixels = (gdk_pixbuf_get_pixels (src)

		+ src_y * src_rowstride

		+ src_x * src_n_channels);

      partial_src = gdk_pixbuf_new_from_data (pixels, GDK_COLORSPACE_RGB,

					      has_alpha,

					      8, src_width, src_height,

					      src_rowstride,

					      NULL, NULL);

      tmp_pixbuf = gdk_pixbuf_new (GDK_COLORSPACE_RGB,

				   has_alpha, 8,

				   rect.width, rect.height);

      gdk_pixbuf_scale (partial_src, tmp_pixbuf,

			0, 0, rect.width, rect.height,

			dest_x - rect.x, dest_y - rect.y, 

			x_scale, y_scale,

			GDK_INTERP_BILINEAR);

      g_object_unref (partial_src);

      x_offset = 0;

      y_offset = 0;

    }

  if (tmp_pixbuf)

    {

      cairo_t *cr;

      if (mask)

	{

          cr = gdk_cairo_create (mask);

          gdk_cairo_set_source_pixbuf (cr, tmp_pixbuf,

                                       -x_offset + rect.x, 

                                       -y_offset + rect.y);

          gdk_cairo_rectangle (cr, &rect);

          cairo_fill (cr);

          cairo_destroy (cr);

	}

      cr = gdk_cairo_create (window);

      gdk_cairo_set_source_pixbuf (cr, 

                                   tmp_pixbuf,

                                   -x_offset + rect.x, 

                                   -y_offset + rect.y);

      gdk_cairo_rectangle (cr, &rect);

      cairo_fill (cr);

      cairo_destroy (cr);

      g_object_unref (tmp_pixbuf);

    }

}

ThemePixbuf *

theme_pixbuf_new (void)

{

  ThemePixbuf *result = g_new0 (ThemePixbuf, 1);

  result->filename = NULL;

  result->pixbuf = NULL;

  result->stretch = TRUE;

  result->border_left = 0;

  result->border_right = 0;

  result->border_bottom = 0;

  result->border_top = 0;

  return result;

}

void

theme_pixbuf_destroy (ThemePixbuf *theme_pb)

{

  if (G_LIKELY (theme_pb))

    {

      theme_pixbuf_set_filename (theme_pb, NULL);

      g_free (theme_pb);

    }

}

void

theme_clear_pixbuf (ThemePixbuf **theme_pb)

{

#if GLIB_CHECK_VERSION (2, 34, 0)

  g_clear_pointer (theme_pb, theme_pixbuf_destroy);

#else

  if (*theme_pb)

    {

      theme_pixbuf_destroy (*theme_pb);

      *theme_pb = NULL;

    }

#endif

}

void         

theme_pixbuf_set_filename (ThemePixbuf *theme_pb,

			   const char  *filename)

{

  if (theme_pb->pixbuf)

    {

      g_cache_remove (pixbuf_cache, theme_pb->pixbuf);

      theme_pb->pixbuf = NULL;

    }

  g_free (theme_pb->filename);

  if (filename)

    theme_pb->filename = g_strdup (filename);

  else

    theme_pb->filename = NULL;

}

static guint

compute_hint (GdkPixbuf *pixbuf,

	      gint       x0,

	      gint       x1,

	      gint       y0,

	      gint       y1)

{

  int i, j;

  int hints = THEME_CONSTANT_ROWS | THEME_CONSTANT_COLS | THEME_MISSING;

  int n_channels = gdk_pixbuf_get_n_channels (pixbuf);

  guchar *data = gdk_pixbuf_get_pixels (pixbuf);

  int rowstride = gdk_pixbuf_get_rowstride (pixbuf);

  if (x0 == x1 || y0 == y1)

    return 0;

  for (i = y0; i < y1; i++)

    {

      guchar *p = data + i * rowstride + x0 * n_channels;

      guchar r = p[0];

      guchar g = p[1];

      guchar b = p[2];

      guchar a = 0;

      if (n_channels == 4)

	a = p[3];

      for (j = x0; j < x1 ; j++)

	{

	  if (n_channels != 4 || p[3] != 0)

	    {

	      hints &= ~THEME_MISSING;

	      if (!(hints & THEME_CONSTANT_ROWS))

		goto cols;

	    }

	  if (r != *(p++) ||

	      g != *(p++) ||

	      b != *(p++) ||

	      (n_channels != 4 && a != *(p++)))

	    {

	      hints &= ~THEME_CONSTANT_ROWS;

	      if (!(hints & THEME_MISSING))

		goto cols;

	    }

	}

    }

 cols:

  for (i = y0 + 1; i < y1; i++)

    {

      guchar *base = data + y0 * rowstride + x0 * n_channels;

      guchar *p = data + i * rowstride + x0 * n_channels;

      if (memcmp (p, base, n_channels * (x1 - x0)) != 0)

	{

	  hints &= ~THEME_CONSTANT_COLS;

	  return hints;

	}

    }

  return hints;

}

static void

theme_pixbuf_compute_hints (ThemePixbuf *theme_pb)

{

  int i, j;

  gint width = gdk_pixbuf_get_width (theme_pb->pixbuf);

  gint height = gdk_pixbuf_get_height (theme_pb->pixbuf);

  if (theme_pb->border_left + theme_pb->border_right > width ||

      theme_pb->border_top + theme_pb->border_bottom > height)

    {

      g_warning ("Invalid borders specified for theme pixmap:\n"

		 "        %s,\n"

		 "borders don't fit within the image", theme_pb->filename);

      if (theme_pb->border_left + theme_pb->border_right > width)

	{

	  theme_pb->border_left = width / 2;

	  theme_pb->border_right = (width + 1) / 2;

	}

      if (theme_pb->border_bottom + theme_pb->border_top > height)

	{

	  theme_pb->border_top = height / 2;

	  theme_pb->border_bottom = (height + 1) / 2;

	}

    }

  for (i = 0; i < 3; i++)

    {

      gint y0, y1;

      switch (i)

	{

	case 0:

	  y0 = 0;

	  y1 = theme_pb->border_top;

	  break;

	case 1:

	  y0 = theme_pb->border_top;

	  y1 = height - theme_pb->border_bottom;

	  break;

	default:

	  y0 = height - theme_pb->border_bottom;

	  y1 = height;

	  break;

	}

      for (j = 0; j < 3; j++)

	{

	  gint x0, x1;

	  switch (j)

	    {

	    case 0:

	      x0 = 0;

	      x1 = theme_pb->border_left;

	      break;

	    case 1:

	      x0 = theme_pb->border_left;

	      x1 = width - theme_pb->border_right;

	      break;

	    default:

	      x0 = width - theme_pb->border_right;

	      x1 = width;

	      break;

	    }

	  theme_pb->hints[i][j] = compute_hint (theme_pb->pixbuf, x0, x1, y0, y1);

	}

    }

}

void

theme_pixbuf_set_border (ThemePixbuf *theme_pb,

			 gint         left,

			 gint         right,

			 gint         top,

			 gint         bottom)

{

  theme_pb->border_left = left;

  theme_pb->border_right = right;

  theme_pb->border_top = top;

  theme_pb->border_bottom = bottom;

  if (theme_pb->pixbuf)

    theme_pixbuf_compute_hints (theme_pb);

}

void

theme_pixbuf_set_stretch (ThemePixbuf *theme_pb,

			  gboolean     stretch)

{

  theme_pb->stretch = stretch;

  if (theme_pb->pixbuf)

    theme_pixbuf_compute_hints (theme_pb);

}

static GdkPixbuf *

pixbuf_cache_value_new (gchar *filename)

{

  GError *err = NULL;

  GdkPixbuf *result = gdk_pixbuf_new_from_file (filename, &err;;

  if (!result)

    {

      g_warning ("Pixbuf theme: Cannot load pixmap file %s: %s\n",

		 filename, err->message);

      g_error_free (err);

    }

  return result;

}

GdkPixbuf *

theme_pixbuf_get_pixbuf (ThemePixbuf *theme_pb)

{

  if (!theme_pb->pixbuf)

    {

      if (!pixbuf_cache)

	pixbuf_cache = g_cache_new ((GCacheNewFunc)pixbuf_cache_value_new,

				    (GCacheDestroyFunc)g_object_unref,

				    (GCacheDupFunc)g_strdup,

				    (GCacheDestroyFunc)g_free,

				    g_str_hash, g_direct_hash, g_str_equal);

      theme_pb->pixbuf = g_cache_insert (pixbuf_cache, theme_pb->filename);

      if (theme_pb->stretch)

	theme_pixbuf_compute_hints (theme_pb);

    }

  return theme_pb->pixbuf;

}

void

theme_pixbuf_render (ThemePixbuf  *theme_pb,

		     GdkWindow    *window,

		     GdkBitmap    *mask,

		     GdkRectangle *clip_rect,

		     guint         component_mask,

		     gboolean      center,

		     gint          x,

		     gint          y,

		     gint          width,

		     gint          height)

{

  GdkPixbuf *pixbuf = theme_pixbuf_get_pixbuf (theme_pb);

  gint src_x[4], src_y[4], dest_x[4], dest_y[4];

  gint pixbuf_width = gdk_pixbuf_get_width (pixbuf);

  gint pixbuf_height = gdk_pixbuf_get_height (pixbuf);

  if (!pixbuf)

    return;

  if (theme_pb->stretch)

    {

      if (component_mask & COMPONENT_ALL)

	component_mask = (COMPONENT_ALL - 1) & ~component_mask;

      src_x[0] = 0;

      src_x[1] = theme_pb->border_left;

      src_x[2] = pixbuf_width - theme_pb->border_right;

      src_x[3] = pixbuf_width;

      src_y[0] = 0;

      src_y[1] = theme_pb->border_top;

      src_y[2] = pixbuf_height - theme_pb->border_bottom;

      src_y[3] = pixbuf_height;

      dest_x[0] = x;

      dest_x[1] = x + theme_pb->border_left;

      dest_x[2] = x + width - theme_pb->border_right;

      dest_x[3] = x + width;

      if (dest_x[1] > dest_x[2])

	{

	  component_mask &= ~(COMPONENT_NORTH | COMPONENT_SOUTH | COMPONENT_CENTER);

	  dest_x[1] = dest_x[2] = (dest_x[1] + dest_x[2]) / 2;

	}

      dest_y[0] = y;

      dest_y[1] = y + theme_pb->border_top;

      dest_y[2] = y + height - theme_pb->border_bottom;

      dest_y[3] = y + height;

      if (dest_y[1] > dest_y[2])

	{

	  component_mask &= ~(COMPONENT_EAST | COMPONENT_WEST | COMPONENT_CENTER);

	  dest_y[1] = dest_y[2] = (dest_y[1] + dest_y[2]) / 2;

	}

#define RENDER_COMPONENT(X1,X2,Y1,Y2)					         \

        pixbuf_render (pixbuf, theme_pb->hints[Y1][X1], window, mask, clip_rect, \

	 	       src_x[X1], src_y[Y1],				         \

		       src_x[X2] - src_x[X1], src_y[Y2] - src_y[Y1],	         \

		       dest_x[X1], dest_y[Y1],				         \

		       dest_x[X2] - dest_x[X1], dest_y[Y2] - dest_y[Y1]);

      if (component_mask & COMPONENT_NORTH_WEST)

	RENDER_COMPONENT (0, 1, 0, 1);

      if (component_mask & COMPONENT_NORTH)

	RENDER_COMPONENT (1, 2, 0, 1);

      if (component_mask & COMPONENT_NORTH_EAST)

	RENDER_COMPONENT (2, 3, 0, 1);

      if (component_mask & COMPONENT_WEST)

	RENDER_COMPONENT (0, 1, 1, 2);

      if (component_mask & COMPONENT_CENTER)

	RENDER_COMPONENT (1, 2, 1, 2);

      if (component_mask & COMPONENT_EAST)

	RENDER_COMPONENT (2, 3, 1, 2);

      if (component_mask & COMPONENT_SOUTH_WEST)

	RENDER_COMPONENT (0, 1, 2, 3);

      if (component_mask & COMPONENT_SOUTH)

	RENDER_COMPONENT (1, 2, 2, 3);

      if (component_mask & COMPONENT_SOUTH_EAST)

	RENDER_COMPONENT (2, 3, 2, 3);

    }

  else

    {

      if (center)

	{

	  x += (width - pixbuf_width) / 2;

	  y += (height - pixbuf_height) / 2;

	  pixbuf_render (pixbuf, 0, window, NULL, clip_rect,

			 0, 0,

			 pixbuf_width, pixbuf_height,

			 x, y,

			 pixbuf_width, pixbuf_height);

	}

      else

	{

          cairo_t *cr = gdk_cairo_create (window);

          gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);

          cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);

	  if (clip_rect)

	    gdk_cairo_rectangle (cr, clip_rect);