/* GDK - The GIMP Drawing Kit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 *

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

 * modify it under the terms of the GNU Lesser 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

 * Lesser General Public License for more details.

 *

 * You should have received a copy of the GNU Lesser 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.

 */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 

 */

#include "config.h"

#include <math.h>

#include <pango/pangocairo.h>

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

#include "gdkcairo.h"

#include "gdkdrawable.h"

#include "gdkinternals.h"

#include "gdkwindow.h"

#include "gdkscreen.h"

#include "gdkpixbuf.h"

#include "gdkalias.h"

static GdkImage*    gdk_drawable_real_get_image (GdkDrawable     *drawable,

						 gint             x,

						 gint             y,

						 gint             width,

						 gint             height);

static GdkDrawable* gdk_drawable_real_get_composite_drawable (GdkDrawable  *drawable,

							      gint          x,

							      gint          y,

							      gint          width,

							      gint          height,

							      gint         *composite_x_offset,

							      gint         *composite_y_offset);

static GdkRegion *  gdk_drawable_real_get_visible_region     (GdkDrawable  *drawable);

static void         gdk_drawable_real_draw_pixbuf            (GdkDrawable  *drawable,

							      GdkGC        *gc,

							      GdkPixbuf    *pixbuf,

							      gint          src_x,

							      gint          src_y,

							      gint          dest_x,

							      gint          dest_y,

							      gint          width,

							      gint          height,

							      GdkRgbDither  dither,

							      gint          x_dither,

							      gint          y_dither);

static void         gdk_drawable_real_draw_drawable          (GdkDrawable  *drawable,

							      GdkGC	   *gc,

							      GdkDrawable  *src,

							      gint          xsrc,

							      gint	    ysrc,

							      gint	    xdest,

							      gint	    ydest,

							      gint	    width,

							      gint	    height);

G_DEFINE_ABSTRACT_TYPE (GdkDrawable, gdk_drawable, G_TYPE_OBJECT)

static void

gdk_drawable_class_init (GdkDrawableClass *klass)

{

  klass->get_image = gdk_drawable_real_get_image;

  klass->get_composite_drawable = gdk_drawable_real_get_composite_drawable;

  /* Default implementation for clip and visible region is the same */

  klass->get_clip_region = gdk_drawable_real_get_visible_region;

  klass->get_visible_region = gdk_drawable_real_get_visible_region;

  klass->draw_pixbuf = gdk_drawable_real_draw_pixbuf;

  klass->draw_drawable = gdk_drawable_real_draw_drawable;

}

static void

gdk_drawable_init (GdkDrawable *drawable)

{

}

/* Manipulation of drawables

 */

/**

 * gdk_drawable_set_data:

 * @drawable: a #GdkDrawable

 * @key: name to store the data under

 * @data: arbitrary data

 * @destroy_func: (allow-none): function to free @data, or %NULL

 *

 * This function is equivalent to g_object_set_data(),

 * the #GObject variant should be used instead.

 * 

 **/

void          

gdk_drawable_set_data (GdkDrawable   *drawable,

		       const gchar   *key,

		       gpointer	      data,

		       GDestroyNotify destroy_func)

{

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_object_set_qdata_full (G_OBJECT (drawable),

                           g_quark_from_string (key),

                           data,

                           destroy_func);

}

/**

 * gdk_drawable_get_data:

 * @drawable: a #GdkDrawable

 * @key: name the data was stored under

 * 

 * Equivalent to g_object_get_data(); the #GObject variant should be

 * used instead.

 * 

 * Return value: the data stored at @key

 **/

gpointer

gdk_drawable_get_data (GdkDrawable   *drawable,

		       const gchar   *key)

{

  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);

  return g_object_get_qdata (G_OBJECT (drawable),

                             g_quark_try_string (key));

}

