0.8 - Federico

2000-05-21  Nils Barth  <nils_barth@post.harvard.edu>

	* Spelling/grammar fixes in comments.

INSTALL

@@ -7,8 +7,8 @@ you got this package.
 Simple install procedure
 ========================
 
-  % gzip -cd gtk+-1.3.0.tar.gz | tar xvf - # unpack the sources
-  % cd gtk+-1.3.0			   # change to the toplevel directory
+  % gzip -cd gtk+-1.2.7.tar.gz | tar xvf - # unpack the sources
+  % cd gtk+-1.2.7			   # change to the toplevel directory
   % ./configure				   # run the `configure' script
   % make				   # build GTK
   [ Become root if necessary ]
@@ -118,7 +118,7 @@ You can compile GTK+ against a copy of GLIB that you have not
 yet installed. To do this, give the --with-glib=DIR options
 to ./configure. For instance:
 
- ./configure --with-glib=../glib-1.3.0
+ ./configure --with-glib=../glib-1.2.7
 
 This, however, will not work if you built GLIB with different
 source and build directories.
@@ -169,7 +169,7 @@ C library multibyte functions. Unless your C library has support
 for Japanese locales, this is incorrect, and will cause problems
 for GTK's internationalization.
 
-(In particular, this occurs with GNU libc 2.0 in which
+(In particular, this occurs with GNU libc 2.0 and 2.1, in which
 the multibyte functions always translate to and from UTF-8; but
 the problem may occur for other C libraries, and other operating
 systems as well.)

README

@@ -1,7 +1,7 @@
 General Information
 ===================
 
-This is GTK+ version 1.3.0. GTK+, which stands for the Gimp ToolKit, 
+This is GTK+ version 1.2.7.   GTK+, which stands for the Gimp ToolKit, 
 is a library for creating graphical user interfaces for the X Window 
 System. It is designed to be small, efficient, and flexible. GTK+ is 
 written in C with a very object-oriented approach.
@@ -37,9 +37,9 @@ version number. This should be separated by a blank
 line from the actual headers.
 
  Package: gtk+
- Version: 1.3.0
+ Version: 1.2.7
 
-[ Please substitute 1.3.0 with the version of GTK+ that
+[ Please substitute 1.2.7 with the version of GTK+ that
   you have installed ]
 
 Then describe the bug. Include:
@@ -82,7 +82,7 @@ From: yourname@your.address.org
 Subject: handlebox test in testgtk is misnamed.
 
 Package: gtk+
-Version: 1.3.0
+Version: 1.2.7
 
 When I run gtk/testgtk, the button "handle box"
 is misnamed. There are multiple handle boxes in

README.nanox

@@ -0,0 +1,154 @@
+Gtk port to nano-X
+
+STATUS
+
+Once upon a time I got a few apps working, then started merging
+the new features added by Owen (32 bit sizes for windows and buffering).
+Since then I haven't found the time to work on it:-/
+
+
+TODO
+
+Finish internal window manager abstraction or add proper support in nano-X.
+Fix event polling.
+Implement GdkImage, GdkRgb stuff.
+Put generic region code in generic gdk and/or use the region code from nano-X.
+Fix ugly automake stuff for make dist.
+
+TODO in nano-X
+
+We need to be able to clip and change the background of windows at runtime
+for apps to not look so ugly!
+Fonts: wait for better nano-X font implementation.
+Properties on windows.
+
+
+If you want to work on this port or get additional informnation, get in 
+touch with me.
+To get the beast to compile you also need to apply the patch below
+(any auto* wizard here?): the issue of having two gtk libraries in the
+system needs to be addressed too, maybe use libgtk-x11-1.4.so and 
+libgtk-nanox-1.4.so ...
+
+Paolo Molaro
+lupus@linuxcare.com
+
+
+Index: acconfig.h
+===================================================================
+RCS file: /cvs/gnome/gtk+/acconfig.h,v
+retrieving revision 1.16
+diff -u -r1.16 acconfig.h
+--- acconfig.h	1999/03/20 00:52:29	1.16
++++ acconfig.h	2000/05/06 11:52:38
+@@ -49,6 +49,8 @@
+ /* Most machines will be happy with int or void.  IRIX requires '...' */
+ #undef SIGNAL_ARG_TYPE
+ 
++#undef USE_NANOX
++
+ /* #undef PACKAGE */
+ /* #undef VERSION */
+ 
+Index: configure.in
+===================================================================
+RCS file: /cvs/gnome/gtk+/configure.in,v
+retrieving revision 1.142
+diff -u -r1.142 configure.in
+--- configure.in	2000/05/04 00:29:46	1.142
++++ configure.in	2000/05/06 11:52:38
+@@ -99,6 +99,8 @@
+ AC_ARG_WITH(locale, [  --with-locale=LOCALE    locale name you want to use ])
+ 
+ AC_ARG_WITH(xinput, [  --with-xinput=[no/gxi/xfree] support XInput ])
++AC_ARG_ENABLE(nanox, [  --enable-nanox            use nano-X instead of X11 [default=no]],
++			, enable_nanox="no")
+ 
+ if test "x$enable_debug" = "xyes"; then
+   test "$cflags_set" = set || CFLAGS="$CFLAGS -g"
+@@ -322,6 +324,8 @@
+ saved_cflags="$CFLAGS"
+ saved_ldflags="$LDFLAGS"
+ 
++if text "x$enable_nanox" = "xno"; then
++
+ CFLAGS="$CFLAGS $X_CFLAGS"
+ LDFLAGS="$LDFLAGS $X_LDFLAGS $X_LIBS"
+ 
+@@ -465,6 +469,13 @@
+   GTK_LOCALE_FLAGS="-DX_LOCALE"
+ fi
+ 
++else
++AC_CHECK_LIB(nano-X, GrOpen)
++LIBS="-lnano-X $LIBS"
++ AC_DEFINE(USE_NANOX)
++AM_CONDITIONAL(USE_NANOX, test x$enable_nanox = xyes)
++fi # if enable_nanox
++
+ # Checks for header files.
+ AC_HEADER_STDC
+ 
+@@ -602,8 +613,13 @@
+ esac
+ ],[
+ # Currently we always use X11 on those systems where we run configure...
++if test x$enable_nanox = xno; then
+ gdk_windowing='
+ #define GDK_WINDOWING_X11'
++else
++gdk_windowing='
++#define GDK_WINDOWING_NANOX'
++fi
+ if test x$gdk_wchar_h = xyes; then
+   gdk_wc='
+ #define GDK_HAVE_WCHAR_H 1'
+@@ -629,6 +645,7 @@
+ docs/Makefile
+ gdk/Makefile
+ gdk/x11/Makefile
++gdk/nanox/Makefile
+ gdk/win32/Makefile
+ gtk/Makefile
+ gtk/gtkfeatures.h
+Index: gdk/Makefile.am
+===================================================================
+RCS file: /cvs/gnome/gtk+/gdk/Makefile.am,v
+retrieving revision 1.41
+diff -u -r1.41 Makefile.am
+--- gdk/Makefile.am	2000/04/05 04:11:10	1.41
++++ gdk/Makefile.am	2000/05/06 11:52:38
+@@ -1,6 +1,10 @@
+ ## Makefile.am for gtk+/gdk
+ 
++if USE_NANOX
++SUBDIRS=win32 nanox
++else
+ SUBDIRS=x11 win32
++endif
+ 
+ EXTRA_DIST =	\
+ 	gdkconfig.h.win32 \
+@@ -36,8 +40,13 @@
+ 	-lm		\
+ @STRIP_END@
+ 
++if USE_NANOX
+ libgdk_la_LIBADD = \
++	nanox/libgdk-nanox.la	
++else
++libgdk_la_LIBADD = \
+ 	x11/libgdk-x11.la	
++endif
+ 
+ #
+ # setup source file variables
+@@ -138,3 +147,8 @@
+ 	@files=`ls $(DISTFILES) 2> /dev/null `; for p in $$files; do \
+ 	  echo $$p; \
+ 	done
++
++noinst_PROGRAMS = simple
++simple_DEPENDENCIES = libgdk.la simple.c
++simple_LDADD = libgdk.la
++

README.win32

@@ -3,10 +3,18 @@ correct as the Unix/X11 version. For more information about the Win32
 port, see http://www.gimp.org/tml/gimp/win32/ or
 http://www.iki.fi/tml/gimp/win32/ .
 
+The current (CVS) version of the Win32 backend is *not* as stable as it
+was before the no-flicker branch was merged. A zipfile with that
+version is available from http://www.gimp.org/win32/. That should be
+use by "production" code until this CVS version is usable. (But note,
+the Win32 backend has never been claimed to be "production quality".)
+
 To build GTk+ on Win32, you need either the Microsoft compiler and
-tools, or gcc-2.95 or later running under cygwin-b20.1 or
-later. Compile in gdk\win32, gdk and gtk with `nmake -f makefile.msc` or
-`make -f makefile.cygwin`.
+tools, or gcc-2.95 or later. The mingw setup of gcc is preferred, but
+you can run gcc also under cygwin-b20.1 or later. Compile in
+gdk\win32, gdk and gtk with `nmake -f makefile.msc` or `make -f
+makefile.cygwin`. The name makefile.cygwin is misleading, it should
+really be called makefile.mingw.
 
 See the README.win32 file in the GLib distribution for instructions
 how to build with gcc.
@@ -32,6 +40,6 @@ config.h.win32 file, and remove references to the gnu-intl library
 from the makefiles.
 
 Note that while the GNU gettext package is under the GPL, the "intl"
-part of it as distributed with GNU libc is under the LGPL (like GTk+
-or GLib). We want the LGPL one, even if they are the same, more or
-less.
+part of it which is distributed with GNU libc is under the LGPL (like
+GTk+ or GLib). We want the LGPL one, even if they are the same, more
+or less.

TODO.xml

@@ -69,11 +69,24 @@
 	  customizable
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
       <bugs>#3958</bugs>
     </entry>
 
-
+    <entry size="small" status="0%" target="1.4">
+      <title>Make color handling more convenient</title>
+      <description>
+	<p>
+          Add some color convenience functions; such as a way to get an
+          allocated GdkColor from GdkRGB, and export functions from gtkstyle.c
+          that lighten/darken a given color, and set a color from HSV in
+          addition to RGB. Also, consider having static variables that contain
+          preallocated common colors (gdk_blue, gdk_red, etc.), the problem
+          being colormap issues.
+	</p>
+      </description>
+      <contact>gtk-devel-list@gnome.org</contact>
+    </entry>
 
     <entry size="small" status="0%" target="1.4">
       <title>Cursors</title>
@@ -89,7 +102,7 @@
           looking at for this task.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="medium" status="0%" target="1.4">
@@ -102,7 +115,7 @@
           friends, though.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
   </section> <!-- GDK -->
@@ -110,7 +123,7 @@
   <section>
     <title>Internationalization</title>
     
-    <entry size="big" status="0%" target="1.4">
+    <entry size="big" status="70%" target="1.4">
       <title>Integrate Pango</title>
       <description>
 	<p>
@@ -123,7 +136,7 @@
       <contact>gtk-i18n-list@redhat.com</contact>
     </entry>
 
-    <entry size="medium" status="20%" target="1.4">
+    <entry size="medium" status="80%" target="1.4">
       <title>Switch to using UTF-8</title>
       <description>
 	<p>
@@ -145,11 +158,11 @@
       <contact>gtk-i18n-list@redhat.com</contact>
     </entry>
 
-    <entry size="big" status="0%" target="1.4">
+    <entry size="big" status="40%" target="1.4">
       <title>Rewrite Input Method Support</title>
       <description>
 	<p>
-	  Current support for Input Methods is done via XIM, with
+	  Support for Input Methods is GTK+-1.2 is done via XIM, with
 	  supported styles being over-the-spot and the root-window
 	  styles. However, the over-the-spot style is not going to
 	  work well with the Pango integration, since it relies on the
@@ -159,8 +172,9 @@
 	  set of callbacks that are invoked by the input methods.
 	</p>
 	<p>
-	  While adding the above support, it may be desirable to
-	  generalize the input-method support to the point where 
+	  GTK+-1.4 will have a new system with loadable input method
+	  modules. These modules can either be implemented using XIM,
+	  or written from scratch.
 	</p>
       </description>
       <contact>gtk-i18n-list@redhat.com</contact>
@@ -196,7 +210,7 @@
 	  "GLib based object and type system").
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="big" status="0%" target="1.4">
@@ -283,25 +297,10 @@
 	  code (especially on AIX).
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
 
-    <entry size="small" status="0%" target="1.4">
-      <title>Make color handling more convenient</title>
-      <description>
-	<p>
-          Add some color convenience functions; such as a way to get an
-          allocated GdkColor from GdkRGB, and export functions from gtkstyle.c
-          that lighten/darken a given color, and set a color from HSV in
-          addition to RGB. Also, consider having static variables that contain
-          preallocated common colors (gtk_blue, gtk_red, etc.), the problem
-          being colormap issues.
-	</p>
-      </description>
-      <contact>gtk-devel-list@redhat.com</contact>
-    </entry>
-
     <entry size="small" status="0%" target="1.4">
       <title>Convenient widget setup</title>
       <description>
@@ -320,7 +319,7 @@
         </p>
 
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="medium" status="0%" target="> 1.4">
@@ -331,7 +330,7 @@
           Consider a GtkClipboard object to simplify cut-and-paste handling.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
 
@@ -357,7 +356,7 @@
           GTK+ API for this.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="big" status="0%" target="> 1.4">
@@ -371,7 +370,7 @@
           help browser gizmo into GTK.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
 
@@ -383,7 +382,7 @@
           blink, etc., from a control panel type of deal.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
   </section> <!-- Core -->
@@ -391,7 +390,7 @@
   <section>
     <title>GTK+ Widgets</title>
 
-    <entry size="small" status="0%" target="1.4">
+    <entry size="small" status="50%" target="1.4">
       <title>Make GtkFrame use a label</title>
       <description>
 	<p>
@@ -403,28 +402,28 @@
 	  in that slot.)
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
-    <entry size="big" status="50%" target="1.4">
+    <entry size="big" status="75%" target="1.4">
       <title>Replace GtkText Widget</title>
       <description>
 	<p>
-	  The GtkText widget is badly in need of replacement, since it is
-	  buggy and insufficiently feature rich. There are a number
-	  of possible candidates for a replacement, with the most
-	  promising at the current time being Havoc Pennington's
-	  (hp@redhat.com) port of the Tk Text widget.
+	  The GtkText widget is badly in need of replacement, since it
+	  is buggy and insufficiently feature rich. This is being done
+	  using Havoc Pennington's port of the Tk Text widget.
 	</p>
 	<p>
-	  As part of this job it will be necessary to add
-	  <a href="http://www.pango.org">Pango</a> support to the
-	  replacement. The structure of the Tk text widget port seems
-	  suited to this as it works paragraph-by-paragraph, and
-	  Pango works at a sub-paragraph scale.
+	  As part of this job <a href="http://www.pango.org">Pango</a>
+	  support is being added to the replacement. The structure of
+	  the Tk text widget port is suited to this as it works
+	  paragraph-by-paragraph, and Pango works at a sub-paragraph
+	  scale. The main remaining tasks here are to implement
+	  incremental reflow to make performance acceptable and to
+	  implement embedded pixmaps and widgets.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="small" status="0%" target="1.4">
@@ -439,7 +438,7 @@
 	  will fit in with well with the rest of the GTK+ look.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="small" status="0%" target="1.4">
@@ -455,7 +454,7 @@
 	  side of the submenu.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="small" status="0%" target="1.4 ?">
@@ -476,7 +475,7 @@
 	  windowing systems.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="big" status="90%" target="1.4">
@@ -527,7 +526,7 @@
 	  both the simplicity and power of the interfaces.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="small" status="0%" target="1.4">
@@ -551,7 +550,7 @@
           don't have to use gtk_statusbar_get_context_id().
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
     
     <entry size="small" status="95%" target="1.4">
@@ -584,7 +583,7 @@
           see GtkSpinButton where these are already implemented.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="big" status="0%" target="> 1.4">
@@ -605,7 +604,7 @@
           (Havoc has a proposed interface for this, mail hp@redhat.com)
         </p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="medium" status="0%" target="> 1.4">
@@ -616,7 +615,7 @@
           the like.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="medium" status="0%" target="> 1.4">
@@ -629,7 +628,7 @@
           saving the current positions of the various docked bars.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="big" status="0%" target="> 1.4">
@@ -639,7 +638,7 @@
           Figure out how to get GnomeCanvas or a derived work into GTK+ itself.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="medium" status="0%" target="1.4">
@@ -650,7 +649,7 @@
           as on the Mac.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="medium" status="0%" target="1.4">
@@ -661,7 +660,7 @@
           wrapping or drop-down deal. (See Windows/Mac apps for examples.)
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="small" status="0%" target="1.4">
@@ -675,17 +674,17 @@
       <contact>otaylor@redhat.com</contact>
     </entry>
 
-    <entry size="small" status="0%" target="1.4">
+    <entry size="small" status="100%" target="1.4">
       <title>Don't highlight first menu item when menus come up</title>
       <description>
 	<p>
           Keep GtkMenu from prelighting the first menu item.
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
-    <entry size="small" status="0%" target="1.4">
+    <entry size="small" status="95%" target="1.4">
       <title>Integrate new color selector</title>
       <description>
 	<p>
@@ -695,7 +694,7 @@
           still called GtkColorSelector).
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
     <entry size="medium" status="0%" target="1.4">
@@ -708,7 +707,31 @@
           it makes sense (like gnome-terminal probably).
 	</p>
       </description>
-      <contact>gtk-devel-list@redhat.com</contact>
+      <contact>gtk-devel-list@gnome.org</contact>
+    </entry>
+
+    <entry size="small" status="0%" target="1.4">
+      <title>Stack Widget</title>
+      <description>
+	<p>
+          Jonathan has a widget like a tabless/frameless notebook, used for
+          something like the GNOME control center where you want to toggle which
+          widget is visible to the user. Needs to be cleaned up and considered
+          for GTK.
+	</p>
+      </description>
+      <contact>gtk-devel-list@gnome.org, jrb@redhat.com</contact>
+    </entry>
+
+    <entry size="small" status="0%" target="1.4">
+      <title>Clean up GtkNotebook</title>
+      <description>
+	<p>
+          GtkNotebook currently breaks GTK invariants about
+          mapping/visibility/etc., needs fixing.
+	</p>
+      </description>
+      <contact>gtk-devel-list@gnome.org</contact>
     </entry>
 
   </section> <!-- GTK+ -->

configure.in

@@ -171,17 +171,19 @@ AC_MSG_CHECKING(whether make is GNU Make)
 STRIP_BEGIN=
 STRIP_END=
 if $ac_make --version 2>/dev/null | grep '^GNU Make ' >/dev/null ; then
-	STRIP_BEGIN='$(strip'
+	STRIP_BEGIN='$(strip $(STRIP_DUMMY)'
 	STRIP_END=')'
 	AC_MSG_RESULT(yes)
 else
 	AC_MSG_RESULT(no)
 fi
+STRIP_DUMMY=
+AC_SUBST(STRIP_DUMMY)
 AC_SUBST(STRIP_BEGIN)
 AC_SUBST(STRIP_END)
 
 # i18n stuff
-ALL_LINGUAS="ca cs da de el es et eu fi fr ga gl hr hu it ja ko lt nl no pl pt pt_BR ru sk sl sv tr uk wa zh_TW.Big5 zh_CN.GB2312"
+ALL_LINGUAS="ca cs da de el es et eu fi fr ga gl hr hu it ja ko lt nl no pl pt pt_BR ro ru sk sl sv tr uk wa zh_TW.Big5 zh_CN.GB2312"
 AM_GTK_GNU_GETTEXT
 LIBS="$LIBS $INTLLIBS"
 
@@ -250,16 +252,16 @@ fi
 if test x$with_glib = x ; then 
   # Look for separately installed glib
 
-  AM_PATH_GLIB(1.3.0,,
+  AM_PATH_GLIB(1.3.1,,
     AC_MSG_ERROR([
 *** GLIB 1.3.0 or better is required. The latest version of GLIB
 *** is always available from ftp://ftp.gtk.org/.]),
-    gmodule gthread)
+    gobject gmodule gthread)
 
   # we do not want to make all gtk progs to link to thread libraries.
-  glib_cflags=`$GLIB_CONFIG glib gmodule --cflags`
+  glib_cflags=`$GLIB_CONFIG glib gobject gmodule --cflags`
   glib_thread_cflags="$GLIB_CFLAGS"
-  glib_libs=`$GLIB_CONFIG glib gmodule --libs`
+  glib_libs=`$GLIB_CONFIG glib gobject gmodule --libs`
   glib_thread_libs="$GLIB_LIBS"
   GLIB_LIBS="$glib_libs"
   GLIB_DEPLIBS="$glib_libs"
@@ -309,7 +311,6 @@ AC_CHECK_HEADERS(dirent.h, AC_DEFINE(HAVE_DIRENT_H))
 AC_CHECK_HEADERS(pwd.h, AC_DEFINE(HAVE_PWD_H))
 AC_CHECK_HEADERS(sys/time.h, AC_DEFINE(HAVE_SYS_TIME_H))
 
-
 # Find the X11 include and library directories
 AC_PATH_X
 AC_PATH_XTRA
@@ -396,24 +397,6 @@ fi
 x_cflags="$X_CFLAGS"
 x_ldflags="$X_LDFLAGS $X_LIBS"
 
-#
-# Check for Pango
-#
-AC_PATH_PROG(PANGO_CONFIG, pango-config, no)
-if test x$PANGO_CONFIG = xno ; then
-  AC_MSG_ERROR([*** pango-config not found])
-fi
-PANGO_CFLAGS="`pango-config --cflags pangox`"
-CFLAGS="$CFLAGS $PANGO_CFLAGS"
-PANGO_LIBS="`pango-config --libs pangox`"
-AC_SUBST(PANGO_LIBS)
-AC_SUBST(PANGO_CFLAGS)
-
-AC_CHECK_LIB(pango, pango_context_new, :, AC_MSG_ERROR([
-*** Pango not found. Pango is required to build
-*** GTK+. For more information see http://www.pango.org]), $PANGO_LIBS $x_ldflags $x_libs)
-
-
 # set up things for XInput
 
 if test "x$with_xinput" = "xgxi" || test "x$with_xinput" = "xyes"; then
@@ -637,9 +620,6 @@ fi
 
 ])
 
-AC_PATH_PROG(SGML2HTML, sgml2html, no)
-AM_CONDITIONAL(HAVE_SGML2HTML, ! test x$SGML2HTML = xno)
-
 AC_OUTPUT([
 gtk+.spec
 docs/gtk-config.1

demos/testanimation.c

@@ -0,0 +1,475 @@
+
+/* 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 Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <gtk/gtk.h>
+#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-loader.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 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 *)gtk_object_get_data(GTK_OBJECT(drawing_area), "pixbuf");
+
+	if (gdk_pixbuf_get_has_alpha (pixbuf)) {
+		gdk_draw_rgb_32_image (drawing_area->window,
+				       drawing_area->style->black_gc,
+				       event->area.x, event->area.y, 
+				       event->area.width, 
+				       event->area.height,
+				       GDK_RGB_DITHER_MAX, 
+				       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));
+	} 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)
+{
+	GdkPixbuf *pixbuf;
+    
+	pixbuf = (GdkPixbuf *)gtk_object_get_data(GTK_OBJECT(drawing_area), "pixbuf");
+
+#if 0
+	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;
+ 
+	w = gdk_pixbuf_get_width (pixbuf);
+	h = gdk_pixbuf_get_height (pixbuf);
+
+	window = gtk_widget_new (gtk_window_get_type (),
+				 "GtkObject::user_data", NULL,
+				 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
+				 "GtkWindow::title", "testrgb",
+				 "GtkWindow::allow_shrink", TRUE,
+				 NULL);
+	gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			    (GtkSignalFunc) 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_drawing_area_size (GTK_DRAWING_AREA(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);
+	
+
+	gtk_signal_connect (GTK_OBJECT(drawing_area), "expose_event",
+			    GTK_SIGNAL_FUNC(expose_func), NULL);
+	gtk_signal_connect (GTK_OBJECT(drawing_area), "configure_event",
+			    GTK_SIGNAL_FUNC (config_func), NULL);
+
+	gtk_object_set_data (GTK_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);
+	gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+				   (GtkSignalFunc) gtk_widget_destroy,
+				   GTK_OBJECT (window));
+
+	gtk_widget_show (button);
+
+	gtk_container_add (GTK_CONTAINER (window), vbox);
+	gtk_widget_show_all (vbox);
+
+	gtk_widget_show (window);
+
+        return window;
+}
+
+#if 0
+
+static gint
+update_timeout(gpointer data)
+{
+        ProgressFileStatus *status = data;
+	gboolean done;
+
+	done = TRUE;
+	if (!feof(status->imagefile)) {
+		gint nbytes;
+
+		nbytes = fread(status->buf, 1, status->readlen, 
+			       status->imagefile);
+
+		done = !gdk_pixbuf_loader_write (GDK_PIXBUF_LOADER (status->loader), status->buf, nbytes);
+			
+	}
+
+	if (done) {
+                gtk_widget_queue_draw(*status->rgbwin);
+		gdk_pixbuf_loader_close (GDK_PIXBUF_LOADER (status->loader));
+		gtk_object_destroy (GTK_OBJECT(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);
+
+        gdk_pixbuf_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;
+
+/*  	g_print ("progressive_updated_callback:\n\t%d\t%d\t%d\t%d\n", x, y, width, height); */
+
+        if (*window_loc != NULL)
+                gtk_widget_queue_draw_area(*window_loc,
+					   x, y, width, height);
+
+        return;
+}
+
+#endif
+
+static int readlen = 4096;
+
+int
+main (int argc, char **argv)
+{
+	int i;
+	int found_valid = FALSE;
+
+	GdkPixbufAnimation *animation;
+
+	gtk_init (&argc, &argv);
+
+	gdk_rgb_set_verbose (TRUE);
+
+	gdk_rgb_init ();
+
+	gtk_widget_set_default_colormap (gdk_rgb_get_cmap ());
+	gtk_widget_set_default_visual (gdk_rgb_get_visual ());
+
+	{
+		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) {
+		g_print ("USAGE:  testanimation FILE1 ...\n");
+		return 0;
+	} else {
+		for (i = 1; i < argc; i++) {
+			animation = gdk_pixbuf_animation_new_from_file (argv[i]);
+
+			if (animation) {
+				gint i = 0;
+				GList *listptr;
+				for (listptr = gdk_pixbuf_animation_get_frames (animation);
+				     listptr;
+				     listptr = listptr->next) {
+					GdkPixbufFrame *frame;
+					GdkPixbuf *pixbuf;
+					gchar *title;
+
+					frame = listptr->data;
+					pixbuf = gdk_pixbuf_frame_get_pixbuf (frame);
+
+					title = g_strdup_printf ("Frame %d", i);
+					g_print ("Frame %d  x:%d y:%d width:%d height:%d\n",
+						 i,
+						 gdk_pixbuf_frame_get_x_offset (frame),
+						 gdk_pixbuf_frame_get_y_offset (frame),
+						 gdk_pixbuf_get_width (pixbuf),
+						 gdk_pixbuf_get_height (pixbuf));
+					new_testrgb_window (pixbuf, title);
+					g_free (title);
+					i++;
+				}
+				found_valid = TRUE;
+			}
+		}
+#if 0
+                {
+                        GtkWidget* rgb_window = NULL;
+			ProgressFileStatus   status;
+			GdkPixbufLoader *pixbuf_loader;
+
+                        pixbuf_loader = gdk_pixbuf_loader_new ();
+			status.loader = pixbuf_loader;
+
+			status.rgbwin = &rgb_window;
+
+			status.buf = g_malloc (readlen);
+                        gtk_signal_connect(GTK_OBJECT(pixbuf_loader),
+                                           "area_prepared",
+                                           GTK_SIGNAL_FUNC(progressive_prepared_callback),
+                                           &rgb_window);
+
+                        gtk_signal_connect(GTK_OBJECT(pixbuf_loader),
+                                           "area_updated",
+                                           GTK_SIGNAL_FUNC(progressive_updated_callback),
+                                           &rgb_window);
+
+			
+                        status.imagefile = fopen (argv[1], "r");
+                        g_assert (status.imagefile != NULL);
+
+			status.readlen = readlen;
+
+                        status.timeout = gtk_timeout_add(100, update_timeout, &status);
+                }
+#endif
+	}
+
+	if (found_valid)
+		gtk_main ();
+
+	return 0;
+}

demos/testpixbuf-drawable.c

@@ -0,0 +1,113 @@
+#include <config.h>
+#include <gtk/gtk.h>
+#include <gdk/gdkx.h>
+#include "gdk-pixbuf.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 *) gtk_object_get_data(GTK_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 *) gtk_object_get_data(GTK_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_ROOT_PARENT();
+      new_pixbuf = gdk_pixbuf_get_from_drawable(NULL, root, NULL,
+						0, 0, 0, 0, evt->width, evt->height);
+      gtk_object_set_data(GTK_OBJECT(drawing_area), "pixbuf", new_pixbuf);
+      gdk_pixbuf_unref(pixbuf);
+   }
+
+   return FALSE;
+}
+
+int main(int argc, char **argv)
+{   
+   GdkWindow     *root;
+   GtkWidget     *window;
+   GtkWidget     *vbox;
+   GtkWidget     *drawing_area;
+   GdkPixbuf     *pixbuf;    
+   
+   gtk_init(&argc, &argv);   
+   gdk_rgb_set_verbose(TRUE);
+   gdk_rgb_init();
+
+   gtk_widget_set_default_colormap(gdk_rgb_get_cmap());
+   gtk_widget_set_default_visual(gdk_rgb_get_visual());
+
+   root = GDK_ROOT_PARENT();
+   pixbuf = gdk_pixbuf_get_from_drawable(NULL, root, NULL,
+					 0, 0, 0, 0, 150, 160);
+   
+   window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+   gtk_signal_connect(GTK_OBJECT(window), "delete_event",
+                      GTK_SIGNAL_FUNC(close_app), NULL);
+   gtk_signal_connect(GTK_OBJECT(window), "destroy",   
+                      GTK_SIGNAL_FUNC(close_app), NULL);
+   
+   vbox = gtk_vbox_new(FALSE, 0);
+   gtk_container_add(GTK_CONTAINER(window), vbox);  
+   
+   drawing_area = gtk_drawing_area_new();
+   gtk_drawing_area_size(GTK_DRAWING_AREA(drawing_area),
+                         gdk_pixbuf_get_width (pixbuf),
+                         gdk_pixbuf_get_height (pixbuf));
+   gtk_signal_connect(GTK_OBJECT(drawing_area), "expose_event",
+                      GTK_SIGNAL_FUNC(expose_cb), NULL);
+
+   gtk_signal_connect(GTK_OBJECT(drawing_area), "configure_event",
+                      GTK_SIGNAL_FUNC(configure_cb), NULL);
+   gtk_object_set_data(GTK_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-scale.c

@@ -0,0 +1,156 @@
+#include <gtk/gtk.h>
+#include "gdk-pixbuf.h"
+
+#include <stdio.h>
+
+GdkInterpType interp_type = GDK_INTERP_BILINEAR;
+int overall_alpha = 255;
+GdkPixbuf *pixbuf;
+GtkWidget *darea;
+  
+void
+set_interp_type (GtkWidget *widget, gpointer data)
+{
+  interp_type = GPOINTER_TO_UINT (data);
+  gtk_widget_queue_draw (darea);
+}
+
+void
+overall_changed_cb (GtkAdjustment *adjustment, gpointer data)
+{
+  if (adjustment->value != overall_alpha)
+    {
+      overall_alpha = adjustment->value;
+      gtk_widget_queue_draw (darea);
+    }
+}
+
+gboolean
+expose_cb (GtkWidget *widget, GdkEventExpose *event, gpointer data)
+{
+  GdkPixbuf *dest;
+
+  gdk_window_set_back_pixmap (widget->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) widget->allocation.width / gdk_pixbuf_get_width (pixbuf),
+			      (double) widget->allocation.height / gdk_pixbuf_get_height (pixbuf),
+			      interp_type, overall_alpha,
+			      event->area.x, event->area.y, 16, 0xaaaaaa, 0x555555);
+
+  gdk_pixbuf_render_to_drawable (dest, widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
+				 0, 0, event->area.x, event->area.y,
+				 event->area.width, event->area.height,
+				 GDK_RGB_DITHER_NORMAL, event->area.x, event->area.y);
+  
+  gdk_pixbuf_unref (dest);
+  
+  return TRUE;
+}
+
+int
+main(int argc, char **argv)
+{
+	GtkWidget *window, *vbox;
+	GtkWidget *menuitem, *optionmenu, *menu;
+	GtkWidget *alignment;
+	GtkWidget *hbox, *label, *hscale;
+	GtkAdjustment *adjustment;
+	GtkRequisition scratch_requisition;
+
+	gtk_init (&argc, &argv);
+	gdk_rgb_init ();
+
+	if (argc != 2) {
+		fprintf (stderr, "Usage: testpixbuf-scale FILE\n");
+		exit (1);
+	}
+
+	pixbuf = gdk_pixbuf_new_from_file (argv[1]);
+	if (!pixbuf) {
+		fprintf (stderr, "Cannot load %s\n", argv[1]);
+		exit(1);
+	}
+
+	window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+	gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			    GTK_SIGNAL_FUNC (gtk_main_quit), NULL);
+	
+	vbox = gtk_vbox_new (FALSE, 0);
+	gtk_container_add (GTK_CONTAINER (window), vbox);
+
+	menu = gtk_menu_new ();
+	
+	menuitem = gtk_menu_item_new_with_label ("NEAREST");
+	gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
+			    GTK_SIGNAL_FUNC (set_interp_type),
+			    GUINT_TO_POINTER (GDK_INTERP_NEAREST));
+	gtk_widget_show (menuitem);
+	gtk_container_add (GTK_CONTAINER (menu), menuitem);
+	
+	menuitem = gtk_menu_item_new_with_label ("BILINEAR");
+	gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
+			    GTK_SIGNAL_FUNC (set_interp_type),
+			    GUINT_TO_POINTER (GDK_INTERP_BILINEAR));
+	gtk_widget_show (menuitem);
+	gtk_container_add (GTK_CONTAINER (menu), menuitem);
+	
+	menuitem = gtk_menu_item_new_with_label ("TILES");
+	gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
+			    GTK_SIGNAL_FUNC (set_interp_type),
+			    GUINT_TO_POINTER (GDK_INTERP_TILES));
+	gtk_container_add (GTK_CONTAINER (menu), menuitem);
+
+	menuitem = gtk_menu_item_new_with_label ("HYPER");
+	gtk_signal_connect (GTK_OBJECT (menuitem), "activate",
+			    GTK_SIGNAL_FUNC (set_interp_type),
+			    GUINT_TO_POINTER (GDK_INTERP_HYPER));
+	gtk_container_add (GTK_CONTAINER (menu), menuitem);
+
+	optionmenu = gtk_option_menu_new ();
+	gtk_option_menu_set_menu (GTK_OPTION_MENU (optionmenu), menu);
+	gtk_option_menu_set_history (GTK_OPTION_MENU (optionmenu), 1);
+	
+	alignment = gtk_alignment_new (0.0, 0.0, 0.0, 0.5);
+	gtk_box_pack_start (GTK_BOX (vbox), alignment, FALSE, FALSE, 0);
+
+	hbox = gtk_hbox_new (FALSE, 4);
+	gtk_box_pack_start (GTK_BOX (vbox), hbox, FALSE, FALSE, 0);
+
+	label = gtk_label_new ("Overall Alpha:");
+	gtk_box_pack_start (GTK_BOX (hbox), label, FALSE, FALSE, 0);
+
+	adjustment = GTK_ADJUSTMENT (gtk_adjustment_new (overall_alpha, 0, 255, 1, 10, 0));
+	gtk_signal_connect (GTK_OBJECT (adjustment), "value_changed",
+			    GTK_SIGNAL_FUNC (overall_changed_cb), NULL);
+	
+	hscale = gtk_hscale_new (adjustment);
+	gtk_scale_set_digits (GTK_SCALE (hscale), 0);
+	gtk_box_pack_start (GTK_BOX (hbox), hscale, TRUE, TRUE, 0);
+
+	gtk_container_add (GTK_CONTAINER (alignment), optionmenu);
+	gtk_widget_show_all (vbox);
+
+	/* Compute the size without the drawing area, so we know how big to make the default size */
+	gtk_widget_size_request (vbox, &scratch_requisition);
+
+	darea = gtk_drawing_area_new ();
+	gtk_box_pack_start (GTK_BOX (vbox), darea, TRUE, TRUE, 0);
+
+	gtk_signal_connect (GTK_OBJECT (darea), "expose_event",
+			    GTK_SIGNAL_FUNC (expose_cb), NULL);
+
+	gtk_window_set_default_size (GTK_WINDOW (window),
+				     gdk_pixbuf_get_width (pixbuf),
+				     scratch_requisition.height + gdk_pixbuf_get_height (pixbuf));
+	
+	gtk_widget_show_all (window);
+
+	gtk_main ();
+
+	return 0;
+}

demos/testpixbuf.c

@@ -0,0 +1,587 @@
+/* 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 Library General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Library General Public License for more details.
+ *
+ * You should have received a copy of the GNU Library General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <gtk/gtk.h>
+#include "gdk-pixbuf.h"
+#include "gdk-pixbuf-loader.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 *)gtk_object_get_data(GTK_OBJECT(drawing_area), "pixbuf");
+
+	if (gdk_pixbuf_get_has_alpha (pixbuf)) {
+		gdk_draw_rgb_32_image (drawing_area->window,
+				       drawing_area->style->black_gc,
+				       event->area.x, event->area.y, 
+				       event->area.width, 
+				       event->area.height,
+				       GDK_RGB_DITHER_MAX, 
+				       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));
+	} 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)
+{
+	GdkPixbuf *pixbuf;
+    
+	pixbuf = (GdkPixbuf *)gtk_object_get_data(GTK_OBJECT(drawing_area), "pixbuf");
+
+	g_print("X:%d Y:%d\n", event->width, event->height);
+
+#if 0
+	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;
+ 
+	w = gdk_pixbuf_get_width (pixbuf);
+	h = gdk_pixbuf_get_height (pixbuf);
+
+	window = gtk_widget_new (gtk_window_get_type (),
+				 "GtkObject::user_data", NULL,
+				 "GtkWindow::type", GTK_WINDOW_TOPLEVEL,
+				 "GtkWindow::title", "testrgb",
+				 "GtkWindow::allow_shrink", TRUE,
+				 NULL);
+	gtk_signal_connect (GTK_OBJECT (window), "destroy",
+			    (GtkSignalFunc) 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_drawing_area_size (GTK_DRAWING_AREA(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);
+	
+
+	gtk_signal_connect (GTK_OBJECT(drawing_area), "expose_event",
+			    GTK_SIGNAL_FUNC(expose_func), NULL);
+	gtk_signal_connect (GTK_OBJECT(drawing_area), "configure_event",
+			    GTK_SIGNAL_FUNC (config_func), NULL);
+
+	gtk_object_set_data (GTK_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);
+	gtk_signal_connect_object (GTK_OBJECT (button), "clicked",
+				   (GtkSignalFunc) gtk_widget_destroy,
+				   GTK_OBJECT (window));
+
+	gtk_widget_show (button);
+
+	gtk_container_add (GTK_CONTAINER (window), vbox);
+	gtk_widget_show_all (vbox);
+
+	gtk_widget_show (window);
+
+        return window;
+}
+
+
+static gint
+update_timeout(gpointer data)
+{
+        ProgressFileStatus *status = data;
+	gboolean done;
+
+	done = TRUE;
+	if (!feof(status->imagefile)) {
+		gint nbytes;
+
+		nbytes = fread(status->buf, 1, status->readlen, 
+			       status->imagefile);
+
+		done = !gdk_pixbuf_loader_write (GDK_PIXBUF_LOADER (status->loader), status->buf, nbytes);
+			
+	}
+
+	if (done) {
+                gtk_widget_queue_draw(*status->rgbwin);
+		gdk_pixbuf_loader_close (GDK_PIXBUF_LOADER (status->loader));
+		gtk_object_destroy (GTK_OBJECT(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);
+
+        gdk_pixbuf_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;
+
+/*  	g_print ("progressive_updated_callback:\n\t%d\t%d\t%d\t%d\n", x, y, width, height); */
+
+        if (*window_loc != NULL)
+                gtk_widget_queue_draw_area(*window_loc,
+					   x, y, width, height);
+
+        return;
+}
+
+static int readlen = 4096;
+
+int
+main (int argc, char **argv)
+{
+	int i;
+	int found_valid = FALSE;
+
+	GdkPixbuf *pixbuf;
+	GdkPixbufLoader *pixbuf_loader;
+
+	gtk_init (&argc, &argv);
+
+	gdk_rgb_set_verbose (TRUE);
+
+	gdk_rgb_init ();
+
+	gtk_widget_set_default_colormap (gdk_rgb_get_cmap ());
+	gtk_widget_set_default_visual (gdk_rgb_get_visual ());
+
+	{
+		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;
+                
+		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;
+                }
+                
+		found_valid = TRUE;
+	} else {
+		for (i = 1; i < argc; i++) {
+
+			pixbuf = gdk_pixbuf_new_from_file (argv[i]);
+#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);
+                        gtk_signal_connect(GTK_OBJECT(pixbuf_loader),
+                                           "area_prepared",
+                                           GTK_SIGNAL_FUNC(progressive_prepared_callback),
+                                           &rgb_window);
+
+                        gtk_signal_connect(GTK_OBJECT(pixbuf_loader),
+                                           "area_updated",
+                                           GTK_SIGNAL_FUNC(progressive_updated_callback),
+                                           &rgb_window);
+
+			
+                        status.imagefile = fopen (argv[1], "r");
+                        g_assert (status.imagefile != NULL);
+
+			status.readlen = readlen;
+
+                        status.timeout = gtk_timeout_add(100, update_timeout, &status);
+                }
+#endif
+	}
+
+	if (found_valid)
+		gtk_main ();
+
+	return 0;
+}

docs/Changes-1.4.txt

@@ -1,36 +1,108 @@
 Incompatible Changes from GTK+-1.2 to GTK+-1.4:
 
-- The gdk_time* functions have been removed. This functionality
+* The gdk_time* functions have been removed. This functionality
   has been unused since the main loop was moved into GLib
   prior to 1.2. 
 
-- The signature for GtkPrintFunc (used for gtk_item_factory_dump_items)
+* The signature for GtkPrintFunc (used for gtk_item_factory_dump_items)
   has been changed to take a 'const gchar *' instead of 'gchar *', to
   match what we do for glib, and other similar cases.
 
-- The detail arguments in the GtkStyleClass structure are now 'const gchar *'.
+* The detail arguments in the GtkStyleClass structure are now 'const gchar *'.
 
-- gtk_paned_set_gutter_size() has been removed, since the small handle tab
+* gtk_paned_set_gutter_size() has been removed, since the small handle tab
   has been changed to include the entire area previously occupied by
   the gutter.
 
-- GDK no longer selects OwnerGrabButtonMask for button presses. This means  
+* GDK no longer selects OwnerGrabButtonMask for button presses. This means  
   that the automatic grab that occurs when the user presses a button
   will have owner_events = FALSE, so all events are redirected to the
   grab window, even events that would normally go to  other windows of the
   window's owner.
 
-- The detail arguments in the GtkStyleClass structure are now 'const gchar *'.
+* GtkColorSelectionDialog has now been moved into it's own set of files,
+  gtkcolorseldialog.c and gtkcolorseldialog.h.
 
-- Inserting and deleting text in GtkEntry though functions such
-  as gtk_entry_insert_text() now leave the cursor at its original
-  position in the text instead of moving it to the location of
-  the insertion/deletion.
+* gtk_widget_shape_combine_mask() now keeps a reference count on the 
+  mask pixmap that is passed in.
 
-- The ->label field of GtkFrame widgets has been removed. (As part of
-  a change to allow the arbitrary widgets in the title position.) The
-  text can now be retrieved with the new function gtk_frame_get_text().
+* Type system changes:
+  - GTK_TYPE_OBJECT is not a fundamental type anymore. Type checks of the
+    style (GTK_FUNDAMENTAL_TYPE (some_type) == GTK_TYPE_OBJECT)
+    will not work anymore. As a replacement, (GTK_TYPE_IS_OBJECT (some_type))
+    can be used now.
+  - The following types vanished: GTK_TYPE_ARGS, GTK_TYPE_CALLBACK,
+    GTK_TYPE_C_CALLBACK, GTK_TYPE_FOREIGN. The corresponding GtkArg
+    fields and field access macros are also gone.
+  - The following type aliases vanished: GTK_TYPE_FLAT_FIRST,
+    GTK_TYPE_FLAT_LAST, GTK_TYPE_STRUCTURED_FIRST, GTK_TYPE_STRUCTURED_LAST.
+  - The type macros GTK_TYPE_MAKE() and GTK_TYPE_SEQNO() vanished, use of
+    GTK_FUNDAMENTAL_TYPE() is discouraged. Instead, the corresponding GType
+    API should be used: G_TYPE_FUNDAMENTAL(), G_TYPE_DERIVE_ID(),
+    G_TYPE_BRANCH_SEQNO(). Note that the GLib type system doesn't build new
+    type ids based on a global incremental sequential number anymore, but
+    numbers new type ids sequentially per fundamental type branch.
+  - The following type functions vanished/were replaced:
+    Old Function		 Replacement
+    gtk_type_query()		 - being investigated -
+    gtk_type_set_varargs_type()	 -
+    gtk_type_get_varargs_type()	 -
+    gtk_type_check_object_cast() g_type_check_instance_cast()
+    gtk_type_check_class_cast()	 g_type_check_class_cast()
+    gtk_type_describe_tree()	 -
+    gtk_type_describe_heritage() -
+    gtk_type_free()		 -
+    gtk_type_children_types()	 g_type_children()
+    gtk_type_set_chunk_alloc()	 GTypeInfo.n_preallocs
+    gtk_type_register_enum()	 g_enum_register_static()
+    gtk_type_register_flags()	 g_flags_register_static()
+    gtk_type_parent_class()	 g_type_parent() / g_type_class_peek_parent()
+    Use of g_type_class_ref() / g_type_class_unref() and g_type_class_peek()
+    is recommended over usage of gtk_type_class().
+    Use of g_type_register_static() / g_type_register_dynamic() is recommended
+    over usage of gtk_type_unique().
 
-- The 'font' and 'font_set' declarations in RC files are now ignored. There
-  is a new 'font_name' field that holds the string form of a Pango font
-  description.
+* Object system changes:
+  GtkObject derives from GObject, so is not the basic object type anymore.
+  This imposes the following source incompatible changes:
+  - GtkObject has no klass field anymore, an object's class can be retrived
+    with the object's coresponding GTK_<OBJECT>_GET_CLASS (object) macro.
+  - GtkObjectClass has no type field anymore, a class's type can be retrived
+    with the GTK_CLASS_TYPE (class) macro.
+  - GtkObjectClass does not introduce the finalize() and shutdown() methods
+    anymore. While shutdown() is intended for GTK+ internal use only, finalize()
+    is required by a variety of object implementations. GObjectClass.finalize
+    should be overriden here, e.g.:
+    static void gtk_label_finalize (GObject *gobject)
+    {
+      GtkLabel *label = GTK_LABEL (gobject);
+      
+      G_OBJECT_CLASS (parent_class)->finalize (object);
+    }
+    static void gtk_label_class_init (GtkLabelClass *class)
+    {
+      GObjectClass *gobject_class = G_OBJECT_CLASS (class);
+      
+      gobject_class->finalize = gtk_label_finalize;
+    }
+
+  - the GtkObject::destroy signal can now be emitted multiple times on an object.
+    ::destroy implementations should check that make sure that they take this
+    into account, by checking to make sure that resources are there before
+    freeing them. For example:
+    if (object->foo_data)
+      { 
+        g_free (object->foo_data);
+        object->foo_data = NULL;
+      }
+
+    Also, ::destroy implementations have to release object references that
+    the object holds. Code in finalize implementations such as:
+    if (object->adjustment)
+      {
+        gtk_object_unref (object->adjustment);
+        object->adjustment = NULL;
+      }
+    have to be moved into the ::destroy implementations. The reason for doing
+    this is that all object reference cycles should be broken at destruction 
+    time.

docs/Makefile.am

@@ -187,19 +187,15 @@ EXTRA_DIST += \
 	gtk_tut_fr.sgml			\
 	gtk_tut_packbox1.gif 		\
 	gtk_tut_packbox2.gif 		\
-	gtk_tut_table.gif
-
-if HAVE_SGML2HTML
-dist-hook: faq tutorial tutorial_it tutorial_fr
-	mkdir $(distdir)/html
-	cp -p $(srcdir)/html/*.html $(distdir)/html
-	cp -p $(srcdir)/html/*.gif $(distdir)/html
-	mkdir $(distdir)/text
-	cp -p $(srcdir)/text/*.txt $(distdir)/text
-else
-dist-hook:
-	echo "***"
-	echo "*** Warning: Tutorial and faq not built"
-	echo "*** DISTRIBUTION IS INCOMPLETE"
-	echo "***"
-endif
+	html/gtk_tut_table.gif		\
+	html/gtk_tut_packbox1.gif 	\
+	html/gtk_tut_packbox2.gif 	\
+	gtk_tut_table.gif		\
+	html/gdk.html            	\
+	html/gdk_toc.html        	\
+	html/gtk.html            	\
+	html/gtk_toc.html        	\
+	$(TUTORIAL_FILES)		\
+	$(TUTORIAL_FR_FILES)		\
+	$(TUTORIAL_IT_FILES)		\
+	$(FAQ_FILES)

docs/es/gtk.html

@@ -0,0 +1,103 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<HTML>
+<HEAD>
+ <META NAME="GENERATOR" CONTENT="SGML-Tools 1.0.6">
+ <TITLE>GTK+ FAQ</TITLE>
+ <LINK HREF="gtkfaq-es-1.html" REL=next>
+
+
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<A HREF="gtkfaq-es-1.html">Next</A>
+Previous
+Contents
+<HR NOSHADE>
+<H1>GTK+ FAQ</H1>
+
+ 
+<H2>Nathan Froyd, Tony Gale, Shawn T. Amundson.</H2>Seis de Julio de 1998
+<P><HR NOSHADE>
+<EM>La intención de este documento es dar respuesta a las preguntas
+realizadas con más frecuencia por parte de los programadores que utilizan GTK+ o simplemente por personas que desean utilizar GTK+. </EM>
+<HR NOSHADE>
+<P>
+<H2><A NAME="toc1">1.</A> <A HREF="gtkfaq-es-1.html">Información General</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-1.html#ss1.1">1.1 Autores</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.2">1.2 ¿Qué es GTK+?</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.3">1.3 ¿Qué es el + en GTK+?</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.4">1.4 ¿La G en GTK+ significa General, Gimp, o GNU?</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.5">1.5 ¿Dónde está la documentación para GTK?</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.6">1.6 ¿Hay alguna lista de correo (o archivo de lista de correo) para GTK+?</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.7">1.7 ¿La lista gtk-list no ha tenido tráfico alguno por días,</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.8">1.8 Cómo conseguir ayuda con GTK+</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.9">1.9 Cómo reportar errores en GTK+</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.10">1.10 ¿Qué aplicaciones se han escrito con GTK+?</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.11">1.11 Estoy buscando una aplicación que escribir en GTK+. ¿Qué tal un cliente IRC?</A>
+</UL>
+<P>
+<H2><A NAME="toc2">2.</A> <A HREF="gtkfaq-es-2.html">Cómo encontrar, configurar, instalar y comprobar GTK+</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-2.html#ss2.1">2.1 ¿Qué necesito para correr GTK+?</A>
+<LI><A HREF="gtkfaq-es-2.html#ss2.2">2.2 ¿Dónde puedo conseguir GTK+?</A>
+<LI><A HREF="gtkfaq-es-2.html#ss2.3">2.3 ¿Cómo configuro/compilo GTK+?</A>
+<LI><A HREF="gtkfaq-es-2.html#ss2.4">2.4 Cuando compilo GTK+ obtengo un error como: <CODE>make: file `Makefile' line 456: Syntax error</CODE></A>
+<LI><A HREF="gtkfaq-es-2.html#ss2.5">2.5 ¡He compilado e instalado GTK+, pero no puedo lograr que los programas se enlacen con él!</A>
+<LI><A HREF="gtkfaq-es-2.html#ss2.6">2.6 Cuando compilo programas con GTK+, obtengo mensajes de error del compilador diciendo que no es capaz de encontrar <CODE>"glibconfig.h"</CODE>.</A>
+<LI><A HREF="gtkfaq-es-2.html#ss2.7">2.7 Cuando instalo El GIMP, configure reporta que no puede encontrar GTK.</A>
+</UL>
+<P>
+<H2><A NAME="toc3">3.</A> <A HREF="gtkfaq-es-3.html">Desarrollo de GTK+</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-3.html#ss3.1">3.1 ¿Qué es esta cosa CVS de la cual todo el mundo habla, y cómo puedo acceder a ella?</A>
+<LI><A HREF="gtkfaq-es-3.html#ss3.2">3.2 ¿Cómo puedo contribuír a GTK+?</A>
+<LI><A HREF="gtkfaq-es-3.html#ss3.3">3.3 ¿Cómo averiguo si mi parche fue aplicado, y si no, por qué no?</A>
+<LI><A HREF="gtkfaq-es-3.html#ss3.4">3.4 ¿Cuál es la política sobre la incorporación de nuevos <EM>widgets</EM> en la librería?</A>
+<LI><A HREF="gtkfaq-es-3.html#ss3.5">3.5 ¿Hay alguien trabajando en atamientos para otros lenguajes distintos a C?</A>
+</UL>
+<P>
+<H2><A NAME="toc4">4.</A> <A HREF="gtkfaq-es-4.html">Desarrollo con GTK+</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-4.html#ss4.1">4.1 ¿Cómo empiezo?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.2">4.2 ¿Qué <EM>widgets</EM> existen en GTK?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.3">4.3 ¿GTK+ es seguro ante múltiples hilos?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.4">4.4 ¿Cómo puedo prevenir el redibujar y reacomodar tamaños mientras cambio múltiples <EM>widgets</EM>?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.5">4.5 ¿Cómo atrapo un evento de doble tecleo (en un <EM>widget</EM> de lista, por ejemplo)?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.6">4.6 ¿Cómo puedo averiguar cuál es la selección de un GtkList?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.7">4.7 ¿Acaso es posible desplegar un texto que se recorte para que quepa dentro del lugar que tenga asignado?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.8">4.8 ¿Por qué el contenido de un botón no se mueve al presionar el botón? Aquí les envío un parche para que funcione de esa forma...</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.9">4.9 ¿Cómo puedo definir una línea de separación como en un menú?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.10">4.10 ¿Cómo puedo darle justificación a la derecha a un menú, como Help, cuando utilizo MenuFactory?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.11">4.11 ¿Cómo hago mi ventana modal? / ¿Cómo hago una sóla ventana activa?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.12">4.12 ¿Por qué mi <EM>widget</EM> (ej. progressbar) no se actualiza?</A>
+</UL>
+<P>
+<H2><A NAME="toc5">5.</A> <A HREF="gtkfaq-es-5.html">Acerca de gdk</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-5.html#ss5.1">5.1 ¿Qué es gdk?</A>
+<LI><A HREF="gtkfaq-es-5.html#ss5.2">5.2 ¿Cómo utilizo la asignación de colores?</A>
+</UL>
+<P>
+<H2><A NAME="toc6">6.</A> <A HREF="gtkfaq-es-6.html">Acerca de glib</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-6.html#ss6.1">6.1 ¿Qué es glib?</A>
+<LI><A HREF="gtkfaq-es-6.html#ss6.2">6.2 ¿Por qué utilizar g_print, g_malloc, g_strdup y funciones compañeras de glib?</A>
+</UL>
+<P>
+<H2><A NAME="toc7">7.</A> <A HREF="gtkfaq-es-7.html">Contribuciones al GTK+ FAQ, Mantenedores y Copyright</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-7.html#ss7.1">7.1 Nota del Traductor</A>
+</UL>
+<HR NOSHADE>
+<A HREF="gtkfaq-es-1.html">Next</A>
+Previous
+Contents
+</BODY>
+</HTML>

docs/es/gtkfaq-es-1.html

@@ -0,0 +1,192 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<HTML>
+<HEAD>
+ <META NAME="GENERATOR" CONTENT="SGML-Tools 1.0.6">
+ <TITLE>GTK+ FAQ: Información General</TITLE>
+ <LINK HREF="gtkfaq-es-2.html" REL=next>
+
+ <LINK HREF="gtkfaq-es.html#toc1" REL=contents>
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<A HREF="gtkfaq-es-2.html">Next</A>
+Previous
+<A HREF="gtkfaq-es.html#toc1">Contents</A>
+<HR NOSHADE>
+<H2><A NAME="s1">1. Información General</A></H2>
+
+<H2><A NAME="ss1.1">1.1 Autores</A>
+</H2>
+
+<P>Los autores de GTK+ son:
+<P>
+<UL>
+<LI>Peter Mattis    (petm@xcf.berkeley.edu)</LI>
+<LI>Spencer Kimball (spencer@xcf.berkeley.edu)</LI>
+<LI>Josh MacDonald  (jmacd@xcf.berkeley.edu)</LI>
+</UL>
+
+GTK+ se ditribuye bajo la licencia de Librería Pública General de GNU
+<P>
+<H2><A NAME="ss1.2">1.2 ¿Qué es GTK+?</A>
+</H2>
+
+<P>GTK+ es un pequeño y eficiente conjunto de <EM>widgets</EM>, diseñados
+con un aspecto y sentir general a Motif. Contiene <EM>widgets</EM> comúnes
+y algúnos <EM>widgets</EM> más complejos como una selección de
+archivos, y <EM>widgets</EM> de selección de colores.
+<P>GTK+ proporciona algunas características únicas. (No tengo conocimiento
+de otra librería de <EM>widge>
+<HR><H3>Transfer interrupted!</H3>
+enos).
+Por ejemplo, un botón no contiene una etiqueta, contiene un <EM>widget</EM>
+hijo, que en muchas instancias será una etiqueta. Sin embargo, el
+<EM>widget</EM> hijo también puede ser un <EM>pixmap</EM> (mapa de pixels),
+imagén o cualquier combinación posible que desee el programador. Toda la
+librería es así de flexible.
+<P>
+<H2><A NAME="ss1.3">1.3 ¿Qué es el + en GTK+?</A>
+</H2>
+
+<P>Peter Mattis informó a la lista de correo gtk:
+<BLOCKQUOTE>
+"Escribí originalmente gtk el cual incluía tres librerías,
+libglib, libgdk y libgtk. Era caracterizado por una jerarquía de
+<EM>widget</EM> plana. O sea, no podías derivar un nuevo
+<EM>widget</EM> de uno ya existente. Contenía un mecanismo de
+<EM>callback</EM> (llamada) más estándar en lugar del mecanismo
+de señales ahora presente en gtk+. El + fue agregado para distinguir
+entre la versión original de gtk y la nueva versión. Pueden pensar
+en ello como una ampliación al gtk original que agrega características
+orientadas o objetos."
+</BLOCKQUOTE>
+<P>
+<H2><A NAME="ss1.4">1.4 ¿La G en GTK+ significa General, Gimp, o GNU?</A>
+</H2>
+
+<P>Peter Mattis informó a la lista de correo gtk:
+<BLOCKQUOTE>
+"Pienso que la última vez que Spencer y yo hablamos al respecto nos
+decidimos por GTK = Gimp ToolKit. Pero no estoy seguro. Sin embargo,
+definitivamente no es GNU."
+</BLOCKQUOTE>
+<P>
+<H2><A NAME="ss1.5">1.5 ¿Dónde está la documentación para GTK?</A>
+</H2>
+
+<P> 
+En el directorio doc/ de la distribución de GTK+ encontrarás
+el material de referencia para GTK y GDK, este FAQ y el tutor de GTK.
+<P>Adicionalmente, puedes encontrar enlaces a versiones HTML de estos
+documentos al ir a 
+<A HREF="http://www.gtk.org/">http://www.gtk.org/</A>.
+<P>El Tutor y el FAQ también se pueden encontrar en
+<A HREF="http://www.geocities.com/ResearchTriangle/Lab/4299/">http://www.geocities.com/ResearchTriangle/Lab/4299/</A>.
+<P>
+<H2><A NAME="ss1.6">1.6 ¿Hay alguna lista de correo (o archivo de lista de correo) para GTK+?</A>
+</H2>
+
+<P>Hay dos listas de correo:
+<UL>
+<LI>Una lista de correo para la discusión del desarrollo de aplicaciones
+basadas en GTK se hospeda en gtk-app-devel-list@redhat.com. Para suscribirse
+envíe un correo electrónico a 
+<A HREF="mailto:gtk-app-devel-list-request@redhat.com">gtk-app-devel-list-request@redhat.com</A> con <EM>subscribe</EM> en el
+campo <B>subject</B>.
+<P>
+</LI>
+<LI>Una lista de correo para la discusión del desarrollo de GTK se hospeda
+en gtk-list@redhat.com. Para suscribirse envíe un correo electrónico 
+a 
+<A HREF="mailto:gtk-list-request@redhat.com">gtk-list-request@redhat.com</A> con <EM>subscribe</EM>
+en el campo <B>subject</B>.
+<P>Un archivo escudriñable de la lista de correo puede ser encontrado en
+<A HREF="http://archive.redhat.com/gtk-list">http://archive.redhat.com/gtk-list</A></LI>
+</UL>
+<H2><A NAME="ss1.7">1.7 ¿La lista gtk-list no ha tenido tráfico alguno por días,</A>
+está muerta?</H2>
+
+<P>No, todos están ocupados codificando.
+<P>
+<H2><A NAME="ss1.8">1.8 Cómo conseguir ayuda con GTK+</A>
+</H2>
+
+<P>Primero, asegúrate que tu pregunta no esté respondida en la 
+documentación, este FAQ o el tutor. ¿Hecho? ¿Estás seguro de que 
+lo has hecho, verdad? En ese caso, el mejor lugar para hacer preguntas es
+la lista de correo de GTK+.
+<P>
+<H2><A NAME="ss1.9">1.9 Cómo reportar errores en GTK+</A>
+</H2>
+
+<P>Los reportes de errores se deben enviar a la lista de correo de GTK+.
+<P>
+<H2><A NAME="ss1.10">1.10 ¿Qué aplicaciones se han escrito con GTK+?</A>
+</H2>
+
+<P>Algunas aplicaciones que utilizan GTK+ son:
+<UL>
+<LI>GIMP (
+<A HREF="http://www.XCF.Berkeley.EDU/~gimp/">http://www.XCF.Berkeley.EDU/~gimp/</A> ), 
+un programa de manipulación de imágenes</LI>
+<LI>Gsumi (
+<A HREF="http://www.msc.cornell.edu/~otaylor/gsumi/gsumi.html">http://www.msc.cornell.edu/~otaylor/gsumi/gsumi.html</A>),
+un divertido programa para rayar en blanco y negro con soporte para 
+XInput.</LI>
+<LI>GUBI (
+<A HREF="http://www.SoftHome.net/pub/users/timj/gubi/index.htm">http://www.SoftHome.net/pub/users/timj/gubi/index.htm</A>),
+un constructor de interface de usuario</LI>
+<LI>Gzilla (
+<A HREF="http://www.levien.com/gzilla/">http://www.levien.com/gzilla/</A>),
+un navegador del web</LI>
+<LI>SANE (
+<A HREF="http://www.azstarnet.com/~axplinux/sane/">http://www.azstarnet.com/~axplinux/sane/</A> ),
+una interface universal para <EM>scanner</EM></LI>
+<LI>XQF (
+<A HREF="http://www.botik.ru/~roma/quake/">http://www.botik.ru/~roma/quake/</A>),
+un lanzador y navegador de servidores de QuakeWorld/Quake2</LI>
+<LI>ElectricEyes (
+<A HREF="http://www.labs.redhat.com/ee.shtml">http://www.labs.redhat.com/ee.shtml</A>),
+un visor de imágenes que se dirige a ser un reemplazo libre de xv</LI>
+<LI>GPK - the General Proxy Kit (
+<A HREF="http://www.humanfactor.com/gpk/">http://www.humanfactor.com/gpk/</A>),
+una librería agregable que permite accesso seguro a GTK+
+ante múltiples hilos</LI>
+<LI>GCK - the General Convenience Kit (
+<A HREF="http://www.ii.uib.no/~tomb/gck.html">http://www.ii.uib.no/~tomb/gck.html</A>),
+funciones misceláneas cuya intención es facilitar el manejo de
+colores, construcción de IU (interfaces de usuario), operaciones
+vectoriales, y funciones matemáticas</LI>
+<LI>GDK Imlib (
+<A HREF="http://www.labs.redhat.com/imlib/">http://www.labs.redhat.com/imlib/</A>),
+una librería de manipulación y carga rápida de imágenes para
+GDK      </LI>
+</UL>
+<P>Adicionalmente a lo de arriba, el proyecto GNOME 
+(
+<A HREF="http://www.gnome.org">http://www.gnome.org</A>)
+utiliza GTK+ para construír un escritorio libre para Linux. Muchos más 
+programas pueden ser encontrados ahí.
+<P>
+<H2><A NAME="ss1.11">1.11 Estoy buscando una aplicación que escribir en GTK+. ¿Qué tal un cliente IRC?</A>
+</H2>
+
+<P> 
+<P>Pregunte en gtk-list para sugerencias. Actualmente hay por lo menos cuatro
+clientes IRC endesarrollo.
+<P>
+<UL>
+<LI>girc. (Incluído con GNOME)</LI>
+<LI>Bezerk (
+<A HREF="http://www.gtk.org/~trog/">http://www.gtk.org/~trog/</A>)</LI>
+<LI>gsirc. (¿Localización?)</LI>
+<LI>Gnirc. (
+<A HREF="http://www.imaginet.fr/~dramboz/gnirc">http://www.imaginet.fr/~dramboz/gnirc</A>)</LI>
+</UL>
+<P>
+<P>
+<HR NOSHADE>
+<A HREF="gtkfaq-es-2.html">Next</A>
+Previous
+<A HREF="gtkfaq-es.html#toc1">Contents</A>
+</BODY>
+</HTML>

docs/es/gtkfaq-es-2.html

@@ -0,0 +1,195 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<HTML>
+<HEAD>
+ <META NAME="GENERATOR" CONTENT="SGML-Tools 1.0.6">
+ <TITLE>GTK+ FAQ: Cómo encontrar, configurar, instalar y comprobar GTK+</TITLE>
+ <LINK HREF="gtkfaq-es-3.html" REL=next>
+ <LINK HREF="gtkfaq-es-1.html" REL=previous>
+ <LINK HREF="gtkfaq-es.html#toc2" REL=contents>
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<A HREF="gtkfaq-es-3.html">Next</A>
+<A HREF="gtkfaq-es-1.html">Previous</A>
+<A HREF="gtkfaq-es.html#toc2">Contents</A>
+<HR NOSHADE>
+<H2><A NAME="s2">2. Cómo encontrar, configurar, instalar y comprobar GTK+</A></H2>
+
+<H2><A NAME="ss2.1">2.1 ¿Qué necesito para correr GTK+?</A>
+</H2>
+
+<P>Para compilar GTK+, todo lo que necesita es un compilador de C (gcc) y
+el Sistema X Windows y librerías asociadas en su sistema.
+<P>
+<H2><A NAME="ss2.2">2.2 ¿Dónde puedo conseguir GTK+?</A>
+</H2>
+
+<P>El sitio canónico es:
+<PRE>
+ftp://ftp.gtk.org/pub/gtk
+</PRE>
+
+Por supuesto, cualquier espejo de ftp.gtk.org debe tener las últimas
+versiones también.
+<P>
+<H2><A NAME="ss2.3">2.3 ¿Cómo configuro/compilo GTK+?</A>
+</H2>
+
+<P>Por lo general, todo lo que necesita es emititir los comandos:
+<PRE>
+./configure
+make
+</PRE>
+
+en el directorio gtk+-version/.
+<P>
+<H2><A NAME="ss2.4">2.4 Cuando compilo GTK+ obtengo un error como: <CODE>make: file `Makefile' line 456: Syntax error</CODE></A>
+</H2>
+
+<P>Asegúrese de que utiliza GNU make (verifique con <CODE>make -v</CODE>). Hay
+varias versiones extrañas y maravillosas de make por ahí, y no todas
+manejan los <EM>Makefiles</EM> generados automáticamente.
+<P>
+<P>
+<H2><A NAME="ss2.5">2.5 ¡He compilado e instalado GTK+, pero no puedo lograr que los programas se enlacen con él!</A>
+</H2>
+
+<P>Este problema se encuentra comúnmente cuando las librerías GTK+ no pueden
+ser localizadas o tienen la versión incorrecta. Generalmente, el compilador
+se quejará de un 'unresolved symbol' (símbolo no resuelto). Hay dos cosas
+que necesita verificar:
+<P>
+<UL>
+<LI>Asegúrese de que las librerías pueden ser encontradas. Usted desea editar
+/etc/ld.so.conf para incluír los directorios que contienen las librerías
+GTK, de manera que luzca como:
+<PRE>
+/usr/X11R6/lib
+/usr/local/lib
+</PRE>
+
+Luego necesita correr /sbin/ldconfig como root. Puede encontrar que directorio
+utiliza GTK al ejecutar
+<PRE>
+gtk-config --libs
+</PRE>
+
+
+Si su sitema no utiliza ld.so para encontrar librerías (como Solaris),
+entonces tendrá que utilizar la variable de ambiente LD_LIBRARY_PATH
+(o compilar el camino en su programa, lo cual no voy a cubrir aquí). Así
+que, con un shell tipo Bourne usted puede hacer (si sus librerías GTK
+están en /usr/local/lib):
+<PRE>
+export LD_LIBRARY_PATH=/usr/local/lib
+</PRE>
+
+y en un csh, usted puede hacer:
+<PRE>
+setenv LD_LIBRARY_PATH /usr/local/lib
+</PRE>
+
+</LI>
+<LI>Asegúrese de que el enlazador está ha encontrado el conjunto correcto de
+librerías. Si tiene una distribución de Linux que instala GTK+ (ej.
+RedHat 5.0) entonces esta versión anterior puede ser utilizada. Ahora
+(asumiendo que tiene un sistema RedHat), emita el comando
+<PRE>
+rpm -e gtk gtk-devel
+</PRE>
+
+También puede querer remover los paquetes que dependen de gtk (rpm le
+dirá cuáles son). Si no tiene un sistema Linux RedHat, verifique
+para estar seguro que ni 
+<PRE>
+/usr/lib
+</PRE>
+ ni 
+<PRE>
+/usr/local/lib
+</PRE>
+
+contengan alguna de las librerías libgtk, libgdk, libglib, or libgck.
+Si existen, elimínelas (y cualquier archivo <EM>include</EM>, como 
+/usr/include/gtk y /usr/include/gdk) y reinstale gtk+.</LI>
+</UL>
+<P>
+<H2><A NAME="ss2.6">2.6 Cuando compilo programas con GTK+, obtengo mensajes de error del compilador diciendo que no es capaz de encontrar <CODE>"glibconfig.h"</CODE>.</A>
+</H2>
+
+<P>El archivo de encabezado "glibconfig.h" se movió al directorio 
+$exec_prefix/lib/glib/include/. $exec_prefix es el directorio que fue
+especificado al dar la bandera --exec-prefix a ./configure cuando se
+compiló GTK+. Va por omisión a $prefix, (especificado con --prefix),
+que en su lugar va por omisión a /usr/local/.
+<P>Ésto se hizo asi porque "glibconfig.h" incluye información 
+dependiente de la arquitectura, y el resto de los archivos <EM>include</EM> 
+se colocan en $prefix/include, el cual puede ser compartido entre distintas 
+arquitecturas.
+<P>GTK+ incluye un guión para el intérprete de comandos, 
+<CODE>gtk-config</CODE>, el cual hace fácil
+encontrar los caminos correctos de inclusión. El tutor de GTK+ incluye
+un ejemplo de como utilizar <CODE>gtk-config</CODE> para una compilación simple
+desde la línea de comandos. Para información sobre configuraciones más
+complicadas, vea el archivo docs/gtk-config.txt en la distribución de GTK+.
+<P>Si está intentando compilar un programa viejo, puede bordear el problema
+al configurarlo con una línea de comando como:
+<P>
+<BLOCKQUOTE><CODE>
+<PRE>
+CPPFLAGS="-I/usr/local/include/glib/include" ./configure
+</PRE>
+</CODE></BLOCKQUOTE>
+<P>para intérpretes de comandos compatibles con Bourne como bash, o para 
+variantes csh:
+<P>
+<BLOCKQUOTE><CODE>
+<PRE>
+setenv CPPFLAGS "-I/usr/local/include/glib/include" 
+./configure
+</PRE>
+</CODE></BLOCKQUOTE>
+<P>(Sustituya el valor apropiado de $exec_prefix para /usr/local.)
+<P>
+<H2><A NAME="ss2.7">2.7 Cuando instalo El GIMP, configure reporta que no puede encontrar GTK.</A>
+</H2>
+
+<P>Hay varias razones comúnes para esto:
+<UL>
+<LI>Usted tiene una versión vieja de GTK instalada en algún lugar.
+RedHat 5.0, por ejemplo, instala una copia anterior de GTK que no funcinará
+con las últimas veriones de GIMP. Debe eliminar esta copia vieja, pero
+observe que en el caso de RedHat 5.0 esto dañará las aplicaciones
+<CODE>control-panel</CODE>.
+<P>
+</LI>
+<LI><CODE>gtk-config</CODE> (u otro componente de GTK) no se encuentra en el camino
+(<EM>path</EM>),
+o hay una versión vieja en su sistema. Teclee:
+<PRE>
+gtk-config --version
+</PRE>
+
+para verificar ambos casos. Ésto debe devolver un valor de por lo menos
+0.99.8 para que las cosas funcionen correctamente con GIMP 0.99.23. Si
+devuelve un valor distinto a lo que usted espera, entonces tiene una versión
+vieja de GTK en su sistema.
+<P>
+</LI>
+<LI>El guión ./configure no puede encontrar las librerías GTK. Como
+./configure compila varios programas de prueba, necesita poder encontrar las
+librerías GTK. Revise la pregunta anterior para obtener más ayuda al
+respecto.</LI>
+</UL>
+<P>Si nada de lo anterior ayuda, entonces revise config.log, el cual es
+generado por ./configure cuando corre. Al final estará la última
+acción tomada antes de fallar. Si es una sección de código fuente,
+copie el código fuente a un archivo y compilelo con la línea
+jústamente arriba de él en config.log. Si la compilación tiene 
+éxito, intente ejecutarlo.
+<P>
+<HR NOSHADE>
+<A HREF="gtkfaq-es-3.html">Next</A>
+<A HREF="gtkfaq-es-1.html">Previous</A>
+<A HREF="gtkfaq-es.html#toc2">Contents</A>
+</BODY>
+</HTML>

docs/es/gtkfaq-es-3.html

@@ -0,0 +1,198 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<HTML>
+<HEAD>
+ <META NAME="GENERATOR" CONTENT="SGML-Tools 1.0.6">
+ <TITLE>GTK+ FAQ: Desarrollo de GTK+</TITLE>
+ <LINK HREF="gtkfaq-es-4.html" REL=next>
+ <LINK HREF="gtkfaq-es-2.html" REL=previous>
+ <LINK HREF="gtkfaq-es.html#toc3" REL=contents>
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<A HREF="gtkfaq-es-4.html">Next</A>
+<A HREF="gtkfaq-es-2.html">Previous</A>
+<A HREF="gtkfaq-es.html#toc3">Contents</A>
+<HR NOSHADE>
+<H2><A NAME="s3">3. Desarrollo de GTK+</A></H2>
+
+<H2><A NAME="ss3.1">3.1 ¿Qué es esta cosa CVS de la cual todo el mundo habla, y cómo puedo acceder a ella?</A>
+</H2>
+
+<P>CVS es el Concurrent Version System (Sistema de Versión Concurrente) y es
+un medio muy popular de control de versión para proyectos de software.
+Está diseñado para permitir que múltiples autores puedan operar de
+manera simultánea en el mismo árbol fuente. Este árbol fuente es
+mantenido centralizadamente, pero cada desarrollador tiene una réplica local
+de este repositorio en el cual hacen sus cambios.
+<P>Los desarrolladores de GTK+ utilizan un repositorio CVS para almacenar la
+copia maestra de la actual versión en desarrollo de GTK+. Como tal,
+la gente que desea contribuír con parches a GTK+ deben generarlos para la
+versión del CVS. La gente normal debe utilizar los paquetes liberados.
+<P>El conjunto de herramientas CVS está disponible como paquetes RPM en los
+sitios usuales de RedHat. La última versión está disponible en
+<A HREF="http://download.cyclic.com/pub/">&lt;http://download.cyclic.com/pub/&gt;</A><P>Cualquiera puede bajar la última versión CVS de GTK+ utilizando
+acceso anónimo con los siguientes pasos:
+<UL>
+<LI> En un descendiente del intérprete de comandos bourne (ej. bash)
+teclee:
+<PRE>
+export CVSROOT=':pserver:anonymous@anoncvs.gimp.org:/debian/home/gnomecvs'
+</PRE>
+</LI>
+<LI>Luego, la primera vez que el árbol fuente se retira, se necesita
+un <EM>login</EM> cvs.
+<PRE>
+cvs login
+</PRE>
+
+Ésto hará que se le solicite una clave de acceso. No hay clave de 
+acceso para cvs.gimp.org, así que solo ingrese un retorno de carro.</LI>
+<LI>Para conseguir el árbol y colocarlo en un subdirectorio de su
+directorio de trabajo actual, emita el comando:
+<PRE>
+cvs -z3 get gtk+
+</PRE>
+
+
+Observe que con el árbol GTK+ 1.1, glib se ha movido a un módulo CVS
+separado, de manera que si no tiene glib instalado necesitará conseguirlo
+igualmente:
+<PRE>
+cvs -z3 get glib
+</PRE>
+
+</LI>
+</UL>
+<H2><A NAME="ss3.2">3.2 ¿Cómo puedo contribuír a GTK+?</A>
+</H2>
+
+<P>Es simple. Si algo no funciona en un programa como usted piensa que debería,
+revise la documentación para asegurarse de que no ha pasado algo por alto.
+Si es un verdadero error o característica perdida, rastréelo en el
+fuente de GTK+, cámbielo, y entonces genere un parche en la forma de un
+'diff de contexto'. Esto puede hacerse utilizando un comando como
+<CODE>diff -ru &lt;oldfile&gt; &lt;newfile&gt;</CODE>. Entonces envíe el archivo 
+de parche a:
+<PRE>
+ftp://ftp.gtk.org/incoming
+</PRE>
+
+junto a un archivo README. ¡Asegúrese de seguir las convenciones de
+asignación de nombres o su parche será borrado! Los archivos deben ser
+de esta forma:
+<PRE>
+gtk-&lt;username>-&lt;date yymmdd-n>.patch.gz
+gtk-&lt;username>-&lt;date yymmdd-n>.patch.README
+</PRE>
+
+La "n" en la fecha indica un número único (empezando de 0)
+de parches que subió ese día. Debe ser 0, a menos que envíe más de
+un parche en el mismo día.
+<P>Example:
+<PRE>
+gtk-gale-982701-0.patch.gz
+gtk-gale-982701-0.patch.README
+</PRE>
+
+Una vez que usted envía <EM>lo que sea</EM>, envíe el README a
+ftp-admin@gtk.org
+<P>
+<H2><A NAME="ss3.3">3.3 ¿Cómo averiguo si mi parche fue aplicado, y si no, por qué no?</A>
+</H2>
+
+<P>Los parches enviados se mandarán a 
+<CODE>ftp://ftp.gtk.org/pub/gtk/patches</CODE>
+donde uno del equipo de desarrollo de GTK+ los recogerá. Si son aplicados,
+serán movidos a <CODE>/pub/gtk/patches/old</CODE>.
+<P>Los parches que no son aplicados, por cualquier razón, se mandarán a
+<CODE>/pub/gtk/patches/unapplied</CODE> o <CODE>/pub/gtk/patches/outdated</CODE>.
+En este punto puede preguntar en la lista de correo <CODE>gtk-list</CODE> el porqué
+su parche no fué aplicado. Hay muchas razones posibles por las cuales un
+parche no se aplica, pasando desde que no se puede aplicar limpiamente, hasta 
+que no es correcto. No se rinda si no logró que su parche se aplicase a la
+primera.
+<P>
+<H2><A NAME="ss3.4">3.4 ¿Cuál es la política sobre la incorporación de nuevos <EM>widgets</EM> en la librería?</A>
+</H2>
+
+<P>Esto corresponde a los autores, de manera que tendrá que preguntarles
+al terminar su <EM>widget</EM>. Como una guía general, los <EM>widgets</EM>
+que por lo general son útiles, funcionan, y no son una desgracia al conjunto
+de <EM>widgets</EM> serán incluídos con mucho gusto.
+<P>
+<H2><A NAME="ss3.5">3.5 ¿Hay alguien trabajando en atamientos para otros lenguajes distintos a C?</A>
+</H2>
+
+<P>Sí. Existe
+<UL>
+<LI>una envoltura de C++ para GTK+ llamada gtk--. Puede encontrar el su
+página hogar en: 
+<A HREF="http://www.cs.tut.fi/~p150650/gtk/gtk--.html">http://www.cs.tut.fi/~p150650/gtk/gtk--.html</A>. 
+El sitio FTP es
+<A HREF="ftp://ftp.gtk.org/pub/gtk/gtk--">ftp://ftp.gtk.org/pub/gtk/gtk--</A>.
+<P>
+<P>
+</LI>
+<LI>Hay dos ataduras para Objective-C en desarrollo:
+
+<UL>
+<LI>El paquete elegido por el 
+<A HREF="http://www.gnome.org/">proyecto GNOME</A> es obgtk. Objgtk se basa en la clase Object y es
+mantenido por 
+<A HREF="mailto:sopwith@cuc.edu">Elliot Lee</A>.
+Aparentemente, objgtk se está aceptando como el atamiento `estándar'
+de Objective-C para GTK+.
+</LI>
+<LI> Si usted está más inclinado al 
+<A HREF="http://www.gnustep.org/">proyecto GNUstep</A>,
+puede que quiera revisar GTKKit por
+<A HREF="mailto:helge@mdlink.de">Helge He&szlig;</A>.
+La intención es crear un atamiento GTK+ utilizando FoundationKit.
+GTKKit incluye linduras como escribir un archivo con una plantilla tipo 
+XML para construír una interface GTK+.
+</LI>
+</UL>
+ 
+<P>               
+</LI>
+<LI>Atamientos Perl
+<A HREF="ftp://ftp.gtk.org/pub/gtk/perl">ftp://ftp.gtk.org/pub/gtk/perl</A>
+<P>
+</LI>
+<LI>Atamientos Guile. La página hogar se encuentra en
+<A HREF="http://www.ping.de/sites/zagadka/guile-gtk">http://www.ping.de/sites/zagadka/guile-gtk</A>.
+Por cierto, Guile es la implantación del Proyecto GNU de Scheme R4RS (el
+estándar). Si le gusta Scheme, querrá darle un vistazo a éste.
+<P>
+<P>
+</LI>
+<LI>David Monniaux informa:
+<BLOCKQUOTE>
+He empezado un sistema de atamiento gtk-O'Caml. Las bases del sistema,
+incluyendo <EM>callbacks</EM>, funcionan bien.
+
+El desarrollo actual se encuentra en
+<A HREF="http://www.ens-lyon.fr/~dmonniau/arcs">http://www.ens-lyon.fr/~dmonniau/arcs</A></BLOCKQUOTE>
+
+</LI>
+<LI>Se han hecho varios atamientos para python:
+<P>
+<UL>
+<LI>pygtk se encuentra en 
+<A HREF="http://www.daa.com.au/~james/pygtk">http://www.daa.com.au/~james/pygtk</A> y 
+<A HREF="ftp://ftp.gtk.org/pub/gtk/python">ftp://ftp.gtk.org/pub/gtk/python</A></LI>
+<LI>python-gtk se encuentra en
+<A HREF="http://www.ucalgary.ca/~nascheme/python-gtk">http://www.ucalgary.ca/~nascheme/python-gtk</A></LI>
+</UL>
+<P>
+</LI>
+<LI>Hay un <EM>widget</EM> disponible para GTK+. Agárrelo en
+<A HREF="http://www.sakuranet.or.jp/~aozasa/shige/doc/comp/gtk/gtkGL/files-en.html">http://www.sakuranet.or.jp/~aozasa/shige/doc/comp/gtk/gtkGL/files-en.html</A>
+</LI>
+</UL>
+<P>
+<HR NOSHADE>
+<A HREF="gtkfaq-es-4.html">Next</A>
+<A HREF="gtkfaq-es-2.html">Previous</A>
+<A HREF="gtkfaq-es.html#toc3">Contents</A>
+</BODY>
+</HTML>

docs/es/gtkfaq-es-4.html

@@ -0,0 +1,435 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<HTML>
+<HEAD>
+ <META NAME="GENERATOR" CONTENT="SGML-Tools 1.0.6">
+ <TITLE>GTK+ FAQ: Desarrollo con GTK+</TITLE>
+ <LINK HREF="gtkfaq-es-5.html" REL=next>
+ <LINK HREF="gtkfaq-es-3.html" REL=previous>
+ <LINK HREF="gtkfaq-es.html#toc4" REL=contents>
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<A HREF="gtkfaq-es-5.html">Next</A>
+<A HREF="gtkfaq-es-3.html">Previous</A>
+<A HREF="gtkfaq-es.html#toc4">Contents</A>
+<HR NOSHADE>
+<H2><A NAME="s4">4. Desarrollo con GTK+</A></H2>
+
+<H2><A NAME="ss4.1">4.1 ¿Cómo empiezo?</A>
+</H2>
+
+<P>Después de que ha instalado GTK+, hay un par de cosas que pueden
+facilitarle el desarrollo de aplicaciones con él. Está el Tutor de
+GTK+ 
+<A HREF="http://www.gtk.org/tutorial/">&lt;http://www.gtk.org/tutorial/&gt;</A>, el cual está en desarrollo
+activo. Este tutorial le introducirá en la escritura de aplicaciones 
+utilizando C.
+<P>El Tutor no contiene (todavía) información sobre todos los
+<EM>widgets</EM> que existen en GTK+. Para código de ejemplo sobre la
+utilización básica de todos los <EM>widgets</EM> de GTK+, debe ver
+el archivo gtk/testgtk.c (y archivos fuentes asociados) en la distribución
+GTK+. Ver estos ejemplos le dará una buena base sobre lo que pueden hacer
+los <EM>widgets</EM>.
+<P>
+<H2><A NAME="ss4.2">4.2 ¿Qué <EM>widgets</EM> existen en GTK?</A>
+</H2>
+
+<P>El Tutor de GTK+ lista los siguientes <EM>widgets</EM>:
+<PRE>
+  GtkObject
+   +GtkData
+   | +GtkAdjustment
+   | `GtkTooltips
+   `GtkWidget
+     +GtkContainer
+     | +GtkBin
+     | | +GtkAlignment
+     | | +GtkEventBox
+     | | +GtkFrame
+     | | | `GtkAspectFrame
+     | | +GtkHandleBox
+     | | +GtkItem
+     | | | +GtkListItem
+     | | | +GtkMenuItem
+     | | | | `GtkCheckMenuItem
+     | | | |   `GtkRadioMenuItem
+     | | | `GtkTreeItem
+     | | +GtkViewport
+     | | `GtkWindow
+     | |   +GtkColorSelectionDialog
+     | |   +GtkDialog
+     | |   | `GtkInputDialog
+     | |   `GtkFileSelection
+     | +GtkBox
+     | | +GtkButtonBox
+     | | | +GtkHButtonBox
+     | | | `GtkVButtonBox
+     | | +GtkHBox
+     | | | +GtkCombo
+     | | | `GtkStatusbar
+     | | `GtkVBox
+     | |   +GtkColorSelection
+     | |   `GtkGammaCurve
+     | +GtkButton
+     | | +GtkOptionMenu
+     | | `GtkToggleButton
+     | |   `GtkCheckButton
+     | |     `GtkRadioButton
+     | +GtkCList
+     |   `GtkCTree
+     | +GtkFixed
+     | +GtkList
+     | +GtkMenuShell
+     | | +GtkMenuBar
+     | | `GtkMenu
+     | +GtkNotebook
+     | +GtkPaned
+     | | +GtkHPaned
+     | | `GtkVPaned
+     | +GtkScrolledWindow
+     | +GtkTable
+     | +GtkToolbar
+     | `GtkTree
+     +GtkDrawingArea
+     | `GtkCurve
+     +GtkEditable
+     | +GtkEntry
+     | | `GtkSpinButton
+     | `GtkText
+     +GtkMisc
+     | +GtkArrow
+     | +GtkImage
+     | +GtkLabel
+     | | `GtkTipsQuery
+     | `GtkPixmap
+     +GtkPreview
+     +GtkProgressBar
+     +GtkRange
+     | +GtkScale
+     | | +GtkHScale
+     | | `GtkVScale
+     | `GtkScrollbar
+     |   +GtkHScrollbar
+     |   `GtkVScrollbar
+     +GtkRuler
+     | +GtkHRuler
+     | `GtkVRuler
+     `GtkSeparator
+       +GtkHSeparator
+       `GtkVSeparator
+</PRE>
+<P>
+<H2><A NAME="ss4.3">4.3 ¿GTK+ es seguro ante múltiples hilos?</A>
+</H2>
+
+<P>Aunque GTK+, como la mayoría de los juegos de herramientas para X,
+no es seguro ante múltiples hilos, esto no prohibe el desarrollo de 
+aplicaciones con múltiples hilos con GTK+.
+<P>Rob Browning (rlb@cs.utexas.edu) describe técnicas de hilamiento
+que pueden utilizarse con GTK+ (levemente modificado):
+<P>Básicamente existen dos enfoques principales, el primero es sencillo,
+y el segundo complicado. En el primero, simplemente hay que asegurarse
+de que todas las interacciones de GTK+ (o X) se manejan por un, y solo un,
+hilo. Cualquier otro hilo que desee dibujar algo tiene que notificarlo de
+alguna manera al hilo "GTK+", y dejarlo que maneje el trabajo real.
+<P>El segundo enfoque le permite llamar funciones de GTK+ (o X) desde cualquier
+hilo, pero requiere sincronización cuidadosa. La idea básica es crear
+una exclusión mutua de protección para X, de manera que nadie haga
+llamadas X sin primero adquirir esta exclusión mutua.
+<P>Observe que se trata de un pequeño esfuerzo, pero que le permitirá ser
+potencialmente más eficiente que un GTK+ completamente seguro ante
+múltiples hilos. Usted decide la granularidad del bloqueo de hilos.
+También debe asegurarse que el hilo que llama a gtk_main mantiene la
+cerradura cuando llama a gtk_main.
+<P>Lo siguiente por lo que hay que preocuparse ya que se tenía agarrada
+la exclusión mutua global cuando se entró a gtk_main, es que todos
+los <EM>callbacks</EM> también la tendrán. Esto significa que el
+<EM>callback</EM> debe soltarla si va a llamar a cualquier otro código
+que pueda readquirirla. De otra manera obtendrá un bloqueo mortal.
+También hay que tener agarrada la exclusión mutua cuando finalmente
+regresa del <EM>callback</EM>.
+<P>Para permitir a otros hilos, además del que llama a gtk_main, tener
+acceso a la exclusión mutua, necesitamos registrar una función de
+trabajo con GTK que nos permita liberar la exclusión mutua 
+periódicamente.
+<P>¿Por qué GTK+ no puede ser seguro ante múltiples hilos de
+manera nativa?
+<P>Complejidad, sobrecarga, y mano de obra. La proporción de programas
+con hilos es todavía razonablemente pequeña, y conseguir seguridad
+ante hilos es muy difícil y le quita tiempo valioso al trabajo
+principal de obtener una buena librería gráfica terminada. Sería
+muy agradable que GTK+ fuera seguro ante hilos "al sacarlo de la caja",
+pero no es práctico ahora mismo, y haría a GTK+ sustancialmente menos
+eficiente si no se maneja cuidadosamente.
+<P>De cualquier manera, no es una prioridad esencial ya que existen remedios
+relativamente buenos.
+<P>
+<H2><A NAME="ss4.4">4.4 ¿Cómo puedo prevenir el redibujar y reacomodar tamaños mientras cambio múltiples <EM>widgets</EM>?</A>
+</H2>
+
+<P> 
+Utilize gtk_container_disable_resize y gtk_container_enable_resize alrededor
+del código donde quiere cambiar varias cosas. Esto resultará en mayor
+velocidad ya que prevendrá tener que darle el tamaño otra vez a la
+jerarquía de <EM>widget</EM> por completo.
+<P>
+<H2><A NAME="ss4.5">4.5 ¿Cómo atrapo un evento de doble tecleo (en un <EM>widget</EM> de lista, por ejemplo)?</A>
+</H2>
+
+<P>Tim Janik escribió a la lista gtk-list (ligeramente modificado):
+<P>Defina un manejador de señal:
+<P>
+<BLOCKQUOTE><CODE>
+<PRE>
+gint
+signal_handler_event(GtkWiget *widget, GdkEvenButton *event, gpointer func_data)
+{
+  if (GTK_IS_LIST_ITEM(widget) &amp;&amp;
+       (event->type==GDK_2BUTTON_PRESS ||
+        event->type==GDK_3BUTTON_PRESS) ) {
+    printf("I feel %s clicked on button %d\",
+           event->type==GDK_2BUTTON_PRESS ? "double" : "triple",
+           event->button);
+  }
+
+  return FALSE;
+}
+</PRE>
+</CODE></BLOCKQUOTE>
+<P>Y conecte el manejador a su objeto:
+<P>
+<BLOCKQUOTE><CODE>
+<PRE>
+{
+  /* lista, asuntos de inicializacion de articulos de lista */     
+
+  gtk_signal_connect(GTK_OBJECT(list_item),
+                     "button_press_event",
+                     GTK_SIGNAL_FUNC(signal_handler_event),
+                     NULL);
+
+  /* y/o */
+
+  gtk_signal_connect(GTK_OBJECT(list_item),
+                     "button_release_event",
+                     GTK_SIGNAL_FUNC(signal_handler_event),
+                     NULL);
+
+  /* algo mas */
+}
+</PRE>
+</CODE></BLOCKQUOTE>
+<P>y, Owen Taylor escribió:
+<P>Observe que se recibirá la pulsación del botón de antemano, y
+si está haciendo esto para un botón, también obtendrá una señal
+de "tecleado" para el botón. (Esto es cierto para cualquier juego de
+herramientas, ya que las computadoras no son buenas para leer la mente de
+cada quien.)
+<P>
+<H2><A NAME="ss4.6">4.6 ¿Cómo puedo averiguar cuál es la selección de un GtkList?</A>
+</H2>
+
+<P>
+<P>Consiga la selección con algo como esto:
+<BLOCKQUOTE><CODE>
+<PRE>
+GList *sel;
+sel = GTK_LIST(list)->selection;
+</PRE>
+</CODE></BLOCKQUOTE>
+<P>Así es como GList está definido (sacado de glist.h):
+<BLOCKQUOTE><CODE>
+<PRE>
+typedef struct _GList GList;
+
+struct _GList
+{
+  gpointer data;
+  GList *next;
+  GList *prev;
+};
+</PRE>
+</CODE></BLOCKQUOTE>
+<P>Una estructura GList es simplemente una estructura para listas doblemente
+enlazadas. Existen varias funciones g_list_*() para modificar una lista
+enlazada en glib.h. Sin embargo, la selección GTK_LIST(MyGtkList)->selection
+es mantenida por las funciones gtk_list_*() y no deben ser modificadas.
+<P>El selection_mode del GtkList determina las facilidades de selección de un
+GtkList y por lo tanto los contenidos de GTK_LIST(AnyGtkList)->selection:
+<P>
+<PRE>
+selection_mode          GTK_LIST()->selection contents
+------------------------------------------------------
+
+GTK_SELECTION_SINGLE)   la selección es NULL
+                        o contiene un puntero GList*
+                        para un artículo seleccionado individualmente
+
+GTK_SELECTION_BROWSE)   la selección es NULL si la lista
+                        no contiene widgets, de otra manera
+                        contiene un puntero GList*
+                        para una estructura GList.
+GTK_SELECTION_MULTIPLE) la selección es NULL si no se seleccionan
+                        listitems para un apuntador GList*
+                        para el primer artículo seleccionado. Eso en
+                        su lugar apunta a una estructura GList para el
+                        segundo artículo seleccionado y continúa
+
+GTK_SELECTION_EXTENDED) la selección es NULL.
+</PRE>
+<P>El campo data de la estructura GList GTK_LIST(MyGtkList)->selection apunta
+al primer GtkListItem que es seleccionado. De manera que si quiere determinar
+cuales listitems están seleccionados debe hacer esto:
+<P>Durante la in>
+<HR><H3>Transfer interrupted!</H3>
+>
+{
+        gchar           *list_items[]={
+                                "Item0",
+                                "Item1",
+                                "foo",
+                                "last Item",
+                        };
+        guint           nlist_items=sizeof(list_items)/sizeof(list_items[0]);
+        GtkWidget       *list_item;
+        guint           i;
+
+        list=gtk_list_new();
+        gtk_list_set_selection_mode(GTK_LIST(list), GTK_SELECTION_MULTIPLE);
+        gtk_container_add(GTK_CONTAINER(AnyGtkContainer), list);
+        gtk_widget_show (list);
+
+        for (i = 0; i &lt; nlist_items; i++)
+        {
+                list_item=gtk_list_item_new_with_label(list_items[i]);
+                gtk_object_set_user_data(GTK_OBJECT(list_item), (gpointer)i);
+                gtk_container_add(GTK_CONTAINER(list), list_item);
+                gtk_widget_show(list_item);
+        }
+}
+</PRE>
+</CODE></BLOCKQUOTE>
+<P>Para tener conocimiento de la inicialización:
+<BLOCKQUOTE><CODE>
+<PRE>
+{
+        GList   *items;
+
+        items=GTK_LIST(list)->selection;
+
+        printf("Selected Items: ");
+        while (items) {
+                if (GTK_IS_LIST_ITEM(items->data))
+                        printf("%d ", (guint) 
+                gtk_object_get_user_data(items->data));
+                items=items->next;
+        }
+        printf("\n");
+}
+</PRE>
+</CODE></BLOCKQUOTE>
+<H2><A NAME="ss4.7">4.7 ¿Acaso es posible desplegar un texto que se recorte para que quepa dentro del lugar que tenga asignado?</A>
+</H2>
+
+<P>El comportamiento de GTK+ (sin recorte) es una consecuencia de sus intentos
+para conservar recursos de X. Los <EM>widgets</EM> etiqueta (entre otros) no
+tienen su propia ventana X - simplemente dibujan su contenido en la ventana
+de su padre. Aunque sería posible hacer que ocurran recortes al establecer
+la máscara de recorte antes de dibujar el texto, esto podría causar una
+penalización substancial en el rendimiento.
+<P>Es posible que, a largo plazo, la mejor solución a tales problemas sea
+simplemente cambiar gtk para que le de ventanas X a las etiquetas. Un remedio
+a corto plazo es poner el <EM>widget</EM> de etiqueta dentro de otro 
+<EM>widget</EM> que sí obtiene su propia ventana - un candidato posible puede ser el <EM>widget</EM> <EM>viewport</EM>.
+<P>
+<BLOCKQUOTE><CODE>
+<PRE>
+viewport = gtk_viewport (NULL, NULL);
+gtk_widget_set_usize (viewport, 50, 25);
+gtk_viewport_set_shadow_type (GTK_VIEWPORT(viewport), GTK_SHADOW_NONE);
+gtk_widget_show(viewport);
+
+label = gtk_label ("a really long label that won't fit");
+gtk_container_add (GTK_CONTAINER(viewport), label);
+gtk_widget_show (label);
+</PRE>
+</CODE></BLOCKQUOTE>
+<P>Si estuviera haciendo esto para un montón de <EM>widgets</EM>, querrá
+copiar gtkviewport.c y arrancar la funcionalidad de sombra y ajuste (tal vez
+quiera llamarlo GtkClipper).
+<P>
+<H2><A NAME="ss4.8">4.8 ¿Por qué el contenido de un botón no se mueve al presionar el botón? Aquí les envío un parche para que funcione de esa forma...</A>
+</H2>
+
+<P>De: Peter Mattis
+<P>La razón por la cuál los botones no mueven a su hijo abajo y a la derecha
+cuando son presionados es porque no me parece que eso es lo que ocurre
+visualmente. Mi visión de los botonos es que los miras de manera recta.
+O sea, la interface de usuario tiende sobre un plano y tú estás sobre
+él observándolo de manera recta. Cuando un botón es presionado se
+mueve directamente lejos de tí. Para ser absolutamente correcto supongo
+que el hijo debería encojerse un poquito. Pero no veo por qué el hijo
+debería moverse abajo y a la izquierda. Recurda, el hijo se supone que
+está pegado a la superficie del botón. No es bueno que luzca como si
+el hijo se resbala sobre la superficie del botón.
+<P>En una nota más práctica, ya implanté esto una vez y determiné
+que no se veía bien y lo quité.
+<P>
+<H2><A NAME="ss4.9">4.9 ¿Cómo puedo definir una línea de separación como en un menú?</A>
+</H2>
+
+<P>Revise el 
+<A HREF="http://www.gtk.org/tutorial/">Tutor</A> para información sobre como crear menús.
+<P>Sin embargo, para crear una línea de separación en un menú,
+simplemente inserte un artículo de menú vacío:
+<P>
+<BLOCKQUOTE><CODE>
+<PRE>
+menuitem = gtk_menu_item_new();
+gtk_menu_append(GTK_MENU(menu), menuitem);
+gtk_widget_show(menuitem);
+</PRE>
+</CODE></BLOCKQUOTE>
+<P>
+<H2><A NAME="ss4.10">4.10 ¿Cómo puedo darle justificación a la derecha a un menú, como Help, cuando utilizo MenuFactory?</A>
+</H2>
+
+<P>Utilice algo como lo que sigue:
+<P>
+<BLOCKQUOTE><CODE>
+<PRE>
+menu_path = gtk_menu_factory_find (factory,  "&lt;MyApp>/Help");
+gtk_menu_item_right_justify(menu_path->widget);
+</PRE>
+</CODE></BLOCKQUOTE>
+<H2><A NAME="ss4.11">4.11 ¿Cómo hago mi ventana modal? / ¿Cómo hago una sóla ventana activa?</A>
+</H2>
+
+<P>Después de haber creado su ventana, haga gtk_grab_add(my_window). Y
+después de cerrar la ventana haga gtk_grab_remove(my_window).
+<P>
+<H2><A NAME="ss4.12">4.12 ¿Por qué mi <EM>widget</EM> (ej. progressbar) no se actualiza?</A>
+</H2>
+
+<P>
+<P>Probablemente usted está haciendo todos los cambios dentro de una función
+sin devolver el control a gtk_main. La mayoría de las actualizaciones de
+dibujo se colocan simplemente en una cola, la cual es procesada dentro de
+gtk_main. Puede forzar que se procese la cola de dibujado utilizando algo como:
+<P>
+<BLOCKQUOTE><CODE>
+<PRE>
+while (gtk_events_pending())
+        gtk_main_iteration();
+</PRE>
+</CODE></BLOCKQUOTE>
+<P>dentro de la función que cambia el <EM>widget</EM>.
+<P>Lo que el fragmento anterior hace es correr todos los eventos pendientes y
+funciones ociosas de alta prioridad, luego regresa de inmediato (el dibujado
+se realiza en una función ociosa de alta prioridad).
+<P>
+<HR NOSHADE>
+<A HREF="gtkfaq-es-5.html">Next</A>
+<A HREF="gtkfaq-es-3.html">Previous</A>
+<A HREF="gtkfaq-es.html#toc4">Contents</A>
+</BODY>
+</HTML>

docs/es/gtkfaq-es-5.html

@@ -0,0 +1,92 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<HTML>
+<HEAD>
+ <META NAME="GENERATOR" CONTENT="SGML-Tools 1.0.6">
+ <TITLE>GTK+ FAQ: Acerca de gdk</TITLE>
+ <LINK HREF="gtkfaq-es-6.html" REL=next>
+ <LINK HREF="gtkfaq-es-4.html" REL=previous>
+ <LINK HREF="gtkfaq-es.html#toc5" REL=contents>
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<A HREF="gtkfaq-es-6.html">Next</A>
+<A HREF="gtkfaq-es-4.html">Previous</A>
+<A HREF="gtkfaq-es.html#toc5">Contents</A>
+<HR NOSHADE>
+<H2><A NAME="s5">5. Acerca de gdk</A></H2>
+
+<H2><A NAME="ss5.1">5.1 ¿Qué es gdk?</A>
+</H2>
+
+<P>gdk es básicamente una envoltura alrededor de las llamadas a funciones
+Xlib. Si estás familiarizado con Xlib, muchas de las funciones en gdk 
+requerirán poco o ningún tiempo para acostumbrarse. 
+Todas las funciones están escritas para proporcionar una manera fácil de 
+acceder a las funciones Xlib en una manera un poco más intuitiva. 
+Adicionalmente, ya que gdk utiliza glib (vea abajo), será más portable
+y seguro de utilizar en
+múltiples plataformas.
+<P>
+<P>
+<H2><A NAME="ss5.2">5.2 ¿Cómo utilizo la asignación de colores?</A>
+</H2>
+
+<P>Una de las cosas agradables de GDK es que está basado sobre Xlib; esto
+también es un problema, especialmente en el área de administración
+de colores. Si usted quiere utilizar color en su programa (dibujando un 
+rectángulo o algo por el estilo, su código debe lucir algo así:
+<P>
+<BLOCKQUOTE><CODE>
+<PRE>
+{
+  GdkColor *color;
+  int width, height;
+  GtkWidget *widget;
+  GdkGC *gc;
+
+  ...
+  
+  /* primero, cree un GC (contexto grafico) en el cual dibujar */
+  gc = gdk_gc_new(widget->window);
+
+  /* encuentre las dimensiones correctas para el rectangulo */
+  gdk_window_get_size(widget->window, &amp;width, &amp;height);
+
+  /* el color que queremos utilizar */
+  color = (GdkColor *)malloc(sizeof(GdkColor));
+  
+  /* rojo, verde y azul son valores pasados, indicando el trio RGB
+   * del color que queremos dibujar. Note que los valores de los componentes 
+   * RGB dentro de GdkColor son tomados de 0 a 65535, no de 0 a 255.
+   */
+  color->red = red * (65535/255);
+  color->green = green * (65535/255);
+  color->blue = blue * (65535/255);
+  
+  /* el valor de pixel indica el indice en el mapa de colores del color.
+   * simplemente es una combinacion de los valores RGB colocados anteriormente
+   */
+  color->pixel = (gulong)(red*65536 + green*256 + blue);
+
+  /* Sin embargo, el valor de pixel es solo valido en dispositivos de 24-bit
+   * (color verdadero). Por lo tanto, esta llamada es requerida para que GDK
+   * y X puedan darnos el color mas cercano disponible en el mapa de colores
+   */
+  gdk_color_alloc(gtk_widget_get_colormap(widget), color);
+
+  /* colocar la parte delantera a nuestro color */
+  gdk_gc_set_foreground(gc, color);
+  
+  /* dibujar el rectangulo*/
+  gdk_draw_rectangle(widget->window, gc, 1, 0, 0, width, height);
+
+  ...
+}
+</PRE>
+</CODE></BLOCKQUOTE>
+<P>
+<HR NOSHADE>
+<A HREF="gtkfaq-es-6.html">Next</A>
+<A HREF="gtkfaq-es-4.html">Previous</A>
+<A HREF="gtkfaq-es.html#toc5">Contents</A>
+</BODY>
+</HTML>

docs/es/gtkfaq-es-6.html

@@ -0,0 +1,64 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<HTML>
+<HEAD>
+ <META NAME="GENERATOR" CONTENT="SGML-Tools 1.0.6">
+ <TITLE>GTK+ FAQ: Acerca de glib</TITLE>
+ <LINK HREF="gtkfaq-es-7.html" REL=next>
+ <LINK HREF="gtkfaq-es-5.html" REL=previous>
+ <LINK HREF="gtkfaq-es.html#toc6" REL=contents>
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<A HREF="gtkfaq-es-7.html">Next</A>
+<A HREF="gtkfaq-es-5.html">Previous</A>
+<A HREF="gtkfaq-es.html#toc6">Contents</A>
+<HR NOSHADE>
+<H2><A NAME="s6">6. Acerca de glib</A></H2>
+
+<H2><A NAME="ss6.1">6.1 ¿Qué es glib?</A>
+</H2>
+
+<P>glib es una librería de funciones y definiciones útiles disponibles
+para ser utilizadas cuando se crean aplicaciones GDK y GTK. Proporciona
+reemplazos para algunas funciones estándar de libc, como malloc, las 
+cuales tienen errores en algunos sistemas.
+<P>También proporciona rutinas para manejar:
+<UL>
+<LI>Listas Doblemente Enlazadas</LI>
+<LI>Listas con Enlace Sencillo</LI>
+<LI>Cronómetros</LI>
+<LI>Manipulación de cadenas</LI>
+<LI>Un Analizador Léxico</LI>
+<LI>Funciones de Error</LI>
+</UL>
+<P>         
+<P>
+<H2><A NAME="ss6.2">6.2 ¿Por qué utilizar g_print, g_malloc, g_strdup y funciones compañeras de glib?</A>
+</H2>
+
+<P>Gracias a Tim Janik que escribió a gtk-list: (ligeramente modificado)
+<BLOCKQUOTE>
+Con respecto a g_malloc(), g_free() y hermanos, estas funciones son más
+seguras que sus equivalentes en libc. Por ejemplo, g_free() solo regresa si
+se llama con NULL. También, si se define USE_DMALLOC, la definición para
+estas funciones cambia (en glib.h) para utilizar MALLOC(), FREE() etc... Si
+MEM_PROFILE o MEM_CHECK se definen, hay incluso pequeñas estadísticas
+realizadas las cuales cuentan los tamaños de los bloques (mostrado por
+g_mem_profile() / g_mem_check()).
+<P>Considerando el hecho de que glib provee una interface para salvar espacio en
+pedazos de memoria si se tiene varios bloques que son siempre del mismo
+tamaño y para marcarlos ALLOC_ONLY si es necesario, es sencillo crear
+una pequeña envoltura para salvar (revisable para errores) alrededor del
+malloc/free normal asimismo - igual que gdk cubre Xlib. ;)
+<P>Utilizar g_error() y g_warning() dentro de aplicaciones como GIMP las cuales
+utilizan gtk por completo incluso da la oportunidad de hacer saltar una ventana
+que muestre los mensajes dentro de una ventana gtk con tu propio handler
+(utilizando g_set_error_handler()) con el mismo estilo que gtk_print() 
+(dentro de gtkmain.c).
+</BLOCKQUOTE>
+<P>
+<HR NOSHADE>
+<A HREF="gtkfaq-es-7.html">Next</A>
+<A HREF="gtkfaq-es-5.html">Previous</A>
+<A HREF="gtkfaq-es.html#toc6">Contents</A>
+</BODY>
+</HTML>

docs/es/gtkfaq-es-7.html

@@ -0,0 +1,80 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<HTML>
+<HEAD>
+ <META NAME="GENERATOR" CONTENT="SGML-Tools 1.0.6">
+ <TITLE>GTK+ FAQ: Contribuciones al GTK+ FAQ, Mantenedores y Copyright</TITLE>
+ <LINK HREF="gtkfaq-es-6.html" REL=previous>
+ <LINK HREF="gtkfaq-es.html#toc7" REL=contents>
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+Next
+<A HREF="gtkfaq-es-6.html">Previous</A>
+<A HREF="gtkfaq-es.html#toc7">Contents</A>
+<HR NOSHADE>
+<H2><A NAME="s7">7. Contribuciones al GTK+ FAQ, Mantenedores y Copyright</A></H2>
+
+<P>Si desea hacer una contribución al FAQ, envíe a alguno de nosotros
+un mensaje por correo electrónico con el texto exacto que cree que
+debería ser incluído (pregunta y respuesta). ¡Con su ayuda, este
+documento puede crecer y llegar a ser más útil!
+<P>Este documento es mantenido por Nathan Froyd
+<A HREF="mailto:maestrox@geocities.com">&lt;maestrox@geocities.com&gt;</A>
+y Tony Gale 
+<A HREF="mailto:gale@gimp.org">&lt;gale@gimp.org&gt;</A>. 
+Este FAQ fue creado por Shawn T. Amundson 
+<A HREF="mailto:amundson@gimp.org">&lt;amundson@gimp.org&gt;</A> quien continúa dando soporte.
+<P>El GTK+ FAQ está registrado Copyright (C) 1997, 1998 por Shawn T. Amundson,
+Nathan Froyd y tony Gale.
+<P>Se otorga permiso para hacer y distribuír copias textuales de este manual
+siempre y cuando la información de copyright y este permiso se preserven en
+todas las copias.
+<P>Se otorga permiso para copiar y distribuir versiones modificados de este
+documento bajo las condiciones para copiado textual, siempre y cuando esta
+noticia de copyright se incluya exáctamente como en el original, y
+que el trabajo resultante en su totalidad sea distribuído bajo los
+términos de una noticia de permiso idéntica a esta.
+<P>Se otorga permiso para copiar y distribuír traducciones de este documento
+a otro lenguaje, bajo las condiciones anteriores de versiones modificadas.
+<P>Si tiene intenciones de incorporar este documento en un trabajo publicado,
+por favor contacte a uno de los mantenedores, y nos aseguraremos de que
+obtenga la información más actual posible.
+<P>No hay garantía de que este documento logre su propósito. Este documento
+se proporciona simplemente como un recurso libre. Como tal, los autores y 
+mantenedores de la información proporcionada en él no pueden dar
+garantía alguna de que la información es precisa.
+<P>
+<H2><A NAME="ss7.1">7.1 Nota del Traductor</A>
+</H2>
+
+<P>Esta traducción fue realizada por 
+<A HREF="http://www.talisman.com.pa">Ramsés Morales</A>.
+He intentado hacer
+la mejor adaptación posible de los términos técnicos, si tiene
+alguna sugerencia o mejora a estos términos y mi español, o alguna 
+duda por causa de mi traducción, no dude en comunicármelo a 
+<A HREF="mailto:ramses@computer.org">&lt;ramses@computer.org&gt;</A><P>Gracias a 
+<A HREF="mailto: e98cuenc@criens.u-psud.fr">Joaquín Cuenca</A> por todas sus sugerencias para mejorar la
+traducción, fueron de gran ayuda.
+<P>--------------------------------------
+<P>The GTK+ FAQ is Copyright (C) 1997,1998 by Shawn T. Amundson, Nathan Froyd and Tony Gale.
+<P>Permission is granted to make and distribute verbatim copies of this manual provided the 
+copyright notice and this permission notice are preserved on all copies.
+<P>Permission is granted to copy and distribute modified versions of this document under the conditions 
+for verbatim copying, provided that this copyright notice is included exactly as in the original, 
+and that the entire resulting derived work is distributed under the terms of a permission 
+notice identical to this one.
+<P>Permission is granted to copy and distribute translations of this document into another language, 
+under the above conditions for modified versions.
+<P>If you are intending to incorporate this document into a published work, please contact one of
+the maintainers, and we will make an effort to ensure that you have the most up to date 
+information available.
+<P>There is no guarentee that this document lives up to its intended
+purpose.  This is simply provided as a free resource.  As such,
+the authors and maintainers of the information provided within can 
+not make any guarentee that the information is even accurate.
+<HR NOSHADE>
+Next
+<A HREF="gtkfaq-es-6.html">Previous</A>
+<A HREF="gtkfaq-es.html#toc7">Contents</A>
+</BODY>
+</HTML>

docs/es/gtkfaq-es.html

@@ -0,0 +1,103 @@
+<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
+<HTML>
+<HEAD>
+ <META NAME="GENERATOR" CONTENT="SGML-Tools 1.0.6">
+ <TITLE>GTK+ FAQ</TITLE>
+ <LINK HREF="gtkfaq-es-1.html" REL=next>
+
+
+</HEAD>
+<BODY BGCOLOR="#FFFFFF">
+<A HREF="gtkfaq-es-1.html">Next</A>
+Previous
+Contents
+<HR NOSHADE>
+<H1>GTK+ FAQ</H1>
+
+ 
+<H2>Nathan Froyd, Tony Gale, Shawn T. Amundson.</H2>Seis de Julio de 1998
+<P><HR NOSHADE>
+<EM>La intención de este documento es dar respuesta a las preguntas
+realizadas con más frecuencia por parte de los programadores que utilizan GTK+ o simplemente por personas que desean utilizar GTK+. </EM>
+<HR NOSHADE>
+<P>
+<H2><A NAME="toc1">1.</A> <A HREF="gtkfaq-es-1.html">Información General</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-1.html#ss1.1">1.1 Autores</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.2">1.2 ¿Qué es GTK+?</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.3">1.3 ¿Qué es el + en GTK+?</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.4">1.4 ¿La G en GTK+ significa General, Gimp, o GNU?</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.5">1.5 ¿Dónde está la documentación para GTK?</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.6">1.6 ¿Hay alguna lista de correo (o archivo de lista de correo) para GTK+?</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.7">1.7 ¿La lista gtk-list no ha tenido tráfico alguno por días,</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.8">1.8 Cómo conseguir ayuda con GTK+</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.9">1.9 Cómo reportar errores en GTK+</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.10">1.10 ¿Qué aplicaciones se han escrito con GTK+?</A>
+<LI><A HREF="gtkfaq-es-1.html#ss1.11">1.11 Estoy buscando una aplicación que escribir en GTK+. ¿Qué tal un cliente IRC?</A>
+</UL>
+<P>
+<H2><A NAME="toc2">2.</A> <A HREF="gtkfaq-es-2.html">Cómo encontrar, configurar, instalar y comprobar GTK+</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-2.html#ss2.1">2.1 ¿Qué necesito para correr GTK+?</A>
+<LI><A HREF="gtkfaq-es-2.html#ss2.2">2.2 ¿Dónde puedo conseguir GTK+?</A>
+<LI><A HREF="gtkfaq-es-2.html#ss2.3">2.3 ¿Cómo configuro/compilo GTK+?</A>
+<LI><A HREF="gtkfaq-es-2.html#ss2.4">2.4 Cuando compilo GTK+ obtengo un error como: <CODE>make: file `Makefile' line 456: Syntax error</CODE></A>
+<LI><A HREF="gtkfaq-es-2.html#ss2.5">2.5 ¡He compilado e instalado GTK+, pero no puedo lograr que los programas se enlacen con él!</A>
+<LI><A HREF="gtkfaq-es-2.html#ss2.6">2.6 Cuando compilo programas con GTK+, obtengo mensajes de error del compilador diciendo que no es capaz de encontrar <CODE>"glibconfig.h"</CODE>.</A>
+<LI><A HREF="gtkfaq-es-2.html#ss2.7">2.7 Cuando instalo El GIMP, configure reporta que no puede encontrar GTK.</A>
+</UL>
+<P>
+<H2><A NAME="toc3">3.</A> <A HREF="gtkfaq-es-3.html">Desarrollo de GTK+</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-3.html#ss3.1">3.1 ¿Qué es esta cosa CVS de la cual todo el mundo habla, y cómo puedo acceder a ella?</A>
+<LI><A HREF="gtkfaq-es-3.html#ss3.2">3.2 ¿Cómo puedo contribuír a GTK+?</A>
+<LI><A HREF="gtkfaq-es-3.html#ss3.3">3.3 ¿Cómo averiguo si mi parche fue aplicado, y si no, por qué no?</A>
+<LI><A HREF="gtkfaq-es-3.html#ss3.4">3.4 ¿Cuál es la política sobre la incorporación de nuevos <EM>widgets</EM> en la librería?</A>
+<LI><A HREF="gtkfaq-es-3.html#ss3.5">3.5 ¿Hay alguien trabajando en atamientos para otros lenguajes distintos a C?</A>
+</UL>
+<P>
+<H2><A NAME="toc4">4.</A> <A HREF="gtkfaq-es-4.html">Desarrollo con GTK+</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-4.html#ss4.1">4.1 ¿Cómo empiezo?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.2">4.2 ¿Qué <EM>widgets</EM> existen en GTK?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.3">4.3 ¿GTK+ es seguro ante múltiples hilos?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.4">4.4 ¿Cómo puedo prevenir el redibujar y reacomodar tamaños mientras cambio múltiples <EM>widgets</EM>?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.5">4.5 ¿Cómo atrapo un evento de doble tecleo (en un <EM>widget</EM> de lista, por ejemplo)?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.6">4.6 ¿Cómo puedo averiguar cuál es la selección de un GtkList?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.7">4.7 ¿Acaso es posible desplegar un texto que se recorte para que quepa dentro del lugar que tenga asignado?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.8">4.8 ¿Por qué el contenido de un botón no se mueve al presionar el botón? Aquí les envío un parche para que funcione de esa forma...</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.9">4.9 ¿Cómo puedo definir una línea de separación como en un menú?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.10">4.10 ¿Cómo puedo darle justificación a la derecha a un menú, como Help, cuando utilizo MenuFactory?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.11">4.11 ¿Cómo hago mi ventana modal? / ¿Cómo hago una sóla ventana activa?</A>
+<LI><A HREF="gtkfaq-es-4.html#ss4.12">4.12 ¿Por qué mi <EM>widget</EM> (ej. progressbar) no se actualiza?</A>
+</UL>
+<P>
+<H2><A NAME="toc5">5.</A> <A HREF="gtkfaq-es-5.html">Acerca de gdk</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-5.html#ss5.1">5.1 ¿Qué es gdk?</A>
+<LI><A HREF="gtkfaq-es-5.html#ss5.2">5.2 ¿Cómo utilizo la asignación de colores?</A>
+</UL>
+<P>
+<H2><A NAME="toc6">6.</A> <A HREF="gtkfaq-es-6.html">Acerca de glib</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-6.html#ss6.1">6.1 ¿Qué es glib?</A>
+<LI><A HREF="gtkfaq-es-6.html#ss6.2">6.2 ¿Por qué utilizar g_print, g_malloc, g_strdup y funciones compañeras de glib?</A>
+</UL>
+<P>
+<H2><A NAME="toc7">7.</A> <A HREF="gtkfaq-es-7.html">Contribuciones al GTK+ FAQ, Mantenedores y Copyright</A></H2>
+
+<UL>
+<LI><A HREF="gtkfaq-es-7.html#ss7.1">7.1 Nota del Traductor</A>
+</UL>
+<HR NOSHADE>
+<A HREF="gtkfaq-es-1.html">Next</A>
+Previous
+Contents
+</BODY>
+</HTML>

docs/reference/AUTHORS

@@ -0,0 +1,7 @@
+Damon Chaplin <damon@karuna.freeserve.co.uk> and others.
+
+See:
+
+ http://www.gtk.org/rdp/status.html
+
+for a complete list.

docs/reference/COPYING

@@ -0,0 +1,30 @@
+This work may be reproduced and distributed in whole or in part, in
+any medium, physical or electronic, so as long as this copyright
+notice remains intact and unchanged on all copies.  Commercial
+redistribution is permitted and encouraged, but you may not
+redistribute, in whole or in part, under terms more restrictive than
+those under which you received it. If you redistribute a modified or
+translated version of this work, you must also make the source code to
+the modified or translated version available in electronic form
+without charge.  However, mere aggregation as part of a larger work
+shall not count as a modification for this purpose.
+
+All code examples in this work are placed into the public domain,
+and may be used, modified and redistributed without restriction.
+
+BECAUSE THIS WORK IS LICENSED FREE OF CHARGE, THERE IS NO
+WARRANTY FOR THE WORK, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
+EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
+OTHER PARTIES PROVIDE THE WORK "AS IS" WITHOUT WARRANTY OF ANY
+KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  SHOULD THE WORK PROVE DEFECTIVE, YOU ASSUME
+THE COST OF ALL NECESSARY REPAIR OR CORRECTION.
+
+IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
+WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
+AND/OR REDISTRIBUTE THE WORK AS PERMITTED ABOVE, BE LIABLE TO YOU
+FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
+CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
+WORK, EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE 
+POSSIBILITY OF SUCH DAMAGES.

docs/reference/ChangeLog

@@ -0,0 +1,251 @@
+2000-04-22  Damon Chaplin  <damon@helixcode.com>
+
+	* gtk/tmpl/gtkenums.sgml: update from Lee Mallabone
+	<lee0@callnetuk.com>
+
+2000-04-09  Damon Chaplin  <damon@helixcode.com>
+
+	* gtk/tmpl/gtkmain.sgml: update from Torsten Landschoff
+	<t.landschoff@gmx.net>
+
+	* gdk/tmpl/input_methods.sgml: 
+	* gdk/tmpl/general.sgml: fixed typos.
+
+Tue Mar 14 14:17:46 2000  Raph Levien  <raph@acm.org>
+
+	* gdk/tmpl/rgb.sgml: Better explanation of gdk_rgb_set_min_colors.
+	Thanks to Stric for spotting it.
+
+2000-03-07  Damon Chaplin  <damon@helixcode.com>
+
+	* gtk/tmpl/gtkclist.sgml: fix to gtk_clist_set_reorderable(). It
+	reorders rows, not columns. From Guy Harris <gharris@flashcom.net>.
+
+2000-02-29  Damon Chaplin  <damon@helixcode.com>
+
+	* gtk/tmpl/gtkmenuitem.sgml: minor fix from Nicolas GEORGE
+	<nicolas.george@ens.fr>.
+
+2000-02-28  Damon Chaplin  <damon@helixcode.com>
+
+	* gtk/tmpl/gtkradiomenuitem.sgml: 
+	* gtk/tmpl/gtkmenuitem.sgml: 
+	* gtk/tmpl/gtknotebook.sgml: new menu item sections and minor update to
+	notebook section from Nicolas GEORGE <nicolas.george@ens.fr>.
+
+2000-02-18  Damon Chaplin  <damon@helixcode.com>
+
+	* gtk/tmpl/gtktooltips.sgml: patch from
+	David Benson <daveb@idealab.com> to note that gtk_tooltips_set_colors()
+	does not work.
+
+2000-02-09  Damon Chaplin  <damon@helixcode.com>
+
+	* gdk/tmpl/input_methods.sgml: minor fix.
+
+2000-02-03  Damon Chaplin  <damon@karuna.freeserve.co.uk>
+
+	* gdk/gdk-sections.txt: rearranged a bit.
+
+	* gdk/tmpl/event_structs.sgml: updated.
+
+	* gtk/gtk-sections.txt: added INCLUDE tag for Private Info section.
+
+	* gdk/tmpl/color_contexts.sgml: added note saying it is deprecated.
+	* gdk/tmpl/dnd.sgml: added note saying read the GTK+ DnD docs.
+
+2000-02-02  Damon Chaplin  <damon@karuna.freeserve.co.uk>
+
+	* gdk/tmpl/*.sgml: ran make templates.
+
+	* gdk/gdk-docs.sgml: rearranged sections.
+
+	* gdk/tmpl/events.sgml: documented.
+
+	* gdk/tmpl/general.sgml: documented.
+
+	* gdk/tmpl/rgb.sgml: fixed a few '@' -> '#'.
+
+	* gdk/gdk-sections.txt: rearranged a few bits, including moving
+	GdkWChar and related functions from the input method section to the
+	font section, and GdkCapStyle etc. from Drawing Primitives to GCs.
+
+	* gdk/tmpl/images.sgml: documented.
+
+	* gdk/tmpl/drawing.sgml: updated.
+
+	* gdk/tmpl/regions.sgml: updated.
+
+	* gdk/tmpl/input_contexts.sgml: documented.
+
+	* gdk/tmpl/input_methods.sgml: documented.
+
+	* gdk/tmpl/selections.sgml: changed xref to a link since Jade says
+	a xref to a RefEntry is not supported.
+
+2000-01-19  Damon Chaplin  <damon@karuna.freeserve.co.uk>
+
+	* gtk/tmpl/gtkscrollbar.sgml: Started.
+
+2000-01-08  Damon Chaplin  <damon@karuna.freeserve.co.uk>
+
+	* gtk/tmpl/gtkclist.sgml: update from Paul Schifferer
+	<isengard@geocities.com>
+
+Wed Jan  5 10:23:41 2000  Owen Taylor  <otaylor@redhat.com>
+
+	* gtk/tmpl/gtkprogress.sgml: Missing </listitem>, remove extra <para>
+	* gtk/tmpl/gtkobject.sgml: dos2unix
+	* gtk/tmpl/gtkcurve.sgml: missing </para>
+	* gtk/tmpl/gtkarg.sgml: dos2unix, missing </para>
+	* gtk/tmpl/gtkcolorsel.sgml: Missing </listitem>'s
+	* gtk/tmpl/gtksignal.sgml (signal): dos2unix, missing </para>'s
+	* gtk/tmpl/gtkmarshal.sgml: Missing </refsect2>
+
+1999-11-16  Damon Chaplin  <damon@karuna.freeserve.co.uk>
+
+	* gtk/tmpl/gtkmenubar.sgml: fixed minor error - using <em>.
+
+	* gtk/tmpl/gtknotebook.sgml: 
+	* gtk/tmpl/gtklist.sgml: new sections from
+	Nicolas George <george@clipper.ens.fr>, with help from
+	"Bob Springett"	<bobspringett@claranet.fr>.
+
+	* gtk/tmpl/gtkobject.sgml: 
+	* gtk/tmpl/gtkarg.sgml: new sections from
+	David Benson <daveb@idealab.com>.
+
+	* gtk/tmpl/gtkvbox.sgml: 
+	* gtk/tmpl/gtkhbox.sgml: fixed line endings.
+
+	* gtk/tmpl/gtkvbbox.sgml: update from Lee Mallabone
+	<lee0@callnetuk.com>
+
+	* gdk/tmpl/drawing.sgml: fixed error in gdk_draw_arc() @angle2 param
+	- it is relative to @angle1 rather than from the 3 o'clock position.
+
+	* gtk/tmpl/gtkfontseldlg.sgml: changed enums to use @ fields.
+
+	* gtk/tmpl/gtkcolorsel.sgml: 
+	* gtk/tmpl/gtkcolorseldlg.sgml: 
+	* gtk/tmpl/gtkprogress.sgml: 
+	* gtk/tmpl/gtkprogressbar.sgml: new sections from Tom Martone
+	<tom@martoneconsulting.com>
+
+	* gtk/tmpl/gtkclist.sgml: partially written documentation from
+	Paul Schifferer <isengard@geocities.com> who won't be able to finish it
+
+1999-09-22  Martin Norbäck  <d95mback@dtek.chalmers.se>
+	
+	* gtk/tmpl/gtkclist.sgml: Added information about the sorting functions
+
+Tue Oct 26 16:50:15 1999  Owen Taylor  <otaylor@redhat.com>
+
+	* gtk/tmpl/gtkrc.sgml: Added information about widget
+	paths and pattern matching.
+
+1999-09-22  Damon Chaplin  <damon@karuna.freeserve.co.uk>
+
+	* gtk/tmpl/*.sgml: ran make templates, to fix problems with structs.
+
+	* gtk/gtk-sections.txt: rearranged GtkCombo section.
+
+	* gtk/tmpl/gtkvseparator.sgml: 
+	* gtk/tmpl/gtkhseparator.sgml: 
+	* gtk/tmpl/gtkgc.sgml: 
+	* gtk/tmpl/gtkfeatures.sgml: 
+	* gtk/tmpl/gtktipsquery.sgml: 
+	* gtk/tmpl/gtkitem.sgml: 
+	* gtk/tmpl/gtkinvisible.sgml: 
+	* gtk/tmpl/gtkgamma.sgml: 
+	* gtk/tmpl/gtkdata.sgml: 
+	* gtk/tmpl/gtkcurve.sgml: 
+	* gtk/tmpl/gtkcombo.sgml: 
+	* gtk/tmpl/gtkaccellabel.sgml: documented.
+
+1999-09-20  Damon Chaplin  <damon@karuna.freeserve.co.uk>
+
+	* gtk/gtk-docs.sgml: added role="no-toc" to the GTK+ Widgets & Objects
+	chapter since we've created our own special contents page.
+
+1999-09-19  Damon Chaplin  <damon@karuna.freeserve.co.uk>
+
+	* gtk/tmpl/gtkmarshal.sgml: 
+	* gtk/tmpl/gtksignal.sgml: new sections from 
+         David Benson <daveb@idealab.com>.
+
+	* gtk/gtk-sections.txt: rearranged signal sections, and made most
+	marshallers private. Moved GtkSignalRunType to signals section.
+
+	* gtk/tmpl/gtkradiobutton.sgml: new section from Lee Mallabone.
+
+1999-09-17  Damon Chaplin  <damon@karuna.freeserve.co.uk>
+
+	* gtk/gtk-docs.sgml: removed menu factory and debugging sections.
+
+	* gtk/gtk-sections.txt: made menu factory stuff private since it is
+	deprecated. Also made debugging stuff private since it is only useful
+	within GTK+.
+
+1999-09-14  Damon Chaplin  <damon@karuna.freeserve.co.uk>
+
+	* gtk/tmpl/gtkfilesel.sgml: fixed mismatched parentheses.
+
+1999-09-02  Damon Chaplin  <damon@karuna.freeserve.co.uk>
+
+	* gdk/tmpl/event_structs.sgml: 
+	* gdk/tmpl/drawing.sgml: minor fixes.
+
+1999-09-20  David C. Mason  <dcm@redhat.com>
+
+	* gtk/tmpl/gtkimage.sgml: first pass at gtkimage... not complete
+
+1999-08-28  Damon Chaplin  <damon@karuna.freeserve.co.uk>
+
+	* gtk/tmpl/gtkbbox.sgml: new section from Lee Mallabone.
+
+	* gdk/gdk-sections.txt: rearranged rgb, regions, and drawing sections.
+
+	* gdk/tmpl/rgb.sgml: new section from Raph Levien, with a few changes
+	by me, including a little example app.
+
+	* gdk/tmpl/regions.sgml: 
+	* gdk/tmpl/event_structs.sgml: 
+	* gdk/tmpl/drawing.sgml: my first attempt.
+	* gdk/tmpl/cursors.sgml: tiny changes.
+
+Tue Aug 17 09:14:01 1999  Owen Taylor  <otaylor@redhat.com>
+
+	* gtk/tmpl/gtktypeutils.sgml: Fix corrupted end tag.
+
+	* gtk/tmpl/gtkselection.sgml gtk/tmpl/gtkrc.sgml
+	  gtk/tmpl/gtkdnd.sgml gtk/tmpl/gtkarrow.sgml
+	  gtk/tmpl/gtkpaned.sgml gtk/tmpl/gtkmisc.sgml
+	  gtk/tmpl/gtkhandlebox.sgml gtk/tmpl/gtkctree.sgml:
+	Added missing close tags.
+
+Thu Aug 19 14:43:08 1999  Owen Taylor  <otaylor@redhat.com>
+
+	* gdk/tmpl/gcs.sgml gdk/gdk-sections.txt: Added section. 
+	  (Written a while ago but fell through the cracks)
+
+	* gtk/gtk-docs.sgml: Add a &hash; entity here as a
+	  temporary hack. (There is no standard entity
+	  for '#', and no way of escaping '#' in gtk-doc)
+
+	* gtk/tmpl/gtkrc.sgml: Use the above to fix up #rrggbb
+	  string literals.
+
+	* gtk/tmpl/gtkdrawingarea.sgml: Fixed a couple
+	  of errors in the example. (pointed out by
+	  Nick Lamb)
+
+Mon Aug 16 6:60:53 1999  Owen Taylor  <otaylor@redhat.com>
+
+	* gdk/tmpl/properties.sgml
+	  gdk/tmpl/selections.sgml
+	  gdk/tmpl/input_devices.sgml: Documented
+
+	* gdk/gdk-sections.txt: Moved around types for
+	  input devices properties and selections, marked
+	  a few functions as private.

docs/reference/README

@@ -0,0 +1,62 @@
+This package contains the reference documentation
+for GTK+. For more information about GTK+
+see:
+
+ http://www.gtk.org
+
+For information about contributing to the
+GLib/GTK+ reference documentation project, see:
+
+ http://www.gtk.org/rdp/
+
+The GTK+ reference documentation is freely redistributable,
+see the file COPYING for details.
+
+
+REQUIREMENTS
+============
+
+To build the documentation, you must have the gtk-doc
+package installed. To rebuild the template files,
+you must have the current version of the GTK+
+header files installed.
+
+
+BUILD
+=====
+
+First, run configure to generate the makefiles for this
+module. There is one option specific to this package
+
+  --with-html-dir=DIR   top of installed HTML documentation tree
+
+
+The Makefiles in the gdk/ and gtk/ subdirs each define three targets:
+
+ templates:
+  
+  Scan the headers and merge the results with the current 
+  template files
+
+ sgml:
+
+  Generate SGML files using the DocBook DTD from
+  the template files
+
+ html:
+
+  Generate HTML from the SGML files.
+
+To build the documentation, do:
+
+ make sgml
+ make html
+
+You should only run the 'make templates' step if you
+need to regenerate the templates for a more recent
+version of the GTK+ sources.
+
+INSTALLATION
+============
+
+ make install

docs/reference/README.cvs-commits

@@ -0,0 +1,39 @@
+Before making any changes to this module, please
+contact:
+
+  Damon Chaplin <damon@karuna.freeserve.co.uk>
+
+This will ensure that duplicate work does not occur,
+and also make sure we know who has written what
+parts of the documentation. See 
+
+ http://www.gtk.org/rdp/
+
+for more information.
+
+By contributing work to the Reference Documentation
+Project, you agree that it will be covered under the
+license terms described in the file COPYING
+included in this directory.
+
+
+Other notes:
+
+- Do not run 'make templates' unless you have
+  the latest cvs version of the gtk-1-2
+  branch of GTK+ and the latest CVS version
+  of gtk-doc.
+
+  (This is very important. Otherwise, the template
+  files may be come corrupted.)
+
+  Make sure that gtk-config --prefix points
+  to the correct version of GTK+.
+
+- As always, ChangeLog entries should be made for
+  each commit. These can be really brief
+  "documented GHashTable"; but if you are editing
+  something someone else wrote, please be specific.
+  (Or better, send the changes to them for their
+  approval, first)
+

docs/reference/gdk-pixbuf/.cvsignore

@@ -0,0 +1,5 @@
+Makefile
+Makefile.in
+html
+sgml
+gdk-pixbuf.html

docs/reference/gdk-pixbuf/Makefile.am

@@ -0,0 +1,110 @@
+## Process this file with automake to produce Makefile.in
+
+# The name of the module.
+DOC_MODULE=gdk-pixbuf
+
+# The top-level SGML file.
+DOC_MAIN_SGML_FILE=gdk-pixbuf.sgml
+
+# The directory containing the source code (if it contains documentation).
+DOC_SOURCE_DIR=$(GDK_PIXBUF_DIR)/gdk-pixbuf
+
+CFLAGS=`gnome-config --cflags gnomeui gdk_pixbuf gnomecanvaspixbuf`
+LDFLAGS=`gnome-config --libs gnomeui gdk_pixbuf gnomecanvaspixbuf`
+
+HTML_DIR=$(datadir)/gnome/html
+
+TARGET_DIR=$(HTML_DIR)/$(DOC_MODULE)
+
+tmpl_sources =					\
+	tmpl/animation.sgml			\
+	tmpl/creating.sgml			\
+	tmpl/file-loading.sgml			\
+	tmpl/from-drawables.sgml		\
+	tmpl/gdk-pixbuf-loader.sgml		\
+	tmpl/gdk-pixbuf-unused.sgml		\
+	tmpl/gdk-pixbuf.sgml			\
+	tmpl/gnome-canvas-pixbuf.sgml		\
+	tmpl/refcounting.sgml			\
+	tmpl/rendering.sgml			\
+	tmpl/scaling.sgml			\
+	tmpl/util.sgml
+
+gdk_pixbuf_docdir = $(HTML_DIR)
+gdk_pixbuf_doc_DATA =			\
+	gdk-pixbuf.html			\
+	gdk-pixbuf.hierarchy		\
+	gdk-pixbuf.types		\
+	gdk-pixbuf-decl.txt		\
+	gdk-pixbuf-sections.txt
+
+content_files =				\
+	compiling.sgml			\
+	gdk-pixbuf.sgml
+
+EXTRA_DIST = 				\
+	$(gdk_pixbuf_doc_DATA)		\
+	$(content_files)
+
+if ENABLE_GTK_DOC
+gdk-pixbuf.html: html/book1.html
+	-cd $(srcdir) && cp html/book1.html gdk-pixbuf.html
+else
+gdk-pixbuf.html:
+endif
+
+html/book1.html: sgml/gdk-pixbuf-doc.bottom $(content_files)
+	$(MAKE) html
+
+sgml/gdk-pixbuf-doc.bottom: $(tmpl_sources)
+	$(MAKE) sgml
+
+scan:
+	-(cd $(srcdir) \
+	&& env CFLAGS=$(CFLAGS) LDFLAGS=$(LDFLAGS) \
+		 gtkdoc-scanobj --module=$(DOC_MODULE) \
+	&& gtkdoc-scan --module=$(DOC_MODULE) --source-dir=$(DOC_SOURCE_DIR) --ignore-headers="pixops.h pixops-internal.h" )
+
+templates: scan
+	cd $(srcdir) && gtkdoc-mktmpl --module=$(DOC_MODULE)
+
+sgml:
+	cd $(srcdir) \
+	&& gtkdoc-mkdb --module=$(DOC_MODULE) --source-dir=$(DOC_SOURCE_DIR)
+
+html:
+	test -d $(srcdir)/html || mkdir $(srcdir)/html
+	-cd $(srcdir)/html && gtkdoc-mkhtml $(DOC_MODULE) ../$(DOC_MAIN_SGML_FILE)
+
+clean-local:
+	rm -f *~ *.bak *.signals *-unused.txt
+
+maintainer-clean-local: clean
+	cd $(srcdir) && rm -rf sgml html $(DOC_MODULE)-decl-list.txt $(DOC_MODULE)-decl.txt
+
+install-data-local:
+	$(mkinstalldirs) $(DESTDIR)$(TARGET_DIR)
+	(installfiles=`echo $(srcdir)/html/*.html`; \
+	if test "$$installfiles" = '$(srcdir)/html/*.html'; \
+	then echo '-- Nothing to install' ; \
+	else \
+	  for i in $$installfiles; do \
+	    echo '-- Installing '$$i ; \
+	    $(INSTALL_DATA) $$i $(DESTDIR)$(TARGET_DIR); \
+	  done; \
+	  echo '-- Installing $(srcdir)/html/index.sgml' ; \
+	  $(INSTALL_DATA) $(srcdir)/html/index.sgml $(DESTDIR)$(TARGET_DIR); \
+	  echo '-- Fixing Crossreferences' ; \
+	  gtkdoc-fixxref --module=$(DOC_MODULE) --html-dir=$(HTML_DIR)|| true; \
+	fi)
+
+dist-hook:
+	mkdir $(distdir)/html
+	mkdir $(distdir)/sgml
+	mkdir $(distdir)/tmpl
+	-cp $(srcdir)/html/*.html $(srcdir)/html/*.css $(distdir)/html
+	-cp $(srcdir)/tmpl/*.sgml $(distdir)/tmpl
+	-cp $(srcdir)/sgml/*.sgml $(distdir)/sgml
+	-cp $(srcdir)/sgml/*.bottom $(srcdir)/sgml/*.top $(distdir)/sgml
+
+.PHONY : html sgml templates scan

docs/reference/gdk-pixbuf/compiling.sgml

@@ -0,0 +1,109 @@
+  <appendix id="compiling">
+    <title>Compiling the <application>gdk-pixbuf</application>
+    library</title>
+
+    <para>
+      This appendix describes the special options you can use while
+      compiling the <application>gdk-pixbuf</application> library.
+    </para>
+
+    <sect1 id="building">
+      <title>Building the Library</title>
+      <para>
+	The <application>gdk-pixbuf</application> library uses the
+	standard GNU build system, using
+	<application>autoconf</application> for package configuration
+	and resolving portability issues,
+	<application>automake</application> for building makefiles
+	that comply with the GNU Coding Standards, and
+	<application>libtool</application> for building shared
+	libraries on multiple platforms.  The normal sequence for
+	compiling and installing the
+	<application>gdk-pixbuf</application> library is thus:
+
+	<literallayout>
+	  <userinput>./configure</userinput>
+	  <userinput>make</userinput>
+	  <userinput>make install</userinput>
+	</literallayout>
+      </para>
+
+      <para>
+	The standard options provided by <application>GNU
+	autoconf</application> may be passed to the
+	<command>configure</command> script.  Please see the
+	<application>autoconf</application> documentation or run
+	<command>./configure --help</command> for information about
+	the standard options.
+      </para>
+    </sect1>
+
+    <sect1 id="extra-configuration-options">
+      <title>Extra Configuration Options</title>
+
+      <para>
+	In addition to the normal options, the
+	<command>configure</command> script in the
+	<application>gdk-pixbuf</application> library supports these
+	additional arguments:
+
+	<cmdsynopsis>
+	  <command>configure</command>
+
+	  <group>
+	    <arg>--disable-modules</arg>
+	    <arg>--enable-modules</arg>
+	  </group>
+
+	  <group>
+	    <arg>--disable-gtk-doc</arg>
+	    <arg>--enable-gtk-doc</arg>
+	  </group>
+	</cmdsynopsis>
+      </para>
+
+      <formalpara>
+	<title><systemitem>--disable-modules</systemitem> and
+	  <systemitem>--enable-modules</systemitem></title>
+
+	<para>
+	  Normally <application>gdk-pixbuf</application> will try to
+	  build the image file format loaders as little shared
+	  libraries that are loaded on demand.  The
+	  <systemitem>--disable-modules</systemitem> argument
+	  indicates that they should all be built statically into the
+	  <application>gdk-pixbuf</application> library instead.  This
+	  is useful for people who need to produce statically-linked
+	  binaries.  If neither
+	  <systemitem>--disable-modules</systemitem> nor
+	  <systemitem>--enable-modules</systemitem> is specified, then
+	  the <command>configure</command> script will try to
+	  auto-detect whether shared modules work on your system.
+	</para>
+      </formalpara>
+
+      <formalpara>
+	<title><systemitem>--disable-gtk-doc</systemitem> and
+	  <systemitem>--enable-gtk-doc</systemitem></title>
+
+	<para>
+	  By default the <command>configure</command> script will try
+	  to auto-detect whether the
+	  <application>gtk-doc</application> package is installed.  If
+	  it is, then it will use it to extract and build the
+	  documentation for the <application>gdk-pixbuf</application>
+	  library.  These options can be used to explicitly control
+	  whether gtk-doc should be used or not.  If it is not used,
+	  the distributed, pre-generated HTML files will be installed
+	  instead of building them on your machine.
+	</para>
+      </formalpara>
+    </sect1>
+  </appendix>
+
+<!--
+Local variables:
+mode: sgml
+sgml-parent-document: ("gdk-pixbuf.sgml" "book" "book" "")
+End:
+-->

docs/reference/gdk-pixbuf/gdk-pixbuf-decl.txt

@@ -0,0 +1,527 @@
+<USER_FUNCTION>
+<NAME>ModulePreparedNotifyFunc</NAME>
+<RETURNS>void </RETURNS>
+GdkPixbuf *pixbuf, gpointer user_data
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>ModuleUpdatedNotifyFunc</NAME>
+<RETURNS>void </RETURNS>
+GdkPixbuf *pixbuf,
+					  guint x, guint y,
+					  guint width, guint height,
+					  gpointer user_data
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>ModuleFrameDoneNotifyFunc</NAME>
+<RETURNS>void </RETURNS>
+GdkPixbufFrame *frame,
+					    gpointer user_data
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>ModuleAnimationDoneNotifyFunc</NAME>
+<RETURNS>void </RETURNS>
+GdkPixbuf *pixbuf,
+						gpointer user_data
+</USER_FUNCTION>
+<STRUCT>
+<NAME>GdkPixbufModule</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GdkPixbufModule</NAME>
+struct GdkPixbufModule {
+	char *module_name;
+	gboolean (* format_check) (guchar *buffer, int size);
+	GModule *module;
+	GdkPixbuf *(* load) (FILE *f);
+        GdkPixbuf *(* load_xpm_data) (const char **data);
+
+        /* Incremental loading */
+
+        gpointer (* begin_load) (ModulePreparedNotifyFunc prepare_func,
+				 ModuleUpdatedNotifyFunc update_func,
+				 ModuleFrameDoneNotifyFunc frame_done_func,
+				 ModuleAnimationDoneNotifyFunc anim_done_func,
+				 gpointer user_data);
+        void (* stop_load) (gpointer context);
+        gboolean (* load_increment) (gpointer context, const guchar *buf, guint size);
+
+	/* Animation loading */
+	GdkPixbufAnimation *(* load_animation) (FILE *f);
+};
+</STRUCT>
+<FUNCTION>
+<NAME>gdk_pixbuf_get_module</NAME>
+<RETURNS>GdkPixbufModule  *</RETURNS>
+guchar *buffer, guint size
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_load_module</NAME>
+<RETURNS>void  </RETURNS>
+GdkPixbufModule *image_module
+</FUNCTION>
+<MACRO>
+<NAME>GDK_TYPE_PIXBUF_LOADER</NAME>
+#define GDK_TYPE_PIXBUF_LOADER		   (gdk_pixbuf_loader_get_type ())
+</MACRO>
+<MACRO>
+<NAME>GDK_PIXBUF_LOADER</NAME>
+#define GDK_PIXBUF_LOADER(obj)		   (GTK_CHECK_CAST ((obj), GDK_TYPE_PIXBUF_LOADER, GdkPixbufLoader))
+</MACRO>
+<MACRO>
+<NAME>GDK_PIXBUF_LOADER_CLASS</NAME>
+#define GDK_PIXBUF_LOADER_CLASS(klass)	   (GTK_CHECK_CLASS_CAST ((klass), GDK_TYPE_PIXBUF_LOADER, GdkPixbufLoaderClass))
+</MACRO>
+<MACRO>
+<NAME>GDK_IS_PIXBUF_LOADER</NAME>
+#define GDK_IS_PIXBUF_LOADER(obj)	   (GTK_CHECK_TYPE ((obj), GDK_TYPE_PIXBUF_LOADER))
+</MACRO>
+<MACRO>
+<NAME>GDK_IS_PIXBUF_LOADER_CLASS</NAME>
+#define GDK_IS_PIXBUF_LOADER_CLASS(klass)  (GTK_CHECK_CLASS_TYPE ((klass), GDK_TYPE_PIXBUF_LOADER))
+</MACRO>
+<STRUCT>
+<NAME>GdkPixbufLoader</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GdkPixbufLoader</NAME>
+struct GdkPixbufLoader
+{
+	GtkObject object;
+
+	/* < Private > */
+	gpointer private;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GdkPixbufLoaderClass</NAME>
+</STRUCT>
+<FUNCTION>
+<NAME>gdk_pixbuf_loader_get_type</NAME>
+<RETURNS>GtkType  </RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_loader_new</NAME>
+<RETURNS>GdkPixbufLoader     *</RETURNS>
+void
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_loader_write</NAME>
+<RETURNS>gboolean  </RETURNS>
+GdkPixbufLoader *loader,const guchar    *buf,size_t           count
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_loader_get_pixbuf</NAME>
+<RETURNS>GdkPixbuf           *</RETURNS>
+GdkPixbufLoader *loader
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_loader_get_animation</NAME>
+<RETURNS>GdkPixbufAnimation  *</RETURNS>
+GdkPixbufLoader *loader
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_loader_close</NAME>
+<RETURNS>void  </RETURNS>
+GdkPixbufLoader *loader
+</FUNCTION>
+<ENUM>
+<NAME>GdkColorspace</NAME>
+typedef enum {
+	GDK_COLORSPACE_RGB
+} GdkColorspace;
+</ENUM>
+<STRUCT>
+<NAME>GdkPixbuf</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GdkPixbufFrame</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GdkPixbufAnimation</NAME>
+</STRUCT>
+<USER_FUNCTION>
+<NAME>GdkPixbufDestroyNotify</NAME>
+<RETURNS>void </RETURNS>
+guchar *pixels, gpointer data
+</USER_FUNCTION>
+<USER_FUNCTION>
+<NAME>GdkPixbufLastUnref</NAME>
+<RETURNS>void </RETURNS>
+GdkPixbuf *pixbuf, gpointer data
+</USER_FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_ref</NAME>
+<RETURNS>GdkPixbuf  *</RETURNS>
+GdkPixbuf *pixbuf
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_unref</NAME>
+<RETURNS>void  </RETURNS>
+GdkPixbuf *pixbuf
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_set_last_unref_handler</NAME>
+<RETURNS>void  </RETURNS>
+GdkPixbuf          *pixbuf,GdkPixbufLastUnref  last_unref_fn,gpointer            last_unref_fn_data
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_finalize</NAME>
+<RETURNS>void  </RETURNS>
+GdkPixbuf *pixbuf
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_get_colorspace</NAME>
+<RETURNS>GdkColorspace  </RETURNS>
+const GdkPixbuf *pixbuf
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_get_n_channels</NAME>
+<RETURNS>int  </RETURNS>
+const GdkPixbuf *pixbuf
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_get_has_alpha</NAME>
+<RETURNS>gboolean  </RETURNS>
+const GdkPixbuf *pixbuf
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_get_bits_per_sample</NAME>
+<RETURNS>int  </RETURNS>
+const GdkPixbuf *pixbuf
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_get_pixels</NAME>
+<RETURNS>guchar        *</RETURNS>
+const GdkPixbuf *pixbuf
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_get_width</NAME>
+<RETURNS>int  </RETURNS>
+const GdkPixbuf *pixbuf
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_get_height</NAME>
+<RETURNS>int  </RETURNS>
+const GdkPixbuf *pixbuf
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_get_rowstride</NAME>
+<RETURNS>int  </RETURNS>
+const GdkPixbuf *pixbuf
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_new</NAME>
+<RETURNS>GdkPixbuf  *</RETURNS>
+GdkColorspace colorspace, gboolean has_alpha, int bits_per_sample,int width, int height
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_copy</NAME>
+<RETURNS>GdkPixbuf  *</RETURNS>
+const GdkPixbuf *pixbuf
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_new_from_file</NAME>
+<RETURNS>GdkPixbuf  *</RETURNS>
+const char *filename
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_new_from_data</NAME>
+<RETURNS>GdkPixbuf  *</RETURNS>
+const guchar *data,GdkColorspace colorspace,gboolean has_alpha,int bits_per_sample,int width, int height,int rowstride,GdkPixbufDestroyNotify destroy_fn,gpointer destroy_fn_data
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_new_from_xpm_data</NAME>
+<RETURNS>GdkPixbuf  *</RETURNS>
+const char **data
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_add_alpha</NAME>
+<RETURNS>GdkPixbuf  *</RETURNS>
+const GdkPixbuf *pixbuf, gboolean substitute_color,guchar r, guchar g, guchar b
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_copy_area</NAME>
+<RETURNS>void  </RETURNS>
+const GdkPixbuf *src_pixbuf,int src_x, int src_y,int width, int height,GdkPixbuf *dest_pixbuf,int dest_x, int dest_y
+</FUNCTION>
+<ENUM>
+<NAME>GdkPixbufAlphaMode</NAME>
+typedef enum {
+	GDK_PIXBUF_ALPHA_BILEVEL,
+	GDK_PIXBUF_ALPHA_FULL
+} GdkPixbufAlphaMode;
+</ENUM>
+<FUNCTION>
+<NAME>gdk_pixbuf_render_threshold_alpha</NAME>
+<RETURNS>void  </RETURNS>
+GdkPixbuf *pixbuf, GdkBitmap *bitmap,int src_x, int src_y,int dest_x, int dest_y,int width, int height,int alpha_threshold
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_render_to_drawable</NAME>
+<RETURNS>void  </RETURNS>
+GdkPixbuf *pixbuf,GdkDrawable *drawable, GdkGC *gc,int src_x, int src_y,int dest_x, int dest_y,int width, int height,GdkRgbDither dither,int x_dither, int y_dither
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_render_to_drawable_alpha</NAME>
+<RETURNS>void  </RETURNS>
+GdkPixbuf *pixbuf, GdkDrawable *drawable,int src_x, int src_y,int dest_x, int dest_y,int width, int height,GdkPixbufAlphaMode alpha_mode,int alpha_threshold,GdkRgbDither dither,int x_dither, int y_dither
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_render_pixmap_and_mask</NAME>
+<RETURNS>void  </RETURNS>
+GdkPixbuf *pixbuf,GdkPixmap **pixmap_return, GdkBitmap **mask_return,int alpha_threshold
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_get_from_drawable</NAME>
+<RETURNS>GdkPixbuf  *</RETURNS>
+GdkPixbuf *dest,GdkDrawable *src, GdkColormap *cmap,int src_x, int src_y,int dest_x, int dest_y,int width, int height
+</FUNCTION>
+<ENUM>
+<NAME>GdkInterpType</NAME>
+typedef enum {
+	GDK_INTERP_NEAREST,
+	GDK_INTERP_TILES,
+	GDK_INTERP_BILINEAR,
+	GDK_INTERP_HYPER
+} GdkInterpType;
+</ENUM>
+<FUNCTION>
+<NAME>gdk_pixbuf_scale</NAME>
+<RETURNS>void  </RETURNS>
+const GdkPixbuf *src,GdkPixbuf       *dest,int              dest_x,int              dest_y,int              dest_width,int              dest_height,double           offset_x,double           offset_y,double           scale_x,double           scale_y,GdkInterpType    interp_type
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_composite</NAME>
+<RETURNS>void  </RETURNS>
+const GdkPixbuf *src,GdkPixbuf       *dest,int              dest_x,int              dest_y,int              dest_width,int              dest_height,double           offset_x,double           offset_y,double           scale_x,double           scale_y,GdkInterpType    interp_type,int              overall_alpha
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_composite_color</NAME>
+<RETURNS>void  </RETURNS>
+const GdkPixbuf *src,GdkPixbuf       *dest,int              dest_x,int              dest_y,int              dest_width,int              dest_height,double           offset_x,double           offset_y,double           scale_x,double           scale_y,GdkInterpType    interp_type,int              overall_alpha,int              check_x,int              check_y,int              check_size,guint32          color1,guint32          color2
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_scale_simple</NAME>
+<RETURNS>GdkPixbuf  *</RETURNS>
+const GdkPixbuf *src,int              dest_width,int              dest_height,GdkInterpType    interp_type
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_composite_color_simple</NAME>
+<RETURNS>GdkPixbuf  *</RETURNS>
+const GdkPixbuf *src,int              dest_width,int              dest_height,GdkInterpType    interp_type,int              overall_alpha,int              check_size,guint32          color1,guint32          color2
+</FUNCTION>
+<ENUM>
+<NAME>GdkPixbufFrameAction</NAME>
+typedef enum {
+	GDK_PIXBUF_FRAME_RETAIN,
+	GDK_PIXBUF_FRAME_DISPOSE,
+	GDK_PIXBUF_FRAME_REVERT
+} GdkPixbufFrameAction;
+</ENUM>
+<FUNCTION>
+<NAME>gdk_pixbuf_animation_new_from_file</NAME>
+<RETURNS>GdkPixbufAnimation  *</RETURNS>
+const char         *filename
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_animation_ref</NAME>
+<RETURNS>GdkPixbufAnimation  *</RETURNS>
+GdkPixbufAnimation *animation
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_animation_unref</NAME>
+<RETURNS>void  </RETURNS>
+GdkPixbufAnimation *animation
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_animation_get_width</NAME>
+<RETURNS>int  </RETURNS>
+GdkPixbufAnimation *animation
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_animation_get_height</NAME>
+<RETURNS>int  </RETURNS>
+GdkPixbufAnimation *animation
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_animation_get_frames</NAME>
+<RETURNS>GList               *</RETURNS>
+GdkPixbufAnimation *animation
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_animation_get_num_frames</NAME>
+<RETURNS>int  </RETURNS>
+GdkPixbufAnimation *animation
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_frame_get_pixbuf</NAME>
+<RETURNS>GdkPixbuf            *</RETURNS>
+GdkPixbufFrame *frame
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_frame_get_x_offset</NAME>
+<RETURNS>int  </RETURNS>
+GdkPixbufFrame *frame
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_frame_get_y_offset</NAME>
+<RETURNS>int  </RETURNS>
+GdkPixbufFrame *frame
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_frame_get_delay_time</NAME>
+<RETURNS>int  </RETURNS>
+GdkPixbufFrame *frame
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_frame_get_action</NAME>
+<RETURNS>GdkPixbufFrameAction  </RETURNS>
+GdkPixbufFrame *frame
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_preinit</NAME>
+<RETURNS>void  </RETURNS>
+gpointer app, gpointer modinfo
+</FUNCTION>
+<FUNCTION>
+<NAME>gdk_pixbuf_postinit</NAME>
+<RETURNS>void  </RETURNS>
+gpointer app, gpointer modinfo
+</FUNCTION>
+<MACRO>
+<NAME>GNOME_TYPE_CANVAS_PIXBUF</NAME>
+#define GNOME_TYPE_CANVAS_PIXBUF            (gnome_canvas_pixbuf_get_type ())
+</MACRO>
+<MACRO>
+<NAME>GNOME_CANVAS_PIXBUF</NAME>
+#define GNOME_CANVAS_PIXBUF(obj)            (GTK_CHECK_CAST ((obj),		\
+					     GNOME_TYPE_CANVAS_PIXBUF, GnomeCanvasPixbuf))
+</MACRO>
+<MACRO>
+<NAME>GNOME_CANVAS_PIXBUF_CLASS</NAME>
+#define GNOME_CANVAS_PIXBUF_CLASS(klass)    (GTK_CHECK_CLASS_CAST ((klass),	\
+					     GNOME_TYPE_CANVAS_PIXBUF, GnomeCanvasPixbufClass))
+</MACRO>
+<MACRO>
+<NAME>GNOME_IS_CANVAS_PIXBUF</NAME>
+#define GNOME_IS_CANVAS_PIXBUF(obj)         (GTK_CHECK_TYPE ((obj), GNOME_TYPE_CANVAS_PIXBUF))
+</MACRO>
+<MACRO>
+<NAME>GNOME_IS_CANVAS_PIXBUF_CLASS</NAME>
+#define GNOME_IS_CANVAS_PIXBUF_CLASS(klass) (GTK_CHECK_CLASS_TYPE ((klass),	\
+					     GNOME_TYPE_CANVAS_PIXBUF))
+</MACRO>
+<STRUCT>
+<NAME>GnomeCanvasPixbuf</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GnomeCanvasPixbufClass</NAME>
+</STRUCT>
+<STRUCT>
+<NAME>GnomeCanvasPixbuf</NAME>
+struct GnomeCanvasPixbuf {
+	GnomeCanvasItem item;
+
+	/* Private data */
+	gpointer priv;
+};
+</STRUCT>
+<FUNCTION>
+<NAME>gnome_canvas_pixbuf_get_type</NAME>
+<RETURNS>GtkType  </RETURNS>
+void
+</FUNCTION>
+<MACRO>
+<NAME>GDK_PIXBUF_MAJOR</NAME>
+#define GDK_PIXBUF_MAJOR (0)
+</MACRO>
+<MACRO>
+<NAME>GDK_PIXBUF_MINOR</NAME>
+#define GDK_PIXBUF_MINOR (7)
+</MACRO>
+<MACRO>
+<NAME>GDK_PIXBUF_MICRO</NAME>
+#define GDK_PIXBUF_MICRO (0)
+</MACRO>
+<MACRO>
+<NAME>GDK_PIXBUF_VERSION</NAME>
+#define GDK_PIXBUF_VERSION "0.7.0"
+</MACRO>
+<VARIABLE>
+<NAME>gdk_pixbuf_version</NAME>
+extern const char *gdk_pixbuf_version;
+</VARIABLE>
+<STRUCT>
+<NAME>GdkPixbuf</NAME>
+struct GdkPixbuf {
+	/* Reference count */
+	int ref_count;
+
+	/* Color space */
+	GdkColorspace colorspace;
+
+	/* Number of channels, alpha included */
+	int n_channels;
+
+	/* Bits per channel */
+	int bits_per_sample;
+
+	/* Size */
+	int width, height;
+
+	/* Offset between rows */
+	int rowstride;
+
+	/* The pixel array */
+	guchar *pixels;
+
+	/* Destroy notification function; it is supposed to free the pixel array */
+	GdkPixbufDestroyNotify destroy_fn;
+
+	/* User data for the destroy notification function */
+	gpointer destroy_fn_data;
+
+	/* Last unref handler, determines whether the pixbuf should be finalized */
+	GdkPixbufLastUnref last_unref_fn;
+
+	/* User data for the last unref handler */
+	gpointer last_unref_fn_data;
+
+	/* Do we have an alpha channel? */
+	guint has_alpha : 1;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GdkPixbufFrame</NAME>
+struct GdkPixbufFrame {
+	/* The pixbuf with this frame's image data */
+	GdkPixbuf *pixbuf;
+
+	/* Offsets for overlaying onto the animation's area */
+	int x_offset;
+	int y_offset;
+
+	/* Frame duration in ms */
+	int delay_time;
+
+	/* Overlay mode */
+	GdkPixbufFrameAction action;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GdkPixbufAnimation</NAME>
+struct GdkPixbufAnimation {
+	/* Reference count */
+	int ref_count;
+
+	/* Number of frames */
+        int n_frames;
+
+	/* List of GdkPixbufFrame structures */
+        GList *frames;
+
+	/* bounding box size */
+	int width, height;
+};
+</STRUCT>

docs/reference/gdk-pixbuf/gdk-pixbuf-sections.txt

@@ -0,0 +1,120 @@
+<INCLUDE>gdk-pixbuf/gdk-pixbuf.h</INCLUDE>
+
+<SECTION>
+<FILE>gdk-pixbuf</FILE>
+GdkColorspace
+GdkPixbuf
+gdk_pixbuf_get_colorspace
+gdk_pixbuf_get_n_channels
+gdk_pixbuf_get_has_alpha
+gdk_pixbuf_get_bits_per_sample
+gdk_pixbuf_get_pixels
+gdk_pixbuf_get_width
+gdk_pixbuf_get_height
+gdk_pixbuf_get_rowstride
+</SECTION>
+
+<SECTION>
+<FILE>refcounting</FILE>
+GdkPixbufDestroyNotify
+GdkPixbufLastUnref
+gdk_pixbuf_ref
+gdk_pixbuf_unref
+gdk_pixbuf_set_last_unref_handler
+gdk_pixbuf_finalize
+</SECTION>
+
+<SECTION>
+<FILE>file-loading</FILE>
+gdk_pixbuf_new_from_file
+</SECTION>
+
+<SECTION>
+<FILE>creating</FILE>
+gdk_pixbuf_new
+gdk_pixbuf_new_from_data
+gdk_pixbuf_new_from_xpm_data
+gdk_pixbuf_copy
+</SECTION>
+
+<SECTION>
+<FILE>rendering</FILE>
+GdkPixbufAlphaMode
+gdk_pixbuf_render_to_drawable_alpha
+gdk_pixbuf_render_to_drawable
+gdk_pixbuf_render_threshold_alpha
+gdk_pixbuf_render_pixmap_and_mask
+</SECTION>
+
+<SECTION>
+<FILE>from-drawables</FILE>
+gdk_pixbuf_get_from_drawable
+</SECTION>
+
+<SECTION>
+<FILE>util</FILE>
+gdk_pixbuf_add_alpha
+gdk_pixbuf_copy_area
+</SECTION>
+
+<SECTION>
+<FILE>animation</FILE>
+GdkPixbufFrameAction
+GdkPixbufFrame
+GdkPixbufAnimation
+gdk_pixbuf_animation_new_from_file
+gdk_pixbuf_animation_ref
+gdk_pixbuf_animation_unref
+gdk_pixbuf_animation_get_frames
+gdk_pixbuf_animation_get_width
+gdk_pixbuf_animation_get_num_frames
+gdk_pixbuf_animation_get_height
+gdk_pixbuf_frame_get_pixbuf
+gdk_pixbuf_frame_get_action
+gdk_pixbuf_frame_get_y_offset
+gdk_pixbuf_frame_get_delay_time
+gdk_pixbuf_frame_get_x_offset
+</SECTION>
+
+<SECTION>
+<FILE>scaling</FILE>
+GdkInterpType
+gdk_pixbuf_scale
+gdk_pixbuf_composite
+gdk_pixbuf_composite_color
+gdk_pixbuf_scale_simple
+gdk_pixbuf_composite_color_simple
+</SECTION>
+
+<SECTION>
+<FILE>gdk-pixbuf-loader</FILE>
+GDK_PIXBUF_LOADER
+<TITLE>GdkPixbufLoader</TITLE>
+gdk_pixbuf_loader_new
+gdk_pixbuf_loader_write
+gdk_pixbuf_loader_get_pixbuf
+gdk_pixbuf_loader_get_animation
+gdk_pixbuf_loader_close
+<SUBSECTION Standard>
+GDK_TYPE_PIXBUF_LOADER
+GDK_IS_PIXBUF_LOADER
+gdk_pixbuf_loader_get_type
+GDK_PIXBUF_LOADER_CLASS
+GDK_IS_PIXBUF_LOADER_CLASS
+<SUBSECTION Private>
+GdkPixbufLoader
+</SECTION>
+
+<SECTION>
+<FILE>gnome-canvas-pixbuf</FILE>
+GNOME_CANVAS_PIXBUF
+<TITLE>GnomeCanvasPixbuf</TITLE>
+<SUBSECTION Standard>
+GNOME_TYPE_CANVAS_PIXBUF
+GNOME_IS_CANVAS_PIXBUF
+gnome_canvas_pixbuf_get_type
+GNOME_CANVAS_PIXBUF_CLASS
+GNOME_IS_CANVAS_PIXBUF_CLASS
+<SUBSECTION Private>
+GnomeCanvasPixbuf
+</SECTION>

docs/reference/gdk-pixbuf/gdk-pixbuf.args

@@ -0,0 +1,66 @@
+<ARG>
+<NAME>GnomeCanvasPixbuf::pixbuf</NAME>
+<TYPE>gpointer</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GnomeCanvasPixbuf::width</NAME>
+<TYPE>gdouble</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GnomeCanvasPixbuf::width_set</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GnomeCanvasPixbuf::width_in_pixels</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GnomeCanvasPixbuf::height</NAME>
+<TYPE>gdouble</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GnomeCanvasPixbuf::height_set</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GnomeCanvasPixbuf::height_in_pixels</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GnomeCanvasPixbuf::x</NAME>
+<TYPE>gdouble</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GnomeCanvasPixbuf::x_in_pixels</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GnomeCanvasPixbuf::y</NAME>
+<TYPE>gdouble</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GnomeCanvasPixbuf::y_in_pixels</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+

docs/reference/gdk-pixbuf/gdk-pixbuf.hierarchy

@@ -0,0 +1,4 @@
+GtkObject
+  GdkPixbufLoader
+  GnomeCanvasItem
+    GnomeCanvasPixbuf

docs/reference/gdk-pixbuf/gdk-pixbuf.sgml

@@ -0,0 +1,64 @@
+<!doctype book PUBLIC "-//Davenport//DTD DocBook V3.0//EN" [
+<!entity gdk-pixbuf-gdk-pixbuf SYSTEM "sgml/gdk-pixbuf.sgml">
+<!entity gdk-pixbuf-refcounting SYSTEM "sgml/refcounting.sgml">
+<!entity gdk-pixbuf-file-loading SYSTEM "sgml/file-loading.sgml">
+<!entity gdk-pixbuf-creating SYSTEM "sgml/creating.sgml">
+<!entity gdk-pixbuf-rendering SYSTEM "sgml/rendering.sgml">
+<!entity gdk-pixbuf-scaling SYSTEM "sgml/scaling.sgml">
+<!entity gdk-pixbuf-from-drawables SYSTEM "sgml/from-drawables.sgml">
+<!entity gdk-pixbuf-util SYSTEM "sgml/util.sgml">
+<!entity gdk-pixbuf-animation SYSTEM "sgml/animation.sgml">
+<!entity GdkPixbufLoader SYSTEM "sgml/gdk-pixbuf-loader.sgml">
+<!entity GnomeCanvasPixbuf SYSTEM "sgml/gnome-canvas-pixbuf.sgml">
+<!entity Compiling SYSTEM "compiling.sgml">
+]>
+
+<book>
+  <bookinfo>
+    <title>The <application>gdk-pixbuf</application> Library</title>
+
+    <authorgroup>
+      <author>
+	<firstname>Federico</firstname>
+	<surname>Mena Quintero</surname>
+	<affiliation>
+	  <address>
+	    <email>federico@gimp.org</email>
+	  </address>
+	</affiliation>
+      </author>
+    </authorgroup>
+
+    <copyright>
+      <year>1999</year>
+      <holder>The Free Software Foundation</holder>
+    </copyright>
+  </bookinfo>
+
+  <reference>
+    <title>API Reference</title>
+
+    <partintro>
+      <para>
+	This part presents the class and function reference for the
+	<application>gdk-pixbuf</application> library.  Classes are
+	described together with their methods; individual functions
+	are grouped by functional group.
+      </para>
+    </partintro>
+
+    &gdk-pixbuf-gdk-pixbuf;
+    &gdk-pixbuf-refcounting;
+    &gdk-pixbuf-file-loading;
+    &gdk-pixbuf-creating;
+    &gdk-pixbuf-rendering;
+    &gdk-pixbuf-scaling;
+    &gdk-pixbuf-from-drawables;
+    &gdk-pixbuf-util;
+    &gdk-pixbuf-animation;
+    &GdkPixbufLoader;
+    &GnomeCanvasPixbuf;
+  </reference>
+
+  &Compiling;
+</book>

docs/reference/gdk-pixbuf/gdk-pixbuf.signals

@@ -0,0 +1,35 @@
+<SIGNAL>
+<NAME>GdkPixbufLoader::area-updated</NAME>
+<RETURNS>void</RETURNS>
+GdkPixbufLoader *gdkpixbufloader
+gint  arg1
+gint  arg2
+gint  arg3
+gint  arg4
+</SIGNAL>
+
+<SIGNAL>
+<NAME>GdkPixbufLoader::area-prepared</NAME>
+<RETURNS>void</RETURNS>
+GdkPixbufLoader *gdkpixbufloader
+</SIGNAL>
+
+<SIGNAL>
+<NAME>GdkPixbufLoader::frame-done</NAME>
+<RETURNS>void</RETURNS>
+GdkPixbufLoader *gdkpixbufloader
+gpointer  arg1
+</SIGNAL>
+
+<SIGNAL>
+<NAME>GdkPixbufLoader::animation-done</NAME>
+<RETURNS>void</RETURNS>
+GdkPixbufLoader *gdkpixbufloader
+</SIGNAL>
+
+<SIGNAL>
+<NAME>GdkPixbufLoader::closed</NAME>
+<RETURNS>void</RETURNS>
+GdkPixbufLoader *gdkpixbufloader
+</SIGNAL>
+

docs/reference/gdk-pixbuf/gdk-pixbuf.types

@@ -0,0 +1,7 @@
+#include <gnome.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <gdk-pixbuf/gdk-pixbuf-loader.h>
+#include <gdk-pixbuf/gnome-canvas-pixbuf.h>
+
+gdk_pixbuf_loader_get_type
+gnome_canvas_pixbuf_get_type

docs/reference/gdk-pixbuf/tmpl/animation.sgml

@@ -0,0 +1,164 @@
+<!-- ##### SECTION Title ##### -->
+Animations
+
+<!-- ##### SECTION Short_Description ##### -->
+Animations as multi-frame structures.
+
+<!-- ##### SECTION Long_Description ##### -->
+  <para>
+    The <application>gdk-pixbuf</application> library provides a
+    simple mechanism to load and represent animations, primarily
+    animated GIF files.  Animations are represented as lists of
+    #GdkPixbufFrame structures.  Each frame structure contains a
+    #GdkPixbuf structure and information about the frame's overlay
+    mode and duration.
+  </para>
+
+<!-- ##### SECTION See_Also ##### -->
+  <para>
+    #GdkPixbufLoader
+  </para>
+
+<!-- ##### ENUM GdkPixbufFrameAction ##### -->
+  <para>
+    Each animation frame can have several things happen to it when the
+    next frame is displayed.  The #GdkPixbufFrameAction determines
+    this.  These are essentially the overlay modes supported by GIF
+    animations.
+  </para>
+
+@GDK_PIXBUF_FRAME_RETAIN: The previous image should remain displayed,
+and will potentially be occluded by the new frame.
+
+@GDK_PIXBUF_FRAME_DISPOSE: The animation will be reverted to the state
+before the frame was shown.
+
+@GDK_PIXBUF_FRAME_REVERT: The animation will be reverted to the first
+frame.
+
+<!-- ##### STRUCT GdkPixbufFrame ##### -->
+  <para>
+    This structure describes a frame in a #GdkPixbufAnimation.  Each
+    frame consists of a #GdkPixbuf, an offset of the frame within the
+    animation's bounding box, a duration, and an overlay mode or
+    action.
+  </para>
+
+<!-- ##### STRUCT GdkPixbufAnimation ##### -->
+  <para>
+    This structure describes an animation, which is represented as a
+    list of #GdkPixbufFrame structures.
+  </para>
+
+<!-- ##### FUNCTION gdk_pixbuf_animation_new_from_file ##### -->
+<para>
+
+</para>
+
+@filename: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_animation_ref ##### -->
+<para>
+
+</para>
+
+@animation: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_animation_unref ##### -->
+<para>
+
+</para>
+
+@animation: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_animation_get_frames ##### -->
+<para>
+
+</para>
+
+@animation: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_animation_get_width ##### -->
+<para>
+
+</para>
+
+@animation: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_animation_get_num_frames ##### -->
+<para>
+
+</para>
+
+@animation: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_animation_get_height ##### -->
+<para>
+
+</para>
+
+@animation: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_frame_get_pixbuf ##### -->
+<para>
+
+</para>
+
+@frame: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_frame_get_action ##### -->
+<para>
+
+</para>
+
+@frame: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_frame_get_y_offset ##### -->
+<para>
+
+</para>
+
+@frame: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_frame_get_delay_time ##### -->
+<para>
+
+</para>
+
+@frame: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_frame_get_x_offset ##### -->
+<para>
+
+</para>
+
+@frame: 
+@Returns: 
+
+<!--
+Local variables:
+mode: sgml
+sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
+End:
+-->

docs/reference/gdk-pixbuf/tmpl/creating.sgml

@@ -0,0 +1,100 @@
+<!-- ##### SECTION Title ##### -->
+Image Data in Memory
+
+<!-- ##### SECTION Short_Description ##### -->
+Creating a pixbuf from image data that is already in memory.
+
+<!-- ##### SECTION Long_Description ##### -->
+  <para>
+    The most basic way to create a pixbuf is to wrap an existing pixel
+    buffer with a #GdkPixbuf structure.  You can use the
+    gdk_pixbuf_new_from_data() function to do this You need to specify
+    the destroy notification function that will be called when the
+    data buffer needs to be freed; this will happen when a #GdkPixbuf
+    is finalized by the reference counting functions If you have a
+    chunk of static data compiled into your application, you can pass
+    in #NULL as the destroy notification function so that the data
+    will not be freed.
+  </para>
+
+  <para>
+    The gdk_pixbuf_new() function can be used as a convenience to
+    create a pixbuf with an empty buffer.  This is equivalent to
+    allocating a data buffer using malloc() and then wrapping it with
+    gdk_pixbuf_new_from_data().  The gdk_pixbuf_new() function will
+    compute an optimal rowstride so that rendering can be performed
+    with an efficient algorithm.
+  </para>
+
+  <para>
+    As a special case, you can use the gdk_pixbuf_new_from_xpm_data()
+    function to create a pixbuf from inline XPM image data.
+  </para>
+
+  <para>
+    You can also copy an existing pixbuf with the gdk_pixbuf_copy()
+    function.  This is not the same as just doing a gdk_pixbuf_ref()
+    on the old pixbuf; the copy function will actually duplicate the
+    pixel data in memory and create a new #GdkPixbuf structure for it.
+  </para>
+
+<!-- ##### SECTION See_Also ##### -->
+  <para>
+    gdk_pixbuf_finalize().
+  </para>
+
+<!-- ##### FUNCTION gdk_pixbuf_new ##### -->
+<para>
+
+</para>
+
+@colorspace: 
+@has_alpha: 
+@bits_per_sample: 
+@width: 
+@height: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_new_from_data ##### -->
+<para>
+
+</para>
+
+@data: 
+@colorspace: 
+@has_alpha: 
+@bits_per_sample: 
+@width: 
+@height: 
+@rowstride: 
+@destroy_fn: 
+@destroy_fn_data: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_new_from_xpm_data ##### -->
+<para>
+
+</para>
+
+@data: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_copy ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@Returns: 
+
+<!--
+Local variables:
+mode: sgml
+sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
+End:
+-->
+
+

docs/reference/gdk-pixbuf/tmpl/file-loading.sgml

@@ -0,0 +1,43 @@
+<!-- ##### SECTION Title ##### -->
+File Loading
+
+<!-- ##### SECTION Short_Description ##### -->
+Loading a pixbuf from a file.
+
+<!-- ##### SECTION Long_Description ##### -->
+  <para>
+    The <application>gdk-pixbuf</application> library provides a
+    simple mechanism for loading an image from a file in synchronous
+    fashion.  This means that the library takes control of the
+    application while the file is being loaded; from the user's point
+    of view, the application will block until the image is done
+    loading.
+  </para>
+
+  <para>
+    This interface can be used by applications in which blocking is
+    acceptable while an image is being loaded.  It can also be used to
+    load small images in general.  Applications that need progressive
+    loading can use the #GdkPixbufLoader functionality instead.
+  </para>
+
+<!-- ##### SECTION See_Also ##### -->
+  <para>
+    #GdkPixbufLoader.
+  </para>
+
+<!-- ##### FUNCTION gdk_pixbuf_new_from_file ##### -->
+<para>
+
+</para>
+
+@filename: 
+@Returns: 
+<!--
+Local variables:
+mode: sgml
+sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
+End:
+-->
+
+

docs/reference/gdk-pixbuf/tmpl/from-drawables.sgml

@@ -0,0 +1,43 @@
+<!-- ##### SECTION Title ##### -->
+Drawables to Pixbufs
+
+<!-- ##### SECTION Short_Description ##### -->
+Getting parts of a drawable's image data into a pixbuf.
+
+<!-- ##### SECTION Long_Description ##### -->
+  <para>
+    The functions in this section allow you to take the image data
+    from a GDK drawable and dump it into a #GdkPixbuf.  This can be
+    used for screenshots and other special effects.  Note that these
+    operations can be expensive, since the image data has to be
+    transferred from the X server to the client program and converted.
+  </para>
+
+<!-- ##### SECTION See_Also ##### -->
+  <para>
+    gdk_image_get().
+  </para>
+
+<!-- ##### FUNCTION gdk_pixbuf_get_from_drawable ##### -->
+<para>
+
+</para>
+
+@dest: 
+@src: 
+@cmap: 
+@src_x: 
+@src_y: 
+@dest_x: 
+@dest_y: 
+@width: 
+@height: 
+@Returns: 
+<!--
+Local variables:
+mode: sgml
+sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
+End:
+-->
+
+

docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-io.sgml

@@ -0,0 +1,70 @@
+<!-- ##### SECTION Title ##### -->
+gdk-pixbuf-io
+
+<!-- ##### SECTION Short_Description ##### -->
+
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### USER_FUNCTION ModulePreparedNotifyFunc ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@user_data: 
+
+
+<!-- ##### USER_FUNCTION ModuleUpdatedNotifyFunc ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@user_data: 
+@x: 
+@y: 
+@width: 
+@height: 
+
+
+<!-- ##### STRUCT GdkPixbufModule ##### -->
+<para>
+
+</para>
+
+@module_name: 
+@format_check: 
+@module: 
+@load: 
+@load_xpm_data: 
+@begin_load: 
+@stop_load: 
+@load_increment: 
+
+<!-- ##### FUNCTION gdk_pixbuf_get_module ##### -->
+<para>
+
+</para>
+
+@buffer: 
+@size: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_load_module ##### -->
+<para>
+
+</para>
+
+@image_module: 
+
+

docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-loader.sgml

@@ -0,0 +1,188 @@
+<!-- ##### SECTION Title ##### -->
+GdkPixbufLoader
+
+<!-- ##### SECTION Short_Description ##### -->
+Application-driven progressive image loading.
+
+<!-- ##### SECTION Long_Description ##### -->
+  <para>
+    #GdkPixbufLoader provides a way for applications to drive the
+    process of loading an image, by letting them send the image data
+    directly to the loader instead of having the loader read the data
+    from a file.  Applications can use this functionality instead of
+    gdk_pixbuf_new_from_file() when they need to parse image data in
+    small chunks.  For example, it should be used when reading an
+    image from a (potentially) slow network connection, or when
+    loading an extremely large file.
+  </para>
+
+  <para>
+    To use #GdkPixbufLoader to load an image, just create a new one,
+    and call gdk_pixbuf_loader_write() to send the data to it.  When
+    done, gdk_pixbuf_loader_close() should be called to end the stream
+    and finalize everything.  The loader will emit two important
+    signals throughout the process.  The first, "<link
+    linkend="GdkPixbufLoader-area-prepared">area_prepared</link>",
+    will be called as soon as the image has enough information to
+    determine the size of the image to be used.  It will pass a
+    @GdkPixbuf in.  If you want to use it, you can simply ref it.  In
+    addition, no actual information will be passed in yet, so the
+    pixbuf can be safely filled with any temporary graphics (or an
+    initial color) as needed.  You can also call the
+    gdk_pixbuf_loader_get_pixbuf() once this signal has been emitted
+    and get the same pixbuf.
+  </para>
+
+  <para>
+    The other signal, "<link
+    linkend="GdkPixbufLoader-area-updated">area_updated</link>" gets
+    called every time a region is updated.  This way you can update a
+    partially completed image.  Note that you do not know anything
+    about the completeness of an image from the area updated.  For
+    example, in an interlaced image, you need to make several passes
+    before the image is done loading.
+  </para>
+
+  <refsect2>
+    <title>Loading an animation</title>
+
+    <para>
+      Loading an animation is a little more complex then loading an
+      image.  In addition to the above signals, there is also a "<link
+      linkend="GdkPixbufLoader-frame-done">frame_done</link>" signal,
+      as well as an "<link
+      linkend="GdkPixbufLoader-animation-done">animation_done</link>"
+      signal.  The first lets the application know that it is dealing
+      with an animation, instead of a static image.  It also passes a
+      #GdkPixbufFrame in the signal.  As before, if you want to keep
+      the frame, you need to ref it.  Once the first "<link
+      linkend="GdkPixbufLoader-frame-done">frame_done</link>" signal
+      has been emitted, you can call gdk_pixbuf_loader_get_animation()
+      to get the #GdkPixbufAnimation struct.  Each subsequent frame
+      goes through a similar lifecycle.  For example "<link
+      linkend="GdkPixbufLoader-area-prepared">area_prepared</link>" is
+      re-emitted.  Then "<link
+      linkend="GdkPixbufLoader-area-updated">area_updated</link>" is
+      emitted as many times as necessary.  Finally, "<link
+      linkend="GdkPixbufLoader-animation-done">animation_done</link>"
+      is emitted as soon as all frames are done.
+    </para>
+  </refsect2>
+
+<!-- ##### SECTION See_Also ##### -->
+  <para>
+    gdk_pixbuf_new_from_file()
+  </para>
+
+<!-- ##### MACRO GDK_PIXBUF_LOADER ##### -->
+  <para>
+    Casts a #GtkObject to a #GdkPixbufLoader.
+  </para>
+
+@obj: A GTK+ object.
+
+
+<!-- ##### FUNCTION gdk_pixbuf_loader_new ##### -->
+<para>
+
+</para>
+
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_loader_write ##### -->
+<para>
+
+</para>
+
+@loader: 
+@buf: 
+@count: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_loader_get_pixbuf ##### -->
+<para>
+
+</para>
+
+@loader: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_loader_get_animation ##### -->
+<para>
+
+</para>
+
+@loader: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_loader_close ##### -->
+<para>
+
+</para>
+
+@loader: 
+
+
+<!-- ##### SIGNAL GdkPixbufLoader::area-updated ##### -->
+  <para>
+    This signal is emitted when a significant area of the image being
+    loaded has been updated.  Normally it means that a complete
+    scanline has been read in, but it could be a different area as
+    well.  Applications can use this signal to know when to repaint
+    areas of an image that is being loaded.
+  </para>
+
+@loader: Loader which emitted the signal.
+@x: X offset of upper-left corner of the updated area.
+@y: Y offset of upper-left corner of the updated area.
+@width: Width of updated area.
+@height: Height of updated area.
+
+<!-- ##### SIGNAL GdkPixbufLoader::area-prepared ##### -->
+  <para>
+    This signal is emitted when the pixbuf loader has been fed the
+    initial amount of data that is required to figure out the size and
+    format of the image that it will create.  After this signal is
+    emitted, applications can call gdk_pixbuf_loader_get_pixbuf() to
+    fetch the partially-loaded pixbuf.
+  </para>
+
+@loader: Loader which emitted the signal.
+
+<!-- ##### SIGNAL GdkPixbufLoader::frame-done ##### -->
+  <para>
+    This signal is emitted when a frame is done loading.  It will be
+    emitted for each frame in an animation data stream.
+  </para>
+
+@loader: Loader which emitted the signal.
+@frame: Frame which just completed loading.
+
+<!-- ##### SIGNAL GdkPixbufLoader::animation-done ##### -->
+  <para>
+    This signal is emitted when an animation is done loading.
+  </para>
+
+@loader: Loader which emitted the signal.
+
+<!-- ##### SIGNAL GdkPixbufLoader::closed ##### -->
+  <para>
+    This signal is emitted when gdk_pixbuf_loader_close() is called.
+    It can be used by different parts of an application to receive
+    notification when an image loader is closed by the code that
+    drives it.
+  </para>
+
+@loader: Loader which emitted the signal.
+
+<!--
+Local variables:
+mode: sgml
+sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
+End:
+-->
+

docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf-unused.sgml

@@ -0,0 +1,130 @@
+<!-- ##### FUNCTION gdk_pixbuf_load_module ##### -->
+<para>
+
+</para>
+
+@image_module: 
+
+<!-- ##### SECTION ./tmpl/gdk-pixbuf-io.sgml:Short_Description ##### -->
+
+
+
+<!-- ##### STRUCT GdkPixbufModule ##### -->
+<para>
+
+</para>
+
+@module_name: 
+@format_check: 
+@module: 
+@load: 
+@load_xpm_data: 
+@begin_load: 
+@stop_load: 
+@load_increment: 
+
+<!-- ##### ARG GnomeCanvasPixbuf:x_set ##### -->
+  <para>
+    Determines whether the <link
+    linkend="GnomeCanvasPixbuf--x">x</link> argument is used to
+    translate the pixbuf from its logical origin in item-relative
+    coordinates.
+  </para>
+
+
+<!-- ##### USER_FUNCTION ModulePreparedNotifyFunc ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@user_data: 
+
+<!-- ##### FUNCTION gdk_pixbuf_get_module ##### -->
+<para>
+
+</para>
+
+@buffer: 
+@size: 
+@Returns: 
+
+<!-- ##### SECTION ./tmpl/gdk-pixbuf-io.sgml:See_Also ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gdk_pixbuf_new_from_art_pixbuf ##### -->
+<para>
+
+</para>
+
+@art_pixbuf: 
+@Returns: 
+
+<!-- ##### ARG GnomeCanvasPixbuf:height_pixels ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### ARG GnomeCanvasPixbuf:y_pixels ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### SECTION ./tmpl/gdk-pixbuf-io.sgml:Long_Description ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### USER_FUNCTION ModuleUpdatedNotifyFunc ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@user_data: 
+@x: 
+@y: 
+@width: 
+@height: 
+
+<!-- ##### SECTION ./tmpl/gdk-pixbuf-io.sgml:Title ##### -->
+gdk-pixbuf-io
+
+
+<!-- ##### ARG GnomeCanvasPixbuf:y_set ##### -->
+  <para>
+    Determines whether the <link
+    linkend="GnomeCanvasPixbuf--y">y</link> argument is used to
+    translate the pixbuf from its logical origin in item-relative
+    coordinates.  Works in the same way as the <link
+    linkend="GnomeCanvasPixbuf--x-set">x_set</link> argument.  The
+    default is %FALSE.
+  </para>
+
+
+<!-- ##### ARG GnomeCanvasPixbuf:x_pixels ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gdk_pixbuf_get_format ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@Returns: 
+
+<!-- ##### ARG GnomeCanvasPixbuf:width_pixels ##### -->
+<para>
+
+</para>
+
+

docs/reference/gdk-pixbuf/tmpl/gdk-pixbuf.sgml

@@ -0,0 +1,112 @@
+<!-- ##### SECTION Title ##### -->
+The GdkPixbuf Structure
+
+<!-- ##### SECTION Short_Description ##### -->
+Information that describes an image.
+
+<!-- ##### SECTION Long_Description ##### -->
+
+  <para>
+    The <structname>GdkPixbuf</structname> structure contains
+    information that describes an image in memory.
+  </para>
+
+<!-- ##### SECTION See_Also ##### -->
+  <para>
+  </para>
+
+<!-- ##### ENUM GdkColorspace ##### -->
+  <para>
+    This enumeration defines the color spaces that are supported by
+    the <application>gdk-pixbuf</application> library.  Currently only
+    RGB is supported.
+  </para>
+
+@GDK_COLORSPACE_RGB: Indicates a red/green/blue additive color space.
+
+<!-- ##### STRUCT GdkPixbuf ##### -->
+  <para>
+    This is the main structure in the
+    <application>gdk-pixbuf</application> library.  It is used to
+    represent images.  It contains information about the image's pixel
+    data, its color space, bits per sample, width and height, and the
+    rowstride or number of bytes between rows.
+  </para>
+
+<!-- ##### FUNCTION gdk_pixbuf_get_colorspace ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_get_n_channels ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_get_has_alpha ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_get_bits_per_sample ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_get_pixels ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_get_width ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_get_height ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_get_rowstride ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@Returns: 
+
+<!--
+Local variables:
+mode: sgml
+sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
+End:
+-->

docs/reference/gdk-pixbuf/tmpl/gnome-canvas-pixbuf.sgml

@@ -0,0 +1,301 @@
+<!-- ##### SECTION Title ##### -->
+GnomeCanvasPixbuf
+
+<!-- ##### SECTION Short_Description ##### -->
+Canvas item to display #GdkPixbuf images.
+
+<!-- ##### SECTION Long_Description ##### -->
+  <para>
+    This canvas item displays #GdkPixbuf images.  It handles full
+    affine transformations in both GDK and antialiased modes, and also
+    supports the <ulink url="http://www.w3.org">W3C</ulink>'s <ulink
+    url="http://www.w3.org/Graphics/SVG/">SVG</ulink>-like scaling and
+    translation semantics for absolute pixel values.
+  </para>
+
+  <para>
+    #GdkPixbuf structures may be shared among different pixbuf canvas
+    items; the pixbuf item uses #GdkPixbuf's reference counting
+    functions for this.
+  </para>
+
+  <refsect2>
+    <title>Custom Scaling and Translation</title>
+
+    <para>
+      In addition to the normal affine transformations supported by
+      canvas items, the #GnomeCanvasPixbuf item supports independent
+      object arguments for scaling and translation.  This is useful
+      for explicitly setting a size to which the pixbuf's image will
+      be scaled, and for specifying translation offsets that take
+      place in the item's local coordinate system.
+    </para>
+
+    <para>
+      By default, the pixbuf canvas item will attain the size in units
+      of the #GdkPixbuf it contains.  If a #GnomeCanvasPixbuf is
+      configured to use a #GdkPixbuf that has a size of 300 by 200
+      pixels, then the pixbuf item will automatically obtain a size of
+      300 by 200 units in the item's local coordinate system.  If the
+      item is transformed with a scaling transformation of (0.5, 2.0),
+      then the final image size will be of 150 by 400 pixels.
+    </para>
+
+    <para>
+      To set custom width and height values, you must set the <link
+      linkend="GnomeCanvasPixbuf--width-set">width_set</link> or <link
+      linkend="GnomeCanvasPixbuf--height-set">height_set</link>
+      arguments to %TRUE, and then set the <link
+      linkend="GnomeCanvasPixbuf--width">width</link> or <link
+      linkend="GnomeCanvasPixbuf--height">height</link> arguments to
+      the desired values.  The former two arguments control whether
+      the latter two are used when computing the final image's size;
+      they are both %FALSE by default so that the pixbuf item will
+      attain a size in units equal to the size in pixels of the
+      #GdkPixbuf that the item contains.
+    </para>
+
+    <para>
+      The custom translation offsets are controlled by the <link
+      linkend="GnomeCanvasPixbuf--x">x</link> and <link
+      linkend="GnomeCanvasPixbuf--y">y</link> arguments.  The logical
+      upper-left vertex of the image will be translated by the
+      specified distance, aligned with the item's local coordinate
+      system.
+    </para>
+  </refsect2>
+
+  <refsect2>
+    <title>Absolute Pixel Scaling and Translation</title>
+
+    <para>
+      The <ulink url="http://www.w3.org/Graphics/SVG/">Scalable Vector
+      Graphics</ulink> specification (SVG) of the <ulink
+      url="http://www.w3.org">World Wide Web Consortium</ulink> also
+      allows images to be translated and scaled by absolute pixel
+      values that are independent of an item's normal affine
+      transformation.
+    </para>
+
+    <para>
+      Normally, the pixbuf item's translation and scaling arguments
+      are interpreted in units, so they will be modified by the item's
+      affine transformation.  The <link
+      linkend="GnomeCanvasPixbuf--width-in-pixels">width_in_pixels</link>,
+      <link
+      linkend="GnomeCanvasPixbuf--height-in-pixels">height_in_pixels</link>,
+      <link
+      linkend="GnomeCanvasPixbuf--x-in-pixels">x_in_pixels</link>, and
+      <link
+      linkend="GnomeCanvasPixbuf--y-in-pixels">y_in_pixels</link>
+      object arguments can be used to modify this behavior.  If one of
+      these arguments is %TRUE, then the corresponding scaling or
+      translation value will not be affected lengthwise by the pixbuf
+      item's affine transformation.
+    </para>
+
+    <para>
+      For example, consider a pixbuf item whose size is (300, 200).
+      If the item is modified with a scaling transformation of (0.5,
+      2.0) but the <link
+      linkend="GnomeCanvasPixbuf--width-in-pixels">width_in_pixels</link>
+      is set to %TRUE, then the item will appear to be (300, 400)
+      pixels in size.  This means that in this case the item's affine
+      transformation only applies to the height value, while the width
+      value is kept in absolute pixels.
+    </para>
+
+    <para>
+      Likewise, consider a pixbuf item whose (<link
+      linkend="GnomeCanvasPixbuf--x">x</link>, <link
+      linkend="GnomeCanvasPixbuf--y">y</link>) arguments are set to
+      (30, 40).  If the item is then modified by the same scaling
+      transformation of (0.5, 2.0) but the <link
+      linkend="GnomeCanvasPixbuf--y-in-pixels">y_in_pixels</link>
+      argument is set to %TRUE, then the image's upper-left corner
+      will appear to be at position (15, 40).  In this case, the
+      affine transformation is applied only to the x offset, while the
+      y offset is kept in absolute pixels.
+    </para>
+
+    <para>
+      In short, these arguments control whether a particular dimension
+      of a pixbuf item is scaled or not in the normal way by the
+      item's affine transformation.
+    </para>
+  </refsect2>
+
+  <refsect2>
+    <title>Resource Management</title>
+
+    <para>
+      When you set the #GdkPixbuf structure that a #GnomeCanvasPixbuf
+      item will use by setting the <link
+      linkend="GnomeCanvasPixbuf--pixbuf">pixbuf</link> argument, a
+      reference count will be added to that #GdkPixbuf structure.
+      When the pixbuf item no longer needs the #GdkPixbuf structure,
+      such as when the item is destroyed or when a new pixbuf
+      structure is passed to it, then the old #GdkPixbuf structure
+      will be automatically unreferenced.
+    </para>
+
+    <para>
+      This means that if an application just needs to load a pixbuf
+      image and set it into a pixbuf canvas item, it can do the
+      following to &lsquo;forget&rsquo; about the pixbuf structure:
+
+      <programlisting>
+	GdkPixbuf *pixbuf;
+	GnomeCanvasItem *item;
+
+	pixbuf = gdk_pixbuf_new_from_file ("foo.png");
+	g_assert (pixbuf != NULL);
+
+	item = gnome_canvas_item_new (gnome_canvas_root (my_canvas),
+				      gnome_canvas_pixbuf_get_type (),
+				      "pixbuf", pixbuf,
+				      NULL);
+	gdk_pixbuf_unref (pixbuf);
+      </programlisting>
+    </para>
+
+    <para>
+      After this happens, the reference count of the pixbuf structure
+      will be 1:  the gdk_pixbuf_new_from_file() function creates it
+      with a reference count of 1, then setting the <link
+      linkend="GnomeCanvasPixbuf--pixbuf">pixbuf</link> argument of
+      the #GnomeCanvasPixbuf item increases it to 2, and then it is
+      decremented to 1 by the call to gdk_pixbuf_unref().  When the
+      canvas item is destroyed, it will automatically unreference the
+      pixbuf structure again, causing its reference count to drop to
+      zero and thus be freed.
+    </para>
+  </refsect2>
+
+<!-- ##### SECTION See_Also ##### -->
+  <para>
+    #GnomeCanvas, #GdkPixbuf
+  </para>
+
+<!-- ##### MACRO GNOME_CANVAS_PIXBUF ##### -->
+  <para>
+    Casts a #GtkOjbect to a #GnomeCanvasPixbuf.
+  </para>
+
+@obj: A GTK+ object.
+
+
+<!-- ##### ARG GnomeCanvasPixbuf:pixbuf ##### -->
+  <para>
+    Contains a pointer to a #GdkPixbuf structure that will be used by
+    the pixbuf canvas item as an image source.  When a pixbuf is set
+    its reference count is incremented; if the pixbuf item kept a
+    pointer to another #GdkPixbuf structure, the reference count of
+    this structure will be decremented.  Also, the GdkPixbuf's
+    reference count will automatically be decremented when the
+    #GnomeCanvasPixbuf item is destroyed.  When a pixbuf is queried, a
+    reference count will not be added to the return value; you must do
+    this yourself if you intend to keep the pixbuf structure around.
+  </para>
+
+<!-- ##### ARG GnomeCanvasPixbuf:width ##### -->
+  <para>
+    Indicates the width the pixbuf will be scaled to.  This argument
+    will only be used if the <link
+    linkend="GnomeCanvasPixbuf--width-set">width_set</link> argument
+    is %TRUE.  If the <link
+    linkend="GnomeCanvasPixbuf--width-in-pixels">width_in_pixels</link>
+    argument is %FALSE, the width will be taken to be in canvas units,
+    and thus will be scaled along with the canvas item's affine
+    transformation.  If width_in_pixels is %TRUE, the width will be
+    taken to be in pixels, and will visually remain a constant size
+    even if the item's affine transformation changes.
+  </para>
+
+<!-- ##### ARG GnomeCanvasPixbuf:width_set ##### -->
+  <para>
+    Determines whether the <link
+    linkend="GnomeCanvasPixbuf--width">width</link> argument is taken
+    into account when scaling the pixbuf item.  If this argument is
+    %FALSE, then the width value of the pixbuf will be used instead.
+    This argument is %FALSE by default.
+  </para>
+
+<!-- ##### ARG GnomeCanvasPixbuf:width_in_pixels ##### -->
+  <para>
+    If this argument is %TRUE, then the width of the pixbuf will be
+    considered to be in pixels, that is, it will not be visually
+    scaled even if the item's affine transformation changes.  If this
+    is %FALSE, then the width of the pixbuf will be considered to be
+    in canvas units, and so will be scaled normally by affine
+    transformations.  The default is %FALSE.
+  </para>
+
+<!-- ##### ARG GnomeCanvasPixbuf:height ##### -->
+  <para>
+    Indicates the height the pixbuf will be scaled to.  This argument
+    will only be used if the <link
+    linkend="GnomeCanvasPixbuf--height-set">height_set</link> argument
+    is %TRUE.  Works in the same way as the <link
+    linkend="GnomeCanvasPixbuf--width">width</link> argument.
+  </para>
+
+<!-- ##### ARG GnomeCanvasPixbuf:height_set ##### -->
+  <para>
+    Determines whether the <link
+    linkend="GnomeCanvasPixbuf--height">height</link> argument is
+    taken into account when scaling the pixbuf item.  Works in the
+    same way as the <link
+    linkend="GnomeCanvasPixbuf--width-set">width_set</link> argument.
+    The default is %FALSE.
+  </para>
+
+<!-- ##### ARG GnomeCanvasPixbuf:height_in_pixels ##### -->
+  <para>
+    Works in the same way as the <link
+    linkend="GnomeCanvasPixbuf--width-in-pixels">width_in_pixels</link>
+    argument.  The default is %FALSE.
+  </para>
+
+<!-- ##### ARG GnomeCanvasPixbuf:x ##### -->
+  <para>
+    Indicates the horizontal translation offset of the pixbuf item's
+    image.  This offset may not actually appear horizontal, since it
+    will be affected by the item's affine transformation.  The default
+    is 0.0.
+  </para>
+
+<!-- ##### ARG GnomeCanvasPixbuf:x_in_pixels ##### -->
+  <para>
+    If this argument is %TRUE, the pixbuf's translation with respect
+    to its logical origin in item-relative coordinates will be in
+    pixels, that is, the visible offset will not change even if the
+    item's affine transformation changes.  If it is %FALSE, the
+    pixbuf's translation will be taken to be in canvas units, and thus
+    will change along with the item's affine transformation.  The
+    default is %FALSE.
+  </para>
+
+<!-- ##### ARG GnomeCanvasPixbuf:y ##### -->
+  <para>
+    Indicates the vertical translation offset of the pixbuf item's
+    image.  Works in the same way as the <link
+    linkend="GnomeCanvasPixbuf--x">x</link> argument.  The default is
+    0.0.
+  </para>
+
+<!-- ##### ARG GnomeCanvasPixbuf:y_in_pixels ##### -->
+  <para>
+    Works in the same way as the <link
+    linkend="GnomeCanvasPixbuf--x-in-pixels">x_in_pixels</link>
+    argument, but controls whether the <link
+    linkend="GnomeCanvasPixbuf--y">y</link> translation offset is
+    scaled or not.  The default is %FALSE.
+  </para>
+
+<!--
+Local variables:
+mode: sgml
+sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
+End:
+-->

docs/reference/gdk-pixbuf/tmpl/refcounting.sgml

@@ -0,0 +1,128 @@
+<!-- ##### SECTION Title ##### -->
+Reference Counting and Memory Mangement
+
+<!-- ##### SECTION Short_Description ##### -->
+
+Functions to perform reference counting and memory management on a
+#GdkPixbuf.
+
+<!-- ##### SECTION Long_Description ##### -->
+  <para>
+    #GdkPixbuf structures are reference counted.  This means that
+    an application can share a single pixbuf among many parts of the
+    code.  When a piece of the program needs to keep a pointer to a
+    pixbuf, it should add a reference to it.  When it no longer needs
+    the pixbuf, it should subtract a reference.  The pixbuf will be
+    destroyed when its reference count drops to zero.  Newly-created
+    #GdkPixbuf structures start with a reference count of one.
+  </para>
+
+  <para>
+    <emphasis>Finalizing</emphasis> a pixbuf means to free its pixel
+    data and to free the #GdkPixbuf structure itself.  Most of the
+    library functions that create #GdkPixbuf structures create the
+    pixel data by themselves and define the way it should be freed;
+    you do not need to worry about those.  The only function that lets
+    you specify how to free the pixel data is
+    gdk_pixbuf_new_from_data().  Since you pass it a pre-allocated
+    pixel buffer, you must also specify a way to free that data.  This
+    is done with a function of type #GdkPixbufDestroyNotify.  When a
+    pixbuf created with gdk_pixbuf_new_from_data() is finalized, your
+    destroy notification function will be called, and it is its
+    responsibility to free the pixel array.
+  </para>
+
+  <para>
+    As an extension to traditional reference counting, #GdkPixbuf
+    structures support defining a handler for the last unref
+    operation.  If gdk_pixbuf_unref() is called on a #GdkPixbuf
+    structure that has a reference count of 1, i.e. its last
+    reference, then the pixbuf's last unref handler function will be
+    called.  It is up to this function to determine whether to
+    finalize the pixbuf using gdk_pixbuf_finalize() or to just
+    continue execution.  This can be used to implement a pixbuf cache
+    efficiently; please see the programmer's documentation for
+    details.
+  </para>
+
+<!-- FIXME: link the last sentence above to the relevant section of
+     the programmer's docs.
+-->
+
+<!-- ##### SECTION See_Also ##### -->
+  <para>
+    #GdkPixbuf, gdk_pixbuf_new_from_data().
+  </para>
+
+<!-- ##### USER_FUNCTION GdkPixbufDestroyNotify ##### -->
+  <para>
+    A function of this type is responsible for freeing the pixel array
+    of a pixbuf.  The gdk_pixbuf_new_from_data() function lets you
+    pass in a pre-allocated pixel array so that a pixbuf can be
+    created from it; in this case you will need to pass in a function
+    of #GdkPixbufDestroyNotify so that the pixel data can be freed
+    when the pixbuf is finalized.
+  </para>
+
+@pixels: The pixel array of the pixbuf that is being finalized.
+@data: User closure data.
+
+
+<!-- ##### USER_FUNCTION GdkPixbufLastUnref ##### -->
+  <para>
+    A function of this type can be used to override the default
+    operation when a pixbuf loses its last reference, i.e. when
+    gdk_pixbuf_unref() is called on a #GdkPixbuf structure that has a
+    reference count of 1.  This function should determine whether to
+    finalize the pixbuf by calling gdk_pixbuf_finalize(), or whether
+    to just resume normal execution.  The last unref handler for a
+    #GdkPixbuf can be set using the
+    gdk_pixbuf_set_last_unref_handler() function.  By default, pixbufs
+    will be finalized automatically if no last unref handler has been
+    defined.
+  </para>
+
+@pixbuf: The pixbuf that is losing its last reference.
+@data: User closure data.
+
+
+<!-- ##### FUNCTION gdk_pixbuf_ref ##### -->
+  <para>
+
+  </para>
+
+@pixbuf: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_unref ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_set_last_unref_handler ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@last_unref_fn: 
+@last_unref_fn_data: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_finalize ##### -->
+<para>
+
+</para>
+
+@pixbuf:
+
+<!--
+Local variables:
+mode: sgml
+sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
+End:
+-->

docs/reference/gdk-pixbuf/tmpl/rendering.sgml

@@ -0,0 +1,126 @@
+<!-- ##### SECTION Title ##### -->
+Rendering
+
+<!-- ##### SECTION Short_Description ##### -->
+Rendering a pixbuf to a GDK drawable.
+
+<!-- ##### SECTION Long_Description ##### -->
+  <para>
+    The <application>gdk-pixbuf</application> library provides several
+    convenience functions to render pixbufs to GDK drawables.  It uses
+    the GdkRGB to render the image data.
+  </para>
+
+  <para>
+    At this point there is not a standard alpha channel extension for
+    the X Window System, so it is not possible to use full opacity
+    information when painting images to arbitrary drawables.  The
+    <application>gdk-pixbuf</application> convenience functions will
+    threshold the opacity information to create a bi-level clipping
+    mask (black and white), and use that to draw the image onto a
+    drawable.
+  </para>
+
+  <important>
+    <para>
+      Since these functions use GdkRGB for rendering, you must
+      initialize GdkRGB before using any of them.  You can do this by
+      calling gdk_rgb_init() near the beginning of your program.
+    </para>
+  </important>
+
+<!-- ##### SECTION See_Also ##### -->
+  <para>
+    GdkRGB
+  </para>
+
+<!-- ##### ENUM GdkPixbufAlphaMode ##### -->
+  <para>
+    These values can be passed to
+    gdk_pixbuf_render_to_drawable_alpha() to control how the alpha
+    chanel of an image should be handled.  This function can create a
+    bilevel clipping mask (black and white) and use it while painting
+    the image.  In the future, when the X Window System gets an alpha
+    channel extension, it will be possible to do full alpha
+    compositing onto arbitrary drawables.  For now both cases fall
+    back to a bilevel clipping mask.
+  </para>
+
+@GDK_PIXBUF_ALPHA_BILEVEL: A bilevel clipping mask (black and white)
+will be created and used to draw the image.  Pixels below 0.5 opacity
+will be considered fully transparent, and all others will be
+considered fully opaque.
+@GDK_PIXBUF_ALPHA_FULL: For now falls back to #GDK_PIXBUF_ALPHA_BILEVEL.
+In the future it will do full alpha compositing.
+
+<!-- ##### FUNCTION gdk_pixbuf_render_to_drawable_alpha ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@drawable: 
+@src_x: 
+@src_y: 
+@dest_x: 
+@dest_y: 
+@width: 
+@height: 
+@alpha_mode: 
+@alpha_threshold: 
+@dither: 
+@x_dither: 
+@y_dither: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_render_to_drawable ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@drawable: 
+@gc: 
+@src_x: 
+@src_y: 
+@dest_x: 
+@dest_y: 
+@width: 
+@height: 
+@dither: 
+@x_dither: 
+@y_dither: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_render_threshold_alpha ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@bitmap: 
+@src_x: 
+@src_y: 
+@dest_x: 
+@dest_y: 
+@width: 
+@height: 
+@alpha_threshold: 
+
+<!-- ##### FUNCTION gdk_pixbuf_render_pixmap_and_mask ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@pixmap_return: 
+@mask_return: 
+@alpha_threshold: 
+
+
+<!--
+Local variables:
+mode: sgml
+sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
+End:
+-->

docs/reference/gdk-pixbuf/tmpl/scaling.sgml

@@ -0,0 +1,199 @@
+<!-- ##### SECTION Title ##### -->
+Scaling
+
+<!-- ##### SECTION Short_Description ##### -->
+Scaling pixbufs and scaling and compositing pixbufs
+
+<!-- ##### SECTION Long_Description ##### -->
+  <para>
+    The <application>gdk-pixbuf</application> contains functions to
+    scale pixbufs, to scale pixbufs and composite against an existing
+    image, and to scale pixbufs and composite against a solid color or
+    checkerboard.  Compositing a checkerboard is a common way to show
+    an image with an alpha channel in image-viewing and editing
+    software.
+  </para>
+
+  <para>
+    Since the full-featured functions (gdk_pixbuf_scale(),
+    gdk_pixbuf_composite(), and gdk_pixbuf_composite_color()) are
+    rather complex to use and have many arguments, two simple
+    convenience functions are provided, gdk_pixbuf_scale_simple() and
+    gdk_pixbuf_composite_color_simple() which create a new pixbuf of a
+    given size, scale an original image to fit, and then return the
+    new pixmap.
+  </para>
+
+  <para>
+    The following example demonstrates handling an expose event by
+    rendering the appropriate area of a source image (which is scaled
+    to fit the widget) onto the widget's window.  The source image is
+    rendered against a checkerboard, which provides a visual
+    representation of the alpha channel if the image has one. If the
+    image doesn't have an alpha channel, calling
+    gdk_pixbuf_composite_color() function has exactly the same effect
+    as calling gdk_pixbuf_scale().
+  </para>
+
+  <programlisting>
+gboolean
+expose_cb (GtkWidget *widget, GdkEventExpose *event, gpointer data)
+{
+  GdkPixbuf *dest;
+
+  gdk_window_set_back_pixmap (widget->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) widget->allocation.width / gdk_pixbuf_get_width (pixbuf),
+                              (double) widget->allocation.height / gdk_pixbuf_get_height (pixbuf),
+                              GDK_INTERP_BILINEAR, 255,
+                              event->area.x, event->area.y, 16, 0xaaaaaa, 0x555555);
+
+  gdk_pixbuf_render_to_drawable (dest, widget->window, widget->style->fg_gc[GTK_STATE_NORMAL],
+                                 0, 0, event->area.x, event->area.y,
+                                 event->area.width, event->area.height,
+                                 GDK_RGB_DITHER_NORMAL, event->area.x, event->area.y);
+  
+  gdk_pixbuf_unref (dest);
+  
+  return TRUE;
+}
+  </programlisting>
+
+<!-- ##### SECTION See_Also ##### -->
+  <para>
+    GdkRGB
+  </para>
+
+<!-- ##### ENUM GdkInterpType ##### -->
+  <para>
+    This enumeration describes the different interpolation modes that
+    can be used with the scaling functions.
+
+    <note>
+      <para>
+	Cubic filtering is missing from the list; hyperbolic
+	interpolation is just as fast and results in higher quality.
+      </para>
+    </note>
+  </para>
+
+@GDK_INTERP_NEAREST: Nearest neighbor sampling; this is the fastest
+and lowest quality mode.
+
+@GDK_INTERP_TILES: This is an accurate simulation of the PostScript
+image operator without any interpolation enabled.  Each pixel is
+rendered as a tiny parallelogram of solid color, the edges of which
+are implemented with antialiasing.  It resembles nearest neighbor for
+enlargement, and bilinear for reduction.
+
+@GDK_INTERP_BILINEAR: Bilinear interpolation.  For enlargement, it is
+equivalent to point-sampling the ideal bilinear-interpolated image.
+For reduction, it is equivalent to laying down small tiles and
+integrating over the coverage area.
+
+@GDK_INTERP_HYPER: This is the slowest and highest quality
+reconstruction function.  It is derived from the hyperbolic filters in
+Wolberg's "Digital Image Warping", and is formally defined as the
+hyperbolic-filter sampling the ideal hyperbolic-filter interpolated
+image (the filter is designed to be idempotent for 1:1 pixel mapping).
+
+<!-- ##### FUNCTION gdk_pixbuf_scale ##### -->
+<para>
+
+</para>
+
+@src: 
+@dest: 
+@dest_x: 
+@dest_y: 
+@dest_width: 
+@dest_height: 
+@offset_x: 
+@offset_y: 
+@scale_x: 
+@scale_y: 
+@interp_type: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_composite ##### -->
+<para>
+
+</para>
+
+@src: 
+@dest: 
+@dest_x: 
+@dest_y: 
+@dest_width: 
+@dest_height: 
+@offset_x: 
+@offset_y: 
+@scale_x: 
+@scale_y: 
+@interp_type: 
+@overall_alpha: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_composite_color ##### -->
+<para>
+
+</para>
+
+@src: 
+@dest: 
+@dest_x: 
+@dest_y: 
+@dest_width: 
+@dest_height: 
+@offset_x: 
+@offset_y: 
+@scale_x: 
+@scale_y: 
+@interp_type: 
+@overall_alpha: 
+@check_x: 
+@check_y: 
+@check_size: 
+@color1: 
+@color2: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_scale_simple ##### -->
+<para>
+
+</para>
+
+@src: 
+@dest_width: 
+@dest_height: 
+@interp_type: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_pixbuf_composite_color_simple ##### -->
+<para>
+
+</para>
+
+@src: 
+@dest_width: 
+@dest_height: 
+@interp_type: 
+@overall_alpha: 
+@check_size: 
+@color1: 
+@color2: 
+@Returns: 
+
+
+<!--
+Local variables:
+mode: sgml
+sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
+End:
+-->

docs/reference/gdk-pixbuf/tmpl/util.sgml

@@ -0,0 +1,52 @@
+<!-- ##### SECTION Title ##### -->
+Utilities
+
+<!-- ##### SECTION Short_Description ##### -->
+Utility and miscellaneous convenience functions.
+
+<!-- ##### SECTION Long_Description ##### -->
+  <para>
+    These functions provide miscellaneous utilities for manipulating
+    pixbufs.  The pixel data in pixbufs may of course be manipulated
+    directly by applications, but several common operations can be
+    performed by these functions instead.
+  </para>
+
+<!-- ##### SECTION See_Also ##### -->
+  <para>
+    #GdkPixbuf
+  </para>
+
+<!-- ##### FUNCTION gdk_pixbuf_add_alpha ##### -->
+<para>
+
+</para>
+
+@pixbuf: 
+@substitute_color: 
+@r: 
+@g: 
+@b: 
+@Returns: 
+
+<!-- ##### FUNCTION gdk_pixbuf_copy_area ##### -->
+<para>
+
+</para>
+
+@src_pixbuf: 
+@src_x: 
+@src_y: 
+@width: 
+@height: 
+@dest_pixbuf: 
+@dest_x: 
+@dest_y: 
+
+
+<!--
+Local variables:
+mode: sgml
+sgml-parent-document: ("../gdk-pixbuf.sgml" "book" "refsect2" "")
+End:
+-->

docs/reference/gdk/.cvsignore

@@ -0,0 +1,6 @@
+Makefile
+Makefile.in
+sgml
+html
+gdk-decl-list.txt
+gdk-unused.txt

docs/reference/gdk/Makefile.am

@@ -0,0 +1,50 @@
+## Process this file with automake to produce Makefile.in
+
+# The name of the module.
+DOC_MODULE=gdk
+
+# The top-level SGML file.
+DOC_MAIN_SGML_FILE=gdk-docs.sgml
+
+# We could alternatively use this for using installed headers.
+INCLUDE_DIR=`gtk-config --prefix`/include/gdk
+
+
+TARGET_DIR=$(HTML_DIR)/$(DOC_MODULE)
+
+scan:
+	gtkdoc-scan --module=$(DOC_MODULE) $(INCLUDE_DIR)/gdk.h $(INCLUDE_DIR)/gdktypes.h $(INCLUDE_DIR)/gdkrgb.h
+
+templates: scan
+	gtkdoc-mktmpl --module=$(DOC_MODULE)
+
+sgml:
+	gtkdoc-mkdb --module=$(DOC_MODULE)
+
+html:
+	if ! test -d html ; then mkdir html ; fi
+	-cd html && gtkdoc-mkhtml $(DOC_MODULE) ../$(DOC_MAIN_SGML_FILE)
+
+clean-local:
+	rm -f *~ *.bak *.hierarchy *.signals *.args *-unused.txt
+
+maintainer-clean-local: clean
+	rm -rf sgml html $(DOC_MODULE)-decl-list.txt $(DOC_MODULE)-decl.txt 
+
+install-data-local:
+	install -d -m 0755 $(TARGET_DIR)
+	install -m 0644 html/*.html $(TARGET_DIR)
+	install -m 0644 html/index.sgml $(TARGET_DIR)
+	gtkdoc-fixxref --module=$(DOC_MODULE) --html-dir=$(HTML_DIR)
+
+EXTRA_DIST = \
+	$(DOC_MAIN_SGML_FILE) \
+	$(DOC_MODULE)-sections.txt \
+	gdk-overrides.txt \
+	gdk-decl.txt
+
+dist-hook:
+	mkdir $(distdir)/tmpl
+	cp -p tmpl/*.sgml $(distdir)/tmpl
+
+.PHONY : html sgml templates scan

docs/reference/gdk/gdk-docs.sgml

@@ -0,0 +1,72 @@
+<!doctype book PUBLIC "-//Davenport//DTD DocBook V3.0//EN" [
+<!entity gdk-General SYSTEM "sgml/general.sgml">
+<!entity gdk-Bitmaps-and-Pixmaps SYSTEM "sgml/pixmaps.sgml">
+<!entity gdk-Images SYSTEM "sgml/images.sgml">
+<!entity gdk-GdkRGB SYSTEM "sgml/rgb.sgml">
+<!entity gdk-Colormaps-and-Colors SYSTEM "sgml/colors.sgml">
+<!entity gdk-Fonts SYSTEM "sgml/fonts.sgml">
+<!entity gdk-Drawing-Primitives SYSTEM "sgml/drawing.sgml">
+<!entity gdk-Graphics-Contexts SYSTEM "sgml/gcs.sgml">
+<!entity gdk-Visuals SYSTEM "sgml/visuals.sgml">
+<!entity gdk-Windows SYSTEM "sgml/windows.sgml">
+<!entity gdk-Selections SYSTEM "sgml/selections.sgml">
+<!entity gdk-Properties-and-Atoms SYSTEM "sgml/properties.sgml">
+<!entity gdk-Input-Methods SYSTEM "sgml/input_methods.sgml">
+<!entity gdk-Input-Contexts SYSTEM "sgml/input_contexts.sgml">
+<!entity gdk-Color-Contexts SYSTEM "sgml/color_contexts.sgml">
+<!entity gdk-Points-Rectangles-and-Regions SYSTEM "sgml/regions.sgml">
+<!entity gdk-Threads SYSTEM "sgml/threads.sgml">
+<!entity gdk-Key-Values SYSTEM "sgml/keys.sgml">
+<!entity gdk-Input-Devices SYSTEM "sgml/input_devices.sgml">
+<!entity gdk-Events SYSTEM "sgml/events.sgml">
+<!entity gdk-Event-Structures SYSTEM "sgml/event_structs.sgml">
+<!entity gdk-Cursors SYSTEM "sgml/cursors.sgml">
+<!entity gdk-Input SYSTEM "sgml/input.sgml">
+<!entity gdk-Drag-and-Drop SYSTEM "sgml/dnd.sgml">
+]>
+<book id="index">
+  <bookinfo>
+    <title>GDK Reference Manual</title>
+  </bookinfo>
+
+  <chapter id="gdk">
+    <title>GDK</title>
+    &gdk-General;
+
+    &gdk-Points-Rectangles-and-Regions;
+    &gdk-Graphics-Contexts;
+    &gdk-Drawing-Primitives;
+
+    &gdk-Bitmaps-and-Pixmaps;
+    &gdk-GdkRGB;
+    &gdk-Images;
+
+    &gdk-Colormaps-and-Colors;
+    &gdk-Color-Contexts;
+    &gdk-Visuals;
+
+    &gdk-Fonts;
+    &gdk-Cursors;
+
+    &gdk-Windows;
+
+    &gdk-Events;
+    &gdk-Event-Structures;
+
+    &gdk-Selections;
+    &gdk-Drag-and-Drop;
+
+    &gdk-Properties-and-Atoms;
+
+    &gdk-Threads;
+
+    &gdk-Input;
+
+    &gdk-Input-Devices;
+
+    &gdk-Key-Values;
+
+    &gdk-Input-Methods;
+    &gdk-Input-Contexts;
+  </chapter>
+</book>

docs/reference/gdk/gdk-overrides.txt

@@ -0,0 +1,23 @@
+
+# GdkPixmap, GdkBitmap and GdkDrawable are the same as GdkWindow.
+<STRUCT>
+<NAME>GdkPixmap</NAME>
+struct GdkPixmap
+{
+  gpointer user_data;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GdkBitmap</NAME>
+struct GdkBitmap
+{
+  gpointer user_data;
+};
+</STRUCT>
+<STRUCT>
+<NAME>GdkDrawable</NAME>
+struct GdkDrawable
+{
+  gpointer user_data;
+};
+</STRUCT>

docs/reference/gdk/gdk-sections.txt

@@ -0,0 +1,622 @@
+
+<INCLUDE>gdk/gdk.h</INCLUDE>
+
+<SECTION>
+<TITLE>General</TITLE>
+<FILE>general</FILE>
+gdk_init
+gdk_init_check
+gdk_exit
+gdk_set_locale
+gdk_set_sm_client_id
+
+<SUBSECTION>
+gdk_get_display
+
+<SUBSECTION>
+gdk_flush
+
+<SUBSECTION>
+gdk_screen_width
+gdk_screen_height
+gdk_screen_width_mm
+gdk_screen_height_mm
+
+<SUBSECTION>
+gdk_pointer_grab
+gdk_pointer_ungrab
+gdk_pointer_is_grabbed
+
+<SUBSECTION>
+gdk_keyboard_grab
+gdk_keyboard_ungrab
+
+<SUBSECTION>
+gdk_key_repeat_disable
+gdk_key_repeat_restore
+
+<SUBSECTION>
+gdk_beep
+
+<SUBSECTION>
+gdk_get_use_xshm
+gdk_set_use_xshm
+
+<SUBSECTION>
+gdk_error_trap_push
+gdk_error_trap_pop
+
+<SUBSECTION Private>
+GdkStatus
+gdk_time_get
+gdk_timer_get
+gdk_timer_set
+gdk_timer_enable
+gdk_timer_disable
+</SECTION>
+
+<SECTION>
+<TITLE>Bitmaps and Pixmaps</TITLE>
+<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
+gdk_pixmap_ref
+gdk_pixmap_unref
+GdkBitmap
+gdk_bitmap_ref
+gdk_bitmap_unref
+</SECTION>
+
+<SECTION>
+<TITLE>Images</TITLE>
+<FILE>images</FILE>
+GdkImage
+gdk_image_new
+GdkImageType
+gdk_image_new_bitmap
+gdk_image_get
+gdk_image_destroy
+<SUBSECTION>
+gdk_image_put_pixel
+gdk_image_get_pixel
+</SECTION>
+
+<SECTION>
+<TITLE>GdkRGB</TITLE>
+<FILE>rgb</FILE>
+gdk_rgb_init
+
+<SUBSECTION>
+gdk_draw_rgb_image
+gdk_draw_rgb_image_dithalign
+gdk_draw_indexed_image
+gdk_draw_gray_image
+gdk_draw_rgb_32_image
+GdkRgbDither
+
+<SUBSECTION>
+gdk_rgb_cmap_new
+gdk_rgb_cmap_free
+GdkRgbCmap
+
+<SUBSECTION>
+gdk_rgb_gc_set_foreground
+gdk_rgb_gc_set_background
+gdk_rgb_xpixel_from_rgb
+
+<SUBSECTION>
+gdk_rgb_set_install
+gdk_rgb_set_min_colors
+gdk_rgb_get_visual
+gdk_rgb_get_cmap
+gdk_rgb_ditherable
+gdk_rgb_set_verbose
+</SECTION>
+
+<SECTION>
+<TITLE>Colormaps and Colors</TITLE>
+<FILE>colors</FILE>
+GdkColor
+GdkColormap
+gdk_colormap_new
+gdk_colormap_ref
+gdk_colormap_unref
+gdk_colormap_get_system
+gdk_colormap_get_system_size
+gdk_colormap_change
+gdk_colormap_alloc_colors
+gdk_colormap_alloc_color
+gdk_colormap_free_colors
+gdk_colormap_get_visual
+gdk_colors_store
+gdk_color_copy
+gdk_color_free
+gdk_colors_alloc
+gdk_colors_free
+gdk_color_white
+gdk_color_black
+gdk_color_parse
+gdk_color_alloc
+gdk_color_change
+gdk_color_equal
+gdk_color_hash
+</SECTION>
+
+<SECTION>
+<TITLE>Fonts</TITLE>
+<FILE>fonts</FILE>
+GdkFont
+GdkFontType
+gdk_font_load
+gdk_fontset_load
+gdk_font_ref
+gdk_font_unref
+gdk_font_id
+gdk_font_equal
+
+<SUBSECTION>
+gdk_string_extents
+gdk_text_extents
+gdk_text_extents_wc
+gdk_string_width
+gdk_text_width
+gdk_text_width_wc
+gdk_char_width
+gdk_char_width_wc
+gdk_string_measure
+gdk_text_measure
+gdk_char_measure
+gdk_string_height
+gdk_text_height
+gdk_char_height
+
+<SUBSECTION>
+GdkWChar
+gdk_wcstombs
+gdk_mbstowcs
+</SECTION>
+
+<SECTION>
+<TITLE>Drawing Primitives</TITLE>
+<FILE>drawing</FILE>
+gdk_draw_point
+gdk_draw_points
+gdk_draw_line
+gdk_draw_lines
+gdk_draw_segments
+GdkSegment
+gdk_draw_rectangle
+gdk_draw_arc
+gdk_draw_polygon
+
+<SUBSECTION>
+gdk_draw_string
+gdk_draw_text
+gdk_draw_text_wc
+
+<SUBSECTION>
+gdk_draw_pixmap
+gdk_draw_image
+
+<SUBSECTION Private>
+gdk_draw_bitmap
+</SECTION>
+
+<SECTION>
+<TITLE>Graphics Contexts</TITLE>
+<FILE>gcs</FILE>
+GdkGC
+GdkGCValues
+GdkGCValuesMask
+
+GdkFunction
+
+gdk_gc_new
+gdk_gc_new_with_values
+gdk_gc_ref
+gdk_gc_unref
+gdk_gc_destroy
+gdk_gc_get_values
+gdk_gc_set_foreground
+gdk_gc_set_background
+gdk_gc_set_font
+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
+</SECTION>
+
+<SECTION>
+<TITLE>Visuals</TITLE>
+<FILE>visuals</FILE>
+GdkVisual
+GdkVisualType
+GdkByteOrder
+gdk_query_depths
+gdk_query_visual_types
+gdk_list_visuals
+
+gdk_visual_get_best_depth
+gdk_visual_get_best_type
+gdk_visual_get_system
+gdk_visual_get_best
+gdk_visual_get_best_with_depth
+gdk_visual_get_best_with_type
+gdk_visual_get_best_with_both
+gdk_visual_ref
+gdk_visual_unref
+</SECTION>
+
+<SECTION>
+<TITLE>Windows</TITLE>
+<FILE>windows</FILE>
+GdkWindowAttr
+GdkWindow
+GdkWindowType
+GdkWindowClass
+GdkWindowAttributesType
+GdkWindowHints
+GdkGeometry
+
+gdk_window_new
+gdk_window_destroy
+gdk_window_ref
+gdk_window_unref
+gdk_window_at_pointer
+gdk_window_show
+gdk_window_hide
+gdk_window_is_visible
+gdk_window_is_viewable
+gdk_window_withdraw
+gdk_window_move
+gdk_window_resize
+gdk_window_move_resize
+gdk_window_reparent
+gdk_window_clear
+gdk_window_clear_area
+gdk_window_clear_area_e
+gdk_window_copy_area
+gdk_window_raise
+gdk_window_lower
+gdk_window_register_dnd
+gdk_window_set_user_data
+gdk_window_set_override_redirect
+gdk_window_add_filter
+gdk_window_remove_filter
+GdkFilterFunc
+GdkFilterReturn
+GdkXEvent
+gdk_window_shape_combine_mask
+gdk_window_set_child_shapes
+gdk_window_merge_child_shapes
+gdk_window_set_static_gravities
+gdk_window_set_hints
+gdk_window_set_title
+gdk_window_set_background
+gdk_window_set_back_pixmap
+GDK_PARENT_RELATIVE
+gdk_window_set_cursor
+gdk_window_set_colormap
+gdk_window_get_user_data
+gdk_window_get_geometry
+gdk_window_set_geometry_hints
+gdk_window_get_position
+gdk_window_get_root_origin
+gdk_window_get_size
+gdk_window_get_visual
+gdk_window_get_colormap
+gdk_window_get_type
+gdk_window_get_origin
+gdk_window_get_deskrelative_origin
+gdk_window_get_pointer
+GdkModifierType
+gdk_window_get_parent
+gdk_window_get_toplevel
+gdk_window_get_children
+gdk_window_get_events
+gdk_window_set_events
+gdk_window_set_icon
+gdk_window_set_icon_name
+gdk_window_set_transient_for
+gdk_window_set_role
+gdk_window_set_group
+gdk_window_set_decorations
+GdkWMDecoration
+gdk_window_set_functions
+GdkWMFunction
+gdk_window_get_toplevels
+GdkDrawable
+gdk_drawable_set_data
+</SECTION>
+
+<SECTION>
+<TITLE>Selections</TITLE>
+<FILE>selections</FILE>
+GdkSelection
+GdkSelectionType
+GdkTarget
+gdk_selection_owner_set
+gdk_selection_owner_get
+gdk_selection_convert
+gdk_selection_property_get
+gdk_selection_send_notify
+</SECTION>
+
+<SECTION>
+<TITLE>Properties and Atoms</TITLE>
+<FILE>properties</FILE>
+GdkAtom
+GDK_NONE
+gdk_text_property_to_text_list
+gdk_free_text_list
+gdk_string_to_compound_text
+gdk_free_compound_text
+gdk_atom_intern
+gdk_atom_name
+gdk_property_get
+gdk_property_change
+GdkPropMode
+gdk_property_delete
+</SECTION>
+
+<SECTION>
+<TITLE>Input Methods</TITLE>
+<FILE>input_methods</FILE>
+GdkIMStyle
+gdk_im_ready
+gdk_im_decide_style
+gdk_im_set_best_style
+
+<SUBSECTION>
+gdk_im_begin
+gdk_im_end
+</SECTION>
+
+<SECTION>
+<TITLE>Input Contexts</TITLE>
+<FILE>input_contexts</FILE>
+GdkIC
+gdk_ic_new
+gdk_ic_destroy
+gdk_ic_get_events
+gdk_ic_get_style
+gdk_ic_get_attr
+gdk_ic_set_attr
+
+<SUBSECTION>
+GdkICAttr
+GdkICAttributesType
+gdk_ic_attr_new
+gdk_ic_attr_destroy
+</SECTION>
+
+<SECTION>
+<TITLE>Color Contexts</TITLE>
+<FILE>color_contexts</FILE>
+GdkColorContext
+GdkColorContextDither
+GdkColorContextMode
+
+gdk_color_context_new
+gdk_color_context_new_mono
+gdk_color_context_free
+gdk_color_context_get_pixel
+gdk_color_context_get_pixels
+gdk_color_context_get_pixels_incremental
+gdk_color_context_query_color
+gdk_color_context_query_colors
+gdk_color_context_add_palette
+gdk_color_context_init_dither
+gdk_color_context_free_dither
+gdk_color_context_get_pixel_from_palette
+gdk_color_context_get_index_from_palette
+</SECTION>
+
+<SECTION>
+<TITLE>Points, Rectangles and Regions</TITLE>
+<FILE>regions</FILE>
+GdkPoint
+
+<SUBSECTION>
+GdkRectangle
+gdk_rectangle_intersect
+gdk_rectangle_union
+
+<SUBSECTION>
+GdkRegion
+gdk_region_new
+gdk_region_polygon
+GdkFillRule
+gdk_region_destroy
+
+<SUBSECTION>
+gdk_regions_intersect
+gdk_regions_union
+gdk_regions_subtract
+gdk_regions_xor
+gdk_region_union_with_rect
+gdk_region_offset
+gdk_region_shrink
+
+<SUBSECTION>
+gdk_region_empty
+gdk_region_equal
+gdk_region_point_in
+gdk_region_rect_in
+GdkOverlapType
+gdk_region_get_clipbox
+</SECTION>
+
+<SECTION>
+<TITLE>Threads</TITLE>
+<FILE>threads</FILE>
+gdk_threads_mutex
+GDK_THREADS_ENTER
+GDK_THREADS_LEAVE
+gdk_threads_enter
+gdk_threads_leave
+</SECTION>
+
+<SECTION>
+<TITLE>Key Values</TITLE>
+<FILE>keys</FILE>
+gdk_keyval_name
+gdk_keyval_from_name
+
+<SUBSECTION>
+gdk_keyval_is_upper
+gdk_keyval_is_lower
+
+<SUBSECTION>
+gdk_keyval_to_upper
+gdk_keyval_to_lower
+</SECTION>
+
+<SECTION>
+<TITLE>Input Devices</TITLE>
+<FILE>input_devices</FILE>
+GDK_CORE_POINTER
+gdk_input_list_devices
+GdkDeviceInfo
+GdkDeviceKey
+gdk_input_set_extension_events
+GdkExtensionMode
+gdk_input_set_source
+GdkInputSource
+gdk_input_set_mode
+GdkInputMode
+gdk_input_set_axes
+GdkAxisUse
+gdk_input_set_key
+gdk_input_window_get_pointer
+gdk_input_motion_events
+GdkTimeCoord
+
+<SUBSECTION Private>
+gdk_input_init
+gdk_input_exit
+</SECTION>
+
+<SECTION>
+<TITLE>Events</TITLE>
+<FILE>events</FILE>
+GdkEventType
+GdkEventMask
+GDK_CURRENT_TIME
+GDK_PRIORITY_EVENTS
+
+<SUBSECTION>
+gdk_events_pending
+gdk_event_peek
+gdk_event_get
+gdk_event_get_graphics_expose
+gdk_event_put
+gdk_event_copy
+gdk_event_free
+gdk_event_get_time
+
+<SUBSECTION>
+gdk_event_handler_set
+GdkEventFunc
+
+<SUBSECTION>
+gdk_event_send_client_message
+gdk_event_send_clientmessage_toall
+gdk_add_client_message_filter
+
+<SUBSECTION>
+gdk_get_show_events
+gdk_set_show_events
+</SECTION>
+
+<SECTION>
+<TITLE>Event Structures</TITLE>
+<FILE>event_structs</FILE>
+GdkEvent
+
+<SUBSECTION>
+GdkEventAny
+GdkEventKey
+GdkEventButton
+GdkEventMotion
+GdkEventExpose
+GdkEventVisibility
+GdkEventCrossing
+GdkEventFocus
+GdkEventConfigure
+GdkEventProperty
+GdkEventSelection
+GdkEventDND
+GdkEventProximity
+GdkEventClient
+GdkEventNoExpose
+
+<SUBSECTION>
+GdkVisibilityState
+GdkCrossingMode
+GdkNotifyType
+GdkPropertyState
+</SECTION>
+
+<SECTION>
+<TITLE>Cursors</TITLE>
+<FILE>cursors</FILE>
+GdkCursor
+GdkCursorType
+gdk_cursor_new
+gdk_cursor_new_from_pixmap
+gdk_cursor_destroy
+</SECTION>
+
+<SECTION>
+<TITLE>Input</TITLE>
+<FILE>input</FILE>
+gdk_input_add_full
+GdkInputCondition
+GdkInputFunction
+GdkDestroyNotify
+gdk_input_add
+gdk_input_remove
+</SECTION>
+
+<SECTION>
+<TITLE>Drag and Drop</TITLE>
+<FILE>dnd</FILE>
+gdk_drag_get_selection
+gdk_drag_abort
+gdk_drop_reply
+gdk_drag_context_new
+gdk_drag_drop
+gdk_drag_find_window
+gdk_drag_context_ref
+gdk_drag_begin
+gdk_drag_motion
+gdk_drop_finish
+gdk_drag_get_protocol
+GdkDragProtocol
+gdk_drag_context_unref
+GdkDragContext
+GdkDragAction
+gdk_drag_status
+</SECTION>

docs/reference/gdk/tmpl/color_contexts.sgml

@@ -0,0 +1,207 @@
+<!-- ##### SECTION Title ##### -->
+Color Contexts
+
+<!-- ##### SECTION Short_Description ##### -->
+routines for allocating colors (deprecated).
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+The #GdkColorContext type is used for allocating groups of colors.
+</para>
+<para>
+It is now deprecated in favor of the gdk_colormap_*() functions described in
+the <link linkend="gdk-Colormaps-and-Colors">Colormaps and Colors</link>
+section.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### STRUCT GdkColorContext ##### -->
+<para>
+
+</para>
+
+@visual: 
+@colormap: 
+@num_colors: 
+@max_colors: 
+@num_allocated: 
+@mode: 
+@need_to_free_colormap: 
+@std_cmap_atom: 
+@clut: 
+@cmap: 
+@color_hash: 
+@palette: 
+@num_palette: 
+@fast_dither: 
+
+<!-- ##### STRUCT GdkColorContextDither ##### -->
+<para>
+
+</para>
+
+@fast_rgb: 
+@fast_err: 
+@fast_erg: 
+@fast_erb: 
+
+<!-- ##### ENUM GdkColorContextMode ##### -->
+<para>
+
+</para>
+
+@GDK_CC_MODE_UNDEFINED: 
+@GDK_CC_MODE_BW: 
+@GDK_CC_MODE_STD_CMAP: 
+@GDK_CC_MODE_TRUE: 
+@GDK_CC_MODE_MY_GRAY: 
+@GDK_CC_MODE_PALETTE: 
+
+<!-- ##### FUNCTION gdk_color_context_new ##### -->
+<para>
+
+</para>
+
+@visual: 
+@colormap: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_color_context_new_mono ##### -->
+<para>
+
+</para>
+
+@visual: 
+@colormap: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_color_context_free ##### -->
+<para>
+
+</para>
+
+@cc: 
+
+
+<!-- ##### FUNCTION gdk_color_context_get_pixel ##### -->
+<para>
+
+</para>
+
+@cc: 
+@red: 
+@green: 
+@blue: 
+@failed: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_color_context_get_pixels ##### -->
+<para>
+
+</para>
+
+@cc: 
+@reds: 
+@greens: 
+@blues: 
+@ncolors: 
+@colors: 
+@nallocated: 
+
+
+<!-- ##### FUNCTION gdk_color_context_get_pixels_incremental ##### -->
+<para>
+
+</para>
+
+@cc: 
+@reds: 
+@greens: 
+@blues: 
+@ncolors: 
+@used: 
+@colors: 
+@nallocated: 
+
+
+<!-- ##### FUNCTION gdk_color_context_query_color ##### -->
+<para>
+
+</para>
+
+@cc: 
+@color: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_color_context_query_colors ##### -->
+<para>
+
+</para>
+
+@cc: 
+@colors: 
+@num_colors: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_color_context_add_palette ##### -->
+<para>
+
+</para>
+
+@cc: 
+@palette: 
+@num_palette: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_color_context_init_dither ##### -->
+<para>
+
+</para>
+
+@cc: 
+
+
+<!-- ##### FUNCTION gdk_color_context_free_dither ##### -->
+<para>
+
+</para>
+
+@cc: 
+
+
+<!-- ##### FUNCTION gdk_color_context_get_pixel_from_palette ##### -->
+<para>
+
+</para>
+
+@cc: 
+@red: 
+@green: 
+@blue: 
+@failed: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_color_context_get_index_from_palette ##### -->
+<para>
+
+</para>
+
+@cc: 
+@red: 
+@green: 
+@blue: 
+@failed: 
+@Returns: 
+
+

docs/reference/gdk/tmpl/colors.sgml

@@ -0,0 +1,390 @@
+<!-- ##### SECTION Title ##### -->
+Colormaps and Colors
+
+<!-- ##### SECTION Short_Description ##### -->
+manipulation of colors and colormaps.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+These functions are used to modify colormaps.
+A colormap is an object that contains the mapping
+between the color values stored in memory and
+the RGB values that are used to display color
+values. In general, colormaps only contain
+significant information for pseudo-color visuals,
+but even for other visual types, a colormap object
+is required in some circumstances.
+</para>
+
+<para>
+There are a couple of special colormaps that can
+be retrieved. The system colormap (retrieved 
+with gdk_colormap_get_system()) is the default
+colormap of the system. If you are using GdkRGB,
+there is another colormap that is important - the
+colormap in which GdkRGB works, retrieved with
+gdk_rgb_get_cmap(). However, when using GdkRGB, 
+it is not generally necessary to allocate colors
+directly.
+</para>
+
+<para>
+In previous revisions of this interface, a number
+of functions that take a #GdkColormap parameter
+were replaced with functions whose names began
+with "gdk_colormap_". This process will probably
+be extended somewhat in the future - 
+gdk_color_white(), gdk_color_black(), and 
+gdk_color_change() will probably become aliases.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### STRUCT GdkColor ##### -->
+<para>
+The #GdkColor structure is used to describe an 
+allocated or unallocated color.
+
+<informaltable pgwide=1 frame="none" role="struct">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry><structfield>pixel</structfield></entry>
+<entry>For allocated colors, the value used to
+draw this color on the screen.</entry>
+</row>
+
+<row>
+<entry><structfield>red</structfield></entry>
+<entry>The red component of the color. This is
+a value between 0 and 65535, with 65535 indicating
+full intensitiy.</entry>
+</row>
+
+<row>
+<entry><structfield>green</structfield></entry>
+<entry>the blue component of the color.</entry>
+</row>
+
+<row>
+<entry><structfield>blue</structfield></entry>
+<entry>the green component of the color..</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+@pixel: 
+@red: 
+@green: 
+@blue: 
+
+<!-- ##### STRUCT GdkColormap ##### -->
+<para>
+The colormap structure contains the following public
+fields.
+
+<informaltable pgwide=1 frame="none" role="struct">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry><structfield>size</structfield></entry>
+<entry>For pseudo-color colormaps, the number of colors
+in the colormap..</entry>
+</row>
+
+<row>
+<entry><structfield>colors</structfield></entry>
+<entry>An array containing the current values in the
+colormap. This can be used to map from pixel values
+back to RGB values. This is only meaningful for
+pseudo-color colormaps.</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+@size: 
+@colors: 
+
+<!-- ##### FUNCTION gdk_colormap_new ##### -->
+<para>
+Create a new colormap for the given visual.
+</para>
+
+@visual: a #GdkVisual.
+@allocate: if %TRUE, the newly created colormap will be
+  a private colormap, and all colors in it will be
+  allocated for the applications use.
+@Returns: the new #GdkColormap.
+
+
+<!-- ##### FUNCTION gdk_colormap_ref ##### -->
+<para>
+Increase the reference count of a colormap.
+</para>
+
+@cmap: a #GdkColormap.
+@Returns: @cmap
+
+
+<!-- ##### FUNCTION gdk_colormap_unref ##### -->
+<para>
+Decrease the reference count of a colormap. If the
+resulting reference count is zero, destroys the colormap.
+</para>
+
+@cmap: a #GdkColormap.
+
+
+<!-- ##### FUNCTION gdk_colormap_get_system ##### -->
+<para>
+Returns the system's default colormap.
+</para>
+
+@Returns: the default colormap.
+
+
+<!-- ##### FUNCTION gdk_colormap_get_system_size ##### -->
+<para>
+Returns the size of the system's default colormap.
+(See the description of struct #GdkColormap for an
+explanation of the size of a colormap.)
+</para>
+
+@Returns: the size of the system's default colormap.
+
+
+<!-- ##### FUNCTION gdk_colormap_change ##### -->
+<para>
+Change the value of the first @ncolors in a private colormap
+to match the values in the <structfield>colors</structfield>
+array in the color map. This function is obsolete and
+should not be used. See gdk_color_change().
+</para>
+
+@colormap: a #GdkColormap.
+@ncolors: the number of colors to change.
+
+
+<!-- ##### FUNCTION gdk_colormap_alloc_colors ##### -->
+<para>
+Allocates colors from a colormap.
+</para>
+
+@colormap: a #GdkColormap.
+@colors: The color values to allocate. On return, the pixel
+ values for allocated colors will be filled in.
+@ncolors: The number of colors in @colors.
+@writeable: If %TRUE, the colors are allocated writeable
+ (their values can later be changed using gdk_color_change()).
+ Writeable colors cannot be shared between applications.
+@best_match: If %TRUE, GDK will attempt to do matching against
+ existing colors if the colors cannot be allocated as
+ requested.
+@success: An array of length @ncolors. On return, this
+ indicates whether the corresponding color in @colors was
+ sucessfully allocated or not.
+@Returns: The number of colors that were not sucessfully 
+ allocated.
+
+
+<!-- ##### FUNCTION gdk_colormap_alloc_color ##### -->
+<para>
+Allocate a single color from a colormap.
+</para>
+
+@colormap: a #GdkColormap.
+@color: the color to allocate. On return the
+<structfield>pixel</structfield> field will be
+filled in if allocation succeeds.
+@writeable: If %TRUE, the color is allocated writeable
+ (their values can later be changed using gdk_color_change()).
+ Writeable colors cannot be shared between applications.
+@best_match: If %TRUE, GDK will attempt to do matching against
+ existing colors if the color cannot be allocated as
+ requested.
+@Returns: %TRUE if the allocation succeeded.
+
+
+<!-- ##### FUNCTION gdk_colormap_free_colors ##### -->
+<para>
+Free previously allocated colors.
+</para>
+
+@colormap: a #GdkColormap.
+@colors: the colors to free.
+@ncolors: the number of colors in @colors.
+
+
+<!-- ##### FUNCTION gdk_colormap_get_visual ##### -->
+<para>
+Return the visual for which a given colormap was created.
+</para>
+
+@colormap: a #GdkColormap.
+@Returns: the visual of the colormap.
+
+
+<!-- ##### FUNCTION gdk_colors_store ##### -->
+<para>
+Change the value of the first @ncolors colors in
+a private colormap. This function is obsolete and
+should not be used. See gdk_color_change().
+</para>
+
+@colormap: a #GdkColormap.
+@colors: the new color values.
+@ncolors: the number of colors to change.
+
+
+<!-- ##### FUNCTION gdk_color_copy ##### -->
+<para>
+Make a copy of a color structure. The result
+must be freed using gdk_color_free().
+</para>
+
+@color: a #GdkColor.
+@Returns: a copy of @color.
+
+
+<!-- ##### FUNCTION gdk_color_free ##### -->
+<para>
+Free a color structure created with 
+gdk_color_copy().
+</para>
+
+@color: a #GdkColor.
+
+
+<!-- ##### FUNCTION gdk_colors_alloc ##### -->
+<para>
+Allocate colors from a colormap. This function
+is obsolete. See gdk_colormap_alloc_colors().
+For full documentation of the fields, see 
+the Xlib documentation for XAllocColorCells.
+</para>
+
+@colormap: a #GdkColormap.
+@contiguous: if %TRUE, the colors should be allocated
+ in contiguous color cells.
+@planes: an array in which to store the plane masks.
+@nplanes: the number of planes to allocate. (Or zero,
+ to indicate that the color allocation should not be
+ planar.)
+@pixels: an array into which to store allocated pixel
+ values.
+@npixels: the number of pixels in each plane to allocate.
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_colors_free ##### -->
+<para>
+Free colors allocated with gdk_colors_alloc(). This
+function is obsolete. See gdk_colormap_free_colors().
+</para>
+
+@colormap: a #GdkColormap.
+@pixels: the pixel values of the colors to free.
+@npixels: the number of values in @pixels.
+@planes: the plane masks for all planes to free, OR'd
+ together.
+
+
+<!-- ##### FUNCTION gdk_color_white ##### -->
+<para>
+Return the white color for a given colormap. The resulting
+value has already allocated been allocated. 
+</para>
+
+@colormap: a #GdkColormap.
+@color: the location to store the color.
+@Returns: %TRUE if the allocation succeeded.
+
+
+<!-- ##### FUNCTION gdk_color_black ##### -->
+<para>
+Return the black color for a given colormap. The resulting
+value has already benn allocated. 
+</para>
+
+@colormap: a #GdkColormap.
+@color: the location to store the color.
+@Returns: %TRUE if the allocation succeeded.
+
+
+<!-- ##### FUNCTION gdk_color_parse ##### -->
+<para>
+Parse a textual specification of a color and fill in
+the <structfield>red</structfield>,
+<structfield>green</structfield>, and 
+<structfield>blue</structfield> fields of a 
+#GdkColor structure. The color is <emphasis>not</emphasis> 
+allocated, you must call gdk_colormap_alloc_color() yourself.
+The text string can be in any of the forms accepted
+by <function>XParseColor</function>; these include
+name for a color from <filename>rgb.txt</filename>, such as
+<literal>DarkSlateGray</literal>, or a hex specification
+such as <literal>305050</literal>.
+</para>
+
+@spec: the string specifying the color.
+@color: the #GdkColor to fill in
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_color_alloc ##### -->
+<para>
+Allocate a single color from a colormap.
+This function is obsolete. See gdk_colormap_alloc_color().
+</para>
+
+@colormap: a #GdkColormap.
+@color: The color to allocate. On return, the 
+<structfield>pixel</structfield> field will be
+filled in.
+@Returns: %TRUE if the allocation succeeded.
+
+
+<!-- ##### FUNCTION gdk_color_change ##### -->
+<para>
+Change the value of a color that has already
+been allocated. If @colormap is not a private
+colormap, then the color must have been allocated
+using gdk_colormap_alloc_colors() with the 
+@writeable set to %TRUE.
+</para>
+
+@colormap: a #GdkColormap.
+@color: a #GdkColor, with the color to change
+in the <structfield>pixel</structfield> field,
+and the new value in the remaining fields.
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_color_equal ##### -->
+<para>
+Compare two colors. 
+</para>
+
+@colora: a #GdkColor.
+@colorb: another #GdkColor.
+@Returns: %TRUE if the two colors compare equal
+
+
+<!-- ##### FUNCTION gdk_color_hash ##### -->
+<para>
+A hash function suitable for using for a hash
+table that stores #GdkColor's.
+</para>
+
+@colora: a #GdkColor.
+@colorb: NOT USED.
+@Returns: The hash function appled to @colora
+
+

docs/reference/gdk/tmpl/cursors.sgml

@@ -0,0 +1,99 @@
+<!-- ##### SECTION Title ##### -->
+Cursors
+
+<!-- ##### SECTION Short_Description ##### -->
+standard and pixmap cursors.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### STRUCT GdkCursor ##### -->
+<para>
+
+</para>
+
+@type: 
+
+<!-- ##### ENUM GdkCursorType ##### -->
+<para>
+The standard cursors available.
+</para>
+
+
+<!-- ##### FUNCTION gdk_cursor_new ##### -->
+<para>
+Creates a new standard cursor.
+</para>
+
+@cursor_type: the type of the cursor.
+@Returns: a new #GdkCursor.
+
+
+<!-- ##### FUNCTION gdk_cursor_new_from_pixmap ##### -->
+<para>
+Creates a new cursor from a given pixmap and mask. Both the pixmap and mask
+must have a depth of 1 (i.e. each pixel has only 2 values - on or off).
+The standard cursor size is 16 by 16 pixels.
+</para>
+<example><title>Creating a custom cursor.</title>
+<programlisting>
+/* This data is in X bitmap format, and can be created with the 'bitmap'
+   utility. */
+#define cursor1_width 16
+#define cursor1_height 16
+static unsigned char cursor1_bits[] = {
+   0x80, 0x01, 0x40, 0x02, 0x20, 0x04, 0x10, 0x08, 0x08, 0x10, 0x04, 0x20,
+   0x82, 0x41, 0x41, 0x82, 0x41, 0x82, 0x82, 0x41, 0x04, 0x20, 0x08, 0x10,
+   0x10, 0x08, 0x20, 0x04, 0x40, 0x02, 0x80, 0x01};
+
+static unsigned char cursor1mask_bits[] = {
+   0x80, 0x01, 0xc0, 0x03, 0x60, 0x06, 0x30, 0x0c, 0x18, 0x18, 0x8c, 0x31,
+   0xc6, 0x63, 0x63, 0xc6, 0x63, 0xc6, 0xc6, 0x63, 0x8c, 0x31, 0x18, 0x18,
+   0x30, 0x0c, 0x60, 0x06, 0xc0, 0x03, 0x80, 0x01};
+
+
+  GdkCursor *cursor;
+  GdkPixmap *source, *mask;
+  GdkColor fg = { 0, 65535, 0, 0 }; /* Red. */
+  GdkColor bg = { 0, 0, 0, 65535 }; /* Blue. */
+
+
+  source = gdk_bitmap_create_from_data (NULL, cursor1_bits,
+					cursor1_width, cursor1_height);
+  mask = gdk_bitmap_create_from_data (NULL, cursor1mask_bits,
+				      cursor1_width, cursor1_height);
+  cursor = gdk_cursor_new_from_pixmap (source, mask, &amp;fg, &amp;bg, 8, 8);
+  gdk_pixmap_unref (source);
+  gdk_pixmap_unref (mask);
+
+
+  gdk_window_set_cursor (widget->window, cursor);
+</programlisting>
+</example>
+
+@source: the pixmap specifying the cursor.
+@mask: the pixmap specifying the mask, which must be the same size as @source.
+@fg: the foreground color, used for the bits in the source which are 1.
+The color does not have to be allocated first.
+@bg: the background color, used for the bits in the source which are 0.
+The color does not have to be allocated first.
+@x: the horizontal offset of the 'hotspot' of the cursor.
+@y: the vertical offset of the 'hotspot' of the cursor.
+@Returns: a new #GdkCursor.
+
+
+<!-- ##### FUNCTION gdk_cursor_destroy ##### -->
+<para>
+Destroys a cursor, freeing any resources allocated for it.
+</para>
+
+@cursor: a #GdkCursor.
+
+

docs/reference/gdk/tmpl/dnd.sgml

@@ -0,0 +1,194 @@
+<!-- ##### SECTION Title ##### -->
+Drag and Drop
+
+<!-- ##### SECTION Short_Description ##### -->
+functions for controlling drag and drop handling.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+These functions provide a low level interface for drag and drop.
+GDK supports both the Xdnd and Motif drag and drop protocols transparently.
+</para>
+<para>
+GTK+ provides a higher level abstraction based on top of these functions,
+and so they are not normally needed in GTK+ applications.
+See the <link linkend="gtk-Drag-and-Drop">Drag and Drop</link> section of
+the GTK+ documentation for more information.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### FUNCTION gdk_drag_get_selection ##### -->
+<para>
+
+</para>
+
+@context: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_drag_abort ##### -->
+<para>
+
+</para>
+
+@context: 
+@time: 
+
+
+<!-- ##### FUNCTION gdk_drop_reply ##### -->
+<para>
+
+</para>
+
+@context: 
+@ok: 
+@time: 
+
+
+<!-- ##### FUNCTION gdk_drag_context_new ##### -->
+<para>
+
+</para>
+
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_drag_drop ##### -->
+<para>
+
+</para>
+
+@context: 
+@time: 
+
+
+<!-- ##### FUNCTION gdk_drag_find_window ##### -->
+<para>
+
+</para>
+
+@context: 
+@drag_window: 
+@x_root: 
+@y_root: 
+@dest_window: 
+@protocol: 
+
+
+<!-- ##### FUNCTION gdk_drag_context_ref ##### -->
+<para>
+
+</para>
+
+@context: 
+
+
+<!-- ##### FUNCTION gdk_drag_begin ##### -->
+<para>
+
+</para>
+
+@window: 
+@targets: 
+@Returns: 
+<!-- # Unused Parameters # -->
+@actions: 
+
+
+<!-- ##### FUNCTION gdk_drag_motion ##### -->
+<para>
+
+</para>
+
+@context: 
+@dest_window: 
+@protocol: 
+@x_root: 
+@y_root: 
+@suggested_action: 
+@possible_actions: 
+@time: 
+@Returns: 
+<!-- # Unused Parameters # -->
+@action: 
+
+
+<!-- ##### FUNCTION gdk_drop_finish ##### -->
+<para>
+
+</para>
+
+@context: 
+@success: 
+@time: 
+
+
+<!-- ##### FUNCTION gdk_drag_get_protocol ##### -->
+<para>
+
+</para>
+
+@xid: 
+@protocol: 
+@Returns: 
+
+
+<!-- ##### ENUM GdkDragProtocol ##### -->
+<para>
+
+</para>
+
+@GDK_DRAG_PROTO_MOTIF: 
+@GDK_DRAG_PROTO_XDND: 
+@GDK_DRAG_PROTO_ROOTWIN: 
+@GDK_DRAG_PROTO_NONE: 
+
+<!-- ##### FUNCTION gdk_drag_context_unref ##### -->
+<para>
+
+</para>
+
+@context: 
+
+
+<!-- ##### STRUCT GdkDragContext ##### -->
+<para>
+
+</para>
+
+@protocol: 
+@is_source: 
+@source_window: 
+@dest_window: 
+@targets: 
+@actions: 
+@suggested_action: 
+@action: 
+@start_time: 
+
+<!-- ##### ENUM GdkDragAction ##### -->
+<para>
+
+</para>
+
+@GDK_ACTION_DEFAULT: 
+@GDK_ACTION_COPY: 
+@GDK_ACTION_MOVE: 
+@GDK_ACTION_LINK: 
+@GDK_ACTION_PRIVATE: 
+@GDK_ACTION_ASK: 
+
+<!-- ##### FUNCTION gdk_drag_status ##### -->
+<para>
+
+</para>
+
+@context: 
+@action: 
+@time: 
+
+

docs/reference/gdk/tmpl/drawing.sgml

@@ -0,0 +1,239 @@
+<!-- ##### SECTION Title ##### -->
+Drawing Primitives
+
+<!-- ##### SECTION Short_Description ##### -->
+functions for drawing points, lines, arcs, and text.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+These functions provide support for drawing points, lines, arcs and text
+onto what are called 'drawables'. Drawables, as the name suggests, are things
+which support drawing onto them, and are either #GdkWindow or #GdkPixmap
+objects.
+</para>
+<para>
+Many of the drawing operations take a #GdkGC argument, which represents a
+graphics context. This #GdkGC contains a number of drawing attributes such
+as foreground color, background color and line width, and is used to reduce
+the number of arguments needed for each drawing operation. See the
+<link linkend="gdk-Graphics-Contexts">Graphics Contexts</link> section for
+more information.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### FUNCTION gdk_draw_point ##### -->
+<para>
+Draws a point, using the foreground color and other attributes of the #GdkGC.
+</para>
+
+@drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).
+@gc: a #GdkGC.
+@x: the x coordinate of the point.
+@y: the y coordinate of the point.
+
+
+<!-- ##### FUNCTION gdk_draw_points ##### -->
+<para>
+Draws a number of points, using the foreground color and other attributes of
+the #GdkGC.
+</para>
+
+@drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).
+@gc: a #GdkGC.
+@points: an array of #GdkPoint structures.
+@npoints: the number of points to be drawn.
+
+
+<!-- ##### FUNCTION gdk_draw_line ##### -->
+<para>
+Draws a line, using the foreground color and other attributes of the #GdkGC.
+</para>
+
+@drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).
+@gc: a #GdkGC.
+@x1: the x coordinate of the start point.
+@y1: the y coordinate of the start point.
+@x2: the x coordinate of the end point.
+@y2: the y coordinate of the end point.
+
+
+<!-- ##### FUNCTION gdk_draw_lines ##### -->
+<para>
+Draws a series of lines connecting the given points.
+The way in which joins between lines are draw is determined by the
+#GdkCapStyle value in the #GdkGC. This can be set with
+gdk_gc_set_line_attributes().
+</para>
+
+@drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).
+@gc: a #GdkGC.
+@points: an array of #GdkPoint structures specifying the endpoints of the
+lines.
+@npoints: the size of the @points array.
+
+
+<!-- ##### FUNCTION gdk_draw_segments ##### -->
+<para>
+Draws a number of unconnected lines.
+</para>
+
+@drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).
+@gc: a #GdkGC.
+@segs: an array of #GdkSegment structures specifying the start and end points
+of the lines to be drawn,
+@nsegs: the number of line segments to draw, i.e. the size of the @segs array.
+
+
+<!-- ##### 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>
+Draws a rectangular outline or filled rectangle, using the foreground color
+and other attributes of the #GdkGC.
+</para>
+<note>
+<para>
+A rectangle drawn filled is 1 pixel smaller in both dimensions than a rectangle
+outlined. Calling gdk_draw_rectangle (window, gc, TRUE, 0, 0, 20, 20) results
+in a filled rectangle 20 pixels wide and 20 pixels high. Calling
+gdk_draw_rectangle (window, gc, FALSE, 0, 0, 20, 20) results in an outlined
+rectangle with corners at (0, 0), (0, 20), (20, 20), and (20, 0), which
+makes it 21 pixels wide and 21 pixels high.
+</para>
+</note>
+
+@drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).
+@gc: a #GdkGC.
+@filled: TRUE if the rectangle should be filled.
+@x: the x coordinate of the left edge of the rectangle.
+@y: the y coordinate of the top edge of the rectangle.
+@width: the width of the rectangle.
+@height: the height of the rectangle.
+
+
+<!-- ##### FUNCTION gdk_draw_arc ##### -->
+<para>
+Draws an arc or a filled 'pie slice'. The arc is defined by the bounding
+rectangle of the entire ellipse, and the start and end angles of the part of
+the ellipse to be drawn.
+</para>
+
+@drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).
+@gc: a #GdkGC.
+@filled: TRUE if the arc should be filled, producing a 'pie slice'.
+@x: the x coordinate of the left edge of the bounding rectangle.
+@y: the y coordinate of the top edge of the bounding rectangle.
+@width: the width of the bounding rectangle.
+@height: the height of the bounding rectangle.
+@angle1: the start angle of the arc, relative to the 3 o'clock position,
+counter-clockwise, in 1/64ths of a degree.
+@angle2: the end angle of the arc, relative to @angle1, in 1/64ths of a degree.
+
+
+<!-- ##### FUNCTION gdk_draw_polygon ##### -->
+<para>
+Draws an outlined or filled polygon.
+</para>
+
+@drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).
+@gc: a #GdkGC.
+@filled: TRUE if the polygon should be filled. The polygon is closed
+automatically, connecting the last point to the first point if necessary.
+@points: an array of #GdkPoint structures specifying the points making up the
+polygon.
+@npoints: the number of points.
+
+
+<!-- ##### FUNCTION gdk_draw_string ##### -->
+<para>
+Draws a string of characters in the given font or fontset.
+</para>
+
+@drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).
+@font: a #GdkFont.
+@gc: a #GdkGC.
+@x: the x coordinate of the left edge of the text.
+@y: the y coordinate of the baseline of the text.
+@string: the string of characters to draw.
+
+
+<!-- ##### FUNCTION gdk_draw_text ##### -->
+<para>
+Draws a number of characters in the given font or fontset.
+</para>
+
+@drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).
+@font: a #GdkFont.
+@gc: a #GdkGC.
+@x: the x coordinate of the left edge of the text.
+@y: the y coordinate of the baseline of the text.
+@text: the characters to draw.
+@text_length: the number of characters of @text to draw.
+
+
+<!-- ##### FUNCTION gdk_draw_text_wc ##### -->
+<para>
+Draws a number of wide characters using the given font of fontset.
+If the font is a 1-byte font, the string is converted into 1-byte characters
+(discarding the high bytes) before output.
+</para>
+
+@drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).
+@font: a #GdkFont.
+@gc: a #GdkGC.
+@x: the x coordinate of the left edge of the text.
+@y: the y coordinate of the baseline of the text.
+@text: the wide characters to draw.
+@text_length: the number of characters to draw.
+
+
+<!-- ##### FUNCTION gdk_draw_pixmap ##### -->
+<para>
+Draws a pixmap, or a part of a pixmap, onto another drawable.
+</para>
+
+@drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).
+@gc: a #GdkGC.
+@src: the source #GdkPixmap to draw.
+@xsrc: the left edge of the source rectangle within @src.
+@ysrc: the top of the source rectangle within @src.
+@xdest: the x coordinate of the destination within @drawable.
+@ydest: the y coordinate of the destination within @drawable.
+@width: the width of the area to be copied, or -1 to make the area extend to
+the right edge of the source pixmap.
+@height: the height of the area to be copied, or -1 to make the area extend
+to the bottom edge of the source pixmap.
+
+
+<!-- ##### FUNCTION gdk_draw_image ##### -->
+<para>
+Draws a #GdkImage onto a drawable.
+The depth of the #GdkImage must match the depth of the #GdkDrawable.
+</para>
+
+@drawable: a #GdkDrawable (a #GdkWindow or a #GdkPixmap).
+@gc: a #GdkGC.
+@image: the #GdkImage to draw.
+@xsrc: the left edge of the source rectangle within @image.
+@ysrc: the top of the source rectangle within @image.
+@xdest: the x coordinate of the destination within @drawable.
+@ydest: the y coordinate of the destination within @drawable.
+@width: the width of the area to be copied, or -1 to make the area extend to
+the right edge of @image.
+@height: the height of the area to be copied, or -1 to make the area extend
+to the bottom edge of @image.
+
+

docs/reference/gdk/tmpl/event_structs.sgml

@@ -0,0 +1,368 @@
+<!-- ##### SECTION Title ##### -->
+Event Structures
+
+<!-- ##### SECTION Short_Description ##### -->
+data structures specific to each type of event.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+The event structs contain data specific to each type of event in GDK.
+</para>
+<note>
+<para>
+A common mistake is to forget to set the event mask of a widget so that the
+required events are received. See gtk_widget_set_events().
+</para>
+</note>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### UNION GdkEvent ##### -->
+<para>
+The #GdkEvent struct contains a union of all of the event structs,
+and allows access to the data fields in a number of ways.
+</para>
+<para>
+The event type is always the first field in all of the event structs, and
+can always be accessed with the following code, no matter what type of event
+it is:
+<informalexample>
+<programlisting>
+  GdkEvent *event;  
+  GdkEventType type;
+
+  type = event->type;
+</programlisting>
+</informalexample>
+</para>
+
+<para>
+To access other fields of the event structs, the pointer to the event can be
+cast to the appropriate event struct pointer, or the union member name can be
+used. For example if the event type is %GDK_BUTTON_PRESS then the x coordinate
+of the button press can be accessed with:
+<informalexample>
+<programlisting>
+  GdkEvent *event;  
+  gdouble x;
+
+  x = ((GdkEventButton*)event)->x;
+</programlisting>
+</informalexample>
+or:
+<informalexample>
+<programlisting>
+  GdkEvent *event;  
+  gdouble x;
+
+  x = event->button.x;
+</programlisting>
+</informalexample>
+</para>
+
+
+<!-- ##### STRUCT GdkEventAny ##### -->
+<para>
+Contains the fields which are common to all event structs.
+Any event pointer can safely be cast to a pointer to a #GdkEventAny to access
+these fields.
+</para>
+
+@type: the type of the event.
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+
+<!-- ##### STRUCT GdkEventKey ##### -->
+<para>
+Describes a key press or key release event.
+</para>
+
+@type: the type of the event (%GDK_KEY_RELEASE or %GDK_KEY_RELEASE).
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+@time: the time of the event in milliseconds.
+@state: a bit-mask representing the state of the modifier keys (e.g. Control,
+Shift and Alt) and the pointer buttons. See #GdkModifierType.
+@keyval: the key that was pressed or released. See the &lt;gdk/gdkkeysym.h&gt;
+header file for a complete list of GDK key codes.
+@length: the length of @string.
+@string: a null-terminated multi-byte string containing the composed characters
+resulting from the key press. When text is being input, in a GtkEntry for
+example, it is these characters which should be added to the input buffer.
+When using <link linkend="gdk-Input-Methods"> Input Methods</link> to support
+internationalized text input, the composed characters appear here after the
+pre-editing has been completed.
+
+<!-- ##### STRUCT GdkEventButton ##### -->
+<para>
+Used for button press and button release events. The
+<structfield>type</structfield> field will be one of %GDK_BUTTON_PRESS,
+%GDK_2BUTTON_PRESS, %GDK_3BUTTON_PRESS, and %GDK_BUTTON_RELEASE.
+</para>
+<para>
+Double and triple-clicks result in a sequence of events being received.
+For double-clicks the order of events will be:
+<orderedlist>
+<listitem><para>%GDK_BUTTON_PRESS</para></listitem>
+<listitem><para>%GDK_BUTTON_RELEASE</para></listitem>
+<listitem><para>%GDK_BUTTON_PRESS</para></listitem>
+<listitem><para>%GDK_2BUTTON_PRESS</para></listitem>
+<listitem><para>%GDK_BUTTON_RELEASE</para></listitem>
+</orderedlist>
+Note that the first click is received just like a normal
+button press, while the second click results in a %GDK_2BUTTON_PRESS being
+received just after the %GDK_BUTTON_PRESS.
+</para>
+<para>
+Triple-clicks are very similar to double-clicks, except that %GDK_3BUTTON_PRESS
+is inserted after the third click. The order of the events is:
+<orderedlist>
+<listitem><para>%GDK_BUTTON_PRESS</para></listitem>
+<listitem><para>%GDK_BUTTON_RELEASE</para></listitem>
+<listitem><para>%GDK_BUTTON_PRESS</para></listitem>
+<listitem><para>%GDK_2BUTTON_PRESS</para></listitem>
+<listitem><para>%GDK_BUTTON_RELEASE</para></listitem>
+<listitem><para>%GDK_BUTTON_PRESS</para></listitem>
+<listitem><para>%GDK_3BUTTON_PRESS</para></listitem>
+<listitem><para>%GDK_BUTTON_RELEASE</para></listitem>
+</orderedlist>
+</para>
+<para>
+For a double click to occur, the second button press must occur within 1/4 of
+a second of the first. For a triple click to occur, the third button press
+must also occur within 1/2 second of the first button press.
+</para>
+
+@type: the type of the event (%GDK_BUTTON_PRESS, %GDK_2BUTTON_PRESS,
+%GDK_3BUTTON_PRESS or %GDK_BUTTON_RELEASE).
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+@time: the time of the event in milliseconds.
+@x: the x coordinate of the mouse relative to the window.
+@y: the y coordinate of the mouse relative to the window.
+@pressure: the pressure of the button press, intended for input devices such
+as graphics tablets. It defaults to 0.5.
+@xtilt: the horizontal tilt of the input device. Defaults to 0.
+@ytilt: the vertical tilt of the input device. Defaults to 0.
+@state: a bit-mask representing the state of the modifier keys (e.g. Control,
+Shift and Alt) and the pointer buttons. See #GdkModifierType.
+@button: the button which was pressed or released, numbered from 1 to 5.
+Normally button 1 is the left mouse button, 2 is the middle button,
+and 3 is the right button. On 2-button mice, the middle button can often
+be simulated by pressing both mouse buttons together.
+@source: the input device where the event came from, usually %GDK_SOURCE_MOUSE.
+@deviceid: the input device ID, usually %GDK_CORE_POINTER but may be
+different if touch screens or graphics tablets are being used.
+@x_root: the x coordinate of the mouse relative to the root of the screen.
+@y_root: the y coordinate of the mouse relative to the root of the screen.
+
+<!-- ##### STRUCT GdkEventMotion ##### -->
+<para>
+
+</para>
+
+@type: the type of the event.
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+@time: 
+@x: 
+@y: 
+@pressure: 
+@xtilt: 
+@ytilt: 
+@state: 
+@is_hint: 
+@source: 
+@deviceid: 
+@x_root: 
+@y_root: 
+
+<!-- ##### STRUCT GdkEventExpose ##### -->
+<para>
+Generated when all or part of a window becomes visible and needs to be
+redrawn.
+</para>
+
+@type: the type of the event (%GDK_EXPOSE).
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+@area: the area that needs to be redrawn.
+@count: the number of contiguous %GDK_EXPOSE events following this one.
+The only use for this is "exposure compression", i.e. handling all contiguous
+%GDK_EXPOSE events in one go, though GDK performs some exposure compression
+so this is not normally needed.
+
+<!-- ##### STRUCT GdkEventVisibility ##### -->
+<para>
+Generated when the window visibility status has changed.
+</para>
+
+@type: the type of the event (%GDK_VISIBILITY_NOTIFY).
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+@state: the new visibility state (%GDK_VISIBILITY_FULLY_OBSCURED,
+%GDK_VISIBILITY_PARTIAL or %GDK_VISIBILITY_UNOBSCURED).
+
+<!-- ##### ENUM GdkVisibilityState ##### -->
+<para>
+Specifies the visiblity status of a window for a #GdkEventVisibility.
+</para>
+
+@GDK_VISIBILITY_UNOBSCURED: the window is completely visible.
+@GDK_VISIBILITY_PARTIAL: the window is partially visible.
+@GDK_VISIBILITY_FULLY_OBSCURED: the window is not visible at all.
+
+<!-- ##### STRUCT GdkEventCrossing ##### -->
+<para>
+
+</para>
+
+@type: the type of the event.
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+@subwindow: 
+@time: the time of the event in milliseconds.
+@x: 
+@y: 
+@x_root: 
+@y_root: 
+@mode: 
+@detail: 
+@focus: 
+@state: 
+
+<!-- ##### ENUM GdkCrossingMode ##### -->
+<para>
+
+</para>
+
+@GDK_CROSSING_NORMAL: 
+@GDK_CROSSING_GRAB: 
+@GDK_CROSSING_UNGRAB: 
+
+<!-- ##### ENUM GdkNotifyType ##### -->
+<para>
+
+</para>
+
+@GDK_NOTIFY_ANCESTOR: 
+@GDK_NOTIFY_VIRTUAL: 
+@GDK_NOTIFY_INFERIOR: 
+@GDK_NOTIFY_NONLINEAR: 
+@GDK_NOTIFY_NONLINEAR_VIRTUAL: 
+@GDK_NOTIFY_UNKNOWN: 
+
+<!-- ##### STRUCT GdkEventFocus ##### -->
+<para>
+Describes a change of keyboard focus.
+</para>
+
+@type: the type of the event (%GDK_FOCUS_CHANGE).
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+@in: TRUE if the window has gained the keyboard focus, FALSE if it has lost
+the focus.
+
+<!-- ##### STRUCT GdkEventConfigure ##### -->
+<para>
+Generated when a window size or position has changed.
+</para>
+
+@type: the type of the event (%GDK_CONFIGURE).
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+@x: the new x coordinate of the window, relative to its parent.
+@y: the new y coordinate of the window, relative to its parent.
+@width: the new width of the window.
+@height: the new height of the window.
+
+<!-- ##### STRUCT GdkEventProperty ##### -->
+<para>
+Describes a property change on a window.
+</para>
+
+@type: the type of the event (%GDK_PROPERTY_NOTIFY).
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+@atom: the property that was changed.
+@time: the time of the event in milliseconds.
+@state: whether the property was changed (%GDK_PROPERTY_NEW_VALUE) or
+deleted (%GDK_PROPERTY_DELETE).
+
+<!-- ##### ENUM GdkPropertyState ##### -->
+<para>
+Specifies the type of a property change for a #GdkEventProperty.
+</para>
+
+@GDK_PROPERTY_NEW_VALUE: the property value wan changed.
+@GDK_PROPERTY_DELETE: the property was deleted.
+
+<!-- ##### STRUCT GdkEventSelection ##### -->
+<para>
+
+</para>
+
+@type: the type of the event.
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+@selection: 
+@target: 
+@property: 
+@requestor: 
+@time: the time of the event in milliseconds.
+
+<!-- ##### STRUCT GdkEventDND ##### -->
+<para>
+
+</para>
+
+@type: the type of the event.
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+@context: 
+@time: the time of the event in milliseconds.
+@x_root: 
+@y_root: 
+
+<!-- ##### STRUCT GdkEventProximity ##### -->
+<para>
+
+</para>
+
+@type: the type of the event.
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+@time: the time of the event in milliseconds.
+@source: 
+@deviceid: 
+
+<!-- ##### STRUCT GdkEventClient ##### -->
+<para>
+An event sent by another client application.
+</para>
+
+@type: the type of the event (%GDK_CLIENT_EVENT).
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+@message_type: the type of the message, which can be defined by the
+application.
+@data_format: the format of the data, given as the number of bits in each
+data element, i.e. 8, 16, or 32. 8-bit data uses the b array of the data
+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, with gdk_draw_pixmap()
+or gdk_window_copy_area(), was completely available.
+</para>
+<para>
+FIXME: add more here.
+</para>
+
+@type: the type of the event (%GDK_NO_EXPOSE).
+@window: the window which received the event.
+@send_event: TRUE if the event was sent explicitly (e.g. using XSendEvent).
+

docs/reference/gdk/tmpl/events.sgml

@@ -0,0 +1,303 @@
+<!-- ##### SECTION Title ##### -->
+Events
+
+<!-- ##### SECTION Short_Description ##### -->
+functions for handling events from the window system.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+This section describes functions dealing with events from the window system.
+</para>
+<para>
+In GTK+ applications the events are handled automatically in
+gtk_main_do_event() and passed on to the appropriate widgets, so these
+functions are rarely needed. Though some of the fields in the
+<link linkend="gdk-Event-Structures">Event Structures</link> are useful.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+<variablelist>
+<varlistentry>
+<term><link linkend="gdk-Event-Structures">Event Structures</link></term>
+<listitem><para>
+The structs used for each type of event.
+</para></listitem>
+</varlistentry>
+</variablelist>
+</para>
+
+<!-- ##### ENUM GdkEventType ##### -->
+<para>
+Specifies the type of the event.
+</para>
+<para>
+Do not confuse these events with the signals that GTK+ widgets emit.
+Although many of these events result in corresponding signals being emitted,
+the events are often transformed or filtered along the way.
+</para>
+
+@GDK_NOTHING: a special code to indicate a null event.
+@GDK_DELETE: the window manager has requested that the toplevel window be
+hidden or destroyed, usually when the user clicks on a special icon in the
+title bar.
+@GDK_DESTROY: the window has been destroyed.
+@GDK_EXPOSE: all or part of the window has become visible and needs to be
+redrawn.
+@GDK_MOTION_NOTIFY: the pointer (usually a mouse) has moved.
+@GDK_BUTTON_PRESS: a mouse button has been pressed.
+@GDK_2BUTTON_PRESS: a mouse button has been double-clicked (clicked twice
+within a short period of time). Note that each click also generates a
+%GDK_BUTTON_PRESS event.
+@GDK_3BUTTON_PRESS: a mouse button has been clicked 3 times in a short period
+of time. Note that each click also generates a %GDK_BUTTON_PRESS event.
+@GDK_BUTTON_RELEASE: a mouse button has been released.
+@GDK_KEY_PRESS: a key has been pressed.
+@GDK_KEY_RELEASE: a key has been released.
+@GDK_ENTER_NOTIFY: the pointer has entered the window.
+@GDK_LEAVE_NOTIFY: the pointer has left the window.
+@GDK_FOCUS_CHANGE: the keyboard focus has entered or left the window.
+@GDK_CONFIGURE: the size, position or stacking order of the window has changed.
+Note that GTK+ discards these events for %GDK_WINDOW_CHILD windows.
+@GDK_MAP: the window has been mapped.
+@GDK_UNMAP: the window has been unmapped.
+@GDK_PROPERTY_NOTIFY: a property on the window has been changed or deleted.
+@GDK_SELECTION_CLEAR: the application has lost ownership of a selection.
+@GDK_SELECTION_REQUEST: another application has requested a selection.
+@GDK_SELECTION_NOTIFY: a selection has been received.
+@GDK_PROXIMITY_IN: an input device has moved into contact with a sensing
+surface (e.g. a touchscreen or graphics tablet).
+@GDK_PROXIMITY_OUT: an input device has moved out of contact with a sensing
+surface.
+@GDK_DRAG_ENTER: the mouse has entered the window while a drag is in progress.
+@GDK_DRAG_LEAVE: the mouse has left the window while a drag is in progress.
+@GDK_DRAG_MOTION: the mouse has moved in the window while a drag is in
+progress.
+@GDK_DRAG_STATUS: the status of the drag operation initiated by the window
+has changed.
+@GDK_DROP_START: a drop operation onto the window has started.
+@GDK_DROP_FINISHED: the drop operation initiated by the window has completed.
+@GDK_CLIENT_EVENT: a message has been received from another application.
+@GDK_VISIBILITY_NOTIFY: the window visibility status has changed.
+@GDK_NO_EXPOSE: indicates that the source region was completely available
+when parts of a drawable were copied. This is not very useful.
+
+<!-- ##### ENUM GdkEventMask ##### -->
+<para>
+A set of bit-flags to indicate which events a window is to receive.
+Most of these masks map onto one or more of the #GdkEventType event types
+above.
+</para>
+<para>
+%GDK_POINTER_MOTION_HINT_MASK is a special mask which is used to reduce the
+number of %GDK_MOTION_NOTIFY events received. Normally a %GDK_MOTION_NOTIFY
+event is received each time the mouse moves. However, if the application
+spends a lot of time processing the event (updating the display, for example),
+it can easily lag behind the position of the mouse. When using the
+%GDK_POINTER_MOTION_HINT_MASK the server will only send %GDK_MOTION_NOTIFY
+events when the application asks for them, by calling gdk_window_get_pointer().
+</para>
+
+@GDK_EXPOSURE_MASK: 
+@GDK_POINTER_MOTION_MASK: 
+@GDK_POINTER_MOTION_HINT_MASK: 
+@GDK_BUTTON_MOTION_MASK: 
+@GDK_BUTTON1_MOTION_MASK: 
+@GDK_BUTTON2_MOTION_MASK: 
+@GDK_BUTTON3_MOTION_MASK: 
+@GDK_BUTTON_PRESS_MASK: 
+@GDK_BUTTON_RELEASE_MASK: 
+@GDK_KEY_PRESS_MASK: 
+@GDK_KEY_RELEASE_MASK: 
+@GDK_ENTER_NOTIFY_MASK: 
+@GDK_LEAVE_NOTIFY_MASK: 
+@GDK_FOCUS_CHANGE_MASK: 
+@GDK_STRUCTURE_MASK: 
+@GDK_PROPERTY_CHANGE_MASK: 
+@GDK_VISIBILITY_NOTIFY_MASK: 
+@GDK_PROXIMITY_IN_MASK: 
+@GDK_PROXIMITY_OUT_MASK: 
+@GDK_SUBSTRUCTURE_MASK: 
+@GDK_ALL_EVENTS_MASK: the combination of all the above event masks.
+
+<!-- ##### MACRO GDK_CURRENT_TIME ##### -->
+<para>
+Represents the current time, and can be used anywhere a time is expected.
+</para>
+
+
+
+<!-- ##### MACRO GDK_PRIORITY_EVENTS ##### -->
+<para>
+This is the priority that events from the X server are given in the
+<link linkend="glib-The-Main-Event-Loop">GLib Main Loop</link>.
+</para>
+
+
+
+<!-- ##### FUNCTION gdk_events_pending ##### -->
+<para>
+Checks if any events are waiting to be processed.
+</para>
+
+@Returns: TRUE if any events are pending.
+
+
+<!-- ##### FUNCTION gdk_event_peek ##### -->
+<para>
+Gets a copy of the first #GdkEvent in the event queue.
+(Note that this function will not get more events from the X server.
+It only checks the events that have already been moved to the GDK event queue.)
+</para>
+
+@Returns: a copy of the first #GdkEvent on the event queue, or NULL if no
+events are in the queue. The returned #GdkEvent should be freed with
+gdk_event_free().
+
+
+<!-- ##### FUNCTION gdk_event_get ##### -->
+<para>
+Gets the next #GdkEvent to be processed, fetching events from the X server if
+necessary.
+</para>
+
+@Returns: the next #GdkEvent to be processed, or NULL if no events are pending.
+The returned #GdkEvent should be freed with gdk_event_free().
+
+
+<!-- ##### FUNCTION gdk_event_get_graphics_expose ##### -->
+<para>
+Waits for a GraphicsExpose or NoExpose event from the X server.
+This is used in the #GtkText and #GtkCList widgets in GTK+ to make sure any
+GraphicsExpose events are handled before the widget is scrolled.
+</para>
+
+@window: the #GdkWindow to wait for the events for.
+@Returns: a #GdkEventExpose if a GraphicsExpose was received, or NULL if a
+NoExpose event was received.
+
+
+<!-- ##### FUNCTION gdk_event_put ##### -->
+<para>
+Appends a copy of the given event onto the front of the event queue.
+</para>
+
+@event: a #GdkEvent.
+
+
+<!-- ##### FUNCTION gdk_event_copy ##### -->
+<para>
+Copies a #GdkEvent, copying or incrementing the reference count of the
+resources associated with it (e.g. #GdkWindow's and strings).
+</para>
+
+@event: a #GdkEvent.
+@Returns: a copy of @event. The returned #GdkEvent should be freed with
+gdk_event_free().
+
+
+<!-- ##### FUNCTION gdk_event_free ##### -->
+<para>
+Frees a #GdkEvent, freeing or decrementing any resources associated with it.
+Note that this function should only be called with events returned from
+gdk_event_peek(), gdk_event_get(), gdk_event_get_graphics_expose() and
+gdk_event_copy().
+</para>
+
+@event: a #GdkEvent.
+
+
+<!-- ##### FUNCTION gdk_event_get_time ##### -->
+<para>
+Gets the timestamp from a #GdkEvent.
+</para>
+
+@event: a #GdkEvent.
+@Returns: the timestamp from @event, or #GDK_CURRENT_TIME if the event has
+no timestamp.
+
+
+<!-- ##### FUNCTION gdk_event_handler_set ##### -->
+<para>
+Sets the function to call to handle all events from GDK.
+</para>
+<para>
+Note that GTK+ uses this to install its own event handler, so it is probably
+not useful for GTK+ applications.
+</para>
+
+@func: the function to call to handle events from GDK.
+@data: user data to pass to the function.
+@notify: the function to call when the handler function is removed, i.e. when
+gdk_event_handler_set() is called with another event handler.
+
+
+<!-- ##### USER_FUNCTION GdkEventFunc ##### -->
+<para>
+Specifies the type of function passed to gdk_event_handler_set() to handle
+all GDK events.
+</para>
+
+@event: the #GdkEvent to process.
+@data: user data set when the event handler was installed with
+gdk_event_handler_set().
+
+
+<!-- ##### FUNCTION gdk_event_send_client_message ##### -->
+<para>
+Sends an X ClientMessage event to a given window.
+</para>
+<para>
+This could be used for communicating between different applications,
+though the amount of data is limited to 20 bytes.
+</para>
+
+@event: the #GdkEvent to send, which should be a #GdkEventClient.
+@xid: the window to send the X ClientMessage event to.
+@Returns: non-zero on success.
+
+
+<!-- ##### FUNCTION gdk_event_send_clientmessage_toall ##### -->
+<para>
+Sends an X ClientMessage event to all toplevel windows.
+</para>
+<para>
+Toplevel windows are determined by checking for the WM_STATE property, as
+described in the Inter-Client Communication Conventions Manual (ICCCM).
+If no windows are found with the WM_STATE property set, the message is sent
+to all children of the root window.
+</para>
+
+@event: the #GdkEvent to send, which should be a #GdkEventClient.
+
+
+<!-- ##### FUNCTION gdk_add_client_message_filter ##### -->
+<para>
+Adds a filter to be called when X ClientMessage events are received.
+</para>
+
+@message_type: the type of ClientMessage events to receive. This will be
+checked against the <structfield>message_type</structfield> field of the
+XClientMessage event struct.
+@func: the function to call to process the event.
+@data: user data to pass to @func.
+
+
+<!-- ##### FUNCTION gdk_get_show_events ##### -->
+<para>
+Returns non-zero if event debugging output is enabled.
+</para>
+
+@Returns: non-zero if event debugging output is enabled.
+
+
+<!-- ##### FUNCTION gdk_set_show_events ##### -->
+<para>
+Sets whether event debugging information is output.
+Note that GTK+ must be compiled with debugging enabled, i.e. using the
+'--enable-debug' configure option.
+</para>
+
+@show_events: TRUE to output event debugging information.
+
+

docs/reference/gdk/tmpl/fonts.sgml

@@ -0,0 +1,643 @@
+<!-- ##### SECTION Title ##### -->
+Fonts
+
+<!-- ##### SECTION Short_Description ##### -->
+loading and manipulating fonts
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+The GdkFont data type represents a font for drawing on
+the screen. These functions provide support for
+loading fonts, and also for determining the dimensions
+of characters and strings when drawn with a particular
+font.
+</para>
+
+<para>
+Fonts in X are specified by a
+<firstterm>X Logical Font Description</firstterm>. 
+The following description is considerably simplified.
+For definitive information about XLFD's see the 
+X reference documentation. A X Logical Font Description (XLFD)
+consists of a sequence of fields separated (and surrounded by) '-'
+characters. For example, Adobe Helvetica Bold 12 pt, has the
+full description: 
+
+<programlisting>
+"-adobe-helvetica-bold-r-normal--12-120-75-75-p-70-iso8859-1"
+</programlisting>
+</para>
+
+<para>
+The fields in the XLFD are:
+
+<informaltable pgwide=1 frame="none">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry>Foundry</entry>
+<entry>the company or organization where the font originated.</entry>
+</row>
+
+<row>
+<entry>Family</entry>
+<entry>the font family (a group of related font designs).</entry>
+</row>
+
+<row>
+<entry>Weight</entry>
+<entry>A name for the font's typographic weight
+For example, 'bold' or 'medium').</entry>
+</row>
+
+<row>
+<entry>Slant</entry>
+<entry>The slant of the font. Common values are 'R' for Roman,
+'I' for italoc, and 'O' for oblique.</entry>
+</row>
+
+<row>
+<entry>Set Width</entry>
+<entry>A name for the width of the font. For example,
+'normal' or 'condensed'.</entry>
+</row>
+
+<row>
+<entry>Add Style</entry>
+<entry>Additional information to distinguish a font from
+other fonts of the same family.</entry>
+</row>
+
+<row>
+<entry>Pixel Size</entry>
+<entry>The body size of the font in pixels.</entry>
+</row>
+
+<row>
+<entry>Point Size</entry>
+<entry>The body size of the font in 10ths of a point.
+(A <firstterm>point</firstterm> is 1/72.27 inch) </entry>
+</row>
+
+<row>
+<entry>Resolution X</entry>
+<entry>The horizontal resolution that the font was designed for.</entry>
+</row>
+
+<row>
+<entry>Resolution Y</entry>
+<entry>The vertical resolution that the font was designed for .</entry>
+</row>
+
+<row>
+<entry>Spacing</entry>
+<entry>The type of spacing for the font - can be 'p' for proportional,
+'m' for monospaced or 'c' for charcell.</entry>
+</row>
+
+<row>
+<entry>Average Width</entry>
+<entry>The average width of a glyph in the font. For monospaced
+and charcell fonts, all glyphs in the font have this width</entry>
+</row>
+
+<row>
+<entry>Charset Registry</entry>
+<entry>The registration authority that owns the encoding for
+the font. Together with the Charset Encoding field, this
+defines the character set for the font.</entry>
+</row>
+
+<row>
+<entry>Charset Encoding</entry>
+<entry>An identifier for the particular character set encoding.</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+<para>
+When specifying a font via a X logical Font Description,
+'*' can be used as a wildcard to match any portion of
+the XLFD. For instance, the above example could
+also be specified as
+
+<programlisting>
+"-*-helvetica-bold-r-normal--*-120-*-*-*-*-iso8859-1"
+</programlisting>
+
+It is generally a good idea to use wildcards for any
+portion of the XLFD that your program does not care
+about specifically, since that will improve the
+chances of finding a matching font.
+</para>
+
+<para>
+A <firstterm>fontset</firstterm> is a list of fonts
+that is used for drawing international text that may
+contain characters from a number of different character
+sets. It is represented by a list of XLFD's. 
+</para>
+
+<para>
+The font for a given character set is determined by going
+through the list of XLFD's in order. For each one, if
+the registry and and encoding fields match the desired
+character set, then that font is used, otherwise if
+the XLFD contains wild-cards for the registry and encoding
+fields, the registry and encoding for the desired character
+set are subsituted in and a lookup is done. If a match is found
+that font is used. Otherwise, processing continues
+on to the next font in the list.
+</para>
+
+<para>
+The functions for determining the metrics of a string
+come in several varieties that can take a number
+of forms of string input:
+
+<variablelist>
+  <varlistentry>
+    <term>8-bit string</term>
+    <listitem><para>
+    When using functions like gdk_string_width() that
+    take a <type>gchar *</type>, if the font is of type
+    %GDK_FONT_FONT and is an 8-bit font, then each
+    <type>gchar</type> indexes the glyphs in the font directly.
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>16-bit string</term>
+    <listitem><para>
+    For functions taking a <type>gchar *</type>, if the
+    font is of type %GDK_FONT_FONT, and is a 16-bit
+    font, then the <type>gchar *</type> argument is
+    interpreted as a <type>guint16 *</type> cast to
+    a <type>gchar *</type> and each <type>guint16</type>
+    indexes the glyphs in the font directly.
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>Multibyte string</term>
+    <listitem><para>
+    For functions taking a <type>gchar *</type>, if the
+    font is of type %GDK_FONT_FONTSET, then the input
+    string is interpreted as a <firstterm>multibyte</firstterm>
+    encoded according to the current locale. (A multibyte
+    string is one in which each character may consist
+    of one or more bytes, with different lengths for different
+    characters in the string). They can be converted to and
+    from wide character strings (see below) using
+    gdk_wcstombs() and gdk_mbstowcs().) The string will
+    be rendered using one or more different fonts from
+    the fontset.
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>Wide character string</term>
+    <listitem><para>
+    For a number of the text-measuring functions, GTK+
+    provides a variant (such as gdk_text_width_wc()) which
+    takes a <type>GdkWChar *</type> instead of a 
+    <type>gchar *</type>. The input is then taken to
+    be a wide character string in the encoding of the
+    current locale. (A wide character string is a string
+    in which each character consists of several bytes,
+    and the width of each character in the string is 
+    constant.)
+    </para></listitem>
+  </varlistentry>
+</variablelist>
+</para>
+
+<para>
+GDK provides functions to determine a number of different
+measurements (metrics) for a given string. (Need diagram
+here).
+
+<variablelist>
+  <varlistentry>
+    <term>ascent</term>
+    <listitem><para>
+    The vertical distance from the origin of the drawing
+    opereration to the top of the drawn character.
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>descent</term>
+    <listitem><para>
+    The vertical distance from the origin of the drawing
+    opereration to the bottom of the drawn character.
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>left bearing</term>
+    <listitem><para>
+    The horizontal distance from the origin of the drawing
+    operation to the left-most part of the drawn character.
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>right bearing</term>
+    <listitem><para>
+    The horizontal distance from the origin of the drawing
+    operation to the right-most part of the drawn character.
+    </para></listitem>
+  </varlistentry>
+  <varlistentry>
+    <term>width bearing</term>
+    <listitem><para>
+    The horizontal distance from the origin of the drawing
+    operation to the correct origin for drawing another
+    string to follow the current one. Depending on the
+    font, this could be greater than or less than the 
+    right bearing.
+    </para></listitem>
+  </varlistentry>
+</variablelist>
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### STRUCT GdkFont ##### -->
+<para>
+The GdkFont structure represents a font or fontset. It
+contains the following public fields. A new GdkFont
+structure is returned by gdk_font_load() or gdk_fontset_load(),
+and is reference counted with gdk_font_ref() and gdk_font_unref()
+
+<informaltable pgwide=1 frame="none" role="struct">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry><structfield>type</structfield></entry>
+<entry>a value of type #GdkFontType which indicates
+whether this font is a single font or a fontset.</entry>
+</row>
+
+<row>
+<entry><structfield>ascent</structfield></entry>
+<entry>the maximum distance that the font, when drawn,
+ascends above the baseline.</entry>
+</row>
+
+<row>
+<entry><structfield>descent</structfield></entry>
+<entry>the maximum distance that the font, when drawn,
+descends below the baseline.</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+@type: 
+@ascent: 
+@descent: 
+
+<!-- ##### ENUM GdkFontType ##### -->
+<para>
+Indicates the type of a font. The possible values
+are currently:
+
+<informaltable pgwide=1 frame="none" role="enum">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry>GDK_FONT_FONT</entry>
+<entry>the font is a single font.</entry>
+</row>
+
+<row>
+<entry>GDK_FONT_FONT</entry>
+<entry>the font is a fontset.</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+@GDK_FONT_FONT: 
+@GDK_FONT_FONTSET: 
+
+<!-- ##### FUNCTION gdk_font_load ##### -->
+<para>
+Loads a font.
+</para>
+
+<para>
+Currently, this function will always return a new
+font, however, in the future, it may be changed to
+look up the font in a cache. You should make no
+assumptions about the initial reference count.
+</para>
+
+@font_name: a XLFD describing the font to load.
+@Returns: a #GdkFont, or NULL if the font could not be loaded.
+
+
+<!-- ##### FUNCTION gdk_fontset_load ##### -->
+<para>
+Loads a fontset.
+</para>
+<para>
+Currently this function will always return a new
+font, however, in the future, it may be changed to
+look up the font in a cache. You should make no
+assumptions about the initial reference count.
+</para>
+
+@fontset_name: a comma-separated list of XLFDs describing
+   the component fonts of the fontset to load.
+@Returns: a #GdkFont, or NULL if the fontset could not be loaded.
+
+
+<!-- ##### FUNCTION gdk_font_ref ##### -->
+<para>
+Increase the reference count of a count by one.
+</para>
+
+@font: a #GdkFont
+@Returns: @font
+
+
+<!-- ##### FUNCTION gdk_font_unref ##### -->
+<para>
+Decrease the reference count of a count by one.
+If the result is zero, destroys the font.
+</para>
+
+@font: a #GdkFont
+
+
+<!-- ##### FUNCTION gdk_font_id ##### -->
+<para>
+Returns the X Font ID for the given font. 
+</para>
+
+@font: a #GdkFont.
+@Returns: the numeric X Font ID
+
+
+<!-- ##### FUNCTION gdk_font_equal ##### -->
+<para>
+Compares two fonts for equality. Single fonts compare equal
+if they have the same X font ID. This operation does
+not currently work correctly for fontsets.
+</para>
+
+@fonta: a #GdkFont.
+@fontb: another #GdkFont.
+@Returns: %TRUE if the fonts are equal.
+
+
+<!-- ##### FUNCTION gdk_string_extents ##### -->
+<para>
+Returns the metrics of a NULL-terminated string.
+</para>
+
+@font: a #GdkFont.
+@string: the NULL-terminated string to measure.
+@lbearing: the left bearing of the string.
+@rbearing: the right bearing of the string.
+@width: the width of the string.
+@ascent: the ascent of the string.
+@descent: the descent of the string.
+
+
+<!-- ##### FUNCTION gdk_text_extents ##### -->
+<para>
+Returns the metrics of a string.
+</para>
+
+@font: a #GdkFont
+@text: the text to measure
+@text_length: the length of the text in bytes. (If the
+  font is a 16-bit font, this is twice the length
+  of the text in characters.)
+@lbearing: the left bearing of the string.
+@rbearing: the right bearing of the string.
+@width: the width of the string.
+@ascent: the ascent of the string.
+@descent: the descent of the string.
+
+
+<!-- ##### FUNCTION gdk_text_extents_wc ##### -->
+<para>
+Returns the metrics of a string of wide characters.
+</para>
+
+@font: a #GdkFont
+@text: the text to measure.
+@text_length: the length of the text in character.
+@lbearing: the left bearing of the string.
+@rbearing: the right bearing of the string.
+@width: the width of the string.
+@ascent: the ascent of the string.
+@descent: the descent of the string.
+
+
+<!-- ##### FUNCTION gdk_string_width ##### -->
+<para>
+Determine the width of a NULL-terminated string.
+(The distance from the origin of the string to the 
+point where the next string in a sequence of strings
+should be drawn)
+</para>
+
+@font: a #GdkFont
+@string: the NULL-terminated string to measure
+@Returns: the width of the string in pixels.
+
+
+<!-- ##### FUNCTION gdk_text_width ##### -->
+<para>
+Determine the width of a given string.
+</para>
+
+@font: a #GdkFont
+@text: the text to measure.
+@text_length: the length of the text in bytes.
+@Returns: the width of the string in pixels.
+
+
+<!-- ##### FUNCTION gdk_text_width_wc ##### -->
+<para>
+Determine the width of a given wide-character string.
+</para>
+
+@font: a #GdkFont
+@text: the text to measure.
+@text_length: the length of the text in characters.
+@Returns: the width of the string in pixels.
+
+
+<!-- ##### FUNCTION gdk_char_width ##### -->
+<para>
+Determine the width of a given character.
+</para>
+
+@font: a #GdkFont
+@character: the character to measure.
+@Returns: the width of the character in pixels.
+
+
+<!-- ##### FUNCTION gdk_char_width_wc ##### -->
+<para>
+Determine the width of a given wide character. (Encoded
+in the wide-character encoding of the current locale).
+</para>
+
+@font: a #GdkFont
+@character: the character to measure.
+@Returns: the width of the character in pixels.
+
+
+<!-- ##### FUNCTION gdk_string_measure ##### -->
+<para>
+Determines the distance from the origin to the rightmost
+portion of a NULL-terminated string when drawn. This is not the
+correct value for determining the origin of the next
+portion when drawing text in multiple pieces.
+See gdk_string_width().
+</para>
+
+@font: a #GdkFont
+@string: the NULL-terminated string to measure.
+@Returns: the right bearing of the string in pixels.
+
+
+<!-- ##### FUNCTION gdk_text_measure ##### -->
+<para>
+Determines the distance from the origin to the rightmost
+portion of a string when drawn. This is not the
+correct value for determining the origin of the next
+portion when drawing text in multiple pieces. 
+See gdk_text_width().
+</para>
+
+@font: a #GdkFont
+@text: the text to measure.
+@text_length: the length of the text in bytes.
+@Returns: the right bearing of the string in pixels.
+
+
+<!-- ##### FUNCTION gdk_char_measure ##### -->
+<para>
+Determines the distance from the origin to the rightmost
+portion of a character when drawn. This is not the
+correct value for determining the origin of the next
+portion when drawing text in multiple pieces. 
+</para>
+
+@font: a #GdkFont
+@character: the character to measure.
+@Returns: the right bearing of the character in pixels.
+
+
+<!-- ##### FUNCTION gdk_string_height ##### -->
+<para>
+Determines the total height of a given NULL-terminated
+string. This value is not generally useful, because you
+cannot determine how this total height will be drawn in
+relation to the baseline. See gdk_string_extents().
+</para>
+
+@font: a #GdkFont
+@string: the NULL-terminated string to measure.
+@Returns: the height of the string in pixels.
+
+
+<!-- ##### FUNCTION gdk_text_height ##### -->
+<para>
+Determines the total height of a given string.
+This value is not generally useful, because you cannot
+determine how this total height will be drawn in
+relation to the baseline. See gdk_text_extents().
+</para>
+
+@font: a #GdkFont
+@text: the text to measure.
+@text_length: the length of the text in bytes.
+@Returns: the height of the string in pixels.
+
+
+<!-- ##### FUNCTION gdk_char_height ##### -->
+<para>
+Determines the total height of a given character.
+This value is not generally useful, because you cannot
+determine how this total height will be drawn in
+relation to the baseline. See gdk_text_extents().
+</para>
+
+@font: a #GdkFont
+@character: the character to measure.
+@Returns: the height of the character in pixels.
+
+
+<!-- ##### TYPEDEF GdkWChar ##### -->
+<para>
+Specifies a wide character type, used to represent character codes.
+This is needed since some native languages have character sets which have
+more than 256 characters (Japanese and Chinese, for example).
+</para>
+<para>
+Wide character values between 0 and 127 are always identical in meaning to
+the ASCII character codes. The wide character value 0 is often used to
+terminate strings of wide characters in a similar way to normal strings
+using the char type.
+</para>
+<para>
+An alternative to wide characters is multi-byte characters, which extend
+normal char strings to cope with larger character sets. As the name suggests,
+multi-byte characters use a different number of bytes to store different
+character codes. For example codes 0-127 (i.e. the ASCII codes) often
+use just one byte of memory, while other codes may use 2, 3 or even 4 bytes.
+Multi-byte characters have the advantage that they can often be used in an
+application with little change, since strings are still represented as arrays
+of char values. However multi-byte strings are much easier to manipulate since
+the character are all of the same size.
+</para>
+<para>
+Applications typically use wide characters to represent character codes
+internally, and multi-byte strings when saving the characters to a file.
+The gdk_wcstombs() and gdk_mbstowcs() functions can be used to convert from
+one representation to the other.
+</para>
+<para>
+See the 'Extended Characters' section of the GNU C Library Reference Manual
+for more detailed information on wide and multi-byte characters.
+</para>
+
+
+<!-- ##### FUNCTION gdk_wcstombs ##### -->
+<para>
+Converts a wide character string to a multi-byte string.
+(The function name comes from an acronym of 'Wide Character String TO
+Multi-Byte String').
+</para>
+
+@src: a wide character string.
+@Returns: the multi-byte string corresponding to @src, or NULL if the
+conversion failed. The returned string should be freed with g_free() when no
+longer needed.
+
+
+<!-- ##### FUNCTION gdk_mbstowcs ##### -->
+<para>
+Converts a multi-byte string to a wide character string.
+(The function name comes from an acronym of 'Multi-Byte String TO Wide
+Character String').
+</para>
+
+@dest: the space to place the converted wide character string into.
+@src: the multi-byte string to convert, which must be null-terminated.
+@dest_max: the maximum number of wide characters to place in @dest.
+@Returns: the number of wide characters written into @dest, or -1 if the
+conversion failed.
+
+

docs/reference/gdk/tmpl/gcs.sgml

@@ -0,0 +1,639 @@
+<!-- ##### 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>
+
+<!-- ##### STRUCT GdkGC ##### -->
+<para>
+The #GdkGC structure represents a graphics context.
+It is an opaque structure with no user-visible
+elements.
+</para>
+
+@dummy_var: 
+
+<!-- ##### STRUCT GdkGCValues ##### -->
+<para>
+The #GdkGCValues structure holds a set of values used
+to create or modify a graphics context.
+
+<informaltable pgwide=1 frame="none" role="struct">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry>#GdkColor	foreground;</entry>
+<entry>the foreground color.</entry>
+</row>
+
+<row>
+<entry>#GdkColor	background;</entry>
+<entry>the background color.</entry>
+</row>
+
+<row>
+<entry>#GdkFont *font;</entry>
+<entry>the default font..</entry>
+</row>
+
+<row>
+<entry>#GdkFunction function;</entry>
+<entry>the bitwise operation used when drawing.</entry>
+</row>
+
+<row>
+<entry>#GdkFill fill;</entry>
+<entry>the fill style.</entry>
+</row>
+
+<row>
+<entry>#GdkPixmap *tile;</entry>
+<entry>the tile pixmap.</entry>
+</row>
+
+<row>
+<entry>#GdkPixmap *stipple;</entry>
+<entry>the stipple bitmap.</entry>
+</row>
+
+<row>
+<entry>#GdkPixmap *clip_mask;</entry>
+<entry>the clip mask bitmap.</entry>
+</row>
+
+<row>
+<entry>#GdkSubwindowMode subwindow_mode;</entry>
+<entry>the subwindow mode.</entry>
+</row>
+
+<row>
+<entry>#gint ts_x_origin;</entry>
+<entry>the x origin of the tile or stipple.</entry>
+</row>
+
+<row>
+<entry>#gint ts_y_origin;</entry>
+<entry>the y origin of the tile or stipple.</entry>
+</row>
+
+<row>
+<entry>#gint clip_x_origin;</entry>
+<entry>the x origin of the clip mask.</entry>
+</row>
+
+<row>
+<entry>#gint clip_y_origin;</entry>
+<entry>the y origin of the clip mask.</entry>
+</row>
+
+<row>
+<entry>#gint graphics_exposures;</entry>
+<entry>whether graphics exposures are enabled.</entry>
+</row>
+
+<row>
+<entry>#gint line_width;</entry>
+<entry>the line width</entry>
+</row>
+
+<row>
+<entry>#GdkLineStyle line_style;</entry>
+<entry>the way dashed lines are drawn</entry>
+</row>
+
+<row>
+<entry>#GdkCapStyle cap_style;</entry>
+<entry>the way the ends of lines are drawn</entry>
+</row>
+
+<row>
+<entry>#GdkJoinStyle join_style;</entry>
+<entry>the way joins between lines are drawn</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+@foreground: 
+@background: 
+@font: 
+@function: 
+@fill: 
+@tile: 
+@stipple: 
+@clip_mask: 
+@subwindow_mode: 
+@ts_x_origin: 
+@ts_y_origin: 
+@clip_x_origin: 
+@clip_y_origin: 
+@graphics_exposures: 
+@line_width: 
+@line_style: 
+@cap_style: 
+@join_style: 
+
+<!-- ##### ENUM GdkGCValuesMask ##### -->
+<para>
+A set of bit flags used to indicate which fields
+#GdkGCValues structure are set.
+</para>
+
+@GDK_GC_FOREGROUND: 
+@GDK_GC_BACKGROUND: 
+@GDK_GC_FONT: 
+@GDK_GC_FUNCTION: 
+@GDK_GC_FILL: 
+@GDK_GC_TILE: 
+@GDK_GC_STIPPLE: 
+@GDK_GC_CLIP_MASK: 
+@GDK_GC_SUBWINDOW: 
+@GDK_GC_TS_X_ORIGIN: 
+@GDK_GC_TS_Y_ORIGIN: 
+@GDK_GC_CLIP_X_ORIGIN: 
+@GDK_GC_CLIP_Y_ORIGIN: 
+@GDK_GC_EXPOSURES: 
+@GDK_GC_LINE_WIDTH: 
+@GDK_GC_LINE_STYLE: 
+@GDK_GC_CAP_STYLE: 
+@GDK_GC_JOIN_STYLE: 
+
+<!-- ##### 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: 
+@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_SET: 
+
+<!-- ##### FUNCTION gdk_gc_new ##### -->
+<para>
+Create a new graphics context with default values. 
+</para>
+
+@window: a #GdkDrawable. The created GC must always be used
+ with drawables of the same depth as this one.
+@Returns: the new graphics context.
+
+
+<!-- ##### FUNCTION gdk_gc_new_with_values ##### -->
+<para>
+Create a new GC with the given initial values.
+</para>
+
+@window: a #GdkDrawable. The created GC must always be used
+ with drawables of the same depth as this one.
+@values: a structure containing initial values for the GC.
+@values_mask: a bit mask indicating which fields in @values
+   are set.
+@Returns: the new graphics context.
+
+
+<!-- ##### FUNCTION gdk_gc_ref ##### -->
+<para>
+Increase the reference count on a graphics context.
+</para>
+
+@gc: a #GdkGC.
+@Returns: @gc.
+
+
+<!-- ##### FUNCTION gdk_gc_unref ##### -->
+<para>
+Decrease the reference count on a graphics context. If
+the resulting reference count is zero, the graphics
+context will be destroyed.
+</para>
+
+@gc: a #GdkGC.
+
+
+<!-- ##### FUNCTION gdk_gc_destroy ##### -->
+<para>
+Identical to gdk_gc_unref(). This function is obsolete
+and should not be used.
+</para>
+
+@gc: a #GdkGC.
+
+
+<!-- ##### FUNCTION gdk_gc_get_values ##### -->
+<para>
+Retrieves the current values from a graphics context.
+</para>
+
+@gc: a #GdkGC.
+@values: the #GdkGCValues structure in which to store the results.
+
+
+<!-- ##### FUNCTION gdk_gc_set_foreground ##### -->
+<para>
+Sets the foreground color for a graphics context.
+</para>
+
+@gc: a #GdkGC.
+@color: the new foreground color.
+
+
+<!-- ##### FUNCTION gdk_gc_set_background ##### -->
+<para>
+Sets the background color for a graphics context.
+</para>
+
+@gc: a #GdkGC.
+@color: the new background color.
+
+
+<!-- ##### FUNCTION gdk_gc_set_font ##### -->
+<para>
+Sets the font for a graphics context. (Note that
+all text-drawing functions in GDK take a @font
+argument; the value set here is used when that
+argument is %NULL.)
+</para>
+
+@gc: a #GdkGC.
+@font: the new font.
+
+
+<!-- ##### FUNCTION gdk_gc_set_function ##### -->
+<para>
+Determines how the current pixel values and the
+pixel values being drawn are combined to produce
+the final pixel values.
+</para>
+
+@gc: a #GdkGC.
+@function: 
+
+
+<!-- ##### FUNCTION gdk_gc_set_fill ##### -->
+<para>
+Set the fill mode for a graphics context.
+</para>
+
+@gc: a #GdkGC.
+@fill: the new fill mode.
+
+
+<!-- ##### ENUM GdkFill ##### -->
+<para>
+Determines how primitives are drawn.
+
+<informaltable pgwide=1 frame="none" role="enum">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry>GDK_SOLID</entry>
+<entry>draw with the foreground color.</entry>
+</row>
+
+<row>
+<entry>GDK_TILED</entry>
+<entry>draw with a tiled pixmap.</entry>
+</row>
+
+<row>
+<entry>GDK_STIPPLED</entry>
+<entry>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.</entry>
+</row>
+
+<row>
+<entry>GDK_OPAQUE_STIPPLED</entry>
+<entry>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.</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+@GDK_SOLID: 
+@GDK_TILED: 
+@GDK_STIPPLED: 
+@GDK_OPAQUE_STIPPLED: 
+
+<!-- ##### FUNCTION gdk_gc_set_tile ##### -->
+<para>
+Set a tile pixmap for a graphics context.
+This will only be used if the fill mode
+is %GDK_TILED.
+</para>
+
+@gc: a #GdkGC.
+@tile: the new tile pixmap.
+
+
+<!-- ##### FUNCTION gdk_gc_set_stipple ##### -->
+<para>
+Set the stipple bitmap for a graphics context. The
+stipple will only be used if the fill mode is
+%GDK_STIPPLED or %GDK_OPAQUE_STIPPLED.
+</para>
+
+@gc: a #GdkGC.
+@stipple: the new stipple bitmap.
+
+
+<!-- ##### FUNCTION gdk_gc_set_ts_origin ##### -->
+<para>
+Set the origin when using tiles or stipples with
+the GC. The tile or stipple will be aligned such
+that the upper left corner of the tile or stipple
+will coincide with this point.
+</para>
+
+@gc: a #GdkGC.
+@x: the x-coordinate of the origin.
+@y: the y-coordinate of the origin.
+
+
+<!-- ##### FUNCTION gdk_gc_set_clip_origin ##### -->
+<para>
+Sets the origin of the clip mask. The coordinates are
+interpreted relative to the upper-left corner of
+the destination drawable of the current operation.
+</para>
+
+@gc: a #GdkGC.
+@x: the x-coordinate of the origin.
+@y: the y-coordinate of the origin.
+
+
+<!-- ##### FUNCTION gdk_gc_set_clip_mask ##### -->
+<para>
+Sets the clip mask for a graphics context from a bitmap.
+The clip mask is interpreted relative to the clip
+origin. (See gdk_gc_set_clip_origin()).
+</para>
+
+@gc: the #GdkGC.
+@mask: a bitmap.
+
+
+<!-- ##### FUNCTION gdk_gc_set_clip_rectangle ##### -->
+<para>
+Sets the clip mask for a graphics context from a
+rectangle. The clip mask is interpreted relative to the clip
+origin. (See gdk_gc_set_clip_origin()).
+
+</para>
+
+@gc: a #GdkGC.
+@rectangle: the rectangle to clip to.
+
+
+<!-- ##### FUNCTION gdk_gc_set_clip_region ##### -->
+<para>
+Sets the clip mask for a graphics context from a region structure.
+The clip mask is interpreted relative to the clip origin. (See
+gdk_gc_set_clip_origin()).
+</para>
+
+@gc: a #GdkGC.
+@region: the #GdkRegion.
+
+
+<!-- ##### FUNCTION gdk_gc_set_subwindow ##### -->
+<para>
+Sets how drawing with this GC on a window will affect child
+windows of that window. 
+</para>
+
+@gc: a #GdkGC.
+@mode: the subwindow mode.
+
+
+<!-- ##### ENUM GdkSubwindowMode ##### -->
+<para>
+
+Determines how drawing onto a window will affect child
+windows of that window. 
+
+<informaltable pgwide=1 frame="none" role="enum">
+<tgroup cols="2"><colspec colwidth="3*"><colspec colwidth="7*">
+<tbody>
+
+<row>
+<entry>GDK_CLIP_BY_CHILDREN</entry>
+<entry>only draw onto the window itself.</entry>
+</row>
+
+<row>
+<entry>GDK_INCLUDE_INFERIORS</entry>
+<entry>Draw onto the window and child windows.</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+@GDK_CLIP_BY_CHILDREN: 
+@GDK_INCLUDE_INFERIORS: 
+
+<!-- ##### FUNCTION gdk_gc_set_exposures ##### -->
+<para>
+Sets whether copying non-visible portions of a drawable
+using this graphics context generate exposure events
+for the corresponding regions of the destination
+drawable. (See gdk_draw_pixmap()).
+</para>
+
+@gc: a #GdkGC.
+@exposures: if %TRUE, exposure events will be generated.
+
+
+<!-- ##### FUNCTION gdk_gc_set_line_attributes ##### -->
+<para>
+Sets various attributes of how lines are drawn. See
+the corresponding members of GdkGCValues for full
+explanations of the arguments.
+</para>
+
+@gc: a #GdkGC.
+@line_width: the width of lines.
+@line_style: the dash-style for lines.
+@cap_style: the manner in which the ends of lines are drawn.
+@join_style: the in which lines are joined together.
+
+
+<!-- ##### ENUM GdkLineStyle ##### -->
+<para>
+Determines how lines are drawn.
+
+<informaltable pgwide=1 frame="none" role="enum">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry>GDK_LINE_SOLID</entry>
+<entry>lines are drawn solid.</entry>
+</row>
+
+<row>
+<entry>GDK_LINE_ON_OFF_DASH</entry>
+<entry>even segments are drawn; odd segments are not drawn.</entry>
+</row>
+
+<row>
+<entry>GDK_LINE_DOUBLE_DASH</entry>
+<entry>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.</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+@GDK_LINE_SOLID: 
+@GDK_LINE_ON_OFF_DASH: 
+@GDK_LINE_DOUBLE_DASH: 
+
+<!-- ##### ENUM GdkCapStyle ##### -->
+<para>
+Determines how the end of lines are drawn.
+
+<informaltable pgwide=1 frame="none" role="struct">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry>GDK_CAP_NOT_LAST</entry>
+<entry>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.</entry>
+</row>
+
+<row>
+<entry>GDK_CAP_BUTT</entry>
+<entry>the ends of the lines are drawn squared off and extending
+       to the coordinates of the end point.</entry>
+</row>
+
+<row>
+<entry>GDK_CAP_ROUND</entry>
+<entry>the ends of the lines are drawn as semicircles with the
+       diameter equal to the line width and centered at the
+       end point.</entry>
+</row>
+
+<row>
+<entry>GDK_CAP_PROJECTING</entry>
+<entry>the ends of the lines are drawn squared off and extending
+       half the width of the line beyond the end point.</entry>
+</row>
+</tbody></tgroup></informaltable>
+</para>
+
+@GDK_CAP_NOT_LAST: 
+@GDK_CAP_BUTT: 
+@GDK_CAP_ROUND: 
+@GDK_CAP_PROJECTING: 
+
+<!-- ##### ENUM GdkJoinStyle ##### -->
+<para>
+Determines how the joins between segments of a polygon are drawn.
+
+<informaltable pgwide=1 frame="none" role="struct">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry>GDK_JOIN_MITER</entry>
+<entry>the sides of each line are extended to meet at an angle.</entry>
+</row>
+
+<row>
+<entry>GDK_JOIN_ROUND</entry>
+<entry>the sides of the two lines are joined by a circular arc.</entry>
+</row>
+
+<row>
+<entry>GDK_JOIN_BEVEL</entry>
+<entry>the sides of the two lines are joined by a straight line which
+       makes an equal angle with each line.</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+@GDK_JOIN_MITER: 
+@GDK_JOIN_ROUND: 
+@GDK_JOIN_BEVEL: 
+
+<!-- ##### FUNCTION gdk_gc_set_dashes ##### -->
+<para>
+Sets the way dashed-lines are drawn. Lines will be
+drawn with alternating on and off segments of the
+lengths specified in @dash_list. The manner in
+which the on and off segments are drawn is determined
+by the @line_style value of the GC. (This can
+be changed with gdk_gc_set_line_attributes)
+</para>
+
+@gc: a #GdkGC.
+@dash_offset: the
+@dash_list: an array of dash lengths.
+@n: the number of elements in @dash_list.
+
+
+<!-- ##### FUNCTION gdk_gc_copy ##### -->
+<para>
+Copy the set of values from one graphics context
+onto another graphics context.
+</para>
+
+@dst_gc: the destination graphics context.
+@src_gc: the source graphics context.
+
+

docs/reference/gdk/tmpl/general.sgml

@@ -0,0 +1,346 @@
+<!-- ##### SECTION Title ##### -->
+General
+
+<!-- ##### SECTION Short_Description ##### -->
+library initialization and miscellaneous functions.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+This section describes the GDK initialization functions and miscellaneous
+utility functions.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### FUNCTION gdk_init ##### -->
+<para>
+Initializes the GDK library and connects to the X server.
+If initialization fails, a warning message is output and the application
+terminates with a call to exit(1).
+</para>
+<para>
+Any arguments used by GDK are removed from the array and @argc and @argv are
+updated accordingly.
+</para>
+<para>
+GTK+ initializes GDK in gtk_init() and so this function is not usually needed
+by GTK+ applications.
+</para>
+
+@argc: the number of command line arguments.
+@argv: the array of command line arguments.
+
+
+<!-- ##### FUNCTION gdk_init_check ##### -->
+<para>
+Initializes the GDK library and connects to the X server, returning TRUE on
+success.
+</para>
+<para>
+Any arguments used by GDK are removed from the array and @argc and @argv are
+updated accordingly.
+</para>
+<para>
+GTK+ initializes GDK in gtk_init() and so this function is not usually needed
+by GTK+ applications.
+</para>
+
+@argc: the number of command line arguments.
+@argv: the array of command line arguments.
+@Returns: TRUE if initialization succeeded.
+
+
+<!-- ##### FUNCTION gdk_exit ##### -->
+<para>
+Exits the application using the exit() system call.
+</para>
+<para>
+This routine is provided mainly for backwards compatability, since it used to
+perform tasks necessary to exit the application cleanly. Those tasks are now
+performed in a function which is automatically called on exit (via the use
+of g_atexit()).
+</para>
+
+@error_code: the error code to pass to the exit() call.
+
+
+<!-- ##### FUNCTION gdk_set_locale ##### -->
+<para>
+Initializes the support for internationalization by calling the setlocale()
+system call. This function is called by gtk_set_locale() and so GTK+
+applications should use that instead.
+</para>
+<para>
+The locale to use is determined by the LANG environment variable,
+so to run an application in a certain locale you can do something like this:
+<informalexample>
+<programlisting>
+  export LANG="fr"
+  ... run application ...
+</programlisting>
+</informalexample>
+</para>
+<para>
+If the locale is not supported by X then it is reset to the standard "C"
+locale.
+</para>
+
+@Returns: the resulting locale.
+
+
+<!-- ##### FUNCTION gdk_set_sm_client_id ##### -->
+<para>
+Sets the SM_CLIENT_ID property on the application's leader window so that
+the window manager can save the application's state using the X11R6 ICCCM
+session management protocol.
+</para>
+<para>
+The leader window is automatically created by GDK and never shown. It's only
+use is for session management. The WM_CLIENT_LEADER property is automatically
+set on all X windows created by the application to point to the leader window.
+</para>
+<para>
+See the X Session Management Library documentation for more information on
+session management and the Inter-Client Communication Conventions Manual
+(ICCCM) for information on the WM_CLIENT_LEADER property. (Both documents are
+part of the X Windows distribution.)
+</para>
+
+@sm_client_id: the client id assigned by the session manager when the
+connection was opened, or NULL to remove the property.
+
+
+<!-- ##### FUNCTION gdk_get_display ##### -->
+<para>
+Gets the name of the display, which usually comes from the DISPLAY
+environment variable or the --display command line option.
+</para>
+
+@Returns: the name of the display.
+
+
+<!-- ##### FUNCTION gdk_flush ##### -->
+<para>
+Flushes the X output buffer and waits until all requests have been processed
+by the server. This is rarely needed by applications. It's main use is for
+trapping X errors with gdk_error_trap_push() and gdk_error_trap_pop().
+</para>
+
+
+
+<!-- ##### FUNCTION gdk_screen_width ##### -->
+<para>
+Returns the width of the screen in pixels.
+</para>
+
+@Returns: the width of the screen in pixels.
+
+
+<!-- ##### FUNCTION gdk_screen_height ##### -->
+<para>
+Returns the height of the screen in pixels.
+</para>
+
+@Returns: the height of the screen in pixels.
+
+
+<!-- ##### FUNCTION gdk_screen_width_mm ##### -->
+<para>
+Returns the width of the screen in millimeters.
+Note that on many X servers this value will not be correct.
+</para>
+
+@Returns: the width of the screen in millimeters, though it is not always
+correct.
+
+
+<!-- ##### FUNCTION gdk_screen_height_mm ##### -->
+<para>
+Returns the height of the screen in millimeters.
+Note that on many X servers this value will not be correct.
+</para>
+
+@Returns: the height of the screen in millimeters, though it is not always
+correct.
+
+
+<!-- ##### FUNCTION gdk_pointer_grab ##### -->
+<para>
+Grabs the pointer (usually a mouse) so that all events are passed to this
+application until the pointer is ungrabbed with gdk_pointer_ungrab(), or
+the grab window becomes unviewable.
+This overrides any previous pointer grab by this client.
+</para>
+<para>
+Pointer grabs are used for operations which need complete control over mouse
+events, even if the mouse leaves the application.
+For example in GTK+ it is used for Drag and Drop, for dragging the handle in
+the #GtkHPaned and #GtkVPaned widgets, and for resizing columns in #GtkCList
+widgets.
+</para>
+<para>
+Note that if the event mask of an X window has selected both button press and
+button release events, then a button press event will cause an automatic
+pointer grab until the button is released.
+X does this automatically since most applications expect to receive button
+press and release events in pairs.
+It is equivalent to a pointer grab on the window with @owner_events set to
+TRUE.
+</para>
+
+@window: the #GdkWindow which will own the grab (the grab window).
+@owner_events: if FALSE then all pointer events are reported with respect to
+@window and are only reported if selected by @event_mask. If TRUE then pointer
+events for this application are reported as normal, but pointer events outside
+this application are reported with respect to @window and only if selected by
+@event_mask. In either mode, unreported events are discarded.
+@event_mask: specifies the event mask, which is used in accordance with
+@owner_events.
+@confine_to: TRUE to confine the pointer to @window. If the pointer is outside
+@window, it will automatically be moved to the closest edge of @window and
+enter and leave events will be generated as necessary.
+@cursor: the cursor to display while the grab is active. If this is NULL then
+the normal cursors are used for @window and its descendants, and the cursor
+for @window is used for all other windows.
+@time: the timestamp of the event which led to this pointer grab. This usually
+comes from a #GdkEventButton struct, though #GDK_CURRENT_TIME can be used if
+the time isn't known.
+@Returns: 0 if the grab was successful.
+
+
+<!-- ##### FUNCTION gdk_pointer_ungrab ##### -->
+<para>
+Ungrabs the pointer, if it is grabbed by this application.
+</para>
+
+@time: a timestamp from a #GdkEvent, or #GDK_CURRENT_TIME if no timestamp is
+available.
+
+
+<!-- ##### FUNCTION gdk_pointer_is_grabbed ##### -->
+<para>
+Returns TRUE if the pointer is currently grabbed by this application.
+</para>
+<para>
+Note that the return value is not completely reliable since the X server may
+automatically ungrab the pointer, without informing the application, if the
+grab window becomes unviewable. It also does not take passive pointer grabs
+into account.
+</para>
+
+@Returns: TRUE if the pointer is currently grabbed by this application.
+Though this value is not always correct.
+
+
+<!-- ##### FUNCTION gdk_keyboard_grab ##### -->
+<para>
+Grabs the keyboard so that all events are passed to this
+application until the keyboard is ungrabbed with gdk_keyboard_ungrab().
+This overrides any previous keyboard grab by this client.
+</para>
+
+@window: the #GdkWindow which will own the grab (the grab window).
+@owner_events: if FALSE then all keyboard events are reported with respect to
+@window. If TRUE then keyboard events for this application are reported as
+normal, but keyboard events outside this application are reported with respect
+to @window. Both key press and key release events are always reported,
+independant of the event mask set by the application.
+@time: a timestamp from a #GdkEvent, or #GDK_CURRENT_TIME if no timestamp is
+available.
+@Returns: 0 if the grab was successful.
+
+
+<!-- ##### FUNCTION gdk_keyboard_ungrab ##### -->
+<para>
+Ungrabs the keyboard, if it is grabbed by this application.
+</para>
+
+@time: a timestamp from a #GdkEvent, or #GDK_CURRENT_TIME if no timestamp is
+available.
+
+
+<!-- ##### FUNCTION gdk_key_repeat_disable ##### -->
+<para>
+Disables the keyboard auto-repeat mode.
+This should be used with care as it may affect other applications.
+</para>
+
+
+
+<!-- ##### FUNCTION gdk_key_repeat_restore ##### -->
+<para>
+Restores the keyboard auto-repeat mode to its state when the application was
+started.
+</para>
+
+
+
+<!-- ##### FUNCTION gdk_beep ##### -->
+<para>
+Emits a short beep.
+</para>
+
+
+
+<!-- ##### FUNCTION gdk_get_use_xshm ##### -->
+<para>
+Returns TRUE if GDK will attempt to use the MIT-SHM shared memory extension.
+</para>
+<para>
+The shared memory extension is used for #GdkImage, and consequently for
+<link linkend="gdk-GdkRGB">GdkRGB</link>.
+It enables much faster drawing by communicating with the X server through
+SYSV shared memory calls. However, it can only be used if the X client and
+server are on the same machine and the server supports it.
+</para>
+
+@Returns: TRUE if use of the MIT shared memory extension will be attempted.
+
+
+<!-- ##### FUNCTION gdk_set_use_xshm ##### -->
+<para>
+Sets whether the use of the MIT shared memory extension should be attempted.
+This function is mainly for internal use. It is only safe for an application
+to set this to FALSE, since if it is set to TRUE and the server does not
+support the extension it may cause warning messages to be output.
+</para>
+
+@use_xshm: TRUE if use of the MIT shared memory extension should be attempted.
+
+
+<!-- ##### FUNCTION gdk_error_trap_push ##### -->
+<para>
+This function allows X errors to be trapped instead of the normal behavior
+of exiting the application. It should only be used if it is not possible to
+avoid the X error in any other way.
+</para>
+<example>
+<title>Trapping an X error.</title>
+<programlisting>
+  gdk_error_trap_push ();
+
+  /* ... Call the X function which may cause an error here ... */
+
+  /* Flush the X queue to catch errors now. */
+  gdk_flush ();
+
+  if (gdk_error_trap_pop ())
+    {
+      /* ... Handle the error here ... */
+    }
+</programlisting>
+</example>
+
+
+
+<!-- ##### FUNCTION gdk_error_trap_pop ##### -->
+<para>
+Removes the X error trap installed with gdk_error_trap_push().
+</para>
+
+@Returns: the X error code, or 0 if no error occurred.
+
+

docs/reference/gdk/tmpl/images.sgml

@@ -0,0 +1,156 @@
+<!-- ##### SECTION Title ##### -->
+Images
+
+<!-- ##### SECTION Short_Description ##### -->
+an area for bit-mapped graphics stored on the X Windows client.
+
+<!-- ##### 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 a #GdkImage from bitmap data use gdk_image_new_bitmap().
+To create an image from part of a #GdkWindow use gdk_image_get().
+</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 gdk_image_destroy().
+</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>
+
+<!-- ##### STRUCT GdkImage ##### -->
+<para>
+The #GdkImage struct contains information on the image and the pixel data.
+</para>
+
+@type: the type of the image.
+@visual: the visual.
+@byte_order: the byte order.
+@width: the width of the image in pixels.
+@height: the height of the image in pixels.
+@depth: the depth of the image, i.e. the number of bits per pixel.
+@bpp: the number of bytes per pixel.
+@bpl: the number of bytes per line of the image.
+@mem: the pixel data.
+
+<!-- ##### 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_new_bitmap ##### -->
+<para>
+Creates a new #GdkImage with a depth of 1 from the given data.
+</para>
+
+@visual: the #GdkVisual to use for the image.
+@data: the pixel data.
+@width: the width of the image in pixels.
+@height: the height of the image in pixels.
+@Returns: a new #GdkImage.
+
+
+<!-- ##### FUNCTION gdk_image_get ##### -->
+<para>
+Gets part of a #GdkWindow and stores it in a new #GdkImage.
+</para>
+
+@window: the #GdkWindow to copy from.
+@x: the left edge of the rectangle to copy from @window.
+@y: the top edge of the rectangle to copy from @window.
+@width: the width of the area to copy, in pixels.
+@height: the height of the area to copy, in pixels.
+@Returns: a new #GdkImage with a copy of the given area of @window.
+
+
+<!-- ##### FUNCTION gdk_image_destroy ##### -->
+<para>
+Destroys a #GdkImage, freeing any resources allocated for it.
+</para>
+
+@image: a #GdkImage.
+
+
+<!-- ##### 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/input.sgml

@@ -0,0 +1,130 @@
+<!-- ##### SECTION Title ##### -->
+Input
+
+<!-- ##### SECTION Short_Description ##### -->
+Callbacks on file descriptors.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+The functions in this section are used to establish
+callbacks when some condition becomes true for
+a file descriptor. They are currently just wrappers around
+the <link linkend="glib-IO-Channels">IO Channel</link>
+facility.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+<variablelist>
+
+<varlistentry>
+<term><link linkend="glib-The-Main-Event-Loop">GLib Main Loop</link></term>
+<listitem><para>The main loop in which input callbacks run.</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term><link linkend="glib-IO-Channels">IO Channels</link></term>
+<listitem><para>A newer and more flexible way of doing IO
+callbacks.</para></listitem>
+</varlistentry>
+
+</variablelist>
+</para>
+
+<!-- ##### FUNCTION gdk_input_add_full ##### -->
+<para>
+Establish a callback when a condition becomes true on
+a file descriptor.
+</para>
+
+@source: a file descriptor.
+@condition: the condition.
+@function: the callback function.
+@data: callback data passed to @function.
+@destroy: callback function to call with @data when the input
+  handler is removed.
+@Returns: a tag that can later be used as an argument to
+ gdk_input_remove().
+
+
+<!-- ##### ENUM GdkInputCondition ##### -->
+<para>
+A set of bit flags used to specify conditions for which
+an input callback will be triggered. The three members
+of this enumeration correspond to the @readfds, 
+@writefds, and @exceptfds arguments to the 
+<function>select</function> system call.
+
+<informaltable pgwide=1 frame="none" role="enum">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry>GDK_INPUT_READ</entry>
+<entry>the file descriptor has become available for reading.
+(Or, as is standard in Unix, a socket or pipe was closed
+at the other end; this is the case if a subsequent read
+on the file descriptor returns a count of zero.)</entry>
+</row>
+
+<row>
+<entry>GDK_INPUT_WRITE</entry>
+<entry>the file descriptor has become available for writing.</entry>
+</row>
+
+<row>
+<entry>GDK_INPUT_EXCEPTION</entry>
+<entry>an exception was raised on the file descriptor.</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+@GDK_INPUT_READ: 
+@GDK_INPUT_WRITE: 
+@GDK_INPUT_EXCEPTION: 
+
+<!-- ##### USER_FUNCTION GdkInputFunction ##### -->
+<para>
+A callback function that will be called when some condition
+occurs.
+</para>
+
+@data: the user data passed to gdk_input_add() or gdk_input_add_full().
+@source: the source where the condition occurred.
+@condition: the triggering condition.
+
+
+<!-- ##### USER_FUNCTION GdkDestroyNotify ##### -->
+<para>
+A callback function called when a piece of user data is 
+no longer being stored by GDK. Will typically free the
+structure or object that @data points to.
+</para>
+
+@data: the user data.
+
+
+<!-- ##### FUNCTION gdk_input_add ##### -->
+<para>
+Establish a callback when a condition becomes true on
+a file descriptor.
+</para>
+
+@source: a file descriptor.
+@condition: the condition.
+@function: the callback function.
+@data: callback data passed to @function.
+@Returns: a tag that can later be used as an argument to
+ gdk_input_remove().
+
+
+<!-- ##### FUNCTION gdk_input_remove ##### -->
+<para>
+Remove a callback added with gdk_input_add() or 
+gdk_input_add_full().
+</para>
+
+@tag: the tag returned when the callback was set up.
+
+

docs/reference/gdk/tmpl/input_contexts.sgml

@@ -0,0 +1,243 @@
+<!-- ##### SECTION Title ##### -->
+Input Contexts
+
+<!-- ##### SECTION Short_Description ##### -->
+internationalized text input properties.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+A #GdkIC input context is used for each user interface element which supports
+internationalized text input. See the
+<link linkend="gdk-Input-Methods">Input Methods</link> section for an overview
+of how internationalized text input works in GTK+.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### STRUCT GdkIC ##### -->
+<para>
+The #GdkIC struct is an opaque structure representing an input context
+for use with the global <link linkend="gdk-Input-Methods">Input Method</link>.
+</para>
+
+
+<!-- ##### FUNCTION gdk_ic_new ##### -->
+<para>
+Creates a new #GdkIC using the given attributes.
+</para>
+
+@attr: a #GdkICAttr struct containing attributes to use for the input context.
+@mask: a #GdkICAttributesType mask specifying which of the attributes in @attr
+are set.
+@Returns: a new #GdkIC.
+
+
+<!-- ##### FUNCTION gdk_ic_destroy ##### -->
+<para>
+Destroys the input context.
+</para>
+
+@ic: a #GdkIC.
+
+
+<!-- ##### FUNCTION gdk_ic_get_events ##### -->
+<para>
+Returns the mask of events that the input method needs to function properly.
+This is typically called in a widget's realize method after creating the
+#GdkIC. The returned event mask is then combined with the widget's
+own event mask and applied using gdk_window_set_events().
+</para>
+
+@ic: a #GdkIC.
+@Returns: the mask of events that the input method needs to function
+properly.
+
+
+<!-- ##### FUNCTION gdk_ic_get_style ##### -->
+<para>
+Returns the pre-edit and status style of the #GdkIC.
+</para>
+
+@ic: a #GdkIC.
+@Returns: the pre-edit and status style of the #GdkIC.
+
+
+<!-- ##### FUNCTION gdk_ic_get_attr ##### -->
+<para>
+Gets attributes of a #GdkIC.
+</para>
+
+@ic: a #GdkIC.
+@attr: a #GdkICAttr struct to contain the returned attributes.
+@mask: a #GdkICAttributesType mask specifying which attributes to get.
+@Returns: a #GdkICAttributesType mask specifying which of the attributes
+were not retrieved succesfully.
+
+
+<!-- ##### FUNCTION gdk_ic_set_attr ##### -->
+<para>
+Sets attributes of the #GdkIC.
+</para>
+<para>
+Note that the GDK_IC_STYLE and GDK_IC_CLIENT_WINDOW attributes can only be set
+when creating the #GdkIC, and the GDK_IC_FILTER_EVENTS attribute is read-only.
+</para>
+
+@ic: a #GdkIC.
+@attr: a #GdkICAttr struct containing attributes to use for the input context.
+@mask: a #GdkICAttributesType mask specifying which of the attributes in @attr
+are set.
+@Returns: a #GdkICAttributesType mask indicating which of the attributes
+were not set successfully.
+
+
+<!-- ##### STRUCT GdkICAttr ##### -->
+<para>
+The #GdkICAttr struct is used when getting and setting attributes of the
+input context. It is used together with a #GdkICAttributesType mask which
+specifies which of the fields are being set or returned.
+</para>
+
+@style: the pre-edit and status style. This attribute is required when
+creating the #GdkIC, and cannot be changed.
+@client_window: the #GdkWindow in which the input method will display its
+pre-edit and status areas or create subwindows.
+The preedit_area and status_area attributes are specified relative to this
+window. This attribute is required when creating the #GdkIC, and cannot be
+changed.
+@focus_window: the #GdkWindow which is to be used when editing text.
+gdk_im_begin() sets this attribute before starting the text input process,
+so it is normally not necessary to set it elsewhere.
+@filter_events: the mask of events that the input method requires.
+See the gdk_ic_get_events() function. This attribute is read-only and is
+never changed.
+@spot_location: the position of the insertion cursor, for use with the
+%GDK_IM_PREEDIT_POSITION style. The y coordinate specifies the baseline of
+the text.
+@line_spacing: the line spacing to be used in the pre-edit and status areas
+when displaying multi-line text.
+@cursor: the cursor to use in the input method's windows.
+If this attribute isn't set it is determined by the input method.
+@preedit_fontset: the font to use for the pre-edit area.
+If this attribute isn't set it is determined by the input method.
+@preedit_area: the area in which the input method will display pre-editing
+data, used for the %GDK_IM_PREEDIT_POSITION and %GDK_IM_PREEDIT_AREA styles.
+@preedit_area_needed: the area that the input method requests for displaying
+pre-editing data, used for the %GDK_IM_PREEDIT_POSITION and
+%GDK_IM_PREEDIT_AREA styles.
+@preedit_foreground: the foreground color to use for the pre-edit area.
+This color must already be allocated in the preedit_colormap.
+If this attribute isn't set it is determined by the input method.
+@preedit_background: the background color to use for the pre-edit area.
+This color must already be allocated in the preedit_colormap.
+If this attribute isn't set it is determined by the input method.
+@preedit_pixmap: the background pixmap to use for the pre-edit area.
+If this attribute isn't set it is determined by the input method.
+@preedit_colormap: the colormap the input method should use to allocate colors.
+The default value is the colormap of client_window.
+@status_fontset: the font to use for the status area.
+If this attribute isn't set it is determined by the input method.
+@status_area: the are that the input method will display status information in.
+This is used for the %GDK_IM_STATUS_AREA style.
+@status_area_needed: the size that the input method requests for displaying
+status information, for the %GDK_IM_STATUS_AREA style.
+@status_foreground: the foreground color to use for the status area.
+This color must already be allocated in the status_colormap.
+If this attribute isn't set it is determined by the input method.
+@status_background: the background color to use for the status area.
+This color must already be allocated in the status_colormap.
+If this attribute isn't set it is determined by the input method.
+@status_pixmap: the background pixmap to use for the status area.
+If this attribute isn't set it is determined by the input method.
+@status_colormap: the colormap the input method should use to allocate colors.
+The default value is the colormap of client_window.
+
+<!-- ##### ENUM GdkICAttributesType ##### -->
+<para>
+The #GdkICAttributesType contains a set of bit-flags which are used to
+specify which of the attributes in a #GdkICAttr are being set or returned.
+</para>
+<para>
+It also contains several combinations of the flags which specify required
+attributes for the various styles:
+<variablelist>
+<varlistentry>
+<term>%GDK_IC_ALL_REQ:</term>
+<listitem><para>
+the set of attributes required for all styles.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term>%GDK_IC_PREEDIT_AREA_REQ:</term>
+<listitem><para>
+the set of additional attributes required for the
+%GDK_IM_PREEDIT_AREA pre-edit style.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term>%GDK_IC_PREEDIT_POSITION_REQ:</term>
+<listitem><para>
+the set of additional attributes required for the
+%GDK_IM_PREEDIT_POSITION pre-edit style.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term>%GDK_IC_STATUS_AREA_REQ:</term>
+<listitem><para>
+the set of additional attributes required for the
+%GDK_IM_STATUS_AREA status style.
+</para></listitem>
+</varlistentry>
+</variablelist>
+</para>
+
+@GDK_IC_STYLE: 
+@GDK_IC_CLIENT_WINDOW: 
+@GDK_IC_FOCUS_WINDOW: 
+@GDK_IC_FILTER_EVENTS: 
+@GDK_IC_SPOT_LOCATION: 
+@GDK_IC_LINE_SPACING: 
+@GDK_IC_CURSOR: 
+@GDK_IC_PREEDIT_FONTSET: 
+@GDK_IC_PREEDIT_AREA: 
+@GDK_IC_PREEDIT_AREA_NEEDED: 
+@GDK_IC_PREEDIT_FOREGROUND: 
+@GDK_IC_PREEDIT_BACKGROUND: 
+@GDK_IC_PREEDIT_PIXMAP: 
+@GDK_IC_PREEDIT_COLORMAP: 
+@GDK_IC_STATUS_FONTSET: 
+@GDK_IC_STATUS_AREA: 
+@GDK_IC_STATUS_AREA_NEEDED: 
+@GDK_IC_STATUS_FOREGROUND: 
+@GDK_IC_STATUS_BACKGROUND: 
+@GDK_IC_STATUS_PIXMAP: 
+@GDK_IC_STATUS_COLORMAP: 
+@GDK_IC_ALL_REQ: 
+@GDK_IC_PREEDIT_AREA_REQ: 
+@GDK_IC_PREEDIT_POSITION_REQ: 
+@GDK_IC_STATUS_AREA_REQ: 
+
+<!-- ##### FUNCTION gdk_ic_attr_new ##### -->
+<para>
+Creates a new #GdkICAttr struct, with all fields set to 0.
+The #GdkICAttr struct should be freed with gdk_ic_attr_destroy() when no
+longer needed.
+</para>
+
+@Returns: a new #GdkICAttr struct.
+
+
+<!-- ##### FUNCTION gdk_ic_attr_destroy ##### -->
+<para>
+Destroys the given #GdkICAttr struct, freeing the allocated memory.
+</para>
+
+@attr: a #GdkICAttr struct.
+
+

docs/reference/gdk/tmpl/input_devices.sgml

@@ -0,0 +1,301 @@
+<!-- ##### SECTION Title ##### -->
+Input Devices
+
+<!-- ##### SECTION Short_Description ##### -->
+Functions for handling extended input devices.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+In addition to the normal keyboard and mouse input devices, GTK+ also
+contains support for <firstterm>extended input devices</firstterm>. In
+particular, this support is targeted at graphics tablets. Graphics
+tablets typically return sub-pixel positioning information and possibly
+information about the pressure and tilt of the stylus. Under
+X, the support for extended devices is done through the 
+<firstterm>XInput</firstterm> extension.
+</para>
+<para>
+Because handling extended input devices may involve considerable
+overhead, they need to be turned on for each #GdkWindow
+individually using gdk_input_set_extension_events().
+(Or, more typically, for GtkWidgets, using gtk_widget_set_extension_events()).
+As an additional complication, depending on the support from
+the windowing system, its possible that a normal mouse
+cursor will not be displayed for a particular extension
+device. If an application does not want to deal with displaying
+a cursor itself, it can ask only to get extension events
+from devices that will display a cursor, by passing the
+%GDK_EXTENSION_EVENTS_CURSOR value to
+gdk_input_set_extension_events(). Otherwise, the application
+must retrieve the device information using gdk_input_list_devices(),
+check the <structfield>has_cursor</structfield> field, and, 
+if it is %FALSE, draw a cursor itself when it receives 
+motion events.
+</para>
+<para>
+Each pointing device is assigned a unique integer ID; events from a
+particular device can be identified by the
+<structfield>deviceid</structfield> field in the event structure. The
+events generated by pointer devices have also been extended to contain
+<structfield>pressure</structfield>, <structfield>xtilt</structfield>
+and <structfield>ytilt</structfield> fields which contain the extended
+information reported as additional <firstterm>valuators</firstterm>
+from the device. The <structfield>pressure</structfield> field is a 
+a double value ranging from 0.0 to 1.0, while the tilt fields are
+double values ranging from -1.0 to 1.0. (With -1.0 representing the
+maximum title to the left or up, and 1.0 representing the maximum
+tilt to the right or down.)
+</para>
+<para>
+One additional field in each event is the
+<structfield>source</structfield> field, which contains an
+enumeration value describing the type of device; this currently
+can be one of 
+%GDK_SOURCE_MOUSE,
+ %GDK_SOURCE_PEN,
+%GDK_SOURCE_ERASER,
+or %GDK_SOURCE_CURSOR. This field is present to allow simple
+applications to (for instance) delete when they detect eraser
+devices without having to keep track of complicated per-device
+settings.
+</para>
+<para>
+Various aspects of each device may be configured. The easiest way of
+creating a GUI to allow the user to conifigure such a device
+is to use to use the #GtkInputDialog widget in GTK+. 
+However, even when using this widget, application writers
+will need to directly query and set the configuration parameters
+in order to save the state between invocations of the application.
+The configuration of devices is queried using gdk_input_list_devices.
+Each device must is activated using gdk_input_set_mode(), which
+also controls whether the device's range is mapped to the
+entire screen or to a single window. The mapping of the valuators of
+the device onto the predefined valuator types is set using
+gdk_input_set_axes. And the source type for each device
+can be set with gdk_input_set_source().
+</para>
+<para>
+Devices may also have associated <firstterm>keys</firstterm>
+or macro buttons. Such keys can be globally set to map
+into normal X keyboard events. The mapping is set using
+gdk_input_set_key().
+</para>
+<para>
+The interfaces in this section will most likely be considerably
+modified in the future to accomodate devices that may have different
+sets of additional valuators than the pressure xtilt and ytilt.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### MACRO GDK_CORE_POINTER ##### -->
+<para>
+This macro contains an integer value representing
+the device ID for the core pointer device.
+</para>
+
+
+
+<!-- ##### FUNCTION gdk_input_list_devices ##### -->
+<para>
+Lists all available input devices, along with their
+configuration information.
+</para>
+
+@Returns: A #GList of #GdkDeviceInfo structures. This list
+          is internal data of GTK+ and should not be modified 
+          or freed.
+
+
+<!-- ##### STRUCT GdkDeviceInfo ##### -->
+<para>
+The #GdkDeviceInfo structure contains information about a 
+device. It has the following fields:
+</para>
+
+@deviceid: a unique integer ID for this device.
+@name: the human-readable name for the device.
+@source: the type of device.
+@mode: a value indicating whether the device is enabled and
+       how the device coordinates map to the screen.
+@has_cursor: if %TRUE, a cursor will be displayed indicating 
+             the current on-screen location to the user. Otherwise,
+             the application is responsible for drawing a cursor 
+             itself.
+@num_axes: the number of axes for this device.
+@axes: a pointer to an array of GdkAxisUse values which
+       give the mapping of axes onto the possible valuators
+       for a GDK device.
+@num_keys: the number of macro buttons.
+@keys: a pointer to an array of #GdkDeviceKey structures  
+       which describe what key press events are generated
+       for each macro button.
+
+<!-- ##### STRUCT GdkDeviceKey ##### -->
+<para>
+The #GdkDeviceKey structure contains information
+about the mapping of one device macro button onto
+a normal X key event. It has the following fields:
+</para>
+
+@keyval: the keyval to generate when the macro button is pressed.
+         If this is 0, no keypress will be generated.
+@modifiers: the modifiers set for the generated key event.
+
+<!-- ##### FUNCTION gdk_input_set_extension_events ##### -->
+<para>
+Turns extension events on or off for a particular window,
+and specifies the event mask for extension events.
+</para>
+
+@window: a #GdkWindow.
+@mask: the event mask
+@mode: the type of extension events that are desired.
+
+
+<!-- ##### ENUM GdkExtensionMode ##### -->
+<para>
+An enumeration used to specify which extension events
+are desired for a particular widget.
+</para>
+
+@GDK_EXTENSION_EVENTS_NONE: no extension events are desired.
+@GDK_EXTENSION_EVENTS_ALL: all extension events are desired.
+@GDK_EXTENSION_EVENTS_CURSOR: extension events are desired only if a cursor
+                              will be displayed for the device.
+
+<!-- ##### FUNCTION gdk_input_set_source ##### -->
+<para>
+Sets the source type for a device.
+</para>
+
+@deviceid: the device to configure
+@source: the new source type.
+
+
+<!-- ##### ENUM GdkInputSource ##### -->
+<para>
+An enumeration describing the type of an input device
+in general terms.
+</para>
+
+@GDK_SOURCE_MOUSE: the device is a mouse. (This will be reported for the core
+                    pointer, even if it is something else, such as a trackball.)
+@GDK_SOURCE_PEN: the device is a stylus of a graphics tablet or similar device.
+@GDK_SOURCE_ERASER: the device is an eraser. Typically, this would be the other end
+                    of a stylus on a graphics tablet.
+@GDK_SOURCE_CURSOR: the device is a graphics tablet "puck" or similar device.
+
+<!-- ##### FUNCTION gdk_input_set_mode ##### -->
+<para>
+Enables or disables a device, and determines how the
+device maps onto the screen.
+</para>
+
+@deviceid: the device to configure.
+@mode: the new mode.
+@Returns: %TRUE if the device supports the given mode, otherwise 
+          %FALSE and the device's mode is unchanged.
+
+
+<!-- ##### ENUM GdkInputMode ##### -->
+<para>
+An enumeration that describes the mode of an input device.
+</para>
+
+@GDK_MODE_DISABLED: the device is disabled and will not report any events.
+@GDK_MODE_SCREEN: the device is enabled. The device's coordinate space
+                    maps to the entire screen.
+@GDK_MODE_WINDOW: the device is enabled. The device's coordinate space
+                    is mapped to a single window. The manner in which this window
+                    is chosen is undefined, but it will typically be the same
+                    way in which the focus window for key events is determined.
+
+<!-- ##### FUNCTION gdk_input_set_axes ##### -->
+<para>
+Sets the mapping of the axes (valuators) of a device
+onto the predefined valuator types that GTK+ understands.
+</para>
+
+@deviceid: the device to configure.
+@axes: an array of GdkAxisUse. This length of this array
+       must match the number of axes for the device.
+
+
+<!-- ##### ENUM GdkAxisUse ##### -->
+<para>
+An enumeration describing the way in which a device
+axis (valuator) maps onto the predefined valuator
+types that GTK+ understands.
+</para>
+
+@GDK_AXIS_IGNORE: the axis is ignored.
+@GDK_AXIS_X: the axis is used as the x axis.
+@GDK_AXIS_Y: the axis is used as the y axis.
+@GDK_AXIS_PRESSURE: the axis is used for pressure information.
+@GDK_AXIS_XTILT: the axis is used for x tilt information.
+@GDK_AXIS_YTILT: the axis is used for x tilt information.
+@GDK_AXIS_LAST: a constant equal to the numerically highest axis value.
+
+<!-- ##### FUNCTION gdk_input_set_key ##### -->
+<para>
+Sets the key event generated when a macro button is pressed.
+</para>
+
+@deviceid: the device to configure.
+@index: the index of the macro button.
+@keyval: the key value for the #GdkKeypressEvent to generate.
+         (a value of 0 means no event will be generated.)
+@modifiers: the modifier field for the generated 
+            #GdkKeyPressEvent.
+
+
+<!-- ##### FUNCTION gdk_input_window_get_pointer ##### -->
+<para>
+Returns information about the current position of the pointer
+within a window, including extended device information.
+Any of the return parameters may be %NULL, in which case,
+they will be ignored.
+</para>
+
+@window: a #GdkWindow.
+@deviceid: a device ID.
+@x: location to store current x postion.
+@y: location to store current y postion.
+@pressure: location to store current pressure.
+@xtilt: location to store current tilt in the x direction.
+@ytilt: location to store current tilt in the y direction.
+@mask: location to store the current modifier state.
+
+
+<!-- ##### FUNCTION gdk_input_motion_events ##### -->
+<para>
+Retrieves the motion history for a given device/window pair.
+</para>
+
+@window: a #GdkWindow.
+@deviceid: the device for which to retrieve motion history.
+@start: the start time.
+@stop: the stop time.
+@nevents_return: location to store the number of events returned.
+@Returns: a newly allocated array containing all the events
+          from @start to @stop. This array should be freed
+          with g_free() when you are finished using it.
+
+
+<!-- ##### STRUCT GdkTimeCoord ##### -->
+<para>
+The #GdkTimeCoord structure stores a single event in a
+motion history. It contains the following fields:
+</para>
+
+@time: The timestamp for this event.
+@x: the x position.
+@y: the y position.
+@pressure: the pressure.
+@xtilt: the tilt in the x direction.
+@ytilt: the tilt in the y direction.
+

docs/reference/gdk/tmpl/input_methods.sgml

@@ -0,0 +1,213 @@
+<!-- ##### SECTION Title ##### -->
+Input Methods
+
+<!-- ##### SECTION Short_Description ##### -->
+support for internationalized text input.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+Input Methods provide a way for complex character sets to be used in GTK+.
+Languages such as Chinese, Japanese, and Korean (often abbreviated to CJK)
+use a large number of ideographs, making it impossible to support all
+characters with a simple keyboard. Instead, text is usually
+<emphasis>pre-edited</emphasis> using a phonetic alphabet and then
+<emphasis>composed</emphasis> to form the ideographs.
+</para>
+<para>
+GTK+ makes use of the input method mechanism provided by the X Windows
+platform. When a GTK+ application is started, it opens a connection to the
+input method appropriate for the current locale (if any). 
+</para>
+<para>
+Widgets which handle textual input, such as #GtkEntry, need to do a number of
+things to support internationalized text input:
+<variablelist>
+<varlistentry>
+<term>When the widget is realized:</term>
+<listitem><para>Check if an input method is being used with gdk_im_ready().
+If it is, create a new <link linkend="gdk-Input-Contexts">Input Context</link>
+using gdk_ic_new(). Find out which events the
+<link linkend="gdk-Input-Contexts">Input Context</link> needs to receive
+with gdk_ic_get_events(), and make sure that the widget's window receives
+these events using gdk_window_set_events().
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term>When the widget's size, state or cursor position changes:</term>
+<listitem><para>
+Update the appropriate
+<link linkend="gdk-Input-Contexts">Input Context</link> attributes
+using gdk_ic_set_attr().
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term>When the keyboard focus enters or leaves the widget:</term>
+<listitem><para>
+Call gdk_im_begin() or gdk_im_end() to start or finish editing the text.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term>When the widget receives a key_press event:</term>
+<listitem><para>
+The <structfield>string</structfield> and <structfield>length</structfield>
+fields of the #GdkEventKey struct should be used to insert the composed text
+into the widget.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term>When the widget is unrealized:</term>
+<listitem><para>
+Destroy the <link linkend="gdk-Input-Contexts">Input Context</link>.
+</para></listitem>
+</varlistentry>
+</variablelist>
+
+</para>
+<para>
+See the XLib reference manual for more detailed information on input methods,
+and the #GtkEntry and #GtkText widgets for some example code.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+<variablelist>
+<varlistentry>
+<term><link linkend="gdk-Input-Contexts">Input Contexts</link></term>
+<listitem><para>
+Used for each widget that handles internationalized text input using the
+global input method.
+</para></listitem>
+</varlistentry>
+</variablelist>
+
+</para>
+
+<!-- ##### ENUM GdkIMStyle ##### -->
+<para>
+A set of bit-flags used to specify the input method styles which are supported
+or which are currently in use. The flags can be divided into 2 groups, the
+pre-edit flags and the status flags.
+</para>
+<para>
+The pre-edit flags specify how pre-editing data is displayed.
+For example, this could display the text being typed in the phonetic
+alphabet before it is composed and inserted as an ideograph.
+</para>
+<para>
+The status flags specify how status information is displayed.
+The status information can be thought of as an extension of the
+standard keyboard mode indicators, such as the Caps Lock indicator.
+</para>
+<note>
+<para>
+The %GDK_IM_PREEDIT_CALLBACKS and %GDK_IM_STATUS_CALLBACKS styles are not 
+currently supported in GTK+.
+</para>
+</note>
+
+@GDK_IM_PREEDIT_AREA: The application provides the input method with an area
+in which to perform <emphasis>off-the-spot</emphasis> pre-editing.
+@GDK_IM_PREEDIT_CALLBACKS: The application registers a number of callback
+functions which are used to display pre-editing data.
+@GDK_IM_PREEDIT_POSITION: The application provides the input method with the
+position of the insertion cursor, for <emphasis>over-the-spot</emphasis>
+pre-editing. The input method creates its own window over the widget to
+display the pre-editing data.
+@GDK_IM_PREEDIT_NOTHING: The input method uses the root X window to perform
+pre-editing, so the application does not need to do anything.
+@GDK_IM_PREEDIT_NONE: No pre-editing is done by the input method, or no
+pre-editing data needs to be displayed.
+@GDK_IM_PREEDIT_MASK: A bit-mask containing all the pre-edit flags.
+@GDK_IM_STATUS_AREA: The application provides the input method with an area
+in which to display status information.
+@GDK_IM_STATUS_CALLBACKS: The applications registers a number of callback
+functions which are used to display status information.
+@GDK_IM_STATUS_NOTHING: The input method uses the root X window to display
+status information, so the application does not need to do anything.
+@GDK_IM_STATUS_NONE: The input method does not display status information.
+@GDK_IM_STATUS_MASK: A bit-mask containing all the status flags.
+
+<!-- ##### FUNCTION gdk_im_ready ##### -->
+<para>
+Checks if an input method is to be used for the current locale.
+If GTK+ has been compiled without support for input methods, or the current
+locale doesn't need an input method, then this will return FALSE.
+</para>
+
+@Returns: TRUE if an input method is available and should be used.
+
+
+<!-- ##### FUNCTION gdk_im_decide_style ##### -->
+<para>
+Decides which input method style should be used, by comparing the styles given
+in @supported_style with those of the available input method.
+</para>
+
+@supported_style: styles which are supported by the widget.
+@Returns: the best style in @supported_style that is also supported by the
+available input method.
+
+
+<!-- ##### FUNCTION gdk_im_set_best_style ##### -->
+<para>
+Sets the best pre-edit and/or status style which should be used.
+This will affect the style chosen in gdk_im_decide_style().
+</para>
+<para>
+The order of the pre-edit styles is (from worst to best):
+%GDK_IM_PREEDIT_NONE, %GDK_IM_PREEDIT_NOTHING, %GDK_IM_PREEDIT_AREA,
+%GDK_IM_PREEDIT_POSITION, %GDK_IM_PREEDIT_CALLBACKS.
+The order of the status styles is:
+%GDK_IM_STATUS_NONE, %GDK_IM_STATUS_NOTHING, %GDK_IM_STATUS_AREA,
+%GDK_IM_STATUS_CALLBACKS.
+</para>
+<para>
+So, for example, to set the best allowed pre-edit style to %GDK_IM_PREEDIT_AREA
+you would do this:
+
+<informalexample>
+<programlisting>
+  gdk_im_set_best_style (GDK_IM_PREEDIT_AREA);
+</programlisting>
+</informalexample>
+
+Or to set the best allowed pre-edit style to %GDK_IM_PREEDIT_POSITION and the
+best allowed status style to %GDK_IM_STATUS_NOTHING you can do this:
+
+<informalexample>
+<programlisting>
+  gdk_im_set_best_style (GDK_IM_PREEDIT_POSITION | GDK_IM_STATUS_NOTHING);
+</programlisting>
+</informalexample>
+</para>
+
+@best_allowed_style: a bit-mask with the best pre-edit style and/or the best
+status style to use. If 0 is used, then the current bit-mask of all allowed
+styles is returned.
+@Returns: a bit-mask of all the styles allowed.
+
+
+<!-- ##### FUNCTION gdk_im_begin ##### -->
+<para>
+Starts editing, using the given input context and #GdkWindow.
+This should be called when the widget receives the input focus, typically in
+the widget's focus_in_event method.
+</para>
+
+@ic: a #GdkIC.
+@window: the #GdkWindow which will be receiving the key press events.
+
+
+<!-- ##### FUNCTION gdk_im_end ##### -->
+<para>
+Stops editing using the input method.
+This should be called when the widget loses the input focus, typically in
+the widget's focus_out_event method.
+</para>
+
+
+

docs/reference/gdk/tmpl/keys.sgml

@@ -0,0 +1,93 @@
+<!-- ##### SECTION Title ##### -->
+Key Values
+
+<!-- ##### SECTION Short_Description ##### -->
+functions for manipulating keyboard codes.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+Key values are the codes which are sent whenever a key is pressed or released.
+They appear in the <structfield>keyval</structfield> field of the
+#GdkEventKey structure, which is passed to signal handlers for the
+"key-press-event" and "key-release-event" signals.
+The complete list of key values can be found in the &lt;gdk/gdkkeysyms.h&gt;
+header file.
+</para>
+<para>
+Key values can be converted into a string representation using
+gdk_keyval_name(). The reverse function, converting a string to a key value,
+is provided by gdk_keyval_from_name().
+</para>
+<para>
+The case of key values can be determined using gdk_keyval_is_upper() and
+gdk_keyval_is_lower(). Key values can be converted to upper or lower case
+using gdk_keyval_to_upper() and gdk_keyval_to_lower().
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### FUNCTION gdk_keyval_name ##### -->
+<para>
+Converts a key value into a symbolic name.
+The names are the same as those in the &lt;gdk/gdkkeysyms.h&gt; header file
+but without the leading "GDK_".
+</para>
+
+@keyval: a key value.
+@Returns: a string containing the name of the key, or NULL if @keyval is not
+a valid key. The string should not be modified.
+
+
+<!-- ##### FUNCTION gdk_keyval_from_name ##### -->
+<para>
+Converts a key name to a key value.
+</para>
+
+@keyval_name: a key name.
+@Returns: the corresponding key value, or %GDK_VoidSymbol if the key name is
+not a valid key.
+
+
+<!-- ##### FUNCTION gdk_keyval_is_upper ##### -->
+<para>
+Returns TRUE if the given key value is in upper case.
+</para>
+
+@keyval: a key value.
+@Returns: TRUE if @keyval is in upper case, or if @keyval is not subject to
+case conversion.
+
+
+<!-- ##### FUNCTION gdk_keyval_is_lower ##### -->
+<para>
+Returns TRUE if the given key value is in lower case.
+</para>
+
+@keyval: a key value.
+@Returns: TRUE if @keyval is in lower case, or if @keyval is not subject to
+case conversion.
+
+
+<!-- ##### FUNCTION gdk_keyval_to_upper ##### -->
+<para>
+Converts a key value to upper case, if applicable.
+</para>
+
+@keyval: a key value.
+@Returns: the upper case form of @keyval, or @keyval itself if it is already
+in upper case or it is not subject to case conversion.
+
+
+<!-- ##### FUNCTION gdk_keyval_to_lower ##### -->
+<para>
+Converts a key value to lower case, if applicable.
+</para>
+
+@keyval: a key value.
+@Returns: the lower case form of @keyval, or @keyval itself if it is already
+in lower case or it is not subject to case conversion.
+
+

docs/reference/gdk/tmpl/pixmaps.sgml

@@ -0,0 +1,196 @@
+<!-- ##### SECTION Title ##### -->
+Bitmaps and Pixmaps
+
+<!-- ##### SECTION Short_Description ##### -->
+Offscreen drawables.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+Pixmaps are offscreen drawables. They can be drawn upon with the
+standard drawing primitives, then copied to another drawable (such as
+a #GdkWindow) with gdk_pixmap_draw(). 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).
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+</para>
+
+<!-- ##### STRUCT GdkPixmap ##### -->
+<para>
+An opaque structure representing an offscreen drawable.
+Pointers to structures of type #GdkPixmap, #GdkBitmap,
+and #GdkWindow, can often be used interchangeably. 
+The type #GdkDrawable refers generically to any of
+these types.
+</para>
+
+@user_data: 
+
+<!-- ##### FUNCTION gdk_pixmap_new ##### -->
+<para>
+Create a new pixmap with a given size and depth.
+</para>
+
+@window: a #GdkWindow, used to determine default values for the
+  new pixmap. Can be %NULL if @depth is specified,
+@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. 
+  If -1, and @window is not %NULL, the depth of the new
+  pixmap will be equal to that of @window.
+@Returns: the #GdkBitmap
+
+
+<!-- ##### FUNCTION gdk_bitmap_create_from_data ##### -->
+<para>
+Creates a new bitmap from data in XBM format.
+</para>
+
+@window: a #GdkWindow, 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>
+
+@window: a #GdkWindow, 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 ##### -->
+<para>
+Create a pixmap from a XPM file.
+</para>
+
+@window: a #GdkWindow, used to determine default values for the
+  new pixmap.
+@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.
+@Returns: the #GdkPixmap
+
+
+<!-- ##### FUNCTION gdk_pixmap_colormap_create_from_xpm ##### -->
+<para>
+Create a pixmap from a XPM file using a particular colormap.
+</para>
+
+@window: a #GdkWindow, 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.
+@Returns: the #GdkPixmap.
+
+
+<!-- ##### FUNCTION gdk_pixmap_create_from_xpm_d ##### -->
+<para>
+Create a pixmap from data in XPM format.
+</para>
+
+@window: a #GdkWindow, used to determine default values for the
+  new pixmap.
+@mask: 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.
+@Returns: the #GdkPixmap
+
+
+<!-- ##### FUNCTION gdk_pixmap_colormap_create_from_xpm_d ##### -->
+<para>
+Create a pixmap from data in XPM format using a particular
+colormap.
+</para>
+
+@window: a #GdkWindow, 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.
+@Returns: the #GdkPixmap.
+
+
+<!-- ##### FUNCTION gdk_pixmap_ref ##### -->
+<para>
+Increase the reference count of a pixmap.
+</para>
+
+@pixmap: a #GdkPixmap
+@Returns: @pixmap
+
+
+<!-- ##### FUNCTION gdk_pixmap_unref ##### -->
+<para>
+Decrease the reference count of a pixmap. If the resulting
+reference count is zero, destroy the pixmap.
+</para>
+
+@pixmap: a #GdkPixmap
+
+
+<!-- ##### STRUCT GdkBitmap ##### -->
+<para>
+An opaque structure representing an offscreen drawable of depth
+1. Pointers to structures of type GdkPixmap, #GdkBitmap, and
+#GdkWindow, can often be used interchangeably.  The type #GdkDrawable
+refers generically to any of these types.
+</para>
+
+@user_data: 
+
+<!-- ##### FUNCTION gdk_bitmap_ref ##### -->
+<para>
+Increase the reference count of a bitmap. An alias
+for gdk_pixmap_ref().
+</para>
+
+@pixmap: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_bitmap_unref ##### -->
+<para>
+Decrease the reference count of a bitmap. An alias
+for gdk_pixmap_unref().
+</para>
+
+@pixmap: 
+
+

docs/reference/gdk/tmpl/properties.sgml

@@ -0,0 +1,225 @@
+<!-- ##### SECTION Title ##### -->
+Properties and Atoms
+
+<!-- ##### SECTION Short_Description ##### -->
+functions to manipulate properties on windows.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+Each window under X can have any number of associated
+<firstterm>properties</firstterm> attached to it.
+Properties are arbitrary chunks of data identified by
+<firstterm>atom</firstterm>s. (An <firstterm>atom</firstterm>
+is a numeric index into a string table on the X server. They are used
+to transfer strings efficiently between clients without
+having to transfer the entire string.) A property
+has an associated type, which is also identified
+using an atom.
+</para>
+<para>
+A property has an associated <firstterm>format</firstterm>,
+an integer describing how many bits are in each unit
+of data inside the property. It must be 8, 16, or 32.
+When data is transfered between the server and client,
+if they are of different endianesses it will be byteswapped
+as necessary according to the format of the property.
+Note that on the client side, properties of format 32
+will be stored with one unit per <emphasis>long</emphasis>,
+even if a long integer has more than 32 bits on the platform.
+(This decision was apparently made for Xlib to maintain
+compatibility with programs that assumed longs were 32
+bits, at the expense of programs that knew better.)
+</para>
+<para>
+The functions in this section are used to add, remove
+and change properties on windows, to convert atoms
+to and from strings and to manipulate some types of
+data commonly stored in X window properties.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### TYPEDEF GdkAtom ##### -->
+<para>
+A numeric type representing a string as an index into a table
+of strings on the X server.
+</para>
+
+
+<!-- ##### MACRO GDK_NONE ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### FUNCTION gdk_text_property_to_text_list ##### -->
+<para>
+Convert a text string from the encoding as it is stored in
+a property into an array of strings in the encoding of
+the current local. (The elements of the array represent
+the null-separated elements of the original text string.)
+</para>
+
+@encoding: an atom representing the encoding. The most common
+           values for this are <literal>STRING</literal>,
+           or <literal>COMPOUND_TEXT</literal>. This is
+           value used as the type for the property.
+@format: the format of the property.
+@text: the text data.
+@length: the length of the property, in item.s
+@list: location to store a terminated array of strings
+       in the encoding of the current locale. This
+       array should be freed using gdk_free_text_list().
+@Returns: the number of strings stored in @list, or 0,
+          if the conversion failed.
+
+
+<!-- ##### FUNCTION gdk_free_text_list ##### -->
+<para>
+Free the array of strings created by
+gdk_text_property_to_text_list().
+</para>
+
+@list: the value stored in the @list parameter by
+       a call to gdk_text_property_to_text_list().
+
+
+<!-- ##### FUNCTION gdk_string_to_compound_text ##### -->
+<para>
+Convert a string from the encoding of the current locale 
+into a form suitable for storing in a window property.
+</para>
+
+@str: a null-terminated string.
+@encoding: location to store the encoding atom (to be used as the type for the property).
+@format: location to store the format for the property.
+@ctext: location to store newly allocated data for the property.
+@length: location to store the length of @ctext in items.
+@Returns: 0 upon sucess, non-zero upon failure.
+
+
+<!-- ##### FUNCTION gdk_free_compound_text ##### -->
+<para>
+Free the data returned from gdk_string_to_compound_text().
+</para>
+
+@ctext: The pointer stored in @ctext from a call to gdk_string_to_compound_text().
+
+
+<!-- ##### FUNCTION gdk_atom_intern ##### -->
+<para>
+Find or create an atom corresponding to a given string.
+</para>
+
+@atom_name: a string.
+@only_if_exists: if %TRUE, do not create a new atom, but
+                 just return the atom if it already exists.
+@Returns: the atom corresponding to @atom_name, or, if
+          @only_if_exists is false, and an atom does not
+          already exists for the string, %GDK_NONE.
+
+
+<!-- ##### FUNCTION gdk_atom_name ##### -->
+<para>
+Determine the string corresponding to an atom.
+</para>
+
+@atom: a #GdkAtom.
+@Returns: a newly allocated string containing the string
+          corresponding to @atom. When you are done
+          with the return value, you should free it 
+          using g_free().
+
+
+<!-- ##### FUNCTION gdk_property_get ##### -->
+<para>
+Retrieves a portion of the contents of a property. If the
+property does not exist, then the function returns FALSE,
+and %GDK_NONE will be stored in @actual_property_type.
+
+Note: the <function>XGetWindowProperty()</function>
+function that gdk_property_get()
+uses has a very confusing and complicated set of semantics.
+Unfortunately, gdk_property_get() makes the situation
+worse instead of better (the semantics should be considered
+undefined), and also prints warnings to stderr in cases where it
+should return a useful error to the program. You are advised to use 
+<function>XGetWindowProperty()</function>
+directly until a replacement function for gdk_property_get()
+is provided. 
+</para>
+
+@window: a #GdkWindow.
+@property: the property to retrieve.
+@type: the desired property type, or 0, if any type of data
+       is acceptable. If this does not match the actual
+       type, then @actual_format and @actual_length will
+       be filled in, a warning will be printed to stderr
+       and no data will be returned.
+@offset: the offset into the property at which to begin
+         retrieving data. (in 4 byte units!)
+@length: the length of the data to delete. (in bytes, but
+         the actual retrieved length will be the next
+         integer multiple multiple of four greater than 
+         this!)
+@pdelete: if %TRUE, delete the property after retrieving the
+          data.
+@actual_property_type: location to store the actual type of 
+                       the property.
+@actual_format: location to store the actual format of the data.
+@actual_length: location to store the length of the retrieved
+                data, in bytes.
+@data: location to store a pointer to the data. The retrieved
+       data should be freed with g_free() when you are finished
+       using it.
+@Returns: %TRUE if data was sucessfully received and stored
+          in @data, otherwise %FALSE.
+
+
+<!-- ##### FUNCTION gdk_property_change ##### -->
+<para>
+Change the contents of a property on a window.
+</para>
+
+@window: a #GdkWindow.
+@property: the property to change.
+@type: the new type for the property. If @mode is
+       %GDK_PROP_MODE_REPLACE or %GDK_PROP_MODE_APPEND, then this 
+       must match the existing type or an error will occur.
+@format: the new format for the property. If @mode is
+         %GDK_PROP_MODE_REPLACE or %GDK_PROP_MODE_APPEND, then this 
+         must match the existing format or an error will occur.
+@mode: a value describing how the new data is to be combined
+       with the current data.
+@data: the data
+       (a <literal>guchar *</literal>
+        <literal>gushort *</literal>, or 
+        <literal>gulong *</literal>, depending on @format), cast to a 
+        <literal>guchar *</literal>.
+@nelements: the number of elements of size determined by the format,
+            contained in @data.
+
+
+<!-- ##### ENUM GdkPropMode ##### -->
+<para>
+Describes how existing data is combined with new data when
+using gdk_property_change().
+</para>
+
+@GDK_PROP_MODE_REPLACE: the new data replaces the existing data.
+@GDK_PROP_MODE_PREPEND: the new data is prepended to the existing data.
+@GDK_PROP_MODE_APPEND: the new data is appended to the existing data.
+
+<!-- ##### FUNCTION gdk_property_delete ##### -->
+<para>
+Delete a property from a window.
+</para>
+
+@window: a #GdkWindow.
+@property: the property to delete.
+
+

docs/reference/gdk/tmpl/regions.sgml

@@ -0,0 +1,259 @@
+<!-- ##### SECTION Title ##### -->
+Points, Rectangles and Regions
+
+<!-- ##### SECTION Short_Description ##### -->
+simple graphical data types.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+GDK provides the #GdkPoint, #GdkRectangle and #GdkRegion data types for
+representing pixels and sets of pixels on the screen.
+</para>
+<para>
+#GdkPoint is a simple structure containing an x and y coordinate of a point.
+</para>
+<para>
+#GdkRectangle is a structure holding the position and size of a rectangle.
+The intersection of two rectangles can be computed with
+gdk_rectangle_intersect(). To find the union of two rectangles use
+gdk_rectangle_union().
+</para>
+<para>
+#GdkRegion is an opaque data type holding a set of arbitrary pixels, and is
+usually used for clipping graphical operations (see gdk_gc_set_clip_region()).
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### STRUCT GdkPoint ##### -->
+<para>
+Defines the x and y coordinates of a point.
+Note that both are defined as #gint16 values, so the coordinates are limited
+to between -32,768 and 32,767.
+</para>
+
+@x: the x coordinate of the point.
+@y: the y coordinate of the point.
+
+<!-- ##### STRUCT GdkRectangle ##### -->
+<para>
+Defines the position and size of a rectangle.
+</para>
+
+@x: the x coordinate of the left edge of the rectangle.
+@y: the y coordinate of the top of the rectangle.
+@width: the width of the rectangle.
+@height: the height of the rectangle.
+
+<!-- ##### FUNCTION gdk_rectangle_intersect ##### -->
+<para>
+Calculates the intersection of two rectangles.
+</para>
+
+@src1: a #GdkRectangle.
+@src2: a #GdkRectangle.
+@dest: the intersection of @src1 and @src2.
+@Returns: TRUE if the rectangles intersect.
+
+
+<!-- ##### FUNCTION gdk_rectangle_union ##### -->
+<para>
+Calculates the union of two rectangles.
+The union of rectangles @src1 and @src2 is the smallest rectangle which
+includes both @src1 and @src2 within it.
+</para>
+
+@src1: a #GdkRectangle.
+@src2: a #GdkRectangle.
+@dest: the union of @src1 and @src2.
+
+
+<!-- ##### STRUCT GdkRegion ##### -->
+<para>
+A GdkRegion represents a set of pixels on the screen.
+The only user-visible field of the structure is the user_data member, which
+can be used to attach arbitrary data to the #GdkRegion.
+</para>
+
+@user_data: arbitrary data attached to the #GdkRegion.
+
+<!-- ##### FUNCTION gdk_region_new ##### -->
+<para>
+Creates a new empty #GdkRegion.
+</para>
+
+@Returns: a new empty #GdkRegion.
+
+
+<!-- ##### FUNCTION gdk_region_polygon ##### -->
+<para>
+Creates a new #GdkRegion using the polygon defined by a number of points.
+
+</para>
+
+@points: an array of #GdkPoint structs.
+@npoints: the number of elements in the @points array.
+@fill_rule: specifies which pixels are included in the region when the polygon
+overlaps itself.
+@Returns: a new #GdkRegion based on the given polygon.
+
+
+<!-- ##### ENUM GdkFillRule ##### -->
+<para>
+The method for determining which pixels are included in a region, when
+creating a #GdkRegion from a polygon.
+The fill rule is only relevant for polygons which overlap themselves.
+</para>
+
+@GDK_EVEN_ODD_RULE: areas which are overlapped an odd number of times are
+included in the region, while areas overlapped an even number of times are not.
+@GDK_WINDING_RULE: overlapping areas are always included.
+
+<!-- ##### FUNCTION gdk_region_destroy ##### -->
+<para>
+Destroys a #GdkRegion.
+</para>
+
+@region: a #GdkRegion.
+
+
+<!-- ##### FUNCTION gdk_regions_intersect ##### -->
+<para>
+Returns the intersection of two regions.
+</para>
+
+@source1: a #GdkRegion.
+@source2: a #GdkRegion.
+@Returns: the intersection of @source1 and @source2.
+
+
+<!-- ##### FUNCTION gdk_regions_union ##### -->
+<para>
+Returns the union of two regions.
+This is all pixels in either of @source1 or @source2.
+</para>
+
+@source1: a #GdkRegion.
+@source2: a #GdkRegion.
+@Returns: the union of @source1 and @source2.
+
+
+<!-- ##### FUNCTION gdk_regions_subtract ##### -->
+<para>
+Subtracts one region from another.
+The result is a region containing all the pixels which are in @source1, but
+which are not in @source2.
+</para>
+
+@source1: a #GdkRegion.
+@source2: a #GdkRegion to subtract from @source1.
+@Returns: @source1 - @source2.
+
+
+<!-- ##### FUNCTION gdk_regions_xor ##### -->
+<para>
+Returns the difference between the union and the intersection of two regions.
+This is a region containing the pixels that are in one of the source regions,
+but which are not in both.
+</para>
+
+@source1: a #GdkRegion.
+@source2: a #GdkRegion.
+@Returns: the difference between the union and the intersection of @source1
+and @source2.
+
+
+<!-- ##### FUNCTION gdk_region_union_with_rect ##### -->
+<para>
+Returns the union of a region and a rectangle.
+</para>
+
+@region: a #GdkRegion.
+@rect: a #GdkRectangle.
+@Returns: the union of @region and @rect.
+
+
+<!-- ##### FUNCTION gdk_region_offset ##### -->
+<para>
+Moves a region the specified distance.
+</para>
+
+@region: a #GdkRegion.
+@dx: the distance to move the region horizontally.
+@dy: the distance to move the region vertically.
+
+
+<!-- ##### FUNCTION gdk_region_shrink ##### -->
+<para>
+Resizes a region by the specified amount.
+Positive values shrink the region. Negative values expand it.
+</para>
+
+@region: a #GdkRegion.
+@dx: the number of pixels to shrink the region horizontally.
+@dy: the number of pixels to shrink the region vertically.
+
+
+<!-- ##### FUNCTION gdk_region_empty ##### -->
+<para>
+Returns TRUE if the #GdkRegion is empty.
+</para>
+
+@region: a #GdkRegion.
+@Returns: TRUE if @region is empty.
+
+
+<!-- ##### FUNCTION gdk_region_equal ##### -->
+<para>
+Returns TRUE if the two regions are the same.
+</para>
+
+@region1: a #GdkRegion.
+@region2: a #GdkRegion.
+@Returns: TRUE if @region1 and @region2 are equal.
+
+
+<!-- ##### FUNCTION gdk_region_point_in ##### -->
+<para>
+Returns TRUE if a point is in a region.
+</para>
+
+@region: a #GdkRegion.
+@x: the x coordinate of a point.
+@y: the y coordinate of a point.
+@Returns: TRUE if the point is in @region.
+
+
+<!-- ##### FUNCTION gdk_region_rect_in ##### -->
+<para>
+Tests whether a rectangle is within a region.
+</para>
+
+@region: a #GdkRegion.
+@rect: a #GdkRectangle.
+@Returns: GDK_OVERLAP_RECTANGLE_IN, GDK_OVERLAP_RECTANGLE_OUT, or
+GDK_OVERLAP_RECTANGLE_PART, depending on whether the rectangle is inside,
+outside, or partly inside the #GdkRegion, respectively.
+
+
+<!-- ##### ENUM GdkOverlapType ##### -->
+<para>
+Specifies the possible values returned by gdk_region_rect_in().
+</para>
+
+@GDK_OVERLAP_RECTANGLE_IN: if the rectangle is inside the #GdkRegion.
+@GDK_OVERLAP_RECTANGLE_OUT: if the rectangle is outside the #GdkRegion.
+@GDK_OVERLAP_RECTANGLE_PART: if the rectangle is partly inside the #GdkRegion.
+
+<!-- ##### FUNCTION gdk_region_get_clipbox ##### -->
+<para>
+Returns the smallest rectangle which includes the entire #GdkRegion.
+</para>
+
+@region: a #GdkRegion.
+@rectangle: returns the smallest rectangle which includes all of @region.
+
+

docs/reference/gdk/tmpl/rgb.sgml

@@ -0,0 +1,458 @@
+<!-- ##### SECTION Title ##### -->
+GdkRGB
+
+<!-- ##### SECTION Short_Description ##### -->
+displays RGB images (as well as grayscale and colormapped) to
+the native window.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+
+GdkRgb converts RGB, grayscale, and colormapped images into the native
+window pixel format and displays them. It takes care of colormaps,
+visuals, dithering, and management of the temporary buffers.
+
+</para>
+
+<para>
+You must call gdk_rgb_init() before using any GdkRgb functionality. If
+you fail to do so, expect coredumps. All Gtk+ widgets that use GdkRgb
+(including #GtkPreview) call gdk_rgb_init() in their class_init method.
+Thus, if you use GdkRgb only indirectly, you don't need to worry
+about it.
+</para>
+
+<para>
+GdkRgb tries to use the system default visual and colormap, but
+doesn't always succeed. Thus, you have to be prepared to install the
+visual and colormap generated by GdkRgb. The following code sequence
+(before any widgets are created) should work in most applications:
+</para>
+
+<informalexample>
+<programlisting>
+  gdk_rgb_init ();
+
+  gtk_widget_set_default_colormap (gdk_rgb_get_cmap ());
+  gtk_widget_set_default_visual (gdk_rgb_get_visual ());
+</programlisting>
+</informalexample>
+
+<para>
+You can also push the colormap and visual, but in general it doesn't
+work unless the push wraps the window creation call. If you wrap the
+push around a widget which is embedded in a window without the GdkRgb
+colormap and visual, it probably won't work, and is likely to cause
+colormap flashing, as well.
+</para>
+
+<para>
+On 8-bit systems, the colormaps used by Imlib and GdkRgb may
+conflict. There is no good general solution to this other than phasing
+out the dependence on Imlib.
+</para>
+
+<para>
+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 gdk_rgb_set_install(TRUE).
+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>
+
+<example>
+<title>A simple example program using GdkRGB.</title>
+<programlisting>
+#include &lt;gtk/gtk.h&gt;
+
+#define IMAGE_WIDTH	256
+#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);
+  gdk_rgb_init ();
+  window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
+  darea = gtk_drawing_area_new ();
+  gtk_drawing_area_size (GTK_DRAWING_AREA (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 < IMAGE_HEIGHT; y++)
+    {
+      for (x = 0; x < 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);
+}
+</programlisting>
+</example>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+<variablelist>
+
+<varlistentry>
+<term>#GdkColor</term>
+<listitem><para>The underlying Gdk mechanism for allocating
+colors.</para></listitem>
+</varlistentry>
+
+</variablelist>
+
+</para>
+
+<!-- ##### FUNCTION gdk_rgb_init ##### -->
+<para>
+Initializes GdkRgb statically. It may be called more than once with no
+ill effects. It must, however, be called before any other GdkRgb
+operations are performed.
+</para>
+
+<para>
+The GdkRgb "context" is allocated statically. Thus, GdkRgb may be used
+to drive only one visual in any given application. GdkRgb
+automatically selects a best visual and sets its own colormap, if
+necessary. gdk_rgb_get_visual() and gdk_rgb_get_cmap () retrieve
+the chosen visual and colormap, respectively.
+</para>
+
+
+
+<!-- ##### 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 other than the
+initialization stuff.
+</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.
+
+
+<!-- ##### ENUM GdkRgbDither ##### -->
+<para>
+
+Selects whether or not GdkRgb applies dithering
+to the image on display. There are three values:
+</para>
+
+<itemizedlist>
+
+<listitem>
+<para>
+%GDK_RGB_DITHER_NONE: Never use dithering.
+</para>
+</listitem>
+
+<listitem>
+<para>
+%GDK_RGB_DITHER_NORMAL: Use dithering in 8 bits per pixel (and below)
+only.
+</para>
+</listitem>
+
+<listitem>
+<para>
+%GDK_RGB_DITHER_MAX: Use dithering in 16 bits per pixel and below.
+</para>
+</listitem>
+
+</itemizedlist>
+
+<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: 
+@GDK_RGB_DITHER_NORMAL: 
+@GDK_RGB_DITHER_MAX: 
+
+<!-- ##### 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: 
+@lut: 
+
+<!-- ##### FUNCTION gdk_rgb_gc_set_foreground ##### -->
+<para>
+Sets the foreground color in @gc to the specified color (or the
+closest approximation, in the case of limited visuals).
+</para>
+
+@gc: The #GdkGC to modify.
+@rgb: The color, represented as a 0xRRGGBB integer value.
+
+
+<!-- ##### FUNCTION gdk_rgb_gc_set_background ##### -->
+<para>
+Sets the background color in @gc to the specified color (or the
+closest approximation, in the case of limited visuals).
+</para>
+
+@gc: The #GdkGC to modify.
+@rgb: The color, represented as a 0xRRGGBB integer value.
+
+
+<!-- ##### FUNCTION gdk_rgb_xpixel_from_rgb ##### -->
+<para>
+Finds the X pixel closest in color to the @rgb color specified. This
+value may be used to set the <structfield>pixel</structfield> field of
+a #GdkColor struct.
+</para>
+
+@rgb: The color, represented as a 0xRRGGBB integer value.
+@Returns: The X pixel value.
+
+
+<!-- ##### 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>
+Gets the visual chosen by GdkRgb. This visual and the corresponding
+colormap should be used when creating windows that will be drawn in by GdkRgb.
+</para>
+
+@Returns: The #GdkVisual chosen by GdkRgb.
+
+
+<!-- ##### FUNCTION gdk_rgb_get_cmap ##### -->
+<para>
+Gets the colormap set by GdkRgb. This colormap and the corresponding
+visual should be used when creating windows that will be drawn in by GdkRgb.
+</para>
+
+@Returns: The #GdkColormap set by GdkRgb.
+
+
+<!-- ##### FUNCTION gdk_rgb_ditherable ##### -->
+<para>
+Determine whether the 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>
+
+@Returns: TRUE if the visual 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/selections.sgml

@@ -0,0 +1,185 @@
+<!-- ##### SECTION Title ##### -->
+Selections
+
+<!-- ##### SECTION Short_Description ##### -->
+functions for transfering data via the X selection mechanism.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+The X selection mechanism provides a way to transfer
+arbitrary chunks of data between programs. 
+A <firstterm>selection</firstterm> is a essentially 
+a named clipboard, identified by a string interned
+as a #GdkAtom. By claiming ownership of a selection,
+an application indicates that it will be responsible
+for supplying its contents. The most common 
+selections are <literal>PRIMARY</literal> and 
+<literal>CLIPBOARD</literal>.
+</para>
+<para>
+The contents of a selection can be represented in
+a number of formats, called <firstterm>targets</firstterm>.
+Each target is identified by an atom. A list of
+all possible targets supported by the selection owner
+can be retrieved by requesting the special target
+<literal>TARGETS</literal>. When a selection is 
+retrieved, the data is accompanied by a type
+(an atom), and a format (an integer, representing
+the number of bits per item).
+See <link linkend="gdk-Properties-and-Atoms">Properties and Atoms</link>
+for more information.
+</para>
+<para>
+The functions in this section only contain the lowlevel
+parts of the selection protocol. A considerably more
+complicated implementation is needed on top of this.
+GTK+ contains such an implementation in the functions
+in <literal>gtkselection.h</literal> and programmers
+should use those functions instead of the ones presented 
+here. If you plan to implement selection handling
+directly on top of the functions here, you should refer
+to the X Inter-client Communication Conventions Manual
+(ICCCM).
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### ENUM GdkSelection ##### -->
+<para>
+The #GdkSelection enumeration contains predefined 
+atom values for several common selections.
+</para>
+
+@GDK_SELECTION_PRIMARY: The primary X selection. Programs
+typically claim this selection when the user
+selects text and paste its contents in response
+to a middle button press.
+@GDK_SELECTION_SECONDARY: An additional X selection.
+
+<!-- ##### ENUM GdkSelectionType ##### -->
+<para>
+The #GdkSelectionType enumeration contains predefined
+atom values used to represent the types of data transferred
+in response to a request for a target. See the
+ICCCM for details about what data should be transferred
+for each of these types. Other atoms can be used,
+and the recommended practice for GTK+ is to to use mime 
+types for this purpose. However, supporting these types
+may be useful for compatibility with older programs.
+</para>
+
+@GDK_SELECTION_TYPE_ATOM: An atom. (format 32)
+@GDK_SELECTION_TYPE_BITMAP: A bitmap ID. (format 32)
+@GDK_SELECTION_TYPE_COLORMAP: A colormap ID. (format 32)
+@GDK_SELECTION_TYPE_DRAWABLE: A drawable ID. (format 32)
+@GDK_SELECTION_TYPE_INTEGER: An integer. (format 32)
+@GDK_SELECTION_TYPE_PIXMAP: A pixmap ID. (format 32)
+@GDK_SELECTION_TYPE_WINDOW: A window ID. (format 32)
+@GDK_SELECTION_TYPE_STRING: A string encoded
+    in ISO Latin-1. (With the additional of <symbol>TAB</symbol>
+     and <symbol>NEWLINE</symbol>.) (format 8)
+
+<!-- ##### ENUM GdkTarget ##### -->
+<para>
+The #GdkTarget enumeration contains predefined atom values which are
+used to describe possible targets for a selection. Other atoms can be
+used, and the recommended practice for GTK+ is to to use mime types
+for this purpose. However, supporting these types may be useful for
+compatibility with older programs.
+</para>
+
+@GDK_TARGET_BITMAP: A bitmap ID.
+@GDK_TARGET_COLORMAP: A colormap ID.
+@GDK_TARGET_DRAWABLE: A drawable ID.
+@GDK_TARGET_PIXMAP: A pixmap ID.
+@GDK_TARGET_STRING: A string encoded in ISO Latin-1. 
+     (With the additional of <symbol>TAB</symbol>
+       and <symbol>NEWLINE</symbol>.)
+
+<!-- ##### FUNCTION gdk_selection_owner_set ##### -->
+<para>
+Set the owner of the given selection.
+</para>
+
+@owner: a #GdkWindow or NULL to indicate that the
+        the owner for the given should be unset.
+@selection: an atom identifying a selection.
+@time: timestamp to use when setting the selection.
+       If this is older than the timestamp given last
+       time the owner was set for the given selection, the 
+       request will be ignored.
+@send_event: if %TRUE, and the new owner is different
+             from the current owner, the current owner
+             will be sent a SelectionClear event.
+@Returns: %TRUE if the selection owner was succesfully
+          changed to @owner, otherwise %FALSE.
+
+
+<!-- ##### FUNCTION gdk_selection_owner_get ##### -->
+<para>
+Determine the owner of the given selection.
+</para>
+
+@selection: an atom indentifying a selection.
+@Returns: if there is a selection owner for this window,
+          and it is a window known to the current process,
+          the #GdkWindow that owns the selection, otherwise
+          NULL. Note that the return value may be owned
+          by a different process if a foreign window
+          was previously created for that window, but
+          a new foreign window will never be created by
+          this call.
+
+
+<!-- ##### FUNCTION gdk_selection_convert ##### -->
+<para>
+Retrieve the contents of a selection in a given
+form.
+</para>
+
+@requestor: a #GdkWindow.
+@selection: an atom identifying the selection to get the
+            contents of.
+@target: the form in which to retrieve the selection.
+@time: the timestamp to use when retrieving the
+       selection. The selection owner may refuse the
+       request if it did not own the selection at 
+       the time indicated by the timestamp.
+
+
+<!-- ##### FUNCTION gdk_selection_property_get ##### -->
+<para>
+Retrieve selection data that was stored by the selection
+data in response to a call to gdk_selection_convert()
+</para>
+
+@requestor: the window on which the data is stored
+@data: location to store a pointer to the retrieved data.
+       If the retrieval failed, NULL we be stored here, otherwise, it
+       will be non-NULL and the returned data should be freed with g_free()
+       when you are finished using it. The length of the
+       allocated memory is one more than the the length
+       of the returned data, and the final byte will always
+       be zero, to ensure null-termination of strings.
+@prop_type: location to store the type of the property.
+@prop_format: location to store the format of the property.
+@Returns: the length of the retrieved data.
+
+
+<!-- ##### FUNCTION gdk_selection_send_notify ##### -->
+<para>
+Send a response to SelectionRequest event.
+</para>
+
+@requestor: window to which to deliver response.
+@selection: selection that was requested.
+@target: target that was selected.
+@property: property in which the selection owner stored the
+           data, or %GDK_NONE to indicate that the request
+           was rejected.
+@time: timestamp.
+
+

docs/reference/gdk/tmpl/threads.sgml

@@ -0,0 +1,50 @@
+<!-- ##### SECTION Title ##### -->
+Threads
+
+<!-- ##### SECTION Short_Description ##### -->
+
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### VARIABLE gdk_threads_mutex ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### MACRO GDK_THREADS_ENTER ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### MACRO GDK_THREADS_LEAVE ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### FUNCTION gdk_threads_enter ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### FUNCTION gdk_threads_leave ##### -->
+<para>
+
+</para>
+
+
+

docs/reference/gdk/tmpl/visuals.sgml

@@ -0,0 +1,391 @@
+<!-- ##### SECTION Title ##### -->
+Visuals
+
+<!-- ##### SECTION Short_Description ##### -->
+manipulation of visuals.
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+The way that the data stored on the screen is stored
+in memory can vary considerably between different X
+servers; some X servers even support multiple formats
+used simultaneously. An X <firstterm>visual</firstterm>
+represents a particular format for screen data.
+It includes information about the number of bits
+used for each color, the way the bits are translated
+into an RGB value for display, and the way the bits
+are stored in memory.
+</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
+suited to displaying full-color image data. If you
+use the calls in GdkRGB, you should create your windows
+using this visual (and the colormap returned by
+gdk_rgb_get_colormap()).
+</para>
+<para>
+A number of functions are provided for determining
+the "best" available visual. For the purposes of
+making this determination, higher bit depths are
+considered better, and for visuals of the same
+bit depth, %GDK_VISUAL_PSEUDO_COLOR is preferred at
+8bpp, otherwise, the visual types are ranked in the
+order of (highest to lowest) %GDK_VISUAL_DIRECT_COLOR,
+%GDK_VISUAL_TRUE_COLOR, %GDK_VISUAL_PSEUDO_COLOR,
+%GDK_VISUAL_STATIC_COLOR, %GDK_VISUAL_GRAYSCALE, 
+then %GDK_VISUAL_STATIC_GRAY.
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### STRUCT GdkVisual ##### -->
+<para>
+The GdkVisual structure contains information about
+a particular visual. It contains the following
+public fields.
+
+<informaltable pgwide=1 frame="none" role="struct">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry><structfield>type</structfield></entry>
+<entry>The type of this visual.</entry>
+</row>
+
+<row>
+<entry><structfield>depth</structfield></entry>
+<entry>The number of bits per pixel.</entry>
+</row>
+
+<row>
+<entry><structfield>byte_order</structfield></entry>
+<entry>The byte-order for this visual.</entry>
+</row>
+
+<row>
+<entry><structfield>colormap_size</structfield></entry>
+<entry>The number of entries in the colormap, for
+visuals of type GDK_VISUAL_PSEUDO_COLOR or 
+GDK_VISUAL_GRAY_SCALE. For other visual types, it
+is the number of possible levels per color component.
+If the visual has different numbers of levels for
+different components, the value of this field is
+undefined.</entry>
+</row>
+
+<row>
+<entry><structfield>bits_per_rgb</structfield></entry>
+<entry>
+The number of significant bits per red, green, or blue
+when specifying colors for this visual. (For instance, 
+for gdk_colormap_alloc_color())
+</entry>
+</row>
+
+<row>
+<entry><structfield>red_mask</structfield></entry>
+<entry>
+A mask giving the bits in a pixel value that
+correspond to the red field. Significant only for 
+%GDK_VISUAL_PSEUDOCOLOR and %GDK_VISUAL_DIRECTCOLOR.
+</entry>
+</row>
+
+<row>
+<entry><structfield>red_shift, red_prec</structfield></entry>
+<entry>
+The <structfield>red_shift</structfield> and 
+<structfield>red_prec</structfield> give an alternate presentation
+of the information in <structfield>red_mask</structfield>.
+<structfield>red_mask</structfield> is a contiguous sequence
+of <structfield>red_prec</structfield> starting at bit
+number <structfield>red_shift</structfield>. For example,
+<xref linkend="rgbmask"> shows constructing a pixel value
+out of three 16 bit color values.
+
+</entry>
+</row>
+
+<row>
+<entry><structfield>green_mask</structfield></entry>
+<entry>
+A mask giving the bits in a pixel value that
+correspond to the green field.
+</entry>
+</row>
+
+<row>
+<entry><structfield>green_shift, green_prec</structfield></entry>
+<entry>
+The <structfield>green_shift</structfield> and 
+<structfield>green_prec</structfield> give an alternate presentation
+of the information in <structfield>green_mask</structfield>.
+</entry>
+</row>
+
+<row>
+<entry><structfield>blue_mask</structfield></entry>
+<entry>
+A mask giving the bits in a pixel value that
+correspond to the blue field.
+</entry>
+</row>
+
+<row>
+<entry><structfield>blue_shift, blue_prec</structfield></entry>
+<entry>
+The <structfield>blue_shift</structfield> and 
+<structfield>blue_prec</structfield> give an alternate presentation
+of the information in <structfield>blue_mask</structfield>.
+</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+<figure float="1" id="rgbmask">
+<title>Constructing a pixel value from components</title>
+<programlisting>
+guint 
+pixel_from_rgb (GdkVisual *visual,
+                guchar r, guchar b, guchar g) 
+{
+  return ((r >> (16 - visual->red_prec))   << visual->red_shift) |
+         ((g >> (16 - visual->green_prec)) << visual->green_shift) |
+         ((r >> (16 - visual->blue_prec))  << visual->blue_shift);
+}
+</programlisting>
+</figure>
+
+@type: 
+@depth: 
+@byte_order: 
+@colormap_size: 
+@bits_per_rgb: 
+@red_mask: 
+@red_shift: 
+@red_prec: 
+@green_mask: 
+@green_shift: 
+@green_prec: 
+@blue_mask: 
+@blue_shift: 
+@blue_prec: 
+
+<!-- ##### ENUM GdkVisualType ##### -->
+<para>
+A set of values that describe the manner in which the
+pixel values for a visual are converted into RGB
+values for display.
+
+<informaltable pgwide=1 frame="none" role="enum">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry>GDK_VISUAL_STATIC_GRAY</entry>
+<entry>Each pixel value indexes a grayscale value directly.</entry>
+</row>
+
+<row>
+<entry>GDK_VISUAL_GRAYSCALE</entry>
+<entry>Each pixel is an index into a color map that maps
+pixel values into grayscale values. The color map can
+be changed by an application.</entry>
+</row>
+
+<row>
+<entry>GDK_VISUAL_STATIC_COLOR</entry>
+<entry>Each pixel value is an index into a predefined,
+unmodifiable color map that maps pixel values into
+rgb values.</entry>
+</row>
+
+<row>
+<entry>GDK_VISUAL_PSEUDO_COLOR</entry>
+<entry>Each pixel is an index into a color map that maps
+pixel values into rgb values. The color map can
+be changed by an application.</entry>
+</row>
+
+<row>
+<entry>GDK_TRUE_COLOR</entry>
+<entry>Each pixel value directly contains red, green,
+and blue components. The <structfield>red_mask</structfield>,
+<structfield>green_mask</structfield>, and 
+<structfield>blue_mask</structfield> fields of the #GdkVisual
+structure describe how the components are assembled into
+a pixel value.
+.</entry>
+</row>
+
+<row>
+<entry>GDK_DIRECT_COLOR</entry>
+<entry>Each pixel value contains red, green, and blue
+components as for %GDK_TRUE_COLOR, but the components
+are mapped via a color table into the final output
+table instead of being converted directly..</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+@GDK_VISUAL_STATIC_GRAY: 
+@GDK_VISUAL_GRAYSCALE: 
+@GDK_VISUAL_STATIC_COLOR: 
+@GDK_VISUAL_PSEUDO_COLOR: 
+@GDK_VISUAL_TRUE_COLOR: 
+@GDK_VISUAL_DIRECT_COLOR: 
+
+<!-- ##### ENUM GdkByteOrder ##### -->
+<para>
+A set of values describing the possible byte-orders
+for storing pixel values in memory.
+
+<informaltable pgwide=1 frame="none" role="enum">
+<tgroup cols="2"><colspec colwidth="2*"><colspec colwidth="8*">
+<tbody>
+
+<row>
+<entry>GDK_LSB_FIRST</entry>
+<entry>The values are stored with the least-significant byte
+first. For instance, the 32-bit value 0xffeecc would be stored
+in memory as 0xcc, 0xee, 0xff, 0x00.</entry>
+</row>
+
+<row>
+<entry>GDK_MSB_FIRST</entry>
+<entry>The values are stored with the least-significant byte
+first. For instance, the 32-bit value 0xffeecc would be stored
+in memory as 0xff, 0xee, 0xcc, 0x00.</entry>
+</row>
+
+</tbody></tgroup></informaltable>
+</para>
+
+@GDK_LSB_FIRST: 
+@GDK_MSB_FIRST: 
+
+<!-- ##### FUNCTION gdk_query_depths ##### -->
+<para>
+Lists the available color depths. The returned values
+are pointers to static storage and should not be
+modified or freed.
+</para>
+
+@depths: a location to store a pointer to an array
+   holding the available color depths.
+@count: a location to store the number of values in @depths.
+
+
+<!-- ##### FUNCTION gdk_query_visual_types ##### -->
+<para>
+Lists the available visual types. The returned values
+are pointers to static storage and should not be
+modified or freed.
+</para>
+
+@visual_types: a location to store a pointer to an 
+   array holding the available visual types.
+@count: a location to store the number of values in @visual types.
+
+
+<!-- ##### FUNCTION gdk_list_visuals ##### -->
+<para>
+Lists the available visuals.
+</para>
+
+@Returns: A #GList of the available visuals. The list
+should be freed this list with g_list_free().
+
+
+<!-- ##### FUNCTION gdk_visual_get_best_depth ##### -->
+<para>
+Returns the best available color depth.
+</para>
+
+@Returns: the best available color depth.
+
+
+<!-- ##### FUNCTION gdk_visual_get_best_type ##### -->
+<para>
+Returns the best available visual type.
+</para>
+
+@Returns: the best available visual type.
+
+
+<!-- ##### FUNCTION gdk_visual_get_system ##### -->
+<para>
+Returns the system's default visual.
+</para>
+
+@Returns: the system's default visual.
+
+
+<!-- ##### FUNCTION gdk_visual_get_best ##### -->
+<para>
+Returns the best available visual.
+</para>
+
+@Returns: the best available visual.
+
+
+<!-- ##### FUNCTION gdk_visual_get_best_with_depth ##### -->
+<para>
+Returns the best available visual with a certain depth.
+</para>
+
+@depth: the desired color depth
+@Returns: the best available visual with @depth bits per pixel
+or %NULL if no visuals with that type are available.
+
+
+<!-- ##### FUNCTION gdk_visual_get_best_with_type ##### -->
+<para>
+Returns the best available visual of a certain visual type.
+</para>
+
+@visual_type: the desired visual type.
+@Returns: the visual of the given type with the highest depth
+or %NULL if no visuals of that type are available.
+
+
+<!-- ##### FUNCTION gdk_visual_get_best_with_both ##### -->
+<para>
+Returns the best available visual 
+</para>
+
+@depth: the desired visual type.
+@visual_type: the desired depth.
+@Returns: the best available visual with the given depth
+and visual type, or %NULL if no matching visuals are
+available.
+
+
+<!-- ##### FUNCTION gdk_visual_ref ##### -->
+<para>
+In theory, increases the reference count of a visual. However,
+the set of visuals is determined statically when GTK+ is
+initialized, so this operation does nothing.
+</para>
+
+@visual: a #GdkVisual.
+@Returns: @visual.
+
+
+<!-- ##### FUNCTION gdk_visual_unref ##### -->
+<para>
+In theory, decreases the reference count of a visual. Like
+gdk_visual_ref(), this operation does nothing.
+</para>
+
+@visual: a #GdkVisual.
+
+

docs/reference/gdk/tmpl/windows.sgml

@@ -0,0 +1,783 @@
+<!-- ##### SECTION Title ##### -->
+Windows
+
+<!-- ##### SECTION Short_Description ##### -->
+
+
+<!-- ##### SECTION Long_Description ##### -->
+<para>
+
+</para>
+
+<!-- ##### SECTION See_Also ##### -->
+<para>
+
+</para>
+
+<!-- ##### STRUCT GdkWindowAttr ##### -->
+<para>
+
+</para>
+
+@title: 
+@event_mask: 
+@x: 
+@y: 
+@width: 
+@height: 
+@wclass: 
+@visual: 
+@colormap: 
+@window_type: 
+@cursor: 
+@wmclass_name: 
+@wmclass_class: 
+@override_redirect: 
+
+<!-- ##### STRUCT GdkWindow ##### -->
+<para>
+
+</para>
+
+@user_data: 
+
+<!-- ##### ENUM GdkWindowType ##### -->
+<para>
+
+</para>
+
+@GDK_WINDOW_ROOT: 
+@GDK_WINDOW_TOPLEVEL: 
+@GDK_WINDOW_CHILD: 
+@GDK_WINDOW_DIALOG: 
+@GDK_WINDOW_TEMP: 
+@GDK_WINDOW_PIXMAP: 
+@GDK_WINDOW_FOREIGN: 
+
+<!-- ##### ENUM GdkWindowClass ##### -->
+<para>
+
+</para>
+
+@GDK_INPUT_OUTPUT: 
+@GDK_INPUT_ONLY: 
+
+<!-- ##### ENUM GdkWindowAttributesType ##### -->
+<para>
+
+</para>
+
+@GDK_WA_TITLE: 
+@GDK_WA_X: 
+@GDK_WA_Y: 
+@GDK_WA_CURSOR: 
+@GDK_WA_COLORMAP: 
+@GDK_WA_VISUAL: 
+@GDK_WA_WMCLASS: 
+@GDK_WA_NOREDIR: 
+
+<!-- ##### ENUM GdkWindowHints ##### -->
+<para>
+
+</para>
+
+@GDK_HINT_POS: 
+@GDK_HINT_MIN_SIZE: 
+@GDK_HINT_MAX_SIZE: 
+@GDK_HINT_BASE_SIZE: 
+@GDK_HINT_ASPECT: 
+@GDK_HINT_RESIZE_INC: 
+
+<!-- ##### STRUCT GdkGeometry ##### -->
+<para>
+
+</para>
+
+@min_width: 
+@min_height: 
+@max_width: 
+@max_height: 
+@base_width: 
+@base_height: 
+@width_inc: 
+@height_inc: 
+@min_aspect: 
+@max_aspect: 
+
+<!-- ##### FUNCTION gdk_window_new ##### -->
+<para>
+
+</para>
+
+@parent: 
+@attributes: 
+@attributes_mask: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_destroy ##### -->
+<para>
+
+</para>
+
+@window: 
+
+
+<!-- ##### FUNCTION gdk_window_ref ##### -->
+<para>
+
+</para>
+
+@window: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_unref ##### -->
+<para>
+
+</para>
+
+@window: 
+
+
+<!-- ##### FUNCTION gdk_window_at_pointer ##### -->
+<para>
+
+</para>
+
+@win_x: 
+@win_y: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_show ##### -->
+<para>
+
+</para>
+
+@window: 
+
+
+<!-- ##### FUNCTION gdk_window_hide ##### -->
+<para>
+
+</para>
+
+@window: 
+
+
+<!-- ##### FUNCTION gdk_window_is_visible ##### -->
+<para>
+
+</para>
+
+@window: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_is_viewable ##### -->
+<para>
+
+</para>
+
+@window: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_withdraw ##### -->
+<para>
+
+</para>
+
+@window: 
+
+
+<!-- ##### FUNCTION gdk_window_move ##### -->
+<para>
+
+</para>
+
+@window: 
+@x: 
+@y: 
+
+
+<!-- ##### FUNCTION gdk_window_resize ##### -->
+<para>
+
+</para>
+
+@window: 
+@width: 
+@height: 
+
+
+<!-- ##### FUNCTION gdk_window_move_resize ##### -->
+<para>
+
+</para>
+
+@window: 
+@x: 
+@y: 
+@width: 
+@height: 
+
+
+<!-- ##### FUNCTION gdk_window_reparent ##### -->
+<para>
+
+</para>
+
+@window: 
+@new_parent: 
+@x: 
+@y: 
+
+
+<!-- ##### FUNCTION gdk_window_clear ##### -->
+<para>
+
+</para>
+
+@window: 
+
+
+<!-- ##### FUNCTION gdk_window_clear_area ##### -->
+<para>
+
+</para>
+
+@window: 
+@x: 
+@y: 
+@width: 
+@height: 
+
+
+<!-- ##### FUNCTION gdk_window_clear_area_e ##### -->
+<para>
+
+</para>
+
+@window: 
+@x: 
+@y: 
+@width: 
+@height: 
+
+
+<!-- ##### FUNCTION gdk_window_copy_area ##### -->
+<para>
+
+</para>
+
+@window: 
+@gc: 
+@x: 
+@y: 
+@source_window: 
+@source_x: 
+@source_y: 
+@width: 
+@height: 
+
+
+<!-- ##### FUNCTION gdk_window_raise ##### -->
+<para>
+
+</para>
+
+@window: 
+
+
+<!-- ##### FUNCTION gdk_window_lower ##### -->
+<para>
+
+</para>
+
+@window: 
+
+
+<!-- ##### FUNCTION gdk_window_register_dnd ##### -->
+<para>
+
+</para>
+
+@window: 
+
+
+<!-- ##### FUNCTION gdk_window_set_user_data ##### -->
+<para>
+
+</para>
+
+@window: 
+@user_data: 
+
+
+<!-- ##### FUNCTION gdk_window_set_override_redirect ##### -->
+<para>
+
+</para>
+
+@window: 
+@override_redirect: 
+
+
+<!-- ##### FUNCTION gdk_window_add_filter ##### -->
+<para>
+
+</para>
+
+@window: 
+@function: 
+@data: 
+
+
+<!-- ##### FUNCTION gdk_window_remove_filter ##### -->
+<para>
+
+</para>
+
+@window: 
+@function: 
+@data: 
+
+
+<!-- ##### USER_FUNCTION GdkFilterFunc ##### -->
+<para>
+
+</para>
+
+@xevent: 
+@event: 
+@data: 
+@Returns: 
+
+
+<!-- ##### ENUM GdkFilterReturn ##### -->
+<para>
+
+</para>
+
+@GDK_FILTER_CONTINUE: 
+@GDK_FILTER_TRANSLATE: 
+@GDK_FILTER_REMOVE: 
+
+<!-- ##### TYPEDEF GdkXEvent ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gdk_window_shape_combine_mask ##### -->
+<para>
+
+</para>
+
+@window: 
+@shape_mask: 
+@offset_x: 
+@offset_y: 
+
+
+<!-- ##### FUNCTION gdk_window_set_child_shapes ##### -->
+<para>
+
+</para>
+
+@window: 
+
+
+<!-- ##### FUNCTION gdk_window_merge_child_shapes ##### -->
+<para>
+
+</para>
+
+@window: 
+
+
+<!-- ##### FUNCTION gdk_window_set_static_gravities ##### -->
+<para>
+
+</para>
+
+@window: 
+@use_static: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_set_hints ##### -->
+<para>
+
+</para>
+
+@window: 
+@x: 
+@y: 
+@min_width: 
+@min_height: 
+@max_width: 
+@max_height: 
+@flags: 
+
+
+<!-- ##### FUNCTION gdk_window_set_title ##### -->
+<para>
+
+</para>
+
+@window: 
+@title: 
+
+
+<!-- ##### FUNCTION gdk_window_set_background ##### -->
+<para>
+
+</para>
+
+@window: 
+@color: 
+
+
+<!-- ##### FUNCTION gdk_window_set_back_pixmap ##### -->
+<para>
+
+</para>
+
+@window: 
+@pixmap: 
+@parent_relative: 
+
+
+<!-- ##### MACRO GDK_PARENT_RELATIVE ##### -->
+<para>
+
+</para>
+
+
+
+<!-- ##### FUNCTION gdk_window_set_cursor ##### -->
+<para>
+
+</para>
+
+@window: 
+@cursor: 
+
+
+<!-- ##### FUNCTION gdk_window_set_colormap ##### -->
+<para>
+
+</para>
+
+@window: 
+@colormap: 
+
+
+<!-- ##### FUNCTION gdk_window_get_user_data ##### -->
+<para>
+
+</para>
+
+@window: 
+@data: 
+
+
+<!-- ##### FUNCTION gdk_window_get_geometry ##### -->
+<para>
+
+</para>
+
+@window: 
+@x: 
+@y: 
+@width: 
+@height: 
+@depth: 
+
+
+<!-- ##### FUNCTION gdk_window_set_geometry_hints ##### -->
+<para>
+
+</para>
+
+@window: 
+@geometry: 
+@flags: 
+
+
+<!-- ##### FUNCTION gdk_window_get_position ##### -->
+<para>
+
+</para>
+
+@window: 
+@x: 
+@y: 
+
+
+<!-- ##### FUNCTION gdk_window_get_root_origin ##### -->
+<para>
+
+</para>
+
+@window: 
+@x: 
+@y: 
+
+
+<!-- ##### FUNCTION gdk_window_get_size ##### -->
+<para>
+
+</para>
+
+@window: 
+@width: 
+@height: 
+
+
+<!-- ##### FUNCTION gdk_window_get_visual ##### -->
+<para>
+
+</para>
+
+@window: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_get_colormap ##### -->
+<para>
+
+</para>
+
+@window: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_get_type ##### -->
+<para>
+
+</para>
+
+@window: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_get_origin ##### -->
+<para>
+
+</para>
+
+@window: 
+@x: 
+@y: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_get_deskrelative_origin ##### -->
+<para>
+
+</para>
+
+@window: 
+@x: 
+@y: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_get_pointer ##### -->
+<para>
+
+</para>
+
+@window: 
+@x: 
+@y: 
+@mask: 
+@Returns: 
+
+
+<!-- ##### ENUM GdkModifierType ##### -->
+<para>
+
+</para>
+
+@GDK_SHIFT_MASK: 
+@GDK_LOCK_MASK: 
+@GDK_CONTROL_MASK: 
+@GDK_MOD1_MASK: 
+@GDK_MOD2_MASK: 
+@GDK_MOD3_MASK: 
+@GDK_MOD4_MASK: 
+@GDK_MOD5_MASK: 
+@GDK_BUTTON1_MASK: 
+@GDK_BUTTON2_MASK: 
+@GDK_BUTTON3_MASK: 
+@GDK_BUTTON4_MASK: 
+@GDK_BUTTON5_MASK: 
+@GDK_RELEASE_MASK: 
+@GDK_MODIFIER_MASK: 
+
+<!-- ##### FUNCTION gdk_window_get_parent ##### -->
+<para>
+
+</para>
+
+@window: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_get_toplevel ##### -->
+<para>
+
+</para>
+
+@window: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_get_children ##### -->
+<para>
+
+</para>
+
+@window: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_get_events ##### -->
+<para>
+
+</para>
+
+@window: 
+@Returns: 
+
+
+<!-- ##### FUNCTION gdk_window_set_events ##### -->
+<para>
+
+</para>
+
+@window: 
+@event_mask: 
+
+
+<!-- ##### FUNCTION gdk_window_set_icon ##### -->
+<para>
+
+</para>
+
+@window: 
+@icon_window: 
+@pixmap: 
+@mask: 
+
+
+<!-- ##### FUNCTION gdk_window_set_icon_name ##### -->
+<para>
+
+</para>
+
+@window: 
+@name: 
+
+
+<!-- ##### FUNCTION gdk_window_set_transient_for ##### -->
+<para>
+
+</para>
+
+@window: 
+@leader: 
+
+
+<!-- ##### FUNCTION gdk_window_set_role ##### -->
+<para>
+
+</para>
+
+@window: 
+@role: 
+
+
+<!-- ##### FUNCTION gdk_window_set_group ##### -->
+<para>
+
+</para>
+
+@window: 
+@leader: 
+
+
+<!-- ##### FUNCTION gdk_window_set_decorations ##### -->
+<para>
+
+</para>
+
+@window: 
+@decorations: 
+
+
+<!-- ##### ENUM GdkWMDecoration ##### -->
+<para>
+
+</para>
+
+@GDK_DECOR_ALL: 
+@GDK_DECOR_BORDER: 
+@GDK_DECOR_RESIZEH: 
+@GDK_DECOR_TITLE: 
+@GDK_DECOR_MENU: 
+@GDK_DECOR_MINIMIZE: 
+@GDK_DECOR_MAXIMIZE: 
+
+<!-- ##### FUNCTION gdk_window_set_functions ##### -->
+<para>
+
+</para>
+
+@window: 
+@functions: 
+
+
+<!-- ##### ENUM GdkWMFunction ##### -->
+<para>
+
+</para>
+
+@GDK_FUNC_ALL: 
+@GDK_FUNC_RESIZE: 
+@GDK_FUNC_MOVE: 
+@GDK_FUNC_MINIMIZE: 
+@GDK_FUNC_MAXIMIZE: 
+@GDK_FUNC_CLOSE: 
+
+<!-- ##### FUNCTION gdk_window_get_toplevels ##### -->
+<para>
+
+</para>
+
+@Returns: 
+
+
+<!-- ##### STRUCT GdkDrawable ##### -->
+<para>
+
+</para>
+
+@user_data: 
+
+<!-- ##### FUNCTION gdk_drawable_set_data ##### -->
+<para>
+
+</para>
+
+@drawable: 
+@key: 
+@data: 
+@destroy_func: 
+
+

docs/reference/gtk/.cvsignore

@@ -0,0 +1,6 @@
+Makefile
+Makefile.in
+sgml
+html
+gtk-decl-list.txt
+gtk-unused.txt

docs/reference/gtk/Makefile.am

@@ -0,0 +1,59 @@
+## Process this file with automake to produce Makefile.in
+
+# The name of the module.
+DOC_MODULE=gtk
+
+# The top-level SGML file.
+DOC_MAIN_SGML_FILE=gtk-docs.sgml
+
+# We could alternatively use this for using installed headers.
+INCLUDE_DIR=`gtk-config --prefix`/include/gtk
+
+
+TARGET_DIR=$(HTML_DIR)/$(DOC_MODULE)
+
+CFLAGS=`gtk-config --cflags`
+LDFLAGS=`gtk-config --libs`
+
+scan:
+	CFLAGS=$(CFLAGS) LDFLAGS=$(LDFLAGS) gtkdoc-scanobj --module=$(DOC_MODULE)
+	gtkdoc-scan --module=$(DOC_MODULE) --ignore-headers='gtkintl.h' $(INCLUDE_DIR)/*.h
+
+templates: scan
+	gtkdoc-mktmpl --module=$(DOC_MODULE)
+
+sgml:
+	gtkdoc-mkdb --module=$(DOC_MODULE)
+
+html:
+	if ! test -d html ; then mkdir html ; fi
+	-cd html && gtkdoc-mkhtml $(DOC_MODULE) ../$(DOC_MAIN_SGML_FILE)
+
+clean-local:
+	rm -f *~ *.bak *.hierarchy *.signals *.args *-unused.txt
+
+maintainer-clean-local: clean
+	rm -rf sgml html $(DOC_MODULE)-decl-list.txt $(DOC_MODULE)-decl.txt 
+
+install-data-local:
+	install -d -m 0755 $(TARGET_DIR)
+	install -m 0644 html/*.html $(TARGET_DIR)
+	install -m 0644 html/index.sgml $(TARGET_DIR)
+	gtkdoc-fixxref --module=$(DOC_MODULE) --html-dir=$(HTML_DIR)
+
+EXTRA_DIST = \
+	$(DOC_MAIN_SGML_FILE) \
+	$(DOC_MODULE)-sections.txt \
+	gtk-overrides.txt \
+	gtk-decl.txt \
+	gtk.hierarchy \
+	gtk.signals \
+	gtk.args \
+	gtk.types \
+	objects_grouped.sgml
+
+dist-hook:
+	mkdir $(distdir)/tmpl
+	cp -p tmpl/*.sgml $(distdir)/tmpl
+
+.PHONY : html sgml templates scan

docs/reference/gtk/gtk-docs.sgml

@@ -0,0 +1,293 @@
+<!doctype book PUBLIC "-//Davenport//DTD DocBook V3.0//EN" [
+<!entity hash "#">
+<!entity GtkAccelLabel SYSTEM "sgml/gtkaccellabel.sgml">
+<!entity GtkAdjustment SYSTEM "sgml/gtkadjustment.sgml">
+<!entity GtkAlignment SYSTEM "sgml/gtkalignment.sgml">
+<!entity GtkArrow SYSTEM "sgml/gtkarrow.sgml">
+<!entity GtkAspectFrame SYSTEM "sgml/gtkaspectframe.sgml">
+<!entity GtkButtonBox SYSTEM "sgml/gtkbbox.sgml">
+<!entity GtkBin SYSTEM "sgml/gtkbin.sgml">
+<!entity GtkBox SYSTEM "sgml/gtkbox.sgml">
+<!entity GtkButton SYSTEM "sgml/gtkbutton.sgml">
+<!entity GtkCalendar SYSTEM "sgml/gtkcalendar.sgml">
+<!entity GtkCheckButton SYSTEM "sgml/gtkcheckbutton.sgml">
+<!entity GtkCheckMenuItem SYSTEM "sgml/gtkcheckmenuitem.sgml">
+<!entity GtkCList SYSTEM "sgml/gtkclist.sgml">
+<!entity GtkColorSelection SYSTEM "sgml/gtkcolorsel.sgml">
+<!entity GtkColorSelectionDialog SYSTEM "sgml/gtkcolorseldlg.sgml">
+<!entity GtkCombo SYSTEM "sgml/gtkcombo.sgml">
+<!entity GtkContainer SYSTEM "sgml/gtkcontainer.sgml">
+<!entity GtkCTree SYSTEM "sgml/gtkctree.sgml">
+<!entity GtkCurve SYSTEM "sgml/gtkcurve.sgml">
+<!entity GtkData SYSTEM "sgml/gtkdata.sgml">
+<!entity GtkDialog SYSTEM "sgml/gtkdialog.sgml">
+<!entity GtkDrawingArea SYSTEM "sgml/gtkdrawingarea.sgml">
+<!entity GtkEditable SYSTEM "sgml/gtkeditable.sgml">
+<!entity GtkEntry SYSTEM "sgml/gtkentry.sgml">
+<!entity GtkEventBox SYSTEM "sgml/gtkeventbox.sgml">
+<!entity GtkFileSelection SYSTEM "sgml/gtkfilesel.sgml">
+<!entity GtkFixed SYSTEM "sgml/gtkfixed.sgml">
+<!entity GtkFontSelection SYSTEM "sgml/gtkfontsel.sgml">
+<!entity GtkFontSelectionDialog SYSTEM "sgml/gtkfontseldlg.sgml">
+<!entity GtkFrame SYSTEM "sgml/gtkframe.sgml">
+<!entity GtkGammaCurve SYSTEM "sgml/gtkgamma.sgml">
+<!entity GtkHandleBox SYSTEM "sgml/gtkhandlebox.sgml">
+<!entity GtkHButtonBox SYSTEM "sgml/gtkhbbox.sgml">
+<!entity GtkHBox SYSTEM "sgml/gtkhbox.sgml">
+<!entity GtkHPaned SYSTEM "sgml/gtkhpaned.sgml">
+<!entity GtkHRuler SYSTEM "sgml/gtkhruler.sgml">
+<!entity GtkHScale SYSTEM "sgml/gtkhscale.sgml">
+<!entity GtkHScrollbar SYSTEM "sgml/gtkhscrollbar.sgml">
+<!entity GtkHSeparator SYSTEM "sgml/gtkhseparator.sgml">
+<!entity GtkImage SYSTEM "sgml/gtkimage.sgml">
+<!entity GtkInputDialog SYSTEM "sgml/gtkinputdialog.sgml">
+<!entity GtkInvisible SYSTEM "sgml/gtkinvisible.sgml">
+<!entity GtkItem SYSTEM "sgml/gtkitem.sgml">
+<!entity GtkItemFactory SYSTEM "sgml/gtkitemfactory.sgml">
+<!entity GtkLabel SYSTEM "sgml/gtklabel.sgml">
+<!entity GtkLayout SYSTEM "sgml/gtklayout.sgml">
+<!entity GtkList SYSTEM "sgml/gtklist.sgml">
+<!entity GtkListItem SYSTEM "sgml/gtklistitem.sgml">
+<!entity GtkMenu SYSTEM "sgml/gtkmenu.sgml">
+<!entity GtkMenuBar SYSTEM "sgml/gtkmenubar.sgml">
+<!entity GtkMenuItem SYSTEM "sgml/gtkmenuitem.sgml">
+<!entity GtkMenuShell SYSTEM "sgml/gtkmenushell.sgml">
+<!entity GtkMisc SYSTEM "sgml/gtkmisc.sgml">
+<!entity GtkNotebook SYSTEM "sgml/gtknotebook.sgml">
+<!entity GtkObject SYSTEM "sgml/gtkobject.sgml">
+<!entity GtkOptionMenu SYSTEM "sgml/gtkoptionmenu.sgml">
+<!entity GtkPacker SYSTEM "sgml/gtkpacker.sgml">
+<!entity GtkPaned SYSTEM "sgml/gtkpaned.sgml">
+<!entity GtkPixmap SYSTEM "sgml/gtkpixmap.sgml">
+<!entity GtkPlug SYSTEM "sgml/gtkplug.sgml">
+<!entity GtkPreview SYSTEM "sgml/gtkpreview.sgml">
+<!entity GtkProgress SYSTEM "sgml/gtkprogress.sgml">
+<!entity GtkProgressBar SYSTEM "sgml/gtkprogressbar.sgml">
+<!entity GtkRadioButton SYSTEM "sgml/gtkradiobutton.sgml">
+<!entity GtkRadioMenuItem SYSTEM "sgml/gtkradiomenuitem.sgml">
+<!entity GtkRange SYSTEM "sgml/gtkrange.sgml">
+<!entity GtkRuler SYSTEM "sgml/gtkruler.sgml">
+<!entity GtkScale SYSTEM "sgml/gtkscale.sgml">
+<!entity GtkScrollbar SYSTEM "sgml/gtkscrollbar.sgml">
+<!entity GtkScrolledWindow SYSTEM "sgml/gtkscrolledwindow.sgml">
+<!entity GtkSeparator SYSTEM "sgml/gtkseparator.sgml">
+<!entity GtkSocket SYSTEM "sgml/gtksocket.sgml">
+<!entity GtkSpinButton SYSTEM "sgml/gtkspinbutton.sgml">
+<!entity GtkStatusbar SYSTEM "sgml/gtkstatusbar.sgml">
+<!entity GtkTable SYSTEM "sgml/gtktable.sgml">
+<!entity GtkTearoffMenuItem SYSTEM "sgml/gtktearoffmenuitem.sgml">
+<!entity GtkText SYSTEM "sgml/gtktext.sgml">
+<!entity GtkTipsQuery SYSTEM "sgml/gtktipsquery.sgml">
+<!entity GtkToggleButton SYSTEM "sgml/gtktogglebutton.sgml">
+<!entity GtkToolbar SYSTEM "sgml/gtktoolbar.sgml">
+<!entity GtkTooltips SYSTEM "sgml/gtktooltips.sgml">
+<!entity GtkTree SYSTEM "sgml/gtktree.sgml">
+<!entity GtkTreeItem SYSTEM "sgml/gtktreeitem.sgml">
+<!entity GtkVButtonBox SYSTEM "sgml/gtkvbbox.sgml">
+<!entity GtkVBox SYSTEM "sgml/gtkvbox.sgml">
+<!entity GtkViewport SYSTEM "sgml/gtkviewport.sgml">
+<!entity GtkVPaned SYSTEM "sgml/gtkvpaned.sgml">
+<!entity GtkVRuler SYSTEM "sgml/gtkvruler.sgml">
+<!entity GtkVScale SYSTEM "sgml/gtkvscale.sgml">
+<!entity GtkVScrollbar SYSTEM "sgml/gtkvscrollbar.sgml">
+<!entity GtkVSeparator SYSTEM "sgml/gtkvseparator.sgml">
+<!entity GtkWidget SYSTEM "sgml/gtkwidget.sgml">
+<!entity GtkWindow SYSTEM "sgml/gtkwindow.sgml">
+<!entity gtk-General SYSTEM "sgml/gtkmain.sgml">
+<!entity gtk-Feature-Test-Macros SYSTEM "sgml/gtkfeatures.sgml">
+<!entity gtk-Graphics-Contexts SYSTEM "sgml/gtkgc.sgml">
+<!entity gtk-Styles SYSTEM "sgml/gtkstyle.sgml">
+<!entity gtk-Themes SYSTEM "sgml/gtkthemes.sgml">
+<!entity gtk-Resource-Files SYSTEM "sgml/gtkrc.sgml">
+<!entity gtk-Keyboard-Accelerators SYSTEM "sgml/gtkaccelgroup.sgml">
+<!entity gtk-Selections SYSTEM "sgml/gtkselection.sgml">
+<!entity gtk-Drag-and-Drop SYSTEM "sgml/gtkdnd.sgml">
+<!entity gtk-Signals SYSTEM "sgml/gtksignal.sgml">
+<!entity gtk-Signal-Marshallers SYSTEM "sgml/gtkmarshal.sgml">
+<!entity gtk-Object-Properties SYSTEM "sgml/gtkarg.sgml">
+<!entity gtk-Types SYSTEM "sgml/gtktypeutils.sgml">
+<!entity gtk-Bindings SYSTEM "sgml/gtkbindings.sgml">
+<!entity gtk-Standard-Enumerations SYSTEM "sgml/gtkenums.sgml">
+<!entity gtk-Private-Information SYSTEM "sgml/gtkprivate.sgml">
+
+<!entity index-Object-Tree SYSTEM "sgml/tree_index.sgml">
+
+<!entity index-Objects-Grouped SYSTEM "objects_grouped.sgml">
+]>
+<book id="index">
+  <bookinfo>
+    <title>GTK+ Reference Manual</title>
+  </bookinfo>
+
+  <chapter id="gtk">
+    <title>GTK+ </title>
+    <para>
+GTK+ is a multi-platform open source GUI Toolkit. Everything about
+GTK+ from the object-oriented design to the Free Software LGPL
+licensing allows you to code your project with the most freedom
+possible. You can develop open software, free software, or even
+commercial non-free software without having to spend a dime for
+licenses or royalties.
+    </para>
+    <para>
+GTK+ is a set of libraries to create graphical user interfaces. It
+works on many Unix-like platforms, and a Windows version is in
+development. GTK+ is released under the GNU Library General Public
+License (GNU LGPL), which allows for flexible licensing of client
+applications. GTK+ has a C-based object-oriented architecture that
+allows for maximum flexibility.  Bindings for other languages have
+been written, including C++, Objective-C, Guile/Scheme, Perl, Python,
+TOM, Ada95, Free Pascal, and Eiffel.
+    </para>
+    <para>
+GTK+ consists of the following component libraries:
+<variablelist>
+
+<varlistentry>
+<term>GLib</term>
+<listitem><para>
+Provides many useful data types, macros, type conversions,
+string utilities and a lexical scanner. Includes Win32 support.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term>GDK</term>
+<listitem><para>
+A wrapper for low-level windowing functions.
+</para></listitem>
+</varlistentry>
+
+<varlistentry>
+<term>GTK+</term>
+<listitem><para>
+An advanced widget set.
+</para></listitem>
+</varlistentry>
+</variablelist>
+    </para>
+    &gtk-General;
+    &gtk-Feature-Test-Macros;
+    &gtk-Graphics-Contexts;
+    &gtk-Styles;
+    &gtk-Themes;
+    &gtk-Resource-Files;
+    &gtk-Keyboard-Accelerators;
+    &gtk-Selections;
+    &gtk-Drag-and-Drop;
+    &gtk-Signals;
+    &gtk-Signal-Marshallers;
+    &gtk-Object-Properties;
+    &gtk-Types;
+    &gtk-Bindings;
+    &gtk-Standard-Enumerations;
+    &gtk-Private-Information;
+  </chapter>
+
+  <chapter id="gtkobjects" role="no-toc">
+    <title>GTK+ Widgets and Objects</title>
+    &index-Objects-Grouped;
+
+    &GtkAccelLabel;
+    &GtkAdjustment;
+    &GtkAlignment;
+    &GtkArrow;
+    &GtkAspectFrame;
+    &GtkButtonBox;
+    &GtkBin;
+    &GtkBox;
+    &GtkButton;
+    &GtkCalendar;
+    &GtkCheckButton;
+    &GtkCheckMenuItem;
+    &GtkCList;
+    &GtkColorSelection;
+    &GtkColorSelectionDialog;
+    &GtkCombo;
+    &GtkContainer;
+    &GtkCTree;
+    &GtkCurve;
+    &GtkData;
+    &GtkDialog;
+    &GtkDrawingArea;
+    &GtkEditable;
+    &GtkEntry;
+    &GtkEventBox;
+    &GtkFileSelection;
+    &GtkFixed;
+    &GtkFontSelection;
+    &GtkFontSelectionDialog;
+    &GtkFrame;
+    &GtkGammaCurve;
+    &GtkHandleBox;
+    &GtkHButtonBox;
+    &GtkHBox;
+    &GtkHPaned;
+    &GtkHRuler;
+    &GtkHScale;
+    &GtkHScrollbar;
+    &GtkHSeparator;
+    &GtkImage;
+    &GtkInputDialog;
+    &GtkInvisible;
+    &GtkItem;
+    &GtkItemFactory;
+    &GtkLabel;
+    &GtkLayout;
+    &GtkList;
+    &GtkListItem;
+    &GtkMenu;
+    &GtkMenuBar;
+    &GtkMenuItem;
+    &GtkMenuShell;
+    &GtkMisc;
+    &GtkNotebook;
+    &GtkObject;
+    &GtkOptionMenu;
+    &GtkPacker;
+    &GtkPaned;
+    &GtkPixmap;
+    &GtkPlug;
+    &GtkPreview;
+    &GtkProgress;
+    &GtkProgressBar;
+    &GtkRadioButton;
+    &GtkRadioMenuItem;
+    &GtkRange;
+    &GtkRuler;
+    &GtkScale;
+    &GtkScrollbar;
+    &GtkScrolledWindow;
+    &GtkSeparator;
+    &GtkSocket;
+    &GtkSpinButton;
+    &GtkStatusbar;
+    &GtkTable;
+    &GtkTearoffMenuItem;
+    &GtkText;
+    &GtkTipsQuery;
+    &GtkToggleButton;
+    &GtkToolbar;
+    &GtkTooltips;
+    &GtkTree;
+    &GtkTreeItem;
+    &GtkVButtonBox;
+    &GtkVBox;
+    &GtkViewport;
+    &GtkVPaned;
+    &GtkVRuler;
+    &GtkVScale;
+    &GtkVScrollbar;
+    &GtkVSeparator;
+    &GtkWidget;
+    &GtkWindow;
+  </chapter>
+
+  <chapter id="gtk-index">
+    <title>Index</title>
+    <sect1>
+      <title>Object Hierarchy</title>
+    &index-Object-Tree;
+    </sect1>
+  </chapter>
+</book>

docs/reference/gtk/gtk-overrides.txt

@@ -0,0 +1,19 @@
+# These are manually-edited to override or add declarations to those scanned
+# from the GTK header files.
+
+# These haven't been given parameter names in the header files.
+<USER_FUNCTION>
+<NAME>GtkArgGetFunc</NAME>
+<RETURNS>void</RETURNS>
+GtkObject *object,
+GtkArg *arg,
+guint arg_id
+</USER_FUNCTION>
+
+<USER_FUNCTION>
+<NAME>GtkArgSetFunc</NAME>
+<RETURNS>void</RETURNS>
+GtkObject *object,
+GtkArg *arg,
+guint arg_id
+</USER_FUNCTION>

docs/reference/gtk/gtk.args

@@ -0,0 +1,846 @@
+<ARG>
+<NAME>GtkAccelLabel::accel_widget</NAME>
+<TYPE>GtkWidget</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkAlignment::xalign</NAME>
+<TYPE>gfloat</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkAlignment::yalign</NAME>
+<TYPE>gfloat</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkAlignment::xscale</NAME>
+<TYPE>gfloat</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkAlignment::yscale</NAME>
+<TYPE>gfloat</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkArrow::arrow_type</NAME>
+<TYPE>GtkArrowType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkArrow::shadow_type</NAME>
+<TYPE>GtkShadowType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkBox::spacing</NAME>
+<TYPE>gint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkBox::homogeneous</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkButton::label</NAME>
+<TYPE>GtkString</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkButton::relief</NAME>
+<TYPE>GtkReliefStyle</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCList::n_columns</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rwX</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCList::shadow_type</NAME>
+<TYPE>GtkShadowType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCList::selection_mode</NAME>
+<TYPE>GtkSelectionMode</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCList::row_height</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCList::reorderable</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCList::titles_active</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCList::use_drag_icons</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkContainer::border_width</NAME>
+<TYPE>gulong</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkContainer::resize_mode</NAME>
+<TYPE>GtkResizeMode</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkContainer::child</NAME>
+<TYPE>GtkWidget</TYPE>
+<FLAGS>w</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCTree::n_columns</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rwX</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCTree::tree_column</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rwX</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCTree::indent</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCTree::spacing</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCTree::show_stub</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCTree::line_style</NAME>
+<TYPE>GtkCTreeLineStyle</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkCTree::expander_style</NAME>
+<TYPE>GtkCTreeExpanderStyle</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkEditable::text_position</NAME>
+<TYPE>gint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkEditable::editable</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkEntry::max_length</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkEntry::visibility</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkFrame::label</NAME>
+<TYPE>GtkString</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkFrame::label_xalign</NAME>
+<TYPE>gfloat</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkFrame::label_yalign</NAME>
+<TYPE>gfloat</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkFrame::shadow</NAME>
+<TYPE>GtkShadowType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkHandleBox::shadow</NAME>
+<TYPE>GtkShadowType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkHScale::adjustment</NAME>
+<TYPE>GtkAdjustment</TYPE>
+<FLAGS>rwx</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkHScrollbar::adjustment</NAME>
+<TYPE>GtkAdjustment</TYPE>
+<FLAGS>rwx</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkLabel::label</NAME>
+<TYPE>GtkString</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkLabel::pattern</NAME>
+<TYPE>GtkString</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkLabel::justify</NAME>
+<TYPE>GtkJustification</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkMenuBar::shadow</NAME>
+<TYPE>GtkShadowType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkMisc::xalign</NAME>
+<TYPE>gfloat</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkMisc::yalign</NAME>
+<TYPE>gfloat</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkMisc::xpad</NAME>
+<TYPE>gint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkMisc::ypad</NAME>
+<TYPE>gint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkNotebook::page</NAME>
+<TYPE>gint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkNotebook::tab_pos</NAME>
+<TYPE>GtkPositionType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkNotebook::tab_border</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>w</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkNotebook::tab_hborder</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkNotebook::tab_vborder</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkNotebook::show_tabs</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkNotebook::show_border</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkNotebook::scrollable</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkNotebook::enable_popup</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkObject::user_data</NAME>
+<TYPE>gpointer</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkObject::signal</NAME>
+<TYPE>GtkSignal</TYPE>
+<FLAGS>w</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkObject::signal_after</NAME>
+<TYPE>GtkSignal</TYPE>
+<FLAGS>w</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkObject::object_signal</NAME>
+<TYPE>GtkSignal</TYPE>
+<FLAGS>w</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkObject::object_signal_after</NAME>
+<TYPE>GtkSignal</TYPE>
+<FLAGS>w</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkPacker::spacing</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkPacker::default_border_width</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkPacker::default_pad_x</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkPacker::default_pad_y</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkPacker::default_ipad_x</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkPacker::default_ipad_y</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkProgress::activity_mode</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkProgress::show_text</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkProgress::text_xalign</NAME>
+<TYPE>gfloat</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkProgress::text_yalign</NAME>
+<TYPE>gfloat</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkProgressBar::adjustment</NAME>
+<TYPE>GtkAdjustment</TYPE>
+<FLAGS>rwx</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkProgressBar::orientation</NAME>
+<TYPE>GtkProgressBarOrientation</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkProgressBar::bar_style</NAME>
+<TYPE>GtkProgressBarStyle</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkProgressBar::activity_step</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkProgressBar::activity_blocks</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkProgressBar::discrete_blocks</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkRadioButton::group</NAME>
+<TYPE>GtkRadioButton</TYPE>
+<FLAGS>w</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkRange::update_policy</NAME>
+<TYPE>GtkUpdateType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkScale::digits</NAME>
+<TYPE>gint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkScale::draw_value</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkScale::value_pos</NAME>
+<TYPE>GtkPositionType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkScrolledWindow::hadjustment</NAME>
+<TYPE>GtkAdjustment</TYPE>
+<FLAGS>rwx</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkScrolledWindow::vadjustment</NAME>
+<TYPE>GtkAdjustment</TYPE>
+<FLAGS>rwx</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkScrolledWindow::hscrollbar_policy</NAME>
+<TYPE>GtkPolicyType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkScrolledWindow::vscrollbar_policy</NAME>
+<TYPE>GtkPolicyType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkScrolledWindow::window_placement</NAME>
+<TYPE>GtkCornerType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkSpinButton::adjustment</NAME>
+<TYPE>GtkAdjustment</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkSpinButton::climb_rate</NAME>
+<TYPE>gfloat</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkSpinButton::digits</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkSpinButton::snap_to_ticks</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkSpinButton::numeric</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkSpinButton::wrap</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkSpinButton::update_policy</NAME>
+<TYPE>GtkSpinButtonUpdatePolicy</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkSpinButton::shadow_type</NAME>
+<TYPE>GtkShadowType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkSpinButton::value</NAME>
+<TYPE>gfloat</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkTable::n_rows</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkTable::n_columns</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkTable::row_spacing</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkTable::column_spacing</NAME>
+<TYPE>guint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkTable::homogeneous</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkText::hadjustment</NAME>
+<TYPE>GtkAdjustment</TYPE>
+<FLAGS>rwx</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkText::vadjustment</NAME>
+<TYPE>GtkAdjustment</TYPE>
+<FLAGS>rwx</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkText::line_wrap</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkText::word_wrap</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkTipsQuery::emit_always</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkTipsQuery::caller</NAME>
+<TYPE>GtkWidget</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkTipsQuery::label_inactive</NAME>
+<TYPE>GtkString</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkTipsQuery::label_no_tip</NAME>
+<TYPE>GtkString</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkToggleButton::active</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkToggleButton::draw_indicator</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkViewport::hadjustment</NAME>
+<TYPE>GtkAdjustment</TYPE>
+<FLAGS>rwx</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkViewport::vadjustment</NAME>
+<TYPE>GtkAdjustment</TYPE>
+<FLAGS>rwx</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkViewport::shadow_type</NAME>
+<TYPE>GtkShadowType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkVScale::adjustment</NAME>
+<TYPE>GtkAdjustment</TYPE>
+<FLAGS>rwx</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkVScrollbar::adjustment</NAME>
+<TYPE>GtkAdjustment</TYPE>
+<FLAGS>rwx</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::name</NAME>
+<TYPE>GtkString</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::parent</NAME>
+<TYPE>GtkContainer</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::x</NAME>
+<TYPE>gint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::y</NAME>
+<TYPE>gint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::width</NAME>
+<TYPE>gint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::height</NAME>
+<TYPE>gint</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::visible</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::sensitive</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::app_paintable</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::can_focus</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::has_focus</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::can_default</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::has_default</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::receives_default</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::composite_child</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::style</NAME>
+<TYPE>GtkStyle</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::events</NAME>
+<TYPE>GdkEventMask</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWidget::extension_events</NAME>
+<TYPE>GdkEventMask</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWindow::type</NAME>
+<TYPE>GtkWindowType</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWindow::title</NAME>
+<TYPE>GtkString</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWindow::auto_shrink</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWindow::allow_shrink</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWindow::allow_grow</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWindow::modal</NAME>
+<TYPE>gboolean</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+
+<ARG>
+<NAME>GtkWindow::window_position</NAME>
+<TYPE>GtkWindowPosition</TYPE>
+<FLAGS>rw</FLAGS>
+</ARG>
+

docs/reference/gtk/gtk.hierarchy

@@ -0,0 +1,93 @@
+GtkObject
+  GtkWidget
+    GtkMisc
+      GtkLabel
+        GtkAccelLabel
+        GtkTipsQuery
+      GtkArrow
+      GtkImage
+      GtkPixmap
+    GtkContainer
+      GtkBin
+        GtkAlignment
+        GtkFrame
+          GtkAspectFrame
+        GtkButton
+          GtkToggleButton
+            GtkCheckButton
+              GtkRadioButton
+          GtkOptionMenu
+        GtkItem
+          GtkMenuItem
+            GtkCheckMenuItem
+              GtkRadioMenuItem
+            GtkTearoffMenuItem
+          GtkListItem
+          GtkTreeItem
+        GtkWindow
+          GtkColorSelectionDialog
+          GtkDialog
+            GtkInputDialog
+          GtkFileSelection
+          GtkFontSelectionDialog
+          GtkPlug
+        GtkEventBox
+        GtkHandleBox
+        GtkScrolledWindow
+        GtkViewport
+      GtkBox
+        GtkButtonBox
+          GtkHButtonBox
+          GtkVButtonBox
+        GtkVBox
+          GtkColorSelection
+          GtkGammaCurve
+        GtkHBox
+          GtkCombo
+          GtkStatusbar
+      GtkCList
+        GtkCTree
+      GtkFixed
+      GtkNotebook
+        GtkFontSelection
+      GtkPaned
+        GtkHPaned
+        GtkVPaned
+      GtkLayout
+      GtkList
+      GtkMenuShell
+        GtkMenu
+        GtkMenuBar
+      GtkPacker
+      GtkSocket
+      GtkTable
+      GtkToolbar
+      GtkTree
+    GtkCalendar
+    GtkDrawingArea
+      GtkCurve
+    GtkEditable
+      GtkEntry
+        GtkSpinButton
+      GtkText
+    GtkRuler
+      GtkHRuler
+      GtkVRuler
+    GtkRange
+      GtkScale
+        GtkHScale
+        GtkVScale
+      GtkScrollbar
+        GtkHScrollbar
+        GtkVScrollbar
+    GtkSeparator
+      GtkHSeparator
+      GtkVSeparator
+    GtkInvisible
+    GtkPreview
+    GtkProgress
+      GtkProgressBar
+  GtkData
+    GtkAdjustment
+    GtkTooltips
+  GtkItemFactory

docs/reference/gtk/gtk.types

@@ -0,0 +1,96 @@
+#include <gtk/gtk.h>
+
+gtk_accel_label_get_type
+gtk_adjustment_get_type
+gtk_alignment_get_type
+gtk_arrow_get_type
+gtk_aspect_frame_get_type
+gtk_bin_get_type
+gtk_box_get_type
+gtk_button_get_type
+gtk_button_box_get_type
+gtk_calendar_get_type
+gtk_check_button_get_type
+gtk_check_menu_item_get_type
+gtk_clist_get_type
+gtk_color_selection_get_type
+gtk_color_selection_dialog_get_type
+gtk_combo_get_type
+gtk_container_get_type
+gtk_ctree_get_type
+gtk_curve_get_type
+gtk_data_get_type
+gtk_dialog_get_type
+gtk_drawing_area_get_type
+gtk_editable_get_type
+gtk_entry_get_type
+gtk_event_box_get_type
+gtk_file_selection_get_type
+gtk_fixed_get_type
+gtk_font_selection_get_type
+gtk_font_selection_dialog_get_type
+gtk_frame_get_type
+gtk_gamma_curve_get_type
+gtk_handle_box_get_type
+gtk_hbox_get_type
+gtk_hbutton_box_get_type
+gtk_hpaned_get_type
+gtk_hruler_get_type
+gtk_hscale_get_type
+gtk_hscrollbar_get_type
+gtk_hseparator_get_type
+gtk_identifier_get_type
+gtk_image_get_type
+gtk_input_dialog_get_type
+gtk_invisible_get_type
+gtk_item_get_type
+gtk_item_factory_get_type
+gtk_label_get_type
+gtk_layout_get_type
+gtk_list_get_type
+gtk_list_item_get_type
+gtk_menu_get_type
+gtk_menu_bar_get_type
+gtk_menu_item_get_type
+gtk_menu_shell_get_type
+gtk_misc_get_type
+gtk_notebook_get_type
+gtk_object_get_type
+gtk_option_menu_get_type
+gtk_packer_get_type
+gtk_paned_get_type
+gtk_pixmap_get_type
+gtk_plug_get_type
+gtk_preview_get_type
+gtk_progress_get_type
+gtk_progress_bar_get_type
+gtk_radio_button_get_type
+gtk_radio_menu_item_get_type
+gtk_range_get_type
+gtk_ruler_get_type
+gtk_scale_get_type
+gtk_scrollbar_get_type
+gtk_scrolled_window_get_type
+gtk_separator_get_type
+gtk_socket_get_type
+gtk_spin_button_get_type
+gtk_statusbar_get_type
+gtk_table_get_type
+gtk_tearoff_menu_item_get_type
+gtk_text_get_type
+gtk_tips_query_get_type
+gtk_toggle_button_get_type
+gtk_toolbar_get_type
+gtk_tooltips_get_type
+gtk_tree_get_type
+gtk_tree_item_get_type
+gtk_vbox_get_type
+gtk_vbutton_box_get_type
+gtk_viewport_get_type
+gtk_vpaned_get_type
+gtk_vruler_get_type
+gtk_vscale_get_type
+gtk_vscrollbar_get_type
+gtk_vseparator_get_type
+gtk_widget_get_type
+gtk_window_get_type

docs/reference/gtk/objects_grouped.sgml

@@ -0,0 +1,130 @@
+<informaltable pgwide=1 frame="none">
+<tgroup cols="4">
+<colspec colwidth="1*">
+<colspec colwidth="1*">
+<colspec colwidth="1*">
+<colspec colwidth="1*">
+<tbody><row>
+<entry><literallayout>
+<emphasis>Windows &amp; Dialogs</emphasis>
+    <link linkend="GtkWindow">GtkWindow</link>
+    <link linkend="GtkDialog">GtkDialog</link>
+    <link linkend="GtkColorSelectionDialog">GtkColorSelectionDialog</link>
+    <link linkend="GtkFileSelection">GtkFileSelection</link>
+    <link linkend="GtkFontSelectionDialog">GtkFontSelectionDialog</link>
+    <link linkend="GtkInputDialog">GtkInputDialog</link>
+
+<emphasis>Containers</emphasis>
+    <link linkend="GtkHBox">GtkHBox</link>
+    <link linkend="GtkVBox">GtkVBox</link>
+    <link linkend="GtkTable">GtkTable</link>
+    <link linkend="GtkToolbar">GtkToolbar</link>
+    <link linkend="GtkHandleBox">GtkHandleBox</link>
+    <link linkend="GtkNotebook">GtkNotebook</link>
+    <link linkend="GtkFrame">GtkFrame</link>
+    <link linkend="GtkAspectFrame">GtkAspectFrame</link>
+    <link linkend="GtkFixed">GtkFixed</link>
+    <link linkend="GtkPacker">GtkPacker</link>
+    <link linkend="GtkLayout">GtkLayout</link>
+    <link linkend="GtkScrolledWindow">GtkScrolledWindow</link>
+    <link linkend="GtkViewport">GtkViewport</link>
+    <link linkend="GtkEventBox">GtkEventBox</link>
+    <link linkend="GtkAlignment">GtkAlignment</link>
+    <link linkend="GtkHButtonBox">GtkHButtonBox</link>
+    <link linkend="GtkVButtonBox">GtkVButtonBox</link>
+    <link linkend="GtkHPaned">GtkHPaned</link>
+    <link linkend="GtkVPaned">GtkVPaned</link>
+</literallayout></entry>
+<entry><literallayout>
+<emphasis>Labels &amp; Buttons</emphasis>
+    <link linkend="GtkLabel">GtkLabel</link>
+    <link linkend="GtkAccelLabel">GtkAccelLabel</link>
+    <link linkend="GtkButton">GtkButton</link>
+    <link linkend="GtkCheckButton">GtkCheckButton</link>
+    <link linkend="GtkToggleButton">GtkToggleButton</link>
+    <link linkend="GtkRadioButton">GtkRadioButton</link>
+
+<emphasis>Data Entry Widgets</emphasis>
+    <link linkend="GtkEntry">GtkEntry</link>
+    <link linkend="GtkText">GtkText</link>
+    <link linkend="GtkSpinButton">GtkSpinButton</link>
+    <link linkend="GtkOptionMenu">GtkOptionMenu</link>
+    <link linkend="GtkCombo">GtkCombo</link>
+    <link linkend="GtkHScale">GtkHScale</link>
+    <link linkend="GtkVScale">GtkVScale</link>
+
+<emphasis>Lists &amp; Trees</emphasis>
+    <link linkend="GtkCList">GtkCList</link>
+    <link linkend="GtkCTree">GtkCTree</link>
+    <link linkend="GtkList">GtkList</link>
+    <link linkend="GtkListItem">GtkListItem</link>
+    <link linkend="GtkTree">GtkTree</link>
+    <link linkend="GtkTreeItem">GtkTreeItem</link>
+
+<emphasis>Tooltips</emphasis>
+    <link linkend="GtkTooltips">GtkTooltips</link>
+    <link linkend="GtkTipsQuery">GtkTipsQuery</link>
+</literallayout></entry>
+<entry><literallayout>
+<emphasis>Menus &amp; Menu Bars</emphasis>
+    <link linkend="GtkMenuBar">GtkMenuBar</link>
+    <link linkend="GtkMenu">GtkMenu</link>
+    <link linkend="GtkMenuItem">GtkMenuItem</link>
+    <link linkend="GtkCheckMenuItem">GtkCheckMenuItem</link>
+    <link linkend="GtkRadioMenuItem">GtkRadioMenuItem</link>
+    <link linkend="GtkTearoffMenuItem">GtkTearoffMenuItem</link>
+
+<emphasis>Graphical Widgets</emphasis>
+    <link linkend="GtkDrawingArea">GtkDrawingArea</link>
+    <link linkend="GtkImage">GtkImage</link>
+    <link linkend="GtkPixmap">GtkPixmap</link>
+    <link linkend="GtkPreview">GtkPreview</link>
+    <link linkend="GtkCurve">GtkCurve</link>
+    <link linkend="GtkGammaCurve">GtkGammaCurve</link>
+
+<emphasis>Misc. Widgets</emphasis>
+    <link linkend="GtkArrow">GtkArrow</link>
+    <link linkend="GtkCalendar">GtkCalendar</link>
+    <link linkend="GtkProgressBar">GtkProgressBar</link>
+    <link linkend="GtkStatusbar">GtkStatusbar</link>
+    <link linkend="GtkHRuler">GtkHRuler</link>
+    <link linkend="GtkVRuler">GtkVRuler</link>
+    <link linkend="GtkHScrollbar">GtkHScrollbar</link>
+    <link linkend="GtkVScrollbar">GtkVScrollbar</link>
+    <link linkend="GtkHSeparator">GtkHSeparator</link>
+    <link linkend="GtkVSeparator">GtkVSeparator</link>
+    <link linkend="GtkColorSelection">GtkColorSelection</link>
+    <link linkend="GtkFontSelection">GtkFontSelection</link>
+</literallayout></entry>
+<entry><literallayout>
+<emphasis>Abstract Base Classes</emphasis>
+    <link linkend="GtkWidget">GtkWidget</link>
+    <link linkend="GtkObject">GtkObject</link>
+    <link linkend="GtkContainer">GtkContainer</link>
+    <link linkend="GtkBin">GtkBin</link>
+    <link linkend="GtkBox">GtkBox</link>
+    <link linkend="GtkButtonBox">GtkButtonBox</link>
+    <link linkend="GtkData">GtkData</link>
+    <link linkend="GtkEditable">GtkEditable</link>
+    <link linkend="GtkItem">GtkItem</link>
+    <link linkend="GtkMenuShell">GtkMenuShell</link>
+    <link linkend="GtkMisc">GtkMisc</link>
+    <link linkend="GtkPaned">GtkPaned</link>
+    <link linkend="GtkProgress">GtkProgress</link>
+    <link linkend="GtkRange">GtkRange</link>
+    <link linkend="GtkRuler">GtkRuler</link>
+    <link linkend="GtkScale">GtkScale</link>
+    <link linkend="GtkScrollbar">GtkScrollbar</link>
+    <link linkend="GtkSeparator">GtkSeparator</link>
+
+<emphasis>Integrating with other X Applications</emphasis>
+    <link linkend="GtkPlug">GtkPlug</link>
+    <link linkend="GtkSocket">GtkSocket</link>
+
+<emphasis>Misc. Objects</emphasis>
+    <link linkend="GtkAdjustment">GtkAdjustment</link>
+    <link linkend="GtkItemFactory">GtkItemFactory</link>
+    <link linkend="GtkInvisible">GtkInvisible</link>
+</literallayout></entry>
+</row>
+</tbody></tgroup></informaltable>

docs/reference/gtk/tmpl/gtk-unused.sgml

@@ -0,0 +1,629 @@
+<!-- ##### SECTION ./tmpl/gtkmenufactory.sgml:Title ##### -->
+Menu Factory
+
+
+<!-- ##### FUNCTION gtk_marshal_NONE__INT_POINTER ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### STRUCT GtkMenuFactory ##### -->
+<para>
+
+</para>
+
+@path: 
+@type: 
+@accel_group: 
+@widget: 
+@subfactories: 
+
+<!-- ##### FUNCTION gtk_marshal_BOOL__POINTER_INT_INT ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### MACRO gtk_marshal_NONE__UINT_STRING ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gtk_marshal_NONE__INT_FLOAT ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_marshal_NONE__POINTER_INT_POINTER ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_marshal_INT__POINTER ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_menu_factory_find ##### -->
+<para>
+
+</para>
+
+@factory: 
+@path: 
+@Returns: 
+
+<!-- ##### MACRO gtk_marshal_NONE__ENUM_FLOAT_BOOL ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### MACRO gtk_marshal_NONE__POINTER_STRING_STRING ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gtk_marshal_NONE__INT_POINTER_INT_INT_INT_POINTER ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_marshal_BOOL__POINTER ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### MACRO gtk_marshal_NONE__UINT_POINTER_UINT_ENUM_ENUM_POINTER ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### ENUM GtkMenuFactoryType ##### -->
+<para>
+
+</para>
+
+@GTK_MENU_FACTORY_MENU: 
+@GTK_MENU_FACTORY_MENU_BAR: 
+@GTK_MENU_FACTORY_OPTION_MENU: 
+
+<!-- ##### FUNCTION gtk_marshal_INT__POINTER_CHAR_CHAR ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_marshal_NONE__POINTER_INT_INT_POINTER_INT_INT ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_marshal_NONE__INT_FLOAT_BOOL ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_marshal_NONE__INT ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### MACRO gtk_marshal_NONE__BOXED ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gtk_menu_factory_add_entries ##### -->
+<para>
+
+</para>
+
+@factory: 
+@entries: 
+@nentries: 
+
+<!-- ##### STRUCT GtkMenuPath ##### -->
+<para>
+
+</para>
+
+@path: 
+@widget: 
+
+<!-- ##### FUNCTION gtk_marshal_NONE__POINTER_INT ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### MACRO gtk_marshal_NONE__UINT_POINTER_UINT_UINT_ENUM ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### ARG GtkPreview:expand ##### -->
+<para>
+Determines the way that the the preview widget behaves
+when the size it is allocated is larger than the requested
+size. See gtk_preview_set_expand().
+</para>
+
+
+<!-- ##### MACRO gtk_marshal_NONE__STRING_INT_POINTER ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### MACRO gtk_marshal_NONE__POINTER_INT_INT_POINTER_UINT_UINT ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gtk_marshal_BOOL__POINTER_INT_INT_INT ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_marshal_NONE__POINTER ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### SECTION ./tmpl/gtkmenufactory.sgml:Short_Description ##### -->
+
+
+
+<!-- ##### MACRO gtk_marshal_BOOL__POINTER_STRING_STRING_POINTER ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### MACRO gtk_marshal_NONE__ENUM_FLOAT ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gtk_marshal_NONE__INT_INT ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### MACRO gtk_marshal_NONE__POINTER_POINTER_UINT_UINT ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gtk_menu_factory_remove_paths ##### -->
+<para>
+
+</para>
+
+@factory: 
+@paths: 
+@npaths: 
+
+<!-- ##### FUNCTION gtk_menu_factory_destroy ##### -->
+<para>
+
+</para>
+
+@factory: 
+
+<!-- ##### MACRO gtk_marshal_BOOL__POINTER_INT_INT_UINT ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gtk_marshal_NONE__POINTER_POINTER ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_marshal_INT__INT ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### MACRO gtk_marshal_ENUM__ENUM ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gtk_marshal_NONE__INT_POINTER_INT_INT_INT ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### MACRO GTK_NOTE ##### -->
+<para>
+
+</para>
+
+@type: 
+@action: 
+
+<!-- ##### FUNCTION gtk_marshal_NONE__POINTER_INT_INT ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### MACRO gtk_marshal_NONE__POINTER_UINT ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gtk_marshal_NONE__POINTER_POINTER_POINTER ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### SECTION ./tmpl/gtkmenufactory.sgml:See_Also ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gtk_marshal_NONE__BOOL ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_marshal_NONE__POINTER_POINTER_INT_INT ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_marshal_BOOL__POINTER_POINTER_POINTER_POINTER ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### MACRO gtk_marshal_NONE__OBJECT ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### ENUM GtkDebugFlag ##### -->
+<para>
+
+</para>
+
+@GTK_DEBUG_OBJECTS: 
+@GTK_DEBUG_MISC: 
+@GTK_DEBUG_SIGNALS: 
+@GTK_DEBUG_DND: 
+@GTK_DEBUG_PLUGSOCKET: 
+
+<!-- ##### ARG GtkHandleBox:snap_edge ##### -->
+<para>
+Determines the snap edge of a handlebox. The snap edge is
+the edge of the detached child that must be aligned
+with the corresponding edge of the "ghost" left
+behind when the child was detached to reattach
+the torn-off window. See gtk_handle_box_set_snap_edge().
+</para>
+
+
+<!-- ##### ARG GtkHandleBox:handle_position ##### -->
+<para>
+Determines the side of the handlebox where the handle is drawn.
+</para>
+
+
+<!-- ##### MACRO gtk_marshal_NONE__STRING ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### MACRO gtk_marshal_NONE__UINT ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### MACRO gtk_marshal_NONE__ENUM ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gtk_marshal_NONE__C_CALLBACK_C_CALLBACK ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_menu_factory_new ##### -->
+<para>
+
+</para>
+
+@type: 
+@Returns: 
+
+<!-- ##### SECTION ./tmpl/gtkdebug.sgml:Short_Description ##### -->
+
+
+
+<!-- ##### FUNCTION gtk_marshal_NONE__INT_INT_POINTER ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_marshal_NONE__C_CALLBACK ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_marshal_BOOL__POINTER_POINTER_INT_INT ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_menu_factory_remove_entries ##### -->
+<para>
+
+</para>
+
+@factory: 
+@entries: 
+@nentries: 
+
+<!-- ##### SECTION ./tmpl/gtkdebug.sgml:Long_Description ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### USER_FUNCTION GtkMenuCallback ##### -->
+<para>
+
+</para>
+
+@widget: 
+@user_data: 
+
+<!-- ##### VARIABLE gtk_debug_flags ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gtk_menu_factory_remove_subfactory ##### -->
+<para>
+
+</para>
+
+@factory: 
+@subfactory: 
+@path: 
+
+<!-- ##### SECTION ./tmpl/gtkdebug.sgml:Title ##### -->
+Debugging
+
+
+<!-- ##### FUNCTION gtk_ruler_draw_pos ##### -->
+<para>
+
+</para>
+
+@ruler: the gtkruler
+
+<!-- ##### MACRO gtk_marshal_NONE__POINTER_UINT_UINT ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### SECTION ./tmpl/gtkdebug.sgml:See_Also ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### MACRO gtk_marshal_NONE__POINTER_UINT_ENUM ##### -->
+<para>
+
+</para>
+
+
+<!-- ##### FUNCTION gtk_marshal_NONE__NONE ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_marshal_BOOL__NONE ##### -->
+<para>
+
+</para>
+
+@object: 
+@func: 
+@func_data: 
+@args: 
+
+<!-- ##### FUNCTION gtk_menu_factory_add_subfactory ##### -->
+<para>
+
+</para>
+
+@factory: 
+@subfactory: 
+@path: 
+
+<!-- ##### STRUCT GtkMenuEntry ##### -->
+<para>
+
+</para>
+
+@path: 
+@accelerator: 
+@callback: 
+@callback_data: 
+@widget: 
+
+<!-- ##### FUNCTION gtk_ruler_draw_ticks ##### -->
+<para>
+
+</para>
+
+@ruler: the gtkruler
+
+<!-- ##### SECTION ./tmpl/gtkmenufactory.sgml:Long_Description ##### -->
+<para>
+
+</para>
+
+