/* 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 <string.h>

#include "gdkcairo.h"

#include "gdkgc.h"

#include "gdkinternals.h"

#include "gdkpixmap.h"

#include "gdkrgb.h"

#include "gdkprivate.h"

#include "gdkalias.h"

static void gdk_gc_finalize   (GObject      *object);

typedef struct _GdkGCPrivate GdkGCPrivate;

struct _GdkGCPrivate

{

  GdkRegion *clip_region;

  guint32 region_tag_applied;

  int region_tag_offset_x;

  int region_tag_offset_y;

  GdkRegion *old_clip_region;

  GdkPixmap *old_clip_mask;

  GdkBitmap *stipple;

  GdkPixmap *tile;

  GdkPixmap *clip_mask;

  guint32 fg_pixel;

  guint32 bg_pixel;

  guint subwindow_mode : 1;

  guint fill : 2;

  guint exposures : 2;

};

#define GDK_GC_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), GDK_TYPE_GC, GdkGCPrivate))

G_DEFINE_TYPE (GdkGC, gdk_gc, G_TYPE_OBJECT)

static void

gdk_gc_class_init (GdkGCClass *class)

{

  GObjectClass *object_class = G_OBJECT_CLASS (class);

  object_class->finalize = gdk_gc_finalize;

  g_type_class_add_private (object_class, sizeof (GdkGCPrivate));

}

static void

gdk_gc_init (GdkGC *gc)

{

  GdkGCPrivate *priv = GDK_GC_GET_PRIVATE (gc);

  priv->fill = GDK_SOLID;

  /* These are the default X11 value, which we match. They are clearly

   * wrong for TrueColor displays, so apps have to change them.

   */

  priv->fg_pixel = 0;

  priv->bg_pixel = 1;

}

/**

 * gdk_gc_new:

 * @drawable: a #GdkDrawable. The created GC must always be used

 *   with drawables of the same depth as this one.

 *

 * Create a new graphics context with default values. 

 *

 * Returns: the new graphics context.

 *

 * Deprecated: 2.22: Use Cairo for rendering.

 **/

GdkGC*

gdk_gc_new (GdkDrawable *drawable)

{

  g_return_val_if_fail (drawable != NULL, NULL);

  return gdk_gc_new_with_values (drawable, NULL, 0);

}

/**

 * gdk_gc_new_with_values:

 * @drawable: a #GdkDrawable. The created GC must always be used

 *   with drawables of the same depth as this one.

 * @values: a structure containing initial values for the GC.

 * @values_mask: a bit mask indicating which fields in @values

 *   are set.

 * 

 * Create a new GC with the given initial values.

 * 

 * Return value: the new graphics context.

 *

 * Deprecated: 2.22: Use Cairo for rendering.

 **/

GdkGC*

gdk_gc_new_with_values (GdkDrawable	*drawable,

			GdkGCValues	*values,

			GdkGCValuesMask	 values_mask)

{

  g_return_val_if_fail (drawable != NULL, NULL);

  return GDK_DRAWABLE_GET_CLASS (drawable)->create_gc (drawable,

						       values,

						       values_mask);

}

/**

 * _gdk_gc_init:

 * @gc: a #GdkGC

 * @drawable: a #GdkDrawable.

 * @values: a structure containing initial values for the GC.

 * @values_mask: a bit mask indicating which fields in @values

 *   are set.

 * 

 * Does initialization of the generic portions of a #GdkGC

 * created with the specified values and values_mask. This

 * should be called out of the implementation of

 * GdkDrawable.create_gc() immediately after creating the

 * #GdkGC object.

 *

 * Deprecated: 2.22: Use Cairo for rendering.

 **/

void

_gdk_gc_init (GdkGC           *gc,

	      GdkDrawable     *drawable,

	      GdkGCValues     *values,

	      GdkGCValuesMask  values_mask)