/**

 * gdk_drawable_get_size:

 * @drawable: a #GdkDrawable

 * @width: (out) (allow-none): location to store drawable's width, or %NULL

 * @height: (out) (allow-none): location to store drawable's height, or %NULL

 *

 * Fills *@width and *@height with the size of @drawable.

 * @width or @height can be %NULL if you only want the other one.

 *

 * On the X11 platform, if @drawable is a #GdkWindow, the returned

 * size is the size reported in the most-recently-processed configure

 * event, rather than the current size on the X server.

 *

 * Deprecated: 2.24: Use gdk_window_get_width() and gdk_window_get_height() for

 *             #GdkWindows. Use gdk_pixmap_get_size() for #GdkPixmaps.

 */

void

gdk_drawable_get_size (GdkDrawable *drawable,

		       gint        *width,

		       gint        *height)

{

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  GDK_DRAWABLE_GET_CLASS (drawable)->get_size (drawable, width, height);  

}

/**

 * gdk_drawable_get_visual:

 * @drawable: a #GdkDrawable

 * 

 * Gets the #GdkVisual describing the pixel format of @drawable.

 * 

 * Return value: a #GdkVisual

 *

 * Deprecated: 2.24: Use gdk_window_get_visual()

 */

GdkVisual*

gdk_drawable_get_visual (GdkDrawable *drawable)

{

  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);

  return GDK_DRAWABLE_GET_CLASS (drawable)->get_visual (drawable);

}

/**

 * gdk_drawable_get_depth:

 * @drawable: a #GdkDrawable

 * 

 * Obtains the bit depth of the drawable, that is, the number of bits

 * that make up a pixel in the drawable's visual. Examples are 8 bits

 * per pixel, 24 bits per pixel, etc.

 * 

 * Return value: number of bits per pixel

 **/

gint

gdk_drawable_get_depth (GdkDrawable *drawable)

{

  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), 0);

  return GDK_DRAWABLE_GET_CLASS (drawable)->get_depth (drawable);

}

/**

 * gdk_drawable_get_screen:

 * @drawable: a #GdkDrawable

 * 

 * Gets the #GdkScreen associated with a #GdkDrawable.

 * 

 * Return value: the #GdkScreen associated with @drawable

 *

 * Since: 2.2

 *

 * Deprecated: 2.24: Use gdk_window_get_screen() instead

 **/

GdkScreen*

gdk_drawable_get_screen (GdkDrawable *drawable)

{

  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);

  return GDK_DRAWABLE_GET_CLASS (drawable)->get_screen (drawable);

}

/**

 * gdk_drawable_get_display:

 * @drawable: a #GdkDrawable

 * 

 * Gets the #GdkDisplay associated with a #GdkDrawable.

 * 

 * Return value: the #GdkDisplay associated with @drawable

 *

 * Since: 2.2

 *

 * Deprecated: 2.24: Use gdk_window_get_display() instead

 **/

GdkDisplay*

gdk_drawable_get_display (GdkDrawable *drawable)

{

  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);

  return gdk_screen_get_display (gdk_drawable_get_screen (drawable));

}

/**

 * gdk_drawable_set_colormap:

 * @drawable: a #GdkDrawable

 * @colormap: a #GdkColormap

 *

 * Sets the colormap associated with @drawable. Normally this will

 * happen automatically when the drawable is created; you only need to

 * use this function if the drawable-creating function did not have a

 * way to determine the colormap, and you then use drawable operations

 * that require a colormap. The colormap for all drawables and

 * graphics contexts you intend to use together should match. i.e.

 * when using a #GdkGC to draw to a drawable, or copying one drawable

 * to another, the colormaps should match.

 * 

 **/

void

gdk_drawable_set_colormap (GdkDrawable *drawable,

                           GdkColormap *cmap)

{

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_return_if_fail (cmap == NULL || gdk_drawable_get_depth (drawable)

                    == cmap->visual->depth);

  GDK_DRAWABLE_GET_CLASS (drawable)->set_colormap (drawable, cmap);

}

/**

 * gdk_drawable_get_colormap:

 * @drawable: a #GdkDrawable

 * 

 * Gets the colormap for @drawable, if one is set; returns

 * %NULL otherwise.

 * 

 * Return value: the colormap, or %NULL

 **/

GdkColormap*

gdk_drawable_get_colormap (GdkDrawable *drawable)

