GtkApplication rewrite

Makefile.decl

@@ -30,17 +30,13 @@ XVFB_START = \
 # call as: $(XVFB_START) && someprogram
 
 # test: run all tests in cwd and subdirs
-test: test-cwd test-recurse
-# test-cwd: run tests in cwd
-test-cwd: ${TEST_PROGS}
+test:	${TEST_PROGS}
 	@$(SKIP_GDKTARGET) || test -z "${TEST_PROGS}" || { \
-	  $(XVFB_START) && { set -e; $(TESTS_ENVIRONMENT) ${GTESTER} --verbose ${TEST_PROGS}; }; \
+	  $(XVFB_START) && { set -e; ${GTESTER} --verbose ${TEST_PROGS}; }; \
 	}
-# test-recurse: run tests in subdirs
-test-recurse:
 	@ for subdir in $(SUBDIRS) ; do \
 	    test "$$subdir" = "." -o "$$subdir" = "po" -o "$$subdir" = "po-properties" || \
-	    ( cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) test ) || exit $? ; \
+	    ( cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $@ ) || exit $? ; \
 	  done
 # test-report: run tests in subdirs and generate report
 # perf-report: run tests in subdirs with -m perf and generate report
@@ -81,6 +77,6 @@ test-report perf-report full-report:	${TEST_PROGS}
 	    rm -rf "$$GTESTER_LOGDIR"/ ; \
 	    ${GTESTER_REPORT} --version 2>/dev/null 1>&2 ; test "$$?" != 0 || ${GTESTER_REPORT} $@.xml >$@.html ; \
 	  }
-.PHONY: test test-cwd test-recurse test-report perf-report full-report
-# run make test-cwd as part of make check
-check-local: test-cwd
+.PHONY: test test-report perf-report full-report
+# run make test as part of make check
+check-local: test

NEWS

@@ -1,103 +1,3 @@
-Overview of Changes from GTK+ 2.90.5 to 2.90.6
-==============================================
-
-* All drawing done by GTK+ itself has been ported from
-  GDK drawing APIs to cairo
-
-* GtkExpander and GtkFrame now implement GtkSizeRequest
-
-* GtkExpander gained a ::label-fill property to make the label
-  fill the entire horizontal space
-
-* Allow windows to be dragged by clicking on empty
-  areas in menubars and toolbars
-
-* GtkAboutDialog can now refer to licenses using a ::license-type
-  enumeration instead of embedding the license text
-
-* Deprecations and cleanups:
- - Remove GtkNotebookPage
- - Remove public struct members in many classes
- - Remove the GtkRecentManager::limit property
- - Remove all GDK drawing functions, ie gdk_draw_*. Use cairo instead
- - Remove all GdkGC functions. Use cairo instead
- - Remove all of GdkImage. Use cairo instead
- - Remove all of GdkRGB. Use cairo instead
- - Remove gdk_{bit,pix}map_create_from_data
- - GDK no longer depends on the render X extension
-
-* New accessors:
- - gdk_cursor_get_cursor_type
- - gdk_device_get_n_axes
- - gdk_display_is_closed
- - gtk_notebook_get_tab_[hv]border
-
-* New cairo-related APIs:
- - gdk_window_create_similar_surface
- - gdk_window_get_background_pattern
-
-* Bugs fixed:
-  90935 GtkIMContextClass inheritance ...
-  97414 gtkaccellabel: s/seperator/separator/
- 336225 Support for common licenses in about dialog
- 554926 gtk_init_with_args: not setting translation domain...
- 557263 Notebooks return 1 selection even if they have no pages
- 579583 GtkStatusIcon's scroll-event documentation missing "Since: ..."
- 580291 Gail does not work with custom treemodels
- 596125 Property string fixes
- 604391 Gtk-CRITICAL when switching between tab
- 605190 Should delete the description of xim related options...
- 609264 gtk_(tree/list)_store_set documentation unclear about ownership
- 611313 Window dragging from menubars/toolbars
- 612919 crash in System Monitor: I was moving up-down wit...
- 614049 Allow packing options for GtkExpander label widgets
- 614443 Doxygen 'forgets' #define documentation under certain conditions
- 615474 gtk_widget_set_has_window() documentation is not correct
- 618327 GtkNotebookPage should be deprecated
- 621571 Fix damage events on offscreen windows
- 622658 GTK_STOCK_FILE Stock Label
- 623603 meld built with pygtk-2.16.0 giving warnings
- 623865 gtkdnd: pointer grab may never finish (ungrab before grab)
- 624087 Missing accessor for GdkCursor.type
- 624224 Missing accessor for GdkDisplay.closed
- 624270 crash in gtk_entry_completion_default_completion_func
- 624333 Deprecate GtkRecentManager:limit
- 624362 access an invalid ActionGroup
- 624367 GtkButtonBox is broken
- 624397 Move GtkBoxChild from public .h to gtkbox.c
- 624432 GtkRadioMenuItem is broken
- 624540 GtkRadionAction loop in its activate handler
- 624687 switch-page bug when activated from menu
- 624707 warnings when showing gnome-terminal menus on gtk master
- 624779 GtkCalendar padding/margin/spacing/border/whatever is hard-coded
- 625104 Don't try and use the child of a GtkSeparatorMenuItem
- 625235 Tooltips cause warnings
- 625300 Buttons order in dialogs broken in gtk+3
- 625416 gtk_file_chooser_default_map should not reload directory
- 625650 Add annotations to gtk_tree_model_iter_next() and...
- 625655 win32 compile failure due to G_SEAL
- 625715 comment string in GtkAboutDialog is not centered
- 625953 GailAdjustment does not implement get_minimum_increment...
- 626052 Activating a file in GtkFileChooserDialog activates action...
- 626276 gtk_tree_selection_set_select_function() should allow...
- 626514 License dialog doesn't take into account long copyrights
-
-* Translation updates:
- Asturian
- Galician
- German
- Hebrew
- Indonesian
- Norwegian bokmål
- Punjabi
- Romanian
- Simplified Chinese
- Slovenian
- Spanish
- Swedish
- Traditional Chinese
-
-
 Overview of Changes from GTK+ 2.90.4 to 2.90.5
 ==============================================
 

build/win32/vs9/gdk-win32.vcproj

@@ -134,6 +134,7 @@
 			<File RelativePath="..\..\..\gdk\win32\gdkgeometry-win32.c" />
 			<File RelativePath="..\..\..\gdk\win32\gdkglobals-win32.c" />
 			<File RelativePath="..\..\..\gdk\win32\gdkim-win32.c" />
+			<File RelativePath="..\..\..\gdk\win32\gdkimage-win32.c" />
 			<File RelativePath="..\..\..\gdk\win32\gdkinput-win32.c" />
 			<File RelativePath="..\..\..\gdk\win32\gdkinput.c" />
 			<File RelativePath="..\..\..\gdk\win32\gdkkeys-win32.c" />

build/win32/vs9/gtk+.vsprops

@@ -108,6 +108,7 @@ copy ..\..\..\gdk\gdkevents.h $(OutDir)\include\gtk-$(GtkApiVersion)\gdk
&#
 copy ..\..\..\gdk\gdkfont.h $(OutDir)\include\gtk-$(GtkApiVersion)\gdk

 copy ..\..\..\gdk\gdkgc.h $(OutDir)\include\gtk-$(GtkApiVersion)\gdk

 copy ..\..\..\gdk\gdki18n.h $(OutDir)\include\gtk-$(GtkApiVersion)\gdk

+copy ..\..\..\gdk\gdkimage.h $(OutDir)\include\gtk-$(GtkApiVersion)\gdk

 copy ..\..\..\gdk\gdkinput.h $(OutDir)\include\gtk-$(GtkApiVersion)\gdk

 copy ..\..\..\gdk\gdkkeys.h $(OutDir)\include\gtk-$(GtkApiVersion)\gdk

 copy ..\..\..\gdk\gdkkeysyms.h $(OutDir)\include\gtk-$(GtkApiVersion)\gdk


configure.ac

@@ -31,7 +31,7 @@ m4_define([gtk_api_version], [3.0])
 m4_define([gtk_binary_version], [3.0.0])
 
 # required versions of other packages
-m4_define([glib_required_version], [2.25.11])
+m4_define([glib_required_version], [2.25.12])
 m4_define([pango_required_version], [1.20])
 m4_define([atk_required_version], [1.29.2])
 m4_define([cairo_required_version], [1.9.10])
@@ -942,11 +942,11 @@ if test "x$gdktarget" = "xx11"; then
   #
   # Check for basic X packages; we use pkg-config if available
   #
-  if $PKG_CONFIG --exists x11 xext; then
+  if $PKG_CONFIG --exists x11 xext xrender; then
     have_base_x_pc=true
-    X_PACKAGES="$X_PACKAGES x11 xext"
-    x_libs="`$PKG_CONFIG --libs x11 xext`"
-    X_CFLAGS="`$PKG_CONFIG --cflags x11 xext`"
+    X_PACKAGES="$X_PACKAGES x11 xext xrender"
+    x_libs="`$PKG_CONFIG --libs x11 xext xrender`"
+    X_CFLAGS="`$PKG_CONFIG --cflags x11 xext xrender`"
 
     # Strip out any .la files that pkg-config might give us (this happens
     # with -uninstalled.pc files)
@@ -967,9 +967,9 @@ if test "x$gdktarget" = "xx11"; then
     fi
 
     x_cflags="$X_CFLAGS"
-    x_libs_for_checks="$X_LIBS -lXext -lX11 $X_EXTRA_LIBS"
+    x_libs_for_checks="$X_LIBS -lXext -lXrender -lX11 $X_EXTRA_LIBS"
 
-    GTK_DEP_LIBS_FOR_X="$X_LIBS -lX11 $X_EXTRA_LIBS"
+    GTK_DEP_LIBS_FOR_X="$X_LIBS -lXrender -lX11 $X_EXTRA_LIBS"
   fi
 
   # Extra libraries found during checks (-lXinerama, etc), not from pkg-config.
@@ -988,6 +988,8 @@ if test "x$gdktarget" = "xx11"; then
                 AC_MSG_ERROR([*** libX11 not found. Check 'config.log' for more details.]))
   AC_CHECK_FUNC(XextFindDisplay, :,
                 AC_MSG_ERROR([*** libXext not found. Check 'config.log' for more details.]))
+  AC_CHECK_FUNC(XRenderQueryExtension, :,
+                AC_MSG_ERROR([*** libXrender not found. Check 'config.log' for more details.]))
 
   # Check for xReply
 

demos/Makefile.am

@@ -22,24 +22,42 @@ LDADDS = 								\
 	$(MATH_LIB)
 
 noinst_PROGRAMS = 		\
+	testpixbuf-drawable 	\
 	testanimation 		\
 	testpixbuf-color	\
 	testpixbuf-save		\
 	testpixbuf-scale 	\
 	pixbuf-demo
 
+# Need to build test-inline-pixbufs.h for testpixbuf
+noinst_PROGRAMS += testpixbuf
+BUILT_SOURCES = test-inline-pixbufs.h
+
+test-inline-pixbufs.h: apple-red.png gnome-foot.png
+	$(GDK_PIXBUF_CSOURCE) --raw --build-list	\
+	        apple_red  $(srcdir)/apple-red.png	\
+                gnome_foot $(srcdir)/gnome-foot.png	\
+        > test-inline-pixbufs.h				\
+	|| (rm -f test-inline-pixbufs.h && false)
+
+testpixbuf_DEPENDENCIES = $(DEPS)
+testpixbuf_drawable_DEPENDENCIES = $(DEPS)
 testpixbuf_save_DEPENDENCIES = $(DEPS)
 testpixbuf_color_DEPENDENCIES = $(DEPS)
 testpixbuf_scale_DEPENDENCIES = $(DEPS)
 testanimation_DEPENDENCIES = $(DEPS)
 pixbuf_demo_DEPENDENCIES = $(DEPS)
 
+testpixbuf_LDADD = $(LDADDS)
+testpixbuf_drawable_LDADD = $(LDADDS)
 testpixbuf_save_LDADD = $(LDADDS)
 testpixbuf_color_LDADD = $(LDADDS)
 testpixbuf_scale_LDADD = $(LDADDS)
 testanimation_LDADD = $(LDADDS)
 pixbuf_demo_LDADD = $(LDADDS)
 
+testpixbuf_SOURCES = testpixbuf.c pixbuf-init.c
+testpixbuf_drawable_SOURCES = testpixbuf-drawable.c pixbuf-init.c
 testpixbuf_save_SOURCES = testpixbuf-save.c
 testpixbuf_color_SOURCES = testpixbuf-color.c
 testpixbuf_scale_SOURCES = testpixbuf-scale.c pixbuf-init.c
@@ -57,4 +75,6 @@ EXTRA_DIST +=			\
 	gnome-gsame.png		\
 	gnu-keys.png
 
+DISTCLEANFILES = test-inline-pixbufs.h
+
 -include $(top_srcdir)/git.mk

demos/gtk-demo/appwindow.c

@@ -109,6 +109,22 @@ about_cb (GtkAction *action,
     NULL
   };
 
+  const gchar *license =
+    "This library is free software; you can redistribute it and/or\n"
+    "modify it under the terms of the GNU Library General Public License as\n"
+    "published by the Free Software Foundation; either version 2 of the\n"
+    "License, or (at your option) any later version.\n"
+    "\n"
+    "This library is distributed in the hope that it will be useful,\n"
+    "but WITHOUT ANY WARRANTY; without even the implied warranty of\n"
+    "MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU\n"
+    "Library General Public License for more details.\n"
+    "\n"
+    "You should have received a copy of the GNU Library General Public\n"
+    "License along with the Gnome Library; see the file COPYING.LIB.  If not,\n"
+    "write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,\n"
+    "Boston, MA 02111-1307, USA.\n";
+
   pixbuf = NULL;
   transparent = NULL;
   filename = demo_find_file ("gtk-logo-rgb.gif", NULL);
@@ -126,7 +142,7 @@ about_cb (GtkAction *action,
 			 "program-name", "GTK+ Code Demos",
 			 "version", PACKAGE_VERSION,
 			 "copyright", "(C) 1997-2009 The GTK+ Team",
-			 "license-type", GTK_LICENSE_LGPL_2_1,
+			 "license", license,
 			 "website", "http://www.gtk.org",
 			 "comments", "Program to demonstrate GTK+ functions.",
 			 "authors", authors,

demos/gtk-demo/colorsel.c

@@ -22,17 +22,14 @@ expose_event_callback (GtkWidget      *widget,
   if (widget->window)
     {
       GtkStyle *style;
-      cairo_t *cr;
 
       style = gtk_widget_get_style (widget);
 
-      cr = gdk_cairo_create (widget->window);
-
-      gdk_cairo_set_source_color (cr, &style->bg[GTK_STATE_NORMAL]);
-      gdk_cairo_rectangle (cr, &event->area);
-      cairo_fill (cr);
-
-      cairo_destroy (cr);
+      gdk_draw_rectangle (widget->window,
+                          style->bg_gc[GTK_STATE_NORMAL],
+                          TRUE,
+                          event->area.x, event->area.y,
+                          event->area.width, event->area.height);
     }
 
   return TRUE;

demos/gtk-demo/drawingarea.c

@@ -17,51 +17,52 @@
 
 static GtkWidget *window = NULL;
 /* Pixmap for scribble area, to store current scribbles */
-static cairo_surface_t *surface = NULL;
+static GdkPixmap *pixmap = NULL;
 
-/* Create a new surface of the appropriate size to store our scribbles */
+/* Create a new pixmap of the appropriate size to store our scribbles */
 static gboolean
 scribble_configure_event (GtkWidget         *widget,
                           GdkEventConfigure *event,
                           gpointer           data)
 {
-  cairo_t *cr;
+  if (pixmap)
+    g_object_unref (pixmap);
 
-  if (surface)
-    cairo_surface_destroy (surface);
+  pixmap = gdk_pixmap_new (widget->window,
+                           widget->allocation.width,
+                           widget->allocation.height,
+                           -1);
 
-  surface = gdk_window_create_similar_surface (widget->window,
-                                               CAIRO_CONTENT_COLOR,
-                                               widget->allocation.width,
-                                               widget->allocation.height);
-
-  /* Initialize the surface to white */
-  cr = cairo_create (surface);
-
-  cairo_set_source_rgb (cr, 1, 1, 1);
-  cairo_paint (cr);
-
-  cairo_destroy (cr);
+  /* Initialize the pixmap to white */
+  gdk_draw_rectangle (pixmap,
+                      widget->style->white_gc,
+                      TRUE,
+                      0, 0,
+                      widget->allocation.width,
+                      widget->allocation.height);
 
   /* We've handled the configure event, no need for further processing. */
   return TRUE;
 }
 
-/* Redraw the screen from the surface */
+/* Redraw the screen from the pixmap */
 static gboolean
 scribble_expose_event (GtkWidget      *widget,
                        GdkEventExpose *event,
                        gpointer        data)
 {
-  cairo_t *cr;
+  /* We use the "foreground GC" for the widget since it already exists,
+   * but honestly any GC would work. The only thing to worry about
+   * is whether the GC has an inappropriate clip region set.
+   */
 
-  cr = gdk_cairo_create (widget->window);
-  
-  cairo_set_source_surface (cr, surface, 0, 0);
-  gdk_cairo_rectangle (cr, &event->area);
-  cairo_fill (cr);
-
-  cairo_destroy (cr);
+  gdk_draw_drawable (widget->window,
+                     widget->style->fg_gc[gtk_widget_get_state (widget)],
+                     pixmap,
+                     /* Only copy the area that was exposed. */
+                     event->area.x, event->area.y,
+                     event->area.x, event->area.y,
+                     event->area.width, event->area.height);
 
   return FALSE;
 }
@@ -73,20 +74,18 @@ draw_brush (GtkWidget *widget,
             gdouble    y)
 {
   GdkRectangle update_rect;
-  cairo_t *cr;
 
   update_rect.x = x - 3;
   update_rect.y = y - 3;
   update_rect.width = 6;
   update_rect.height = 6;
 
-  /* Paint to the surface, where we store our state */
-  cr = cairo_create (surface);
-
-  gdk_cairo_rectangle (cr, &update_rect);
-  cairo_fill (cr);
-
-  cairo_destroy (cr);
+  /* Paint to the pixmap, where we store our state */
+  gdk_draw_rectangle (pixmap,
+                      widget->style->black_gc,
+                      TRUE,
+                      update_rect.x, update_rect.y,
+                      update_rect.width, update_rect.height);
 
   /* Now invalidate the affected region of the drawing area. */
   gdk_window_invalidate_rect (widget->window,
@@ -99,7 +98,7 @@ scribble_button_press_event (GtkWidget      *widget,
                              GdkEventButton *event,
                              gpointer        data)
 {
-  if (surface == NULL)
+  if (pixmap == NULL)
     return FALSE; /* paranoia check, in case we haven't gotten a configure event */
 
   if (event->button == 1)
@@ -117,7 +116,7 @@ scribble_motion_notify_event (GtkWidget      *widget,
   int x, y;
   GdkModifierType state;
 
-  if (surface == NULL)
+  if (pixmap == NULL)
     return FALSE; /* paranoia check, in case we haven't gotten a configure event */
 
   /* This call is very important; it requests the next motion event.
@@ -147,7 +146,8 @@ checkerboard_expose (GtkWidget      *da,
                      gpointer        data)
 {
   gint i, j, xcount, ycount;
-  cairo_t *cr;
+  GdkGC *gc1, *gc2;
+  GdkColor color;
 
 #define CHECK_SIZE 10
 #define SPACING 2
@@ -159,9 +159,21 @@ checkerboard_expose (GtkWidget      *da,
    * works.
    */
 
-  cr = gdk_cairo_create (da->window);
-  gdk_cairo_rectangle (cr, &event->area);
-  cairo_clip (cr);
+  /* It would be a bit more efficient to keep these
+   * GC's around instead of recreating on each expose, but
+   * this is the lazy/slow way.
+   */
+  gc1 = gdk_gc_new (da->window);
+  color.red = 30000;
+  color.green = 0;
+  color.blue = 30000;
+  gdk_gc_set_rgb_fg_color (gc1, &color);
+
+  gc2 = gdk_gc_new (da->window);
+  color.red = 65535;
+  color.green = 65535;
+  color.blue = 65535;
+  gdk_gc_set_rgb_fg_color (gc2, &color);
 
   xcount = 0;
   i = SPACING;
@@ -171,17 +183,23 @@ checkerboard_expose (GtkWidget      *da,
       ycount = xcount % 2; /* start with even/odd depending on row */
       while (j < da->allocation.height)
         {
+          GdkGC *gc;
+
           if (ycount % 2)
-            cairo_set_source_rgb (cr, 0.45777, 0, 0.45777);
+            gc = gc1;
           else
-            cairo_set_source_rgb (cr, 1, 1, 1);
+            gc = gc2;
 
           /* If we're outside event->area, this will do nothing.
            * It might be mildly more efficient if we handled
            * the clipping ourselves, but again we're feeling lazy.
            */
-          cairo_rectangle (cr, i, j, CHECK_SIZE, CHECK_SIZE);
-          cairo_fill (cr);
+          gdk_draw_rectangle (da->window,
+                              gc,
+                              TRUE,
+                              i, j,
+                              CHECK_SIZE,
+                              CHECK_SIZE);
 
           j += CHECK_SIZE + SPACING;
           ++ycount;
@@ -191,7 +209,8 @@ checkerboard_expose (GtkWidget      *da,
       ++xcount;
     }
 
-  cairo_destroy (cr);
+  g_object_unref (gc1);
+  g_object_unref (gc2);
 
   /* return TRUE because we've handled this event, so no
    * further processing is required.
@@ -204,9 +223,9 @@ close_window (void)
 {
   window = NULL;
 
-  if (surface)
-    g_object_unref (surface);
-  surface = NULL;
+  if (pixmap)
+    g_object_unref (pixmap);
+  pixmap = NULL;
 }
 
 GtkWidget *
@@ -273,7 +292,7 @@ do_drawingarea (GtkWidget *do_widget)
 
       gtk_container_add (GTK_CONTAINER (frame), da);
 
-      /* Signals used to handle backing surface */
+      /* Signals used to handle backing pixmap */
 
       g_signal_connect (da, "expose-event",
                         G_CALLBACK (scribble_expose_event), NULL);

demos/gtk-demo/pixbufs.c

@@ -100,15 +100,20 @@ expose_cb (GtkWidget      *widget,
            GdkEventExpose *event,
            gpointer        data)
 {
-  cairo_t *cr;
+  guchar *pixels;
+  int rowstride;
 
-  cr = gdk_cairo_create (event->window);
+  rowstride = gdk_pixbuf_get_rowstride (frame);
 
-  gdk_cairo_set_source_pixbuf (cr, frame, 0, 0);
-  gdk_cairo_rectangle (cr, &event->area);
-  cairo_fill (cr);
+  pixels = gdk_pixbuf_get_pixels (frame) + rowstride * event->area.y + event->area.x * 3;
 
-  cairo_destroy (cr);
+  gdk_draw_rgb_image_dithalign (widget->window,
+                                widget->style->black_gc,
+                                event->area.x, event->area.y,
+                                event->area.width, event->area.height,
+                                GDK_RGB_DITHER_NORMAL,
+                                pixels, rowstride,
+                                event->area.x, event->area.y);
 
   return TRUE;
 }

demos/gtk-demo/textview.c

@@ -14,9 +14,17 @@
 
 static void easter_egg_callback (GtkWidget *button, gpointer data);
 
+#define gray50_width 2
+#define gray50_height 2
+static char gray50_bits[] = {
+  0x02, 0x01
+};
+
 static void
 create_tags (GtkTextBuffer *buffer)
 {
+  GdkBitmap *stipple;
+
   /* Create a bunch of tags. Note that it's also possible to
    * create tags with gtk_text_tag_new() then add them to the
    * tag table for the buffer, gtk_text_buffer_create_tag() is
@@ -66,6 +74,18 @@ create_tags (GtkTextBuffer *buffer)
   gtk_text_buffer_create_tag (buffer, "red_background",
 			      "background", "red", NULL);
 
+  stipple = gdk_bitmap_create_from_data (NULL,
+					 gray50_bits, gray50_width,
+					 gray50_height);
+  
+  gtk_text_buffer_create_tag (buffer, "background_stipple",
+			      "background_stipple", stipple, NULL);
+
+  gtk_text_buffer_create_tag (buffer, "foreground_stipple",
+			      "foreground_stipple", stipple, NULL);
+
+  g_object_unref (stipple);
+
   gtk_text_buffer_create_tag (buffer, "big_gap_before_line",
 			      "pixels_above_lines", 30, NULL);
 
@@ -207,9 +227,17 @@ insert_text (GtkTextBuffer *buffer)
 					    "red_background", NULL);
   gtk_text_buffer_insert (buffer, &iter, " or even ", -1);  
   gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
-					    "a blue foreground on red background", -1,
+					    "a stippled red background", -1,
+					    "red_background",
+					    "background_stipple",
+					    NULL);
+
+  gtk_text_buffer_insert (buffer, &iter, " or ", -1);  
+  gtk_text_buffer_insert_with_tags_by_name (buffer, &iter,
+					    "a stippled blue foreground on solid red background", -1,
 					    "blue_foreground",
 					    "red_background",
+					    "foreground_stipple",
 					    NULL);
   gtk_text_buffer_insert (buffer, &iter, " (select that to read it) can be used.\n\n", -1);  
 

demos/pixbuf-demo.c

@@ -89,14 +89,20 @@ load_pixbufs (void)
 static gint
 expose_cb (GtkWidget *widget, GdkEventExpose *event, gpointer data)
 {
-        cairo_t *cr;
-         
-        cr = gdk_cairo_create (event->window);
-        gdk_cairo_set_source_pixbuf (cr, frame, 0, 0);
-        gdk_cairo_rectangle (cr, &event->area);
-        cairo_fill (cr);
+	guchar *pixels;
+	int rowstride;
 
-        cairo_destroy (cr);
+	rowstride = gdk_pixbuf_get_rowstride (frame);
+
+	pixels = gdk_pixbuf_get_pixels (frame) + rowstride * event->area.y + event->area.x * 3;
+		  
+	gdk_draw_rgb_image_dithalign (widget->window,
+				      widget->style->black_gc,
+				      event->area.x, event->area.y,
+				      event->area.width, event->area.height,
+				      GDK_RGB_DITHER_NORMAL,
+				      pixels, rowstride,
+				      event->area.x, event->area.y);
 
 	return TRUE;
 }

demos/testpixbuf-color.c

@@ -111,6 +111,8 @@ main (int argc, char **argv)
 
 	gtk_init (&argc, &argv);
 
+	gtk_widget_set_default_colormap (gdk_rgb_get_colormap ());
+
 	root = gdk_get_default_root_window ();
 	pixbuf = gdk_pixbuf_get_from_drawable (NULL, root, NULL,
 					       0, 0, 0, 0, 150, 160);

demos/testpixbuf-drawable.c

@@ -0,0 +1,115 @@
+#include "config.h"
+#include <gtk/gtk.h>
+
+int
+close_app (GtkWidget *widget, gpointer data)
+{
+   gtk_main_quit ();
+   return TRUE;
+}
+
+int
+expose_cb (GtkWidget *drawing_area, GdkEventExpose *evt, gpointer data)
+{
+   GdkPixbuf *pixbuf;
+         
+   pixbuf = (GdkPixbuf *) g_object_get_data (G_OBJECT (drawing_area), "pixbuf");
+   if (gdk_pixbuf_get_has_alpha (pixbuf))
+   {
+      gdk_draw_rgb_32_image (drawing_area->window,
+			     drawing_area->style->black_gc,
+			     evt->area.x, evt->area.y,
+			     evt->area.width,
+			     evt->area.height,
+			     GDK_RGB_DITHER_MAX,
+			     gdk_pixbuf_get_pixels (pixbuf) +
+			     (evt->area.y * gdk_pixbuf_get_rowstride (pixbuf)) +
+			     (evt->area.x * gdk_pixbuf_get_n_channels (pixbuf)),
+			     gdk_pixbuf_get_rowstride (pixbuf));
+   }
+   else
+   {
+      gdk_draw_rgb_image (drawing_area->window, 
+			  drawing_area->style->black_gc, 
+			  evt->area.x, evt->area.y,
+			  evt->area.width,
+			  evt->area.height,  
+			  GDK_RGB_DITHER_NORMAL,
+			  gdk_pixbuf_get_pixels (pixbuf) +
+			  (evt->area.y * gdk_pixbuf_get_rowstride (pixbuf)) +
+			  (evt->area.x * gdk_pixbuf_get_n_channels (pixbuf)),
+			  gdk_pixbuf_get_rowstride (pixbuf));
+   }
+   return FALSE;
+}
+
+int
+configure_cb (GtkWidget *drawing_area, GdkEventConfigure *evt, gpointer data)
+{
+   GdkPixbuf *pixbuf;
+                           
+   pixbuf = (GdkPixbuf *) g_object_get_data (G_OBJECT (drawing_area), "pixbuf");
+    
+   g_print ("X:%d Y:%d\n", evt->width, evt->height);
+   if (evt->width != gdk_pixbuf_get_width (pixbuf) || evt->height != gdk_pixbuf_get_height (pixbuf))
+   {
+      GdkWindow *root;
+      GdkPixbuf *new_pixbuf;
+
+      root = gdk_get_default_root_window ();
+      new_pixbuf = gdk_pixbuf_get_from_drawable (NULL, root, NULL,
+						 0, 0, 0, 0, evt->width, evt->height);
+      g_object_set_data (G_OBJECT (drawing_area), "pixbuf", new_pixbuf);
+      g_object_unref (pixbuf);
+   }
+
+   return FALSE;
+}
+
+extern void pixbuf_init (void);
+
+int
+main (int argc, char **argv)
+{   
+   GdkWindow     *root;
+   GtkWidget     *window;
+   GtkWidget     *vbox;
+   GtkWidget     *drawing_area;
+   GdkPixbuf     *pixbuf;    
+   
+   pixbuf_init ();
+
+   gtk_init (&argc, &argv);   
+   gdk_rgb_set_verbose (TRUE);
+
+   gtk_widget_set_default_colormap (gdk_rgb_get_colormap ());
+
+   root = gdk_get_default_root_window ();
+   pixbuf = gdk_pixbuf_get_from_drawable (NULL, root, NULL,
+					  0, 0, 0, 0, 150, 160);
+   
+   window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+   g_signal_connect (window, "delete_event",
+		     G_CALLBACK (close_app), NULL);
+   g_signal_connect (window, "destroy",   
+		     G_CALLBACK (close_app), NULL);
+   
+   vbox = gtk_vbox_new (FALSE, 0);
+   gtk_container_add (GTK_CONTAINER (window), vbox);  
+   
+   drawing_area = gtk_drawing_area_new ();
+   gtk_widget_set_size_request (GTK_WIDGET (drawing_area),
+                                gdk_pixbuf_get_width (pixbuf),
+                                gdk_pixbuf_get_height (pixbuf));
+   g_signal_connect (drawing_area, "expose_event",
+		     G_CALLBACK (expose_cb), NULL);
+
+   g_signal_connect (drawing_area, "configure_event",
+		     G_CALLBACK (configure_cb), NULL);
+   g_object_set_data (G_OBJECT (drawing_area), "pixbuf", pixbuf);
+   gtk_box_pack_start (GTK_BOX (vbox), drawing_area, TRUE, TRUE, 0);
+   
+   gtk_widget_show_all (window);
+   gtk_main ();
+   return 0;
+}

demos/testpixbuf-save.c

@@ -311,18 +311,32 @@ static int
 expose_cb (GtkWidget *drawing_area, GdkEventExpose *evt, gpointer data)
 {
         GdkPixbuf *pixbuf;
-        cairo_t *cr;
          
         pixbuf = (GdkPixbuf *) g_object_get_data (G_OBJECT (drawing_area),
 						  "pixbuf");
-
-        cr = gdk_cairo_create (evt->window);
-        gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
-        gdk_cairo_rectangle (cr, &evt->area);
-        cairo_fill (cr);
-
-        cairo_destroy (cr);
-
+        if (gdk_pixbuf_get_has_alpha (pixbuf)) {
+                gdk_draw_rgb_32_image (drawing_area->window,
+                                       drawing_area->style->black_gc,
+                                       evt->area.x, evt->area.y,
+                                       evt->area.width,
+                                       evt->area.height,
+                                       GDK_RGB_DITHER_MAX,
+                                       gdk_pixbuf_get_pixels (pixbuf) +
+                                       (evt->area.y * gdk_pixbuf_get_rowstride (pixbuf)) +
+                                       (evt->area.x * gdk_pixbuf_get_n_channels (pixbuf)),
+                                       gdk_pixbuf_get_rowstride (pixbuf));
+        } else {
+                gdk_draw_rgb_image (drawing_area->window, 
+                                    drawing_area->style->black_gc, 
+                                    evt->area.x, evt->area.y,
+                                    evt->area.width,
+                                    evt->area.height,  
+                                    GDK_RGB_DITHER_NORMAL,
+                                    gdk_pixbuf_get_pixels (pixbuf) +
+                                    (evt->area.y * gdk_pixbuf_get_rowstride (pixbuf)) +
+                                    (evt->area.x * gdk_pixbuf_get_n_channels (pixbuf)),
+                                    gdk_pixbuf_get_rowstride (pixbuf));
+        }
         return FALSE;
 }
 
@@ -360,6 +374,8 @@ main (int argc, char **argv)
    
         gtk_init (&argc, &argv);   
 
+        gtk_widget_set_default_colormap (gdk_rgb_get_colormap ());
+
         root = gdk_get_default_root_window ();
         pixbuf = gdk_pixbuf_get_from_drawable (NULL, root, NULL,
                                                0, 0, 0, 0, 150, 160);

demos/testpixbuf-scale.c

@@ -35,7 +35,6 @@ gboolean
 expose_cb (GtkWidget *widget, GdkEventExpose *event, gpointer data)
 {
   GdkPixbuf *dest;
-  cairo_t *cr;
 
   gdk_window_set_back_pixmap (widget->window, NULL, FALSE);
   
@@ -49,13 +48,11 @@ expose_cb (GtkWidget *widget, GdkEventExpose *event, gpointer data)
 			      interp_type, overall_alpha,
 			      event->area.x, event->area.y, 16, 0xaaaaaa, 0x555555);
 
-  cr = gdk_cairo_create (event->window);
-
-  gdk_cairo_set_source_pixbuf (cr, dest, 0, 0);
-  gdk_cairo_rectangle (cr, &event->area);
-  cairo_fill (cr);
-
-  cairo_destroy (cr);
+  gdk_draw_pixbuf (widget->window, widget->style->fg_gc[GTK_STATE_NORMAL], dest,
+		   0, 0, event->area.x, event->area.y,
+		   event->area.width, event->area.height,
+		   GDK_RGB_DITHER_NORMAL, event->area.x, event->area.y);
+  
   g_object_unref (dest);
   
   return TRUE;

demos/testpixbuf.c

@@ -0,0 +1,640 @@
+/* testpixbuf -- test program for gdk-pixbuf code
+ * Copyright (C) 1999 Mark Crichton, Larry Ewing
+ *
+ * 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.
+ */
+
+#include "config.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <gtk/gtk.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#include "test-inline-pixbufs.h"
+
+typedef struct {
+	FILE             *imagefile;
+	GdkPixbufLoader  *loader;
+	GtkWidget        **rgbwin;
+	guchar           *buf;
+	guint            timeout;
+	guint            readlen;
+} ProgressFileStatus;
+
+
+#define DEFAULT_WIDTH  24
+#define DEFAULT_HEIGHT 24
+
+static const unsigned char default_image[] = {
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0xae, 0xb3, 0xb3, 0xc6, 0xc9, 0xcd, 0xd7, 0xd4, 0xdf,
+	0xec, 0xde, 0xf3, 0xe7, 0xcb, 0xe9, 0xd9, 0xb5, 0xd3, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xb1, 0xb7, 0xa5,
+	0xb0, 0xb8, 0xad, 0xb3, 0xb9, 0xb6, 0xc1, 0xc6, 0xc8, 0xd5, 0xd3, 0xdc,
+	0xec, 0xde, 0xf3, 0xe5, 0xca, 0xe6, 0xe0, 0xbb, 0xd7, 0xe1, 0xad, 0xc2,
+	0xe3, 0xac, 0xa3, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xca, 0xc1, 0xa4, 0xc5, 0xc7, 0xac,
+	0xb7, 0xbe, 0xaf, 0xad, 0xb4, 0xaf, 0xbd, 0xc2, 0xc3, 0xd1, 0xd0, 0xd8,
+	0xec, 0xde, 0xf3, 0xe5, 0xc7, 0xe4, 0xe0, 0xb6, 0xd1, 0xe7, 0xa9, 0xb4,
+	0xed, 0xcd, 0xb6, 0xd6, 0xcf, 0xae, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0x00, 0x00, 0x00, 0xdf, 0xa7, 0x9f, 0xdd, 0xbf, 0xaa, 0xcf, 0xc5, 0xa9,
+	0xc1, 0xc4, 0xac, 0xb2, 0xba, 0xaf, 0xb6, 0xbb, 0xbb, 0xcd, 0xce, 0xd4,
+	0xec, 0xde, 0xf3, 0xe4, 0xc4, 0xe1, 0xe0, 0xaf, 0xc7, 0xea, 0xbc, 0xae,
+	0xe1, 0xd6, 0xb6, 0xc7, 0xcc, 0xae, 0xa2, 0xab, 0x9a, 0x00, 0x00, 0x00,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0x00, 0x00, 0x00, 0xe3, 0xab, 0xc0, 0xe6, 0xa3, 0xa7, 0xdf, 0xba, 0xa8,
+	0xcf, 0xc5, 0xa9, 0xbd, 0xc2, 0xae, 0xad, 0xb4, 0xaf, 0xc6, 0xc9, 0xcd,
+	0xec, 0xde, 0xf3, 0xe2, 0xbf, 0xdc, 0xe7, 0xa9, 0xb4, 0xe7, 0xd6, 0xb8,
+	0xc7, 0xcc, 0xae, 0xac, 0xb6, 0xa6, 0x9d, 0xa8, 0x9f, 0x00, 0x00, 0x00,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00,
+	0xd9, 0xaf, 0xcf, 0xe1, 0xb4, 0xd2, 0xe2, 0xb0, 0xcb, 0xe4, 0xa9, 0xbb,
+	0xe2, 0xb2, 0xa6, 0xcf, 0xc5, 0xa9, 0x6a, 0x6a, 0x6a, 0x0d, 0x0d, 0x0d,
+	0x0d, 0x0d, 0x0d, 0x6a, 0x6a, 0x6a, 0xed, 0xcd, 0xb6, 0xc7, 0xcc, 0xae,
+	0xa6, 0xb1, 0xa3, 0x98, 0xa2, 0x9c, 0x8f, 0x97, 0x96, 0x7e, 0x84, 0x85,
+	0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00,
+	0xe8, 0xc6, 0xe7, 0xe5, 0xc2, 0xe3, 0xe3, 0xbd, 0xdd, 0xe1, 0xb6, 0xd5,
+	0xe2, 0xb0, 0xcb, 0x6a, 0x6a, 0x6a, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x6a, 0x6a, 0x6a, 0x9d, 0xa8, 0x9f,
+	0x8f, 0x97, 0x96, 0x8b, 0x90, 0x92, 0x97, 0x9e, 0xa2, 0xa0, 0xa7, 0xae,
+	0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00,
+	0xe7, 0xd3, 0xed, 0xe8, 0xd1, 0xed, 0xe8, 0xce, 0xec, 0xe9, 0xcc, 0xeb,
+	0xe8, 0xc6, 0xe7, 0x0d, 0x0d, 0x0d, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x0d, 0x0d, 0x0d, 0x97, 0x9e, 0xa2,
+	0xa7, 0xae, 0xb7, 0xb2, 0xb6, 0xc5, 0xba, 0xbc, 0xce, 0xbf, 0xbe, 0xd3,
+	0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00,
+	0xe9, 0xdf, 0xf0, 0xe9, 0xdf, 0xf0, 0xe9, 0xdf, 0xf0, 0xe9, 0xdf, 0xf0,
+	0xe9, 0xdf, 0xf0, 0x0d, 0x0d, 0x0d, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x0d, 0x0d, 0x0d, 0xe1, 0xd2, 0xf7,
+	0xe1, 0xd2, 0xf7, 0xe1, 0xd2, 0xf7, 0xe1, 0xd2, 0xf7, 0xe1, 0xd2, 0xf7,
+	0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00,
+	0xca, 0xc7, 0xd2, 0xc5, 0xc4, 0xcd, 0xbf, 0xbf, 0xc7, 0xb8, 0xb9, 0xc0,
+	0xae, 0xaf, 0xb6, 0x6a, 0x6a, 0x6a, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x6a, 0x6a, 0x6a, 0xd5, 0xa8, 0xe1,
+	0xd8, 0xb2, 0xe9, 0xd9, 0xb8, 0xed, 0xdb, 0xbd, 0xf0, 0xdc, 0xbf, 0xf1,
+	0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00,
+	0xa4, 0xa6, 0xac, 0xa8, 0xaa, 0xaf, 0xa0, 0xa6, 0xa8, 0x98, 0x9e, 0x9c,
+	0xa1, 0xa8, 0x9e, 0xb1, 0xb6, 0xa1, 0x6a, 0x6a, 0x6a, 0x0d, 0x0d, 0x0d,
+	0x0d, 0x0d, 0x0d, 0x6a, 0x6a, 0x6a, 0xc0, 0x8c, 0xad, 0xcc, 0x90, 0xb5,
+	0xd3, 0x94, 0xca, 0xd6, 0xa2, 0xdb, 0xd5, 0xa8, 0xe1, 0xcf, 0xa7, 0xdf,
+	0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0x00, 0x00, 0x00, 0x98, 0x9f, 0x9b, 0xa1, 0xa8, 0x9e, 0xac, 0xb3, 0xa0,
+	0xb9, 0xb9, 0xa4, 0xd0, 0xb8, 0xa8, 0xc5, 0xb5, 0xb8, 0xb6, 0xbb, 0xad,
+	0xe3, 0xd7, 0xb5, 0xdd, 0xb4, 0xa9, 0xcb, 0x89, 0xac, 0xc0, 0x8c, 0xad,
+	0xc8, 0x91, 0xb5, 0xd1, 0x8d, 0xb7, 0xd3, 0x94, 0xca, 0x00, 0x00, 0x00,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0x00, 0x00, 0x00, 0xa1, 0xa7, 0x98, 0xb1, 0xb6, 0xa1, 0xbd, 0xb9, 0xa5,
+	0xd0, 0xb8, 0xa8, 0xca, 0xb5, 0xb7, 0xb8, 0xb1, 0xb1, 0xc2, 0xc8, 0xb2,
+	0xe3, 0xd7, 0xb5, 0xe1, 0xbf, 0xaf, 0xdb, 0x92, 0x9a, 0xbe, 0x82, 0xa6,
+	0xc0, 0x8c, 0xad, 0xc8, 0x91, 0xb4, 0xc7, 0x8b, 0xb0, 0x00, 0x00, 0x00,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xbc, 0xb6, 0xa1, 0xd0, 0xb8, 0xa8,
+	0xcd, 0xb6, 0xb7, 0xc0, 0xb4, 0xb5, 0xb1, 0xb1, 0xaa, 0xca, 0xd1, 0xb4,
+	0xe3, 0xd7, 0xb5, 0xe2, 0xc1, 0xb0, 0xdb, 0xa8, 0xa3, 0xd2, 0x8a, 0xa9,
+	0xb7, 0x7e, 0xa2, 0xbd, 0x89, 0xa9, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0xc9, 0xaf, 0xaf,
+	0xc5, 0xb5, 0xb8, 0xb8, 0xb1, 0xb1, 0xb6, 0xbb, 0xad, 0xd0, 0xd6, 0xb5,
+	0xe3, 0xd7, 0xb5, 0xe2, 0xbf, 0xaf, 0xdd, 0xb4, 0xa9, 0xdb, 0x92, 0x9a,
+	0xc6, 0x84, 0xa7, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0xac, 0xaa, 0xa6, 0xbd, 0xc3, 0xb0, 0xd2, 0xd7, 0xb5,
+	0xe3, 0xd7, 0xb5, 0xe2, 0xbf, 0xae, 0xdb, 0xb6, 0xa8, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff,
+	0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff, 0xff, 0x00, 0xff
+};
+
+
+static const char * book_open_xpm[] = {
+"16 16 4 1",
+"       c None s None",
+".      c black",
+"X      c #808080",
+"o      c white",
+"                ",
+"  ..            ",
+" .Xo.    ...    ",
+" .Xoo. ..oo.    ",
+" .Xooo.Xooo...  ",
+" .Xooo.oooo.X.  ",
+" .Xooo.Xooo.X.  ",
+" .Xooo.oooo.X.  ",
+" .Xooo.Xooo.X.  ",
+" .Xooo.oooo.X.  ",
+"  .Xoo.Xoo..X.  ",
+"   .Xo.o..ooX.  ",
+"    .X..XXXXX.  ",
+"    ..X.......  ",
+"     ..         ",
+"                "};
+
+static const char * book_closed_xpm[] = {
+"16 16 6 1",
+"       c None s None",
+".      c black",
+"X      c red",
+"o      c yellow",
+"O      c #808080",
+"#      c white",
+"                ",
+"       ..       ",
+"     ..XX.      ",
+"   ..XXXXX.     ",
+" ..XXXXXXXX.    ",
+".ooXXXXXXXXX.   ",
+"..ooXXXXXXXXX.  ",
+".X.ooXXXXXXXXX. ",
+".XX.ooXXXXXX..  ",
+" .XX.ooXXX..#O  ",
+"  .XX.oo..##OO. ",
+"   .XX..##OO..  ",
+"    .X.#OO..    ",
+"     ..O..      ",
+"      ..        ",
+"                "};
+
+static const char * mini_page_xpm[] = {
+"16 16 4 1",
+"       c None s None",
+".      c black",
+"X      c white",
+"o      c #808080",
+"                ",
+"   .......      ",
+"   .XXXXX..     ",
+"   .XoooX.X.    ",
+"   .XXXXX....   ",
+"   .XooooXoo.o  ",
+"   .XXXXXXXX.o  ",
+"   .XooooooX.o  ",
+"   .XXXXXXXX.o  ",
+"   .XooooooX.o  ",
+"   .XXXXXXXX.o  ",
+"   .XooooooX.o  ",
+"   .XXXXXXXX.o  ",
+"   ..........o  ",
+"    oooooooooo  ",
+"                "};
+
+static const char * gtk_mini_xpm[] = {
+"15 20 17 1",
+"       c None",
+".      c #14121F",
+"+      c #278828",
+"@      c #9B3334",
+"#      c #284C72",
+"$      c #24692A",
+"%      c #69282E",
+"&      c #37C539",
+"*      c #1D2F4D",
+"=      c #6D7076",
+"-      c #7D8482",
+";      c #E24A49",
+">      c #515357",
+",      c #9B9C9B",
+"'      c #2FA232",
+")      c #3CE23D",
+"!      c #3B6CCB",
+"               ",
+"      ***>     ",
+"    >.*!!!*    ",
+"   ***....#*=  ",
+"  *!*.!!!**!!# ",
+" .!!#*!#*!!!!# ",
+" @%#!.##.*!!$& ",
+" @;%*!*.#!#')) ",
+" @;;@%!!*$&)'' ",
+" @%.%@%$'&)$+' ",
+" @;...@$'*'*)+ ",
+" @;%..@$+*.')$ ",
+" @;%%;;$+..$)# ",
+" @;%%;@$$$'.$# ",
+" %;@@;;$$+))&* ",
+"  %;;;@+$&)&*  ",
+"   %;;@'))+>   ",
+"    %;@'&#     ",
+"     >%$$      ",
+"      >=       "};
+
+const gchar ** xpms[] = { 
+  book_open_xpm,
+  book_closed_xpm,
+  mini_page_xpm,
+  gtk_mini_xpm,
+  NULL
+};
+
+static void
+quit_func (GtkWidget *widget, gpointer dummy)
+{
+	gtk_main_quit ();
+}
+
+static void
+expose_func (GtkWidget *drawing_area, GdkEventExpose *event, gpointer data)
+{
+	GdkPixbuf *pixbuf;
+
+	pixbuf = (GdkPixbuf *)g_object_get_data (G_OBJECT (drawing_area), "pixbuf");
+
+	if (gdk_pixbuf_get_has_alpha (pixbuf)) {
+		GdkPixbuf *dest;
+	  
+		gdk_window_set_back_pixmap (drawing_area->window, NULL, FALSE);
+	  
+		dest = gdk_pixbuf_new (GDK_COLORSPACE_RGB, FALSE, 8, event->area.width, event->area.height);
+		
+		gdk_pixbuf_composite_color (pixbuf, dest,
+					    0, 0, event->area.width, event->area.height,
+					    -event->area.x, -event->area.y,
+					    (double) drawing_area->allocation.width / gdk_pixbuf_get_width (pixbuf),
+					    (double) drawing_area->allocation.height / gdk_pixbuf_get_height (pixbuf),
+					    GDK_INTERP_BILINEAR, 255,
+					    event->area.x, event->area.y, 16, 0xaaaaaa, 0x555555);
+		
+		gdk_draw_pixbuf (drawing_area->window, drawing_area->style->fg_gc[GTK_STATE_NORMAL], dest,
+				 0, 0, event->area.x, event->area.y,
+				 event->area.width, event->area.height,
+				 GDK_RGB_DITHER_NORMAL, event->area.x, event->area.y);
+		
+		g_object_unref (dest);
+	} else {
+		gdk_draw_rgb_image (drawing_area->window,
+				    drawing_area->style->white_gc,
+				    event->area.x, event->area.y, 
+				    event->area.width, 
+				    event->area.height,
+				    GDK_RGB_DITHER_NORMAL,
+				    gdk_pixbuf_get_pixels (pixbuf)
+				    + (event->area.y * gdk_pixbuf_get_rowstride (pixbuf))
+				    + (event->area.x * gdk_pixbuf_get_n_channels (pixbuf)),
+				    gdk_pixbuf_get_rowstride (pixbuf));
+	}
+}
+
+static void
+config_func (GtkWidget *drawing_area, GdkEventConfigure *event, gpointer data)
+{
+#if 0
+	GdkPixbuf *pixbuf;
+    
+	pixbuf = (GdkPixbuf *)g_object_get_data (G_OBJECT (drawing_area), "pixbuf");
+
+	if (((event->width) != gdk_pixbuf_get_width (pixbuf)) ||
+	    ((event->height) != gdk_pixbuf_get_height (pixbuf)))
+		gdk_pixbuf_scale (pixbuf, event->width, event->height);
+#endif
+}
+
+static GtkWidget*
+new_testrgb_window (GdkPixbuf *pixbuf, gchar *title)
+{
+	GtkWidget *window;
+	GtkWidget *vbox;
+	GtkWidget *temp_box;
+	GtkWidget *button;
+	GtkWidget *drawing_area;
+	gint w, h;
+
+        g_return_val_if_fail (pixbuf != NULL, NULL);
+	w = gdk_pixbuf_get_width (pixbuf);
+	h = gdk_pixbuf_get_height (pixbuf);
+
+	window = g_object_new (gtk_window_get_type (),
+				 "GtkObject::user_data", NULL,
+				 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
+				 "GtkWindow::title", title ? title : "testrgb",
+				 "GtkWindow::allow_shrink", TRUE,
+				 NULL);
+	g_signal_connect (window, "destroy",
+			  G_CALLBACK (quit_func), NULL);
+
+	vbox = gtk_vbox_new (FALSE, 0);
+
+	if (title)
+		gtk_box_pack_start (GTK_BOX (vbox), gtk_label_new (title),
+				    TRUE, TRUE, 0);
+
+	drawing_area = gtk_drawing_area_new ();
+
+	temp_box = gtk_hbox_new (FALSE, 0);
+	gtk_widget_set_size_request (GTK_WIDGET (drawing_area), w, h);
+	gtk_box_pack_start (GTK_BOX (temp_box), drawing_area, FALSE, FALSE, 0);
+	gtk_box_pack_start (GTK_BOX (vbox), temp_box, FALSE, FALSE, 0);
+	
+
+	g_signal_connect (drawing_area, "expose_event",
+			  G_CALLBACK (expose_func), NULL);
+	g_signal_connect (drawing_area, "configure_event",
+			  G_CALLBACK (config_func), NULL);
+
+	g_object_set_data (G_OBJECT (drawing_area), "pixbuf", pixbuf);
+
+	gtk_widget_show (drawing_area);
+
+	button = gtk_button_new_with_label ("Quit");
+	gtk_box_pack_start (GTK_BOX (vbox), button, FALSE, FALSE, 0);
+	g_signal_connect_swapped (button, "clicked",
+				  G_CALLBACK (gtk_widget_destroy), window);
+
+	gtk_widget_show (button);
+
+	gtk_container_add (GTK_CONTAINER (window), vbox);
+	gtk_widget_show_all (vbox);
+
+	gtk_widget_show (window);
+
+        return drawing_area;
+}
+
+
+static gint
+update_timeout (gpointer data)
+{
+        ProgressFileStatus *status = data;
+	gboolean done;
+        GError *error;
+        
+	done = FALSE;
+        error = NULL;
+
+	if (!feof (status->imagefile)) {
+		gint nbytes;
+                
+		nbytes = fread (status->buf, 1, status->readlen, 
+			       status->imagefile);
+
+
+                if (!gdk_pixbuf_loader_write (GDK_PIXBUF_LOADER (status->loader), status->buf, nbytes, &error)) {
+                        g_warning ("Error writing to loader: %s",
+                                   error->message);
+                        g_error_free (error);
+                        done = TRUE;
+                }
+                        
+                        
+        } 
+	else 
+                done = TRUE;
+	  
+	if (done) {
+                /* ignoring errors, we should not do that. */
+		gdk_pixbuf_loader_close (GDK_PIXBUF_LOADER (status->loader), NULL);
+		gtk_widget_queue_draw (*status->rgbwin);
+		g_object_unref (status->loader);
+		fclose (status->imagefile);
+		g_free (status->buf);
+	}
+
+	return !done;
+}
+
+
+static void
+progressive_prepared_callback (GdkPixbufLoader* loader, gpointer data)
+{
+        GtkWidget** retloc = data;
+        GdkPixbuf* pixbuf;
+
+        pixbuf = gdk_pixbuf_loader_get_pixbuf (loader);
+
+        g_assert (pixbuf != NULL);
+
+        g_object_ref (pixbuf); /* for the RGB window */
+
+        *retloc = new_testrgb_window (pixbuf, "Progressive");
+
+        return;
+}
+
+
+static void
+progressive_updated_callback (GdkPixbufLoader* loader, guint x, guint y, guint width, guint height, gpointer data)
+{
+        GtkWidget** window_loc = data;
+
+        if (*window_loc != NULL)
+                gtk_widget_queue_draw_area (*window_loc,
+					   x, y, width, height);
+        return;
+}
+
+static int readlen = 4096;
+
+extern void pixbuf_init (void);
+
+void size_func (GdkPixbufLoader *loader, gint width, gint height, gpointer data)
+{
+        gdk_pixbuf_loader_set_size (loader, width*2, height*2);
+}
+
+
+int
+main (int argc, char **argv)
+{
+	int i;
+	int found_valid = FALSE;
+
+	GdkPixbuf *pixbuf;
+	GdkPixbufLoader *pixbuf_loader;
+
+	pixbuf_init ();
+
+	gtk_init (&argc, &argv);
+
+	/*	gdk_rgb_set_verbose (TRUE);*/
+
+	gtk_widget_set_default_colormap (gdk_rgb_get_colormap ());
+
+	{
+		char *tbf_readlen = getenv ("TBF_READLEN");
+		if (tbf_readlen) readlen = atoi (tbf_readlen);
+	}
+
+	{
+		char *tbf_bps = getenv ("TBF_KBPS");
+		guint bps;
+
+		if (tbf_bps) {
+			bps = atoi (tbf_bps);
+			g_print ("Simulating %d kBytes/sec\n", bps);
+			readlen = (bps*1024)/10;
+		}
+	}
+
+	i = 1;
+	if (argc == 1) {
+                const gchar*** xpmp;
+                GError *error = NULL;
+		
+		pixbuf = gdk_pixbuf_new_from_data (default_image, GDK_COLORSPACE_RGB, FALSE, 8,
+						   DEFAULT_WIDTH, DEFAULT_HEIGHT, DEFAULT_WIDTH * 3,
+						   NULL, NULL);
+		new_testrgb_window (pixbuf, NULL);
+
+                xpmp = xpms;
+                while (*xpmp) {
+                        pixbuf = gdk_pixbuf_new_from_xpm_data (*xpmp);
+                        new_testrgb_window (pixbuf, NULL);
+                        ++xpmp;
+                }
+
+                /* Test loading from inline data. */
+                pixbuf = gdk_pixbuf_new_from_inline (-1, apple_red, FALSE, &error);
+		if (!pixbuf)
+		  {
+		    fprintf (stderr, "failed to construct \"red apple\" pixbuf: %s\n",
+			     error->message);
+		    g_error_free (error);
+		  }
+		else
+		  new_testrgb_window (pixbuf, "Red apple from inlined RLE data");
+
+                pixbuf = gdk_pixbuf_new_from_inline (sizeof (gnome_foot), gnome_foot, TRUE, NULL);
+                new_testrgb_window (pixbuf, "GNOME Foot from inlined RLE data");
+                
+		found_valid = TRUE;
+	} else {
+		for (i = 1; i < argc; i++) {
+                        GError *error;
+
+                        error = NULL;
+			pixbuf = gdk_pixbuf_new_from_file (argv[i], &error);
+
+                        if (pixbuf == NULL) {
+                                g_warning ("Error loading image: %s",
+                                           error->message);
+                                g_error_free (error);
+                        }
+                        
+#if 0
+			pixbuf = gdk_pixbuf_rotate (pixbuf, 10.0);
+#endif
+
+			if (pixbuf) {
+				new_testrgb_window (pixbuf, "File");
+				found_valid = TRUE;
+			}
+		}
+#if 1	
+                {
+                        GtkWidget* rgb_window = NULL;
+			ProgressFileStatus   status;
+
+                        pixbuf_loader = gdk_pixbuf_loader_new ();
+			status.loader = pixbuf_loader;
+
+			status.rgbwin = &rgb_window;
+
+			status.buf = g_malloc (readlen);
+
+#if 0
+			g_signal_connect (pixbuf_loader, "size_prepared", 
+					  G_CALLBACK (size_func), NULL);
+#endif
+
+                        g_signal_connect (pixbuf_loader, "area_prepared",
+					  G_CALLBACK (progressive_prepared_callback),
+					  &rgb_window);
+                        g_signal_connect (pixbuf_loader, "area_updated",
+					  G_CALLBACK (progressive_updated_callback),
+					  &rgb_window);
+			
+                        status.imagefile = fopen (argv[1], "r");
+                        g_assert (status.imagefile != NULL);
+
+			status.readlen = readlen;
+
+                        status.timeout = gdk_threads_add_timeout (100, update_timeout, &status);
+                }
+#endif
+	}
+
+	if (found_valid)
+		gtk_main ();
+
+	return 0;
+}

docs/reference/gdk/gdk-docs.sgml

@@ -24,9 +24,12 @@
     <xi:include href="xml/gdkscreen.xml" />
 
     <xi:include href="xml/regions.xml" />
+    <xi:include href="xml/gcs.xml" />
     <xi:include href="xml/drawing.xml" />
 
     <xi:include href="xml/pixmaps.xml" />
+    <xi:include href="xml/rgb.xml" />
+    <xi:include href="xml/images.xml" />
     <xi:include href="xml/pixbufs.xml" />
 
     <xi:include href="xml/colors.xml" />

docs/reference/gdk/gdk3-sections.txt

@@ -71,17 +71,25 @@ gdk_drag_protocol_get_type
 gdk_event_mask_get_type
 gdk_event_type_get_type
 gdk_extension_mode_get_type
+gdk_fill_get_type
+gdk_fill_rule_get_type
 gdk_filter_return_get_type
+gdk_function_get_type
+gdk_gc_values_mask_get_type
 gdk_grab_ownership_get_type
 gdk_grab_status_get_type
 gdk_gravity_get_type
+gdk_image_type_get_type
 gdk_input_mode_get_type
 gdk_input_source_get_type
+gdk_join_style_get_type
+gdk_line_style_get_type
 gdk_modifier_type_get_type
 gdk_notify_type_get_type
 gdk_overlap_type_get_type
 gdk_property_state_get_type
 gdk_prop_mode_get_type
+gdk_rgb_dither_get_type
 gdk_scroll_direction_get_type
 gdk_setting_action_get_type
 gdk_status_get_type
@@ -121,7 +129,6 @@ gdk_display_beep
 gdk_display_sync
 gdk_display_flush
 gdk_display_close
-gdk_display_is_closed
 gdk_display_list_devices
 gdk_display_get_event
 gdk_display_peek_event
@@ -194,6 +201,8 @@ gdk_screen_get_default_colormap
 gdk_screen_set_default_colormap
 gdk_screen_get_system_colormap
 gdk_screen_get_system_visual
+gdk_screen_get_rgb_colormap
+gdk_screen_get_rgb_visual
 gdk_screen_get_rgba_colormap
 gdk_screen_get_rgba_visual
 gdk_screen_is_composited
@@ -245,6 +254,12 @@ gdk_screen_get_type
 <FILE>pixmaps</FILE>
 GdkPixmap
 gdk_pixmap_new
+gdk_bitmap_create_from_data
+gdk_pixmap_create_from_data
+gdk_pixmap_create_from_xpm
+gdk_pixmap_colormap_create_from_xpm
+gdk_pixmap_create_from_xpm_d
+gdk_pixmap_colormap_create_from_xpm_d
 GdkBitmap
 
 <SUBSECTION Standard>
@@ -262,6 +277,77 @@ GdkPixmapObject
 GdkPixmapObjectClass
 </SECTION>
 
+<SECTION>
+<TITLE>Images</TITLE>
+<FILE>images</FILE>
+GdkImage
+gdk_image_new
+GdkImageType
+gdk_image_get_colormap
+gdk_image_set_colormap
+gdk_image_get_bits_per_pixel
+gdk_image_get_bytes_per_pixel
+gdk_image_get_bytes_per_line
+gdk_image_get_byte_order
+gdk_image_get_depth
+gdk_image_get_height
+gdk_image_get_image_type
+gdk_image_get_visual
+gdk_image_get_width
+gdk_image_get_pixels
+
+<SUBSECTION>
+gdk_image_put_pixel
+gdk_image_get_pixel
+
+<SUBSECTION Standard>
+GDK_IMAGE
+GDK_TYPE_IMAGE
+GDK_IS_IMAGE
+GDK_IMAGE_CLASS
+GDK_IMAGE_GET_CLASS
+GDK_IS_IMAGE_CLASS
+GDK_TYPE_IMAGE_TYPE
+
+<SUBSECTION Private>
+GdkImageClass
+gdk_image_get_type
+</SECTION>
+
+<SECTION>
+<TITLE>GdkRGB</TITLE>
+<FILE>rgb</FILE>
+
+<SUBSECTION>
+gdk_draw_rgb_image
+gdk_draw_rgb_image_dithalign
+gdk_draw_indexed_image
+gdk_draw_gray_image
+gdk_draw_rgb_32_image
+gdk_draw_rgb_32_image_dithalign
+GdkRgbDither
+
+<SUBSECTION>
+gdk_rgb_cmap_new
+gdk_rgb_cmap_free
+GdkRgbCmap
+
+<SUBSECTION>
+gdk_rgb_find_color
+
+<SUBSECTION>
+gdk_rgb_set_install
+gdk_rgb_set_min_colors
+gdk_rgb_get_visual
+gdk_rgb_get_colormap
+gdk_rgb_ditherable
+gdk_rgb_colormap_ditherable
+gdk_rgb_set_verbose
+
+<SUBSECTION Standard>
+GDK_TYPE_RGB_DITHER
+</SECTION>
+
 <SECTION>
 <TITLE>Pixbufs</TITLE>
 <FILE>pixbufs</FILE>
@@ -269,7 +355,7 @@ gdk_pixbuf_render_threshold_alpha
 gdk_pixbuf_render_pixmap_and_mask
 gdk_pixbuf_render_pixmap_and_mask_for_colormap
 gdk_pixbuf_get_from_drawable
-gdk_pixbuf_get_from_surface
+gdk_pixbuf_get_from_image
 </SECTION>
 
 <SECTION>
@@ -282,6 +368,7 @@ gdk_colormap_get_system
 gdk_colormap_alloc_colors
 gdk_colormap_alloc_color
 gdk_colormap_free_colors
+gdk_colormap_query_color
 gdk_colormap_get_visual
 gdk_colormap_get_screen
 gdk_color_copy
@@ -320,6 +407,32 @@ gdk_drawable_get_size
 gdk_drawable_get_clip_region
 gdk_drawable_get_visible_region
 
+<SUBSECTION>
+gdk_draw_point
+gdk_draw_points
+gdk_draw_line
+gdk_draw_lines
+gdk_draw_pixbuf
+gdk_draw_segments
+GdkSegment
+gdk_draw_rectangle
+gdk_draw_arc
+gdk_draw_polygon
+gdk_draw_trapezoids
+GdkTrapezoid
+gdk_draw_glyphs
+gdk_draw_glyphs_transformed
+gdk_draw_layout_line
+gdk_draw_layout_line_with_colors
+gdk_draw_layout
+gdk_draw_layout_with_colors
+
+<SUBSECTION>
+gdk_draw_drawable
+gdk_draw_image
+gdk_drawable_get_image
+gdk_drawable_copy_to_image
+
 <SUBSECTION Standard>
 GDK_DRAWABLE
 GDK_DRAWABLE_GET_CLASS
@@ -332,6 +445,69 @@ GDK_IS_DRAWABLE_CLASS
 GdkDrawableClass
 </SECTION>
 
+<SECTION>
+<TITLE>Graphics Contexts</TITLE>
+<FILE>gcs</FILE>
+GdkGC
+GdkGCValues
+GdkGCValuesMask
+
+GdkFunction
+
+gdk_gc_new
+gdk_gc_new_with_values
+gdk_gc_get_screen
+gdk_gc_set_values
+gdk_gc_get_values
+gdk_gc_set_foreground
+gdk_gc_set_background
+gdk_gc_set_rgb_fg_color
+gdk_gc_set_rgb_bg_color
+gdk_gc_set_function
+gdk_gc_set_fill
+GdkFill
+gdk_gc_set_tile
+gdk_gc_set_stipple
+gdk_gc_set_ts_origin
+gdk_gc_set_clip_origin
+gdk_gc_set_clip_mask
+gdk_gc_set_clip_rectangle
+gdk_gc_set_clip_region
+gdk_gc_set_subwindow
+GdkSubwindowMode
+gdk_gc_set_exposures
+gdk_gc_set_line_attributes
+GdkLineStyle
+GdkCapStyle
+GdkJoinStyle
+gdk_gc_set_dashes
+gdk_gc_copy
+gdk_gc_set_colormap
+gdk_gc_get_colormap
+
+gdk_gc_offset
+
+<SUBSECTION Standard>
+GDK_GC
+GDK_TYPE_GC
+GDK_IS_GC
+GDK_GC_CLASS
+GDK_GC_GET_CLASS
+GDK_IS_GC_CLASS
+GDK_TYPE_CAP_STYLE
+GDK_TYPE_FILL
+GDK_TYPE_FILL_RULE
+GDK_TYPE_FUNCTION
+GDK_TYPE_GC_VALUES_MASK
+GDK_TYPE_JOIN_STYLE
+GDK_TYPE_LINE_STYLE
+GDK_TYPE_SUBWINDOW_MODE
+
+<SUBSECTION Private>
+GdkGCClass
+gdk_gc_get_type
+</SECTION>
+
 <SECTION>
 <TITLE>Visuals</TITLE>
 <FILE>visuals</FILE>
@@ -477,8 +653,9 @@ gdk_window_merge_child_input_shapes
 gdk_window_set_static_gravities
 gdk_window_set_title
 gdk_window_set_background
+gdk_window_get_background
 gdk_window_set_back_pixmap
-gdk_window_get_background_pattern
+gdk_window_get_back_pixmap
 GDK_PARENT_RELATIVE
 gdk_window_set_cursor
 gdk_window_get_cursor
@@ -640,16 +817,40 @@ GDK_TYPE_PROP_MODE
 <SECTION>
 <TITLE>Pango Interaction</TITLE>
 <FILE>pango_interaction</FILE>
-gdk_pango_layout_get_clip_region
-gdk_pango_layout_line_get_clip_region
+GdkPangoRenderer
+GdkPangoRendererClass
+gdk_pango_renderer_new
+gdk_pango_renderer_get_default
+gdk_pango_renderer_set_drawable
+gdk_pango_renderer_set_gc
+gdk_pango_renderer_set_stipple
+gdk_pango_renderer_set_override_color
 gdk_pango_context_get
 gdk_pango_context_get_for_screen
+GdkPangoAttrEmbossed
+GdkPangoAttrEmbossColor
+GdkPangoAttrStipple
+gdk_pango_attr_emboss_color_new
+gdk_pango_attr_embossed_new
+gdk_pango_attr_stipple_new
+gdk_pango_layout_get_clip_region
+gdk_pango_layout_line_get_clip_region
+<SUBSECTION Standard>
+GDK_TYPE_PANGO_RENDERER
+GDK_PANGO_RENDERER
+GDK_IS_PANGO_RENDERER
+GDK_PANGO_RENDERER_CLASS
+GDK_IS_PANGO_RENDERER_CLASS
+GDK_PANGO_RENDERER_GET_CLASS
+
+<SUBSECTION Private>
+gdk_pango_renderer_get_type
+GdkPangoRendererPrivate
 </SECTION>
 
 <SECTION>
 <TITLE>Cairo Interaction</TITLE>
 <FILE>cairo_interaction</FILE>
-gdk_window_create_similar_surface
 gdk_cairo_create
 gdk_cairo_set_source_color
 gdk_cairo_set_source_pixbuf
@@ -946,7 +1147,6 @@ gdk_cursor_new_from_name
 gdk_cursor_new_for_display
 gdk_cursor_get_display
 gdk_cursor_get_image
-gdk_cursor_get_cursor_type
 gdk_cursor_ref
 gdk_cursor_unref
 
@@ -1015,6 +1215,9 @@ GDK_PIXMAP_XID
 GDK_DISPLAY_XDISPLAY
 GDK_DRAWABLE_XDISPLAY
 GDK_DRAWABLE_XID
+GDK_IMAGE_XDISPLAY
+GDK_IMAGE_XIMAGE
+GDK_GC_XDISPLAY
 GDK_COLORMAP_XDISPLAY
 GDK_COLORMAP_XCOLORMAP
 GDK_SCREEN_XDISPLAY
@@ -1023,6 +1226,8 @@ GDK_SCREEN_XSCREEN
 GDK_VISUAL_XVISUAL
 GDK_CURSOR_XCURSOR
 GDK_CURSOR_XDISPLAY
+GDK_GC_XGC
+GDK_GC_GET_XGC
 GDK_WINDOW_XWINDOW
 gdkx_visual_get
 gdk_pixmap_foreign_new
@@ -1060,10 +1265,14 @@ gdk_x11_display_set_cursor_theme
 gdk_x11_register_standard_event_type
 gdk_x11_drawable_get_xdisplay
 gdk_x11_drawable_get_xid
+gdk_x11_gc_get_xdisplay
+gdk_x11_gc_get_xgc
 gdk_x11_get_default_root_xwindow
 gdk_x11_get_default_screen
 gdk_x11_get_default_xdisplay
 gdk_x11_grab_server
+gdk_x11_image_get_xdisplay
+gdk_x11_image_get_ximage
 gdk_x11_screen_get_screen_number
 gdk_x11_screen_get_xscreen
 gdk_x11_ungrab_server

docs/reference/gdk/gdk3.types

@@ -5,7 +5,9 @@ gdk_display_manager_get_type
 gdk_screen_get_type
 gdk_drawable_get_type
 gdk_window_object_get_type
+gdk_pango_renderer_get_type
 gdk_pixmap_get_type
+gdk_gc_get_type
 gdk_keymap_get_type
 gdk_device_get_type
 gdk_device_manager_get_type

docs/reference/gdk/tmpl/colors.sgml

@@ -116,6 +116,16 @@ The colormap structure contains the following public fields.
 @n_colors: 
 
 
+<!-- ##### FUNCTION gdk_colormap_query_color ##### -->
+<para>
+
+</para>
+
+@colormap: 
+@pixel: 
+@result: 
+
+
 <!-- ##### FUNCTION gdk_colormap_get_visual ##### -->
 <para>
 </para>

docs/reference/gdk/tmpl/cursors.sgml

@@ -199,15 +199,6 @@ The standard cursors available.
 @Returns: 
 
 
-<!-- ##### FUNCTION gdk_cursor_get_cursor_type ##### -->
-<para>
-
-</para>
-
-@cursor: 
-@Returns: 
-
-
 <!-- ##### FUNCTION gdk_cursor_ref ##### -->
 <para>
 

docs/reference/gdk/tmpl/drawing.sgml

@@ -127,3 +127,293 @@ or a #GdkWindow.
 @Returns: 
 
 
+<!-- ##### FUNCTION gdk_draw_point ##### -->
+<para>
+</para>
+
+@drawable: 
+@gc: 
+@x: 
+@y: 
+
+
+<!-- ##### FUNCTION gdk_draw_points ##### -->
+<para>
+</para>
+
+@drawable: 
+@gc: 
+@points: 
+@n_points: 
+
+
+<!-- ##### FUNCTION gdk_draw_line ##### -->
+<para>
+</para>
+
+@drawable: 
+@gc: 
+@x1_: 
+@y1_: 
+@x2_: 
+@y2_: 
+
+
+<!-- ##### FUNCTION gdk_draw_lines ##### -->
+<para>
+</para>
+
+@drawable: 
+@gc: 
+@points: 
+lines.
+@n_points: 
+
+
+<!-- ##### FUNCTION gdk_draw_pixbuf ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@gc: 
+@pixbuf: 
+@src_x: 
+@src_y: 
+@dest_x: 
+@dest_y: 
+@width: 
+@height: 
+@dither: 
+@x_dither: 
+@y_dither: 
+
+
+<!-- ##### FUNCTION gdk_draw_segments ##### -->
+<para>
+</para>
+
+@drawable: 
+@gc: 
+@segs: 
+@n_segs: 
+
+
+<!-- ##### STRUCT GdkSegment ##### -->
+<para>
+Specifies the start and end point of a line for use by the gdk_draw_segments()
+function.
+</para>
+
+@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.
+
+<!-- ##### FUNCTION gdk_draw_rectangle ##### -->
+<para>
+</para>
+<note>
+<para>
+</para>
+</note>
+
+@drawable: 
+@gc: 
+@filled: 
+@x: 
+@y: 
+@width: 
+@height: 
+
+
+<!-- ##### FUNCTION gdk_draw_arc ##### -->
+<para>
+</para>
+
+@drawable: 
+@gc: 
+@filled: 
+@x: 
+@y: 
+@width: 
+@height: 
+@angle1: 
+@angle2: 
+
+
+<!-- ##### FUNCTION gdk_draw_polygon ##### -->
+<para>
+</para>
+
+@drawable: 
+@gc: 
+@filled: 
+@points: 
+@n_points: 
+
+
+<!-- ##### FUNCTION gdk_draw_trapezoids ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@gc: 
+@trapezoids: 
+@n_trapezoids: 
+
+
+<!-- ##### STRUCT GdkTrapezoid ##### -->
+<para>
+Specifies a trapezpoid for use by the gdk_draw_trapezoids().
+The trapezoids used here have parallel, horizontal top and 
+bottom edges. 
+</para>
+
+@y1: the y coordinate of the start point.
+@x11: the x coordinate of the top left corner
+@x21: the x coordinate of the top right corner
+@y2: the y coordinate of the end point.
+@x12: the x coordinate of the bottom left corner
+@x22: the x coordinate of the bottom right corner
+
+<!-- ##### FUNCTION gdk_draw_glyphs ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@gc: 
+@font: 
+@x: 
+@y: 
+@glyphs: 
+
+
+<!-- ##### FUNCTION gdk_draw_glyphs_transformed ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@gc: 
+@matrix: 
+@font: 
+@x: 
+@y: 
+@glyphs: 
+
+
+<!-- ##### FUNCTION gdk_draw_layout_line ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@gc: 
+@x: 
+@y: 
+@line: 
+
+
+<!-- ##### FUNCTION gdk_draw_layout_line_with_colors ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@gc: 
+@x: 
+@y: 
+@line: 
+@foreground: 
+@background: 
+
+
+<!-- ##### FUNCTION gdk_draw_layout ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@gc: 
+@x: 
+@y: 
+@layout: 
+
+
+<!-- ##### FUNCTION gdk_draw_layout_with_colors ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@gc: 
+@x: 
+@y: 
+@layout: 
+@foreground: 
+@background: 
+
+
+<!-- ##### FUNCTION gdk_draw_drawable ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@gc: 
+@src: 
+@xsrc: 
+@ysrc: 
+@xdest: 
+@ydest: 
+@width: 
+@height: 
+
+
+<!-- ##### FUNCTION gdk_draw_image ##### -->
+<para>
+</para>
+
+@drawable: 
+@gc: 
+@image: 
+@xsrc: 
+@ysrc: 
+@xdest: 
+@ydest: 
+@width: 
+@height: 
+
+
+<!-- ##### FUNCTION gdk_drawable_get_image ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@x: 
+@y: 
+@width: 
+@height: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_drawable_copy_to_image ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@image: 
+@src_x: 
+@src_y: 
+@dest_x: 
+@dest_y: 
+@width: 
+@height: 
+@Returns: 
+
+

docs/reference/gdk/tmpl/event_structs.sgml

@@ -382,7 +382,8 @@ union, 16-bit data uses the s array, and 32-bit data uses the l array.
 
 <!-- ##### STRUCT GdkEventNoExpose ##### -->
 <para>
-Generated when the area of a #GdkDrawable being copied was completely available.
+Generated when the area of a #GdkDrawable being copied, with gdk_draw_drawable()
+, was completely available.
 </para>
 <para>
 FIXME: add more here.

docs/reference/gdk/tmpl/gcs.sgml

@@ -0,0 +1,427 @@
+<!-- ##### SECTION Title ##### -->
+Graphics Contexts
+
+<!-- ##### SECTION Short_Description ##### -->
+Objects to encapsulate drawing properties
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+All drawing operations in GDK take a 
+<firstterm>graphics context</firstterm> (GC) argument. 
+A graphics context encapsulates information about
+the way things are drawn, such as the foreground
+color or line width. By using graphics contexts, 
+the number of arguments to each drawing call is
+greatly reduced, and communication overhead is
+minimized, since identical arguments do not need
+to be passed repeatedly.
+</para>
+<para>
+Most values of a graphics context can be set at
+creation time by using gdk_gc_new_with_values(),
+or can be set one-by-one using functions such
+as gdk_gc_set_foreground(). A few of the values
+in the GC, such as the dash pattern, can only
+be set by the latter method.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### SECTION Stability_Level ##### -->
+
+
+<!-- ##### SECTION Image ##### -->
+
+
+<!-- ##### STRUCT GdkGC ##### -->
+<para>
+The #GdkGC structure represents a graphics context.
+It is an opaque structure with no user-visible
+elements.
+</para>
+
+
+<!-- ##### STRUCT GdkGCValues ##### -->
+<para>
+The #GdkGCValues structure holds a set of values used
+to create or modify a graphics context.
+</para>
+
+@foreground: the foreground color. Note that gdk_gc_get_values()
+  only sets the pixel value.
+@background: the background color. Note that gdk_gc_get_values()
+  only sets the pixel value.
+@font: the default font.
+@function: the bitwise operation used when drawing.
+@fill: the fill style.
+@tile: the tile pixmap.
+@stipple: the stipple bitmap.
+@clip_mask: the clip mask bitmap.
+@subwindow_mode: the subwindow mode.
+@ts_x_origin: the x origin of the tile or stipple.
+@ts_y_origin: the y origin of the tile or stipple.
+@clip_x_origin: the x origin of the clip mask.
+@clip_y_origin: the y origin of the clip mask.
+@graphics_exposures: whether graphics exposures are enabled.
+@line_width: the line width.
+@line_style: the way dashed lines are drawn.
+@cap_style: the way the ends of lines are drawn.
+@join_style: the way joins between lines are drawn.
+
+<!-- ##### ENUM GdkGCValuesMask ##### -->
+<para>
+A set of bit flags used to indicate which fields
+#GdkGCValues structure are set.
+</para>
+
+@GDK_GC_FOREGROUND: the @foreground is set.
+@GDK_GC_BACKGROUND: the @background is set.
+@GDK_GC_FUNCTION: the @function is set.
+@GDK_GC_FILL: the @fill is set.
+@GDK_GC_TILE: the @tile is set.
+@GDK_GC_STIPPLE: the @stipple is set.
+@GDK_GC_CLIP_MASK: the @clip_mask is set.
+@GDK_GC_SUBWINDOW: the @subwindow_mode is set.
+@GDK_GC_TS_X_ORIGIN: the @ts_x_origin is set.
+@GDK_GC_TS_Y_ORIGIN: the @ts_y_origin is set.
+@GDK_GC_CLIP_X_ORIGIN: the @clip_x_origin is set.
+@GDK_GC_CLIP_Y_ORIGIN: the @clip_y_origin is set.
+@GDK_GC_EXPOSURES: the @graphics_exposures is set.
+@GDK_GC_LINE_WIDTH: the @line_width is set.
+@GDK_GC_LINE_STYLE: the @line_style is set.
+@GDK_GC_CAP_STYLE: the @cap_style is set.
+@GDK_GC_JOIN_STYLE: the @join_style is set.
+
+<!-- ##### ENUM GdkFunction ##### -->
+<para>
+Determines how the bit values for the source pixels are combined with
+the bit values for destination pixels to produce the final result. The
+sixteen values here correspond to the 16 different possible 2x2 truth
+tables.  Only a couple of these values are usually useful; for colored
+images, only %GDK_COPY, %GDK_XOR and %GDK_INVERT are generally
+useful. For bitmaps, %GDK_AND and %GDK_OR are also useful.
+</para>
+
+@GDK_COPY: <literal>dst = src</literal>
+@GDK_INVERT: <literal>dst = NOT dst</literal>
+@GDK_XOR: <literal>dst = src XOR dst</literal>
+@GDK_CLEAR: <literal>dst = 0</literal>
+@GDK_AND: <literal>dst = dst AND src</literal>
+@GDK_AND_REVERSE: <literal>dst = src AND (NOT dst)</literal>
+@GDK_AND_INVERT: <literal>dst = (NOT src) AND dst</literal>
+@GDK_NOOP: <literal>dst = dst</literal>
+@GDK_OR: <literal>dst = src OR dst</literal>
+@GDK_EQUIV: <literal>dst = (NOT src) XOR dst</literal>
+@GDK_OR_REVERSE: <literal>dst = src OR (NOT dst)</literal>
+@GDK_COPY_INVERT: <literal>dst = NOT src</literal>
+@GDK_OR_INVERT: <literal>dst = (NOT src) OR dst</literal>
+@GDK_NAND: <literal>dst = (NOT src) OR (NOT dst)</literal>
+@GDK_NOR: <literal>dst = (NOT src) AND (NOT dst)</literal>
+@GDK_SET: <literal>dst = 1</literal>
+
+<!-- ##### FUNCTION gdk_gc_new ##### -->
+<para>
+</para>
+
+@drawable: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_gc_new_with_values ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@values: 
+@values_mask: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_gc_get_screen ##### -->
+<para>
+
+</para>
+
+@gc: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_values ##### -->
+<para>
+
+</para>
+
+@gc: 
+@values: 
+@values_mask: 
+
+
+<!-- ##### FUNCTION gdk_gc_get_values ##### -->
+<para>
+
+</para>
+
+@gc: 
+@values: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_foreground ##### -->
+<para>
+
+</para>
+
+@gc: 
+@color: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_background ##### -->
+<para>
+
+</para>
+
+@gc: 
+@color: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_rgb_fg_color ##### -->
+<para>
+
+</para>
+
+@gc: 
+@color: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_rgb_bg_color ##### -->
+<para>
+
+</para>
+
+@gc: 
+@color: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_function ##### -->
+<para>
+
+</para>
+
+@gc: 
+@function: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_fill ##### -->
+<para>
+
+</para>
+
+@gc: 
+@fill: 
+
+
+<!-- ##### ENUM GdkFill ##### -->
+<para>
+Determines how primitives are drawn.
+</para>
+
+@GDK_SOLID: draw with the foreground color.
+@GDK_TILED: draw with a tiled pixmap.
+@GDK_STIPPLED: draw using the stipple bitmap. Pixels corresponding
+  to bits in the stipple bitmap that are set will be drawn in the
+  foreground color; pixels corresponding to bits that are
+  not set will be left untouched.
+@GDK_OPAQUE_STIPPLED: draw using the stipple bitmap. Pixels corresponding
+  to bits in the stipple bitmap that are set will be drawn in the
+  foreground color; pixels corresponding to bits that are
+  not set will be drawn with the background color.
+
+<!-- ##### FUNCTION gdk_gc_set_tile ##### -->
+<para>
+
+</para>
+
+@gc: 
+@tile: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_stipple ##### -->
+<para>
+
+</para>
+
+@gc: 
+@stipple: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_ts_origin ##### -->
+<para>
+
+</para>
+
+@gc: 
+@x: 
+@y: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_clip_origin ##### -->
+<para>
+
+</para>
+
+@gc: 
+@x: 
+@y: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_clip_mask ##### -->
+<para>
+
+</para>
+
+@gc: 
+@mask: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_clip_rectangle ##### -->
+<para>
+</para>
+
+@gc: 
+@rectangle: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_clip_region ##### -->
+<para>
+
+</para>
+
+@gc: 
+@region: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_subwindow ##### -->
+<para>
+
+</para>
+
+@gc: 
+@mode: 
+
+
+<!-- ##### ENUM GdkSubwindowMode ##### -->
+<para>
+Determines how drawing onto a window will affect child
+windows of that window. 
+</para>
+
+@GDK_CLIP_BY_CHILDREN: only draw onto the window itself.
+@GDK_INCLUDE_INFERIORS: draw onto the window and child windows.
+
+<!-- ##### FUNCTION gdk_gc_set_exposures ##### -->
+<para>
+
+</para>
+
+@gc: 
+@exposures: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_line_attributes ##### -->
+<para>
+
+</para>
+
+@gc: 
+@line_width: 
+@line_style: 
+@cap_style: 
+@join_style: 
+
+
+<!-- ##### ENUM GdkLineStyle ##### -->
+<para>
+Determines how lines are drawn.
+</para>
+
+@GDK_LINE_SOLID: lines are drawn solid.
+@GDK_LINE_ON_OFF_DASH: even segments are drawn; odd segments are not drawn.
+@GDK_LINE_DOUBLE_DASH: even segments are normally. Odd segments are drawn
+  in the background color if the fill style is %GDK_SOLID, or in the background
+  color masked by the stipple if the fill style is %GDK_STIPPLED.
+
+<!-- ##### ENUM GdkCapStyle ##### -->
+<para>
+Determines how the end of lines are drawn.
+</para>
+
+@GDK_CAP_NOT_LAST: the same as %GDK_CAP_BUTT for lines of non-zero width.
+       for zero width lines, the final point on the line will not be drawn.
+@GDK_CAP_BUTT: the ends of the lines are drawn squared off and extending
+       to the coordinates of the end point.
+@GDK_CAP_ROUND: the ends of the lines are drawn as semicircles with the
+       diameter equal to the line width and centered at the end point.
+@GDK_CAP_PROJECTING: the ends of the lines are drawn squared off and extending
+       half the width of the line beyond the end point.
+
+<!-- ##### ENUM GdkJoinStyle ##### -->
+<para>
+Determines how the joins between segments of a polygon are drawn.
+</para>
+
+@GDK_JOIN_MITER: the sides of each line are extended to meet at an angle.
+@GDK_JOIN_ROUND: the sides of the two lines are joined by a circular arc.
+@GDK_JOIN_BEVEL: the sides of the two lines are joined by a straight line which
+       makes an equal angle with each line.
+
+<!-- ##### FUNCTION gdk_gc_set_dashes ##### -->
+<para>
+
+</para>
+
+@gc: 
+@dash_offset: 
+@dash_list: 
+@n: 
+
+
+<!-- ##### FUNCTION gdk_gc_copy ##### -->
+<para>
+
+</para>
+
+@dst_gc: 
+@src_gc: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_colormap ##### -->
+<para>
+
+</para>
+
+@gc: 
+@colormap: 
+
+
+<!-- ##### FUNCTION gdk_gc_get_colormap ##### -->
+<para>
+
+</para>
+
+@gc: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_gc_offset ##### -->
+<para>
+
+</para>
+
+@gc: 
+@x_offset: 
+@y_offset: 
+
+

docs/reference/gdk/tmpl/gdkdisplay.sgml

@@ -190,15 +190,6 @@ of an X display. All its fields are private and should not be accessed directly.
 @display: 
 
 
-<!-- ##### FUNCTION gdk_display_is_closed ##### -->
-<para>
-
-</para>
-
-@display: 
-@Returns: 
-
-
 <!-- ##### FUNCTION gdk_display_list_devices ##### -->
 <para>
 

docs/reference/gdk/tmpl/gdkscreen.sgml

@@ -113,6 +113,24 @@ when GDK gets multihead support.
 @Returns: 
 
 
+<!-- ##### FUNCTION gdk_screen_get_rgb_colormap ##### -->
+<para>
+
+</para>
+
+@screen: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_screen_get_rgb_visual ##### -->
+<para>
+
+</para>
+
+@screen: 
+@Returns: 
+
+
 <!-- ##### FUNCTION gdk_screen_get_rgba_colormap ##### -->
 <para>
 

docs/reference/gdk/tmpl/images.sgml

@@ -0,0 +1,228 @@
+<!-- ##### SECTION Title ##### -->
+Images
+
+<!-- ##### SECTION Short_Description ##### -->
+A client-side area for bit-mapped graphics
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+The #GdkImage type represents an area for drawing graphics.
+It has now been superceded to a large extent by the much more flexible
+<link linkend="gdk-GdkRGB">GdkRGB</link> functions.
+</para>
+<para>
+To create an empty #GdkImage use gdk_image_new().
+To create an image from part of a #GdkWindow use gdk_drawable_get_image().
+</para>
+<para>
+The image can be manipulated with gdk_image_get_pixel() and
+gdk_image_put_pixel(), or alternatively by changing the actual pixel data.
+Though manipulating the pixel data requires complicated code to cope with
+the different formats that may be used.
+</para>
+<para>
+To draw a #GdkImage in a #GdkWindow or #GdkPixmap use gdk_draw_image().
+</para>
+<para>
+To destroy a #GdkImage use g_object_unref().
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+<variablelist>
+
+<varlistentry>
+<term><link linkend="gdk-Bitmaps-and-Pixmaps">Bitmaps and Pixmaps</link></term>
+<listitem><para>
+Graphics which are stored on the X Windows server.
+Since these are stored on the server they can be drawn very quickly, and all
+of the <link linkend="gdk-Drawing-Primitives">Drawing Primitives</link> can be
+used to draw on them. Their main disadvantage is that manipulating individual
+pixels can be very slow.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><link linkend="gdk-GdkRGB">GdkRGB</link></term>
+<listitem><para>
+Built on top of #GdkImage, this provides much more functionality,
+including the dithering of colors to produce better output on low-color
+displays.
+</para></listitem>
+</varlistentry>
+
+</variablelist>
+</para>
+
+<!-- ##### SECTION Stability_Level ##### -->
+
+
+<!-- ##### SECTION Image ##### -->
+
+
+<!-- ##### STRUCT GdkImage ##### -->
+<para>
+The #GdkImage struct contains information on the image and the pixel data.
+</para>
+
+@parent_instance: the parent instance
+
+<!-- ##### FUNCTION gdk_image_new ##### -->
+<para>
+Creates a new #GdkImage.
+</para>
+
+@type: the type of the #GdkImage, one of %GDK_IMAGE_NORMAL, %GDK_IMAGE_SHARED
+and %GDK_IMAGE_FASTEST. %GDK_IMAGE_FASTEST is probably the best choice, since
+it will try creating a %GDK_IMAGE_SHARED image first and if that fails it will
+then use %GDK_IMAGE_NORMAL.
+@visual: the #GdkVisual to use for the image.
+@width: the width of the image in pixels.
+@height: the height of the image in pixels.
+@Returns: a new #GdkImage, or %NULL if the image could not be created.
+
+
+<!-- ##### ENUM GdkImageType ##### -->
+<para>
+Specifies the type of a #GdkImage.
+</para>
+
+@GDK_IMAGE_NORMAL: The original X image type, which is quite slow since the
+image has to be transferred from the client to the server to display it.
+@GDK_IMAGE_SHARED: A faster image type, which uses shared memory to transfer
+the image data between client and server. However this will only be available
+if client and server are on the same machine and the shared memory extension
+is supported by the server.
+@GDK_IMAGE_FASTEST: Specifies that %GDK_IMAGE_SHARED should be tried first,
+and if that fails then %GDK_IMAGE_NORMAL will be used.
+
+<!-- ##### FUNCTION gdk_image_get_colormap ##### -->
+<para>
+
+</para>
+
+@image: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_image_set_colormap ##### -->
+<para>
+
+</para>
+
+@image: 
+@colormap: 
+
+
+<!-- ##### FUNCTION gdk_image_get_bits_per_pixel ##### -->
+<para>
+
+</para>
+
+@image: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_image_get_bytes_per_pixel ##### -->
+<para>
+
+</para>
+
+@image: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_image_get_bytes_per_line ##### -->
+<para>
+
+</para>
+
+@image: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_image_get_byte_order ##### -->
+<para>
+
+</para>
+
+@image: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_image_get_depth ##### -->
+<para>
+
+</para>
+
+@image: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_image_get_height ##### -->
+<para>
+
+</para>
+
+@image: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_image_get_image_type ##### -->
+<para>
+
+</para>
+
+@image: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_image_get_visual ##### -->
+<para>
+
+</para>
+
+@image: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_image_get_width ##### -->
+<para>
+
+</para>
+
+@image: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_image_get_pixels ##### -->
+<para>
+
+</para>
+
+@image: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_image_put_pixel ##### -->
+<para>
+Sets a pixel in a #GdkImage to a given pixel value.
+</para>
+
+@image: a #GdkImage.
+@x: the x coordinate of the pixel to set.
+@y: the y coordinate of the pixel to set.
+@pixel: the pixel value to set.
+
+
+<!-- ##### FUNCTION gdk_image_get_pixel ##### -->
+<para>
+Gets a pixel value at a specified position in a #GdkImage.
+</para>
+
+@image: a #GdkImage.
+@x: the x coordinate of the pixel to get.
+@y: the y coordinate of the pixel to get.
+@Returns: the pixel value at the given position.
+
+

docs/reference/gdk/tmpl/keys.sgml

@@ -238,15 +238,6 @@ Returns: %PANGO_DIRECTION_LTR or %PANGO_DIRECTION_RTL.
 @Returns: 
 
 
-<!-- ##### FUNCTION gdk_keymap_get_num_lock_state ##### -->
-<para>
-
-</para>
-
-@keymap: 
-@Returns: 
-
-
 <!-- ##### FUNCTION gdk_keymap_add_virtual_modifiers ##### -->
 <para>
 

docs/reference/gdk/tmpl/pango_interaction.sgml

@@ -25,10 +25,11 @@ linkend="PANGO-SCALE-CAPS">PANGO_SCALE</link> or the PANGO_PIXELS() macro.)
 </para>
 <para>
 Rendering a Pango layout is done most simply with gdk_draw_layout();
-you can also draw pieces of the layout with gdk_draw_layout().
-#GdkPangoRenderer is a subclass of #PangoRenderer that is used internally
-to implement these functions. Using it directly or subclassing it can be
-useful in some cases. See the #GdkPangoRenderer documentation for details.
+you can also draw pieces of the layout with gdk_draw_layout() or
+gdk_draw_glyphs(). #GdkPangoRenderer is a subclass of #PangoRenderer
+that is used internally to implement these functions. Using it
+directly or subclassing it can be useful in some cases. See the
+#GdkPangoRenderer documentation for details.
 </para>
 <example id="rotated-example">
 <title>Using #GdkPangoRenderer to draw transformed text</title>
@@ -134,6 +135,150 @@ g_object_unref (gc);
 <!-- ##### SECTION Image ##### -->
 
 
+<!-- ##### STRUCT GdkPangoRenderer ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### ARG GdkPangoRenderer:screen ##### -->
+<para>
+
+</para>
+
+<!-- ##### STRUCT GdkPangoRendererClass ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gdk_pango_renderer_new ##### -->
+<para>
+
+</para>
+
+@screen: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pango_renderer_get_default ##### -->
+<para>
+
+</para>
+
+@screen: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pango_renderer_set_drawable ##### -->
+<para>
+
+</para>
+
+@gdk_renderer: 
+@drawable: 
+
+
+<!-- ##### FUNCTION gdk_pango_renderer_set_gc ##### -->
+<para>
+
+</para>
+
+@gdk_renderer: 
+@gc: 
+
+
+<!-- ##### FUNCTION gdk_pango_renderer_set_stipple ##### -->
+<para>
+
+</para>
+
+@gdk_renderer: 
+@part: 
+@stipple: 
+
+
+<!-- ##### FUNCTION gdk_pango_renderer_set_override_color ##### -->
+<para>
+
+</para>
+
+@gdk_renderer: 
+@part: 
+@color: 
+
+
+<!-- ##### FUNCTION gdk_pango_context_get ##### -->
+<para>
+
+</para>
+
+@void: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pango_context_get_for_screen ##### -->
+<para>
+
+</para>
+
+@screen: 
+@Returns: 
+
+
+<!-- ##### STRUCT GdkPangoAttrEmbossed ##### -->
+<para>
+A Pango text attribute containing a embossed bitmap to be used when
+rendering the text.
+</para>
+
+@attr: the #PangoAttribute.
+@embossed: the embossed bitmap.
+
+<!-- ##### STRUCT GdkPangoAttrEmbossColor ##### -->
+<para>
+A Pango text attribute specifying the color to emboss text with.
+</para>
+
+@attr: the #PangoAttribute
+@color: the color
+
+<!-- ##### STRUCT GdkPangoAttrStipple ##### -->
+<para>
+A Pango text attribute containing a stipple bitmap to be used when
+rendering the text.
+</para>
+
+@attr: the #PangoAttribute.
+@stipple: the stipple bitmap.
+
+<!-- ##### FUNCTION gdk_pango_attr_emboss_color_new ##### -->
+<para>
+
+</para>
+
+@color: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pango_attr_embossed_new ##### -->
+<para>
+
+</para>
+
+@embossed: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pango_attr_stipple_new ##### -->
+<para>
+
+</para>
+
+@stipple: 
+@Returns: 
+
+
 <!-- ##### FUNCTION gdk_pango_layout_get_clip_region ##### -->
 <para>
 

docs/reference/gdk/tmpl/pixbufs.sgml

@@ -83,13 +83,14 @@ pixbufs, see the #GdkPixbuf API documentation.
 @Returns: 
 
 
-<!-- ##### FUNCTION gdk_pixbuf_get_from_surface ##### -->
+<!-- ##### FUNCTION gdk_pixbuf_get_from_image ##### -->
 <para>
 
 </para>
 
 @dest: 
-@surface: 
+@src: 
+@cmap: 
 @src_x: 
 @src_y: 
 @dest_x: 

docs/reference/gdk/tmpl/pixmaps.sgml

@@ -8,7 +8,7 @@ Offscreen drawables
 <para>
 Pixmaps are offscreen drawables. They can be drawn upon with the
 standard drawing primitives, then copied to another drawable (such as
-a #GdkWindow). The depth of a pixmap
+a #GdkWindow) with gdk_draw_drawable(). The depth of a pixmap
 is the number of bits per pixels. Bitmaps are simply pixmaps
 with a depth of 1. (That is, they are monochrome bitmaps - each
 pixel can be either on or off).
@@ -49,6 +49,78 @@ for the new pixmap. Can be %NULL if @depth is specified,
 @Returns: the #GdkPixmap
 
 
+<!-- ##### FUNCTION gdk_bitmap_create_from_data ##### -->
+<para>
+Creates a new bitmap from data in XBM format.
+</para>
+
+@drawable: a #GdkDrawable, used to determine default values
+for the new pixmap. Can be %NULL, in which case the root
+window is used.
+@data: a pointer to the XBM data.
+@width: the width of the new pixmap in pixels.
+@height: the height of the new pixmap in pixels.
+@Returns: the #GdkBitmap
+
+
+<!-- ##### FUNCTION gdk_pixmap_create_from_data ##### -->
+<para>
+Create a two-color pixmap from data in XBM data.
+</para>
+
+@drawable: a #GdkDrawable, used to determine default values
+for the new pixmap. Can be %NULL, if the depth is given.
+@data: a pointer to the data.
+@width: the width of the new pixmap in pixels.
+@height: the height of the new pixmap in pixels.
+@depth: the depth (number of bits per pixel) of the new pixmap.
+@fg: the foreground color.
+@bg: the background color.
+@Returns: the #GdkPixmap
+
+
+<!-- ##### FUNCTION gdk_pixmap_create_from_xpm ##### -->
+
+
+@drawable: 
+@mask: 
+@transparent_color: 
+@filename: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixmap_colormap_create_from_xpm ##### -->
+
+
+@drawable: 
+@colormap: 
+@mask: 
+@transparent_color: 
+@filename: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixmap_create_from_xpm_d ##### -->
+
+
+@drawable: 
+@mask: 
+@transparent_color: 
+@data: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixmap_colormap_create_from_xpm_d ##### -->
+
+
+@drawable: 
+@colormap: 
+@mask: 
+@transparent_color: 
+@data: 
+@Returns: 
+
+
 <!-- ##### TYPEDEF GdkBitmap ##### -->
 <para>
 An opaque structure representing an offscreen drawable of depth

docs/reference/gdk/tmpl/rgb.sgml

@@ -0,0 +1,410 @@
+<!-- ##### SECTION Title ##### -->
+GdkRGB
+
+<!-- ##### SECTION Short_Description ##### -->
+Renders RGB, grayscale, or indexed image data to a GdkDrawable
+
+<!-- ##### SECTION Long_Description ##### -->
+
+<para>
+GdkRGB is a low-level module which renders RGB, grayscale, and indexed
+colormap images to a #GdkDrawable. It does this as efficiently as
+possible, handling issues such as colormaps, visuals, dithering,
+temporary buffers, and so on. Most code should use the higher-level
+#GdkPixbuf features in place of this module; for example,
+gdk_draw_pixbuf() uses GdkRGB in its implementation.
+</para>
+
+<para>
+GdkRGB allocates a color cube to use when rendering images.  You can
+set the threshold for installing colormaps with
+gdk_rgb_set_min_colors(). The default is 5x5x5 (125). If a colorcube
+of this size or larger can be allocated in the default colormap, then
+that's done. Otherwise, GdkRGB creates its own private colormap.
+Setting it to 0 means that it always tries to use the default
+colormap, and setting it to 216 means that it always creates a private
+one if it cannot allocate the 6x6x6 colormap in the default. If you
+always want a private colormap (to avoid consuming too many colormap
+entries for other apps, say), you can use 
+<literal>gdk_rgb_set_install(TRUE)</literal>.
+Setting the value greater than 216 exercises a bug in older versions
+of GdkRGB. Note, however, that setting it to 0 doesn't let you get
+away with ignoring the colormap and visual - a colormap is always
+created in grayscale and direct color modes, and the visual is changed
+in cases where a "better" visual than the default is available.
+</para>
+
+<para>
+If GDK is built with the Sun mediaLib library, the GdkRGB functions are
+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.
+</para>
+
+<example>
+<title>A simple example program using GdkRGB</title>
+<programlisting>
+&num;include &lt;gtk/gtk.h&gt;
+
+&num;define IMAGE_WIDTH	256
+&num;define IMAGE_HEIGHT	256
+
+guchar rgbbuf[IMAGE_WIDTH * IMAGE_HEIGHT * 3];
+
+gboolean on_darea_expose (GtkWidget *widget,
+			  GdkEventExpose *event,
+			  gpointer user_data);
+
+int
+main (int argc, char *argv[])
+{
+  GtkWidget *window, *darea;
+  gint x, y;
+  guchar *pos;
+
+  gtk_init (&amp;argc, &amp;argv);
+
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  darea = gtk_drawing_area_new (<!-- -->);
+  gtk_widget_set_size_request (darea, IMAGE_WIDTH, IMAGE_HEIGHT);
+  gtk_container_add (GTK_CONTAINER (window), darea);
+  gtk_signal_connect (GTK_OBJECT (darea), "expose-event",
+                      GTK_SIGNAL_FUNC (on_darea_expose), NULL);
+  gtk_widget_show_all (window);
+
+  /* Set up the RGB buffer. */
+  pos = rgbbuf;
+  for (y = 0; y &lt; IMAGE_HEIGHT; y++)
+    {
+      for (x = 0; x &lt; IMAGE_WIDTH; x++)
+	{
+	  *pos++ = x - x % 32;			/* Red. */
+	  *pos++ = (x / 32) * 4 + y - y % 32;	/* Green. */
+	  *pos++ = y - y % 32;			/* Blue. */
+	}
+    }
+
+  gtk_main (<!-- -->);
+  return 0;
+}
+
+
+gboolean
+on_darea_expose (GtkWidget *widget,
+		 GdkEventExpose *event,
+		 gpointer user_data)
+{
+  gdk_draw_rgb_image (widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
+		      0, 0, IMAGE_WIDTH, IMAGE_HEIGHT,
+		      GDK_RGB_DITHER_MAX, rgbbuf, IMAGE_WIDTH * 3);
+
+  return TRUE;
+}
+</programlisting>
+</example>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+<variablelist>
+
+<varlistentry>
+<term>#GdkColor</term>
+<listitem><para>The underlying GDK mechanism for allocating
+colors.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term>#GdkPixbuf and gdk_draw_pixbuf()</term>
+<listitem><para>Higher-level image handling.</para></listitem>
+</varlistentry>
+
+</variablelist>
+
+</para>
+
+<!-- ##### SECTION Stability_Level ##### -->
+
+
+<!-- ##### SECTION Image ##### -->
+
+
+<!-- ##### FUNCTION gdk_draw_rgb_image ##### -->
+<para>
+Draws an RGB image in the drawable. This is the core GdkRGB
+function, and likely the only one you will need to use.
+</para>
+
+<para>
+The @rowstride parameter allows for lines to be aligned more flexibly.
+For example, lines may be allocated to begin on 32-bit boundaries,
+even if the width of the rectangle is odd. Rowstride is also useful
+when drawing a subrectangle of a larger image in memory. Finally, to
+replicate the same line a number of times, the trick of setting
+@rowstride to 0 is allowed.
+</para>
+
+<para>
+In general, for 0 &lt;= i &lt; @width and 0 &lt;= j &lt; height,
+the pixel (x + i, y + j) is colored with red value @rgb_buf[@j *
+@rowstride + @i * 3], green value @rgb_buf[@j * @rowstride + @i * 3 +
+1], and blue value @rgb_buf[@j * @rowstride + @i * 3 + 2].
+</para>
+
+@drawable: The #GdkDrawable to draw in (usually a #GdkWindow).
+@gc: The graphics context (all GDK drawing operations require one; its
+contents are ignored).
+@x: The x coordinate of the top-left corner in the drawable.
+@y: The y coordinate of the top-left corner in the drawable.
+@width: The width of the rectangle to be drawn.
+@height: The height of the rectangle to be drawn.
+@dith: A #GdkRgbDither value, selecting the desired dither mode.
+@rgb_buf: The pixel data, represented as packed 24-bit data.
+@rowstride: The number of bytes from the start of one row in @rgb_buf to the
+start of the next.
+
+
+<!-- ##### FUNCTION gdk_draw_rgb_image_dithalign ##### -->
+<para>
+Draws an RGB image in the drawable, with an adjustment for dither alignment.
+</para>
+
+<para>
+This function is useful when drawing dithered images into a window
+that may be scrolled. Pixel (x, y) will be drawn dithered as if its
+actual location is (x + @xdith, y + @ydith). Thus, if you draw an
+image into a window using zero dither alignment, then scroll up one
+pixel, subsequent draws to the window should have @ydith = 1.
+</para>
+
+<para>
+Setting the dither alignment correctly allows updating of small parts
+of the screen while avoiding visible "seams" between the different
+dither textures.
+</para>
+
+@drawable: The #GdkDrawable to draw in (usually a #GdkWindow).
+@gc: The graphics context.
+@x: The x coordinate of the top-left corner in the drawable.
+@y: The y coordinate of the top-left corner in the drawable.
+@width: The width of the rectangle to be drawn.
+@height: The height of the rectangle to be drawn.
+@dith: A #GdkRgbDither value, selecting the desired dither mode.
+@rgb_buf: The pixel data, represented as packed 24-bit data.
+@rowstride: The number of bytes from the start of one row in @rgb_buf to the
+start of the next.
+@xdith: An x offset for dither alignment.
+@ydith: A y offset for dither alignment.
+
+
+<!-- ##### FUNCTION gdk_draw_indexed_image ##### -->
+<para>
+Draws an indexed image in the drawable, using a #GdkRgbCmap to assign
+actual colors to the color indices.
+</para>
+
+@drawable: The #GdkDrawable to draw in (usually a #GdkWindow).
+@gc: The graphics context.
+@x: The x coordinate of the top-left corner in the drawable.
+@y: The y coordinate of the top-left corner in the drawable.
+@width: The width of the rectangle to be drawn.
+@height: The height of the rectangle to be drawn.
+@dith: A #GdkRgbDither value, selecting the desired dither mode.
+@buf: The pixel data, represented as 8-bit color indices.
+@rowstride: The number of bytes from the start of one row in @buf to the
+start of the next.
+@cmap: The #GdkRgbCmap used to assign colors to the color indices.
+
+
+<!-- ##### FUNCTION gdk_draw_gray_image ##### -->
+<para>
+Draws a grayscale image in the drawable.
+
+</para>
+
+@drawable: The #GdkDrawable to draw in (usually a #GdkWindow).
+@gc: The graphics context.
+@x: The x coordinate of the top-left corner in the drawable.
+@y: The y coordinate of the top-left corner in the drawable.
+@width: The width of the rectangle to be drawn.
+@height: The height of the rectangle to be drawn.
+@dith: A #GdkRgbDither value, selecting the desired dither mode.
+@buf: The pixel data, represented as 8-bit gray values.
+@rowstride: The number of bytes from the start of one row in @buf to the
+start of the next.
+
+
+<!-- ##### FUNCTION gdk_draw_rgb_32_image ##### -->
+<para>
+Draws a padded RGB image in the drawable. The image is stored as one
+pixel per 32-bit word. It is laid out as a red byte, a green byte, a
+blue byte, and a padding byte.
+</para>
+
+<para>
+It's unlikely that this function will give significant performance
+gains in practice. In my experience, the performance gain from having
+pixels aligned to 32-bit boundaries is cancelled out by the increased
+memory bandwidth.
+</para>
+
+@drawable: The #GdkDrawable to draw in (usually a #GdkWindow).
+@gc: The graphics context.
+@x: The x coordinate of the top-left corner in the drawable.
+@y: The y coordinate of the top-left corner in the drawable.
+@width: The width of the rectangle to be drawn.
+@height: The height of the rectangle to be drawn.
+@dith: A #GdkRgbDither value, selecting the desired dither mode.
+@buf: The pixel data, represented as padded 32-bit data.
+@rowstride: The number of bytes from the start of one row in @buf to the
+start of the next.
+
+
+<!-- ##### FUNCTION gdk_draw_rgb_32_image_dithalign ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@gc: 
+@x: 
+@y: 
+@width: 
+@height: 
+@dith: 
+@buf: 
+@rowstride: 
+@xdith: 
+@ydith: 
+
+
+<!-- ##### ENUM GdkRgbDither ##### -->
+<para>
+Selects whether or not GdkRGB applies dithering
+to the image on display. 
+</para>
+
+<para>
+Since GdkRGB currently only handles images with 8 bits per component,
+dithering on 24 bit per pixel displays is a moot point.
+</para>
+
+@GDK_RGB_DITHER_NONE: Never use dithering.
+@GDK_RGB_DITHER_NORMAL: Use dithering in 8 bits per pixel (and below)
+only.
+@GDK_RGB_DITHER_MAX: Use dithering in 16 bits per pixel and below.
+
+<!-- ##### FUNCTION gdk_rgb_cmap_new ##### -->
+<para>
+Creates a new #GdkRgbCmap structure. The cmap maps color indexes to
+RGB colors. If @n_colors is less than 256, then images containing
+color values greater than or equal to @n_colors will produce undefined
+results, including possibly segfaults.
+</para>
+
+@colors: The colors, represented as 0xRRGGBB integer values.
+@n_colors: The number of colors in the cmap.
+@Returns: The newly created #GdkRgbCmap
+
+
+<!-- ##### FUNCTION gdk_rgb_cmap_free ##### -->
+<para>
+Frees the memory associated with a #GdkRgbCmap created by gdk_rgb_cmap_new().
+</para>
+
+@cmap: The #GdkRgbCmap to free.
+
+
+<!-- ##### STRUCT GdkRgbCmap ##### -->
+<para>
+A private data structure which maps color indices to actual RGB
+colors. This is used only for gdk_draw_indexed_image().
+</para>
+
+@colors: The colors, represented as 0xRRGGBB integer values.
+@n_colors: The number of colors in the cmap.
+
+<!-- ##### FUNCTION gdk_rgb_find_color ##### -->
+<para>
+
+</para>
+
+@colormap: 
+@color: 
+
+
+<!-- ##### FUNCTION gdk_rgb_set_install ##### -->
+<para>
+If @install is %TRUE, directs GdkRGB to always install a new "private"
+colormap rather than trying to find a best fit with the colors already
+allocated. Ordinarily, GdkRGB will install a colormap only if a
+sufficient cube cannot be allocated.
+</para>
+
+<para>
+A private colormap has more colors, leading to better quality display,
+but also leads to the dreaded "colormap flashing" effect.
+</para>
+
+@install: %TRUE to set install mode.
+
+
+<!-- ##### FUNCTION gdk_rgb_set_min_colors ##### -->
+<para>
+Sets the minimum number of colors for the color cube. Generally,
+GdkRGB tries to allocate the largest color cube it can. If it can't
+allocate a color cube at least as large as @min_colors, it installs a
+private colormap.
+</para>
+
+@min_colors: The minimum number of colors accepted.
+
+
+<!-- ##### FUNCTION gdk_rgb_get_visual ##### -->
+<para>
+</para>
+
+@void: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_rgb_get_colormap ##### -->
+<para>
+
+</para>
+
+@void: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_rgb_ditherable ##### -->
+<para>
+Determines whether the preferred visual is ditherable. This function may be
+useful for presenting a user interface choice to the user about which
+dither mode is desired; if the display is not ditherable, it may make
+sense to gray out or hide the corresponding UI widget.
+</para>
+
+@void: 
+@Returns: %TRUE if the preferred visual is ditherable.
+
+
+<!-- ##### FUNCTION gdk_rgb_colormap_ditherable ##### -->
+<para>
+Determines whether the visual associated with @cmap is ditherable. This 
+function may be useful for presenting a user interface choice to the user 
+about which dither mode is desired; if the display is not ditherable, it may 
+make sense to gray out or hide the corresponding UI widget.
+</para>
+
+@cmap: a #GdkColormap
+@Returns: %TRUE if the visual associated with @cmap is ditherable.
+
+
+<!-- ##### FUNCTION gdk_rgb_set_verbose ##### -->
+<para>
+Sets the "verbose" flag. This is generally only useful for debugging.
+</para>
+
+@verbose: %TRUE if verbose messages are desired.
+
+

docs/reference/gdk/tmpl/visuals.sgml

@@ -17,6 +17,14 @@ of an RGB pixel may be in the top 8 bits of the pixel, or may be in the lower
 4 bits.
 </para>
 <para>
+Usually you can avoid thinking about visuals in GTK+. Visuals are useful to
+interpret the contents of a #GdkImage, but you should avoid #GdkImage precisely
+because its contents depend on the display hardware; use #GdkPixbuf instead, for
+all but the most low-level purposes. Also, anytime you provide a #GdkColormap,
+the visual is implied as part of the colormap (gdk_colormap_get_visual()), so
+you won't have to provide a visual in addition.
+</para>
+<para>
 There are several standard visuals. The visual returned
 by gdk_visual_get_system() is the system's default
 visual. gdk_rgb_get_visual() return the visual most
@@ -40,7 +48,7 @@ then %GDK_VISUAL_STATIC_GRAY.
 
 <!-- ##### SECTION See_Also ##### -->
 <para>
-#GdkColormap
+#GdkImage, #GdkColormap, #GdkRGB
 </para>
 
 <!-- ##### SECTION Stability_Level ##### -->

docs/reference/gdk/tmpl/x_interaction.sgml

@@ -97,6 +97,33 @@ Returns the X resource (window or pixmap) belonging to a #GdkDrawable.
 @Returns: the ID of @win's X resource.
 
 
+<!-- ##### MACRO GDK_IMAGE_XDISPLAY ##### -->
+<para>
+Returns the display of a #GdkImage.
+</para>
+
+@image: a #GdkImage.
+@Returns: an Xlib <type>Display*</type>.
+
+
+<!-- ##### MACRO GDK_IMAGE_XIMAGE ##### -->
+<para>
+Returns the X image belonging to a #GdkImage.
+</para>
+
+@image: a #GdkImage.
+@Returns: an <type>XImage*</type>.
+
+
+<!-- ##### MACRO GDK_GC_XDISPLAY ##### -->
+<para>
+Returns the display of a #GdkGC.
+</para>
+
+@gc: a #GdkGC.
+@Returns: an Xlib <type>Display*</type>.
+
+
 <!-- ##### MACRO GDK_COLORMAP_XDISPLAY ##### -->
 <para>
 Returns the display of a #GdkColormap.
@@ -170,6 +197,24 @@ Returns the display of a #GdkCursor.
 @Returns: an Xlib <type>Display*</type>.
 
 
+<!-- ##### MACRO GDK_GC_XGC ##### -->
+<para>
+Returns the X GC of a #GdkGC.
+</para>
+
+@gc: a #GdkGC.
+@Returns: an Xlib <type>GC</type>.
+
+
+<!-- ##### MACRO GDK_GC_GET_XGC ##### -->
+<para>
+Returns the X GC of a #GdkGC.
+</para>
+
+@gc: a #GdkGC.
+@Returns: an Xlib <type>GC</type>.
+
+
 <!-- ##### MACRO GDK_WINDOW_XWINDOW ##### -->
 <para>
 Another name for GDK_DRAWABLE_XID(). 
@@ -512,6 +557,24 @@ Another name for GDK_DRAWABLE_XID().
 @Returns: 
 
 
+<!-- ##### FUNCTION gdk_x11_gc_get_xdisplay ##### -->
+<para>
+
+</para>
+
+@gc: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_x11_gc_get_xgc ##### -->
+<para>
+
+</para>
+
+@gc: 
+@Returns: 
+
+
 <!-- ##### FUNCTION gdk_x11_get_default_root_xwindow ##### -->
 <para>
 
@@ -547,6 +610,24 @@ Another name for GDK_DRAWABLE_XID().
 @void: 
 
 
+<!-- ##### FUNCTION gdk_x11_image_get_xdisplay ##### -->
+<para>
+
+</para>
+
+@image: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_x11_image_get_ximage ##### -->
+<para>
+
+</para>
+
+@image: 
+@Returns: 
+
+
 <!-- ##### FUNCTION gdk_x11_screen_get_screen_number ##### -->
 <para>
 

docs/reference/gtk/building.sgml

@@ -337,6 +337,14 @@ How to compile GTK+ itself
             <arg>--disable-shm</arg>
             <arg>--enable-shm</arg>
           </group>
+          <group>
+            <arg>--disable-xim</arg>
+            <arg>--enable-xim</arg>
+          </group>
+          <group>
+            <arg>--disable-xim-inst</arg>
+            <arg>--enable-xim-inst</arg>
+          </group>
           <group>
             <arg>--disable-xkb</arg>
             <arg>--enable-xkb</arg>
@@ -463,6 +471,30 @@ How to compile GTK+ itself
         </para>
       </formalpara>
 
+      <formalpara>
+        <title><systemitem>--disable-xim</systemitem> and
+          <systemitem>--enable-xim</systemitem></title>
+
+        <para>
+          These options can be used to control whether GTK+ will
+          be compiled with support for XIM. (The X Input Method
+          extension, used for Japanese input.) The default is yes.
+        </para>
+      </formalpara>
+
+      <formalpara>
+        <title><systemitem>--disable-xim-inst</systemitem> and
+          <systemitem>--enable-xim-inst</systemitem></title>
+
+        <para>
+          These options determine whether GTK+ will use the
+          XIM instantiate callback.
+          The default is 'yes', unless the host system is Solaris,
+          where <function>XRegisterIMInstantiateCallback()</function>
+          seems to cause a segfault.
+        </para>
+      </formalpara>
+
       <formalpara>
         <title><systemitem>--disable-xkb</systemitem> and
           <systemitem>--enable-xkb</systemitem></title>

docs/reference/gtk/gtk-docs.sgml

@@ -140,6 +140,7 @@ that is, GUI components such as #GtkButton or #GtkTextView.
     <xi:include href="xml/gtksettings.xml" />
     <xi:include href="xml/gtkbindings.xml" />
     <xi:include href="xml/gtkenums.xml" />
+    <xi:include href="xml/gtkgc.xml" />
     <xi:include href="xml/gtkstyle.xml" />
     <xi:include href="xml/gtkselection.xml" />
     <xi:include href="xml/gtkfeatures.xml" />
@@ -427,7 +428,7 @@ that is, GUI components such as #GtkButton or #GtkTextView.
     </partintro>
 
     <xi:include href="xml/migrating-checklist.sgml" />
-    <xi:include href="xml/migrating-2to3.xml" />
+    <xi:include href="migrating-2to3.xml" />
   </part>
 
   <part>

docs/reference/gtk/gtk3-sections.txt

@@ -18,8 +18,6 @@ gtk_about_dialog_get_license
 gtk_about_dialog_set_license
 gtk_about_dialog_get_wrap_license
 gtk_about_dialog_set_wrap_license
-gtk_about_dialog_get_license_type
-gtk_about_dialog_set_license_type
 gtk_about_dialog_get_website
 gtk_about_dialog_set_website
 gtk_about_dialog_get_website_label
@@ -423,6 +421,7 @@ gtk_aspect_frame_get_type
 <FILE>gtkbbox</FILE>
 <TITLE>GtkButtonBox</TITLE>
 GtkButtonBox
+GTK_BUTTONBOX_DEFAULT
 gtk_button_box_new
 gtk_button_box_get_layout
 gtk_button_box_get_child_secondary
@@ -459,6 +458,7 @@ gtk_bin_get_type
 <FILE>gtkbox</FILE>
 <TITLE>GtkBox</TITLE>
 GtkBox
+GtkBoxChild
 gtk_box_new
 gtk_box_pack_start
 gtk_box_pack_end
@@ -1155,8 +1155,6 @@ gtk_expander_set_use_markup
 gtk_expander_get_use_markup
 gtk_expander_set_label_widget
 gtk_expander_get_label_widget
-gtk_expander_set_label_fill
-gtk_expander_get_label_fill
 <SUBSECTION Standard>
 GTK_TYPE_EXPANDER
 GTK_EXPANDER_CLASS
@@ -1674,6 +1672,7 @@ GtkIconViewPrivate
 GtkImage
 GtkImageType
 gtk_image_get_icon_set
+gtk_image_get_image
 gtk_image_get_pixbuf
 gtk_image_get_pixmap
 gtk_image_get_stock
@@ -1683,6 +1682,7 @@ gtk_image_get_gicon
 gtk_image_get_storage_type
 gtk_image_new_from_file
 gtk_image_new_from_icon_set
+gtk_image_new_from_image
 gtk_image_new_from_pixbuf
 gtk_image_new_from_pixmap
 gtk_image_new_from_stock
@@ -1691,6 +1691,7 @@ gtk_image_new_from_icon_name
 gtk_image_new_from_gicon
 gtk_image_set_from_file
 gtk_image_set_from_icon_set
+gtk_image_set_from_image
 gtk_image_set_from_pixbuf
 gtk_image_set_from_pixmap
 gtk_image_set_from_stock
@@ -2023,7 +2024,6 @@ GTK_MENU_BAR_CLASS
 GTK_IS_MENU_BAR_CLASS
 GTK_MENU_BAR_GET_CLASS
 <SUBSECTION Private>
-GtkMenuBarPrivate
 gtk_menu_bar_get_type
 </SECTION>
 
@@ -2144,7 +2144,6 @@ GTK_MESSAGE_DIALOG_CLASS
 GTK_IS_MESSAGE_DIALOG_CLASS
 GTK_MESSAGE_DIALOG_GET_CLASS
 <SUBSECTION Private>
-GtkMessageDialogPriv
 gtk_message_dialog_get_type
 </SECTION>
 
@@ -2194,7 +2193,6 @@ GTK_MISC_CLASS
 GTK_IS_MISC_CLASS
 GTK_MISC_GET_CLASS
 <SUBSECTION Private>
-GtkMiscPriv
 gtk_misc_get_type
 </SECTION>
 
@@ -2202,6 +2200,7 @@ gtk_misc_get_type
 <FILE>gtknotebook</FILE>
 <TITLE>GtkNotebook</TITLE>
 GtkNotebook
+GtkNotebookPage
 gtk_notebook_new
 gtk_notebook_append_page
 gtk_notebook_append_page_menu
@@ -2239,8 +2238,6 @@ gtk_notebook_get_tab_label_text
 gtk_notebook_get_tab_pos
 gtk_notebook_get_tab_reorderable
 gtk_notebook_get_tab_detachable
-gtk_notebook_get_tab_hborder
-gtk_notebook_get_tab_vborder
 gtk_notebook_set_current_page
 gtk_notebook_set_group
 gtk_notebook_get_group
@@ -2258,7 +2255,6 @@ GTK_NOTEBOOK_GET_CLASS
 <SUBSECTION Private>
 gtk_notebook_get_type
 GtkNotebookTab
-GtkNotebookPriv
 </SECTION>
 
 <SECTION>
@@ -2377,7 +2373,6 @@ GTK_PROGRESS_BAR_CLASS
 GTK_IS_PROGRESS_BAR_CLASS
 GTK_PROGRESS_BAR_GET_CLASS
 <SUBSECTION Private>
-GtkProgressBarPriv
 gtk_progress_bar_get_type
 </SECTION>
 
@@ -2423,7 +2418,6 @@ GTK_RADIO_BUTTON_CLASS
 GTK_IS_RADIO_BUTTON_CLASS
 GTK_RADIO_BUTTON_GET_CLASS
 <SUBSECTION Private>
-GtkRadioButtonPriv
 gtk_radio_button_get_type
 </SECTION>
 
@@ -2447,7 +2441,6 @@ GTK_RADIO_MENU_ITEM_CLASS
 GTK_IS_RADIO_MENU_ITEM_CLASS
 GTK_RADIO_MENU_ITEM_GET_CLASS
 <SUBSECTION Private>
-GtkRadioMenuItemPriv
 gtk_radio_menu_item_get_type
 </SECTION>
 
@@ -2651,6 +2644,8 @@ gtk_recent_manager_remove_item
 gtk_recent_manager_lookup_item
 gtk_recent_manager_has_item
 gtk_recent_manager_move_item
+gtk_recent_manager_get_limit
+gtk_recent_manager_set_limit
 gtk_recent_manager_get_items
 gtk_recent_manager_purge_items
 <SUBSECTION>
@@ -2731,7 +2726,6 @@ GTK_RULER_CLASS
 GTK_IS_RULER_CLASS
 GTK_RULER_GET_CLASS
 <SUBSECTION Private>
-GtkRulerPriv
 gtk_ruler_get_type
 gtk_ruler_draw_ticks
 gtk_ruler_draw_pos
@@ -2761,7 +2755,6 @@ GTK_SCALE_CLASS
 GTK_IS_SCALE_CLASS
 GTK_SCALE_GET_CLASS
 <SUBSECTION Private>
-GtkScalePriv
 gtk_scale_get_type
 </SECTION>
 
@@ -2921,7 +2914,6 @@ GTK_SIZE_GROUP_CLASS
 GTK_IS_SIZE_GROUP_CLASS
 GTK_SIZE_GROUP_GET_CLASS
 <SUBSECTION Private>
-GtkSizeGroupPriv
 gtk_size_group_get_type
 </SECTION>
 
@@ -2983,7 +2975,6 @@ GTK_SPIN_BUTTON_CLASS
 GTK_IS_SPIN_BUTTON_CLASS
 GTK_SPIN_BUTTON_GET_CLASS
 <SUBSECTION Private>
-GtkSpinButtonPriv
 gtk_spin_button_get_type
 </SECTION>
 
@@ -3030,7 +3021,6 @@ GTK_STATUSBAR_CLASS
 GTK_IS_STATUSBAR_CLASS
 GTK_STATUSBAR_GET_CLASS
 <SUBSECTION Private>
-GtkStatusbarPriv
 gtk_statusbar_get_type
 </SECTION>
 
@@ -3114,7 +3104,6 @@ GTK_TABLE_CLASS
 GTK_IS_TABLE_CLASS
 GTK_TABLE_GET_CLASS
 <SUBSECTION Private>
-GtkTablePriv
 GtkTableChild
 GtkTableRowCol
 gtk_table_get_type
@@ -3133,7 +3122,6 @@ GTK_TEAROFF_MENU_ITEM_CLASS
 GTK_IS_TEAROFF_MENU_ITEM_CLASS
 GTK_TEAROFF_MENU_ITEM_GET_CLASS
 <SUBSECTION Private>
-GtkTearoffMenuItemPriv
 gtk_tearoff_menu_item_get_type
 </SECTION>
 
@@ -3228,7 +3216,6 @@ GTK_TEXT_BUFFER_CLASS
 GTK_IS_TEXT_BUFFER_CLASS
 GTK_TEXT_BUFFER_GET_CLASS
 <SUBSECTION Private>
-GtkTextBufferPrivate
 gtk_text_buffer_get_type
 GtkTextLogAttrCache
 </SECTION>
@@ -3405,7 +3392,6 @@ GTK_TEXT_TAG_TABLE_CLASS
 GTK_IS_TEXT_TAG_TABLE_CLASS
 GTK_TEXT_TAG_TABLE_GET_CLASS
 <SUBSECTION Private>
-GtkTextTagTablePriv
 gtk_text_tag_table_get_type
 </SECTION>
 
@@ -3495,7 +3481,6 @@ GTK_TEXT_CHILD_ANCHOR_CLASS
 GTK_IS_TEXT_CHILD_ANCHOR_CLASS
 GTK_TEXT_CHILD_ANCHOR_GET_CLASS
 <SUBSECTION Private>
-GtkTextViewPrivate
 gtk_text_view_get_type
 gtk_text_child_anchor_get_type
 GtkTextBTree
@@ -3610,7 +3595,7 @@ GTK_IS_TOOLBAR_CLASS
 GTK_TOOLBAR_GET_CLASS
 <SUBSECTION Private>
 gtk_toolbar_get_type
-GtkToolbarPriv
+GtkToolbarPrivate
 </SECTION>
 
 <SECTION>
@@ -4606,7 +4591,6 @@ GTK_LIST_STORE_CLASS
 GTK_IS_LIST_STORE_CLASS
 GTK_LIST_STORE_GET_CLASS
 <SUBSECTION Private>
-GtkListStorePriv
 gtk_list_store_get_type
 </SECTION>
 
@@ -4663,7 +4647,6 @@ GTK_VIEWPORT_CLASS
 GTK_IS_VIEWPORT_CLASS
 GTK_VIEWPORT_GET_CLASS
 <SUBSECTION Private>
-GtkViewportPriv
 gtk_viewport_get_type
 </SECTION>
 
@@ -5203,6 +5186,14 @@ GTK_INTERFACE_AGE
 GTK_CHECK_VERSION
 </SECTION>
 
+
+<SECTION>
+<FILE>gtkgc</FILE>
+<TITLE>Graphics Contexts</TITLE>
+gtk_gc_get
+gtk_gc_release
+</SECTION>
+
 <SECTION>
 <FILE>gtkstyle</FILE>
 <TITLE>GtkStyle</TITLE>
@@ -5231,6 +5222,7 @@ gtk_paint_focus
 gtk_paint_handle
 gtk_paint_hline
 gtk_paint_option
+gtk_paint_polygon
 gtk_paint_shadow
 gtk_paint_shadow_gap
 gtk_paint_slider
@@ -6312,14 +6304,12 @@ gtk_orientable_get_type
 GtkSizeRequest
 GtkSizeRequestIface
 GtkSizeRequestMode
-GtkRequestedSize
 gtk_size_request_get_height
 gtk_size_request_get_width
 gtk_size_request_get_height_for_width
 gtk_size_request_get_width_for_height
 gtk_size_request_get_request_mode
 gtk_size_request_get_size
-gtk_distribute_natural_allocation
 
 <SUBSECTION Standard>
 GTK_SIZE_REQUEST
@@ -6343,7 +6333,6 @@ gtk_application_quit
 gtk_application_set_action_group
 gtk_application_get_window
 gtk_application_add_window
-gtk_application_get_windows
 gtk_application_create_window
 
 <SUBSECTION Standard>

docs/reference/gtk/migrating-2to3.xml

@@ -6,69 +6,14 @@
   <title>Migrating from GTK+ 2.x to GTK+ 3</title>
 
   <para>
-    GTK+ 3 is a major new version of GTK+ that breaks both API and ABI
-    compared to GTK+ 2.x, which has remained API- and ABI-stable for a
-    long time. Thankfully, most of the changes are not hard to adapt to
-    and there are a number of steps that you can take to prepare your
-    GTK+ 2.x application for the switch to GTK+ 3. After that, there's
-    a small number of adjustments that you may have to do when you actually
-    switch your application to build against GTK+ 3.
+    There are a number of steps that you can take to prepare your GTK+ 2.x
+    application for the switch to GTK+ 3.
   </para>
 
   <section>
-    <title>Preparation in GTK+ 2.x</title>
-
-    <para>
-      The steps outlined in the following sections assume that your
-      application is working with GTK+ 2.22, which is the final stable
-      release of GTK+ 2.x. It includes all the necessary APIs and tools
-      to help you port your application to GTK+ 3. If you are still using
-      an older version of GTK+ 2.x, you should first get your application
-      to build and work with 2.22.
-    </para>
-
-  <section>
-  <title>Do not include individual headers</title>
+  <title>Only single includes</title>
   <para>
-    With GTK+ 2.x it was common to include just the header files for
-    a few widgets that your application was using, which could lead
-    to problems with missing definitions, etc. GTK+ 3 tightens the
-    rules about which header files you are allowed to include directly.
-    The allowed header files are are
-    <variablelist>
-      <varlistentry>
-        <term><filename>gtk/gtk.h</filename></term>
-        <listitem>for GTK</listitem>
-      </varlistentry>
-      <varlistentry>
-        <term><filename>gtk/gtkunixprint.h</filename></term>
-        <listitem>for low-level, UNIX-specific printing functions</listitem>
-      </varlistentry>
-      <varlistentry>
-        <term><filename>gdk-pixbuf/gdk-pixbuf.h</filename></term>
-        <listitem>for GdkPixbuf</listitem>
-      </varlistentry>
-      <varlistentry>
-        <term><filename>gdk/gdk.h</filename></term>
-        <listitem>for GDK</listitem>
-      </varlistentry>
-      <varlistentry>
-        <term><filename>gdk/gdkx.h</filename></term>
-        <listitem>for GDK functions that are X11-specific</listitem>
-      </varlistentry>
-      <varlistentry>
-        <term><filename>gdk/gdkkeysyms.h</filename></term>
-        <listitem>if you need the GDK keysym definitions</listitem>
-      </varlistentry>
-    </variablelist>
-    (these relative paths are assuming that you are using the include
-     paths that are specified in the gtk+-2.0.pc file, as returned by
-     <literal>pkg-config --cflags gtk+-2.0.pc</literal>.)
-  </para>
-  <para>
-    To check that your application only includes the allowed headers,
-    you can use defines to disable inclusion of individual headers,
-    as follows:
+    Make sure your program only include the toplevel headers:
     <programlisting>
     make CFLAGS+="-DG_DISABLE_SINGLE_INCLUDES -DGDK_PIXBUF_DISABLE_SINGLE_INCLUDES -DGTK_DISABLE_SINGLE_INCLUDES"
     </programlisting>
@@ -78,17 +23,8 @@
   <section>
   <title>Do not use deprecated symbols</title>
   <para>
-    Over the years, a number of functions, and in some cases, entire
-    widgets have been deprecated. These deprecations are clearly spelled
-    out in the API reference, with hints about the recommended replacements.
-    The API reference also includes an
-    <link linkend="api-index-deprecated">index</link> of all deprecated
-    symbols.
-  </para>
-  <para>
-    To verify that your program does not use any deprecated symbols,
-    you can use defines to remove deprecated symbols from the header files,
-    as follows:
+    Make sure your program doesn't use any functions that have been
+    deprecated in GTK+ 2.x:
     <programlisting>
     make CFLAGS+="-DG_DISABLE_DEPRECATED -DGDK_PIXBUF_DISABLE_DEPRECATED -DGDK_DISABLE_DEPRECATED -DGTK_DISABLE_DEPRECATED"
     </programlisting>
@@ -96,316 +32,23 @@
   </section>
 
   <section>
-  <title>Use accessor functions instead of direct access</title>
+  <title>Use accessor functions instead direct access</title>
   <para>
     GTK+ 3 removes many implementation details and struct members from
-    its public headers.
-  </para>
-  <para>
-    To ensure that your application does not have problems with this, you
-    define the preprocessor symbol <literal>GSEAL_ENABLE</literal>. This
-    will make the compiler catch all uses of direct access to struct fields
-    so that you can go through them one by one and replace them with a call
-    to an accessor function instead.
+    its public headers. To ensure that your application does not have problems
+    with this, you define the preprocessor symbol GSEAL_ENABLE. This will
+    make the compiler catch all uses of direct access to struct fields so that
+    you can go through them one by one and replace them with a call to an
+    accessor function instead.
     <programlisting>
     make CFLAGS+="-DGSEAL_ENABLE"
     </programlisting>
+    Starting with 2.90.4, GTK+'s .pc files turn on GSEAL_ENABLE by default.
   </para>
   </section>
 
   <section>
-    <title>Use cairo for drawing</title>
-    <para>
-      In GTK+ 3, the GDK drawing API (which closely mimics the X
-      drawing API, which is itself modeled after PostScript) has been
-      removed. All drawing in GTK+ 3 is done via cairo.
-    </para>
-    <para>
-      The #GdkGC and #GdkImage objects, as well as all the functions using
-      them are gone. This includes the <literal>gdk_draw_</literal> family
-      of functions like gdk_draw_rectangle() and gdk_draw_drawable(). As
-      #GdkGC is roughly equivalent to #cairo_t and #GdkImage was used for
-      drawing images to GdkDrawables, which cairo supports automatically,
-      a transition is usually straightforward.
-    </para>
-    <para>
-      The following examples show a few common drawing idioms used by
-      applications that have been ported to use cairo and how the code
-      was replaced.
-    </para>
-    <example>
-       <title>Drawing a GdkPixbuf onto a GdkDrawable</title>
-         <para>
-           Drawing a pixbuf onto a drawable used to be done like this:
-<programlisting><![CDATA[
-gdk_draw_pixbuf (window,
-                 gtk_widget_get_style (widget)->black_gc,
-                 pixbuf,
-                 0, 0
-                 x, y,
-                 gdk_pixbuf_get_width (pixbuf),
-                 gdk_pixbuf_get_height (pixbuf),
-                 GDK_RGB_DITHER_NORMAL,
-                 0, 0);
-]]></programlisting>
-           Doing the same thing with cairo:
-<programlisting><![CDATA[
-cairo_t *cr = gdk_cairo_create (window);
-gdk_cairo_set_source_pixbuf (cr, pixbuf, x, y);
-cairo_paint (cr);
-cairo_destroy (cr);
-]]></programlisting>
-           Note that very similar code can be used for drawing pixmaps
-           by using gdk_cairo_set_source_pixmap() instead of
-           gdk_cairo_set_source_pixbuf().
-         </para>
-      </example>
-      <example>
-        <title>Drawing a tiled GdkPixmap to a GdkDrawable</title>
-        <para>
-          Tiled pixmaps are often used for drawing backgrounds.
-          Old code looked something like this:
-          <programlisting><![CDATA[
-GdkGCValues gc_values;
-GdkGC *gc;
-
-/* setup */
-gc = gtk_widget_get_style (widget)->black_gc;
-gdk_gc_set_tile (gc, pixmap);
-gdk_gc_set_fill (gc, GDK_TILED);
-gdk_gc_set_ts_origin (gc, x_origin, y_origin);
-/* use */
-gdk_draw_rectangle (drawable, gc, TRUE, 0, 0, width, height);
-/* restore */
-gdk_gc_set_tile (gc, NULL);
-gdk_gc_set_fill (gc, GDK_SOLID);
-gdk_gc_set_ts_origin (gc, 0, 0);
-]]></programlisting>
-          The equivalent cairo code looks like this:
-<programlisting><![CDATA[
-cairo_t *cr;
-
-cr = gdk_cairo_create (drawable);
-gdk_cairo_set_source_pixmap (cr, pixmap, x_origin, y_origin);
-cairo_pattern_set_extend (cairo_get_source (cr), CAIRO_EXTEND_REPEAT);
-cairo_rectangle (cr, 0, 0, width, height);
-cairo_fill (cr);
-cairo_destroy (cr);
-]]></programlisting>
-          Again, you can exchange pixbufs and pixmaps by using
-          gdk_cairo_set_source_pixbuf() instead of
-          gdk_cairo_set_source_pixmap().
-        </para>
-      </example>
-      <example>
-        <title>Drawing a PangoLayout to a clipped area</title>
-        <para>
-          Drawing layouts clipped is often used to avoid overdraw or to
-          allow drawing selections. Code would have looked like this:
-<programlisting><![CDATA[
-GdkGC *gc;
-
-/* setup */
-gc = gtk_widget_get_style (widget)->text_gc[state];
-gdk_gc_set_clip_rectangle (gc, &area);
-/* use */
-gdk_draw_layout (drawable, gc, x, y, layout);
-/* restore */
-gdk_gc_set_clip_rectangle (gc, NULL);
-]]></programlisting>
-          With cairo, the same effect can be achieved using:
-<programlisting><![CDATA[
-cairo_t *cr;
-
-cr = gdk_cairo_create (drawable);
-/* clip */
-gdk_cairo_rectangle (cr, &area);
-cairo_clip (cr);
-/* set the correct source color */
-gdk_cairo_set_source_color (cr, &gtk_widget_get_style (widget)->text[state]);
-/* draw the text */
-cairo_move_to (cr, x, y);
-pango_cairo_show_layout (cr, layout);
-cairo_destroy (cr);
-]]></programlisting>
-          Clipping using cairo_clip() is of course not restricted to text
-          rendering and can be used everywhere where GC clips were used.
-          And using gdk_cairo_set_source_color() with style colors should
-          be used in all the places where a style’s GC was used to achieve
-          a particular color.
-        </para>
-      </example>
-    <section>
-      <title>what should you be aware of ?</title>
-      <formalpara><title>No more stippling</title>
-        <para>
-          Stippling is the usage of a bi-level mask, called a #GdkBitmap.
-          It was often used to achieve a checkerboard effect. You can use
-          cairo_mask() to achieve this effect. To get a checkerbox mask,
-          you can use code like this:
-<programlisting><![CDATA[
-static cairo_pattern_t *
-gtk_color_button_get_checkered (void)
-{
-    /* need to respect pixman's stride being a multiple of 4 */
-    static unsigned char data[8] = { 0xFF, 0x00, 0x00, 0x00,
-                                     0x00, 0xFF, 0x00, 0x00 };
-    cairo_surface_t *surface;
-    cairo_pattern_t *pattern;
-
-    surface = cairo_image_surface_create_for_data (data,
-                                                   CAIRO_FORMAT_A8,
-                                                   2, 2,
-                                                   4);
-    pattern = cairo_pattern_create_for_surface (surface);
-    cairo_surface_destroy (surface);
-    cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
-    cairo_pattern_set_filter (pattern, CAIRO_FILTER_NEAREST);
-
-    return pattern;
-}
-]]></programlisting>
-          Note that stippling looks very outdated in UIs, and is rarely
-          used in modern applications. All properties that made use of
-          stippling have been removed from GTK+ 3. Most prominently,
-          stippling is absent from text rendering, in particular #GtkTextTag.
-        </para>
-      </formalpara>
-      <formalpara><title>Using the the target drawable also as source or mask</title>
-        <para>
-          The gdk_draw_drawable() function allowed using the same drawable
-          as source and target. This was often used to achieve a scrolling
-          effect. Cairo does not allow this yet. You can however use
-          cairo_push_group() to get a different intermediate target that
-          you can copy to. So you can replace this code:
-<programlisting><![CDATA[
-gdk_draw_drawable (pixmap,
-                   gc,
-                   pixmap,
-                   area.x + dx, area.y + dy,
-                   area.x, area.y,
-                   area.width, area.height);
-]]></programlisting>
-          By using this code:
-<programlisting><![CDATA[
-cairo_t *cr = gdk_cairo_create (pixmap);
-/* clipping restricts the intermediate surface's size, so it's a good idea
- * to use it. */
-gdk_cairo_rectangle (cr, &area);
-cairo_clip (cr);
-/* Now push a group to change the target */
-cairo_push_group (cr);
-gdk_cairo_set_source_pixmap (cr, pixmap, dx, dy);
-cairo_paint (cr);
-/* Now copy the intermediate target back */
-cairo_pop_group_to_source (cr);
-cairo_paint (cr);
-cairo_destroy (cr);
-]]></programlisting>
-          The cairo developers plan to add self-copies in the future to allow
-          exactly this effect, so you might want to keep up on cairo
-          development to be able to change your code.
-        </para>
-      </formalpara>
-      <formalpara><title>Using pango_cairo_show_layout() instead of gdk_draw_layout_with_colors()</title>
-        <para>
-          GDK provided a way to ignore the color attributes of text and use
-          a hardcoded text color with the gdk_draw_layout_with_colors()
-          function. This is often used to draw text shadows or selections.
-          Pango’s cairo support does not yet provide this functionality. If
-          you use Pango layouts that change colors, the easiest way to achieve
-          a similar effect is using pango_cairo_layout_path() and cairo_fill()
-          instead of gdk_draw_layout_with_colors(). Note that this results in
-          a slightly uglier-looking text, as subpixel anti-aliasing is not
-          supported.
-        </para>
-      </formalpara>
-    </section>
-    </section>
-  </section>
-
-  <section>
-    <title>Changes that need to be done at the time of the switch</title>
-
-  <para>
-    This section outlines porting tasks that you need to tackle when
-    you get to the point that you actually build your application against
-    GTK+ 3. Making it possible to prepare for these in GTK+ 2.22 would
-    have been either impossible or impractical.
-  </para>
-
-  <section>
-    <title>Replace GdkRegion by cairo_region_t</title>
-
-    <para>
-      Starting with version 1.10, cairo provides a region API that is
-      equivalent to the GDK region API (which was itself copied from
-      the X server). Therefore, the region API has been removed in GTK+ 3.
-    </para>
-    <para>
-      Porting your application to the cairo region API should be a straight
-      find-and-replace task. Please refer to the following table:
-      <table>
-        <tgroup cols="2">
-          <thead>
-            <row><entry>GDK</entry><entry>cairo</entry></row>
-          </thead>
-          <tbody>
-            <row><entry>#GdkRegion</entry><entry>#cairo_region_t</entry></row>
-            <row><entry>#GdkRectangle</entry><entry>#cairo_rectangle_int_t</entry></row>
-            <row><entry>gdk_rectangle_intersect()</entry><entry>this function is still there</entry></row>
-            <row><entry>gdk_rectangle_union()</entry><entry>this function is still there</entry></row>
-            <row><entry>gdk_region_new()</entry><entry>cairo_region_create()</entry></row>
-            <row><entry>gdk_region_copy()</entry><entry>cairo_region_copy()</entry></row>
-            <row><entry>gdk_region_destroy()</entry><entry>cairo_region_destroy()</entry></row>
-            <row><entry>gdk_region_rectangle()</entry><entry>cairo_region_create_rectangle()</entry></row>
-            <row><entry>gdk_region_get_clipbox()</entry><entry>cairo_region_get_extents()</entry></row>
-            <row><entry>gdk_region_get_rectangles()</entry><entry>cairo_region_num_rectangles() and
-                                cairo_region_get_rectangle()</entry></row>
-            <row><entry>gdk_region_empty()</entry><entry>cairo_region_is_empty()</entry></row>
-            <row><entry>gdk_region_equal()</entry><entry>cairo_region_equal()</entry></row>
-            <row><entry>gdk_region_point_in()</entry><entry>cairo_region_contains_point()</entry></row>
-            <row><entry>gdk_region_rect_in()</entry><entry>cairo_region_contains_rectangle()</entry></row>
-            <row><entry>gdk_region_offset()</entry><entry>cairo_region_translate()</entry></row>
-            <row><entry>gdk_region_union_with_rect()</entry><entry>cairo_region_union_rectangle()</entry></row>
-            <row><entry>gdk_region_intersect()</entry><entry>cairo_region_intersect()</entry></row>
-            <row><entry>gdk_region_union()</entry><entry>cairo_region_union()</entry></row>
-            <row><entry>gdk_region_subtract()</entry><entry>cairo_region_subtract()</entry></row>
-            <row><entry>gdk_region_xor()</entry><entry>cairo_region_xor()</entry></row>
-            <row><entry>gdk_region_shrink()</entry><entry>no replacement</entry></row>
-            <row><entry>gdk_region_polygon()</entry><entry>no replacement, use cairo paths instead</entry></row>
-          </tbody>
-        </tgroup>
-      </table>
-    </para>
-  </section>
-
-  <section>
-    <title>Prevent mixed linkage</title>
-    <para>
-      Linking against GTK+ 2.x and GTK+ 3 in the same process is problematic
-      and can lead to hard-to-diagnose crashes. The gtk_init() function in
-      both GTK+ 2.22 and in GTK+ 3 tries to detect this situation and abort
-      with a diagnostic message, but this check is not 100% reliable (e.g. if
-      the problematic linking happens only in loadable modules).
-    </para>
-    <para>
-      Direct linking of your application against both versions of GTK+ is
-      easy to avoid; the problem gets harder when your application is using
-      libraries that are themselves linked against some version of GTK+.
-      In that case, you have to verify that you are using a version of the
-      library that is linked against GTK+ 3.
-    </para>
-    <para>
-      If you are using packages provided by a distributor, it is likely that
-      parallel installable versions of the library exist for GTK+ 2.x and
-      GTK+ 3, e.g for vte, check for vte3; for webkitgtk look for webkitgtk3,
-      and so on.
-    </para>
-  </section>
-
-  <section>
-  <title>Install GTK+ modules in the right place</title>
+  <title>GTK+ Modules</title>
   <para>
     Some software packages install loadable GTK+ modules such as theme engines,
     gdk-pixbuf loaders or input methods. Since GTK+ 3 is parallel-installable
@@ -435,7 +78,4 @@ cairo_destroy (cr);
     unhappiness and must be avoided.
   </para>
   </section>
-
-  </section>
-
 </chapter>

docs/reference/gtk/tmpl/.gitignore

@@ -20,7 +20,6 @@ gtkrecentchooser.sgml
 gtkrecentchooserdialog.sgml
 gtkrecentchoosermenu.sgml
 gtkrecentchooserwidget.sgml
-gtkrecentmanager.sgml
 gtkscalebutton.sgml
 gtkseparator.sgml
 gtkseparatormenuitem.sgml

docs/reference/gtk/tmpl/gtkdrawingarea.sgml

@@ -55,14 +55,11 @@ that drawing is implicitly clipped to the exposed area.
 gboolean
 expose_event_callback (GtkWidget *widget, GdkEventExpose *event, gpointer data)
 {
-  cairo_t *cr;
-  
-  cr = gdk_cairo_create (event->window);
-
-  cairo_set_source_rgb (cr, 0.0, 0.0, 1.0);
-  cairo_paint (cr);
-
-  cairo_destroy (cr);
+  gdk_draw_arc (widget->window,
+                widget->style->fg_gc[gtk_widget_get_state (widget)],
+                TRUE,
+                0, 0, widget->allocation.width, widget->allocation.height,
+                0, 64 * 360);
  
   return TRUE;
 }

docs/reference/gtk/tmpl/gtkexpander.sgml

@@ -115,11 +115,6 @@ a <child> type attribute.
 
 </para>
 
-<!-- ##### ARG GtkExpander:label-fill ##### -->
-<para>
-
-</para>
-
 <!-- ##### ARG GtkExpander:label-widget ##### -->
 <para>
 
@@ -276,21 +271,3 @@ a &lt;child&gt; type attribute.
 @Returns: 
 
 
-<!-- ##### FUNCTION gtk_expander_set_label_fill ##### -->
-<para>
-
-</para>
-
-@expander: 
-@label_fill: 
-
-
-<!-- ##### FUNCTION gtk_expander_get_label_fill ##### -->
-<para>
-
-</para>
-
-@expander: 
-@Returns: 
-
-

docs/reference/gtk/tmpl/gtkgc.sgml

@@ -0,0 +1,51 @@
+<!-- ##### SECTION Title ##### -->
+Graphics Contexts
+
+<!-- ##### SECTION Short_Description ##### -->
+A shared pool of GdkGC objects
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+These functions provide access to a shared pool of #GdkGC objects.
+When a new #GdkGC is needed, gtk_gc_get() is called with the required depth,
+colormap and #GdkGCValues. If a #GdkGC with the required properties already
+exists then that is returned. If not, a new #GdkGC is created.
+When the #GdkGC is no longer needed, gtk_gc_release() should be called.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### SECTION Stability_Level ##### -->
+
+
+<!-- ##### SECTION Image ##### -->
+
+
+<!-- ##### FUNCTION gtk_gc_get ##### -->
+<para>
+Gets a #GdkGC with the given depth, colormap and #GdkGCValues.
+If a #GdkGC with the given properties already exists then it is returned,
+otherwise a new #GdkGC is created.
+The returned #GdkGC should be released with gtk_gc_release() when it is no
+longer needed.
+</para>
+
+@depth: the depth of the #GdkGC to create.
+@colormap: the #GdkColormap (FIXME: I don't know why this is needed).
+@values: a #GdkGCValues struct containing settings for the #GdkGC.
+@values_mask: a set of flags indicating which of the fields in @values has
+been set.
+@Returns: a #GdkGC.
+
+
+<!-- ##### FUNCTION gtk_gc_release ##### -->
+<para>
+Releases a #GdkGC allocated using gtk_gc_get().
+</para>
+
+@gc: a #GdkGC.
+
+

docs/reference/gtk/tmpl/gtknotebook.sgml

@@ -278,6 +278,12 @@ Emitted when the user or a function changes the current page.
 
 </para>
 
+<!-- ##### STRUCT GtkNotebookPage ##### -->
+<para>
+The #GtkNotebookPage is an opaque implementation detail of #GtkNotebook.
+</para>
+
+
 <!-- ##### FUNCTION gtk_notebook_new ##### -->
 <para>
 </para>
@@ -613,24 +619,6 @@ Emitted when the user or a function changes the current page.
 @Returns: 
 
 
-<!-- ##### FUNCTION gtk_notebook_get_tab_hborder ##### -->
-<para>
-
-</para>
-
-@notebook: 
-@Returns: 
-
-
-<!-- ##### FUNCTION gtk_notebook_get_tab_vborder ##### -->
-<para>
-
-</para>
-
-@notebook: 
-@Returns: 
-
-
 <!-- ##### FUNCTION gtk_notebook_set_current_page ##### -->
 <para>
 

docs/reference/gtk/tmpl/gtkrecentmanager.sgml

@@ -0,0 +1,482 @@
+<!-- ##### SECTION Title ##### -->
+GtkRecentManager
+
+<!-- ##### SECTION Short_Description ##### -->
+Managing Recently Used Files
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+#GtkRecentManager provides a facility for adding, removing and
+looking up recently used files.  Each recently used file is
+identified by its URI, and has meta-data associated to it, like
+the names and command lines of the applications that have
+registered it, the number of time each application has registered
+the same file, the mime type of the file and whether the file
+should be displayed only by the applications that have
+registered it.
+</para>
+
+<para>
+The #GtkRecentManager acts like a database of all the recently
+used files.  You can create new #GtkRecentManager objects, but
+it is more efficient to use the standard recent manager for
+the #GdkScreen so that informations about the recently used
+files is shared with other people using them.  In case the
+default screen is being used, adding a new recently used
+file is as simple as:
+</para>
+
+<informalexample>
+  <programlisting>
+GtkRecentManager *manager;
+
+manager = gtk_recent_manager_get_default ();
+gtk_recent_manager_add_item (manager, file_uri);
+  </programlisting>
+</informalexample>
+
+While looking up a recently used file is as simple as:
+
+<informalexample>
+  <programlisting>
+GtkRecentManager *manager;
+GtkRecentInfo *info;
+GError *error = NULL;
+
+manager = gtk_recent_manager_get_default ();
+info = gtk_recent_manager_lookup_item (manager, file_uri, &amp;error);
+if (error)
+  {
+    g_warning ("Could not find the file: &percnt;s", error-&gt;message);
+    g_error_free (error);
+  }
+else
+  {
+    /* Use the info object */
+    gtk_recent_info_unref (info);
+  }
+  </programlisting>
+</informalexample>
+
+<para>
+Recently used files are supported since GTK+ 2.10.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### SECTION Stability_Level ##### -->
+
+
+<!-- ##### SECTION Image ##### -->
+
+
+<!-- ##### STRUCT GtkRecentManager ##### -->
+<para>
+Acts as a database of information about the list of recently
+used files.  Normally, you retrieve the recent manager for a
+particular screen using gtk_recent_manager_get_for_screen()
+and it will contain information about current recent manager
+for that screen.</para>
+
+
+<!-- ##### SIGNAL GtkRecentManager::changed ##### -->
+<para>
+
+</para>
+
+@recentmanager: the object which received the signal.
+
+<!-- ##### ARG GtkRecentManager:filename ##### -->
+<para>
+
+</para>
+
+<!-- ##### ARG GtkRecentManager:limit ##### -->
+<para>
+
+</para>
+
+<!-- ##### ARG GtkRecentManager:size ##### -->
+<para>
+
+</para>
+
+<!-- ##### STRUCT GtkRecentInfo ##### -->
+<para>
+Contains informations found when looking up an entry of the
+recently used files list.
+</para>
+
+
+<!-- ##### STRUCT GtkRecentData ##### -->
+<para>
+
+</para>
+
+@display_name: 
+@description: 
+@mime_type: 
+@app_name: 
+@app_exec: 
+@groups: 
+@is_private: 
+
+<!-- ##### MACRO GTK_RECENT_MANAGER_ERROR ##### -->
+<para>
+The #GQuark used for #GtkRecentManagerError errors.
+</para>
+
+
+
+<!-- ##### ENUM GtkRecentManagerError ##### -->
+<para>
+
+</para>
+
+@GTK_RECENT_MANAGER_ERROR_NOT_FOUND: 
+@GTK_RECENT_MANAGER_ERROR_INVALID_URI: 
+@GTK_RECENT_MANAGER_ERROR_INVALID_ENCODING: 
+@GTK_RECENT_MANAGER_ERROR_NOT_REGISTERED: 
+@GTK_RECENT_MANAGER_ERROR_READ: 
+@GTK_RECENT_MANAGER_ERROR_WRITE: 
+@GTK_RECENT_MANAGER_ERROR_UNKNOWN: 
+
+<!-- ##### FUNCTION gtk_recent_manager_new ##### -->
+<para>
+
+</para>
+
+@void: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_manager_get_default ##### -->
+<para>
+
+</para>
+
+@void: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_manager_add_item ##### -->
+<para>
+
+</para>
+
+@manager: 
+@uri: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_manager_add_full ##### -->
+<para>
+
+</para>
+
+@manager: 
+@uri: 
+@recent_data: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_manager_remove_item ##### -->
+<para>
+
+</para>
+
+@manager: 
+@uri: 
+@error: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_manager_lookup_item ##### -->
+<para>
+
+</para>
+
+@manager: 
+@uri: 
+@error: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_manager_has_item ##### -->
+<para>
+
+</para>
+
+@manager: 
+@uri: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_manager_move_item ##### -->
+<para>
+
+</para>
+
+@manager: 
+@uri: 
+@new_uri: 
+@error: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_manager_get_limit ##### -->
+<para>
+
+</para>
+
+@manager: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_manager_set_limit ##### -->
+<para>
+
+</para>
+
+@manager: 
+@limit: 
+
+
+<!-- ##### FUNCTION gtk_recent_manager_get_items ##### -->
+<para>
+
+</para>
+
+@manager: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_manager_purge_items ##### -->
+<para>
+
+</para>
+
+@manager: 
+@error: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_ref ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_unref ##### -->
+<para>
+
+</para>
+
+@info: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_uri ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_display_name ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_description ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_mime_type ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_added ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_modified ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_visited ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_private_hint ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_application_info ##### -->
+<para>
+
+</para>
+
+@info: 
+@app_name: 
+@app_exec: 
+@count: 
+@time_: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_applications ##### -->
+<para>
+
+</para>
+
+@info: 
+@length: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_last_application ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_groups ##### -->
+<para>
+
+</para>
+
+@info: 
+@length: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_has_group ##### -->
+<para>
+
+</para>
+
+@info: 
+@group_name: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_has_application ##### -->
+<para>
+
+</para>
+
+@info: 
+@app_name: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_icon ##### -->
+<para>
+
+</para>
+
+@info: 
+@size: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_short_name ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_uri_display ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_get_age ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_is_local ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_exists ##### -->
+<para>
+
+</para>
+
+@info: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gtk_recent_info_match ##### -->
+<para>
+
+</para>
+
+@info_a: 
+@info_b: 
+@Returns: 
+
+

docs/reference/gtk/tmpl/gtktexttag.sgml

@@ -84,6 +84,16 @@ It is working (with minor issues) since 2.8.
 
 </para>
 
+<!-- ##### ARG GtkTextTag:background-stipple ##### -->
+<para>
+
+</para>
+
+<!-- ##### ARG GtkTextTag:background-stipple-set ##### -->
+<para>
+
+</para>
+
 <!-- ##### ARG GtkTextTag:direction ##### -->
 <para>
 
@@ -134,6 +144,16 @@ It is working (with minor issues) since 2.8.
 
 </para>
 
+<!-- ##### ARG GtkTextTag:foreground-stipple ##### -->
+<para>
+
+</para>
+
+<!-- ##### ARG GtkTextTag:foreground-stipple-set ##### -->
+<para>
+
+</para>
+
 <!-- ##### ARG GtkTextTag:indent ##### -->
 <para>
 
@@ -398,6 +418,7 @@ modified directly.
 @invisible: 
 @bg_full_height: 
 @editable: 
+@realized: 
 
 <!-- ##### FUNCTION gtk_text_tag_new ##### -->
 <para>
@@ -445,6 +466,8 @@ modified directly.
 
 @bg_color: 
 @fg_color: 
+@bg_stipple: 
+@fg_stipple: 
 @rise: 
 @underline: 
 @strikethrough: 

docs/sizing-test.txt

@@ -106,7 +106,8 @@ GtkWindow::default_width, GtkWindow::default_height:
  - default_height is -1 if unset, or >= 0 if
    a default height is set
 
-GtkWindow::resizable:
+GtkWindow::allow_grow, GtkWindow::resizable:
+ - equivalent properties; changing one notifies on the other
  - if FALSE, we set the min size to the max size in the geometry 
    hints. 
  - If the app programmer has called gtk_window_set_geometry_hints()

docs/tutorial/gtk-tut.sgml

@@ -7599,6 +7599,7 @@ int main (int argc, char *argv[])
   dialog = gtk_dialog_new ();
   gtk_window_set_title (GTK_WINDOW (dialog), "GTKToolbar Tutorial");
   gtk_widget_set_size_request (GTK_WIDGET (dialog), 600, 300);
+  GTK_WINDOW (dialog)->allow_shrink = TRUE;
 
   /* typically we quit if someone tries to close us */
   g_signal_connect (dialog, "delete-event",

gdk/Makefile.am

@@ -81,6 +81,8 @@ gdk_public_h_sources =				\
 	gdkdnd.h				\
 	gdkdrawable.h				\
 	gdkevents.h				\
+	gdkgc.h					\
+	gdkimage.h				\
 	gdkinput.h				\
 	gdkkeys.h				\
 	gdkkeysyms.h				\
@@ -89,6 +91,7 @@ gdk_public_h_sources =				\
 	gdkpixmap.h				\
 	gdkprivate.h				\
 	gdkproperty.h				\
+	gdkrgb.h				\
 	gdkscreen.h				\
 	gdkselection.h				\
 	gdkspawn.h				\
@@ -120,7 +123,9 @@ gdk_c_sources =                 \
 	gdkdnd.c		\
 	gdkdraw.c		\
 	gdkevents.c     	\
+	gdkgc.c			\
 	gdkglobals.c		\
+	gdkimage.c		\
 	gdkkeys.c		\
 	gdkkeyuni.c		\
 	gdkoffscreenwindow.c	\
@@ -129,6 +134,7 @@ gdk_c_sources =                 \
 	gdkpixbuf-render.c	\
 	gdkpixmap.c		\
 	gdkrectangle.c		\
+	gdkrgb.c		\
 	gdkscreen.c		\
 	gdkselection.c		\
 	gdkvisual.c		\
@@ -207,8 +213,10 @@ x11_introspection_files = 		\
 	x11/gdkdrawable-x11.c		\
 	x11/gdkeventsource.c		\
 	x11/gdkeventtranslator.c	\
+	x11/gdkgc-x11.c			\
 	x11/gdkgeometry-x11.c		\
 	x11/gdkglobals-x11.c		\
+	x11/gdkimage-x11.c		\
 	x11/gdkim-x11.c			\
 	x11/gdkinput.c			\
 	x11/gdkkeys-x11.c		\

gdk/directfb/Makefile.am

@@ -27,9 +27,11 @@ libgdk_directfb_la_SOURCES =	\
 	gdkdisplay-directfb.h   \
 	gdkdrawable-directfb.c	\
 	gdkevents-directfb.c	\
+	gdkgc-directfb.c	\
 	gdkgeometry-directfb.c	\
 	gdkglobals-directfb.c	\
 	gdkim-directfb.c	\
+	gdkimage-directfb.c	\
 	gdkinput-directfb.c	\
 	gdkinput-directfb.h	\
 	gdkkeys-directfb.c	\

gdk/directfb/TODO

@@ -34,6 +34,7 @@ gdkevents-directfb.c
 gdkgc-directfb.c
 gdkgeometry-directfb.c
 gdkglobals-directfb.c
+gdkimage-directfb.c
 gdkim-directfb.c
 gdkinput-directfb.c
 gdkkeys-directfb.c

gdk/directfb/gdkcolor-directfb.c

@@ -304,6 +304,54 @@ gdk_colormap_alloc_colors (GdkColormap *colormap,
   return 0;
 }
 
+void
+gdk_colormap_query_color (GdkColormap *colormap,
+                          gulong       pixel,
+                          GdkColor    *result)
+{
+  GdkVisual *visual;
+
+  g_return_if_fail (GDK_IS_COLORMAP (colormap));
+
+  visual = gdk_colormap_get_visual (colormap);
+
+  switch (visual->type)
+    {
+    case GDK_VISUAL_TRUE_COLOR:
+      result->red = 65535. *
+        (gdouble)((pixel & visual->red_mask) >> visual->red_shift) /
+        ((1 << visual->red_prec) - 1);
+
+      result->green = 65535. *
+        (gdouble)((pixel & visual->green_mask) >> visual->green_shift) /
+        ((1 << visual->green_prec) - 1);
+
+      result->blue = 65535. *
+        (gdouble)((pixel & visual->blue_mask) >> visual->blue_shift) /
+        ((1 << visual->blue_prec) - 1);
+      break;
+
+    case GDK_VISUAL_STATIC_COLOR:
+    case GDK_VISUAL_PSEUDO_COLOR:
+      if (pixel >= 0 && pixel < colormap->size)
+        {
+          result->red   = colormap->colors[pixel].red;
+          result->green = colormap->colors[pixel].green;
+          result->blue  = colormap->colors[pixel].blue;
+        }
+      else
+        g_warning ("gdk_colormap_query_color: pixel outside colormap");
+      break;
+
+    case GDK_VISUAL_DIRECT_COLOR:
+    case GDK_VISUAL_GRAYSCALE:
+    case GDK_VISUAL_STATIC_GRAY:
+      /* unsupported */
+      g_assert_not_reached ();
+      break;
+    }
+}
+
 IDirectFBPalette *
 gdk_directfb_colormap_get_palette (GdkColormap *colormap)
 {

gdk/directfb/gdkdisplay-directfb.c

@@ -39,6 +39,7 @@ extern void _gdk_events_init            (void);
 extern void _gdk_input_init             (void);
 extern void _gdk_dnd_init               (void);
 extern void _gdk_windowing_window_init  (void);
+extern void _gdk_windowing_image_init   (void);
 extern void _gdk_directfb_keyboard_init (void);
 
 static gboolean   gdk_directfb_argb_font           = FALSE;

gdk/directfb/gdkgc-directfb.c

@@ -0,0 +1,386 @@
+/* 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.
+ */
+
+/*
+ * GTK+ DirectFB backend
+ * Copyright (C) 2001-2002  convergence integrated media GmbH
+ * Copyright (C) 2002-2004  convergence GmbH
+ * Written by Denis Oliver Kropp <dok@convergence.de> and
+ *            Sven Neumann <sven@convergence.de>
+ */
+
+#undef GDK_DISABLE_DEPRECATED
+
+#include "config.h"
+#include "gdk.h"
+
+#include <string.h>
+
+#include "gdkdirectfb.h"
+#include "gdkprivate-directfb.h"
+
+#include "gdkgc.h"
+#include "gdkpixmap.h"
+
+static void gdk_directfb_gc_get_values (GdkGC           *gc,
+                                        GdkGCValues     *values);
+static void gdk_directfb_gc_set_values (GdkGC           *gc,
+                                        GdkGCValues     *values,
+                                        GdkGCValuesMask  values_mask);
+static void gdk_directfb_gc_set_dashes (GdkGC           *gc,
+                                        gint             dash_offset,
+                                        gint8            dash_list[],
+                                        gint             n);
+
+
+static void gdk_gc_directfb_finalize   (GObject            *object);
+
+G_DEFINE_TYPE (GdkGCDirectFB, _gdk_gc_directfb, GDK_TYPE_GC)
+
+static void
+_gdk_gc_directfb_init (GdkGCDirectFB *directfb_gc)
+{
+}
+
+static void
+_gdk_gc_directfb_class_init (GdkGCDirectFBClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkGCClass   *gc_class     = GDK_GC_CLASS (klass);
+
+  object_class->finalize = gdk_gc_directfb_finalize;
+
+  gc_class->get_values = gdk_directfb_gc_get_values;
+  gc_class->set_values = gdk_directfb_gc_set_values;
+  gc_class->set_dashes = gdk_directfb_gc_set_dashes;
+}
+
+static void
+gdk_gc_directfb_finalize (GObject *object)
+{
+  GdkGCDirectFB *directfb_gc = GDK_GC_DIRECTFB (object);
+
+  if (directfb_gc->clip_region.numRects)
+    temp_region_deinit (&directfb_gc->clip_region);
+  if (directfb_gc->values.clip_mask)
+    g_object_unref (directfb_gc->values.clip_mask);
+  if (directfb_gc->values.stipple)
+    g_object_unref (directfb_gc->values.stipple);
+  if (directfb_gc->values.tile)
+    g_object_unref (directfb_gc->values.tile);
+
+  G_OBJECT_CLASS (_gdk_gc_directfb_parent_class)->finalize (object);
+}
+
+
+GdkGC *
+_gdk_directfb_gc_new (GdkDrawable     *drawable,
+                      GdkGCValues     *values,
+                      GdkGCValuesMask  values_mask)
+{
+  GdkGC         *gc;
+  GdkGCDirectFB *private;
+
+  /* NOTICE that the drawable here has to be the impl drawable, not the
+     publicly visible drawable. */
+  g_return_val_if_fail (GDK_IS_DRAWABLE_IMPL_DIRECTFB (drawable), NULL);
+
+  gc = GDK_GC (g_object_new (_gdk_gc_directfb_get_type (), NULL));
+
+  _gdk_gc_init (gc, drawable, values, values_mask);
+
+  private = GDK_GC_DIRECTFB (gc);
+#if 0
+  private->values.background.pixel = 0;
+  private->values.background.red   =
+  private->values.background.green =
+  private->values.background.blue  = 0;
+
+  private->values.foreground.pixel = 0;
+  private->values.foreground.red   =
+  private->values.foreground.green =
+  private->values.foreground.blue  = 0;
+#endif
+
+  private->values.cap_style = GDK_CAP_BUTT;
+
+  gdk_directfb_gc_set_values (gc, values, values_mask);
+
+  return gc;
+}
+
+static void
+gdk_directfb_gc_get_values (GdkGC       *gc,
+                            GdkGCValues *values)
+{
+  *values = GDK_GC_DIRECTFB (gc)->values;
+}
+
+#if 0
+void
+_gdk_windowing_gc_get_foreground (GdkGC    *gc,
+                                  GdkColor *color)
+{
+  GdkGCDirectFB *private;
+  private = GDK_GC_DIRECTFB (gc);
+  *color =private->values.foreground;
+
+
+}
+#endif
+
+static void
+gdk_directfb_gc_set_values (GdkGC           *gc,
+                            GdkGCValues     *values,
+                            GdkGCValuesMask  values_mask)
+{
+  GdkGCDirectFB *private = GDK_GC_DIRECTFB (gc);
+
+  if (values_mask & GDK_GC_FOREGROUND)
+    {
+      private->values.foreground = values->foreground;
+      private->values_mask |= GDK_GC_FOREGROUND;
+    }
+
+  if (values_mask & GDK_GC_BACKGROUND)
+    {
+      private->values.background = values->background;
+      private->values_mask |= GDK_GC_BACKGROUND;
+    }
+
+  if (values_mask & GDK_GC_FUNCTION)
+    {
+      private->values.function = values->function;
+      private->values_mask |= GDK_GC_FUNCTION;
+    }
+
+  if (values_mask & GDK_GC_FILL)
+    {
+      private->values.fill = values->fill;
+      private->values_mask |= GDK_GC_FILL;
+    }
+
+  if (values_mask & GDK_GC_TILE)
+    {
+      GdkPixmap *oldpm = private->values.tile;
+
+      if (values->tile)
+        g_assert (GDK_PIXMAP_OBJECT (values->tile)->depth > 1);
+
+      private->values.tile = values->tile ? g_object_ref (values->tile) : NULL;
+      private->values_mask |= GDK_GC_TILE;
+
+      if (oldpm)
+        g_object_unref (oldpm);
+    }
+
+  if (values_mask & GDK_GC_STIPPLE)
+    {
+      GdkPixmap *oldpm = private->values.stipple;
+
+      if (values->stipple)
+        g_assert (GDK_PIXMAP_OBJECT (values->stipple)->depth == 1);
+
+      private->values.stipple = (values->stipple ?
+                                 g_object_ref (values->stipple) : NULL);
+      private->values_mask |= GDK_GC_STIPPLE;
+
+      if (oldpm)
+        g_object_unref (oldpm);
+    }
+
+  if (values_mask & GDK_GC_CLIP_MASK)
+    {
+      GdkPixmap *oldpm = private->values.clip_mask;
+
+      private->values.clip_mask = (values->clip_mask ?
+                                   g_object_ref (values->clip_mask) : NULL);
+      private->values_mask |= GDK_GC_CLIP_MASK;
+
+      if (oldpm)
+        g_object_unref (oldpm);
+
+      temp_region_reset (&private->clip_region);
+    }
+
+  if (values_mask & GDK_GC_SUBWINDOW)
+    {
+      private->values.subwindow_mode = values->subwindow_mode;
+      private->values_mask |= GDK_GC_SUBWINDOW;
+    }
+
+  if (values_mask & GDK_GC_TS_X_ORIGIN)
+    {
+      private->values.ts_x_origin = values->ts_x_origin;
+      private->values_mask |= GDK_GC_TS_X_ORIGIN;
+    }
+
+  if (values_mask & GDK_GC_TS_Y_ORIGIN)
+    {
+      private->values.ts_y_origin = values->ts_y_origin;
+      private->values_mask |= GDK_GC_TS_Y_ORIGIN;
+    }
+
+  if (values_mask & GDK_GC_CLIP_X_ORIGIN)
+    {
+      private->values.clip_x_origin = GDK_GC (gc)->clip_x_origin = values->clip_x_origin;
+      private->values_mask |= GDK_GC_CLIP_X_ORIGIN;
+    }
+
+  if (values_mask & GDK_GC_CLIP_Y_ORIGIN)
+    {
+      private->values.clip_y_origin = GDK_GC (gc)->clip_y_origin = values->clip_y_origin;
+      private->values_mask |= GDK_GC_CLIP_Y_ORIGIN;
+    }
+
+  if (values_mask & GDK_GC_EXPOSURES)
+    {
+      private->values.graphics_exposures = values->graphics_exposures;
+      private->values_mask |= GDK_GC_EXPOSURES;
+    }
+
+  if (values_mask & GDK_GC_LINE_WIDTH)
+    {
+      private->values.line_width = values->line_width;
+      private->values_mask |= GDK_GC_LINE_WIDTH;
+    }
+
+  if (values_mask & GDK_GC_LINE_STYLE)
+    {
+      private->values.line_style = values->line_style;
+      private->values_mask |= GDK_GC_LINE_STYLE;
+    }
+
+  if (values_mask & GDK_GC_CAP_STYLE)
+    {
+      private->values.cap_style = values->cap_style;
+      private->values_mask |= GDK_GC_CAP_STYLE;
+    }
+
+  if (values_mask & GDK_GC_JOIN_STYLE)
+    {
+      private->values.join_style = values->join_style;
+      private->values_mask |= GDK_GC_JOIN_STYLE;
+    }
+}
+
+static void
+gdk_directfb_gc_set_dashes (GdkGC *gc,
+                            gint   dash_offset,
+                            gint8  dash_list[],
+                            gint   n)
+{
+  g_warning ("gdk_directfb_gc_set_dashes not implemented");
+}
+
+static void
+gc_unset_clip_mask (GdkGC *gc)
+{
+  GdkGCDirectFB *data = GDK_GC_DIRECTFB (gc);
+
+  if (data->values.clip_mask)
+    {
+      g_object_unref (data->values.clip_mask);
+      data->values.clip_mask = NULL;
+      data->values_mask &= ~ GDK_GC_CLIP_MASK;
+    }
+}
+
+
+void
+_gdk_windowing_gc_set_clip_region (GdkGC           *gc,
+                                   const cairo_region_t *region,
+                                   gboolean         reset_origin)
+{
+  GdkGCDirectFB *data;
+
+  g_return_if_fail (gc != NULL);
+
+  data = GDK_GC_DIRECTFB (gc);
+
+  if (region == &data->clip_region)
+    return;
+
+  if (region)
+    temp_region_init_copy (&data->clip_region, region);
+  else
+    temp_region_reset (&data->clip_region);
+
+  if (reset_origin)
+    {
+      gc->clip_x_origin = 0;
+      gc->clip_y_origin = 0;
+      data->values.clip_x_origin = 0;
+      data->values.clip_y_origin = 0;
+    }
+
+  gc_unset_clip_mask (gc);
+}
+
+void
+_gdk_windowing_gc_copy (GdkGC *dst_gc,
+             GdkGC *src_gc)
+{
+  GdkGCDirectFB *dst_private;
+
+  g_return_if_fail (dst_gc != NULL);
+  g_return_if_fail (src_gc != NULL);
+
+  dst_private = GDK_GC_DIRECTFB (dst_gc);
+
+  temp_region_reset(&dst_private->clip_region);
+
+  if (dst_private->values_mask & GDK_GC_TILE)
+    g_object_unref (dst_private->values.tile);
+  if (dst_private->values_mask & GDK_GC_STIPPLE)
+    g_object_unref (dst_private->values.stipple);
+  if (dst_private->values_mask & GDK_GC_CLIP_MASK)
+    g_object_unref (dst_private->values.clip_mask);
+
+  *dst_gc = *src_gc;
+  if (dst_private->values_mask & GDK_GC_TILE)
+    g_object_ref (dst_private->values.tile);
+  if (dst_private->values_mask & GDK_GC_STIPPLE)
+    g_object_ref (dst_private->values.stipple);
+  if (dst_private->values_mask & GDK_GC_CLIP_MASK)
+    g_object_ref (dst_private->values.clip_mask);
+}
+
+/**
+ * gdk_gc_get_screen:
+ * @gc: a #GdkGC.
+ *
+ * Gets the #GdkScreen for which @gc was created
+ *
+ * Returns: the #GdkScreen for @gc.
+ *
+ * Since: 2.2
+ */
+GdkScreen *  
+gdk_gc_get_screen (GdkGC *gc)
+{
+  g_return_val_if_fail (GDK_IS_GC_DIRECTFB (gc), NULL);
+  
+  return _gdk_screen;
+}

gdk/directfb/gdkimage-directfb.c

@@ -0,0 +1,405 @@
+/* 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.
+ */
+
+/*
+ * GTK+ DirectFB backend
+ * Copyright (C) 2001-2002  convergence integrated media GmbH
+ * Copyright (C) 2002-2004  convergence GmbH
+ * Written by Denis Oliver Kropp <dok@convergence.de> and
+ *            Sven Neumann <sven@convergence.de>
+ */
+
+#include "config.h"
+#include "gdk.h"
+
+
+#include "gdkdirectfb.h"
+#include "gdkprivate-directfb.h"
+
+#include "gdkinternals.h"
+
+#include "gdkimage.h"
+
+
+static GList    *image_list   = NULL;
+static gpointer  parent_class = NULL;
+
+static void gdk_directfb_image_destroy (GdkImage      *image);
+static void gdk_image_init             (GdkImage      *image);
+static void gdk_image_class_init       (GdkImageClass *klass);
+static void gdk_image_finalize         (GObject       *object);
+
+GType
+gdk_image_get_type (void)
+{
+  static GType object_type = 0;
+
+  if (!object_type)
+    {
+      const GTypeInfo object_info =
+        {
+          sizeof (GdkImageClass),
+          (GBaseInitFunc) NULL,
+          (GBaseFinalizeFunc) NULL,
+          (GClassInitFunc) gdk_image_class_init,
+          NULL,           /* class_finalize */
+          NULL,           /* class_data */
+          sizeof (GdkImage),
+          0,              /* n_preallocs */
+          (GInstanceInitFunc) gdk_image_init,
+        };
+
+      object_type = g_type_register_static (G_TYPE_OBJECT,
+                                            "GdkImage",
+                                            &object_info, 0);
+    }
+
+  return object_type;
+}
+
+static void
+gdk_image_init (GdkImage *image)
+{
+  image->windowing_data = g_new0 (GdkImageDirectFB, 1);
+  image->mem = NULL;
+
+  image_list = g_list_prepend (image_list, image);
+}
+
+static void
+gdk_image_class_init (GdkImageClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  parent_class = g_type_class_peek_parent (klass);
+
+  object_class->finalize = gdk_image_finalize;
+}
+
+static void
+gdk_image_finalize (GObject *object)
+{
+  GdkImage *image;
+
+  image = GDK_IMAGE (object);
+
+  image_list = g_list_remove (image_list, image);
+
+  if (image->depth == 1)
+    g_free (image->mem);
+
+  gdk_directfb_image_destroy (image);
+
+  if (G_OBJECT_CLASS (parent_class)->finalize)
+    G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+
+/* this function is called from the atexit handler! */
+void
+_gdk_image_exit (void)
+{
+  GObject *image;
+
+  while (image_list)
+    {
+      image = image_list->data;
+
+      gdk_image_finalize (image);
+    }
+}
+
+void
+_gdk_windowing_image_init (void)
+{
+}
+
+GdkImage*
+_gdk_image_new_for_depth (GdkScreen    *screen,
+                          GdkImageType  type,
+                          GdkVisual    *visual,
+                          gint          width,
+                          gint          height,
+                          gint          depth)
+{
+  GdkImage              *image;
+  GdkImageDirectFB      *private;
+  DFBResult              ret;
+  gint                   pitch;
+  DFBSurfacePixelFormat  format;
+  IDirectFBSurface      *surface;
+
+  if (type == GDK_IMAGE_FASTEST || type == GDK_IMAGE_NORMAL)
+    type = GDK_IMAGE_SHARED;
+
+  if (visual)
+    depth = visual->depth;
+
+  switch (depth)
+    {
+    case 8:
+      format = DSPF_LUT8;
+      break;
+    case 15:
+      format = DSPF_ARGB1555;
+      break;
+    case 16:
+      format = DSPF_RGB16;
+      break;
+    case 24:
+      format = DSPF_RGB32;
+      break;
+    case 32:
+      format = DSPF_ARGB;
+      break;
+    default:
+      g_message ("unimplemented %s for depth %d", G_STRFUNC, depth);
+      return NULL;
+    }
+
+  surface = gdk_display_dfb_create_surface(_gdk_display,format,width,height);
+  if (!surface)
+    {
+      return NULL;
+    }
+  surface->GetPixelFormat( surface, &format );
+
+  image = g_object_new (gdk_image_get_type (), NULL);
+  private = image->windowing_data;
+
+  private->surface = surface;
+
+  ret = surface->Lock( surface, DSLF_WRITE, &image->mem, &pitch );
+  if (ret)
+    {
+      DirectFBError( "IDirectFBSurface::Lock() for writing failed!\n", ret );
+      g_object_unref( image );
+      return NULL;
+    }
+
+  image->type           = type;
+  image->visual         = visual;
+#if G_BYTE_ORDER == G_BIG_ENDIAN
+  image->byte_order		= GDK_MSB_FIRST;
+#else
+  image->byte_order 	= GDK_LSB_FIRST;
+#endif
+  image->width          = width;
+  image->height         = height;
+  image->depth          = depth;
+  image->bpp            = DFB_BYTES_PER_PIXEL (format);
+  image->bpl            = pitch;
+  image->bits_per_pixel = DFB_BITS_PER_PIXEL (format);
+
+  image_list = g_list_prepend (image_list, image);
+
+  return image;
+}
+
+
+GdkImage*
+_gdk_directfb_copy_to_image (GdkDrawable *drawable,
+                             GdkImage    *image,
+                             gint         src_x,
+                             gint         src_y,
+                             gint         dest_x,
+                             gint         dest_y,
+                             gint         width,
+                             gint         height)
+{
+  GdkDrawableImplDirectFB *impl;
+  GdkImageDirectFB        *private;
+  int                      pitch;
+  DFBRectangle             rect = { src_x, src_y, width, height };
+  IDirectFBDisplayLayer *layer = _gdk_display->layer;
+
+  g_return_val_if_fail (GDK_IS_DRAWABLE_IMPL_DIRECTFB (drawable), NULL);
+  g_return_val_if_fail (image != NULL || (dest_x == 0 && dest_y == 0), NULL);
+
+  impl = GDK_DRAWABLE_IMPL_DIRECTFB (drawable);
+
+  if (impl->wrapper == _gdk_parent_root)
+    {
+      DFBResult ret;
+
+      ret = layer->SetCooperativeLevel (layer, DLSCL_ADMINISTRATIVE);
+      if (ret)
+        {
+          DirectFBError ("_gdk_directfb_copy_to_image - SetCooperativeLevel",
+                         ret);
+          return NULL;
+        }
+
+      ret = layer->GetSurface (layer, &impl->surface);
+      if (ret)
+        {
+          layer->SetCooperativeLevel (layer, DLSCL_SHARED);
+          DirectFBError ("_gdk_directfb_copy_to_image - GetSurface", ret);
+          return NULL;
+        }
+    }
+
+  if (! impl->surface)
+    return NULL;
+
+  if (!image)
+    image =  gdk_image_new (GDK_IMAGE_NORMAL,
+                            gdk_drawable_get_visual (drawable), width, height);
+
+  private = image->windowing_data;
+
+  private->surface->Unlock( private->surface );
+
+  private->surface->Blit( private->surface,
+                          impl->surface, &rect, dest_x, dest_y );
+
+  private->surface->Lock( private->surface, DSLF_READ | DSLF_WRITE, &image->mem, &pitch );
+  image->bpl = pitch;
+
+  if (impl->wrapper == _gdk_parent_root)
+    {
+      impl->surface->Release (impl->surface);
+      impl->surface = NULL;
+      layer->SetCooperativeLevel (layer, DLSCL_SHARED);
+    }
+
+  return image;
+}
+
+guint32
+gdk_image_get_pixel (GdkImage *image,
+                     gint      x,
+                     gint      y)
+{
+  guint32 pixel = 0;
+
+  g_return_val_if_fail (GDK_IS_IMAGE (image), 0);
+
+  if (!(x >= 0 && x < image->width && y >= 0 && y < image->height))
+    return 0;
+
+  if (image->depth == 1)
+    pixel = (((guchar *) image->mem)[y * image->bpl + (x >> 3)] & (1 << (7 - (x & 0x7)))) != 0;
+  else
+    {
+      guchar *pixelp = (guchar *) image->mem + y * image->bpl + x * image->bpp;
+
+      switch (image->bpp)
+        {
+        case 1:
+          pixel = *pixelp;
+          break;
+
+        case 2:
+          pixel = pixelp[0] | (pixelp[1] << 8);
+          break;
+
+        case 3:
+          pixel = pixelp[0] | (pixelp[1] << 8) | (pixelp[2] << 16);
+          break;
+
+        case 4:
+          pixel = pixelp[0] | (pixelp[1] << 8) | (pixelp[2] << 16);
+          break;
+        }
+    }
+
+  return pixel;
+}
+
+void
+gdk_image_put_pixel (GdkImage *image,
+                     gint       x,
+                     gint       y,
+                     guint32    pixel)
+{
+  g_return_if_fail (image != NULL);
+
+  if  (!(x >= 0 && x < image->width && y >= 0 && y < image->height))
+    return;
+
+  if (image->depth == 1)
+    if (pixel & 1)
+      ((guchar *) image->mem)[y * image->bpl + (x >> 3)] |= (1 << (7 - (x & 0x7)));
+    else
+      ((guchar *) image->mem)[y * image->bpl + (x >> 3)] &= ~(1 << (7 - (x & 0x7)));
+  else
+    {
+      guchar *pixelp = (guchar *) image->mem + y * image->bpl + x * image->bpp;
+
+      switch (image->bpp)
+        {
+        case 4:
+          pixelp[3] = 0xFF;
+        case 3:
+          pixelp[2] = ((pixel >> 16) & 0xFF);
+        case 2:
+          pixelp[1] = ((pixel >> 8) & 0xFF);
+        case 1:
+          pixelp[0] = (pixel & 0xFF);
+        }
+    }
+}
+
+static void
+gdk_directfb_image_destroy (GdkImage *image)
+{
+  GdkImageDirectFB *private;
+
+  g_return_if_fail (GDK_IS_IMAGE (image));
+
+  private = image->windowing_data;
+
+  if (!private)
+    return;
+
+  GDK_NOTE (MISC, g_print ("gdk_directfb_image_destroy: %#lx\n",
+                           (gulong) private->surface));
+
+  private->surface->Unlock( private->surface );
+  private->surface->Release( private->surface );
+
+  g_free (private);
+  image->windowing_data = NULL;
+}
+
+gint
+_gdk_windowing_get_bits_for_depth (GdkDisplay *display,
+                                   gint        depth)
+{
+  switch (depth)
+    {
+    case 1:
+    case 8:
+      return 8;
+    case 15:
+    case 16:
+      return 16;
+    case 24:
+    case 32:
+      return 32;
+    }
+
+  return 0;
+}

gdk/directfb/gdkpixmap-directfb.c

@@ -194,6 +194,111 @@ _gdk_pixmap_new (GdkDrawable *drawable,
   return pixmap;
 }
 
+GdkPixmap *
+_gdk_bitmap_create_from_data (GdkDrawable   *drawable,
+                              const gchar *data,
+                              gint         width,
+                              gint         height)
+{
+  GdkPixmap *pixmap;
+
+  g_return_val_if_fail (drawable == NULL || GDK_IS_DRAWABLE (drawable), NULL);
+  g_return_val_if_fail (data != NULL, NULL);
+  g_return_val_if_fail (width > 0 && height > 0, NULL);
+
+  GDK_NOTE (MISC, g_print ("gdk_bitmap_create_from_data: %dx%d\n",
+                           width, height));
+
+  pixmap = gdk_pixmap_new (drawable, width, height, 1);
+
+#define GET_PIXEL(data,pixel) \
+  ((data[(pixel / 8)] & (0x1 << ((pixel) % 8))) >> ((pixel) % 8))
+
+  if (pixmap)
+    {
+      guchar *dst;
+      gint    pitch;
+
+      IDirectFBSurface *surface;
+
+      surface = GDK_DRAWABLE_IMPL_DIRECTFB (GDK_PIXMAP_OBJECT (pixmap)->impl)->surface;
+
+      if (surface->Lock( surface, DSLF_WRITE, (void**)(&dst), &pitch ) == DFB_OK)
+        {
+          gint i, j;
+
+          for (i = 0; i < height; i++)
+            {
+	      for (j = 0; j < width; j++)
+		{
+		  dst[j] = GET_PIXEL (data, j) * 255;
+		}
+
+              data += (width + 7) / 8;
+	      dst += pitch;
+            }
+
+          surface->Unlock( surface );
+        }
+    }
+
+#undef GET_PIXEL
+
+  return pixmap;
+}
+
+GdkPixmap*
+_gdk_pixmap_create_from_data (GdkDrawable   *drawable,
+                              const gchar *data,
+                              gint         width,
+                              gint         height,
+                              gint         depth,
+                              const GdkColor    *fg,
+                              const GdkColor    *bg)
+{
+  GdkPixmap *pixmap;
+
+  g_return_val_if_fail (drawable == NULL || GDK_IS_DRAWABLE (drawable), NULL);
+  g_return_val_if_fail (data != NULL, NULL);
+  g_return_val_if_fail (drawable != NULL || depth > 0, NULL);
+  g_return_val_if_fail (width > 0 && height > 0, NULL);
+
+  GDK_NOTE (MISC, g_print ("gdk_pixmap_create_from_data: %dx%dx%d\n",
+                           width, height, depth));
+
+  pixmap = gdk_pixmap_new (drawable, width, height, depth);
+
+  if (pixmap)
+    {
+      IDirectFBSurface *surface;
+      gchar            *dst;
+      gint              pitch;
+      gint              src_pitch;
+
+      depth = gdk_drawable_get_depth (pixmap);
+      src_pitch = width * ((depth + 7) / 8);
+
+      surface = GDK_DRAWABLE_IMPL_DIRECTFB (GDK_PIXMAP_OBJECT (pixmap)->impl)->surface;
+
+      if (surface->Lock( surface,
+                         DSLF_WRITE, (void**)(&dst), &pitch ) == DFB_OK)
+        {
+          gint i;
+
+          for (i = 0; i < height; i++)
+            {
+              memcpy (dst, data, src_pitch);
+              dst += pitch;
+              data += src_pitch;
+            }
+
+          surface->Unlock( surface );
+        }
+    }
+
+  return pixmap;
+}
+
 GdkPixmap*
 gdk_pixmap_foreign_new (GdkNativeWindow anid)
 {

gdk/directfb/gdkprivate-directfb.h

@@ -198,6 +198,46 @@ typedef struct
   DFBSurfacePixelFormat  format;
 } GdkVisualDirectFB;
 
+typedef struct
+{
+  IDirectFBSurface *surface;
+} GdkImageDirectFB;
+
+
+#define GDK_TYPE_GC_DIRECTFB       (_gdk_gc_directfb_get_type ())
+#define GDK_GC_DIRECTFB(object)    (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_GC_DIRECTFB, GdkGCDirectFB))
+#define GDK_IS_GC_DIRECTFB(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_GC_DIRECTFB))
+
+typedef struct
+{
+  GdkGC             parent_instance;
+
+  cairo_region_t         clip_region;
+
+  GdkGCValuesMask   values_mask;
+  GdkGCValues       values;
+} GdkGCDirectFB;
+
+typedef struct
+{
+  GdkGCClass        parent_class;
+} GdkGCDirectFBClass;
+
+GType     _gdk_gc_directfb_get_type (void);
+
+GdkGC *   _gdk_directfb_gc_new      (GdkDrawable     *drawable,
+                                     GdkGCValues     *values,
+                                     GdkGCValuesMask  values_mask);
+
+GdkImage* _gdk_directfb_copy_to_image (GdkDrawable  *drawable,
+                                       GdkImage     *image,
+                                       gint          src_x,
+                                       gint          src_y,
+                                       gint          dest_x,
+                                       gint          dest_y,
+                                       gint          width,
+                                       gint          height);
+
 void       gdk_directfb_event_windows_add    (GdkWindow *window);
 void       gdk_directfb_event_windows_remove (GdkWindow *window);
 

gdk/gdk.c

@@ -71,6 +71,7 @@ static const GDebugKey gdk_debug_keys[] = {
   {"xim",	    GDK_DEBUG_XIM},
   {"nograbs",       GDK_DEBUG_NOGRABS},
   {"colormap",	    GDK_DEBUG_COLORMAP},
+  {"gdkrgb",	    GDK_DEBUG_GDKRGB},
   {"gc",	    GDK_DEBUG_GC},
   {"pixmap",	    GDK_DEBUG_PIXMAP},
   {"image",	    GDK_DEBUG_IMAGE},
@@ -265,6 +266,9 @@ gdk_parse_args (int    *argc,
     }
   g_option_context_free (option_context);
 
+  if (_gdk_debug_flags && GDK_DEBUG_GDKRGB)
+    gdk_rgb_set_verbose (TRUE);
+
   GDK_NOTE (MISC, g_message ("progname: \"%s\"", g_get_prgname ()));
 }
 

gdk/gdk.h

@@ -41,12 +41,15 @@
 #include <gdk/gdkdrawable.h>
 #include <gdk/gdkenumtypes.h>
 #include <gdk/gdkevents.h>
+#include <gdk/gdkgc.h>
+#include <gdk/gdkimage.h>
 #include <gdk/gdkinput.h>
 #include <gdk/gdkkeys.h>
 #include <gdk/gdkpango.h>
 #include <gdk/gdkpixbuf.h>
 #include <gdk/gdkpixmap.h>
 #include <gdk/gdkproperty.h>
+#include <gdk/gdkrgb.h>
 #include <gdk/gdkscreen.h>
 #include <gdk/gdkselection.h>
 #include <gdk/gdkspawn.h>

gdk/gdk.symbols

@@ -245,20 +245,26 @@ gdk_utf8_to_compound_text_for_display
 
 #if IN_HEADER(__GDK_ENUM_TYPES_H__)
 #if IN_FILE(__GDK_ENUM_TYPES_C__)
+gdk_rgb_dither_get_type G_GNUC_CONST
 gdk_drag_protocol_get_type G_GNUC_CONST
 gdk_input_source_get_type G_GNUC_CONST
 gdk_input_mode_get_type G_GNUC_CONST
 gdk_axis_use_get_type G_GNUC_CONST
 gdk_byte_order_get_type G_GNUC_CONST
+gdk_cap_style_get_type G_GNUC_CONST
 gdk_crossing_mode_get_type G_GNUC_CONST
 gdk_device_type_get_type G_GNUC_CONST
 gdk_extension_mode_get_type G_GNUC_CONST
 gdk_event_mask_get_type G_GNUC_CONST
 gdk_event_type_get_type G_GNUC_CONST
+gdk_fill_get_type G_GNUC_CONST
 gdk_filter_return_get_type G_GNUC_CONST
+gdk_function_get_type G_GNUC_CONST
 gdk_grab_ownership_get_type G_GNUC_CONST
 gdk_grab_status_get_type G_GNUC_CONST
 gdk_gravity_get_type G_GNUC_CONST
+gdk_join_style_get_type G_GNUC_CONST
+gdk_line_style_get_type G_GNUC_CONST
 gdk_modifier_type_get_type G_GNUC_CONST
 gdk_notify_type_get_type G_GNUC_CONST
 gdk_owner_change_get_type G_GNUC_CONST
@@ -267,11 +273,13 @@ gdk_prop_mode_get_type G_GNUC_CONST
 gdk_scroll_direction_get_type G_GNUC_CONST
 gdk_setting_action_get_type G_GNUC_CONST
 gdk_status_get_type G_GNUC_CONST
+gdk_subwindow_mode_get_type G_GNUC_CONST
 gdk_visibility_state_get_type G_GNUC_CONST
 gdk_wm_decoration_get_type G_GNUC_CONST
 gdk_wm_function_get_type G_GNUC_CONST
 gdk_cursor_type_get_type G_GNUC_CONST
 gdk_drag_action_get_type G_GNUC_CONST
+gdk_gc_values_mask_get_type G_GNUC_CONST
 gdk_window_attributes_type_get_type G_GNUC_CONST
 gdk_window_class_get_type G_GNUC_CONST
 gdk_window_edge_get_type G_GNUC_CONST
@@ -279,6 +287,7 @@ gdk_window_hints_get_type G_GNUC_CONST
 gdk_window_state_get_type G_GNUC_CONST
 gdk_window_type_get_type G_GNUC_CONST
 gdk_window_type_hint_get_type G_GNUC_CONST
+gdk_image_type_get_type G_GNUC_CONST
 gdk_visual_type_get_type G_GNUC_CONST
 #endif
 #endif
@@ -316,6 +325,7 @@ gdk_colormap_new
 gdk_colormap_get_type G_GNUC_CONST
 gdk_colormap_alloc_colors
 gdk_colormap_free_colors
+gdk_colormap_query_color
 gdk_colormap_get_screen
 #endif
 #endif
@@ -323,7 +333,6 @@ gdk_colormap_get_screen
 #if IN_HEADER(__GDK_CURSOR_H__)
 #if IN_FILE(__GDK_CURSOR_C__)
 gdk_cursor_get_type G_GNUC_CONST
-gdk_cursor_get_cursor_type
 gdk_cursor_new
 gdk_cursor_ref
 gdk_cursor_unref
@@ -405,7 +414,6 @@ gdk_input_set_extension_events
 #if IN_HEADER(__GDK_DISPLAY_H__)
 #if IN_FILE(__GDK_DISPLAY_C__)
 gdk_display_close
-gdk_display_is_closed
 gdk_display_get_event
 gdk_display_get_device_manager
 gdk_display_get_device_state
@@ -531,16 +539,78 @@ gdk_drag_get_protocol
 
 #if IN_HEADER(__GDK_DRAWABLE_H__)
 #if IN_FILE(__GDK_DRAW_C__)
+gdk_drawable_copy_to_image
 gdk_drawable_get_clip_region
 gdk_drawable_get_colormap
 gdk_drawable_get_depth
 gdk_drawable_get_display
+gdk_drawable_get_image
 gdk_drawable_get_screen
 gdk_drawable_get_size
 gdk_drawable_get_type G_GNUC_CONST
 gdk_drawable_get_visible_region
 gdk_drawable_get_visual
 gdk_drawable_set_colormap
+gdk_draw_arc
+gdk_draw_drawable
+gdk_draw_glyphs
+gdk_draw_glyphs_transformed
+gdk_draw_image
+gdk_draw_line
+gdk_draw_lines
+gdk_draw_pixbuf
+gdk_draw_point
+gdk_draw_points
+gdk_draw_polygon
+gdk_draw_rectangle
+gdk_draw_segments
+gdk_draw_trapezoids
+#endif
+#endif
+
+#if IN_HEADER(__GDK_DRAWABLE_H__)
+#if IN_FILE(__GDK_PANGO_C__)
+gdk_draw_layout
+gdk_draw_layout_line
+gdk_draw_layout_line_with_colors
+gdk_draw_layout_with_colors
+#endif
+#endif
+
+#if IN_HEADER(__GDK_GC_H__)
+#if IN_FILE(__GDK_GC_C__)
+gdk_gc_new
+gdk_gc_get_type G_GNUC_CONST
+gdk_gc_new_with_values
+gdk_gc_get_values
+gdk_gc_set_values
+gdk_gc_set_foreground
+gdk_gc_set_background
+gdk_gc_set_function
+gdk_gc_set_fill
+gdk_gc_set_tile
+gdk_gc_set_stipple
+gdk_gc_set_ts_origin
+gdk_gc_set_clip_origin
+gdk_gc_set_clip_mask
+gdk_gc_set_clip_rectangle
+gdk_gc_set_clip_region
+gdk_gc_set_subwindow
+gdk_gc_set_exposures
+gdk_gc_set_line_attributes
+gdk_gc_set_dashes
+gdk_gc_offset
+gdk_gc_copy
+gdk_gc_get_colormap
+gdk_gc_set_colormap
+gdk_gc_set_rgb_bg_color
+gdk_gc_set_rgb_fg_color
+#endif
+#endif
+
+#if IN_HEADER(__GDK_GC_H__)
+#if IN_FILE(__GDK_GC_X11_C__)
+gdk_gc_get_screen
 #endif
 #endif
 
@@ -579,7 +649,8 @@ gdk_window_move_resize
 gdk_window_scroll
 gdk_window_move_region
 gdk_window_get_accept_focus
-gdk_window_get_background_pattern
+gdk_window_get_back_pixmap
+gdk_window_get_background
 gdk_window_get_composited
 gdk_window_get_cursor
 gdk_window_get_focus_on_map
@@ -616,7 +687,6 @@ gdk_window_clear_area_e
 gdk_window_constrain_size
 gdk_window_coords_from_parent
 gdk_window_coords_to_parent
-gdk_window_create_similar_surface
 gdk_window_destroy
 gdk_window_end_paint
 gdk_window_flush
@@ -739,6 +809,32 @@ gdk_window_configure_finished
 #endif
 #endif
 
+#if IN_HEADER(__GDK_IMAGE_H__)
+#if IN_FILE(__GDK_IMAGE_C__)
+gdk_image_get_bits_per_pixel
+gdk_image_get_bytes_per_pixel
+gdk_image_get_bytes_per_line
+gdk_image_get_byte_order
+gdk_image_get_colormap
+gdk_image_get_depth
+gdk_image_get_height
+gdk_image_get_image_type
+gdk_image_get_visual
+gdk_image_get_width
+gdk_image_get_pixels
+gdk_image_set_colormap
+gdk_image_new
+#endif
+#endif
+
+#if IN_HEADER(__GDK_IMAGE_H__)
+#if IN_FILE(__GDK_IMAGE_X11_C__)
+gdk_image_get_pixel
+gdk_image_put_pixel
+gdk_image_get_type G_GNUC_CONST
+#endif
+#endif
+
 #if IN_HEADER(__GDK_KEYS_H__)
 #if IN_FILE(__GDK_KEYS_C__)
 gdk_keymap_get_default
@@ -825,17 +921,27 @@ gdk_visual_get_type G_GNUC_CONST
 
 #if IN_HEADER(__GDK_PANGO_H__)
 #if IN_FILE(__GDK_PANGO_C__)
+gdk_pango_attr_emboss_color_new
+gdk_pango_attr_embossed_new
+gdk_pango_attr_stipple_new
 gdk_pango_context_get
 gdk_pango_context_get_for_screen
 gdk_pango_layout_get_clip_region
 gdk_pango_layout_line_get_clip_region
+gdk_pango_renderer_get_default
+gdk_pango_renderer_get_type G_GNUC_CONST
+gdk_pango_renderer_new
+gdk_pango_renderer_set_drawable
+gdk_pango_renderer_set_gc
+gdk_pango_renderer_set_override_color
+gdk_pango_renderer_set_stipple
 #endif
 #endif
 
 #if IN_HEADER(__GDK_PIXBUF_H__)
 #if IN_FILE(__GDK_PIXBUF_DRAWABLE_C__)
 gdk_pixbuf_get_from_drawable
-gdk_pixbuf_get_from_surface
+gdk_pixbuf_get_from_image
 #endif
 #endif
 
@@ -849,6 +955,12 @@ gdk_pixbuf_render_threshold_alpha
 
 #if IN_HEADER(__GDK_PIXMAP_H__)
 #if IN_FILE(__GDK_PIXMAP_C__)
+gdk_bitmap_create_from_data
+gdk_pixmap_colormap_create_from_xpm
+gdk_pixmap_create_from_data
+gdk_pixmap_create_from_xpm
+gdk_pixmap_colormap_create_from_xpm_d
+gdk_pixmap_create_from_xpm_d
 gdk_pixmap_get_type G_GNUC_CONST
 gdk_pixmap_new
 #endif
@@ -864,6 +976,27 @@ gdk_pixmap_lookup_for_display
 #endif
 #endif
 
+#if IN_HEADER(__GDK_RGB_H__)
+#if IN_FILE(__GDK_RGB_C__)
+gdk_rgb_cmap_free
+gdk_rgb_cmap_new
+gdk_rgb_colormap_ditherable
+gdk_rgb_ditherable
+gdk_rgb_find_color
+gdk_rgb_get_colormap
+gdk_rgb_get_visual
+gdk_rgb_set_install
+gdk_rgb_set_min_colors
+gdk_rgb_set_verbose
+gdk_draw_gray_image
+gdk_draw_indexed_image
+gdk_draw_rgb_32_image
+gdk_draw_rgb_32_image_dithalign
+gdk_draw_rgb_image
+gdk_draw_rgb_image_dithalign
+#endif
+#endif
+
 #if IN_HEADER(__GDK_SCREEN_H__)
 #if IN_FILE(__GDK_SCREEN_C__)
 gdk_screen_get_type G_GNUC_CONST
@@ -882,6 +1015,13 @@ gdk_screen_get_default
 #endif
 #endif
 
+#if IN_HEADER(__GDK_SCREEN_H__)
+#if IN_FILE(__GDK_RGB_C__)
+gdk_screen_get_rgb_colormap
+gdk_screen_get_rgb_visual
+#endif
+#endif
+
 #if IN_HEADER(__GDK_SCREEN_H__)
 #if IN_FILE(__GDK_VISUAL_X11_C__)
 gdk_screen_get_system_visual
@@ -977,6 +1117,8 @@ gdk_window_destroy_notify
 #if IN_HEADER(__GDK_WIN32_H__)
 #if IN_FILE(__GDK_WINDOW_WIN32_C__)
 gdk_win32_window_is_win32
+gdk_win32_begin_direct_draw_libgtk_only
+gdk_win32_end_direct_draw_libgtk_only
 #endif
 #endif
 
@@ -1062,6 +1204,11 @@ gdk_x11_window_get_drawable_impl
 gdk_x11_pixmap_get_drawable_impl
 #endif
 
+#if IN_FILE(__GDK_GC_X11_C__)
+gdk_x11_gc_get_xdisplay
+gdk_x11_gc_get_xgc
+#endif
+
 #if IN_FILE(__GDK_MAIN_X11_C__)
 gdk_x11_get_default_root_xwindow
 gdk_x11_get_default_screen
@@ -1070,6 +1217,11 @@ gdk_x11_grab_server
 gdk_x11_ungrab_server
 #endif
 
+#if IN_FILE(__GDK_IMAGE_X11_C__)
+gdk_x11_image_get_xdisplay
+gdk_x11_image_get_ximage
+#endif
+
 #if IN_FILE(__GDK_SCREEN_X11_C__)
 gdk_net_wm_supports
 gdk_x11_screen_get_screen_number

gdk/gdkcolor.h

@@ -110,6 +110,9 @@ gboolean gdk_colormap_alloc_color (GdkColormap    *colormap,
 void     gdk_colormap_free_colors (GdkColormap    *colormap,
 				   const GdkColor *colors,
 				   gint            n_colors);
+void     gdk_colormap_query_color (GdkColormap    *colormap,
+				   gulong          pixel,
+				   GdkColor       *result);
 
 GdkVisual *gdk_colormap_get_visual (GdkColormap *colormap);
 

gdk/gdkcursor.c

@@ -97,20 +97,3 @@ gdk_cursor_new (GdkCursorType cursor_type)
 {
   return gdk_cursor_new_for_display (gdk_display_get_default(), cursor_type);
 }
-
-/**
- * gdk_cursor_get_cursor_type:
- * @cursor:  a #GdkCursor
- *
- * Returns the cursor type for this cursor.
- *
- * Return value: a #GdkCursorType
- *
- * Since: 2.22
- **/
-GdkCursorType
-gdk_cursor_get_cursor_type (GdkCursor *cursor)
-{
-  g_return_val_if_fail (cursor != NULL, GDK_BLANK_CURSOR);
-  return cursor->type;
-}

gdk/gdkcursor.h

@@ -157,7 +157,6 @@ void        gdk_cursor_unref             (GdkCursor       *cursor);
 GdkCursor*  gdk_cursor_new_from_name	 (GdkDisplay      *display,
 					  const gchar     *name);
 GdkPixbuf*  gdk_cursor_get_image         (GdkCursor       *cursor);
-GdkCursorType gdk_cursor_get_cursor_type (GdkCursor       *cursor);
 
 
 G_END_DECLS

gdk/gdkdevicemanager.c

@@ -283,8 +283,7 @@ gdk_device_manager_get_display (GdkDeviceManager *device_manager)
  * Returns the list of devices of type @type currently attached to
  * @device_manager.
  *
- * Returns: (transfer container) (element-type Gdk.Device): a list of 
- *          #GdkDevice<!-- -->s. The returned list must be
+ * Returns: a list of #GdkDevice<!-- -->s. The returned list must be
  *          freed with g_list_free (). The list elements are owned by
  *          GTK+ and must not be freed or unreffed.
  *

gdk/gdkdisplay.c

@@ -338,24 +338,6 @@ gdk_display_close (GdkDisplay *display)
     }
 }
 
-/**
- * gdk_display_is_closed:
- * @display: a #GdkDisplay
- *
- * Finds out if the display has been closed.
- *
- * Returns: %TRUE if the display is closed.
- *
- * Since: 2.22
- */
-gboolean
-gdk_display_is_closed  (GdkDisplay  *display)
-{
-  g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
-
-  return display->closed;
-}
-
 /**
  * gdk_display_get_event:
  * @display: a #GdkDisplay

gdk/gdkdisplay.h

@@ -211,8 +211,7 @@ void        gdk_display_beep               (GdkDisplay  *display);
 void        gdk_display_sync               (GdkDisplay  *display);
 void        gdk_display_flush              (GdkDisplay  *display);
 
-void	    gdk_display_close		       (GdkDisplay  *display);
-gboolean    gdk_display_is_closed          (GdkDisplay  *display);
+void	    gdk_display_close		   (GdkDisplay  *display);
 
 #ifndef GDK_DISABLE_DEPRECATED
 GList *     gdk_display_list_devices       (GdkDisplay  *display);

gdk/gdkdrawable.h

@@ -32,6 +32,8 @@
 #define __GDK_DRAWABLE_H__
 
 #include <gdk/gdktypes.h>
+#include <gdk/gdkgc.h>
+#include <gdk/gdkrgb.h>
 #include <gdk-pixbuf/gdk-pixbuf.h>
 
 #include <cairo.h>
@@ -39,6 +41,7 @@
 G_BEGIN_DECLS
 
 typedef struct _GdkDrawableClass GdkDrawableClass;
+typedef struct _GdkTrapezoid     GdkTrapezoid;
 
 #define GDK_TYPE_DRAWABLE              (gdk_drawable_get_type ())
 #define GDK_DRAWABLE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_DRAWABLE, GdkDrawable))
@@ -56,6 +59,69 @@ struct _GdkDrawableClass
 {
   GObjectClass parent_class;
   
+  GdkGC *(*create_gc)    (GdkDrawable    *drawable,
+		          GdkGCValues    *values,
+		          GdkGCValuesMask mask);
+  void (*draw_rectangle) (GdkDrawable  *drawable,
+			  GdkGC	       *gc,
+			  gboolean	filled,
+			  gint		x,
+			  gint		y,
+			  gint		width,
+			  gint		height);
+  void (*draw_arc)       (GdkDrawable  *drawable,
+			  GdkGC	       *gc,
+			  gboolean	filled,
+			  gint		x,
+			  gint		y,
+			  gint		width,
+			  gint		height,
+			  gint		angle1,
+			  gint		angle2);
+  void (*draw_polygon)   (GdkDrawable  *drawable,
+			  GdkGC	       *gc,
+			  gboolean	filled,
+			  GdkPoint     *points,
+			  gint		npoints);
+  void (*draw_drawable)  (GdkDrawable  *drawable,
+			  GdkGC	       *gc,
+			  GdkDrawable  *src,
+			  gint		xsrc,
+			  gint		ysrc,
+			  gint		xdest,
+			  gint		ydest,
+			  gint		width,
+			  gint		height);
+  void (*draw_points)	 (GdkDrawable  *drawable,
+			  GdkGC	       *gc,
+			  GdkPoint     *points,
+			  gint		npoints);
+  void (*draw_segments)	 (GdkDrawable  *drawable,
+			  GdkGC	       *gc,
+			  GdkSegment   *segs,
+			  gint		nsegs);
+  void (*draw_lines)     (GdkDrawable  *drawable,
+			  GdkGC        *gc,
+			  GdkPoint     *points,
+			  gint          npoints);
+
+  void (*draw_glyphs)    (GdkDrawable      *drawable,
+			  GdkGC	           *gc,
+			  PangoFont        *font,
+			  gint              x,
+			  gint              y,
+			  PangoGlyphString *glyphs);
+
+  void (*draw_image)     (GdkDrawable *drawable,
+                          GdkGC	      *gc,
+                          GdkImage    *image,
+                          gint	       xsrc,
+                          gint	       ysrc,
+                          gint	       xdest,
+                          gint	       ydest,
+                          gint	       width,
+                          gint	       height);
+  
   gint (*get_depth)      (GdkDrawable  *drawable);
   void (*get_size)       (GdkDrawable  *drawable,
                           gint         *width,
@@ -68,9 +134,56 @@ struct _GdkDrawableClass
   GdkVisual*   (*get_visual)	(GdkDrawable  *drawable);
   GdkScreen*   (*get_screen)	(GdkDrawable  *drawable);
 
+  GdkImage*    (*get_image)  (GdkDrawable  *drawable,
+                              gint          x,
+                              gint          y,
+                              gint          width,
+                              gint          height);
+
   cairo_region_t*   (*get_clip_region)    (GdkDrawable  *drawable);
   cairo_region_t*   (*get_visible_region) (GdkDrawable  *drawable);
 
+  GdkDrawable* (*get_composite_drawable) (GdkDrawable *drawable,
+                                          gint         x,
+                                          gint         y,
+                                          gint         width,
+                                          gint         height,
+                                          gint        *composite_x_offset,
+                                          gint        *composite_y_offset);
+
+  void         (*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);
+  GdkImage*    (*_copy_to_image) (GdkDrawable    *drawable,
+				  GdkImage       *image,
+				  gint            src_x,
+				  gint            src_y,
+				  gint            dest_x,
+				  gint            dest_y,
+				  gint            width,
+				  gint            height);
+  
+  void (*draw_glyphs_transformed) (GdkDrawable      *drawable,
+				   GdkGC	    *gc,
+				   PangoMatrix      *matrix,
+				   PangoFont        *font,
+				   gint              x,
+				   gint              y,
+				   PangoGlyphString *glyphs);
+  void (*draw_trapezoids)         (GdkDrawable      *drawable,
+				   GdkGC	    *gc,
+				   GdkTrapezoid     *trapezoids,
+				   gint              n_trapezoids);
+
   cairo_surface_t *(*ref_cairo_surface) (GdkDrawable *drawable);
 
   GdkDrawable *(*get_source_drawable) (GdkDrawable *drawable);
@@ -82,6 +195,17 @@ struct _GdkDrawableClass
 					     int width,
 					     int height);
 
+  void (*draw_drawable_with_src)  (GdkDrawable  *drawable,
+				   GdkGC	       *gc,
+				   GdkDrawable  *src,
+				   gint		xsrc,
+				   gint		ysrc,
+				   gint		xdest,
+				   gint		ydest,
+				   gint		width,
+				   gint		height,
+				   GdkDrawable  *original_src);
+
   /* Padding for future expansion */
   void         (*_gdk_reserved7)  (void);
   void         (*_gdk_reserved9)  (void);
@@ -93,6 +217,11 @@ struct _GdkDrawableClass
   void         (*_gdk_reserved15) (void);
 };
 
+struct _GdkTrapezoid
+{
+  double y1, x11, x21, y2, x12, x22;
+};
+
 GType           gdk_drawable_get_type     (void) G_GNUC_CONST;
 
 /* Manipulation of drawables
@@ -108,6 +237,141 @@ gint            gdk_drawable_get_depth    (GdkDrawable	  *drawable);
 GdkScreen*	gdk_drawable_get_screen   (GdkDrawable    *drawable);
 GdkDisplay*	gdk_drawable_get_display  (GdkDrawable    *drawable);
 
+/* Drawing
+ */
+void gdk_draw_point     (GdkDrawable      *drawable,
+			 GdkGC            *gc,
+			 gint              x,
+			 gint              y);
+void gdk_draw_line      (GdkDrawable      *drawable,
+			 GdkGC            *gc,
+			 gint              x1_,
+			 gint              y1_,
+			 gint              x2_,
+			 gint              y2_);
+void gdk_draw_rectangle (GdkDrawable      *drawable,
+			 GdkGC            *gc,
+			 gboolean          filled,
+			 gint              x,
+			 gint              y,
+			 gint              width,
+			 gint              height);
+void gdk_draw_arc       (GdkDrawable      *drawable,
+			 GdkGC            *gc,
+			 gboolean          filled,
+			 gint              x,
+			 gint              y,
+			 gint              width,
+			 gint              height,
+			 gint              angle1,
+			 gint              angle2);
+void gdk_draw_polygon   (GdkDrawable      *drawable,
+			 GdkGC            *gc,
+			 gboolean          filled,
+			 const GdkPoint   *points,
+			 gint              n_points);
+void gdk_draw_drawable  (GdkDrawable      *drawable,
+			 GdkGC            *gc,
+			 GdkDrawable      *src,
+			 gint              xsrc,
+			 gint              ysrc,
+			 gint              xdest,
+			 gint              ydest,
+			 gint              width,
+			 gint              height);
+void gdk_draw_image     (GdkDrawable      *drawable,
+			 GdkGC            *gc,
+			 GdkImage         *image,
+			 gint              xsrc,
+			 gint              ysrc,
+			 gint              xdest,
+			 gint              ydest,
+			 gint              width,
+			 gint              height);
+void gdk_draw_points    (GdkDrawable      *drawable,
+			 GdkGC            *gc,
+			 const GdkPoint   *points,
+			 gint              n_points);
+void gdk_draw_segments  (GdkDrawable      *drawable,
+			 GdkGC            *gc,
+			 const GdkSegment *segs,
+			 gint              n_segs);
+void gdk_draw_lines     (GdkDrawable      *drawable,
+			 GdkGC            *gc,
+			 const GdkPoint   *points,
+			 gint              n_points);
+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);
+
+void gdk_draw_glyphs      (GdkDrawable      *drawable,
+			   GdkGC            *gc,
+			   PangoFont        *font,
+			   gint              x,
+			   gint              y,
+			   PangoGlyphString *glyphs);
+void gdk_draw_layout_line (GdkDrawable      *drawable,
+			   GdkGC            *gc,
+			   gint              x,
+			   gint              y,
+			   PangoLayoutLine  *line);
+void gdk_draw_layout      (GdkDrawable      *drawable,
+			   GdkGC            *gc,
+			   gint              x,
+			   gint              y,
+			   PangoLayout      *layout);
+
+void gdk_draw_layout_line_with_colors (GdkDrawable     *drawable,
+                                       GdkGC           *gc,
+                                       gint             x,
+                                       gint             y,
+                                       PangoLayoutLine *line,
+                                       const GdkColor  *foreground,
+                                       const GdkColor  *background);
+void gdk_draw_layout_with_colors      (GdkDrawable     *drawable,
+                                       GdkGC           *gc,
+                                       gint             x,
+                                       gint             y,
+                                       PangoLayout     *layout,
+                                       const GdkColor  *foreground,
+                                       const GdkColor  *background);
+
+void gdk_draw_glyphs_transformed (GdkDrawable        *drawable,
+				  GdkGC	             *gc,
+				  const PangoMatrix  *matrix,
+				  PangoFont          *font,
+				  gint                x,
+				  gint                y,
+				  PangoGlyphString   *glyphs);
+void gdk_draw_trapezoids         (GdkDrawable        *drawable,
+				  GdkGC	             *gc,
+				  const GdkTrapezoid *trapezoids,
+				  gint                n_trapezoids);
+
+
+GdkImage* gdk_drawable_get_image      (GdkDrawable *drawable,
+                                       gint         x,
+                                       gint         y,
+                                       gint         width,
+                                       gint         height);
+GdkImage *gdk_drawable_copy_to_image (GdkDrawable  *drawable,
+				      GdkImage     *image,
+				      gint          src_x,
+				      gint          src_y,
+				      gint          dest_x,
+				      gint          dest_y,
+				      gint          width,
+				      gint          height);
+
 cairo_region_t *gdk_drawable_get_clip_region    (GdkDrawable *drawable);
 cairo_region_t *gdk_drawable_get_visible_region (GdkDrawable *drawable);
 

gdk/gdkgc.h

@@ -0,0 +1,288 @@
+/* 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/.
+ */
+
+#if !defined (__GDK_H_INSIDE__) && !defined (GDK_COMPILATION)
+#error "Only <gdk/gdk.h> can be included directly."
+#endif
+
+#ifndef __GDK_GC_H__
+#define __GDK_GC_H__
+
+#include <gdk/gdkcolor.h>
+#include <gdk/gdktypes.h>
+
+G_BEGIN_DECLS
+
+typedef struct _GdkGCValues	      GdkGCValues;
+typedef struct _GdkGCClass	      GdkGCClass;
+
+/* GC cap styles
+ *  CapNotLast:
+ *  CapButt:
+ *  CapRound:
+ *  CapProjecting:
+ */
+typedef enum
+{
+  GDK_CAP_NOT_LAST,
+  GDK_CAP_BUTT,
+  GDK_CAP_ROUND,
+  GDK_CAP_PROJECTING
+} GdkCapStyle;
+
+/* GC fill types.
+ *  Solid:
+ *  Tiled:
+ *  Stippled:
+ *  OpaqueStippled:
+ */
+typedef enum
+{
+  GDK_SOLID,
+  GDK_TILED,
+  GDK_STIPPLED,
+  GDK_OPAQUE_STIPPLED
+} GdkFill;
+
+/* GC function types.
+ *   Copy: Overwrites destination pixels with the source pixels.
+ *   Invert: Inverts the destination pixels.
+ *   Xor: Xor's the destination pixels with the source pixels.
+ *   Clear: set pixels to 0
+ *   And: source AND destination
+ *   And Reverse: source AND (NOT destination)
+ *   And Invert: (NOT source) AND destination
+ *   Noop: destination
+ *   Or: source OR destination
+ *   Nor: (NOT source) AND (NOT destination)
+ *   Equiv: (NOT source) XOR destination
+ *   Xor Reverse: source OR (NOT destination)
+ *   Copy Inverted: NOT source
+ *   Xor Inverted: (NOT source) OR destination
+ *   Nand: (NOT source) OR (NOT destination)
+ *   Set: set pixels to 1
+ */
+typedef enum
+{
+  GDK_COPY,
+  GDK_INVERT,
+  GDK_XOR,
+  GDK_CLEAR,
+  GDK_AND,
+  GDK_AND_REVERSE,
+  GDK_AND_INVERT,
+  GDK_NOOP,
+  GDK_OR,
+  GDK_EQUIV,
+  GDK_OR_REVERSE,
+  GDK_COPY_INVERT,
+  GDK_OR_INVERT,
+  GDK_NAND,
+  GDK_NOR,
+  GDK_SET
+} GdkFunction;
+
+/* GC join styles
+ *  JoinMiter:
+ *  JoinRound:
+ *  JoinBevel:
+ */
+typedef enum
+{
+  GDK_JOIN_MITER,
+  GDK_JOIN_ROUND,
+  GDK_JOIN_BEVEL
+} GdkJoinStyle;
+
+/* GC line styles
+ *  Solid:
+ *  OnOffDash:
+ *  DoubleDash:
+ */
+typedef enum
+{
+  GDK_LINE_SOLID,
+  GDK_LINE_ON_OFF_DASH,
+  GDK_LINE_DOUBLE_DASH
+} GdkLineStyle;
+
+typedef enum
+{
+  GDK_CLIP_BY_CHILDREN	= 0,
+  GDK_INCLUDE_INFERIORS = 1
+} GdkSubwindowMode;
+
+typedef enum
+{
+  GDK_GC_FOREGROUND    = 1 << 0,
+  GDK_GC_BACKGROUND    = 1 << 1,
+  GDK_GC_FUNCTION      = 1 << 2,
+  GDK_GC_FILL	       = 1 << 3,
+  GDK_GC_TILE	       = 1 << 4,
+  GDK_GC_STIPPLE       = 1 << 5,
+  GDK_GC_CLIP_MASK     = 1 << 6,
+  GDK_GC_SUBWINDOW     = 1 << 7,
+  GDK_GC_TS_X_ORIGIN   = 1 << 8,
+  GDK_GC_TS_Y_ORIGIN   = 1 << 9,
+  GDK_GC_CLIP_X_ORIGIN = 1 << 10,
+  GDK_GC_CLIP_Y_ORIGIN = 1 << 11,
+  GDK_GC_EXPOSURES     = 1 << 12,
+  GDK_GC_LINE_WIDTH    = 1 << 13,
+  GDK_GC_LINE_STYLE    = 1 << 14,
+  GDK_GC_CAP_STYLE     = 1 << 15,
+  GDK_GC_JOIN_STYLE    = 1 << 16
+} GdkGCValuesMask;
+
+struct _GdkGCValues
+{
+  GdkColor	    foreground;
+  GdkColor	    background;
+  GdkFunction	    function;
+  GdkFill	    fill;
+  GdkPixmap	   *tile;
+  GdkPixmap	   *stipple;
+  GdkPixmap	   *clip_mask;
+  GdkSubwindowMode  subwindow_mode;
+  gint		    ts_x_origin;
+  gint		    ts_y_origin;
+  gint		    clip_x_origin;
+  gint		    clip_y_origin;
+  gint		    graphics_exposures;
+  gint		    line_width;
+  GdkLineStyle	    line_style;
+  GdkCapStyle	    cap_style;
+  GdkJoinStyle	    join_style;
+};
+
+#define GDK_TYPE_GC              (gdk_gc_get_type ())
+#define GDK_GC(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_GC, GdkGC))
+#define GDK_GC_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_GC, GdkGCClass))
+#define GDK_IS_GC(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_GC))
+#define GDK_IS_GC_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_GC))
+#define GDK_GC_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_GC, GdkGCClass))
+
+struct _GdkGC
+{
+  GObject parent_instance;
+
+  gint GSEAL (clip_x_origin);
+  gint GSEAL (clip_y_origin);
+  gint GSEAL (ts_x_origin);
+  gint GSEAL (ts_y_origin);
+
+  GdkColormap *GSEAL (colormap);
+};
+
+struct _GdkGCClass 
+{
+  GObjectClass parent_class;
+  
+  void (*get_values)     (GdkGC          *gc,
+			  GdkGCValues    *values);
+  void (*set_values)     (GdkGC          *gc,
+			  GdkGCValues    *values,
+			  GdkGCValuesMask mask);
+  void (*set_dashes)     (GdkGC          *gc,
+			  gint	          dash_offset,
+			  gint8           dash_list[],
+			  gint            n);
+  
+  /* Padding for future expansion */
+  void         (*_gdk_reserved1)  (void);
+  void         (*_gdk_reserved2)  (void);
+  void         (*_gdk_reserved3)  (void);
+  void         (*_gdk_reserved4)  (void);
+};
+
+
+GType  gdk_gc_get_type            (void) G_GNUC_CONST;
+GdkGC *gdk_gc_new		  (GdkDrawable	    *drawable);
+GdkGC *gdk_gc_new_with_values	  (GdkDrawable	    *drawable,
+				   GdkGCValues	    *values,
+				   GdkGCValuesMask   values_mask);
+
+void   gdk_gc_get_values	  (GdkGC	    *gc,
+				   GdkGCValues	    *values);
+void   gdk_gc_set_values          (GdkGC           *gc,
+                                   GdkGCValues	   *values,
+                                   GdkGCValuesMask  values_mask);
+void   gdk_gc_set_foreground	  (GdkGC	    *gc,
+				   const GdkColor   *color);
+void   gdk_gc_set_background	  (GdkGC	    *gc,
+				   const GdkColor   *color);
+void   gdk_gc_set_function	  (GdkGC	    *gc,
+				   GdkFunction	     function);
+void   gdk_gc_set_fill		  (GdkGC	    *gc,
+				   GdkFill	     fill);
+void   gdk_gc_set_tile		  (GdkGC	    *gc,
+				   GdkPixmap	    *tile);
+void   gdk_gc_set_stipple	  (GdkGC	    *gc,
+				   GdkPixmap	    *stipple);
+void   gdk_gc_set_ts_origin	  (GdkGC	    *gc,
+				   gint		     x,
+				   gint		     y);
+void   gdk_gc_set_clip_origin	  (GdkGC	    *gc,
+				   gint		     x,
+				   gint		     y);
+void   gdk_gc_set_clip_mask	  (GdkGC	    *gc,
+				   GdkBitmap	    *mask);
+void   gdk_gc_set_clip_rectangle  (GdkGC	    *gc,
+				   const GdkRectangle *rectangle);
+void   gdk_gc_set_clip_region	  (GdkGC	    *gc,
+				   const cairo_region_t  *region);
+void   gdk_gc_set_subwindow	  (GdkGC	    *gc,
+				   GdkSubwindowMode  mode);
+void   gdk_gc_set_exposures	  (GdkGC	    *gc,
+				   gboolean	     exposures);
+void   gdk_gc_set_line_attributes (GdkGC	    *gc,
+				   gint		     line_width,
+				   GdkLineStyle	     line_style,
+				   GdkCapStyle	     cap_style,
+				   GdkJoinStyle	     join_style);
+void   gdk_gc_set_dashes          (GdkGC            *gc,
+				   gint	             dash_offset,
+				   gint8             dash_list[],
+				   gint              n);
+void   gdk_gc_offset              (GdkGC            *gc,
+				   gint              x_offset,
+				   gint              y_offset);
+void   gdk_gc_copy		  (GdkGC	    *dst_gc,
+				   GdkGC	    *src_gc);
+
+
+void         gdk_gc_set_colormap     (GdkGC          *gc,
+				      GdkColormap    *colormap);
+GdkColormap *gdk_gc_get_colormap     (GdkGC          *gc);
+void         gdk_gc_set_rgb_fg_color (GdkGC          *gc,
+				      const GdkColor *color);
+void         gdk_gc_set_rgb_bg_color (GdkGC          *gc,
+				      const GdkColor *color);
+GdkScreen *  gdk_gc_get_screen	     (GdkGC          *gc);
+
+
+G_END_DECLS
+
+#endif /* __GDK_DRAWABLE_H__ */

gdk/gdkimage.c

@@ -0,0 +1,566 @@
+/* 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 <stdlib.h>
+#include <sys/types.h>
+
+#include "gdk.h"		/* For gdk_flush() */
+#include "gdkimage.h"
+#include "gdkprivate.h"
+#include "gdkinternals.h"	/* For scratch_image code */
+
+/**
+ * gdk_image_set_colormap:
+ * @image: a #GdkImage
+ * @colormap: a #GdkColormap
+ * 
+ * Sets the colormap for the image to the given colormap.  Normally
+ * there's no need to use this function, images are created with the
+ * correct colormap if you get the image from a drawable. If you
+ * create the image from scratch, use the colormap of the drawable you
+ * intend to render the image to.
+ **/
+void
+gdk_image_set_colormap (GdkImage       *image,
+                        GdkColormap    *colormap)
+{
+  g_return_if_fail (GDK_IS_IMAGE (image));
+  g_return_if_fail (GDK_IS_COLORMAP (colormap));
+
+  if (image->colormap != colormap)
+    {
+      if (image->colormap)
+	g_object_unref (image->colormap);
+
+      image->colormap = colormap;
+      g_object_ref (image->colormap);
+    }
+}
+
+/**
+ * gdk_image_get_colormap:
+ * @image: a #GdkImage
+ * 
+ * Retrieves the colormap for a given image, if it exists.  An image
+ * will have a colormap if the drawable from which it was created has
+ * a colormap, or if a colormap was set explicitely with
+ * gdk_image_set_colormap().
+ * 
+ * Return value: colormap for the image
+ **/
+GdkColormap *
+gdk_image_get_colormap (GdkImage *image)
+{
+  g_return_val_if_fail (GDK_IS_IMAGE (image), NULL);
+
+  return image->colormap;
+}
+
+/**
+ * gdk_image_get_image_type:
+ * @image: a #GdkImage
+ *
+ * Determines the type of a given image.
+ *
+ * Return value: the #GdkImageType of the image
+ *
+ * Since: 2.22
+ **/
+GdkImageType
+gdk_image_get_image_type (GdkImage *image)
+{
+  g_return_val_if_fail (GDK_IS_IMAGE (image), 0);
+
+  return image->type;
+}
+
+/**
+ * gdk_image_get_visual:
+ * @image: a #GdkImage
+ *
+ * Determines the visual that was used to create the image.
+ *
+ * Return value: a #GdkVisual
+ *
+ * Since: 2.22
+ **/
+GdkVisual *
+gdk_image_get_visual (GdkImage *image)
+{
+  g_return_val_if_fail (GDK_IS_IMAGE (image), NULL);
+
+  return image->visual;
+}
+
+/**
+ * gdk_image_get_byte_order:
+ * @image: a #GdkImage
+ *
+ * Determines the byte order of the image.
+ *
+ * Return value: a #GdkVisual
+ *
+ * Since: 2.22
+ **/
+GdkByteOrder
+gdk_image_get_byte_order (GdkImage *image)
+{
+  g_return_val_if_fail (GDK_IS_IMAGE (image), 0);
+
+  return image->byte_order;
+}
+
+/**
+ * gdk_image_get_width:
+ * @image: a #GdkImage
+ *
+ * Determines the width of the image.
+ *
+ * Return value: the width
+ *
+ * Since: 2.22
+ **/
+gint
+gdk_image_get_width (GdkImage *image)
+{
+  g_return_val_if_fail (GDK_IS_IMAGE (image), 0);
+
+  return image->width;
+}
+
+/**
+ * gdk_image_get_height:
+ * @image: a #GdkImage
+ *
+ * Determines the height of the image.
+ *
+ * Return value: the height
+ *
+ * Since: 2.22
+ **/
+gint
+gdk_image_get_height (GdkImage *image)
+{
+  g_return_val_if_fail (GDK_IS_IMAGE (image), 0);
+
+  return image->height;
+}
+
+/**
+ * gdk_image_get_depth:
+ * @image: a #GdkImage
+ *
+ * Determines the depth of the image.
+ *
+ * Return value: the depth
+ *
+ * Since: 2.22
+ **/
+guint16
+gdk_image_get_depth (GdkImage *image)
+{
+  g_return_val_if_fail (GDK_IS_IMAGE (image), 0);
+
+  return image->depth;
+}
+
+/**
+ * gdk_image_get_bytes_per_pixel:
+ * @image: a #GdkImage
+ *
+ * Determines the number of bytes per pixel of the image.
+ *
+ * Return value: the bytes per pixel
+ *
+ * Since: 2.22
+ **/
+guint16
+gdk_image_get_bytes_per_pixel (GdkImage *image)
+{
+  g_return_val_if_fail (GDK_IS_IMAGE (image), 0);
+
+  return image->bpp;
+}
+
+/**
+ * gdk_image_get_bytes_per_line:
+ * @image: a #GdkImage
+ *
+ * Determines the number of bytes per line of the image.
+ *
+ * Return value: the bytes per line
+ *
+ * Since: 2.22
+ **/
+guint16
+gdk_image_get_bytes_per_line (GdkImage *image)
+{
+  g_return_val_if_fail (GDK_IS_IMAGE (image), 0);
+
+  return image->bpl;
+}
+
+/**
+ * gdk_image_get_bits_per_pixel:
+ * @image: a #GdkImage
+ *
+ * Determines the number of bits per pixel of the image.
+ *
+ * Return value: the bits per pixel
+ *
+ * Since: 2.22
+ **/
+guint16
+gdk_image_get_bits_per_pixel (GdkImage *image)
+{
+  g_return_val_if_fail (GDK_IS_IMAGE (image), 0);
+
+  return image->bits_per_pixel;
+}
+
+/**
+ * gdk_image_get_pixels:
+ * @image: a #GdkImage
+ *
+ * Returns a pointer to the pixel data of the image.
+ *
+ * Returns: the pixel data of the image
+ *
+ * Since: 2.22
+ */
+gpointer
+gdk_image_get_pixels (GdkImage *image)
+{
+  g_return_val_if_fail (GDK_IS_IMAGE (image), NULL);
+
+  return image->mem;
+}
+
+/* We have N_REGION GDK_SCRATCH_IMAGE_WIDTH x GDK_SCRATCH_IMAGE_HEIGHT regions divided
+ * up between n_images different images. possible_n_images gives
+ * various divisors of N_REGIONS. The reason for allowing this
+ * flexibility is that we want to create as few images as possible,
+ * but we want to deal with the abberant systems that have a SHMMAX
+ * limit less than
+ *
+ * GDK_SCRATCH_IMAGE_WIDTH * GDK_SCRATCH_IMAGE_HEIGHT * N_REGIONS * 4 (384k)
+ *
+ * (Are there any such?)
+ */
+#define N_REGIONS 6
+static const int possible_n_images[] = { 1, 2, 3, 6 };
+
+/* We allocate one GdkScratchImageInfo structure for each
+ * depth where we are allocating scratch images. (Future: one
+ * per depth, per display)
+ */
+typedef struct _GdkScratchImageInfo GdkScratchImageInfo;
+
+struct _GdkScratchImageInfo {
+  gint depth;
+  
+  gint n_images;
+  GdkImage *static_image[N_REGIONS];
+  gint static_image_idx;
+
+  /* In order to optimize filling fractions, we simultaneously fill in up
+   * to three regions of size GDK_SCRATCH_IMAGE_WIDTH * GDK_SCRATCH_IMAGE_HEIGHT: one
+   * for images that are taller than GDK_SCRATCH_IMAGE_HEIGHT / 2, and must
+   * be tiled horizontally. One for images that are wider than
+   * GDK_SCRATCH_IMAGE_WIDTH / 2 and must be tiled vertically, and a third
+   * for images smaller than GDK_SCRATCH_IMAGE_HEIGHT / 2 x GDK_SCRATCH_IMAGE_WIDTH x 2
+   * that we tile in horizontal rows.
+   */
+  gint horiz_idx;
+  gint horiz_y;
+  gint vert_idx;
+  gint vert_x;
+  
+  /* tile_y1 and tile_y2 define the horizontal band into
+   * which we are tiling images. tile_x is the x extent to
+   * which that is filled
+   */
+  gint tile_idx;
+  gint tile_x;
+  gint tile_y1;
+  gint tile_y2;
+
+  GdkScreen *screen;
+};
+
+static GSList *scratch_image_infos = NULL;
+
+static gboolean
+allocate_scratch_images (GdkScratchImageInfo *info,
+			 gint                 n_images,
+			 gboolean             shared)
+{
+  gint i;
+  
+  for (i = 0; i < n_images; i++)
+    {
+      info->static_image[i] = _gdk_image_new_for_depth (info->screen,
+							shared ? GDK_IMAGE_SHARED : GDK_IMAGE_NORMAL,
+							NULL,
+							GDK_SCRATCH_IMAGE_WIDTH * (N_REGIONS / n_images), 
+							GDK_SCRATCH_IMAGE_HEIGHT,
+							info->depth);
+      
+      if (!info->static_image[i])
+	{
+	  gint j;
+	  
+	  for (j = 0; j < i; j++)
+	    g_object_unref (info->static_image[j]);
+	  
+	  return FALSE;
+	}
+    }
+  
+  return TRUE;
+}
+
+static void
+scratch_image_info_display_closed (GdkDisplay          *display,
+                                   gboolean             is_error,
+                                   GdkScratchImageInfo *image_info)
+{
+  gint i;
+
+  g_signal_handlers_disconnect_by_func (display,
+                                        scratch_image_info_display_closed,
+                                        image_info);
+
+  scratch_image_infos = g_slist_remove (scratch_image_infos, image_info);
+
+  for (i = 0; i < image_info->n_images; i++)
+    g_object_unref (image_info->static_image[i]);
+
+  g_free (image_info);
+}
+
+static GdkScratchImageInfo *
+scratch_image_info_for_depth (GdkScreen *screen,
+			      gint       depth)
+{
+  GSList *tmp_list;
+  GdkScratchImageInfo *image_info;
+  gint i;
+
+  tmp_list = scratch_image_infos;
+  while (tmp_list)
+    {
+      image_info = tmp_list->data;
+      if (image_info->depth == depth && image_info->screen == screen)
+	return image_info;
+      
+      tmp_list = tmp_list->next;
+    }
+
+  image_info = g_new (GdkScratchImageInfo, 1);
+
+  image_info->depth = depth;
+  image_info->screen = screen;
+
+  g_signal_connect (gdk_screen_get_display (screen), "closed",
+                    G_CALLBACK (scratch_image_info_display_closed),
+                    image_info);
+
+  /* Try to allocate as few possible shared images */
+  for (i=0; i < G_N_ELEMENTS (possible_n_images); i++)
+    {
+      if (allocate_scratch_images (image_info, possible_n_images[i], TRUE))
+	{
+	  image_info->n_images = possible_n_images[i];
+	  break;
+	}
+    }
+
+  /* If that fails, just allocate N_REGIONS normal images */
+  if (i == G_N_ELEMENTS (possible_n_images))
+    {
+      allocate_scratch_images (image_info, N_REGIONS, FALSE);
+      image_info->n_images = N_REGIONS;
+    }
+
+  image_info->static_image_idx = 0;
+
+  image_info->horiz_y = GDK_SCRATCH_IMAGE_HEIGHT;
+  image_info->vert_x = GDK_SCRATCH_IMAGE_WIDTH;
+  image_info->tile_x = GDK_SCRATCH_IMAGE_WIDTH;
+  image_info->tile_y1 = image_info->tile_y2 = GDK_SCRATCH_IMAGE_HEIGHT;
+
+  scratch_image_infos = g_slist_prepend (scratch_image_infos, image_info);
+
+  return image_info;
+}
+
+/* Defining NO_FLUSH can cause inconsistent screen updates, but is useful
+   for performance evaluation. */
+
+#undef NO_FLUSH
+
+#ifdef VERBOSE
+static gint sincelast;
+#endif
+
+static gint
+alloc_scratch_image (GdkScratchImageInfo *image_info)
+{
+  if (image_info->static_image_idx == N_REGIONS)
+    {
+#ifndef NO_FLUSH
+      gdk_flush ();
+#endif
+#ifdef VERBOSE
+      g_print ("flush, %d puts since last flush\n", sincelast);
+      sincelast = 0;
+#endif
+      image_info->static_image_idx = 0;
+
+      /* Mark all regions that we might be filling in as completely
+       * full, to force new tiles to be allocated for subsequent
+       * images
+       */
+      image_info->horiz_y = GDK_SCRATCH_IMAGE_HEIGHT;
+      image_info->vert_x = GDK_SCRATCH_IMAGE_WIDTH;
+      image_info->tile_x = GDK_SCRATCH_IMAGE_WIDTH;
+      image_info->tile_y1 = image_info->tile_y2 = GDK_SCRATCH_IMAGE_HEIGHT;
+    }
+  return image_info->static_image_idx++;
+}
+
+/**
+ * _gdk_image_get_scratch:
+ * @screen: a #GdkScreen
+ * @width: desired width
+ * @height: desired height
+ * @depth: depth of image 
+ * @x: X location within returned image of scratch image
+ * @y: Y location within returned image of scratch image
+ * 
+ * Allocates an image of size width/height, up to a maximum
+ * of GDK_SCRATCH_IMAGE_WIDTHxGDK_SCRATCH_IMAGE_HEIGHT that is
+ * suitable to use on @screen.
+ * 
+ * Return value: a scratch image. This must be used by a
+ *  call to gdk_image_put() before any other calls to
+ *  _gdk_image_get_scratch()
+ **/
+GdkImage *
+_gdk_image_get_scratch (GdkScreen   *screen,
+			gint	     width,			
+			gint	     height,
+			gint	     depth,
+			gint	    *x,
+			gint	    *y)
+{
+  GdkScratchImageInfo *image_info;
+  GdkImage *image;
+  gint idx;
+  
+  g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+
+  image_info = scratch_image_info_for_depth (screen, depth);
+
+  if (width >= (GDK_SCRATCH_IMAGE_WIDTH >> 1))
+    {
+      if (height >= (GDK_SCRATCH_IMAGE_HEIGHT >> 1))
+	{
+	  idx = alloc_scratch_image (image_info);
+	  *x = 0;
+	  *y = 0;
+	}
+      else
+	{
+	  if (height + image_info->horiz_y > GDK_SCRATCH_IMAGE_HEIGHT)
+	    {
+	      image_info->horiz_idx = alloc_scratch_image (image_info);
+	      image_info->horiz_y = 0;
+	    }
+	  idx = image_info->horiz_idx;
+	  *x = 0;
+	  *y = image_info->horiz_y;
+	  image_info->horiz_y += height;
+	}
+    }
+  else
+    {
+      if (height >= (GDK_SCRATCH_IMAGE_HEIGHT >> 1))
+	{
+	  if (width + image_info->vert_x > GDK_SCRATCH_IMAGE_WIDTH)
+	    {
+	      image_info->vert_idx = alloc_scratch_image (image_info);
+	      image_info->vert_x = 0;
+	    }
+	  idx = image_info->vert_idx;
+	  *x = image_info->vert_x;
+	  *y = 0;
+	  /* using 3 and -4 would be slightly more efficient on 32-bit machines
+	     with > 1bpp displays */
+	  image_info->vert_x += (width + 7) & -8;
+	}
+      else
+	{
+	  if (width + image_info->tile_x > GDK_SCRATCH_IMAGE_WIDTH)
+	    {
+	      image_info->tile_y1 = image_info->tile_y2;
+	      image_info->tile_x = 0;
+	    }
+	  if (height + image_info->tile_y1 > GDK_SCRATCH_IMAGE_HEIGHT)
+	    {
+	      image_info->tile_idx = alloc_scratch_image (image_info);
+	      image_info->tile_x = 0;
+	      image_info->tile_y1 = 0;
+	      image_info->tile_y2 = 0;
+	    }
+	  if (height + image_info->tile_y1 > image_info->tile_y2)
+	    image_info->tile_y2 = height + image_info->tile_y1;
+	  idx = image_info->tile_idx;
+	  *x = image_info->tile_x;
+	  *y = image_info->tile_y1;
+	  image_info->tile_x += (width + 7) & -8;
+	}
+    }
+  image = image_info->static_image[idx * image_info->n_images / N_REGIONS];
+  *x += GDK_SCRATCH_IMAGE_WIDTH * (idx % (N_REGIONS / image_info->n_images));
+#ifdef VERBOSE
+  g_print ("index %d, x %d, y %d (%d x %d)\n", idx, *x, *y, width, height);
+  sincelast++;
+#endif
+  return image;
+}
+
+GdkImage*
+gdk_image_new (GdkImageType  type,
+	       GdkVisual    *visual,
+	       gint          width,
+	       gint          height)
+{
+  return _gdk_image_new_for_depth (gdk_visual_get_screen (visual), type,
+				   visual, width, height, -1);
+}

gdk/gdkimage.h

@@ -0,0 +1,126 @@
+/* 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/.
+ */
+
+#if !defined (__GDK_H_INSIDE__) && !defined (GDK_COMPILATION)
+#error "Only <gdk/gdk.h> can be included directly."
+#endif
+
+#ifndef __GDK_IMAGE_H__
+#define __GDK_IMAGE_H__
+
+#include <gdk/gdktypes.h>
+
+G_BEGIN_DECLS
+
+/* Types of images.
+ *   Normal: Normal X image type. These are slow as they involve passing
+ *	     the entire image through the X connection each time a draw
+ *	     request is required. On Win32, a bitmap.
+ *   Shared: Shared memory X image type. These are fast as the X server
+ *	     and the program actually use the same piece of memory. They
+ *	     should be used with care though as there is the possibility
+ *	     for both the X server and the program to be reading/writing
+ *	     the image simultaneously and producing undesired results.
+ *	     On Win32, also a bitmap.
+ */
+typedef enum
+{
+  GDK_IMAGE_NORMAL,
+  GDK_IMAGE_SHARED,
+  GDK_IMAGE_FASTEST
+} GdkImageType;
+
+typedef struct _GdkImageClass GdkImageClass;
+
+#define GDK_TYPE_IMAGE              (gdk_image_get_type ())
+#define GDK_IMAGE(object)           (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_IMAGE, GdkImage))
+#define GDK_IMAGE_CLASS(klass)      (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_IMAGE, GdkImageClass))
+#define GDK_IS_IMAGE(object)        (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_IMAGE))
+#define GDK_IS_IMAGE_CLASS(klass)   (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_IMAGE))
+#define GDK_IMAGE_GET_CLASS(obj)    (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_IMAGE, GdkImageClass))
+
+struct _GdkImage
+{
+  GObject parent_instance;
+
+  /*< public >*/
+  
+  GdkImageType	GSEAL (type); /* read only. */
+  GdkVisual    *GSEAL (visual);	    /* read only. visual used to create the image */
+  GdkByteOrder	GSEAL (byte_order); /* read only. */
+  gint		GSEAL (width);  /* read only. */
+  gint		GSEAL (height); /* read only. */
+  guint16	GSEAL (depth);  /* read only. */
+  guint16	GSEAL (bpp);    /* read only. bytes per pixel */
+  guint16	GSEAL (bpl);    /* read only. bytes per line */
+  guint16       GSEAL (bits_per_pixel); /* read only. bits per pixel */
+  gpointer	GSEAL (mem);
+
+  GdkColormap  *GSEAL (colormap); /* read only. */
+
+  /*< private >*/
+  gpointer GSEAL (windowing_data); /* read only. */
+};
+
+struct _GdkImageClass
+{
+  GObjectClass parent_class;
+};
+
+GType     gdk_image_get_type   (void) G_GNUC_CONST;
+
+GdkImage*  gdk_image_new       (GdkImageType  type,
+				GdkVisual    *visual,
+				gint	      width,
+				gint	      height);
+
+void	   gdk_image_put_pixel (GdkImage     *image,
+				gint	      x,
+				gint	      y,
+				guint32	      pixel);
+guint32	   gdk_image_get_pixel (GdkImage     *image,
+				gint	      x,
+				gint	      y);
+
+void       gdk_image_set_colormap (GdkImage    *image,
+                                   GdkColormap *colormap);
+GdkColormap* gdk_image_get_colormap (GdkImage    *image);
+
+GdkImageType  gdk_image_get_image_type     (GdkImage *image);
+GdkVisual    *gdk_image_get_visual         (GdkImage *image);
+GdkByteOrder  gdk_image_get_byte_order     (GdkImage *image);
+gint          gdk_image_get_width          (GdkImage *image);
+gint          gdk_image_get_height         (GdkImage *image);
+guint16       gdk_image_get_depth          (GdkImage *image);
+guint16       gdk_image_get_bytes_per_pixel(GdkImage *image);
+guint16       gdk_image_get_bytes_per_line (GdkImage *image);
+guint16       gdk_image_get_bits_per_pixel (GdkImage *image);
+gpointer      gdk_image_get_pixels         (GdkImage *image);
+
+
+G_END_DECLS
+
+#endif /* __GDK_IMAGE_H__ */

gdk/gdkinternals.h

@@ -77,15 +77,16 @@ typedef enum {
   GDK_DEBUG_XIM           = 1 << 3,
   GDK_DEBUG_NOGRABS       = 1 << 4,
   GDK_DEBUG_COLORMAP	  = 1 << 5,
-  GDK_DEBUG_GC		  = 1 << 6,
-  GDK_DEBUG_PIXMAP	  = 1 << 7,
-  GDK_DEBUG_IMAGE	  = 1 << 8,
-  GDK_DEBUG_INPUT	  = 1 << 9,
-  GDK_DEBUG_CURSOR	  = 1 <<10,
-  GDK_DEBUG_MULTIHEAD	  = 1 <<11,
-  GDK_DEBUG_XINERAMA	  = 1 <<12,
-  GDK_DEBUG_DRAW	  = 1 <<13,
-  GDK_DEBUG_EVENTLOOP     = 1 <<14
+  GDK_DEBUG_GDKRGB	  = 1 << 6,
+  GDK_DEBUG_GC		  = 1 << 7,
+  GDK_DEBUG_PIXMAP	  = 1 << 8,
+  GDK_DEBUG_IMAGE	  = 1 << 9,
+  GDK_DEBUG_INPUT	  = 1 <<10,
+  GDK_DEBUG_CURSOR	  = 1 <<11,
+  GDK_DEBUG_MULTIHEAD	  = 1 <<12,
+  GDK_DEBUG_XINERAMA	  = 1 <<13,
+  GDK_DEBUG_DRAW	  = 1 <<14,
+  GDK_DEBUG_EVENTLOOP     = 1 <<15
 } GdkDebugFlag;
 
 extern GList            *_gdk_default_filters;
@@ -209,7 +210,6 @@ struct _GdkWindowObject
 
   GdkColor bg_color;
   GdkPixmap *bg_pixmap;
-  cairo_pattern_t *background;
   
   GSList *paint_stack;
   
@@ -318,6 +318,31 @@ void gdk_synthesize_window_state (GdkWindow     *window,
 GdkDeviceManager * _gdk_device_manager_new (GdkDisplay *display);
 
 
+#define GDK_SCRATCH_IMAGE_WIDTH 256
+#define GDK_SCRATCH_IMAGE_HEIGHT 64
+
+GdkImage* _gdk_image_new_for_depth (GdkScreen    *screen,
+				    GdkImageType  type,
+				    GdkVisual    *visual,
+				    gint          width,
+				    gint          height,
+				    gint          depth);
+GdkImage *_gdk_image_get_scratch (GdkScreen *screen,
+				  gint	     width,
+				  gint	     height,
+				  gint	     depth,
+				  gint	    *x,
+				  gint	    *y);
+
+GdkImage *_gdk_drawable_copy_to_image (GdkDrawable  *drawable,
+				       GdkImage     *image,
+				       gint          src_x,
+				       gint          src_y,
+				       gint          dest_x,
+				       gint          dest_y,
+				       gint          width,
+				       gint          height);
+
 cairo_surface_t *_gdk_drawable_ref_cairo_surface (GdkDrawable *drawable);
 
 GdkDrawable *_gdk_drawable_get_source_drawable (GdkDrawable *drawable);
@@ -325,6 +350,18 @@ cairo_surface_t * _gdk_drawable_create_cairo_surface (GdkDrawable *drawable,
 						      int width,
 						      int height);
 
+/* GC caching */
+GdkGC *_gdk_drawable_get_scratch_gc (GdkDrawable *drawable,
+				     gboolean     graphics_exposures);
+GdkGC *_gdk_drawable_get_subwindow_scratch_gc (GdkDrawable *drawable);
+
+void _gdk_gc_update_context (GdkGC          *gc,
+			     cairo_t        *cr,
+			     const GdkColor *override_foreground,
+			     GdkBitmap      *override_stipple,
+			     gboolean        gc_changed,
+			     GdkDrawable    *target_drawable);
+
 /*************************************
  * Interfaces used by windowing code *
  *************************************/
@@ -333,6 +370,17 @@ GdkPixmap *_gdk_pixmap_new               (GdkDrawable    *drawable,
                                           gint            width,
                                           gint            height,
                                           gint            depth);
+GdkPixmap *_gdk_pixmap_create_from_data  (GdkDrawable    *drawable,
+                                          const gchar    *data,
+                                          gint            width,
+                                          gint            height,
+                                          gint            depth,
+                                          const GdkColor *fg,
+                                          const GdkColor *bg);
+GdkPixmap *_gdk_bitmap_create_from_data  (GdkDrawable    *drawable,
+                                          const gchar    *data,
+                                          gint            width,
+                                          gint            height);
 
 void       _gdk_window_impl_new          (GdkWindow      *window,
 					  GdkWindow      *real_parent,
@@ -354,6 +402,38 @@ void       _gdk_screen_close             (GdkScreen      *screen);
 
 const char *_gdk_get_sm_client_id (void);
 
+void _gdk_gc_init (GdkGC           *gc,
+		   GdkDrawable     *drawable,
+		   GdkGCValues     *values,
+		   GdkGCValuesMask  values_mask);
+
+cairo_region_t *_gdk_gc_get_clip_region (GdkGC *gc);
+GdkBitmap *_gdk_gc_get_clip_mask   (GdkGC *gc);
+gboolean   _gdk_gc_get_exposures   (GdkGC *gc);
+GdkFill    _gdk_gc_get_fill        (GdkGC *gc);
+GdkPixmap *_gdk_gc_get_tile        (GdkGC *gc);
+GdkBitmap *_gdk_gc_get_stipple     (GdkGC *gc);
+guint32    _gdk_gc_get_fg_pixel    (GdkGC *gc);
+guint32    _gdk_gc_get_bg_pixel    (GdkGC *gc);
+void      _gdk_gc_add_drawable_clip     (GdkGC     *gc,
+					 guint32    region_tag,
+					 cairo_region_t *region,
+					 int        offset_x,
+					 int        offset_y);
+void      _gdk_gc_remove_drawable_clip  (GdkGC     *gc);
+void       _gdk_gc_set_clip_region_internal (GdkGC     *gc,
+					     cairo_region_t *region,
+					     gboolean reset_origin);
+GdkSubwindowMode _gdk_gc_get_subwindow (GdkGC *gc);
+
+GdkDrawable *_gdk_drawable_begin_direct_draw (GdkDrawable *drawable,
+					      GdkGC *gc,
+					      gpointer *priv_data,
+					      gint *x_offset_out,
+					      gint *y_offset_out);
+void         _gdk_drawable_end_direct_draw (gpointer priv_data);
+
+
 /*****************************************
  * Interfaces provided by windowing code *
  *****************************************/
@@ -457,6 +537,45 @@ GType _gdk_paintable_get_type (void) G_GNUC_CONST;
 GType _gdk_window_impl_get_type (void) G_GNUC_CONST;
 GType _gdk_pixmap_impl_get_type (void) G_GNUC_CONST;
 
+
+/**
+ * _gdk_windowing_gc_set_clip_region:
+ * @gc: a #GdkGC
+ * @region: the new clip region
+ * @reset_origin: if TRUE, reset the clip_x/y_origin values to 0
+ * 
+ * Do any window-system specific processing necessary
+ * for a change in clip region. Since the clip origin
+ * will likely change before the GC is used with the
+ * new clip, frequently this function will only set a flag and
+ * do the real processing later.
+ *
+ * When this function is called, _gdk_gc_get_clip_region
+ * will already return the new region.
+ **/
+void _gdk_windowing_gc_set_clip_region (GdkGC           *gc,
+					const cairo_region_t *region,
+					gboolean reset_origin);
+
+/**
+ * _gdk_windowing_gc_copy:
+ * @dst_gc: a #GdkGC from the GDK backend
+ * @src_gc: a #GdkGC from the GDK backend
+ * 
+ * Copies backend specific state from @src_gc to @dst_gc.
+ * This is called before the generic state is copied, so
+ * the old generic state is still available from @dst_gc
+ **/
+void _gdk_windowing_gc_copy (GdkGC *dst_gc,
+			     GdkGC *src_gc);
+     
+/* Queries the current foreground color of a GdkGC */
+void _gdk_windowing_gc_get_foreground (GdkGC    *gc,
+				       GdkColor *color);
+/* Queries the current background color of a GdkGC */
+void _gdk_windowing_gc_get_background (GdkGC    *gc,
+				       GdkColor *color);
+
 struct GdkAppLaunchContextPrivate
 {
   GdkDisplay *display;
@@ -512,9 +631,9 @@ void _gdk_display_pointer_info_foreach (GdkDisplay                   *display,
 void _gdk_window_invalidate_for_expose (GdkWindow       *window,
 					cairo_region_t       *region);
 
-gboolean _gdk_windowing_set_cairo_surface_size (cairo_surface_t *surface,
-					        int width,
-					        int height);
+void _gdk_windowing_set_cairo_surface_size (cairo_surface_t *surface,
+					    int width,
+					    int height);
 
 cairo_surface_t * _gdk_windowing_create_cairo_surface (GdkDrawable *drawable,
 						       int width,
@@ -582,6 +701,7 @@ void       _gdk_offscreen_window_new                 (GdkWindow     *window,
  * Initialization and exit routines *
  ************************************/
 
+void _gdk_image_exit  (void);
 void _gdk_windowing_exit (void);
 
 G_END_DECLS

gdk/gdkoffscreenwindow.c

@@ -34,6 +34,7 @@
 #include "gdkdrawable.h"
 #include "gdktypes.h"
 #include "gdkscreen.h"
+#include "gdkgc.h"
 #include "gdkcolor.h"
 #include "gdkcursor.h"
 
@@ -140,6 +141,36 @@ is_parent_of (GdkWindow *parent,
   return FALSE;
 }
 
+static GdkGC *
+gdk_offscreen_window_create_gc (GdkDrawable     *drawable,
+				GdkGCValues     *values,
+				GdkGCValuesMask  values_mask)
+{
+  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
+
+  return gdk_gc_new_with_values (offscreen->pixmap, values, values_mask);
+}
+
+static GdkImage*
+gdk_offscreen_window_copy_to_image (GdkDrawable    *drawable,
+				    GdkImage       *image,
+				    gint            src_x,
+				    gint            src_y,
+				    gint            dest_x,
+				    gint            dest_y,
+				    gint            width,
+				    gint            height)
+{
+  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
+
+  return gdk_drawable_copy_to_image (offscreen->pixmap,
+				     image,
+				     src_x,
+				     src_y,
+				     dest_x, dest_y,
+				     width, height);
+}
+
 static cairo_surface_t *
 gdk_offscreen_window_ref_cairo_surface (GdkDrawable *drawable)
 {
@@ -193,6 +224,20 @@ gdk_offscreen_window_get_source_drawable (GdkDrawable  *drawable)
   return _gdk_drawable_get_source_drawable (offscreen->pixmap);
 }
 
+static GdkDrawable *
+gdk_offscreen_window_get_composite_drawable (GdkDrawable *drawable,
+					     gint         x,
+					     gint         y,
+					     gint         width,
+					     gint         height,
+					     gint        *composite_x_offset,
+					     gint        *composite_y_offset)
+{
+  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
+
+  return g_object_ref (offscreen->pixmap);
+}
+
 static GdkScreen*
 gdk_offscreen_window_get_screen (GdkDrawable *drawable)
 {
@@ -209,6 +254,318 @@ gdk_offscreen_window_get_visual (GdkDrawable    *drawable)
   return gdk_drawable_get_visual (offscreen->wrapper);
 }
 
+static void
+add_damage (GdkOffscreenWindow *offscreen,
+	    int x, int y,
+	    int w, int h,
+	    gboolean is_line)
+{
+  GdkRectangle rect;
+  cairo_region_t *damage;
+
+  rect.x = x;
+  rect.y = y;
+  rect.width = w;
+  rect.height = h;
+
+  if (is_line)
+    {
+      /* This should really take into account line width, line
+       * joins (and miter) and line caps. But these are hard
+       * to compute, rarely used and generally a pain. And in
+       * the end a snug damage rectangle is not that important
+       * as multiple damages are generally created anyway.
+       *
+       * So, we just add some padding around the rect.
+       * We use a padding of 3 pixels, plus an extra row
+       * below and on the right for the normal line size. I.E.
+       * line from (0,0) to (2,0) gets h=0 but is really
+       * at least one pixel tall.
+       */
+      rect.x -= 3;
+      rect.y -= 3;
+      rect.width += 7;
+      rect.height += 7;
+    }
+
+  damage = cairo_region_create_rectangle (&rect);
+  _gdk_window_add_damage (offscreen->wrapper, damage);
+  cairo_region_destroy (damage);
+}
+
+static GdkDrawable *
+get_real_drawable (GdkOffscreenWindow *offscreen)
+{
+  GdkPixmapObject *pixmap;
+  pixmap = (GdkPixmapObject *) offscreen->pixmap;
+  return GDK_DRAWABLE (pixmap->impl);
+}
+
+static void
+gdk_offscreen_window_draw_drawable (GdkDrawable *drawable,
+				    GdkGC       *gc,
+				    GdkPixmap   *src,
+				    gint         xsrc,
+				    gint         ysrc,
+				    gint         xdest,
+				    gint         ydest,
+				    gint         width,
+				    gint         height,
+				    GdkDrawable *original_src)
+{
+  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
+  GdkDrawable *real_drawable = get_real_drawable (offscreen);
+
+  gdk_draw_drawable (real_drawable, gc,
+		     src, xsrc, ysrc,
+		     xdest, ydest,
+		     width, height);
+
+  add_damage (offscreen, xdest, ydest, width, height, FALSE);
+}
+
+static void
+gdk_offscreen_window_draw_rectangle (GdkDrawable  *drawable,
+				     GdkGC	  *gc,
+				     gboolean	   filled,
+				     gint	   x,
+				     gint	   y,
+				     gint	   width,
+				     gint	   height)
+{
+  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
+  GdkDrawable *real_drawable = get_real_drawable (offscreen);
+
+  gdk_draw_rectangle (real_drawable,
+		      gc, filled, x, y, width, height);
+
+  add_damage (offscreen, x, y, width, height, !filled);
+
+}
+
+static void
+gdk_offscreen_window_draw_arc (GdkDrawable  *drawable,
+			       GdkGC	       *gc,
+			       gboolean	filled,
+			       gint		x,
+			       gint		y,
+			       gint		width,
+			       gint		height,
+			       gint		angle1,
+			       gint		angle2)
+{
+  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
+  GdkDrawable *real_drawable = get_real_drawable (offscreen);
+
+  gdk_draw_arc (real_drawable,
+		gc,
+		filled,
+		x,
+		y,
+		width,
+		height,
+		angle1,
+		angle2);
+  add_damage (offscreen, x, y, width, height, !filled);
+}
+
+static void
+gdk_offscreen_window_draw_polygon (GdkDrawable  *drawable,
+				   GdkGC	       *gc,
+				   gboolean	filled,
+				   GdkPoint     *points,
+				   gint		npoints)
+{
+  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
+  GdkDrawable *real_drawable = get_real_drawable (offscreen);
+
+  gdk_draw_polygon (real_drawable,
+		    gc,
+		    filled,
+		    points,
+		    npoints);
+
+  if (npoints > 0)
+    {
+      int min_x, min_y, max_x, max_y, i;
+
+      min_x = max_x = points[0].x;
+      min_y = max_y = points[0].y;
+
+	for (i = 1; i < npoints; i++)
+	  {
+	    min_x = MIN (min_x, points[i].x);
+	    max_x = MAX (max_x, points[i].x);
+	    min_y = MIN (min_y, points[i].y);
+	    max_y = MAX (max_y, points[i].y);
+	  }
+
+	add_damage (offscreen, min_x, min_y,
+		    max_x - min_x,
+		    max_y - min_y, !filled);
+    }
+}
+
+static void
+gdk_offscreen_window_draw_points (GdkDrawable  *drawable,
+				  GdkGC	       *gc,
+				  GdkPoint     *points,
+				  gint		npoints)
+{
+  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
+  GdkDrawable *real_drawable = get_real_drawable (offscreen);
+
+  gdk_draw_points (real_drawable,
+		   gc,
+		   points,
+		   npoints);
+
+
+  if (npoints > 0)
+    {
+      int min_x, min_y, max_x, max_y, i;
+
+      min_x = max_x = points[0].x;
+      min_y = max_y = points[0].y;
+
+	for (i = 1; i < npoints; i++)
+	  {
+	    min_x = MIN (min_x, points[i].x);
+	    max_x = MAX (max_x, points[i].x);
+	    min_y = MIN (min_y, points[i].y);
+	    max_y = MAX (max_y, points[i].y);
+	  }
+
+	add_damage (offscreen, min_x, min_y,
+		    max_x - min_x + 1,
+		    max_y - min_y + 1,
+		    FALSE);
+    }
+}
+
+static void
+gdk_offscreen_window_draw_segments (GdkDrawable  *drawable,
+				    GdkGC	 *gc,
+				    GdkSegment   *segs,
+				    gint	  nsegs)
+{
+  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
+  GdkDrawable *real_drawable = get_real_drawable (offscreen);
+
+  gdk_draw_segments (real_drawable,
+		     gc,
+		     segs,
+		     nsegs);
+
+  if (nsegs > 0)
+    {
+      int min_x, min_y, max_x, max_y, i;
+
+      min_x = max_x = segs[0].x1;
+      min_y = max_y = segs[0].y1;
+
+	for (i = 0; i < nsegs; i++)
+	  {
+	    min_x = MIN (min_x, segs[i].x1);
+	    max_x = MAX (max_x, segs[i].x1);
+	    min_x = MIN (min_x, segs[i].x2);
+	    max_x = MAX (max_x, segs[i].x2);
+	    min_y = MIN (min_y, segs[i].y1);
+	    max_y = MAX (max_y, segs[i].y1);
+	    min_y = MIN (min_y, segs[i].y2);
+	    max_y = MAX (max_y, segs[i].y2);
+	  }
+
+	add_damage (offscreen, min_x, min_y,
+		    max_x - min_x,
+		    max_y - min_y, TRUE);
+    }
+
+}
+
+static void
+gdk_offscreen_window_draw_lines (GdkDrawable  *drawable,
+				 GdkGC        *gc,
+				 GdkPoint     *points,
+				 gint          npoints)
+{
+  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
+  GdkDrawable *real_drawable = get_real_drawable (offscreen);
+  GdkWindowObject *private = GDK_WINDOW_OBJECT (offscreen->wrapper);
+
+  gdk_draw_lines (real_drawable,
+		  gc,
+		  points,
+		  npoints);
+
+  /* Hard to compute the minimal size, as we don't know the line
+     width, and since joins are hard to calculate.
+     Its not that often used anyway, damage it all */
+  add_damage (offscreen, 0, 0, private->width, private->height, TRUE);
+}
+
+static void
+gdk_offscreen_window_draw_image (GdkDrawable *drawable,
+				 GdkGC	      *gc,
+				 GdkImage    *image,
+				 gint	       xsrc,
+				 gint	       ysrc,
+				 gint	       xdest,
+				 gint	       ydest,
+				 gint	       width,
+				 gint	       height)
+{
+  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
+  GdkDrawable *real_drawable = get_real_drawable (offscreen);
+
+  gdk_draw_image (real_drawable,
+		  gc,
+		  image,
+		  xsrc,
+		  ysrc,
+		  xdest,
+		  ydest,
+		  width,
+		  height);
+
+  add_damage (offscreen, xdest, ydest, width, height, FALSE);
+}
+
+
+static void
+gdk_offscreen_window_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)
+{
+  GdkOffscreenWindow *offscreen = GDK_OFFSCREEN_WINDOW (drawable);
+  GdkDrawable *real_drawable = get_real_drawable (offscreen);
+
+  gdk_draw_pixbuf (real_drawable,
+		   gc,
+		   pixbuf,
+		   src_x,
+		   src_y,
+		   dest_x,
+		   dest_y,
+		   width,
+		   height,
+		   dither,
+		   x_dither,
+		   y_dither);
+
+  add_damage (offscreen, dest_x, dest_y, width, height, FALSE);
+
+}
+
 void
 _gdk_offscreen_window_new (GdkWindow     *window,
 			   GdkScreen     *screen,
@@ -492,6 +849,7 @@ gdk_offscreen_window_move_resize_internal (GdkWindow *window,
   GdkWindowObject *private = (GdkWindowObject *)window;
   GdkOffscreenWindow *offscreen;
   gint dx, dy, dw, dh;
+  GdkGC *gc;
   GdkPixmap *old_pixmap;
 
   offscreen = GDK_OFFSCREEN_WINDOW (private->impl);
@@ -515,8 +873,6 @@ gdk_offscreen_window_move_resize_internal (GdkWindow *window,
   if (private->width != width ||
       private->height != height)
     {
-      cairo_t *cr;
-
       private->width = width;
       private->height = height;
 
@@ -526,10 +882,13 @@ gdk_offscreen_window_move_resize_internal (GdkWindow *window,
 					  height,
 					  private->depth);
 
-      cr = gdk_cairo_create (offscreen->pixmap);
-      gdk_cairo_set_source_pixmap (cr, old_pixmap, 0, 0);
-      cairo_paint (cr);
-      cairo_destroy (cr);
+      gc = _gdk_drawable_get_scratch_gc (offscreen->pixmap, FALSE);
+      gdk_draw_drawable (offscreen->pixmap,
+			 gc,
+			 old_pixmap,
+			 0,0, 0, 0,
+			 -1, -1);
+      g_object_unref (old_pixmap);
     }
 
   if (GDK_WINDOW_IS_MAPPED (private))
@@ -637,8 +996,10 @@ gdk_offscreen_window_set_background (GdkWindow      *window,
 				     const GdkColor *color)
 {
   GdkWindowObject *private = (GdkWindowObject *)window;
+  GdkColormap *colormap = gdk_drawable_get_colormap (window);
 
   private->bg_color = *color;
+  gdk_colormap_query_color (colormap, private->bg_color.pixel, &private->bg_color);
 
   if (private->bg_pixmap &&
       private->bg_pixmap != GDK_PARENT_RELATIVE_BG &&
@@ -734,38 +1095,12 @@ gdk_offscreen_window_queue_antiexpose (GdkWindow *window,
 }
 
 static void
-gdk_offscreen_window_translate (GdkWindow      *window,
-                                cairo_region_t *area,
-                                gint            dx,
-                                gint            dy)
+gdk_offscreen_window_queue_translation (GdkWindow *window,
+					GdkGC     *gc,
+					cairo_region_t *area,
+					gint       dx,
+					gint       dy)
 {
-  cairo_surface_t *surface;
-  cairo_t *cr;
-
-  /* Can't use gdk_cairo_create here due to clipping */
-  surface = _gdk_drawable_ref_cairo_surface (window);
-  cr = cairo_create (surface);
-  cairo_surface_destroy (surface);
-
-  area = cairo_region_copy (area);
-
-  gdk_cairo_region (cr, area);
-  cairo_clip (cr);
-  
-  /* NB: This is a self-copy and Cairo doesn't support that yet.
-   * So we do a litle trick.
-   */
-  cairo_push_group (cr);
-
-  gdk_cairo_set_source_pixmap (cr, window, dx, dy);
-  cairo_paint (cr);
-
-  cairo_pop_group_to_source (cr);
-  cairo_paint (cr);
-
-  cairo_destroy (cr);
-
-  _gdk_window_add_damage (window, area);
 }
 
 /**
@@ -846,6 +1181,8 @@ gdk_offscreen_window_class_init (GdkOffscreenWindowClass *klass)
 
   object_class->finalize = gdk_offscreen_window_finalize;
 
+  drawable_class->create_gc = gdk_offscreen_window_create_gc;
+  drawable_class->_copy_to_image = gdk_offscreen_window_copy_to_image;
   drawable_class->ref_cairo_surface = gdk_offscreen_window_ref_cairo_surface;
   drawable_class->set_colormap = gdk_offscreen_window_set_colormap;
   drawable_class->get_colormap = gdk_offscreen_window_get_colormap;
@@ -853,6 +1190,17 @@ gdk_offscreen_window_class_init (GdkOffscreenWindowClass *klass)
   drawable_class->get_screen = gdk_offscreen_window_get_screen;
   drawable_class->get_visual = gdk_offscreen_window_get_visual;
   drawable_class->get_source_drawable = gdk_offscreen_window_get_source_drawable;
+  drawable_class->get_composite_drawable = gdk_offscreen_window_get_composite_drawable;
+
+  drawable_class->draw_rectangle = gdk_offscreen_window_draw_rectangle;
+  drawable_class->draw_arc = gdk_offscreen_window_draw_arc;
+  drawable_class->draw_polygon = gdk_offscreen_window_draw_polygon;
+  drawable_class->draw_drawable_with_src = gdk_offscreen_window_draw_drawable;
+  drawable_class->draw_points = gdk_offscreen_window_draw_points;
+  drawable_class->draw_segments = gdk_offscreen_window_draw_segments;
+  drawable_class->draw_lines = gdk_offscreen_window_draw_lines;
+  drawable_class->draw_image = gdk_offscreen_window_draw_image;
+  drawable_class->draw_pixbuf = gdk_offscreen_window_draw_pixbuf;
 }
 
 static void
@@ -874,7 +1222,7 @@ gdk_offscreen_window_impl_iface_init (GdkWindowImplIface *iface)
   iface->input_shape_combine_region = gdk_offscreen_window_input_shape_combine_region;
   iface->set_static_gravities = gdk_offscreen_window_set_static_gravities;
   iface->queue_antiexpose = gdk_offscreen_window_queue_antiexpose;
-  iface->translate = gdk_offscreen_window_translate;
+  iface->queue_translation = gdk_offscreen_window_queue_translation;
   iface->get_root_coords = gdk_offscreen_window_get_root_coords;
   iface->get_deskrelative_origin = gdk_offscreen_window_get_deskrelative_origin;
   iface->get_device_state = gdk_offscreen_window_get_device_state;

gdk/gdkpango.h

@@ -28,6 +28,80 @@
 
 G_BEGIN_DECLS
 
+/* Pango interaction */
+
+typedef struct _GdkPangoRenderer        GdkPangoRenderer;
+typedef struct _GdkPangoRendererClass   GdkPangoRendererClass;
+typedef struct _GdkPangoRendererPrivate GdkPangoRendererPrivate;
+
+#define GDK_TYPE_PANGO_RENDERER            (gdk_pango_renderer_get_type())
+#define GDK_PANGO_RENDERER(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), GDK_TYPE_PANGO_RENDERER, GdkPangoRenderer))
+#define GDK_IS_PANGO_RENDERER(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), GDK_TYPE_PANGO_RENDERER))
+#define GDK_PANGO_RENDERER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), GDK_TYPE_PANGO_RENDERER, GdkPangoRendererClass))
+#define GDK_IS_PANGO_RENDERER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PANGO_RENDERER))
+#define GDK_PANGO_RENDERER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), GDK_TYPE_PANGO_RENDERER, GdkPangoRendererClass))
+
+/**
+ * GdkPangoRenderer:
+ *
+ * #GdkPangoRenderer is a subclass of #PangoRenderer used for rendering
+ * Pango objects into GDK drawables. The default renderer for a particular
+ * screen is obtained with gdk_pango_renderer_get_default(); Pango
+ * functions like pango_renderer_draw_layout() and
+ * pango_renderer_draw_layout_line() are then used to draw objects with
+ * the renderer.
+ *
+ * In most simple cases, applications can just use gdk_draw_layout(), and
+ * don't need to directly use #GdkPangoRenderer at all. Using the
+ * #GdkPangoRenderer directly is most useful when working with a
+ * transformation such as a rotation, because the Pango drawing functions
+ * take user space coordinates (coordinates before the transformation)
+ * instead of device coordinates.
+ *
+ * In certain cases it can be useful to subclass #GdkPangoRenderer. Examples
+ * of reasons to do this are to add handling of custom attributes by
+ * overriding 'prepare_run' or to do custom drawing of embedded objects
+ * by overriding 'draw_shape'.
+ *
+ * Since: 2.6
+ **/
+struct _GdkPangoRenderer
+{
+  /*< private >*/
+  PangoRenderer parent_instance;
+
+  GdkPangoRendererPrivate *priv;
+};
+
+/**
+ * GdkPangoRendererClass:
+ *
+ * #GdkPangoRenderer is the class structure for #GdkPangoRenderer.
+ *
+ * Since: 2.6
+ **/
+struct _GdkPangoRendererClass
+{
+  /*< private >*/
+  PangoRendererClass parent_class;
+};
+
+GType gdk_pango_renderer_get_type (void) G_GNUC_CONST;
+
+PangoRenderer *gdk_pango_renderer_new         (GdkScreen *screen);
+PangoRenderer *gdk_pango_renderer_get_default (GdkScreen *screen);
+
+void gdk_pango_renderer_set_drawable       (GdkPangoRenderer *gdk_renderer,
+					    GdkDrawable      *drawable);
+void gdk_pango_renderer_set_gc             (GdkPangoRenderer *gdk_renderer,
+					    GdkGC            *gc);
+void gdk_pango_renderer_set_stipple        (GdkPangoRenderer *gdk_renderer,
+					    PangoRenderPart   part,
+					    GdkBitmap        *stipple);
+void gdk_pango_renderer_set_override_color (GdkPangoRenderer *gdk_renderer,
+					    PangoRenderPart   part,
+					    const GdkColor   *color);
+
 /************************************************************************/
 
 PangoContext *gdk_pango_context_get_for_screen (GdkScreen    *screen);
@@ -53,6 +127,36 @@ cairo_region_t    *gdk_pango_layout_get_clip_region      (PangoLayout     *layou
                                                      const gint      *index_ranges,
                                                      gint             n_ranges);
 
+
+
+/* Attributes use to render insensitive text in GTK+. */
+
+typedef struct _GdkPangoAttrStipple GdkPangoAttrStipple;
+typedef struct _GdkPangoAttrEmbossed GdkPangoAttrEmbossed;
+typedef struct _GdkPangoAttrEmbossColor GdkPangoAttrEmbossColor;
+
+struct _GdkPangoAttrStipple
+{
+  PangoAttribute attr;
+  GdkBitmap *stipple;
+};
+
+struct _GdkPangoAttrEmbossed
+{
+  PangoAttribute attr;
+  gboolean embossed;
+};
+
+struct _GdkPangoAttrEmbossColor
+{
+  PangoAttribute attr;
+  PangoColor color;
+};
+
+PangoAttribute *gdk_pango_attr_stipple_new  (GdkBitmap *stipple);
+PangoAttribute *gdk_pango_attr_embossed_new (gboolean embossed);
+PangoAttribute *gdk_pango_attr_emboss_color_new (const GdkColor *color);
+
 G_END_DECLS
 
 #endif /* __GDK_PANGO_H__ */

gdk/gdkpixbuf-render.c

@@ -57,7 +57,8 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf,
                                    int        height,
                                    int        alpha_threshold)
 {
-  cairo_t *cr;
+  GdkGC *gc;
+  GdkColor color;
   int x, y;
   guchar *p;
   int start, start_status;
@@ -83,31 +84,22 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf,
   if (width == 0 || height == 0)
     return;
 
-  cr = gdk_cairo_create (bitmap);
-  cairo_rectangle (cr, dest_x, dest_y, width, height);
-  cairo_clip (cr);
+  gc = _gdk_drawable_get_scratch_gc (bitmap, FALSE);
 
   if (!gdk_pixbuf_get_has_alpha (pixbuf))
     {
-      cairo_set_source_rgba (cr, 0, 0, 0, alpha_threshold == 255 ? 0 : 1);
-      cairo_paint (cr);
-      cairo_destroy (cr);
+      color.pixel = (alpha_threshold == 255) ? 0 : 1;
+      gdk_gc_set_foreground (gc, &color);
+      gdk_draw_rectangle (bitmap, gc, TRUE, dest_x, dest_y, width, height);
       return;
     }
 
-  cairo_set_operator (cr, CAIRO_OPERATOR_CLEAR);
-  cairo_paint (cr);
+  color.pixel = 0;
+  gdk_gc_set_foreground (gc, &color);
+  gdk_draw_rectangle (bitmap, gc, TRUE, dest_x, dest_y, width, height);
 
-  cairo_set_operator (cr, CAIRO_OPERATOR_SOURCE);
-  if (alpha_threshold == 128)
-    {
-      gdk_cairo_set_source_pixbuf (cr, pixbuf, src_x - dest_x, src_y - dest_y);
-      cairo_paint (cr);
-      cairo_destroy (cr);
-      return;
-    }
-
-  cairo_set_source_rgb (cr, 0, 0, 0);
+  color.pixel = 1;
+  gdk_gc_set_foreground (gc, &color);
 
   for (y = 0; y < height; y++)
     {
@@ -124,9 +116,9 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf,
 	  if (status != start_status)
 	    {
 	      if (!start_status)
-                cairo_rectangle (cr, 
-                                 start + dest_x, y + dest_y,
-			         x + dest_x, y + dest_y + 1);
+		gdk_draw_line (bitmap, gc,
+			       start + dest_x, y + dest_y,
+			       x - 1 + dest_x, y + dest_y);
 	      
 	      start = x;
 	      start_status = status;
@@ -136,13 +128,10 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf,
 	}
       
       if (!start_status)
-        cairo_rectangle (cr, 
-                         start + dest_x, y + dest_y,
-                         x + dest_x, y + dest_y + 1);
+	gdk_draw_line (bitmap, gc,
+		       start + dest_x, y + dest_y,
+		       x - 1 + dest_x, y + dest_y);
     }
-
-  cairo_fill (cr);
-  cairo_destroy (cr);
 }
 
 /**
@@ -158,10 +147,10 @@ gdk_pixbuf_render_threshold_alpha (GdkPixbuf *pixbuf,
  * and @mask_return arguments, respectively, and renders a pixbuf and its
  * corresponding thresholded alpha mask to them.  This is merely a convenience
  * function; applications that need to render pixbufs with dither offsets or to
- * given drawables should use Cairo and gdk_pixbuf_render_threshold_alpha().
+ * given drawables should use gdk_draw_pixbuf() and gdk_pixbuf_render_threshold_alpha().
  *
  * The pixmap that is created is created for the colormap returned
- * by gdk_colormap_get_system(). You normally will want to instead use
+ * by gdk_rgb_get_colormap(). You normally will want to instead use
  * the actual colormap for a widget, and use
  * gdk_pixbuf_render_pixmap_and_mask_for_colormap().
  *
@@ -175,42 +164,11 @@ gdk_pixbuf_render_pixmap_and_mask (GdkPixbuf  *pixbuf,
 				   int         alpha_threshold)
 {
   gdk_pixbuf_render_pixmap_and_mask_for_colormap (pixbuf,
-						  gdk_colormap_get_system (),
+						  gdk_rgb_get_colormap (),
 						  pixmap_return, mask_return,
 						  alpha_threshold);
 }
 
-static GdkPixbuf *
-remove_alpha_channel (GdkPixbuf *orig)
-{
-  GdkPixbuf *pixbuf;
-
-  unsigned int x, y, width, height, stride;
-  unsigned char *data;
-
-  if (!gdk_pixbuf_get_has_alpha (orig))
-    return g_object_ref (orig);
-
-  pixbuf = gdk_pixbuf_copy (orig);
-
-  width = gdk_pixbuf_get_width (pixbuf);
-  height = gdk_pixbuf_get_height (pixbuf);
-  stride = gdk_pixbuf_get_rowstride (pixbuf);
-  data = gdk_pixbuf_get_pixels (pixbuf);
-
-  for (y = 0; y < height; y++)
-    {
-      for (x = 0; x < width; x++)
-        {
-          data[x * 4 + 3] = 0xFF;
-        }
-
-      data += stride;
-    }
-
-  return pixbuf;
-}
-
 /**
  * gdk_pixbuf_render_pixmap_and_mask_for_colormap:
  * @pixbuf: A pixbuf.
@@ -225,7 +183,7 @@ remove_alpha_channel (GdkPixbuf *orig)
  * and @mask_return arguments, respectively, and renders a pixbuf and its
  * corresponding tresholded alpha mask to them.  This is merely a convenience
  * function; applications that need to render pixbufs with dither offsets or to
- * given drawables should use Cairo and gdk_pixbuf_render_threshold_alpha().
+ * given drawables should use gdk_draw_pixbuf(), and gdk_pixbuf_render_threshold_alpha().
  *
  * The pixmap that is created uses the #GdkColormap specified by @colormap.
  * This colormap must match the colormap of the window where the pixmap
@@ -250,29 +208,31 @@ gdk_pixbuf_render_pixmap_and_mask_for_colormap (GdkPixbuf   *pixbuf,
   
   if (pixmap_return)
     {
-      GdkPixbuf *tmp_pixbuf;
-      cairo_t *cr;
-
+      GdkGC *gc;
       *pixmap_return = gdk_pixmap_new (gdk_screen_get_root_window (screen),
 				       gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf),
 				       gdk_colormap_get_visual (colormap)->depth);
 
       gdk_drawable_set_colormap (GDK_DRAWABLE (*pixmap_return), colormap);
+      gc = _gdk_drawable_get_scratch_gc (*pixmap_return, FALSE);
 
-      /* If the pixbuf has an alpha channel, using gdk_cairo_set_source_pixbuf()
-       * would give
+      /* If the pixbuf has an alpha channel, using gdk_pixbuf_draw would give
        * random pixel values in the area that are within the mask, but semi-
        * transparent. So we treat the pixbuf like a pixbuf without alpha channel;
        * see bug #487865.
        */
-      tmp_pixbuf = remove_alpha_channel (pixbuf);
-
-      cr = gdk_cairo_create (*pixmap_return);
-      gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
-      cairo_paint (cr);
-
-      cairo_destroy (cr);
-      g_object_unref (tmp_pixbuf);
+      if (gdk_pixbuf_get_has_alpha (pixbuf))
+        gdk_draw_rgb_32_image (*pixmap_return, gc,
+                               0, 0,
+                               gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf),
+                               GDK_RGB_DITHER_NORMAL,
+                               gdk_pixbuf_get_pixels (pixbuf), gdk_pixbuf_get_rowstride (pixbuf));
+      else
+        gdk_draw_pixbuf (*pixmap_return, gc, pixbuf, 
+                         0, 0, 0, 0,
+                         gdk_pixbuf_get_width (pixbuf), gdk_pixbuf_get_height (pixbuf),
+                         GDK_RGB_DITHER_NORMAL,
+                         0, 0);
     }
   
   if (mask_return)

gdk/gdkpixbuf.h

@@ -33,6 +33,7 @@
 
 #include <cairo.h>
 #include <gdk/gdktypes.h>
+#include <gdk/gdkrgb.h>
 #include <gdk-pixbuf/gdk-pixbuf.h>
 
 G_BEGIN_DECLS
@@ -72,14 +73,15 @@ GdkPixbuf *gdk_pixbuf_get_from_drawable (GdkPixbuf   *dest,
 					 int          width,
 					 int          height);
 
-GdkPixbuf *gdk_pixbuf_get_from_surface  (GdkPixbuf       *dest,
-                                         cairo_surface_t *surface,
-					 int              src_x,
-					 int              src_y,
-					 int              dest_x,
-					 int              dest_y,
-					 int              width,
-					 int              height);
+GdkPixbuf *gdk_pixbuf_get_from_image    (GdkPixbuf   *dest,
+                                         GdkImage    *src,
+                                         GdkColormap *cmap,
+                                         int          src_x,
+                                         int          src_y,
+                                         int          dest_x,
+                                         int          dest_y,
+                                         int          width,
+                                         int          height);
 
 G_END_DECLS
 

gdk/gdkpixmap.c

@@ -31,10 +31,106 @@
 #include "gdkscreen.h"
 
 
+static GdkGC *gdk_pixmap_create_gc      (GdkDrawable     *drawable,
+                                         GdkGCValues     *values,
+                                         GdkGCValuesMask  mask);
+static void   gdk_pixmap_draw_rectangle (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 gboolean         filled,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height);
+static void   gdk_pixmap_draw_arc       (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 gboolean         filled,
+					 gint             x,
+					 gint             y,
+					 gint             width,
+					 gint             height,
+					 gint             angle1,
+					 gint             angle2);
+static void   gdk_pixmap_draw_polygon   (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 gboolean         filled,
+					 GdkPoint        *points,
+					 gint             npoints);
+static void   gdk_pixmap_draw_drawable  (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 GdkPixmap       *src,
+					 gint             xsrc,
+					 gint             ysrc,
+					 gint             xdest,
+					 gint             ydest,
+					 gint             width,
+					 gint             height,
+					 GdkPixmap       *original_src);
+static void   gdk_pixmap_draw_points    (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 GdkPoint        *points,
+					 gint             npoints);
+static void   gdk_pixmap_draw_segments  (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 GdkSegment      *segs,
+					 gint             nsegs);
+static void   gdk_pixmap_draw_lines     (GdkDrawable     *drawable,
+					 GdkGC           *gc,
+					 GdkPoint        *points,
+					 gint             npoints);
+
+static void gdk_pixmap_draw_glyphs             (GdkDrawable      *drawable,
+						GdkGC            *gc,
+						PangoFont        *font,
+						gint              x,
+						gint              y,
+						PangoGlyphString *glyphs);
+static void gdk_pixmap_draw_glyphs_transformed (GdkDrawable      *drawable,
+						GdkGC            *gc,
+						PangoMatrix      *matrix,
+						PangoFont        *font,
+						gint              x,
+						gint              y,
+						PangoGlyphString *glyphs);
+
+static void   gdk_pixmap_draw_image     (GdkDrawable     *drawable,
+                                         GdkGC           *gc,
+                                         GdkImage        *image,
+                                         gint             xsrc,
+                                         gint             ysrc,
+                                         gint             xdest,
+                                         gint             ydest,
+                                         gint             width,
+                                         gint             height);
+static void   gdk_pixmap_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_pixmap_draw_trapezoids (GdkDrawable     *drawable,
+					 GdkGC	         *gc,
+					 GdkTrapezoid    *trapezoids,
+					 gint             n_trapezoids);
+
 static void   gdk_pixmap_real_get_size  (GdkDrawable     *drawable,
                                          gint            *width,
                                          gint            *height);
 
+static GdkImage* gdk_pixmap_copy_to_image (GdkDrawable *drawable,
+					   GdkImage    *image,
+					   gint         src_x,
+					   gint         src_y,
+					   gint         dest_x,
+					   gint         dest_y,
+					   gint         width,
+					   gint         height);
+
 static cairo_surface_t *gdk_pixmap_ref_cairo_surface (GdkDrawable *drawable);
 static cairo_surface_t *gdk_pixmap_create_cairo_surface (GdkDrawable *drawable,
 							 int width,
@@ -87,12 +183,26 @@ gdk_pixmap_class_init (GdkPixmapObjectClass *klass)
 
   object_class->finalize = gdk_pixmap_finalize;
 
+  drawable_class->create_gc = gdk_pixmap_create_gc;
+  drawable_class->draw_rectangle = gdk_pixmap_draw_rectangle;
+  drawable_class->draw_arc = gdk_pixmap_draw_arc;
+  drawable_class->draw_polygon = gdk_pixmap_draw_polygon;
+  drawable_class->draw_drawable_with_src = gdk_pixmap_draw_drawable;
+  drawable_class->draw_points = gdk_pixmap_draw_points;
+  drawable_class->draw_segments = gdk_pixmap_draw_segments;
+  drawable_class->draw_lines = gdk_pixmap_draw_lines;
+  drawable_class->draw_glyphs = gdk_pixmap_draw_glyphs;
+  drawable_class->draw_glyphs_transformed = gdk_pixmap_draw_glyphs_transformed;
+  drawable_class->draw_image = gdk_pixmap_draw_image;
+  drawable_class->draw_pixbuf = gdk_pixmap_draw_pixbuf;
+  drawable_class->draw_trapezoids = gdk_pixmap_draw_trapezoids;
   drawable_class->get_depth = gdk_pixmap_real_get_depth;
   drawable_class->get_screen = gdk_pixmap_real_get_screen;
   drawable_class->get_size = gdk_pixmap_real_get_size;
   drawable_class->set_colormap = gdk_pixmap_real_set_colormap;
   drawable_class->get_colormap = gdk_pixmap_real_get_colormap;
   drawable_class->get_visual = gdk_pixmap_real_get_visual;
+  drawable_class->_copy_to_image = gdk_pixmap_copy_to_image;
   drawable_class->ref_cairo_surface = gdk_pixmap_ref_cairo_surface;
   drawable_class->create_cairo_surface = gdk_pixmap_create_cairo_surface;
 }
@@ -123,6 +233,238 @@ gdk_pixmap_new (GdkDrawable *drawable,
   return _gdk_pixmap_new (source_drawable, width, height, depth);
 }
 
+GdkPixmap *
+gdk_bitmap_create_from_data (GdkDrawable *drawable,
+                             const gchar *data,
+                             gint         width,
+                             gint         height)
+{
+  GdkDrawable *source_drawable;
+
+  if (drawable)
+    source_drawable = _gdk_drawable_get_source_drawable (drawable);
+  else
+    source_drawable = NULL;
+  return _gdk_bitmap_create_from_data (source_drawable, data, width, height);
+}
+
+GdkPixmap*
+gdk_pixmap_create_from_data (GdkDrawable    *drawable,
+                             const gchar    *data,
+                             gint            width,
+                             gint            height,
+                             gint            depth,
+                             const GdkColor *fg,
+                             const GdkColor *bg)
+{
+  GdkDrawable *source_drawable;
+
+  source_drawable = _gdk_drawable_get_source_drawable (drawable);
+  return _gdk_pixmap_create_from_data (source_drawable,
+                                       data, width, height,
+                                       depth, fg,bg);
+}
+
+
+static GdkGC *
+gdk_pixmap_create_gc (GdkDrawable     *drawable,
+                      GdkGCValues     *values,
+                      GdkGCValuesMask  mask)
+{
+  return gdk_gc_new_with_values (((GdkPixmapObject *) drawable)->impl,
+                                 values, mask);
+}
+
+static void
+gdk_pixmap_draw_rectangle (GdkDrawable *drawable,
+			   GdkGC       *gc,
+			   gboolean     filled,
+			   gint         x,
+			   gint         y,
+			   gint         width,
+			   gint         height)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  _gdk_gc_remove_drawable_clip (gc);  
+  gdk_draw_rectangle (private->impl, gc, filled,
+                      x, y, width, height);
+}
+
+static void
+gdk_pixmap_draw_arc (GdkDrawable *drawable,
+		     GdkGC       *gc,
+		     gboolean     filled,
+		     gint         x,
+		     gint         y,
+		     gint         width,
+		     gint         height,
+		     gint         angle1,
+		     gint         angle2)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  _gdk_gc_remove_drawable_clip (gc);  
+  gdk_draw_arc (private->impl, gc, filled,
+                x, y,
+                width, height, angle1, angle2);
+}
+
+static void
+gdk_pixmap_draw_polygon (GdkDrawable *drawable,
+			 GdkGC       *gc,
+			 gboolean     filled,
+			 GdkPoint    *points,
+			 gint         npoints)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  _gdk_gc_remove_drawable_clip (gc);  
+  gdk_draw_polygon (private->impl, gc, filled, points, npoints);
+}
+
+static void
+gdk_pixmap_draw_drawable (GdkDrawable *drawable,
+			  GdkGC       *gc,
+			  GdkPixmap   *src,
+			  gint         xsrc,
+			  gint         ysrc,
+			  gint         xdest,
+			  gint         ydest,
+			  gint         width,
+			  gint         height,
+			  GdkPixmap   *original_src)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  _gdk_gc_remove_drawable_clip (gc);
+  /* Call the method directly to avoid getting the composite drawable again */
+  GDK_DRAWABLE_GET_CLASS (private->impl)->draw_drawable_with_src (private->impl, gc,
+								  src,
+								  xsrc, ysrc,
+								  xdest, ydest,
+								  width, height,
+								  original_src);
+}
+
+static void
+gdk_pixmap_draw_points (GdkDrawable *drawable,
+			GdkGC       *gc,
+			GdkPoint    *points,
+			gint         npoints)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  _gdk_gc_remove_drawable_clip (gc);  
+  gdk_draw_points (private->impl, gc, points, npoints);
+}
+
+static void
+gdk_pixmap_draw_segments (GdkDrawable *drawable,
+			  GdkGC       *gc,
+			  GdkSegment  *segs,
+			  gint         nsegs)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  _gdk_gc_remove_drawable_clip (gc);  
+  gdk_draw_segments (private->impl, gc, segs, nsegs);
+}
+
+static void
+gdk_pixmap_draw_lines (GdkDrawable *drawable,
+		       GdkGC       *gc,
+		       GdkPoint    *points,
+		       gint         npoints)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  _gdk_gc_remove_drawable_clip (gc);  
+  gdk_draw_lines (private->impl, gc, points, npoints);
+}
+
+static void
+gdk_pixmap_draw_glyphs (GdkDrawable      *drawable,
+                        GdkGC            *gc,
+                        PangoFont        *font,
+                        gint              x,
+                        gint              y,
+                        PangoGlyphString *glyphs)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  _gdk_gc_remove_drawable_clip (gc);  
+  gdk_draw_glyphs (private->impl, gc, font, x, y, glyphs);
+}
+
+static void
+gdk_pixmap_draw_glyphs_transformed (GdkDrawable      *drawable,
+				    GdkGC            *gc,
+				    PangoMatrix      *matrix,
+				    PangoFont        *font,
+				    gint              x,
+				    gint              y,
+				    PangoGlyphString *glyphs)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  _gdk_gc_remove_drawable_clip (gc);  
+  gdk_draw_glyphs_transformed (private->impl, gc, matrix, font, x, y, glyphs);
+}
+
+static void
+gdk_pixmap_draw_image (GdkDrawable     *drawable,
+                       GdkGC           *gc,
+                       GdkImage        *image,
+                       gint             xsrc,
+                       gint             ysrc,
+                       gint             xdest,
+                       gint             ydest,
+                       gint             width,
+                       gint             height)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  _gdk_gc_remove_drawable_clip (gc);  
+  gdk_draw_image (private->impl, gc, image, xsrc, ysrc, xdest, ydest,
+                  width, height);
+}
+
+static void
+gdk_pixmap_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)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  if (gc)
+    _gdk_gc_remove_drawable_clip (gc);  
+  gdk_draw_pixbuf (private->impl, gc, pixbuf,
+		   src_x, src_y, dest_x, dest_y, width, height,
+		   dither, x_dither, y_dither);
+}
+
+static void
+gdk_pixmap_draw_trapezoids (GdkDrawable     *drawable,
+			    GdkGC	    *gc,
+			    GdkTrapezoid    *trapezoids,
+			    gint             n_trapezoids)
+{
+  GdkPixmapObject *private = (GdkPixmapObject *)drawable;
+
+  _gdk_gc_remove_drawable_clip (gc);  
+  gdk_draw_trapezoids (private->impl, gc, trapezoids, n_trapezoids);
+}
+
 static void
 gdk_pixmap_real_get_size (GdkDrawable *drawable,
                           gint *width,
@@ -174,6 +516,24 @@ gdk_pixmap_real_get_colormap (GdkDrawable *drawable)
   return gdk_drawable_get_colormap (((GdkPixmapObject*)drawable)->impl);
 }
 
+static GdkImage*
+gdk_pixmap_copy_to_image (GdkDrawable     *drawable,
+			  GdkImage        *image,
+			  gint             src_x,
+			  gint             src_y,
+			  gint             dest_x,
+			  gint             dest_y,
+			  gint             width,
+			  gint             height)
+{
+  g_return_val_if_fail (GDK_IS_PIXMAP (drawable), NULL);
+  
+  return gdk_drawable_copy_to_image (((GdkPixmapObject*)drawable)->impl,
+				     image,
+				     src_x, src_y, dest_x, dest_y,
+				     width, height);
+}
+
 static cairo_surface_t *
 gdk_pixmap_ref_cairo_surface (GdkDrawable *drawable)
 {
@@ -189,6 +549,226 @@ gdk_pixmap_create_cairo_surface (GdkDrawable *drawable,
 					      width, height);
 }
 
+
+
+static GdkBitmap *
+make_solid_mask (GdkScreen *screen, gint width, gint height)
+{
+  GdkBitmap *bitmap;
+  GdkGC *gc;
+  GdkGCValues gc_values;
+  
+  bitmap = gdk_pixmap_new (gdk_screen_get_root_window (screen),
+			   width, height, 1);
+
+  gc_values.foreground.pixel = 1;
+  gc = gdk_gc_new_with_values (bitmap, &gc_values, GDK_GC_FOREGROUND);
+  
+  gdk_draw_rectangle (bitmap, gc, TRUE, 0, 0, width, height);
+  
+  g_object_unref (gc);
+  
+  return bitmap;
+}
+
+#define PACKED_COLOR(c) ((((c)->red   & 0xff00)  << 8) |   \
+			  ((c)->green & 0xff00)        |   \
+			  ((c)->blue             >> 8))
+
+static GdkPixmap *
+gdk_pixmap_colormap_new_from_pixbuf (GdkColormap    *colormap,
+				     GdkBitmap     **mask,
+				     const GdkColor *transparent_color,
+				     GdkPixbuf      *pixbuf)
+{
+  GdkPixmap *pixmap;
+  GdkPixbuf *render_pixbuf;
+  GdkGC *tmp_gc;
+  GdkScreen *screen = gdk_colormap_get_screen (colormap);
+  
+  pixmap = gdk_pixmap_new (gdk_screen_get_root_window (screen),
+			   gdk_pixbuf_get_width (pixbuf),
+			   gdk_pixbuf_get_height (pixbuf),
+			   gdk_colormap_get_visual (colormap)->depth);
+  gdk_drawable_set_colormap (pixmap, colormap);
+  
+  if (transparent_color)
+    {
+      guint32 packed_color = PACKED_COLOR (transparent_color);
+      render_pixbuf = gdk_pixbuf_composite_color_simple (pixbuf,
+							 gdk_pixbuf_get_width (pixbuf),
+							 gdk_pixbuf_get_height (pixbuf),
+							 GDK_INTERP_NEAREST,
+							 255, 16, packed_color, packed_color);
+    }
+  else
+    render_pixbuf = pixbuf;
+
+  tmp_gc = _gdk_drawable_get_scratch_gc (pixmap, FALSE);
+  gdk_draw_pixbuf (pixmap, tmp_gc, render_pixbuf, 0, 0, 0, 0,
+		   gdk_pixbuf_get_width (render_pixbuf),
+		   gdk_pixbuf_get_height (render_pixbuf),
+		   GDK_RGB_DITHER_NORMAL, 0, 0);
+
+  if (render_pixbuf != pixbuf)
+    g_object_unref (render_pixbuf);
+
+  if (mask)
+    gdk_pixbuf_render_pixmap_and_mask_for_colormap (pixbuf, colormap, NULL, mask, 128);
+
+  if (mask && !*mask)
+    *mask = make_solid_mask (screen,
+			     gdk_pixbuf_get_width (pixbuf),
+			     gdk_pixbuf_get_height (pixbuf));
+
+  return pixmap;
+}
+
+/**
+ * gdk_pixmap_colormap_create_from_xpm:
+ * @drawable: a #GdkDrawable, used to determine default values
+ * for the new pixmap. Can be %NULL if @colormap is given.
+ * @colormap: the #GdkColormap that the new pixmap will be use.
+ * If omitted, the colormap for @window will be used.
+ * @mask: a pointer to a place to store a bitmap representing
+ * the transparency mask of the XPM file. Can be %NULL,
+ * in which case transparency will be ignored.
+ * @transparent_color: the color to be used for the pixels
+ * that are transparent in the input file. Can be %NULL,
+ * in which case a default color will be used.
+ * @filename: the filename of a file containing XPM data.
+ *
+ * Create a pixmap from a XPM file using a particular colormap.
+ *
+ * Returns: (transfer none): the #GdkPixmap.
+ */
+GdkPixmap*
+gdk_pixmap_colormap_create_from_xpm (GdkDrawable    *drawable,
+				     GdkColormap    *colormap,
+				     GdkBitmap     **mask,
+				     const GdkColor *transparent_color,
+				     const gchar    *filename)
+{
+  GdkPixbuf *pixbuf;
+  GdkPixmap *pixmap;
+
+  g_return_val_if_fail (drawable != NULL || colormap != NULL, NULL);
+  g_return_val_if_fail (drawable == NULL || GDK_IS_DRAWABLE (drawable), NULL);
+  g_return_val_if_fail (colormap == NULL || GDK_IS_COLORMAP (colormap), NULL);
+
+  if (colormap == NULL)
+    colormap = gdk_drawable_get_colormap (drawable);
+  
+  pixbuf = gdk_pixbuf_new_from_file (filename, NULL);
+  if (!pixbuf)
+    return NULL;
+
+  pixmap = gdk_pixmap_colormap_new_from_pixbuf (colormap, mask, transparent_color, pixbuf);
+
+  g_object_unref (pixbuf);
+  
+  return pixmap;
+}
+
+/**
+ * gdk_pixmap_create_from_xpm:
+ * @drawable: a #GdkDrawable, used to determine default values
+ * for the new pixmap.
+ * @mask: (out) a pointer to a place to store a bitmap representing
+ * the transparency mask of the XPM file. Can be %NULL,
+ * in which case transparency will be ignored.
+ * @transparent_color: the color to be used for the pixels
+ * that are transparent in the input file. Can be %NULL,
+ * in which case a default color will be used.
+ * @filename: the filename of a file containing XPM data.
+ *
+ * Create a pixmap from a XPM file.
+ *
+ * Returns: (transfer none): the #GdkPixmap
+ */
+GdkPixmap*
+gdk_pixmap_create_from_xpm (GdkDrawable    *drawable,
+			    GdkBitmap     **mask,
+			    const GdkColor *transparent_color,
+			    const gchar    *filename)
+{
+  return gdk_pixmap_colormap_create_from_xpm (drawable, NULL, mask,
+					      transparent_color, filename);
+}
+
+/**
+ * gdk_pixmap_colormap_create_from_xpm_d:
+ * @drawable: a #GdkDrawable, used to determine default values
+ *     for the new pixmap. Can be %NULL if @colormap is given.
+ * @colormap: the #GdkColormap that the new pixmap will be use.
+ *     If omitted, the colormap for @window will be used.
+ * @mask: a pointer to a place to store a bitmap representing
+ *     the transparency mask of the XPM file. Can be %NULL,
+ *     in which case transparency will be ignored.
+ * @transparent_color: the color to be used for the pixels
+ *     that are transparent in the input file. Can be %NULL,
+ *     in which case a default color will be used.
+ * @data: Pointer to a string containing the XPM data.
+ *
+ * Create a pixmap from data in XPM format using a particular
+ * colormap.
+ *
+ * Returns: (transfer none): the #GdkPixmap.
+ */
+GdkPixmap*
+gdk_pixmap_colormap_create_from_xpm_d (GdkDrawable     *drawable,
+				       GdkColormap     *colormap,
+				       GdkBitmap      **mask,
+				       const GdkColor  *transparent_color,
+				       gchar          **data)
+{
+  GdkPixbuf *pixbuf;
+  GdkPixmap *pixmap;
+
+  g_return_val_if_fail (drawable != NULL || colormap != NULL, NULL);
+  g_return_val_if_fail (drawable == NULL || GDK_IS_DRAWABLE (drawable), NULL);
+  g_return_val_if_fail (colormap == NULL || GDK_IS_COLORMAP (colormap), NULL);
+
+  if (colormap == NULL)
+    colormap = gdk_drawable_get_colormap (drawable);
+  
+  pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **)data);
+  if (!pixbuf)
+    return NULL;
+
+  pixmap = gdk_pixmap_colormap_new_from_pixbuf (colormap, mask, transparent_color, pixbuf);
+
+  g_object_unref (pixbuf);
+
+  return pixmap;
+}
+
+/**
+ * gdk_pixmap_create_from_xpm_d:
+ * @drawable: a #GdkDrawable, used to determine default values
+ *     for the new pixmap.
+ * @mask: (out): Pointer to a place to store a bitmap representing
+ *     the transparency mask of the XPM file. Can be %NULL,
+ *     in which case transparency will be ignored.
+ * @transparent_color: This color will be used for the pixels
+ *     that are transparent in the input file. Can be %NULL
+ *     in which case a default color will be used.
+ * @data: Pointer to a string containing the XPM data.
+ *
+ * Create a pixmap from data in XPM format.
+ *
+ * Returns: (transfer none): the #GdkPixmap.
+ */
+GdkPixmap*
+gdk_pixmap_create_from_xpm_d (GdkDrawable    *drawable,
+			      GdkBitmap     **mask,
+			      const GdkColor *transparent_color,
+			      gchar         **data)
+{
+  return gdk_pixmap_colormap_create_from_xpm_d (drawable, NULL, mask,
+						transparent_color, data);
+}
+
 static GdkScreen*
 gdk_pixmap_real_get_screen (GdkDrawable *drawable)
 {

gdk/gdkpixmap.h

@@ -70,6 +70,36 @@ GdkPixmap* gdk_pixmap_new		(GdkDrawable *drawable,
 					 gint	      width,
 					 gint	      height,
 					 gint	      depth);
+GdkBitmap* gdk_bitmap_create_from_data	(GdkDrawable *drawable,
+					 const gchar *data,
+					 gint	      width,
+					 gint	      height);
+GdkPixmap* gdk_pixmap_create_from_data	(GdkDrawable    *drawable,
+					 const gchar 	*data,
+					 gint	     	 width,
+					 gint	     	 height,
+					 gint	         depth,
+					 const GdkColor *fg,
+					 const GdkColor *bg);
+
+GdkPixmap* gdk_pixmap_create_from_xpm            (GdkDrawable    *drawable,
+						  GdkBitmap     **mask,
+						  const GdkColor *transparent_color,
+						  const gchar    *filename);
+GdkPixmap* gdk_pixmap_colormap_create_from_xpm   (GdkDrawable    *drawable,
+						  GdkColormap    *colormap,
+						  GdkBitmap     **mask,
+						  const GdkColor *transparent_color,
+						  const gchar    *filename);
+GdkPixmap* gdk_pixmap_create_from_xpm_d          (GdkDrawable    *drawable,
+						  GdkBitmap     **mask,
+						  const GdkColor *transparent_color,
+						  gchar         **data);
+GdkPixmap* gdk_pixmap_colormap_create_from_xpm_d (GdkDrawable    *drawable,
+						  GdkColormap    *colormap,
+						  GdkBitmap     **mask,
+						  const GdkColor *transparent_color,
+						  gchar         **data);
 
 /* Functions to create/lookup pixmaps from their native equivalents
  */

gdk/gdkrectangle.c

@@ -62,8 +62,7 @@ gdk_rectangle_union (const GdkRectangle *src1,
  * gdk_rectangle_intersect:
  * @src1: a #GdkRectangle
  * @src2: a #GdkRectangle
- * @dest: (out caller-allocates) (allow-none): return location for the
- * intersection of @src1 and @src2, or %NULL
+ * @dest: (allow-none): return location for the intersection of @src1 and @src2, or %NULL
  *
  * Calculates the intersection of two rectangles. It is allowed for
  * @dest to be the same as either @src1 or @src2. If the rectangles 

gdk/gdkrgb.h

@@ -0,0 +1,137 @@
+/* GTK - The GIMP Toolkit
+ * 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/.
+ */
+
+#if !defined (__GDK_H_INSIDE__) && !defined (GDK_COMPILATION)
+#error "Only <gdk/gdk.h> can be included directly."
+#endif
+
+#ifndef __GDK_RGB_H__
+#define __GDK_RGB_H__
+
+#include <gdk/gdktypes.h>
+
+G_BEGIN_DECLS
+
+typedef struct _GdkRgbCmap GdkRgbCmap;
+
+struct _GdkRgbCmap {
+  guint32 colors[256];
+  gint n_colors;
+
+  /*< private >*/
+  GSList *info_list;
+};
+
+void   gdk_rgb_find_color        (GdkColormap *colormap,
+				  GdkColor    *color);
+
+typedef enum
+{
+  GDK_RGB_DITHER_NONE,
+  GDK_RGB_DITHER_NORMAL,
+  GDK_RGB_DITHER_MAX
+} GdkRgbDither;
+
+void        gdk_draw_rgb_image              (GdkDrawable  *drawable,
+					     GdkGC        *gc,
+					     gint          x,
+					     gint          y,
+					     gint          width,
+					     gint          height,
+					     GdkRgbDither  dith,
+					     const guchar *rgb_buf,
+					     gint          rowstride);
+void        gdk_draw_rgb_image_dithalign    (GdkDrawable  *drawable,
+					     GdkGC        *gc,
+					     gint          x,
+					     gint          y,
+					     gint          width,
+					     gint          height,
+					     GdkRgbDither  dith,
+					     const guchar *rgb_buf,
+					     gint          rowstride,
+					     gint          xdith,
+					     gint          ydith);
+void        gdk_draw_rgb_32_image           (GdkDrawable  *drawable,
+					     GdkGC        *gc,
+					     gint          x,
+					     gint          y,
+					     gint          width,
+					     gint          height,
+					     GdkRgbDither  dith,
+					     const guchar *buf,
+					     gint          rowstride);
+void        gdk_draw_rgb_32_image_dithalign (GdkDrawable  *drawable,
+					     GdkGC        *gc,
+					     gint          x,
+					     gint          y,
+					     gint          width,
+					     gint          height,
+					     GdkRgbDither  dith,
+					     const guchar *buf,
+					     gint          rowstride,
+					     gint          xdith,
+					     gint          ydith);
+void        gdk_draw_gray_image             (GdkDrawable  *drawable,
+					     GdkGC        *gc,
+					     gint          x,
+					     gint          y,
+					     gint          width,
+					     gint          height,
+					     GdkRgbDither  dith,
+					     const guchar *buf,
+					     gint          rowstride);
+void        gdk_draw_indexed_image          (GdkDrawable  *drawable,
+					     GdkGC        *gc,
+					     gint          x,
+					     gint          y,
+					     gint          width,
+					     gint          height,
+					     GdkRgbDither  dith,
+					     const guchar *buf,
+					     gint          rowstride,
+					     GdkRgbCmap   *cmap);
+GdkRgbCmap *gdk_rgb_cmap_new                (guint32      *colors,
+					     gint          n_colors);
+void        gdk_rgb_cmap_free               (GdkRgbCmap   *cmap);
+
+void     gdk_rgb_set_verbose (gboolean verbose);
+
+/* experimental colormap stuff */
+void gdk_rgb_set_install    (gboolean install);
+void gdk_rgb_set_min_colors (gint     min_colors);
+
+#ifndef GDK_MULTIHEAD_SAFE
+GdkColormap *gdk_rgb_get_colormap (void);
+GdkVisual *  gdk_rgb_get_visual   (void);
+gboolean     gdk_rgb_ditherable   (void);
+gboolean     gdk_rgb_colormap_ditherable (GdkColormap *cmap);
+#endif
+
+G_END_DECLS
+
+
+#endif /* __GDK_RGB_H__ */

gdk/gdkscreen.c

@@ -29,6 +29,7 @@
 #include "gdkintl.h"
 
 
+static void gdk_screen_dispose      (GObject        *object);
 static void gdk_screen_finalize     (GObject        *object);
 static void gdk_screen_set_property (GObject        *object,
 				     guint           prop_id,
@@ -63,6 +64,7 @@ gdk_screen_class_init (GdkScreenClass *klass)
 {
   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
+  object_class->dispose = gdk_screen_dispose;
   object_class->finalize = gdk_screen_finalize;
   object_class->set_property = gdk_screen_set_property;
   object_class->get_property = gdk_screen_get_property;
@@ -153,6 +155,30 @@ gdk_screen_init (GdkScreen *screen)
   screen->resolution = -1.;
 }
 
+static void
+gdk_screen_dispose (GObject *object)
+{
+  GdkScreen *screen = GDK_SCREEN (object);
+  gint i;
+
+  for (i = 0; i < 32; ++i)
+    {
+      if (screen->exposure_gcs[i])
+        {
+          g_object_unref (screen->exposure_gcs[i]);
+          screen->exposure_gcs[i] = NULL;
+        }
+
+      if (screen->normal_gcs[i])
+        {
+          g_object_unref (screen->normal_gcs[i]);
+          screen->normal_gcs[i] = NULL;
+        }
+    }
+
+  G_OBJECT_CLASS (gdk_screen_parent_class)->dispose (object);
+}
+
 static void
 gdk_screen_finalize (GObject *object)
 {

gdk/gdkscreen.h

@@ -49,6 +49,10 @@ struct _GdkScreen
 
   guint GSEAL (closed) : 1;
 
+  GdkGC *GSEAL (normal_gcs[32]);
+  GdkGC *GSEAL (exposure_gcs[32]);
+  GdkGC *GSEAL (subwindow_gcs[32]);
+
   cairo_font_options_t *GSEAL (font_options);
   double GSEAL (resolution);	/* pixels/points scale factor for fonts */
 };
@@ -68,6 +72,8 @@ void         gdk_screen_set_default_colormap  (GdkScreen   *screen,
 					       GdkColormap *colormap);
 GdkColormap* gdk_screen_get_system_colormap   (GdkScreen   *screen);
 GdkVisual*   gdk_screen_get_system_visual     (GdkScreen   *screen);
+GdkColormap *gdk_screen_get_rgb_colormap      (GdkScreen   *screen);
+GdkVisual *  gdk_screen_get_rgb_visual        (GdkScreen   *screen);
 GdkColormap *gdk_screen_get_rgba_colormap     (GdkScreen   *screen);
 GdkVisual *  gdk_screen_get_rgba_visual       (GdkScreen   *screen);
 gboolean     gdk_screen_is_composited	      (GdkScreen   *screen);

gdk/gdktypes.h

@@ -75,6 +75,7 @@ G_BEGIN_DECLS
  */
 typedef struct _GdkPoint	      GdkPoint;
 typedef cairo_rectangle_int_t	      GdkRectangle;
+typedef struct _GdkSegment	      GdkSegment;
 typedef struct _GdkSpan	              GdkSpan;
 
 typedef struct _GdkAtom            *GdkAtom;
@@ -102,6 +103,8 @@ typedef guint32 GdkNativeWindow;
 typedef struct _GdkColor	      GdkColor;
 typedef struct _GdkColormap	      GdkColormap;
 typedef struct _GdkCursor	      GdkCursor;
+typedef struct _GdkGC                 GdkGC;
+typedef struct _GdkImage              GdkImage;
 typedef struct _GdkVisual             GdkVisual;
 
 typedef struct _GdkDrawable           GdkDrawable;
@@ -268,6 +271,14 @@ struct _GdkPoint
   gint y;
 };
 
+struct _GdkSegment
+{
+  gint x1;
+  gint y1;
+  gint x2;
+  gint y2;
+};
+
 struct _GdkSpan
 {
   gint x;

gdk/gdkwindow.h

@@ -576,6 +576,8 @@ gboolean      gdk_window_ensure_native        (GdkWindow       *window);
 /* 
  * This allows for making shaped (partially transparent) windows
  * - cool feature, needed for Drag and Drag for example.
+ *  The shape_mask can be the mask
+ *  from gdk_pixmap_create_from_xpm.   Stefan Wille
  */
 void gdk_window_shape_combine_mask  (GdkWindow	      *window,
                                      GdkBitmap	      *mask,
@@ -688,13 +690,16 @@ void          gdk_window_set_startup_id    (GdkWindow     *window,
 					    const gchar   *startup_id);
 void          gdk_window_set_transient_for (GdkWindow     *window,
 					    GdkWindow     *parent);
+void          gdk_window_get_background  (GdkWindow       *window,
+                                          GdkColor        *color);
 void	      gdk_window_set_background	 (GdkWindow	  *window,
 					  const GdkColor  *color);
+void	      gdk_window_get_back_pixmap (GdkWindow       *window,
+					  GdkPixmap	 **pixmap,
+					  gboolean	  *parent_relative);
 void	      gdk_window_set_back_pixmap (GdkWindow	  *window,
 					  GdkPixmap	  *pixmap,
 					  gboolean	   parent_relative);
-cairo_pattern_t *gdk_window_get_background_pattern (GdkWindow     *window);
-
 void	      gdk_window_set_cursor	 (GdkWindow	  *window,
 					  GdkCursor	  *cursor);
 GdkCursor    *gdk_window_get_cursor      (GdkWindow       *window);
@@ -792,12 +797,6 @@ gboolean      gdk_window_get_decorations (GdkWindow       *window,
 void	      gdk_window_set_functions	 (GdkWindow	  *window,
 					  GdkWMFunction	   functions);
 
-cairo_surface_t *
-              gdk_window_create_similar_surface (GdkWindow *window,
-                                          cairo_content_t  content,
-                                          int              width,
-                                          int              height);
-
 void          gdk_window_beep            (GdkWindow       *window);
 void          gdk_window_iconify         (GdkWindow       *window);
 void          gdk_window_deiconify       (GdkWindow       *window);

gdk/gdkwindowimpl.h

@@ -121,15 +121,10 @@ struct _GdkWindowImplIface
    * for destroying the region later.
    */
   gboolean     (* queue_antiexpose)     (GdkWindow       *window,
-					 cairo_region_t  *update_area);
-
-  /* Called to move @area inside @window by @dx x @dy pixels. @area is 
-   * guaranteed to be inside @window. If part of @area is not invisible or
-   * invalid, it is this function's job to queue expose events in those 
-   * areas.
-   */
-  void         (* translate)            (GdkWindow       *window,
-					 cairo_region_t  *area,
+					 cairo_region_t       *update_area);
+  void         (* queue_translation)    (GdkWindow       *window,
+					 GdkGC           *gc,
+					 cairo_region_t       *area,
 					 gint            dx,
 					 gint            dy);
 

gdk/makefile.msc

@@ -75,6 +75,7 @@ gdk_OBJECTS = \
 	gdkevents.obj \
 	gdkgc.obj \
 	gdkglobals.obj \
+	gdkimage.obj \
 	gdkwindowimpl.obj \
 	gdkkeynames.obj \
 	gdkkeys.obj \
@@ -86,6 +87,7 @@ gdk_OBJECTS = \
 	gdkpixbuf-render.obj \
 	gdkpixmap.obj \
 	gdkrectangle.obj \
+	gdkrgb.obj \
 	gdkscreen.obj \
 	gdkselection.obj \
 	gdkvisual.obj \
@@ -100,12 +102,14 @@ gdk_public_h_sources = \
 	gdkevents.h	\
 	gdkgc.h		\
 	gdkkeysyms.h	\
+	gdkimage.h	\
 	gdkinput.h	\
 	gdkkeys.h	\
 	gdkpango.h	\
 	gdkpixbuf.h	\
 	gdkpixmap.h	\
 	gdkproperty.h	\
+	gdkrgb.h	\
 	gdkselection.h	\
 	gdktypes.h	\
 	gdkvisual.h	\

gdk/quartz/Makefile.am

@@ -32,9 +32,11 @@ libgdk_quartz_la_SOURCES =    	\
 	gdkdrawable-quartz.h	\
 	gdkevents-quartz.c	\
 	gdkeventloop-quartz.c	\
+	gdkgc-quartz.c		\
 	gdkgeometry-quartz.c	\
 	gdkglobals-quartz.c	\
 	gdkim-quartz.c		\
+	gdkimage-quartz.c	\
 	gdkinput.c		\
 	gdkinputprivate.h	\
 	gdkkeys-quartz.c	\

gdk/quartz/gdkcolor-quartz.c

@@ -140,6 +140,21 @@ gdk_colormap_alloc_colors (GdkColormap *colormap,
   return 0;
 }
 
+void
+gdk_colormap_query_color (GdkColormap *colormap,
+			  gulong       pixel,
+			  GdkColor    *result)
+{
+  result->red = pixel >> 16 & 0xff;
+  result->red += result->red << 8;
+
+  result->green = pixel >> 8 & 0xff;
+  result->green += result->green << 8;
+
+  result->blue = pixel & 0xff;
+  result->blue += result->blue << 8;
+}
+
 GdkScreen*
 gdk_colormap_get_screen (GdkColormap *cmap)
 {

gdk/quartz/gdkdevice-core.c

@@ -147,7 +147,7 @@ translate_coords_to_child_coords (GdkWindow *parent,
       *x -= tmp_x;
       *y -= tmp_y;
 
-      current = gdk_window_get_effective_parent (current);
+      current = gdk_window_get_parent (current);
     }
 }
 
@@ -204,7 +204,7 @@ gdk_device_core_query_state_helper (GdkWindow       *window,
       return NULL;
     }
 
-  toplevel = GDK_WINDOW_OBJECT (gdk_window_get_effective_toplevel (window));
+  toplevel = GDK_WINDOW_OBJECT (gdk_window_get_toplevel (window));
 
   *mask = _gdk_quartz_events_get_current_event_mask ();
 

gdk/quartz/gdkdrawable-quartz.c

@@ -32,13 +32,12 @@ typedef struct {
   CGContextRef  cg_context;
 } GdkQuartzCairoSurfaceData;
 
-gboolean
+void
 _gdk_windowing_set_cairo_surface_size (cairo_surface_t *surface,
 				       int              width,
 				       int              height)
 {
   /* This is not supported with quartz surfaces. */
-  return FALSE;
 }
 
 static void
@@ -148,6 +147,469 @@ gdk_quartz_get_depth (GdkDrawable *drawable)
   return gdk_drawable_get_depth (GDK_DRAWABLE_IMPL_QUARTZ (drawable)->wrapper);
 }
 
+static void
+gdk_quartz_draw_rectangle (GdkDrawable *drawable,
+			   GdkGC       *gc,
+			   gboolean     filled,
+			   gint         x,
+			   gint         y,
+			   gint         width,
+			   gint         height)
+{
+  CGContextRef context = gdk_quartz_drawable_get_context (drawable, FALSE);
+
+  if (!context)
+    return;
+
+  _gdk_quartz_gc_update_cg_context (gc, 
+				    drawable,
+				    context,
+				    filled ?
+				    GDK_QUARTZ_CONTEXT_FILL : 
+				    GDK_QUARTZ_CONTEXT_STROKE);
+
+  if (filled)
+    {
+      CGRect rect = CGRectMake (x, y, width, height);
+
+      CGContextFillRect (context, rect);
+    }
+  else
+    {
+      CGRect rect = CGRectMake (x + 0.5, y + 0.5, width, height);
+
+      CGContextStrokeRect (context, rect);
+    }
+
+  gdk_quartz_drawable_release_context (drawable, context);
+}
+
+static void
+gdk_quartz_draw_arc (GdkDrawable *drawable,
+		     GdkGC       *gc,
+		     gboolean     filled,
+		     gint         x,
+		     gint         y,
+		     gint         width,
+		     gint         height,
+		     gint         angle1,
+		     gint         angle2)
+{
+  CGContextRef context = gdk_quartz_drawable_get_context (drawable, FALSE);
+  float start_angle, end_angle;
+  gboolean clockwise = FALSE;
+
+  if (!context)
+    return;
+
+  _gdk_quartz_gc_update_cg_context (gc, drawable, context,
+				    filled ?
+				    GDK_QUARTZ_CONTEXT_FILL :
+				    GDK_QUARTZ_CONTEXT_STROKE);
+
+  start_angle = angle1 * 2.0 * G_PI / 360.0 / 64.0;
+  end_angle = start_angle + angle2 * 2.0 * G_PI / 360.0 / 64.0;
+
+  /*  angle2 is relative to angle1 and can be negative, which switches
+   *  the drawing direction
+   */
+  if (angle2 < 0)
+    clockwise = TRUE;
+
+  /*  below, flip the coordinate system back to its original y-diretion
+   *  so the angles passed to CGContextAddArc() are interpreted as
+   *  expected
+   *
+   *  FIXME: the implementation below works only for perfect circles
+   *  (width == height). Any other aspect ratio either scales the
+   *  line width unevenly or scales away the path entirely for very
+   *  small line widths (esp. for line_width == 0, which is a hair
+   *  line on X11 but must be approximated with the thinnest possible
+   *  line on quartz).
+   */
+
+  if (filled)
+    {
+      CGContextTranslateCTM (context,
+                             x + width / 2.0,
+                             y + height / 2.0);
+      CGContextScaleCTM (context, 1.0, - (double)height / (double)width);
+
+      CGContextMoveToPoint (context, 0, 0);
+      CGContextAddArc (context, 0, 0, width / 2.0,
+		       start_angle, end_angle,
+		       clockwise);
+      CGContextClosePath (context);
+      CGContextFillPath (context);
+    }
+  else
+    {
+      CGContextTranslateCTM (context,
+                             x + width / 2.0 + 0.5,
+                             y + height / 2.0 + 0.5);
+      CGContextScaleCTM (context, 1.0, - (double)height / (double)width);
+
+      CGContextAddArc (context, 0, 0, width / 2.0,
+		       start_angle, end_angle,
+		       clockwise);
+      CGContextStrokePath (context);
+    }
+
+  gdk_quartz_drawable_release_context (drawable, context);
+}
+
+static void
+gdk_quartz_draw_polygon (GdkDrawable *drawable,
+			 GdkGC       *gc,
+			 gboolean     filled,
+			 GdkPoint    *points,
+			 gint         npoints)
+{
+  CGContextRef context = gdk_quartz_drawable_get_context (drawable, FALSE);
+  int i;
+
+  if (!context)
+    return;
+
+  _gdk_quartz_gc_update_cg_context (gc, drawable, context,
+				    filled ?
+				    GDK_QUARTZ_CONTEXT_FILL :
+				    GDK_QUARTZ_CONTEXT_STROKE);
+
+  if (filled)
+    {
+      CGContextMoveToPoint (context, points[0].x, points[0].y);
+      for (i = 1; i < npoints; i++)
+	CGContextAddLineToPoint (context, points[i].x, points[i].y);
+
+      CGContextClosePath (context);
+      CGContextFillPath (context);
+    }
+  else
+    {
+      CGContextMoveToPoint (context, points[0].x + 0.5, points[0].y + 0.5);
+      for (i = 1; i < npoints; i++)
+	CGContextAddLineToPoint (context, points[i].x + 0.5, points[i].y + 0.5);
+
+      CGContextClosePath (context);
+      CGContextStrokePath (context);
+    }
+
+  gdk_quartz_drawable_release_context (drawable, context);
+}
+
+static void
+gdk_quartz_draw_drawable (GdkDrawable *drawable,
+			  GdkGC       *gc,
+			  GdkPixmap   *src,
+			  gint         xsrc,
+			  gint         ysrc,
+			  gint         xdest,
+			  gint         ydest,
+			  gint         width,
+			  gint         height,
+			  GdkDrawable *original_src)
+{
+  int src_depth = gdk_drawable_get_depth (src);
+  int dest_depth = gdk_drawable_get_depth (drawable);
+  GdkDrawableImplQuartz *src_impl;
+
+  if (GDK_IS_WINDOW_IMPL_QUARTZ (src))
+    {
+      GdkWindowImplQuartz *window_impl;
+
+      window_impl = GDK_WINDOW_IMPL_QUARTZ (src);
+
+      /* We do support moving areas on the same drawable, if it can be done
+       * by using a scroll. FIXME: We need to check that the params support
+       * this hack, and make sure it's done properly with any offsets etc?
+       */
+      if (drawable == (GdkDrawable *)window_impl)
+        {
+          [window_impl->view scrollRect:NSMakeRect (xsrc, ysrc, width, height)
+                                     by:NSMakeSize (xdest - xsrc, ydest - ysrc)];
+
+
+        }
+      else
+        g_warning ("Drawing with window source != dest is not supported");
+
+      return;
+    }
+  else if (GDK_IS_DRAWABLE_IMPL_QUARTZ (src))
+    src_impl = GDK_DRAWABLE_IMPL_QUARTZ (src);
+  else if (GDK_IS_PIXMAP (src))
+    src_impl = GDK_DRAWABLE_IMPL_QUARTZ (GDK_PIXMAP_OBJECT (src)->impl);
+  else
+    {
+      g_warning ("Unsupported source %s", G_OBJECT_TYPE_NAME (src));
+      return;
+    }
+
+  /* Handle drawable and pixmap sources. */
+  if (src_depth == 1)
+    {
+      /* FIXME: src depth 1 is not supported yet */
+      g_warning ("Source with depth 1 unsupported");
+    }
+  else if (dest_depth != 0 && src_depth == dest_depth)
+    {
+      GdkPixmapImplQuartz *pixmap_impl = GDK_PIXMAP_IMPL_QUARTZ (src_impl);
+      CGContextRef context = gdk_quartz_drawable_get_context (drawable, FALSE);
+
+      if (!context)
+        return;
+
+      _gdk_quartz_gc_update_cg_context (gc, drawable, context,
+                                        GDK_QUARTZ_CONTEXT_STROKE);
+
+      CGContextClipToRect (context, CGRectMake (xdest, ydest, width, height));
+      CGContextTranslateCTM (context, xdest - xsrc, ydest - ysrc +
+                             pixmap_impl->height);
+      CGContextScaleCTM (context, 1.0, -1.0);
+
+      CGContextDrawImage (context,
+                          CGRectMake (0, 0, pixmap_impl->width, pixmap_impl->height),
+                          pixmap_impl->image);
+
+      gdk_quartz_drawable_release_context (drawable, context);
+    }
+  else
+    g_warning ("Attempt to draw a drawable with depth %d to a drawable with depth %d",
+               src_depth, dest_depth);
+}
+
+static void
+gdk_quartz_draw_points (GdkDrawable *drawable,
+			GdkGC       *gc,
+			GdkPoint    *points,
+			gint         npoints)
+{
+  CGContextRef context = gdk_quartz_drawable_get_context (drawable, FALSE);
+  int i;
+
+  if (!context)
+    return;
+
+  _gdk_quartz_gc_update_cg_context (gc, drawable, context,
+				    GDK_QUARTZ_CONTEXT_STROKE |
+				    GDK_QUARTZ_CONTEXT_FILL);
+
+  /* Just draw 1x1 rectangles */
+  for (i = 0; i < npoints; i++) 
+    {
+      CGRect rect = CGRectMake (points[i].x, points[i].y, 1, 1);
+      CGContextFillRect (context, rect);
+    }
+
+  gdk_quartz_drawable_release_context (drawable, context);
+}
+
+static inline void
+gdk_quartz_fix_cap_not_last_line (GdkGCQuartz *private,
+				  gint         x1,
+				  gint         y1,
+				  gint         x2,
+				  gint         y2,
+				  gint        *xfix,
+				  gint        *yfix)
+{
+  *xfix = 0;
+  *yfix = 0;
+
+  if (private->cap_style == GDK_CAP_NOT_LAST && private->line_width == 0)
+    {
+      /* fix only vertical and horizontal lines for now */
+
+      if (y1 == y2 && x1 != x2)
+	{
+	  *xfix = (x1 < x2) ? -1 : 1;
+	}
+      else if (x1 == x2 && y1 != y2)
+	{
+	  *yfix = (y1 < y2) ? -1 : 1;
+	}
+    }
+}
+
+static void
+gdk_quartz_draw_segments (GdkDrawable    *drawable,
+			  GdkGC          *gc,
+			  GdkSegment     *segs,
+			  gint            nsegs)
+{
+  CGContextRef context = gdk_quartz_drawable_get_context (drawable, FALSE);
+  GdkGCQuartz *private;
+  int i;
+
+  if (!context)
+    return;
+
+  private = GDK_GC_QUARTZ (gc);
+
+  _gdk_quartz_gc_update_cg_context (gc, drawable, context,
+				    GDK_QUARTZ_CONTEXT_STROKE);
+
+  for (i = 0; i < nsegs; i++)
+    {
+      gint xfix, yfix;
+
+      gdk_quartz_fix_cap_not_last_line (private,
+					segs[i].x1, segs[i].y1,
+					segs[i].x2, segs[i].y2,
+					&xfix, &yfix);
+
+      CGContextMoveToPoint (context, segs[i].x1 + 0.5, segs[i].y1 + 0.5);
+      CGContextAddLineToPoint (context, segs[i].x2 + 0.5 + xfix, segs[i].y2 + 0.5 + yfix);
+    }
+  
+  CGContextStrokePath (context);
+
+  gdk_quartz_drawable_release_context (drawable, context);
+}
+
+static void
+gdk_quartz_draw_lines (GdkDrawable *drawable,
+		       GdkGC       *gc,
+		       GdkPoint    *points,
+		       gint         npoints)
+{
+  CGContextRef context = gdk_quartz_drawable_get_context (drawable, FALSE);
+  GdkGCQuartz *private;
+  gint xfix, yfix;
+  gint i;
+
+  if (!context)
+    return;
+
+  private = GDK_GC_QUARTZ (gc);
+
+  _gdk_quartz_gc_update_cg_context (gc, drawable, context,
+				    GDK_QUARTZ_CONTEXT_STROKE);
+
+  CGContextMoveToPoint (context, points[0].x + 0.5, points[0].y + 0.5);
+
+  for (i = 1; i < npoints - 1; i++)
+    CGContextAddLineToPoint (context, points[i].x + 0.5, points[i].y + 0.5);
+
+  gdk_quartz_fix_cap_not_last_line (private,
+				    points[npoints - 2].x, points[npoints - 2].y,
+				    points[npoints - 1].x, points[npoints - 1].y,
+				    &xfix, &yfix);
+
+  CGContextAddLineToPoint (context,
+			   points[npoints - 1].x + 0.5 + xfix,
+			   points[npoints - 1].y + 0.5 + yfix);
+
+  CGContextStrokePath (context);
+
+  gdk_quartz_drawable_release_context (drawable, context);
+}
+
+static void
+gdk_quartz_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)
+{
+  CGContextRef context = gdk_quartz_drawable_get_context (drawable, FALSE);
+  CGColorSpaceRef colorspace;
+  CGDataProviderRef data_provider;
+  CGImageRef image;
+  void *data;
+  int rowstride, pixbuf_width, pixbuf_height;
+  gboolean has_alpha;
+
+  if (!context)
+    return;
+
+  pixbuf_width = gdk_pixbuf_get_width (pixbuf);
+  pixbuf_height = gdk_pixbuf_get_height (pixbuf);
+  rowstride = gdk_pixbuf_get_rowstride (pixbuf);
+  has_alpha = gdk_pixbuf_get_has_alpha (pixbuf);
+
+  data = gdk_pixbuf_get_pixels (pixbuf);
+
+  colorspace = CGColorSpaceCreateDeviceRGB ();
+  data_provider = CGDataProviderCreateWithData (NULL, data, pixbuf_height * rowstride, NULL);
+
+  image = CGImageCreate (pixbuf_width, pixbuf_height, 8,
+			 has_alpha ? 32 : 24, rowstride, 
+			 colorspace, 
+			 has_alpha ? kCGImageAlphaLast : 0,
+			 data_provider, NULL, FALSE, 
+			 kCGRenderingIntentDefault);
+
+  CGDataProviderRelease (data_provider);
+  CGColorSpaceRelease (colorspace);
+
+  _gdk_quartz_gc_update_cg_context (gc, drawable, context,
+				    GDK_QUARTZ_CONTEXT_STROKE);
+
+  CGContextClipToRect (context, CGRectMake (dest_x, dest_y, width, height));
+  CGContextTranslateCTM (context, dest_x - src_x, dest_y - src_y + pixbuf_height);
+  CGContextScaleCTM (context, 1, -1);
+
+  CGContextDrawImage (context, CGRectMake (0, 0, pixbuf_width, pixbuf_height), image);
+  CGImageRelease (image);
+
+  gdk_quartz_drawable_release_context (drawable, context);
+}
+
+static void
+gdk_quartz_draw_image (GdkDrawable     *drawable,
+		       GdkGC           *gc,
+		       GdkImage        *image,
+		       gint             xsrc,
+		       gint             ysrc,
+		       gint             xdest,
+		       gint             ydest,
+		       gint             width,
+		       gint             height)
+{
+  CGContextRef context = gdk_quartz_drawable_get_context (drawable, FALSE);
+  CGColorSpaceRef colorspace;
+  CGDataProviderRef data_provider;
+  CGImageRef cgimage;
+
+  if (!context)
+    return;
+
+  colorspace = CGColorSpaceCreateDeviceRGB ();
+  data_provider = CGDataProviderCreateWithData (NULL, image->mem, image->height * image->bpl, NULL);
+
+  /* FIXME: Make sure that this function draws 32-bit images correctly,
+  * also check endianness wrt kCGImageAlphaNoneSkipFirst */
+  cgimage = CGImageCreate (image->width, image->height, 8,
+			   32, image->bpl,
+			   colorspace,
+			   kCGImageAlphaNoneSkipFirst, 
+			   data_provider, NULL, FALSE, kCGRenderingIntentDefault);
+
+  CGDataProviderRelease (data_provider);
+  CGColorSpaceRelease (colorspace);
+
+  _gdk_quartz_gc_update_cg_context (gc, drawable, context,
+				    GDK_QUARTZ_CONTEXT_STROKE);
+
+  CGContextClipToRect (context, CGRectMake (xdest, ydest, width, height));
+  CGContextTranslateCTM (context, xdest - xsrc, ydest - ysrc + image->height);
+  CGContextScaleCTM (context, 1, -1);
+
+  CGContextDrawImage (context, CGRectMake (0, 0, image->width, image->height), cgimage);
+  CGImageRelease (cgimage);
+
+  gdk_quartz_drawable_release_context (drawable, context);
+}
+
 static void
 gdk_drawable_impl_quartz_finalize (GObject *object)
 {
@@ -169,6 +631,17 @@ gdk_drawable_impl_quartz_class_init (GdkDrawableImplQuartzClass *klass)
 
   object_class->finalize = gdk_drawable_impl_quartz_finalize;
 
+  drawable_class->create_gc = _gdk_quartz_gc_new;
+  drawable_class->draw_rectangle = gdk_quartz_draw_rectangle;
+  drawable_class->draw_arc = gdk_quartz_draw_arc;
+  drawable_class->draw_polygon = gdk_quartz_draw_polygon;
+  drawable_class->draw_drawable_with_src = gdk_quartz_draw_drawable;
+  drawable_class->draw_points = gdk_quartz_draw_points;
+  drawable_class->draw_segments = gdk_quartz_draw_segments;
+  drawable_class->draw_lines = gdk_quartz_draw_lines;
+  drawable_class->draw_image = gdk_quartz_draw_image;
+  drawable_class->draw_pixbuf = gdk_quartz_draw_pixbuf;
+
   drawable_class->ref_cairo_surface = gdk_quartz_ref_cairo_surface;
 
   drawable_class->set_colormap = gdk_quartz_set_colormap;
@@ -177,6 +650,8 @@ gdk_drawable_impl_quartz_class_init (GdkDrawableImplQuartzClass *klass)
   drawable_class->get_depth = gdk_quartz_get_depth;
   drawable_class->get_screen = gdk_quartz_get_screen;
   drawable_class->get_visual = gdk_quartz_get_visual;
+
+  drawable_class->_copy_to_image = _gdk_quartz_image_copy_to_image;
 }
 
 GType

gdk/quartz/gdkevents-quartz.c

@@ -37,11 +37,6 @@
 #define GRIP_WIDTH 15
 #define GRIP_HEIGHT 15
 
-#define WINDOW_IS_TOPLEVEL(window)		     \
-  (GDK_WINDOW_TYPE (window) != GDK_WINDOW_CHILD &&   \
-   GDK_WINDOW_TYPE (window) != GDK_WINDOW_FOREIGN && \
-   GDK_WINDOW_TYPE (window) != GDK_WINDOW_OFFSCREEN)
-
 /* This is the window corresponding to the key window */
 static GdkWindow   *current_keyboard_window;
 
@@ -510,7 +505,7 @@ find_toplevel_under_pointer (GdkDisplay *display,
 
   info = _gdk_display_get_pointer_info (display, display->core_pointer);
   toplevel = info->toplevel_under_pointer;
-  if (toplevel && WINDOW_IS_TOPLEVEL (toplevel))
+  if (toplevel)
     {
       GdkWindowObject *private;
       NSWindow *nswindow;
@@ -556,7 +551,7 @@ find_toplevel_for_keyboard_event (NSEvent *nsevent)
       grab = _gdk_display_get_last_device_grab (display, device);
       if (grab && grab->window && !grab->owner_events)
         {
-          window = gdk_window_get_effective_toplevel (grab->window);
+          window = gdk_window_get_toplevel (grab->window);
           break;
         }
     }
@@ -601,7 +596,7 @@ find_toplevel_for_mouse_event (NSEvent    *nsevent,
    */
   grab = _gdk_display_get_last_device_grab (display,
                                             display->core_pointer);
-  if (WINDOW_IS_TOPLEVEL (toplevel) && grab)
+  if (grab)
     {
       /* Implicit grabs do not go through XGrabPointer and thus the
        * event mask should not be checked.
@@ -639,7 +634,7 @@ find_toplevel_for_mouse_event (NSEvent    *nsevent,
           GdkWindowObject *grab_private;
           NSWindow *grab_nswindow;
 
-          grab_toplevel = gdk_window_get_effective_toplevel (grab->window);
+          grab_toplevel = gdk_window_get_toplevel (grab->window);
           grab_private = (GdkWindowObject *)grab_toplevel;
 
           grab_nswindow = ((GdkWindowImplQuartz *)grab_private->impl)->toplevel;
@@ -675,8 +670,7 @@ find_toplevel_for_mouse_event (NSEvent    *nsevent,
       toplevel_under_pointer = find_toplevel_under_pointer (display,
                                                             screen_point,
                                                             &x_tmp, &y_tmp);
-      if (toplevel_under_pointer
-          && WINDOW_IS_TOPLEVEL (toplevel_under_pointer))
+      if (toplevel_under_pointer)
         {
           GdkWindowObject *toplevel_private;
           GdkWindowImplQuartz *toplevel_impl;

gdk/quartz/gdkgc-quartz.c

@@ -0,0 +1,686 @@
+/* gdkgc-quartz.c
+ *
+ * Copyright (C) 2005 Imendio AB
+ *
+ * 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.
+ */
+
+#include "config.h"
+
+#include "gdkgc.h"
+#include "gdkprivate-quartz.h"
+
+static gpointer parent_class = NULL;
+
+static void
+gdk_quartz_gc_get_values (GdkGC       *gc,
+			  GdkGCValues *values)
+{
+  GdkGCQuartz *private;
+
+  private = GDK_GC_QUARTZ (gc);
+
+  values->foreground.pixel = _gdk_gc_get_fg_pixel (gc);
+  values->background.pixel = _gdk_gc_get_bg_pixel (gc);
+
+  values->function = private->function;
+
+  values->fill = _gdk_gc_get_fill (gc);
+  values->tile = _gdk_gc_get_tile (gc);
+  values->stipple = _gdk_gc_get_stipple (gc);
+  
+  /* The X11 backend always returns a NULL clip_mask. */
+  values->clip_mask = NULL;
+
+  values->ts_x_origin = gc->ts_x_origin;
+  values->ts_y_origin = gc->ts_y_origin;
+  values->clip_x_origin = gc->clip_x_origin;
+  values->clip_y_origin = gc->clip_y_origin;
+
+  values->graphics_exposures = private->graphics_exposures;
+
+  values->line_width = private->line_width;
+  values->line_style = private->line_style;
+  values->cap_style = private->cap_style;
+  values->join_style = private->join_style;
+}
+
+
+static void
+data_provider_release (void *info, const void *data, size_t size)
+{
+  g_free (info);
+}
+
+static CGImageRef
+create_clip_mask (GdkPixmap *source_pixmap)
+{
+  int width, height, bytes_per_row, bits_per_pixel;
+  void *data;
+  CGImageRef source;
+  CGImageRef clip_mask;
+  CGContextRef cg_context;
+  CGDataProviderRef data_provider;
+
+  /* We need to flip the clip mask here, because this cannot be done during
+   * the drawing process when this mask will be used to do clipping.  We
+   * quickly create a new CGImage, set up a CGContext, draw the source
+   * image while flipping, and done.  If this appears too slow in the
+   * future, we would look into doing this by hand on the actual raw
+   * data.
+   */
+  source = GDK_PIXMAP_IMPL_QUARTZ (GDK_PIXMAP_OBJECT (source_pixmap)->impl)->image;
+
+  width = CGImageGetWidth (source);
+  height = CGImageGetHeight (source);
+  bytes_per_row = CGImageGetBytesPerRow (source);
+  bits_per_pixel = CGImageGetBitsPerPixel (source);
+
+  data = g_malloc (height * bytes_per_row);
+  data_provider = CGDataProviderCreateWithData (data, data,
+                                                height * bytes_per_row,
+                                                data_provider_release);
+
+  clip_mask = CGImageCreate (width, height, 8,
+                             bits_per_pixel,
+                             bytes_per_row,
+                             CGImageGetColorSpace (source),
+                             CGImageGetAlphaInfo (source),
+                             data_provider, NULL, FALSE,
+                             kCGRenderingIntentDefault);
+  CGDataProviderRelease (data_provider);
+
+  cg_context = CGBitmapContextCreate (data,
+                                      width, height,
+                                      CGImageGetBitsPerComponent (source),
+                                      bytes_per_row,
+                                      CGImageGetColorSpace (source),
+                                      CGImageGetBitmapInfo (source));
+
+  CGContextTranslateCTM (cg_context, 0, height);
+  CGContextScaleCTM (cg_context, 1.0, -1.0);
+
+  CGContextDrawImage (cg_context,
+                      CGRectMake (0, 0, width, height), source);
+
+  CGContextRelease (cg_context);
+
+  return clip_mask;
+}
+
+static void
+gdk_quartz_gc_set_values (GdkGC           *gc,
+			  GdkGCValues     *values,
+			  GdkGCValuesMask  mask)
+{
+  GdkGCQuartz *private = GDK_GC_QUARTZ (gc);
+
+  if (mask & GDK_GC_FUNCTION)
+    private->function = values->function;
+
+  if (mask & GDK_GC_SUBWINDOW)
+    private->subwindow_mode = values->subwindow_mode;
+
+  if (mask & GDK_GC_EXPOSURES)
+    private->graphics_exposures = values->graphics_exposures;
+
+  if (mask & GDK_GC_CLIP_MASK)
+    {
+      private->have_clip_region = FALSE;
+      private->have_clip_mask = values->clip_mask != NULL;
+      if (private->clip_mask)
+	CGImageRelease (private->clip_mask);
+
+      if (values->clip_mask)
+        private->clip_mask = create_clip_mask (values->clip_mask);
+      else
+	private->clip_mask = NULL;
+    }
+
+  if (mask & GDK_GC_LINE_WIDTH)
+    private->line_width = values->line_width;
+
+  if (mask & GDK_GC_LINE_STYLE)
+    private->line_style = values->line_style;
+
+  if (mask & GDK_GC_CAP_STYLE)
+    private->cap_style = values->cap_style;
+
+  if (mask & GDK_GC_JOIN_STYLE)
+    private->join_style = values->join_style;
+}
+
+static void
+gdk_quartz_gc_set_dashes (GdkGC *gc,
+			  gint   dash_offset,
+			  gint8  dash_list[],
+			  gint   n)
+{
+  GdkGCQuartz *private = GDK_GC_QUARTZ (gc);
+  gint i;
+
+  private->dash_count = n;
+  g_free (private->dash_lengths);
+  private->dash_lengths = g_new (CGFloat, n);
+  for (i = 0; i < n; i++)
+    private->dash_lengths[i] = (CGFloat) dash_list[i];
+  private->dash_phase = (CGFloat) dash_offset;
+}
+
+static void
+gdk_gc_quartz_finalize (GObject *object)
+{
+  GdkGCQuartz *private = GDK_GC_QUARTZ (object);
+
+  if (private->clip_mask)
+    CGImageRelease (private->clip_mask);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gdk_gc_quartz_class_init (GdkGCQuartzClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+  GdkGCClass *gc_class = GDK_GC_CLASS (klass);
+  
+  parent_class = g_type_class_peek_parent (klass);
+
+  object_class->finalize = gdk_gc_quartz_finalize;
+
+  gc_class->get_values = gdk_quartz_gc_get_values;
+  gc_class->set_values = gdk_quartz_gc_set_values;
+  gc_class->set_dashes = gdk_quartz_gc_set_dashes;
+}
+
+static void
+gdk_gc_quartz_init (GdkGCQuartz *gc_quartz)
+{
+  gc_quartz->function = GDK_COPY;
+  gc_quartz->subwindow_mode = GDK_CLIP_BY_CHILDREN;
+  gc_quartz->graphics_exposures = TRUE;
+  gc_quartz->line_width = 0;
+  gc_quartz->line_style = GDK_LINE_SOLID;
+  gc_quartz->cap_style = GDK_CAP_BUTT;
+  gc_quartz->join_style = GDK_JOIN_MITER;
+}
+
+GType
+_gdk_gc_quartz_get_type (void)
+{
+  static GType object_type = 0;
+
+  if (!object_type)
+    {
+      const GTypeInfo object_info =
+      {
+        sizeof (GdkGCQuartzClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gdk_gc_quartz_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkGCQuartz),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) gdk_gc_quartz_init,
+      };
+      
+      object_type = g_type_register_static (GDK_TYPE_GC,
+                                            "GdkGCQuartz",
+                                            &object_info, 0);
+    }
+  
+  return object_type;
+}
+
+GdkGC *
+_gdk_quartz_gc_new (GdkDrawable      *drawable,
+		    GdkGCValues      *values,
+		    GdkGCValuesMask   values_mask)
+{
+  GdkGC *gc;
+
+  gc = g_object_new (GDK_TYPE_GC_QUARTZ, NULL);
+
+  _gdk_gc_init (gc, drawable, values, values_mask);
+
+  gdk_quartz_gc_set_values (gc, values, values_mask);
+
+  return gc;
+}
+
+void
+_gdk_windowing_gc_set_clip_region (GdkGC           *gc,
+				   const cairo_region_t *region,
+				   gboolean         reset_origin)
+{
+  GdkGCQuartz *private = GDK_GC_QUARTZ (gc);
+
+  if ((private->have_clip_region && ! region) || private->have_clip_mask)
+    {
+      if (private->clip_mask)
+	{
+	  CGImageRelease (private->clip_mask);
+	  private->clip_mask = NULL;
+	}
+      private->have_clip_mask = FALSE;
+    }
+
+  private->have_clip_region = region != NULL;
+
+  if (reset_origin)
+    {
+      gc->clip_x_origin = 0;
+      gc->clip_y_origin = 0;
+    }
+}
+
+void
+_gdk_windowing_gc_copy (GdkGC *dst_gc,
+			GdkGC *src_gc)
+{
+  GdkGCQuartz *dst_quartz_gc = GDK_GC_QUARTZ (dst_gc);
+  GdkGCQuartz *src_quartz_gc = GDK_GC_QUARTZ (src_gc);
+
+  dst_quartz_gc->function = src_quartz_gc->function;
+  dst_quartz_gc->subwindow_mode = src_quartz_gc->subwindow_mode;
+  dst_quartz_gc->graphics_exposures = src_quartz_gc->graphics_exposures;
+
+  dst_quartz_gc->have_clip_region = src_quartz_gc->have_clip_region;
+  dst_quartz_gc->have_clip_mask = src_quartz_gc->have_clip_mask;
+
+  if (dst_quartz_gc->clip_mask)
+    {
+      CGImageRelease (dst_quartz_gc->clip_mask);
+      dst_quartz_gc->clip_mask = NULL;
+    }
+  
+  if (src_quartz_gc->clip_mask)
+    dst_quartz_gc->clip_mask =
+      CGImageCreateCopy (GDK_PIXMAP_IMPL_QUARTZ (GDK_PIXMAP_OBJECT (src_quartz_gc->clip_mask)->impl)->image);
+
+  dst_quartz_gc->line_width = src_quartz_gc->line_width;
+  dst_quartz_gc->line_style = src_quartz_gc->line_style;
+  dst_quartz_gc->cap_style = src_quartz_gc->cap_style;
+  dst_quartz_gc->join_style = src_quartz_gc->join_style;
+
+  g_free (dst_quartz_gc->dash_lengths);
+  dst_quartz_gc->dash_lengths = g_memdup (src_quartz_gc->dash_lengths,
+					  sizeof (CGFloat) * src_quartz_gc->dash_count);
+  dst_quartz_gc->dash_count = src_quartz_gc->dash_count;
+  dst_quartz_gc->dash_phase = src_quartz_gc->dash_phase;
+}
+
+GdkScreen *  
+gdk_gc_get_screen (GdkGC *gc)
+{
+  return _gdk_screen;
+}
+
+struct PatternCallbackInfo
+{
+  GdkGCQuartz *private_gc;
+  GdkDrawable *drawable;
+};
+
+static void
+pattern_callback_info_release (void *info)
+{
+  g_free (info);
+}
+
+static void
+gdk_quartz_draw_tiled_pattern (void         *info,
+			       CGContextRef  context)
+{
+  struct PatternCallbackInfo *pinfo = info;
+  GdkGC       *gc = GDK_GC (pinfo->private_gc);
+  CGImageRef   pattern_image;
+  size_t       width, height;
+
+  pattern_image = GDK_PIXMAP_IMPL_QUARTZ (GDK_PIXMAP_OBJECT (_gdk_gc_get_tile (gc))->impl)->image;
+
+  width = CGImageGetWidth (pattern_image);
+  height = CGImageGetHeight (pattern_image);
+
+  CGContextDrawImage (context, 
+		      CGRectMake (0, 0, width, height),
+		      pattern_image);
+}
+
+static void
+gdk_quartz_draw_stippled_pattern (void         *info,
+				  CGContextRef  context)
+{
+  struct PatternCallbackInfo *pinfo = info;
+  GdkGC      *gc = GDK_GC (pinfo->private_gc);
+  CGImageRef  pattern_image;
+  CGRect      rect;
+  CGColorRef  color;
+
+  pattern_image = GDK_PIXMAP_IMPL_QUARTZ (GDK_PIXMAP_OBJECT (_gdk_gc_get_stipple (gc))->impl)->image;
+  rect = CGRectMake (0, 0,
+		     CGImageGetWidth (pattern_image),
+		     CGImageGetHeight (pattern_image));
+
+  CGContextClipToMask (context, rect, pattern_image);
+  color = _gdk_quartz_colormap_get_cgcolor_from_pixel (pinfo->drawable,
+                                                       _gdk_gc_get_fg_pixel (gc));
+  CGContextSetFillColorWithColor (context, color);
+  CGColorRelease (color);
+
+  CGContextFillRect (context, rect);
+}
+
+static void
+gdk_quartz_draw_opaque_stippled_pattern (void         *info,
+					 CGContextRef  context)
+{
+  struct PatternCallbackInfo *pinfo = info;
+  GdkGC      *gc = GDK_GC (pinfo->private_gc);
+  CGImageRef  pattern_image;
+  CGRect      rect;
+  CGColorRef  color;
+
+  pattern_image = GDK_PIXMAP_IMPL_QUARTZ (GDK_PIXMAP_OBJECT (_gdk_gc_get_stipple (gc))->impl)->image;
+  rect = CGRectMake (0, 0,
+		     CGImageGetWidth (pattern_image),
+		     CGImageGetHeight (pattern_image));
+
+  color = _gdk_quartz_colormap_get_cgcolor_from_pixel (pinfo->drawable,
+                                                       _gdk_gc_get_bg_pixel (gc));
+  CGContextSetFillColorWithColor (context, color);
+  CGColorRelease (color);
+
+  CGContextFillRect (context, rect);
+
+  CGContextClipToMask (context, rect, pattern_image);
+  color = _gdk_quartz_colormap_get_cgcolor_from_pixel (info,
+                                                       _gdk_gc_get_fg_pixel (gc));
+  CGContextSetFillColorWithColor (context, color);
+  CGColorRelease (color);
+
+  CGContextFillRect (context, rect);
+}
+
+void
+_gdk_quartz_gc_update_cg_context (GdkGC                      *gc,
+				  GdkDrawable                *drawable,
+				  CGContextRef                context,
+				  GdkQuartzContextValuesMask  mask)
+{
+  GdkGCQuartz *private;
+  guint32      fg_pixel;
+  guint32      bg_pixel;
+
+  g_return_if_fail (gc == NULL || GDK_IS_GC (gc));
+
+  if (!gc)
+    return;
+
+  private = GDK_GC_QUARTZ (gc);
+
+  if (private->have_clip_region)
+    {
+      CGRect rect;
+      CGRect *cg_rects;
+      cairo_region_t *region;
+      gint n_rects, i;
+
+      region = _gdk_gc_get_clip_region (gc);
+      n_rects = cairo_region_num_rectangles (region);
+
+      if (n_rects == 1)
+	cg_rects = &rect;
+      else
+	cg_rects = g_new (CGRect, n_rects);
+
+      for (i = 0; i < n_rects; i++)
+	{
+          cairo_rectangle_int_t cairo_rect;
+          cairo_region_get_rectangle (region, i, &cairo_rect);
+	  cg_rects[i].origin.x = cairo_rect.x + gc->clip_x_origin;
+	  cg_rects[i].origin.y = cairo_rect.y + gc->clip_y_origin;
+	  cg_rects[i].size.width = cairo_rect.width;
+	  cg_rects[i].size.height = cairo_rect.height;
+	}
+
+      CGContextClipToRects (context, cg_rects, n_rects);
+
+      if (cg_rects != &rect)
+	g_free (cg_rects);
+    }
+  else if (private->have_clip_mask && private->clip_mask)
+    {
+      /* Note: This is 10.4 only. For lower versions, we need to transform the
+       * mask into a region.
+       */
+      CGContextClipToMask (context,
+			   CGRectMake (gc->clip_x_origin, gc->clip_y_origin,
+				       CGImageGetWidth (private->clip_mask),
+				       CGImageGetHeight (private->clip_mask)),
+			   private->clip_mask);
+    }
+
+  fg_pixel = _gdk_gc_get_fg_pixel (gc);
+  bg_pixel = _gdk_gc_get_bg_pixel (gc);
+
+  {
+    CGBlendMode blend_mode = kCGBlendModeNormal;
+
+    switch (private->function)
+      {
+      case GDK_COPY:
+	blend_mode = kCGBlendModeNormal;
+	break;
+
+      case GDK_INVERT:
+      case GDK_XOR:
+	blend_mode = kCGBlendModeExclusion;
+	fg_pixel = 0xffffffff;
+	bg_pixel = 0xffffffff;
+	break;
+
+      case GDK_CLEAR:
+      case GDK_AND:
+      case GDK_AND_REVERSE:
+      case GDK_AND_INVERT:
+      case GDK_NOOP:
+      case GDK_OR:
+      case GDK_EQUIV:
+      case GDK_OR_REVERSE:
+      case GDK_COPY_INVERT:
+      case GDK_OR_INVERT:
+      case GDK_NAND:
+      case GDK_NOR:
+      case GDK_SET:
+	blend_mode = kCGBlendModeNormal; /* FIXME */
+	break;
+      }
+
+    CGContextSetBlendMode (context, blend_mode);
+  }
+
+  /* FIXME: implement subwindow mode */
+
+  /* FIXME: implement graphics exposures */
+
+  if (mask & GDK_QUARTZ_CONTEXT_STROKE)
+    {
+      CGLineCap  line_cap  = kCGLineCapButt;
+      CGLineJoin line_join = kCGLineJoinMiter;
+      CGColorRef color;
+
+      color = _gdk_quartz_colormap_get_cgcolor_from_pixel (drawable,
+                                                           fg_pixel);
+      CGContextSetStrokeColorWithColor (context, color);
+      CGColorRelease (color);
+
+      CGContextSetLineWidth (context, MAX (G_MINFLOAT, private->line_width));
+
+      switch (private->line_style)
+	{
+	case GDK_LINE_SOLID:
+	  CGContextSetLineDash (context, 0.0, NULL, 0);
+	  break;
+
+	case GDK_LINE_DOUBLE_DASH:
+	  /* FIXME: Implement; for now, fall back to GDK_LINE_ON_OFF_DASH */
+
+	case GDK_LINE_ON_OFF_DASH:
+	  CGContextSetLineDash (context, private->dash_phase,
+				private->dash_lengths, private->dash_count);
+	  break;
+	}
+
+      switch (private->cap_style)
+        {
+	case GDK_CAP_NOT_LAST:
+	  /* FIXME: Implement; for now, fall back to GDK_CAP_BUTT */
+	case GDK_CAP_BUTT:
+	  line_cap = kCGLineCapButt;
+	  break;
+	case GDK_CAP_ROUND:
+	  line_cap = kCGLineCapRound;
+	  break;
+	case GDK_CAP_PROJECTING:
+	  line_cap = kCGLineCapSquare;
+	  break;
+	}
+
+      CGContextSetLineCap (context, line_cap);
+
+      switch (private->join_style)
+        {
+	case GDK_JOIN_MITER:
+	  line_join = kCGLineJoinMiter;
+	  break;
+	case GDK_JOIN_ROUND:
+	  line_join = kCGLineJoinRound;
+	  break;
+	case GDK_JOIN_BEVEL:
+	  line_join = kCGLineJoinBevel;
+	  break;
+	}
+
+      CGContextSetLineJoin (context, line_join);
+    }
+
+  if (mask & GDK_QUARTZ_CONTEXT_FILL)
+    {
+      GdkFill         fill = _gdk_gc_get_fill (gc);
+      CGColorSpaceRef baseSpace;
+      CGColorSpaceRef patternSpace;
+      CGFloat         alpha     = 1.0;
+
+      if (fill == GDK_SOLID)
+	{
+          CGColorRef color;
+
+	  color = _gdk_quartz_colormap_get_cgcolor_from_pixel (drawable,
+                                                               fg_pixel);
+	  CGContextSetFillColorWithColor (context, color);
+          CGColorRelease (color);
+	}
+      else
+	{
+	  if (!private->ts_pattern)
+	    {
+	      CGImageRef pattern_image = NULL;
+	      gfloat     width, height;
+	      gboolean   is_colored = FALSE;
+	      CGPatternCallbacks callbacks =  { 0, NULL, NULL };
+              struct PatternCallbackInfo *info;
+	      CGPoint    phase;
+
+              info = g_new (struct PatternCallbackInfo, 1);
+              /* Won't ref to avoid circular dependencies */
+              info->drawable = drawable;
+              info->private_gc = private;
+
+              callbacks.releaseInfo = pattern_callback_info_release;
+
+	      switch (fill)
+		{
+		case GDK_TILED:
+		  pattern_image = GDK_PIXMAP_IMPL_QUARTZ (GDK_PIXMAP_OBJECT (_gdk_gc_get_tile (gc))->impl)->image;
+		  is_colored = TRUE;
+		  callbacks.drawPattern = gdk_quartz_draw_tiled_pattern;
+		  break;
+		case GDK_STIPPLED:
+		  pattern_image = GDK_PIXMAP_IMPL_QUARTZ (GDK_PIXMAP_OBJECT (_gdk_gc_get_stipple (gc))->impl)->image;
+		  is_colored = FALSE;
+		  callbacks.drawPattern = gdk_quartz_draw_stippled_pattern;
+		  break;
+		case GDK_OPAQUE_STIPPLED:
+		  pattern_image = GDK_PIXMAP_IMPL_QUARTZ (GDK_PIXMAP_OBJECT (_gdk_gc_get_stipple (gc))->impl)->image;
+		  is_colored = TRUE;
+		  callbacks.drawPattern = gdk_quartz_draw_opaque_stippled_pattern;
+		  break;
+		default:
+		  break;
+		}
+
+	      width  = CGImageGetWidth (pattern_image);
+	      height = CGImageGetHeight (pattern_image);
+
+	      phase = CGPointApplyAffineTransform (CGPointMake (gc->ts_x_origin, gc->ts_y_origin), CGContextGetCTM (context));
+	      CGContextSetPatternPhase (context, CGSizeMake (phase.x, phase.y));
+
+	      private->ts_pattern = CGPatternCreate (info,
+						     CGRectMake (0, 0, width, height),
+						     CGAffineTransformIdentity,
+						     width, height,
+						     kCGPatternTilingConstantSpacing,
+						     is_colored,
+						     &callbacks);
+	    }
+
+	  baseSpace = (fill == GDK_STIPPLED) ? CGColorSpaceCreateWithName (kCGColorSpaceGenericRGB) : NULL;
+	  patternSpace = CGColorSpaceCreatePattern (baseSpace);
+
+	  CGContextSetFillColorSpace (context, patternSpace);
+	  CGColorSpaceRelease (patternSpace);
+	  CGColorSpaceRelease (baseSpace);
+
+	  if (fill == GDK_STIPPLED)
+            {
+              CGColorRef color;
+              const CGFloat *components;
+
+              color = _gdk_quartz_colormap_get_cgcolor_from_pixel (drawable,
+                                                                   fg_pixel);
+              components = CGColorGetComponents (color);
+
+              CGContextSetFillPattern (context, private->ts_pattern,
+                                       components);
+              CGColorRelease (color);
+            }
+          else
+            CGContextSetFillPattern (context, private->ts_pattern, &alpha);
+       }
+    }
+
+  if (mask & GDK_QUARTZ_CONTEXT_TEXT)
+    {
+      /* FIXME: implement text */
+    }
+
+  if (GDK_IS_WINDOW_IMPL_QUARTZ (drawable))
+      private->is_window = TRUE;
+  else
+      private->is_window = FALSE;
+}

gdk/quartz/gdkgeometry-quartz.c

@@ -23,47 +23,33 @@
 #include "gdkprivate-quartz.h"
 
 void
-_gdk_quartz_window_translate (GdkWindow      *window,
-                              cairo_region_t *area,
-                              gint            dx,
-                              gint            dy)
+_gdk_quartz_window_queue_translation (GdkWindow *window,
+				      GdkGC     *gc,
+                                      cairo_region_t *area,
+                                      gint       dx,
+                                      gint       dy)
 {
-  cairo_region_t *invalidate, *scrolled;
   GdkWindowObject *private = (GdkWindowObject *)window;
   GdkWindowImplQuartz *impl = (GdkWindowImplQuartz *)private->impl;
-  GdkRectangle extents;
 
-  cairo_region_get_extents (area, &extents);
+  int i, n_rects;
+  cairo_region_t *intersection;
+  GdkRectangle rect;
 
-  [impl->view scrollRect:NSMakeRect (extents.x - dx, extents.y - dy,
-                                     extents.width, extents.height)
-              by:NSMakeSize (dx, dy)];
+  /* We will intersect the known region that needs display with the given
+   * area.  This intersection will be translated by dx, dy.  For the end
+   * result, we will also set that it needs display.
+   */
 
-  if (impl->needs_display_region)
-    {
-      cairo_region_t *intersection;
+  if (!impl->needs_display_region)
+    return;
 
-      /* Invalidate already invalidated area that was moved at new
-       * location.
-       */
-      intersection = cairo_region_copy (impl->needs_display_region);
-      cairo_region_intersect (intersection, area);
-      cairo_region_translate (intersection, dx, dy);
+  intersection = cairo_region_copy (impl->needs_display_region);
+  cairo_region_intersect (intersection, area);
+  cairo_region_translate (intersection, dx, dy);
 
-      _gdk_quartz_window_set_needs_display_in_region (window, intersection);
-      cairo_region_destroy (intersection);
-    }
-
-  /* Calculate newly exposed area that needs invalidation */
-  scrolled = cairo_region_copy (area);
-  cairo_region_translate (scrolled, dx, dy);
-
-  invalidate = cairo_region_copy (area);
-  cairo_region_subtract (invalidate, scrolled);
-  cairo_region_destroy (scrolled);
-
-  _gdk_quartz_window_set_needs_display_in_region (window, invalidate);
-  cairo_region_destroy (invalidate);
+  _gdk_quartz_window_set_needs_display_in_region (window, intersection);
+  cairo_region_destroy (intersection);
 }
 
 gboolean

gdk/quartz/gdkimage-quartz.c

@@ -0,0 +1,301 @@
+/* gdkimage-quartz.c
+ *
+ * Copyright (C) 2005 Imendio AB
+ *
+ * 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.
+ */
+
+#include "config.h"
+
+#include "gdk.h"
+#include "gdkimage.h"
+#include "gdkprivate-quartz.h"
+
+static GObjectClass *parent_class;
+
+GdkImage *
+_gdk_quartz_image_copy_to_image (GdkDrawable *drawable,
+				 GdkImage    *image,
+				 gint         src_x,
+				 gint         src_y,
+				 gint         dest_x,
+				 gint         dest_y,
+				 gint         width,
+				 gint         height)
+{
+  GdkScreen *screen;
+  
+  g_return_val_if_fail (GDK_IS_DRAWABLE_IMPL_QUARTZ (drawable), NULL);
+  g_return_val_if_fail (image != NULL || (dest_x == 0 && dest_y == 0), NULL);
+
+  screen = gdk_drawable_get_screen (drawable);
+  if (!image)
+    image = _gdk_image_new_for_depth (screen, GDK_IMAGE_FASTEST, NULL, 
+				      width, height,
+				      gdk_drawable_get_depth (drawable));
+  
+  if (GDK_IS_PIXMAP_IMPL_QUARTZ (drawable))
+    {
+      GdkPixmapImplQuartz *pix_impl;
+      gint bytes_per_row;
+      guchar *data;
+      int x, y;
+
+      pix_impl = GDK_PIXMAP_IMPL_QUARTZ (drawable);
+      data = (guchar *)(pix_impl->data);
+
+      if (src_x + width > pix_impl->width || src_y + height > pix_impl->height)
+      	{
+          g_warning ("Out of bounds copy-area for pixmap -> image conversion\n");
+          return image;
+        }
+
+      switch (gdk_drawable_get_depth (drawable))
+        {
+        case 24:
+          bytes_per_row = pix_impl->width * 4;
+          for (y = 0; y < height; y++)
+            {
+              guchar *src = data + ((y + src_y) * bytes_per_row) + (src_x * 4);
+
+              for (x = 0; x < width; x++)
+                {
+                  gint32 pixel;
+	  
+                  /* RGB24, 4 bytes per pixel, skip first. */
+                  pixel = src[0] << 16 | src[1] << 8 | src[2];
+                  src += 4;
+
+                  gdk_image_put_pixel (image, dest_x + x, dest_y + y, pixel);
+                }
+            }
+          break;
+
+        case 32:
+          bytes_per_row = pix_impl->width * 4;
+          for (y = 0; y < height; y++)
+            {
+              guchar *src = data + ((y + src_y) * bytes_per_row) + (src_x * 4);
+
+              for (x = 0; x < width; x++)
+                {
+                  gint32 pixel;
+	  
+                  /* ARGB32, 4 bytes per pixel. */
+                  pixel = src[0] << 24 | src[1] << 16 | src[2] << 8 | src[3];
+                  src += 4;
+
+                  gdk_image_put_pixel (image, dest_x + x, dest_y + y, pixel);
+                }
+            }
+          break;
+
+        case 1: /* TODO: optimize */
+          bytes_per_row = pix_impl->width;
+          for (y = 0; y < height; y++)
+            {
+              guchar *src = data + ((y + src_y) * bytes_per_row) + src_x;
+
+              for (x = 0; x < width; x++)
+                {
+                  gint32 pixel;
+	  
+                  /* 8 bits */
+                  pixel = src[0];
+                  src++;
+
+                  gdk_image_put_pixel (image, dest_x + x, dest_y + y, pixel);
+                }
+            }
+          break;
+
+        default:
+          g_warning ("Unsupported bit depth %d\n", gdk_drawable_get_depth (drawable));
+          return image;
+        }
+    }
+  else if (GDK_IS_WINDOW_IMPL_QUARTZ (drawable))
+    {
+      GdkQuartzView *view;
+      NSBitmapImageRep *rep;
+      NSRect rect;
+      guchar *data;
+      int x, y;
+      NSSize size;
+
+      view = GDK_WINDOW_IMPL_QUARTZ (drawable)->view;
+
+      /* We return the image even if we can't copy to it. */
+      if (![view lockFocusIfCanDraw])
+        return image;
+
+      rect = NSMakeRect (src_x, src_y, width, height);
+
+      rep = [[NSBitmapImageRep alloc] initWithFocusedViewRect: rect];
+      [view unlockFocus];
+	  
+      data = [rep bitmapData];
+      size = [rep size];
+
+      for (y = 0; y < size.height; y++)
+	{
+	  guchar *src = data + y * [rep bytesPerRow];
+
+	  for (x = 0; x < size.width; x++)
+	    {
+	      gint32 pixel;
+
+	      if (image->byte_order == GDK_LSB_FIRST)
+		pixel = src[0] << 8 | src[1] << 16 |src[2] << 24;
+	      else
+		pixel = src[0] << 16 | src[1] << 8 |src[2];
+
+	      src += 3;
+
+	      gdk_image_put_pixel (image, dest_x + x, dest_y + y, pixel);
+	    }
+	}
+
+      [rep release];
+    }
+
+  return image;
+}
+
+static void
+gdk_image_finalize (GObject *object)
+{
+  GdkImage *image = GDK_IMAGE (object);
+
+  g_free (image->mem);
+
+  G_OBJECT_CLASS (parent_class)->finalize (object);
+}
+
+static void
+gdk_image_class_init (GdkImageClass *klass)
+{
+  GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+  parent_class = g_type_class_peek_parent (klass);
+  
+  object_class->finalize = gdk_image_finalize;
+}
+
+GType
+gdk_image_get_type (void)
+{
+  static GType object_type = 0;
+
+  if (!object_type)
+    {
+      const GTypeInfo object_info =
+      {
+        sizeof (GdkImageClass),
+        (GBaseInitFunc) NULL,
+        (GBaseFinalizeFunc) NULL,
+        (GClassInitFunc) gdk_image_class_init,
+        NULL,           /* class_finalize */
+        NULL,           /* class_data */
+        sizeof (GdkImage),
+        0,              /* n_preallocs */
+        (GInstanceInitFunc) NULL,
+      };
+      
+      object_type = g_type_register_static (G_TYPE_OBJECT,
+                                            "GdkImage",
+                                            &object_info,
+					    0);
+    }
+  
+  return object_type;
+}
+
+GdkImage*
+_gdk_image_new_for_depth (GdkScreen    *screen,
+			  GdkImageType  type,
+			  GdkVisual    *visual,
+			  gint          width,
+			  gint          height,
+			  gint          depth)
+{
+  GdkImage *image;
+
+  if (visual)
+    depth = visual->depth;
+
+  g_assert (depth == 24 || depth == 32);
+
+  image = g_object_new (gdk_image_get_type (), NULL);
+  image->type = type;
+  image->visual = visual;
+  image->width = width;
+  image->height = height;
+  image->depth = depth;
+
+  image->byte_order = (G_BYTE_ORDER == G_LITTLE_ENDIAN) ? GDK_LSB_FIRST : GDK_MSB_FIRST;
+
+  /* We only support images with bpp 4 */
+  image->bpp = 4;
+  image->bpl = image->width * image->bpp;
+  image->bits_per_pixel = image->bpp * 8;
+  
+  image->mem = g_malloc (image->bpl * image->height);
+  memset (image->mem, 0x00, image->bpl * image->height);
+
+  return image;
+}
+
+guint32
+gdk_image_get_pixel (GdkImage *image,
+		     gint x,
+		     gint y)
+{
+  guchar *ptr;
+
+  g_return_val_if_fail (image != NULL, 0);
+  g_return_val_if_fail (x >= 0 && x < image->width, 0);
+  g_return_val_if_fail (y >= 0 && y < image->height, 0);
+
+  ptr = image->mem + y * image->bpl + x * image->bpp;
+
+  return *(guint32 *)ptr;
+}
+
+void
+gdk_image_put_pixel (GdkImage *image,
+		     gint x,
+		     gint y,
+		     guint32 pixel)
+{
+  guchar *ptr;
+
+  ptr = image->mem + y * image->bpl + x * image->bpp;
+
+  *(guint32 *)ptr = pixel;
+}
+
+gint
+_gdk_windowing_get_bits_for_depth (GdkDisplay *display,
+				   gint        depth)
+{
+  if (depth == 24 || depth == 32)
+    return 32;
+  else
+    g_assert_not_reached ();
+
+  return 0;
+}