{

  GdkGCPrivate *priv;

  g_return_if_fail (GDK_IS_GC (gc));

  priv = GDK_GC_GET_PRIVATE (gc);

  if (values_mask & GDK_GC_CLIP_X_ORIGIN)

    gc->clip_x_origin = values->clip_x_origin;

  if (values_mask & GDK_GC_CLIP_Y_ORIGIN)

    gc->clip_y_origin = values->clip_y_origin;

  if ((values_mask & GDK_GC_CLIP_MASK) && values->clip_mask)

    priv->clip_mask = g_object_ref (values->clip_mask);

  if (values_mask & GDK_GC_TS_X_ORIGIN)

    gc->ts_x_origin = values->ts_x_origin;

  if (values_mask & GDK_GC_TS_Y_ORIGIN)

    gc->ts_y_origin = values->ts_y_origin;

  if (values_mask & GDK_GC_FILL)

    priv->fill = values->fill;

  if (values_mask & GDK_GC_STIPPLE)

    {

      priv->stipple = values->stipple;

      if (priv->stipple)

	g_object_ref (priv->stipple);

    }

  if (values_mask & GDK_GC_TILE)

    {

      priv->tile = values->tile;

      if (priv->tile)

	g_object_ref (priv->tile);

    }

  if (values_mask & GDK_GC_FOREGROUND)

    priv->fg_pixel = values->foreground.pixel;

  if (values_mask & GDK_GC_BACKGROUND)

    priv->bg_pixel = values->background.pixel;

  if (values_mask & GDK_GC_SUBWINDOW)

    priv->subwindow_mode = values->subwindow_mode;

  if (values_mask & GDK_GC_EXPOSURES)

    priv->exposures = values->graphics_exposures;

  else

    priv->exposures = TRUE;

  gc->colormap = gdk_drawable_get_colormap (drawable);

  if (gc->colormap)

    g_object_ref (gc->colormap);

}

static void

gdk_gc_finalize (GObject *object)

{

  GdkGC *gc = GDK_GC (object);

  GdkGCPrivate *priv = GDK_GC_GET_PRIVATE (gc);

  if (priv->clip_region)

    gdk_region_destroy (priv->clip_region);

  if (priv->old_clip_region)

    gdk_region_destroy (priv->old_clip_region);

  if (priv->clip_mask)

    g_object_unref (priv->clip_mask);

  if (priv->old_clip_mask)

    g_object_unref (priv->old_clip_mask);

  if (gc->colormap)

    g_object_unref (gc->colormap);

  if (priv->tile)

    g_object_unref (priv->tile);

  if (priv->stipple)

    g_object_unref (priv->stipple);

  G_OBJECT_CLASS (gdk_gc_parent_class)->finalize (object);

}

/**

 * gdk_gc_ref:

 * @gc: a #GdkGC

 *

 * Deprecated function; use g_object_ref() instead.

 *

 * Return value: the gc.

 *

 * Deprecated: 2.0: Use g_object_ref() instead.

 **/

GdkGC *

gdk_gc_ref (GdkGC *gc)

{

  return (GdkGC *) g_object_ref (gc);

}

/**

 * gdk_gc_unref:

 * @gc: a #GdkGC

 *

 * Decrement the reference count of @gc.

 *

 * Deprecated: 2.0: Use g_object_unref() instead.

 **/

void

gdk_gc_unref (GdkGC *gc)

{

  g_object_unref (gc);

}

/**

 * gdk_gc_get_values:

 * @gc:  a #GdkGC.

 * @values: the #GdkGCValues structure in which to store the results.

 * 

 * Retrieves the current values from a graphics context. Note that 

 * only the pixel values of the @values->foreground and @values->background

 * are filled, use gdk_colormap_query_color() to obtain the rgb values

 * if you need them.

 *

 * Deprecated: 2.22: Use Cairo for rendering.

 **/

void

gdk_gc_get_values (GdkGC       *gc,

		   GdkGCValues *values)