{

  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);

  return GDK_DRAWABLE_GET_CLASS (drawable)->get_colormap (drawable);

}

/**

 * gdk_drawable_ref:

 * @drawable: a #GdkDrawable

 * 

 * Deprecated equivalent of calling g_object_ref() on @drawable.

 * (Drawables were not objects in previous versions of GDK.)

 * 

 * Return value: the same @drawable passed in

 *

 * Deprecated: 2.0: Use g_object_ref() instead.

 **/

GdkDrawable*

gdk_drawable_ref (GdkDrawable *drawable)

{

  return (GdkDrawable *) g_object_ref (drawable);

}

/**

 * gdk_drawable_unref:

 * @drawable: a #GdkDrawable

 *

 * Deprecated equivalent of calling g_object_unref() on @drawable.

 * 

 * Deprecated: 2.0: Use g_object_unref() instead.

 **/

void

gdk_drawable_unref (GdkDrawable *drawable)

{

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_object_unref (drawable);

}

/* Drawing

 */

/**

 * gdk_draw_point:

 * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).

 * @gc: a #GdkGC.

 * @x: the x coordinate of the point.

 * @y: the y coordinate of the point.

 * 

 * Draws a point, using the foreground color and other attributes of 

 * the #GdkGC.

 *

 * Deprecated: 2.22: Use cairo_rectangle() and cairo_fill() or 

 * cairo_move_to() and cairo_stroke() instead.

 **/

void

gdk_draw_point (GdkDrawable *drawable,

                GdkGC       *gc,

                gint         x,

                gint         y)

{

  GdkPoint point;

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_return_if_fail (GDK_IS_GC (gc));

  point.x = x;

  point.y = y;

  GDK_DRAWABLE_GET_CLASS (drawable)->draw_points (drawable, gc, &point, 1);

}

/**

 * gdk_draw_line:

 * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap). 

 * @gc: a #GdkGC.

 * @x1_: the x coordinate of the start point.

 * @y1_: the y coordinate of the start point.

 * @x2_: the x coordinate of the end point.

 * @y2_: the y coordinate of the end point.

 * 

 * Draws a line, using the foreground color and other attributes of 

 * the #GdkGC.

 *

 * Deprecated: 2.22: Use cairo_line_to() and cairo_stroke() instead.

 * Be aware that the default line width in Cairo is 2 pixels and that your

 * coordinates need to describe the center of the line. To draw a single

 * pixel wide pixel-aligned line, you would use:

 * |[cairo_set_line_width (cr, 1.0);

 * cairo_set_line_cap (cr, CAIRO_LINE_CAP_SQUARE);

 * cairo_move_to (cr, 0.5, 0.5);

 * cairo_line_to (cr, 9.5, 0.5);

 * cairo_stroke (cr);]|

 * See also <ulink url="http://cairographics.org/FAQ/#sharp_lines">the Cairo

 * FAQ</ulink> on this topic.

 **/

void

gdk_draw_line (GdkDrawable *drawable,

	       GdkGC       *gc,

	       gint         x1,

	       gint         y1,

	       gint         x2,

	       gint         y2)

{

  GdkSegment segment;

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_return_if_fail (GDK_IS_GC (gc));

  segment.x1 = x1;

  segment.y1 = y1;

  segment.x2 = x2;

  segment.y2 = y2;

  GDK_DRAWABLE_GET_CLASS (drawable)->draw_segments (drawable, gc, &segment, 1);

}

/**

 * gdk_draw_rectangle:

 * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).

 * @gc: a #GdkGC.

 * @filled: %TRUE if the rectangle should be filled.

 * @x: the x coordinate of the left edge of the rectangle.

 * @y: the y coordinate of the top edge of the rectangle.

 * @width: the width of the rectangle.

 * @height: the height of the rectangle.

 * 

 * Draws a rectangular outline or filled rectangle, using the foreground color

 * and other attributes of the #GdkGC.

 *

 * A rectangle drawn filled is 1 pixel smaller in both dimensions than a 

 * rectangle outlined. Calling 

 * <literal>gdk_draw_rectangle (window, gc, TRUE, 0, 0, 20, 20)</literal> 

 * results in a filled rectangle 20 pixels wide and 20 pixels high. Calling

 * <literal>gdk_draw_rectangle (window, gc, FALSE, 0, 0, 20, 20)</literal> 

 * results in an outlined rectangle with corners at (0, 0), (0, 20), (20, 20),

 * and (20, 0), which makes it 21 pixels wide and 21 pixels high.

 *

 * Deprecated: 2.22: Use cairo_rectangle() and cairo_fill() or cairo_stroke()

 * instead. For stroking, the same caveats for converting code apply as for

 * gdk_draw_line().

 **/

