X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;ds=sidebyside;f=gdk%2Fgdkdraw.c;h=4946596121b7854835da29ae9a902b2c702f1109;hb=451b224324864047842dfe009834a0fe53728147;hp=03517f48a06353670eced1b955ec3c8c685169cd;hpb=4fe58c01f9c9af6e711e319d2d03aaccf411d0a8;p=~andy%2Fgtk

diff --git a/gdk/gdkdraw.c b/gdk/gdkdraw.c
index 03517f48a..494659612 100644
--- a/gdk/gdkdraw.c
+++ b/gdk/gdkdraw.c
@@ -2,23 +2,23 @@
  * 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 Library General Public
+ * 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
- * Library General Public License for more details.
+ * Lesser General Public License for more details.
  *
- * You should have received a copy of the GNU Library General Public
+ * 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-1999.  See the AUTHORS
+ * 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/. 
@@ -28,118 +28,225 @@
 #include "gdkinternals.h"
 #include "gdkwindow.h"
 
-/* Manipulation of drawables
- */
-GdkDrawable *
-gdk_drawable_alloc (void)
-{
-  GdkDrawablePrivate *private = g_new (GdkDrawablePrivate, 1);
-  GdkDrawable *drawable = (GdkDrawable*) private;
-  
-  drawable->user_data = NULL;
-
-  private->ref_count = 1;
-  private->destroyed = FALSE;
-  private->klass = NULL;
-  private->klass_data = NULL;
-  private->window_type = GDK_WINDOW_CHILD;
+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);
 
-  private->width = 1;
-  private->height = 1;
+static void gdk_drawable_class_init (GdkDrawableClass *klass);
 
-  private->depth = 0;
+GType
+gdk_drawable_get_type (void)
+{
+  static GType object_type = 0;
 
-  private->colormap = NULL;
+  if (!object_type)
+    {
+      static const GTypeInfo object_info =
+      {
+        sizeof (GdkDrawableClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gdk_drawable_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkDrawable),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) NULL,
+      };
+      
+      object_type = g_type_register_static (G_TYPE_OBJECT,
+                                            "GdkDrawable",
+                                            &object_info, 0);
+    }  
+
+  return object_type;
+}
 
-  return drawable;
+static void
+gdk_drawable_class_init (GdkDrawableClass *klass)
+{
+  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;
 }
 
+/* Manipulation of drawables
+ */
+
+/**
+ * gdk_drawable_set_data:
+ * @drawable: a #GdkDrawable
+ * @key: name to store the data under
+ * @data: arbitrary data
+ * @destroy_func: 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_dataset_set_data_full (drawable, key, data, 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)
 {
-  return g_dataset_get_data (drawable, key);
-}
-
-GdkDrawableType
-gdk_drawable_get_type (GdkDrawable *drawable)
-{
-  g_return_val_if_fail (drawable != NULL, (GdkDrawableType) -1);
+  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
   
-  return GDK_DRAWABLE_TYPE (drawable);
+  return g_object_get_qdata (G_OBJECT (drawable),
+                             g_quark_try_string (key));
 }
 
+/**
+ * gdk_drawable_get_size:
+ * @drawable: a #GdkDrawable
+ * @width: location to store drawable's width, or %NULL
+ * @height: 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.
+ * 
+ **/
 void
 gdk_drawable_get_size (GdkDrawable *drawable,
 		       gint        *width,
 		       gint        *height)
 {
-  GdkDrawablePrivate *drawable_private;
-  
-  g_return_if_fail (drawable != NULL);
-  
-  drawable_private = (GdkDrawablePrivate*) drawable;
-  
-  if (width)
-    *width = drawable_private->width;
-  if (height)
-    *height = drawable_private->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
+ **/
 GdkVisual*
 gdk_drawable_get_visual (GdkDrawable *drawable)
 {
-  GdkColormap *colormap;
-
-  g_return_val_if_fail (drawable != NULL, NULL);
-
-  colormap = gdk_drawable_get_colormap (drawable);
-  return colormap ? gdk_colormap_get_visual (colormap) : NULL;
+  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)
 {
-  GdkDrawablePrivate *private = (GdkDrawablePrivate *)drawable;
-  g_return_val_if_fail (drawable != NULL, 0);
+  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), 0);
 
-  return private->depth;
+  return GDK_DRAWABLE_GET_CLASS (drawable)->get_depth (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));
+
+  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
+ **/
 GdkDrawable*
 gdk_drawable_ref (GdkDrawable *drawable)
 {
-  GdkDrawablePrivate *private = (GdkDrawablePrivate *)drawable;
-  g_return_val_if_fail (drawable != NULL, NULL);
-  
-  private->ref_count += 1;
-  return drawable;
+  return (GdkDrawable *) g_object_ref (G_OBJECT (drawable));
 }
 