{

  g_return_if_fail (GDK_IS_GC (gc));

  g_return_if_fail (values != NULL);

  GDK_GC_GET_CLASS (gc)->get_values (gc, values);

}

/**

 * gdk_gc_set_values:

 * @gc: a #GdkGC

 * @values: struct containing the new values

 * @values_mask: mask indicating which struct fields are to be used

 *

 * Sets attributes of a graphics context in bulk. For each flag set in

 * @values_mask, the corresponding field will be read from @values and

 * set as the new value for @gc. If you're only setting a few values

 * on @gc, calling individual "setter" functions is likely more

 * convenient.

 *

 * Deprecated: 2.22: Use Cairo for rendering.

 **/

void

gdk_gc_set_values (GdkGC           *gc,

		   GdkGCValues	   *values,

		   GdkGCValuesMask  values_mask)

{

  GdkGCPrivate *priv;

  g_return_if_fail (GDK_IS_GC (gc));

  g_return_if_fail (values != NULL);

  priv = GDK_GC_GET_PRIVATE (gc);

  if ((values_mask & GDK_GC_CLIP_X_ORIGIN) ||

      (values_mask & GDK_GC_CLIP_Y_ORIGIN) ||

      (values_mask & GDK_GC_CLIP_MASK) ||

      (values_mask & GDK_GC_SUBWINDOW))

    _gdk_gc_remove_drawable_clip (gc);

  if (values_mask & GDK_GC_CLIP_X_ORIGIN)

    gc->clip_x_origin = values->clip_x_origin;

  if (values_mask & GDK_GC_CLIP_Y_ORIGIN)

    gc->clip_y_origin = values->clip_y_origin;

  if (values_mask & GDK_GC_TS_X_ORIGIN)

    gc->ts_x_origin = values->ts_x_origin;

  if (values_mask & GDK_GC_TS_Y_ORIGIN)

    gc->ts_y_origin = values->ts_y_origin;

  if (values_mask & GDK_GC_CLIP_MASK)

    {

      if (priv->clip_mask)

	{

	  g_object_unref (priv->clip_mask);

	  priv->clip_mask = NULL;

	}

      if (values->clip_mask)

	priv->clip_mask = g_object_ref (values->clip_mask);

      if (priv->clip_region)

	{

	  gdk_region_destroy (priv->clip_region);

	  priv->clip_region = NULL;

	}

    }

  if (values_mask & GDK_GC_FILL)

    priv->fill = values->fill;

  if (values_mask & GDK_GC_STIPPLE)

    {

      if (priv->stipple != values->stipple)

	{

	  if (priv->stipple)

	    g_object_unref (priv->stipple);

	  priv->stipple = values->stipple;

	  if (priv->stipple)

	    g_object_ref (priv->stipple);

	}

    }

  if (values_mask & GDK_GC_TILE)

    {

      if (priv->tile != values->tile)

	{

	  if (priv->tile)

	    g_object_unref (priv->tile);

	  priv->tile = values->tile;

	  if (priv->tile)

	    g_object_ref (priv->tile);

	}

    }

  if (values_mask & GDK_GC_FOREGROUND)

    priv->fg_pixel = values->foreground.pixel;

  if (values_mask & GDK_GC_BACKGROUND)

    priv->bg_pixel = values->background.pixel;

  if (values_mask & GDK_GC_SUBWINDOW)

    priv->subwindow_mode = values->subwindow_mode;

  if (values_mask & GDK_GC_EXPOSURES)

    priv->exposures = values->graphics_exposures;

  GDK_GC_GET_CLASS (gc)->set_values (gc, values, values_mask);

}

/**

 * gdk_gc_set_foreground:

 * @gc: a #GdkGC.

 * @color: the new foreground color.

 * 

 * Sets the foreground color for a graphics context.

 * Note that this function uses @color->pixel, use 

 * gdk_gc_set_rgb_fg_color() to specify the foreground 

 * color as red, green, blue components.

 *

 * Deprecated: 2.22: Use gdk_cairo_set_source_color() to use a #GdkColor

 * as the source in Cairo.

 **/