void

gdk_draw_rectangle (GdkDrawable *drawable,

		    GdkGC       *gc,

		    gboolean     filled,

		    gint         x,

		    gint         y,

		    gint         width,

		    gint         height)

{  

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_return_if_fail (GDK_IS_GC (gc));

  if (width < 0 || height < 0)

    {

      gint real_width;

      gint real_height;

      gdk_drawable_get_size (drawable, &real_width, &real_height);

      if (width < 0)

        width = real_width;

      if (height < 0)

        height = real_height;

    }

  GDK_DRAWABLE_GET_CLASS (drawable)->draw_rectangle (drawable, gc, filled, x, y,

                                                     width, height);

}

/**

 * gdk_draw_arc:

 * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).

 * @gc: a #GdkGC.

 * @filled: %TRUE if the arc should be filled, producing a 'pie slice'.

 * @x: the x coordinate of the left edge of the bounding rectangle.

 * @y: the y coordinate of the top edge of the bounding rectangle.

 * @width: the width of the bounding rectangle.

 * @height: the height of the bounding rectangle.

 * @angle1: the start angle of the arc, relative to the 3 o'clock position,

 *     counter-clockwise, in 1/64ths of a degree.

 * @angle2: the end angle of the arc, relative to @angle1, in 1/64ths 

 *     of a degree.

 * 

 * Draws an arc or a filled 'pie slice'. The arc is defined by the bounding

 * rectangle of the entire ellipse, and the start and end angles of the part 

 * of the ellipse to be drawn.

 *

 * Deprecated: 2.22: Use cairo_arc() and cairo_fill() or cairo_stroke()

 * instead. Note that arcs just like any drawing operation in Cairo are

 * antialiased unless you call cairo_set_antialias().

 **/

void

gdk_draw_arc (GdkDrawable *drawable,

	      GdkGC       *gc,

	      gboolean     filled,

	      gint         x,

	      gint         y,

	      gint         width,

	      gint         height,

	      gint         angle1,

	      gint         angle2)

{  

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_return_if_fail (GDK_IS_GC (gc));

  if (width < 0 || height < 0)

    {

      gint real_width;

      gint real_height;

      gdk_drawable_get_size (drawable, &real_width, &real_height);

      if (width < 0)

        width = real_width;

      if (height < 0)

        height = real_height;

    }

  GDK_DRAWABLE_GET_CLASS (drawable)->draw_arc (drawable, gc, filled,

                                               x, y, width, height, angle1, angle2);

}

/**

 * gdk_draw_polygon:

 * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).

 * @gc: a #GdkGC.

 * @filled: %TRUE if the polygon should be filled. The polygon is closed

 *     automatically, connecting the last point to the first point if 

 *     necessary.

 * @points: an array of #GdkPoint structures specifying the points making 

 *     up the polygon.

 * @n_points: the number of points.

 * 

 * Draws an outlined or filled polygon.

 *

 * Deprecated: 2.22: Use cairo_line_to() or cairo_append_path() and

 * cairo_fill() or cairo_stroke() instead.

 **/

void

gdk_draw_polygon (GdkDrawable    *drawable,

		  GdkGC          *gc,

		  gboolean        filled,

		  const GdkPoint *points,

		  gint            n_points)

{

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_return_if_fail (GDK_IS_GC (gc));

  GDK_DRAWABLE_GET_CLASS (drawable)->draw_polygon (drawable, gc, filled,

                                                   (GdkPoint *) points,

                                                   n_points);

}