+/**
+ * gdk_drawable_unref:
+ * @drawable: a #GdkDrawable
+ * 
+ * Deprecated equivalent of calling g_object_unref() on @drawable.
+ * 
+ **/
 void
 gdk_drawable_unref (GdkDrawable *drawable)
 {
-  GdkDrawablePrivate *private = (GdkDrawablePrivate *)drawable;
-  
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (private->ref_count > 0);
-  
-  private->ref_count -= 1;
-  if (private->ref_count == 0)
-    {
-      private->klass->destroy (drawable);
-      g_dataset_destroy (drawable);
-      g_free (drawable);
-    }
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+
+  g_object_unref (G_OBJECT (drawable));
 }
 
 /* Drawing
@@ -150,20 +257,15 @@ gdk_draw_point (GdkDrawable *drawable,
                 gint         x,
                 gint         y)
 {
-  GdkGCPrivate *gc_private;
   GdkPoint point;
 
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (gc != NULL);
-
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-  gc_private = (GdkGCPrivate*) gc;
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+  g_return_if_fail (GDK_IS_GC (gc));
 
   point.x = x;
   point.y = y;
   
-  ((GdkDrawablePrivate *)drawable)->klass->draw_points (drawable, gc, &point, 1);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_points (drawable, gc, &point, 1);
 }
 
 void
@@ -174,21 +276,18 @@ gdk_draw_line (GdkDrawable *drawable,
 	       gint         x2,
 	       gint         y2)
 {
-  GdkGCPrivate *gc_private;
   GdkSegment segment;
 
   g_return_if_fail (drawable != NULL);
   g_return_if_fail (gc != NULL);
-
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-  gc_private = (GdkGCPrivate*) gc;
+  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;
-  ((GdkDrawablePrivate *)drawable)->klass->draw_segments (drawable, gc, &segment, 1);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_segments (drawable, gc, &segment, 1);
 }
 
 void
@@ -199,23 +298,25 @@ gdk_draw_rectangle (GdkDrawable *drawable,
 		    gint         y,
 		    gint         width,
 		    gint         height)
-{
-  GdkDrawablePrivate *drawable_private;
-
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (gc != NULL);
-
-  drawable_private = (GdkDrawablePrivate*) drawable;
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
+{  
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+  g_return_if_fail (GDK_IS_GC (gc));
 
-  if (width < 0)
-    width = drawable_private->width;
-  if (height < 0)
-    height = drawable_private->height;
+  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;
+    }
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_rectangle (drawable, gc, filled, x, y,
-							   width, height);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_rectangle (drawable, gc, filled, x, y,
+                                                     width, height);
 }
 
 void
@@ -228,25 +329,25 @@ gdk_draw_arc (GdkDrawable *drawable,
 	      gint         height,
 	      gint         angle1,
 	      gint         angle2)
-{
-  GdkDrawablePrivate *drawable_private;
-  GdkGCPrivate *gc_private;
-
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (gc != NULL);
+{  
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+  g_return_if_fail (GDK_IS_GC (gc));
 
-  drawable_private = (GdkDrawablePrivate*) drawable;
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-  gc_private = (GdkGCPrivate*) gc;
-
-  if (width < 0)
-    width = drawable_private->width;
-  if (height < 0)
-    height = drawable_private->height;
+  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;
+    }
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_arc (drawable, gc, filled,
-						     x, y, width, height, angle1, angle2);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_arc (drawable, gc, filled,
+                                               x, y, width, height, angle1, angle2);
 }
 
 void
@@ -256,14 +357,11 @@ gdk_draw_polygon (GdkDrawable *drawable,
 		  GdkPoint    *points,
 		  gint         npoints)
 {
-  g_return_if_fail (drawable != NULL);
-  g_return_if_fail (gc != NULL);
-
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+  g_return_if_fail (GDK_IS_GC (gc));
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_polygon (drawable, gc, filled,
-							 points, npoints);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_polygon (drawable, gc, filled,
+                                                   points, npoints);
 }
 
 /* gdk_draw_string
@@ -298,12 +396,12 @@ gdk_draw_text (GdkDrawable *drawable,
 	       const gchar *text,
 	       gint         text_length)
 {
-  g_return_if_fail (drawable != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
   g_return_if_fail (font != NULL);
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (text != NULL);
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_text (drawable, font, gc, x, y, text, text_length);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_text (drawable, font, gc, x, y, text, text_length);
 }
 
 void
@@ -315,12 +413,12 @@ gdk_draw_text_wc (GdkDrawable	 *drawable,
 		  const GdkWChar *text,
 		  gint		  text_length)
 {
-  g_return_if_fail (drawable != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
   g_return_if_fail (font != NULL);
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (text != NULL);
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_text_wc (drawable, font, gc, x, y, text, text_length);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_text_wc (drawable, font, gc, x, y, text, text_length);
 }
 
 void
@@ -334,21 +432,43 @@ gdk_draw_drawable (GdkDrawable *drawable,
 		   gint         width,
 		   gint         height)
 {
-  g_return_if_fail (drawable != NULL);
+  GdkDrawable *composite;
+  gint composite_x_offset = 0;
+  gint composite_y_offset = 0;
+
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
   g_return_if_fail (src != NULL);
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
 
-  if (GDK_DRAWABLE_DESTROYED (drawable) || GDK_DRAWABLE_DESTROYED (src))
-    return;
+  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;
+    }
 
-  if (width == -1)
-    width = ((GdkDrawablePrivate *)src)->width;
-  if (height == -1)
-    height = ((GdkDrawablePrivate *)src)->height;
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_drawable (drawable, gc, src,
-							  xsrc, ysrc, xdest, ydest,
-							  width, height);
+  composite =
+    GDK_DRAWABLE_GET_CLASS (src)->get_composite_drawable (src,
+                                                          xsrc, ysrc,
+                                                          width, height,
+                                                          &composite_x_offset,
+                                                          &composite_y_offset);
+
+  
+  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 (G_OBJECT (composite));
 }
 
 void
@@ -362,26 +482,17 @@ gdk_draw_image (GdkDrawable *drawable,
 		gint         width,
 		gint         height)
 {
-  GdkImagePrivate *image_private;
-
-  g_return_if_fail (drawable != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
   g_return_if_fail (image != NULL);
-  g_return_if_fail (gc != NULL);
-
-  image_private = (GdkImagePrivate*) image;
+  g_return_if_fail (GDK_IS_GC (gc));
 
   if (width == -1)
     width = image->width;
   if (height == -1)
     height = image->height;
 
-
-  if (GDK_IS_WINDOW (drawable))
-    _gdk_window_draw_image (drawable, gc, image, xsrc, ysrc,
-			    xdest, ydest, width, height);
-  else
-    image_private->klass->image_put (image, drawable, gc, xsrc, ysrc,
-				     xdest, ydest, width, height);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_image (drawable, gc, image, xsrc, ysrc,
+                                                 xdest, ydest, width, height);
 }
 
 void
@@ -390,18 +501,15 @@ gdk_draw_points (GdkDrawable *drawable,
 		 GdkPoint    *points,
 		 gint         npoints)
 {
-  g_return_if_fail (drawable != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
   g_return_if_fail ((points != NULL) && (npoints > 0));
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (npoints >= 0);
 
   if (npoints == 0)
     return;
 
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-
-  ((GdkDrawablePrivate *)drawable)->klass->draw_points (drawable, gc, points, npoints);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_points (drawable, gc, points, npoints);
 }
 
 void
@@ -410,19 +518,16 @@ gdk_draw_segments (GdkDrawable *drawable,
 		   GdkSegment  *segs,
 		   gint         nsegs)
 {
-  g_return_if_fail (drawable != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
 
   if (nsegs == 0)
     return;
 
   g_return_if_fail (segs != NULL);
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (nsegs >= 0);
 
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
-
-  ((GdkDrawablePrivate *)drawable)->klass->draw_segments (drawable, gc, segs, nsegs);
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_segments (drawable, gc, segs, nsegs);
 }
 
 void
@@ -432,16 +537,179 @@ gdk_draw_lines (GdkDrawable *drawable,
 		gint         npoints)
 {
 
-  g_return_if_fail (drawable != NULL);
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
   g_return_if_fail (points != NULL);
-  g_return_if_fail (gc != NULL);
+  g_return_if_fail (GDK_IS_GC (gc));
   g_return_if_fail (npoints >= 0);
 
   if (npoints == 0)
     return;
 
-  if (GDK_DRAWABLE_DESTROYED (drawable))
-    return;
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_lines (drawable, gc, points, npoints);
+}
+
+void
+gdk_draw_glyphs (GdkDrawable      *drawable,
+		 GdkGC            *gc,
+		 PangoFont        *font,
+		 gint              x,
+		 gint              y,
+		 PangoGlyphString *glyphs)
+{
+  g_return_if_fail (GDK_IS_DRAWABLE (drawable));
+  g_return_if_fail (GDK_IS_GC (gc));
+
+
+  GDK_DRAWABLE_GET_CLASS (drawable)->draw_glyphs (drawable, gc, font, x, y, glyphs);
+}
+
+
+/**
+ * gdk_drawable_get_image:
+ * @drawable: a #GdkDrawable
+ * @x: x coordinate on @drawable
+ * @y: y coordinate on @drawable
+ * @width: width of region to get
+ * @height: height or region to get
+ * 
+ * A #GdkImage stores client-side image data (pixels). In contrast,
+ * #GdkPixmap and #GdkWindow are server-side
+ * objects. gdk_drawable_get_image() obtains the pixels from a
+ * server-side drawable as a client-side #GdkImage.  The format of a
+ * #GdkImage depends on the #GdkVisual of the current display, which
+ * makes manipulating #GdkImage extremely difficult; therefore, in
+ * most cases you should use gdk_pixbuf_get_from_drawable() instead of
+ * this lower-level function. A #GdkPixbuf contains image data in a
+ * canonicalized RGB format, rather than a display-dependent format.
+ * Of course, there's a convenience vs. speed tradeoff here, so you'll
+ * want to think about what makes sense for your application.
+ *
+ * @x, @y, @width, and @height define the region of @drawable to
+ * obtain as an image.
+ *
+ * You would usually copy image data to the client side if you intend
+ * to examine the values of individual pixels, for example to darken
+ * an image or add a red tint. It would be prohibitively slow to
+ * make a round-trip request to the windowing system for each pixel,
+ * so instead you get all of them at once, modify them, then copy
+ * them all back at once.
+ *
+ * If the X server or other windowing system backend is on the local
+ * machine, this function may use shared memory to avoid copying
+ * the image data.
+ * 
+ * Return value: a #GdkImage containing the contents of @drawable
+ **/
+GdkImage*
+gdk_drawable_get_image (GdkDrawable *drawable,
+                        gint         x,
+                        gint         y,
+                        gint         width,
+                        gint         height)
+{
+  GdkDrawable *composite;
+  gint composite_x_offset = 0;
+  gint composite_y_offset = 0;
+  GdkImage *retval;
+  
+  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
+  g_return_val_if_fail (x >= 0, NULL);
+  g_return_val_if_fail (y >= 0, NULL);
+
+  /* FIXME? Note race condition since we get the size then
+   * get the image, and the size may have changed.
+   */
+  
+  if (width < 0 || height < 0)
+    gdk_drawable_get_size (drawable,
+                           width < 0 ? &width : NULL,
+                           height < 0 ? &height : NULL);
+  
+  composite =
+    GDK_DRAWABLE_GET_CLASS (drawable)->get_composite_drawable (drawable,
+                                                               x, y,
+                                                               width, height,
+                                                               &composite_x_offset,
+                                                               &composite_y_offset); 
+  
+  retval = GDK_DRAWABLE_GET_CLASS (composite)->get_image (composite,
+                                                          x - composite_x_offset,
+                                                          y - composite_y_offset,
+                                                          width, height);
+
+  g_object_unref (G_OBJECT (composite));
+
+  return retval;
+}
+
+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)
+{
+  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
+
+  *composite_x_offset = 0;
+  *composite_y_offset = 0;
+  
+  return GDK_DRAWABLE (g_object_ref (G_OBJECT (drawable)));
+}
+
+/**
+ * gdk_drawable_get_clip_region:
+ * @drawable: a #GdkDrawable
+ * 
+ * Computes the region of a drawable that potentially can be written
+ * to by drawing primitives. This region will not take into account
+ * the clip region for the GC, and may also not take into account
+ * other factors such as if the window is obscured by other windows,
+ * but no area outside of this region will be affected by drawing
+ * primitives.
+ * 
+ * Return value: a #GdkRegion. This must be freed with gdk_region_destroy()
+ *               when you are done.
+ **/
+GdkRegion *
+gdk_drawable_get_clip_region (GdkDrawable *drawable)
+{
+  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
+
+  return GDK_DRAWABLE_GET_CLASS (drawable)->get_clip_region (drawable);
+}
+
+/**
+ * gdk_drawable_get_visible_region:
+ * @drawable: 
+ * 
+ * Computes the region of a drawable that is potentially visible.
+ * This does not necessarily take into account if the window is
+ * obscured by other windows, but no area outside of this region
+ * is visible.
+ * 
+ * Return value: a #GdkRegion. This must be freed with gdk_region_destroy()
+ *               when you are done.
+ **/
+GdkRegion *
+gdk_drawable_get_visible_region (GdkDrawable *drawable)
+{
+  g_return_val_if_fail (GDK_IS_DRAWABLE (drawable), NULL);
+
+  return GDK_DRAWABLE_GET_CLASS (drawable)->get_visible_region (drawable);
+}
+
+static GdkRegion *
+gdk_drawable_real_get_visible_region (GdkDrawable *drawable)
+{
+  GdkRectangle rect;
+
+  rect.x = 0;
+  rect.y = 0;
+
+  gdk_drawable_get_size (drawable, &rect.width, &rect.height);
 
-  ((GdkDrawablePrivate *)drawable)->klass->draw_lines (drawable, gc, points, npoints);
+  return gdk_region_rectangle (&rect);
 }