void

gdk_gc_set_foreground (GdkGC	      *gc,

		       const GdkColor *color)

{

  GdkGCValues values;

  g_return_if_fail (GDK_IS_GC (gc));

  g_return_if_fail (color != NULL);

  values.foreground = *color;

  gdk_gc_set_values (gc, &values, GDK_GC_FOREGROUND);

}

/**

 * gdk_gc_set_background:

 * @gc: a #GdkGC.

 * @color: the new background color.

 * 

 * Sets the background color for a graphics context.

 * Note that this function uses @color->pixel, use 

 * gdk_gc_set_rgb_bg_color() to specify the background 

 * color as red, green, blue components.

 *

 * Deprecated: 2.22: Use gdk_cairo_set_source_color() to use a #GdkColor

 * as the source in Cairo. Note that if you want to draw a background and a

 * foreground in Cairo, you need to call drawing functions (like cairo_fill())

 * twice.

 **/

void

gdk_gc_set_background (GdkGC	      *gc,

		       const GdkColor *color)

{

  GdkGCValues values;

  g_return_if_fail (GDK_IS_GC (gc));

  g_return_if_fail (color != NULL);

  values.background = *color;

  gdk_gc_set_values (gc, &values, GDK_GC_BACKGROUND);

}

/**

 * gdk_gc_set_font:

 * @gc: a #GdkGC.

 * @font: the new font. 

 * 

 * Sets the font for a graphics context. (Note that

 * all text-drawing functions in GDK take a @font

 * argument; the value set here is used when that

 * argument is %NULL.)

 **/

void

gdk_gc_set_font (GdkGC	 *gc,

		 GdkFont *font)

{

  GdkGCValues values;

  g_return_if_fail (GDK_IS_GC (gc));

  g_return_if_fail (font != NULL);

  values.font = font;

  gdk_gc_set_values (gc, &values, GDK_GC_FONT);

}

/**

 * gdk_gc_set_function:

 * @gc: a #GdkGC.

 * @function: the #GdkFunction to use

 * 

 * Determines how the current pixel values and the

 * pixel values being drawn are combined to produce

 * the final pixel values.

 *

 * Deprecated: 2.22: Use cairo_set_operator() with Cairo.

 **/

void

gdk_gc_set_function (GdkGC	 *gc,

		     GdkFunction  function)

{

  GdkGCValues values;

  g_return_if_fail (GDK_IS_GC (gc));

  values.function = function;

  gdk_gc_set_values (gc, &values, GDK_GC_FUNCTION);

}

/**

 * gdk_gc_set_fill:

 * @gc: a #GdkGC.

 * @fill: the new fill mode.

 * 

 * Set the fill mode for a graphics context.

 *

 * Deprecated: 2.22: You can achieve tiling in Cairo by using

 * cairo_pattern_set_extend() on the source. For stippling, see the

 * deprecation comments on gdk_gc_set_stipple().

 **/

void

gdk_gc_set_fill (GdkGC	 *gc,

		 GdkFill  fill)

{

  GdkGCValues values;

  g_return_if_fail (GDK_IS_GC (gc));

  values.fill = fill;

  gdk_gc_set_values (gc, &values, GDK_GC_FILL);

}

/**

 * gdk_gc_set_tile:

 * @gc:  a #GdkGC.

 * @tile:  the new tile pixmap.

 * 

 * Set a tile pixmap for a graphics context.

 * This will only be used if the fill mode

 * is %GDK_TILED.

 *

 * Deprecated: 2.22: The following code snippet sets a tiling #GdkPixmap

 * as the source in Cairo:

 * |[gdk_cairo_set_source_pixmap (cr, tile, ts_origin_x, ts_origin_y);

 * cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);]|

 **/

void

gdk_gc_set_tile (GdkGC	   *gc,

		 GdkPixmap *tile)