/* gdk_draw_string

 *

 * Modified by Li-Da Lho to draw 16 bits and Multibyte strings

 *

 * Interface changed: add "GdkFont *font" to specify font or fontset explicitely

 */

/**

 * gdk_draw_string:

 * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).

 * @font: a #GdkFont.

 * @gc: a #GdkGC.

 * @x: the x coordinate of the left edge of the text.

 * @y: the y coordinate of the baseline of the text.

 * @string:  the string of characters to draw.

 * 

 * Draws a string of characters in the given font or fontset.

 * 

 * Deprecated: 2.4: Use gdk_draw_layout() instead.

 **/

void

gdk_draw_string (GdkDrawable *drawable,

		 GdkFont     *font,

		 GdkGC       *gc,

		 gint         x,

		 gint         y,

		 const gchar *string)

{

  gdk_draw_text (drawable, font, gc, x, y, string, _gdk_font_strlen (font, string));

}

/* gdk_draw_text

 *

 * Modified by Li-Da Lho to draw 16 bits and Multibyte strings

 *

 * Interface changed: add "GdkFont *font" to specify font or fontset explicitely

 */

/**

 * gdk_draw_text:

 * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).

 * @font: a #GdkFont.

 * @gc: a #GdkGC.

 * @x: the x coordinate of the left edge of the text.

 * @y: the y coordinate of the baseline of the text.

 * @text:  the characters to draw.

 * @text_length: the number of characters of @text to draw.

 * 

 * Draws a number of characters in the given font or fontset.

 *

 * Deprecated: 2.4: Use gdk_draw_layout() instead.

 **/

void

gdk_draw_text (GdkDrawable *drawable,

	       GdkFont     *font,

	       GdkGC       *gc,

	       gint         x,

	       gint         y,

	       const gchar *text,

	       gint         text_length)

{

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_return_if_fail (font != NULL);

  g_return_if_fail (GDK_IS_GC (gc));

  g_return_if_fail (text != NULL);

  GDK_DRAWABLE_GET_CLASS (drawable)->draw_text (drawable, font, gc, x, y, text, text_length);

}

/**

 * gdk_draw_text_wc:

 * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).

 * @font: a #GdkFont.

 * @gc: a #GdkGC.

 * @x: the x coordinate of the left edge of the text.

 * @y: the y coordinate of the baseline of the text.

 * @text: the wide characters to draw.

 * @text_length: the number of characters to draw.

 * 

 * Draws a number of wide characters using the given font of fontset.

 * If the font is a 1-byte font, the string is converted into 1-byte 

 * characters (discarding the high bytes) before output.

 * 

 * Deprecated: 2.4: Use gdk_draw_layout() instead.

 **/

void

gdk_draw_text_wc (GdkDrawable	 *drawable,

		  GdkFont	 *font,

		  GdkGC		 *gc,

		  gint		  x,

		  gint		  y,

		  const GdkWChar *text,

		  gint		  text_length)

{

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_return_if_fail (font != NULL);

  g_return_if_fail (GDK_IS_GC (gc));

  g_return_if_fail (text != NULL);

  GDK_DRAWABLE_GET_CLASS (drawable)->draw_text_wc (drawable, font, gc, x, y, text, text_length);

}

/**

 * gdk_draw_drawable:

 * @drawable: a #GdkDrawable

 * @gc: a #GdkGC sharing the drawable's visual and colormap

 * @src: the source #GdkDrawable, which may be the same as @drawable

 * @xsrc: X position in @src of rectangle to draw

 * @ysrc: Y position in @src of rectangle to draw

 * @xdest: X position in @drawable where the rectangle should be drawn

 * @ydest: Y position in @drawable where the rectangle should be drawn

 * @width: width of rectangle to draw, or -1 for entire @src width

 * @height: height of rectangle to draw, or -1 for entire @src height

 *

 * Copies the @width x @height region of @src at coordinates (@xsrc,

 * @ysrc) to coordinates (@xdest, @ydest) in @drawable.

 * @width and/or @height may be given as -1, in which case the entire

 * @src drawable will be copied.

 *

 * Most fields in @gc are not used for this operation, but notably the

 * clip mask or clip region will be honored.

 *

 * The source and destination drawables must have the same visual and

 * colormap, or errors will result. (On X11, failure to match

 * visual/colormap results in a BadMatch error from the X server.)

 * A common cause of this problem is an attempt to draw a bitmap to

 * a color drawable. The way to draw a bitmap is to set the bitmap as 

 * the stipple on the #GdkGC, set the fill mode to %GDK_STIPPLED, and 

 * then draw the rectangle.

 *

 * Deprecated: 2.22: Use gdk_cairo_set_source_pixmap(), cairo_rectangle()

 * and cairo_fill() to draw pixmap on top of other drawables. Also keep

 * in mind that the limitations on allowed sources do not apply to Cairo.

 **/

void

gdk_draw_drawable (GdkDrawable *drawable,

		   GdkGC       *gc,

		   GdkDrawable *src,

		   gint         xsrc,

		   gint         ysrc,

		   gint         xdest,

		   gint         ydest,

		   gint         width,

		   gint         height)

{

  GdkDrawable *composite;

  gint composite_x_offset = 0;

  gint composite_y_offset = 0;

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_return_if_fail (GDK_IS_DRAWABLE (src));

  g_return_if_fail (GDK_IS_GC (gc));

  if (width < 0 || height < 0)

    {

      gint real_width;

      gint real_height;

      gdk_drawable_get_size (src, &real_width, &real_height);

      if (width < 0)

        width = real_width;

      if (height < 0)

        height = real_height;

    }

  composite =

    GDK_DRAWABLE_GET_CLASS (src)->get_composite_drawable (src,

                                                          xsrc, ysrc,

                                                          width, height,

                                                          &composite_x_offset,

                                                          &composite_y_offset);

  /* TODO: For non-native windows this may copy stuff from other overlapping

     windows. We should clip that and (for windows with bg != None) clear that

     area in the destination instead. */

  if (GDK_DRAWABLE_GET_CLASS (drawable)->draw_drawable_with_src)

    GDK_DRAWABLE_GET_CLASS (drawable)->draw_drawable_with_src (drawable, gc,

							       composite,

							       xsrc - composite_x_offset,

							       ysrc - composite_y_offset,

							       xdest, ydest,

							       width, height,

							       src);

  else /* backwards compat for old out-of-tree implementations of GdkDrawable (are there any?) */

    GDK_DRAWABLE_GET_CLASS (drawable)->draw_drawable (drawable, gc,

						      composite,

						      xsrc - composite_x_offset,

						      ysrc - composite_y_offset,

						      xdest, ydest,

						      width, height);

  g_object_unref (composite);

}

/**

 * gdk_draw_image:

 * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).

 * @gc: a #GdkGC.

 * @image: the #GdkImage to draw.

 * @xsrc: the left edge of the source rectangle within @image.

 * @ysrc: the top of the source rectangle within @image.

 * @xdest: the x coordinate of the destination within @drawable.

 * @ydest: the y coordinate of the destination within @drawable.

 * @width: the width of the area to be copied, or -1 to make the area 

 *     extend to the right edge of @image.

 * @height: the height of the area to be copied, or -1 to make the area 

 *     extend to the bottom edge of @image.

 * 

 * Draws a #GdkImage onto a drawable.

 * The depth of the #GdkImage must match the depth of the #GdkDrawable.

 *

 * Deprecated: 2.22: Do not use #GdkImage anymore, instead use Cairo image

 * surfaces.

 **/

void

gdk_draw_image (GdkDrawable *drawable,

		GdkGC       *gc,

		GdkImage    *image,

		gint         xsrc,

		gint         ysrc,

		gint         xdest,

		gint         ydest,

		gint         width,

		gint         height)

{

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_return_if_fail (GDK_IS_IMAGE (image));

  g_return_if_fail (GDK_IS_GC (gc));

  if (width == -1)

    width = image->width;

  if (height == -1)

    height = image->height;

  GDK_DRAWABLE_GET_CLASS (drawable)->draw_image (drawable, gc, image, xsrc, ysrc,

                                                 xdest, ydest, width, height);

}