{

  GdkGCValues values;

  g_return_if_fail (GDK_IS_GC (gc));

  values.tile = tile;

  gdk_gc_set_values (gc, &values, GDK_GC_TILE);

}

/**

 * gdk_gc_set_stipple:

 * @gc: a #GdkGC.

 * @stipple: the new stipple bitmap.

 * 

 * Set the stipple bitmap for a graphics context. The

 * stipple will only be used if the fill mode is

 * %GDK_STIPPLED or %GDK_OPAQUE_STIPPLED.

 *

 * Deprecated: 2.22: Stippling has no direct replacement in Cairo. If you

 * want to achieve an identical look, you can use the stipple bitmap as a

 * mask. Most likely, this involves rendering the source to an intermediate

 * surface using cairo_push_group() first, so that you can then use

 * cairo_mask() to achieve the stippled look.

 **/

void

gdk_gc_set_stipple (GdkGC     *gc,

		    GdkPixmap *stipple)

{

  GdkGCValues values;

  g_return_if_fail (GDK_IS_GC (gc));

  values.stipple = stipple;

  gdk_gc_set_values (gc, &values, GDK_GC_STIPPLE);

}

/**

 * gdk_gc_set_ts_origin:

 * @gc:  a #GdkGC.

 * @x: the x-coordinate of the origin.

 * @y: the y-coordinate of the origin.

 * 

 * Set the origin when using tiles or stipples with

 * the GC. The tile or stipple will be aligned such

 * that the upper left corner of the tile or stipple

 * will coincide with this point.

 *

 * Deprecated: 2.22: You can set the origin for tiles and stipples in Cairo

 * by changing the source's matrix using cairo_pattern_set_matrix(). Or you

 * can specify it with gdk_cairo_set_source_pixmap() as shown in the example

 * for gdk_gc_set_tile().

 **/

void

gdk_gc_set_ts_origin (GdkGC *gc,

		      gint   x,

		      gint   y)

{

  GdkGCValues values;

  g_return_if_fail (GDK_IS_GC (gc));

  values.ts_x_origin = x;

  values.ts_y_origin = y;

  gdk_gc_set_values (gc, &values,

		     GDK_GC_TS_X_ORIGIN | GDK_GC_TS_Y_ORIGIN);

}

/**

 * gdk_gc_set_clip_origin:

 * @gc: a #GdkGC.

 * @x: the x-coordinate of the origin.

 * @y: the y-coordinate of the origin.

 * 

 * Sets the origin of the clip mask. The coordinates are

 * interpreted relative to the upper-left corner of

 * the destination drawable of the current operation.

 *

 * Deprecated: 2.22: Use cairo_translate() before applying the clip path in

 * Cairo.

 **/

void

gdk_gc_set_clip_origin (GdkGC *gc,

			gint   x,

			gint   y)

{

  GdkGCValues values;

  g_return_if_fail (GDK_IS_GC (gc));

  values.clip_x_origin = x;

  values.clip_y_origin = y;

  gdk_gc_set_values (gc, &values,

		     GDK_GC_CLIP_X_ORIGIN | GDK_GC_CLIP_Y_ORIGIN);

}

/**

 * gdk_gc_set_clip_mask:

 * @gc: the #GdkGC.

 * @mask: a bitmap.

 * 

 * Sets the clip mask for a graphics context from a bitmap.

 * The clip mask is interpreted relative to the clip

 * origin. (See gdk_gc_set_clip_origin()).

 *

 * Deprecated: 2.22: Use cairo_mask() instead.

 **/

void

gdk_gc_set_clip_mask (GdkGC	*gc,

		      GdkBitmap *mask)

{

  GdkGCValues values;

  g_return_if_fail (GDK_IS_GC (gc));

  values.clip_mask = mask;

  gdk_gc_set_values (gc, &values, GDK_GC_CLIP_MASK);

}

/* Takes ownership of passed in region */

static void

_gdk_gc_set_clip_region_real (GdkGC     *gc,

			      GdkRegion *region,

			      gboolean reset_origin)

{

  GdkGCPrivate *priv = GDK_GC_GET_PRIVATE (gc);

  if (priv->clip_mask)

    {

      g_object_unref (priv->clip_mask);

      priv->clip_mask = NULL;

    }

  if (priv->clip_region)

    gdk_region_destroy (priv->clip_region);

  priv->clip_region = region;

  _gdk_windowing_gc_set_clip_region (gc, region, reset_origin);

}

/* Doesn't copy region, allows not to reset origin */

void

_gdk_gc_set_clip_region_internal (GdkGC     *gc,

				  GdkRegion *region,

				  gboolean reset_origin)

{

  _gdk_gc_remove_drawable_clip (gc);

  _gdk_gc_set_clip_region_real (gc, region, reset_origin);

}

void

_gdk_gc_add_drawable_clip (GdkGC     *gc,

			   guint32    region_tag,

			   GdkRegion *region,

			   int        offset_x,

			   int        offset_y)

{

  GdkGCPrivate *priv = GDK_GC_GET_PRIVATE (gc);

  if (priv->region_tag_applied == region_tag &&

      offset_x == priv->region_tag_offset_x &&

      offset_y == priv->region_tag_offset_y)

    return; /* Already appied this drawable region */

  if (priv->region_tag_applied)

    _gdk_gc_remove_drawable_clip (gc);

  region = gdk_region_copy (region);

  if (offset_x != 0 || offset_y != 0)

    gdk_region_offset (region, offset_x, offset_y);

  if (priv->clip_mask)

    {

      int w, h;

      GdkPixmap *new_mask;

      GdkGC *tmp_gc;

      GdkColor black = {0, 0, 0, 0};

      GdkRectangle r;

      GdkOverlapType overlap;

      gdk_drawable_get_size (priv->clip_mask, &w, &h);

      r.x = 0;

      r.y = 0;

      r.width = w;

      r.height = h;

      /* Its quite common to expose areas that are completely in or outside

       * the region, so we try to avoid allocating bitmaps that are just fully

       * set or completely unset.

       */

      overlap = gdk_region_rect_in (region, &r);

      if (overlap == GDK_OVERLAP_RECTANGLE_PART)

	{

	   /* The region and the mask intersect, create a new clip mask that

	      includes both areas */

	  priv->old_clip_mask = g_object_ref (priv->clip_mask);

	  new_mask = gdk_pixmap_new (priv->old_clip_mask, w, h, -1);

	  tmp_gc = _gdk_drawable_get_scratch_gc ((GdkDrawable *)new_mask, FALSE);

	  gdk_gc_set_foreground (tmp_gc, &black);

	  gdk_draw_rectangle (new_mask, tmp_gc, TRUE, 0, 0, -1, -1);

	  _gdk_gc_set_clip_region_internal (tmp_gc, region, TRUE); /* Takes ownership of region */

	  gdk_draw_drawable  (new_mask,

			      tmp_gc,

			      priv->old_clip_mask,

			      0, 0,

			      0, 0,

			      -1, -1);

	  gdk_gc_set_clip_region (tmp_gc, NULL);

	  gdk_gc_set_clip_mask (gc, new_mask);

	  g_object_unref (new_mask);

	}

      else if (overlap == GDK_OVERLAP_RECTANGLE_OUT)

	{

	  /* No intersection, set empty clip region */

	  GdkRegion *empty = gdk_region_new ();

	  gdk_region_destroy (region);

	  priv->old_clip_mask = g_object_ref (priv->clip_mask);

	  priv->clip_region = empty;

	  _gdk_windowing_gc_set_clip_region (gc, empty, FALSE);

	}

      else

	{

	  /* Completely inside region, don't set unnecessary clip */

	  gdk_region_destroy (region);

	  return;

	}

    }

  else

    {

      priv->old_clip_region = priv->clip_region;

      priv->clip_region = region;

      if (priv->old_clip_region)

	gdk_region_intersect (region, priv->old_clip_region);

      _gdk_windowing_gc_set_clip_region (gc, priv->clip_region, FALSE);

    }

  priv->region_tag_applied = region_tag;

  priv->region_tag_offset_x = offset_x;

  priv->region_tag_offset_y = offset_y;

}