/**

 * gdk_draw_pixbuf:

 * @drawable: Destination drawable.

 * @gc: (allow-none): a #GdkGC, used for clipping, or %NULL

 * @pixbuf: a #GdkPixbuf

 * @src_x: Source X coordinate within pixbuf.

 * @src_y: Source Y coordinates within pixbuf.

 * @dest_x: Destination X coordinate within drawable.

 * @dest_y: Destination Y coordinate within drawable.

 * @width: Width of region to render, in pixels, or -1 to use pixbuf width.

 * @height: Height of region to render, in pixels, or -1 to use pixbuf height.

 * @dither: Dithering mode for #GdkRGB.

 * @x_dither: X offset for dither.

 * @y_dither: Y offset for dither.

 * 

 * Renders a rectangular portion of a pixbuf to a drawable.  The destination

 * drawable must have a colormap. All windows have a colormap, however, pixmaps

 * only have colormap by default if they were created with a non-%NULL window 

 * argument. Otherwise a colormap must be set on them with 

 * gdk_drawable_set_colormap().

 *

 * On older X servers, rendering pixbufs with an alpha channel involves round 

 * trips to the X server, and may be somewhat slow.

 *

 * If GDK is built with the Sun mediaLib library, the gdk_draw_pixbuf

 * function is accelerated using mediaLib, which provides hardware

 * acceleration on Intel, AMD, and Sparc chipsets.  If desired, mediaLib

 * support can be turned off by setting the GDK_DISABLE_MEDIALIB environment

 * variable.

 *

 * Since: 2.2

 *

 * Deprecated: 2.22: Use gdk_cairo_set_source_pixbuf() and cairo_paint() or

 * cairo_rectangle() and cairo_fill() instead.

 **/

void

gdk_draw_pixbuf (GdkDrawable     *drawable,

                 GdkGC           *gc,

                 const GdkPixbuf *pixbuf,

                 gint             src_x,

                 gint             src_y,

                 gint             dest_x,

                 gint             dest_y,

                 gint             width,

                 gint             height,

                 GdkRgbDither     dither,

                 gint             x_dither,

                 gint             y_dither)

{

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_return_if_fail (gc == NULL || GDK_IS_GC (gc));

  g_return_if_fail (GDK_IS_PIXBUF (pixbuf));

  if (width == 0 || height == 0)

    return;

  if (width == -1)

    width = gdk_pixbuf_get_width (pixbuf);

  if (height == -1)

    height = gdk_pixbuf_get_height (pixbuf);

  GDK_DRAWABLE_GET_CLASS (drawable)->draw_pixbuf (drawable, gc,

                                                  (GdkPixbuf *) pixbuf,

						  src_x, src_y, dest_x, dest_y,

                                                  width, height,

						  dither, x_dither, y_dither);

}

/**

 * gdk_draw_points:

 * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).

 * @gc: a #GdkGC.

 * @points: an array of #GdkPoint structures.

 * @n_points: the number of points to be drawn.

 * 

 * Draws a number of points, using the foreground color and other 

 * attributes of the #GdkGC.

 *

 * Deprecated: 2.22: Use @n_points calls to cairo_rectangle() and

 * cairo_fill() instead.

 **/

void

gdk_draw_points (GdkDrawable    *drawable,

		 GdkGC          *gc,

		 const GdkPoint *points,

		 gint            n_points)

{

  g_return_if_fail (GDK_IS_DRAWABLE (drawable));

  g_return_if_fail ((points != NULL) && (n_points > 0));

  g_return_if_fail (GDK_IS_GC (gc));

  g_return_if_fail (n_points >= 0);

  if (n_points == 0)

    return;

  GDK_DRAWABLE_GET_CLASS (drawable)->draw_points (drawable, gc,

                                                  (GdkPoint *) points, n_points);

}

/**

 * gdk_draw_segments:

 * @drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).

 * @gc: a #GdkGC.

 * @segs: an array of #GdkSegment structures specifying the start and 

 *   end points of the lines to be drawn.

 * @n_segs: the number of line segments to draw, i.e. the size of the 

 *   @segs array.

 *