void

_gdk_gc_remove_drawable_clip (GdkGC *gc)

{

  GdkGCPrivate *priv = GDK_GC_GET_PRIVATE (gc);

  if (priv->region_tag_applied)

    {

      priv->region_tag_applied = 0;

      if (priv->old_clip_mask)

	{

	  gdk_gc_set_clip_mask (gc, priv->old_clip_mask);

	  g_object_unref (priv->old_clip_mask);

	  priv->old_clip_mask = NULL;

	  if (priv->clip_region)

	    {

	      g_object_unref (priv->clip_region);

	      priv->clip_region = NULL;

	    }

	}

      else

	{

	  _gdk_gc_set_clip_region_real (gc, priv->old_clip_region, FALSE);

	  priv->old_clip_region = NULL;

	}

    }

}

/**

 * gdk_gc_set_clip_rectangle:

 * @gc: a #GdkGC.

 * @rectangle: the rectangle to clip to.

 * 

 * Sets the clip mask for a graphics context from a

 * rectangle. The clip mask is interpreted relative to the clip

 * origin. (See gdk_gc_set_clip_origin()).

 *

 * Deprecated: 2.22: Use cairo_rectangle() and cairo_clip() in Cairo.

 **/

void

gdk_gc_set_clip_rectangle (GdkGC              *gc,

			   const GdkRectangle *rectangle)

{

  GdkRegion *region;

  g_return_if_fail (GDK_IS_GC (gc));

  _gdk_gc_remove_drawable_clip (gc);

  if (rectangle)

    region = gdk_region_rectangle (rectangle);

  else

    region = NULL;

  _gdk_gc_set_clip_region_real (gc, region, TRUE);

}

/**

 * gdk_gc_set_clip_region:

 * @gc: a #GdkGC.

 * @region: the #GdkRegion. 

 * 

 * Sets the clip mask for a graphics context from a region structure.

 * The clip mask is interpreted relative to the clip origin. (See

 * gdk_gc_set_clip_origin()).

 *

 * Deprecated: 2.22: Use gdk_cairo_region() and cairo_clip() in Cairo.

 **/

void

gdk_gc_set_clip_region (GdkGC           *gc,

			const GdkRegion *region)

{

  GdkRegion *copy;

  g_return_if_fail (GDK_IS_GC (gc));

  _gdk_gc_remove_drawable_clip (gc);

  if (region)

    copy = gdk_region_copy (region);

  else

    copy = NULL;

  _gdk_gc_set_clip_region_real (gc, copy, TRUE);

}

/**

 * _gdk_gc_get_clip_region:

 * @gc: a #GdkGC

 * 

 * Gets the current clip region for @gc, if any.

 * 

 * Return value: the clip region for the GC, or %NULL.

 *   (if a clip mask is set, the return will be %NULL)

 *   This value is owned by the GC and must not be freed.

 **/

GdkRegion *

_gdk_gc_get_clip_region (GdkGC *gc)

{

  g_return_val_if_fail (GDK_IS_GC (gc), NULL);

  return GDK_GC_GET_PRIVATE (gc)->clip_region;

}

/**

 * _gdk_gc_get_clip_mask:

 * @gc: a #GdkGC

 *

 * Gets the current clip mask for @gc, if any.

 *

 * Return value: the clip mask for the GC, or %NULL.

 *   (if a clip region is set, the return will be %NULL)

 *   This value is owned by the GC and must not be freed.

 **/

GdkBitmap *

_gdk_gc_get_clip_mask (GdkGC *gc)

{

  g_return_val_if_fail (GDK_IS_GC (gc), NULL);