Initial revision

9 files changed, 7810 insertions, 0 deletions

diff --git a/eazel-engine/src/Makefile.am b/eazel-engine/src/Makefile.am
new file mode 100644
index 0000000..ce9898c
--- /dev/null
+++ b/eazel-engine/src/Makefile.am
@@ -0,0 +1,17 @@
+
+INCLUDES = $(GTK_CFLAGS) $(GDK_PIXBUF_CFLAGS) -DDATADIR=\"$(datadir)/eazel-engine\"
+
+enginedir = $(libdir)/gtk/themes/engines
+
+engine_LTLIBRARIES = libeazel-engine.la
+
+libeazel_engine_la_SOURCES =	\
+	eazel-theme.h		\
+	eazel-theme-draw.c	\
+	eazel-theme-main.c	\
+	eazel-theme-gradient.c	\
+	eazel-theme-pixmaps.c	\
+	eazel-theme-hacks.c
+
+libeazel_engine_la_LDFLAGS = -module -avoid-version
+libeazel_engine_la_LIBADD = $(GTK_LIBS) $(GDK_PIXBUF_LIBS)
diff --git a/eazel-engine/src/Makefile.in b/eazel-engine/src/Makefile.in
new file mode 100644
index 0000000..28f2b40
--- /dev/null
+++ b/eazel-engine/src/Makefile.in
@@ -0,0 +1,324 @@
+# Makefile.in generated automatically by automake 1.4 from Makefile.am
+
+# Copyright (C) 1994, 1995-8, 1999 Free Software Foundation, Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+
+SHELL = @SHELL@
+
+srcdir = @srcdir@
+top_srcdir = @top_srcdir@
+VPATH = @srcdir@
+prefix = @prefix@
+exec_prefix = @exec_prefix@
+
+bindir = @bindir@
+sbindir = @sbindir@
+libexecdir = @libexecdir@
+datadir = @datadir@
+sysconfdir = @sysconfdir@
+sharedstatedir = @sharedstatedir@
+localstatedir = @localstatedir@
+libdir = @libdir@
+infodir = @infodir@
+mandir = @mandir@
+includedir = @includedir@
+oldincludedir = /usr/include
+
+DESTDIR =
+
+pkgdatadir = $(datadir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+
+top_builddir = ..
+
+ACLOCAL = @ACLOCAL@
+AUTOCONF = @AUTOCONF@
+AUTOMAKE = @AUTOMAKE@
+AUTOHEADER = @AUTOHEADER@
+
+INSTALL = @INSTALL@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@ $(AM_INSTALL_PROGRAM_FLAGS)
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+transform = @program_transform_name@
+
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+host_alias = @host_alias@
+host_triplet = @host@
+AS = @AS@
+CAPPLET_CFLAGS = @CAPPLET_CFLAGS@
+CAPPLET_LIBS = @CAPPLET_LIBS@
+CC = @CC@
+DLLTOOL = @DLLTOOL@
+GDK_PIXBUF_CFLAGS = @GDK_PIXBUF_CFLAGS@
+GDK_PIXBUF_CONFIG = @GDK_PIXBUF_CONFIG@
+GDK_PIXBUF_LIBS = @GDK_PIXBUF_LIBS@
+GNOME_CFLAGS = @GNOME_CFLAGS@
+GNOME_LIBS = @GNOME_LIBS@
+GTK_CFLAGS = @GTK_CFLAGS@
+GTK_CONFIG = @GTK_CONFIG@
+GTK_LIBS = @GTK_LIBS@
+LIBTOOL = @LIBTOOL@
+LN_S = @LN_S@
+MAINT = @MAINT@
+MAKEINFO = @MAKEINFO@
+OBJDUMP = @OBJDUMP@
+PACKAGE = @PACKAGE@
+RANLIB = @RANLIB@
+VERSION = @VERSION@
+
+INCLUDES = $(GTK_CFLAGS) $(GDK_PIXBUF_CFLAGS) -DDATADIR=\"$(datadir)/eazel-engine\"
+
+enginedir = $(libdir)/gtk/themes/engines
+
+engine_LTLIBRARIES = libeazel-engine.la
+
+libeazel_engine_la_SOURCES =  	eazel-theme.h			eazel-theme-draw.c		eazel-theme-main.c		eazel-theme-gradient.c		eazel-theme-pixmaps.c		eazel-theme-hacks.c
+
+
+libeazel_engine_la_LDFLAGS = -module -avoid-version
+libeazel_engine_la_LIBADD = $(GTK_LIBS) $(GDK_PIXBUF_LIBS)
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = ../config.h
+CONFIG_CLEAN_FILES = 
+LTLIBRARIES =  $(engine_LTLIBRARIES)
+
+
+DEFS = @DEFS@ -I. -I$(srcdir) -I..
+CPPFLAGS = @CPPFLAGS@
+LDFLAGS = @LDFLAGS@
+LIBS = @LIBS@
+libeazel_engine_la_DEPENDENCIES = 
+libeazel_engine_la_OBJECTS =  eazel-theme-draw.lo eazel-theme-main.lo \
+eazel-theme-gradient.lo eazel-theme-pixmaps.lo eazel-theme-hacks.lo
+CFLAGS = @CFLAGS@
+COMPILE = $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+CCLD = $(CC)
+LINK = $(LIBTOOL) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(LDFLAGS) -o $@
+DIST_COMMON =  Makefile.am Makefile.in
+
+
+DISTFILES = $(DIST_COMMON) $(SOURCES) $(HEADERS) $(TEXINFOS) $(EXTRA_DIST)
+
+TAR = gtar
+GZIP_ENV = --best
+SOURCES = $(libeazel_engine_la_SOURCES)
+OBJECTS = $(libeazel_engine_la_OBJECTS)
+
+all: all-redirect
+.SUFFIXES:
+.SUFFIXES: .S .c .lo .o .s
+$(srcdir)/Makefile.in: @MAINTAINER_MODE_TRUE@ Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) 
+	cd $(top_srcdir) && $(AUTOMAKE) --gnu --include-deps src/Makefile
+
+Makefile: $(srcdir)/Makefile.in  $(top_builddir)/config.status
+	cd $(top_builddir) \
+	  && CONFIG_FILES=$(subdir)/$@ CONFIG_HEADERS= $(SHELL) ./config.status
+
+
+mostlyclean-engineLTLIBRARIES:
+
+clean-engineLTLIBRARIES:
+	-test -z "$(engine_LTLIBRARIES)" || rm -f $(engine_LTLIBRARIES)
+
+distclean-engineLTLIBRARIES:
+
+maintainer-clean-engineLTLIBRARIES:
+
+install-engineLTLIBRARIES: $(engine_LTLIBRARIES)
+	@$(NORMAL_INSTALL)
+	$(mkinstalldirs) $(DESTDIR)$(enginedir)
+	@list='$(engine_LTLIBRARIES)'; for p in $$list; do \
+	  if test -f $$p; then \
+	    echo "$(LIBTOOL)  --mode=install $(INSTALL) $$p $(DESTDIR)$(enginedir)/$$p"; \
+	    $(LIBTOOL)  --mode=install $(INSTALL) $$p $(DESTDIR)$(enginedir)/$$p; \
+	  else :; fi; \
+	done
+
+uninstall-engineLTLIBRARIES:
+	@$(NORMAL_UNINSTALL)
+	list='$(engine_LTLIBRARIES)'; for p in $$list; do \
+	  $(LIBTOOL)  --mode=uninstall rm -f $(DESTDIR)$(enginedir)/$$p; \
+	done
+
+.c.o:
+	$(COMPILE) -c $<
+
+.s.o:
+	$(COMPILE) -c $<
+
+.S.o:
+	$(COMPILE) -c $<
+
+mostlyclean-compile:
+	-rm -f *.o core *.core
+
+clean-compile:
+
+distclean-compile:
+	-rm -f *.tab.c
+
+maintainer-clean-compile:
+
+.c.lo:
+	$(LIBTOOL) --mode=compile $(COMPILE) -c $<
+
+.s.lo:
+	$(LIBTOOL) --mode=compile $(COMPILE) -c $<
+
+.S.lo:
+	$(LIBTOOL) --mode=compile $(COMPILE) -c $<
+
+mostlyclean-libtool:
+	-rm -f *.lo
+
+clean-libtool:
+	-rm -rf .libs _libs
+
+distclean-libtool:
+
+maintainer-clean-libtool:
+
+libeazel-engine.la: $(libeazel_engine_la_OBJECTS) $(libeazel_engine_la_DEPENDENCIES)
+	$(LINK) -rpath $(enginedir) $(libeazel_engine_la_LDFLAGS) $(libeazel_engine_la_OBJECTS) $(libeazel_engine_la_LIBADD) $(LIBS)
+
+tags: TAGS
+
+ID: $(HEADERS) $(SOURCES) $(LISP)
+	list='$(SOURCES) $(HEADERS)'; \
+	unique=`for i in $$list; do echo $$i; done | \
+	  awk '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	here=`pwd` && cd $(srcdir) \
+	  && mkid -f$$here/ID $$unique $(LISP)
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) $(LISP)
+	tags=; \
+	here=`pwd`; \
+	list='$(SOURCES) $(HEADERS)'; \
+	unique=`for i in $$list; do echo $$i; done | \
+	  awk '    { files[$$0] = 1; } \
+	       END { for (i in files) print i; }'`; \
+	test -z "$(ETAGS_ARGS)$$unique$(LISP)$$tags" \
+	  || (cd $(srcdir) && etags $(ETAGS_ARGS) $$tags  $$unique $(LISP) -o $$here/TAGS)
+
+mostlyclean-tags:
+
+clean-tags:
+
+distclean-tags:
+	-rm -f TAGS ID
+
+maintainer-clean-tags:
+
+distdir = $(top_builddir)/$(PACKAGE)-$(VERSION)/$(subdir)
+
+subdir = src
+
+distdir: $(DISTFILES)
+	@for file in $(DISTFILES); do \
+	  d=$(srcdir); \
+	  if test -d $$d/$$file; then \
+	    cp -pr $$/$$file $(distdir)/$$file; \
+	  else \
+	    test -f $(distdir)/$$file \
+	    || ln $$d/$$file $(distdir)/$$file 2> /dev/null \
+	    || cp -p $$d/$$file $(distdir)/$$file || :; \
+	  fi; \
+	done
+
+info-am:
+info: info-am
+dvi-am:
+dvi: dvi-am
+check-am: all-am
+check: check-am
+installcheck-am:
+installcheck: installcheck-am
+install-exec-am:
+install-exec: install-exec-am
+
+install-data-am: install-engineLTLIBRARIES
+install-data: install-data-am
+
+install-am: all-am
+	@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+install: install-am
+uninstall-am: uninstall-engineLTLIBRARIES
+uninstall: uninstall-am
+all-am: Makefile $(LTLIBRARIES)
+all-redirect: all-am
+install-strip:
+	$(MAKE) $(AM_MAKEFLAGS) AM_INSTALL_PROGRAM_FLAGS=-s install
+installdirs:
+	$(mkinstalldirs)  $(DESTDIR)$(enginedir)
+
+
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+	-rm -f Makefile $(CONFIG_CLEAN_FILES)
+	-rm -f config.cache config.log stamp-h stamp-h[0-9]*
+
+maintainer-clean-generic:
+mostlyclean-am:  mostlyclean-engineLTLIBRARIES mostlyclean-compile \
+		mostlyclean-libtool mostlyclean-tags \
+		mostlyclean-generic
+
+mostlyclean: mostlyclean-am
+
+clean-am:  clean-engineLTLIBRARIES clean-compile clean-libtool \
+		clean-tags clean-generic mostlyclean-am
+
+clean: clean-am
+
+distclean-am:  distclean-engineLTLIBRARIES distclean-compile \
+		distclean-libtool distclean-tags distclean-generic \
+		clean-am
+	-rm -f libtool
+
+distclean: distclean-am
+
+maintainer-clean-am:  maintainer-clean-engineLTLIBRARIES \
+		maintainer-clean-compile maintainer-clean-libtool \
+		maintainer-clean-tags maintainer-clean-generic \
+		distclean-am
+	@echo "This command is intended for maintainers to use;"
+	@echo "it deletes files that may require special tools to rebuild."
+
+maintainer-clean: maintainer-clean-am
+
+.PHONY: mostlyclean-engineLTLIBRARIES distclean-engineLTLIBRARIES \
+clean-engineLTLIBRARIES maintainer-clean-engineLTLIBRARIES \
+uninstall-engineLTLIBRARIES install-engineLTLIBRARIES \
+mostlyclean-compile distclean-compile clean-compile \
+maintainer-clean-compile mostlyclean-libtool distclean-libtool \
+clean-libtool maintainer-clean-libtool tags mostlyclean-tags \
+distclean-tags clean-tags maintainer-clean-tags distdir info-am info \
+dvi-am dvi check check-am installcheck-am installcheck install-exec-am \
+install-exec install-data-am install-data install-am install \
+uninstall-am uninstall all-redirect all-am all installdirs \
+mostlyclean-generic distclean-generic clean-generic \
+maintainer-clean-generic clean mostlyclean distclean maintainer-clean
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/eazel-engine/src/eazel-theme-draw.c b/eazel-engine/src/eazel-theme-draw.c
new file mode 100644
index 0000000..8098ef7
--- /dev/null
+++ b/eazel-engine/src/eazel-theme-draw.c
@@ -0,0 +1,2358 @@
+/* eazel-theme-draw.c -- replacement drawing `primitives'
+
+   Copyright (C) 2000 Eazel, Inc.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program 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
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   $Id: eazel-theme-draw.c,v 1.21 2001/05/23 04:56:34 jsh Exp $
+
+   Authors: The Rasterman <raster@redhat.com>
+            Owen Taylor <otaylor@redhat.com>
+	    John Harper <jsh@eazel.com>   */
+
+/* Adapted from gtk-engines/notif/notif_theme_draw.c
+
+   Repeat after me: ``the implementation is unimportant, the only thing
+   that matters is the user-experience'' */
+
+#include "eazel-theme.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+#define DEBUG 0
+
+#define DETAIL(xx) ((detail) != 0 && strcmp (xx, detail) == 0)
+
+
+/* utility functions */
+
+static inline void
+debug (const char *fmt, ...)
+{
+    if (DEBUG)
+    {
+	va_list args;
+	va_start (args, fmt);
+	vfprintf (stderr, fmt, args);
+	va_end (args);
+    }
+}
+
+/* adapted from nautilus-gdk-extensions.c */
+static void
+interpolate_color (GdkColor *dest, gdouble ratio,
+		   GdkColor *start, GdkColor *end)
+{
+	g_return_if_fail (ratio >= 0.0);
+	g_return_if_fail (ratio <= 1.0);
+
+	dest->red = start->red * (1.0 - ratio) + (end->red & 0xFF) * ratio;
+	dest->green = start->green * (1.0 - ratio) + end->green * ratio;
+	dest->blue = start->blue * (1.0 - ratio) + end->blue * ratio;
+}
+
+static void
+paint_background_area (GtkStyle *style,
+		       GdkWindow *window,
+		       GtkStateType state_type,
+		       GdkRectangle *area,
+		       int x, int y, int width, int height)
+{
+    GdkGC *gc = style->bg_gc[GTK_STATE_NORMAL];
+
+    if (area != 0)
+	gdk_gc_set_clip_rectangle (gc, area);
+
+    gdk_draw_rectangle (window, gc, TRUE, x, y, width, height);
+
+    if (area != 0)
+	gdk_gc_set_clip_rectangle (gc, 0);
+}
+
+static void
+paint_stock_image (eazel_theme_data *theme_data,
+		   eazel_engine_stock_image type,
+		   gboolean scaled, gboolean setbg,
+		   GtkStyle *style,
+		   GdkWindow *window,
+		   GtkStateType state_type,
+		   GdkRectangle *area,
+		   GtkWidget *widget,
+		   gint x, gint y, gint width, gint height)
+{
+    GdkPixmap *pixmap, *mask;
+
+    if (width == -1 || height == -1)
+    {
+	eazel_engine_stock_get_size (theme_data->stock, type,
+				     width == -1 ? &width : 0,
+				     height == -1 ? &height : 0);
+    }
+
+    if (scaled)
+    {
+	eazel_engine_stock_pixmap_and_mask_scaled (theme_data->stock, type,
+						   width, height,
+						   &pixmap, &mask);
+    }
+    else
+	eazel_engine_stock_pixmap_and_mask (theme_data->stock, type,
+					    &pixmap, &mask);
+
+    if (gdk_window_get_type (window) == GDK_WINDOW_PIXMAP)
+	setbg = FALSE;
+
+    if (setbg)
+    {
+	gdk_draw_pixmap (window, style->fg_gc[state_type], pixmap,
+			 0, 0, x, y, width, height);
+	if (mask != 0)
+	    gdk_window_shape_combine_mask (window, mask, 0, 0);
+    }
+    else
+    {
+	int xsrc = 0, ysrc = 0;
+
+	/* Install the mask before clipping.. */
+	if (mask != 0)
+	{
+	    gdk_gc_set_clip_mask (style->fg_gc[state_type], mask);
+	    gdk_gc_set_clip_origin (style->fg_gc[state_type], x, y);
+	}
+
+	if (area != 0)
+	{
+	    /* clip by hand to leave gc's clipping for the possible mask */
+	    GdkRectangle src = { x, y, width, height }, dest;
+
+	    if (!gdk_rectangle_intersect (&src, area, &dest))
+		return;
+
+	    xsrc -= x - dest.x;
+	    ysrc -= y - dest.y;
+	    x = dest.x;
+	    y = dest.y;
+	    width = dest.width;
+	    height = dest.height;
+
+	}
+
+	if (width > 0 && height > 0)
+	{
+	    gdk_draw_pixmap (window, style->fg_gc[state_type], pixmap,
+			     xsrc, ysrc, x, y, width, height);
+	} 
+
+	if (mask != 0)
+	{
+	    gdk_gc_set_clip_mask (style->fg_gc[state_type], 0);
+	    gdk_gc_set_clip_origin (style->fg_gc[state_type], 0, 0);
+	}
+   }
+    
+    eazel_engine_stock_free_pixmaps (theme_data->stock, type, pixmap, mask);
+}
+
+static void
+paint_outline (GdkWindow *window, GdkGC *gc, gboolean rounded,
+	       int x, int y, int width, int height)
+{
+    int corner = rounded ? 1 : 0;
+
+    /* left and top outermost */
+    gdk_draw_line (window, gc, x, y + corner,
+		   x, y + height - (corner + 1));
+    gdk_draw_line (window, gc, x + corner, y, x + width - (corner + 1), y);
+
+    /* right and bottom outermost */
+    gdk_draw_line (window, gc, x + width - 1, y + corner,
+		   x + width - 1, y + height - (corner + 1));
+    gdk_draw_line (window, gc, x + corner, y + height - 1,
+		   x + width - (corner + 1), y + height - 1);
+}
+
+static void
+paint_shadow (GdkWindow *window, GdkGC *a, GdkGC *b, GdkGC *c, GdkGC *d,
+	      gboolean rounded, int x, int y, int width, int height)
+{
+    int corner = rounded ? 1 : 0;
+
+    if (a != 0)
+    {
+	/* left and top outermost */
+	gdk_draw_line (window, a, x, y + corner,
+		       x, y + height - (corner + 1));
+	gdk_draw_line (window, a, x + corner, y, x + width - (corner + 1), y);
+    }
+
+    if (d != 0)
+    {
+	/* right and bottom outermost */
+	gdk_draw_line (window, d, x + width - 1, y + corner,
+		       x + width - 1, y + height - (corner + 1));
+	gdk_draw_line (window, d, x + corner, y + height - 1,
+		       x + width - (corner + 1), y + height - 1);
+    }
+
+    if (b != 0)
+    {
+	/* left and top inner */
+	gdk_draw_line (window, b, x + 1, y + 2, x + 1, y + height - 2);
+	gdk_draw_line (window, b, x + 1, y + 1, x + width - 2, y + 1);
+    }
+
+    if (c != 0)
+    {
+	/* right and bottom outermost */
+	gdk_draw_line (window, c, x + width - 2, y + 1,
+		       x + width - 2, y + height - 2);
+	gdk_draw_line (window, c, x + 1, y + height - 2,
+		       x + width - 2, y + height - 2);
+    }
+}
+
+static void
+paint_entry_shadow (GdkWindow *window, GtkStyle *style,
+		    GtkStateType state_type,
+		    int x, int y, int width, int height)
+{
+    gdk_draw_rectangle (window, style->black_gc, FALSE,
+			x + 1, y + 1, width - 3, height - 3);
+
+    gdk_draw_line (window, style->dark_gc[state_type],
+		   x, y, x + width - 1, y);
+    gdk_draw_line (window, style->dark_gc[state_type],
+		   x, y, x, y + height - 1);
+
+    gdk_draw_line (window, style->white_gc,
+		   x + 1, y + height - 1, x + width - 1, y + height - 1);
+    gdk_draw_line (window, style->white_gc,
+		   x + width - 1, y + 1, x + width - 1, y + height - 1);
+
+    gdk_draw_line (window, style->mid_gc[state_type],
+		   x + 2, y + 2, x + width - 3, y + 2);
+    gdk_draw_line (window, style->mid_gc[state_type],
+		   x + 2, y + 2, x + 2, y + height - 3);
+
+    gdk_draw_line (window, style->white_gc,
+		   x + 2, y + height - 3, x + width - 3, y + height - 3);
+    gdk_draw_line (window, style->white_gc,
+		   x + width - 3, y + 2, x + width - 3, y + height - 3);
+}
+
+static void
+paint_menuitem_shadow (GdkWindow *window, GtkStyle *style,
+		       int x, int y, int width, int height)
+{
+    gdk_draw_rectangle (window, style->black_gc, FALSE,
+			x + 2, y + 1, width - 5, height - 3);
+
+    gdk_draw_line (window, style->dark_gc[GTK_STATE_NORMAL],
+		   x + 1, y, x + width - 3, y);
+    gdk_draw_line (window, style->dark_gc[GTK_STATE_NORMAL],
+		   x + 1, y, x + 1, y + height - 2);
+    gdk_draw_line (window, style->white_gc,
+		   x + 2, y + height - 1, x + width - 2, y + height - 1);
+    gdk_draw_line (window, style->white_gc,
+		   x + width - 2, y + 1, x + width - 2, y + height - 1);
+}
+
+static void
+paint_default_highlight (eazel_theme_data *theme_data,
+			 GdkColor *hi_color, GdkColor *bg_color,
+			 GdkWindow *window, GdkGC *gc, int x, int y)
+{
+    GdkColormap *sys_lut = gdk_colormap_get_system ();
+    GdkGCValues old_values;
+    GdkColor spectrum[6];
+    int i;
+
+    gdk_gc_get_values (gc, &old_values);
+
+    /* Calculate pixel colors */
+    for (i = 0; i < 6; i++)
+    {
+	interpolate_color (spectrum + i, 1.0 / 7 * i, hi_color, bg_color);
+    }
+
+#define COLOR(i)							\
+    gdk_colormap_alloc_color (sys_lut, spectrum + i, FALSE, TRUE);	\
+    gdk_gc_set_foreground (gc, spectrum + i);
+
+#define PIXEL(a,b) gdk_draw_point (window, gc, x + a, y + b)
+
+    COLOR (0); PIXEL (2, 2);
+    COLOR (1); PIXEL (3, 2); PIXEL (2, 3); PIXEL (4, 1); PIXEL (1, 4);
+    COLOR (2); PIXEL (5, 1); PIXEL (1, 5);
+    COLOR (3); PIXEL (6, 1); PIXEL (1, 6);
+    COLOR (4); PIXEL (7, 1); PIXEL (1, 7); PIXEL (4, 2); PIXEL (2, 4);
+    COLOR (5); PIXEL (8, 1); PIXEL (1, 8);
+
+#undef PIXEL
+#undef COLOR
+
+    gdk_gc_set_foreground (gc, &old_values.foreground);
+}
+
+static void
+paint_default (eazel_theme_data *theme_data,
+	       GdkWindow *window, GdkGC *gc, GdkColor *bg,
+	       gboolean rounded, gboolean rounded_inner, int thickness,
+	       int x, int y, int width, int height)
+{
+    int corner = rounded ? ((thickness > 2) ? 3 : 1) : 0;
+    int window_width, window_height;
+    int i;
+
+    gdk_window_get_size (window, &window_width, &window_height);
+
+    /* If trying to draw a box that's too big for the dimensions of
+       the window, iteratively reduce the thickness until a value
+       is found that won't draw off the window edges */
+    while (x < 0 || y < 0 || x + width >= window_width
+	   || y + height >= window_height)
+    {
+	if (thickness <= 0 || width <= 0 || height <= 0)
+	    return;
+
+	thickness -= 1;
+	x += 1;
+	y += 1;
+	width -= 2;
+	height -= 2;
+    }
+
+    if (rounded)
+    {
+	/* XXX this doesn't work, the background of the window
+	   XXX is white, not grey */
+	gdk_window_clear_area (window, x, y, 1, 1);
+	gdk_window_clear_area (window, x + width, y, 1, 1);
+	gdk_window_clear_area (window, x, y + height, 1, 1);
+	gdk_window_clear_area (window, x + width, y + height, 1, 1);
+    }
+
+    for (i = 0; i < thickness; i++)
+    {
+	int x_i = x + i;
+	int y_i = y + i;
+	int w_i = width - (i * 2);
+	int h_i = height - (i * 2);
+
+	int d_corner = (corner && i == 0) ? corner : 0;
+
+	gdk_draw_line (window, gc, x_i + d_corner, y_i,
+		       x_i + w_i - d_corner , y_i);
+	gdk_draw_line (window, gc, x_i + w_i, y_i + d_corner,
+		       x_i + w_i, y_i + h_i - d_corner);
+	gdk_draw_line (window, gc, x_i + w_i - d_corner, y_i + h_i,
+		       x_i + d_corner, y_i + h_i);
+	gdk_draw_line (window, gc, x_i, y+i + h_i - d_corner,
+		       x_i, y_i + d_corner);
+    }
+
+    if (rounded_inner)
+    {
+	gdk_draw_point (window, gc, x + thickness, y + thickness);
+	gdk_draw_point (window, gc, x + thickness, y + height - thickness);
+	gdk_draw_point (window, gc, x + width - thickness, y + thickness);
+	gdk_draw_point (window, gc, x + width - thickness, y + height - thickness);
+    }
+
+    if (thickness >= 3 && rounded)
+    {
+	GdkColor white = { 0, 65535, 65535, 65535 };
+	paint_default_highlight (theme_data, &white, bg, window, gc, x, y);
+    }
+}
+
+static void
+paint_default_box (eazel_theme_data *theme_data,
+		   GdkWindow *window, GdkGC *gc,
+		   gboolean rounded, gboolean rounded_inner, int thickness,
+		   int x, int y, int width, int height)
+{
+    GdkColor black = { 0, 0, 0, 0 };
+    paint_default (theme_data, window, gc, &black,
+		   rounded, rounded_inner, thickness,
+		   x, y, width, height);
+}
+
+static void
+paint_focus_box (eazel_theme_data *theme_data, GdkWindow *window,
+		 GdkGC *gc, gboolean rounded, gboolean rounded_inner,
+		 int thickness, int x, int y, int width, int height)
+{
+    GdkColormap *sys_lut = gdk_colormap_get_system ();
+    GdkGCValues old_values;
+    GdkColor color;
+    gdk_gc_get_values (gc, &old_values);
+
+    color = theme_data->focus_color;
+    gdk_colormap_alloc_color (sys_lut, &color, FALSE, TRUE);
+    gdk_gc_set_foreground (gc, &color);
+
+    paint_default (theme_data, window, gc, &color, rounded,
+		   rounded_inner, thickness, x, y, width, height);
+
+    gdk_gc_set_foreground (gc, &old_values.foreground);
+}
+
+static void
+paint_insensitive_box (eazel_theme_data *theme_data,
+		       GdkWindow *window, GdkGC *gc, gboolean rounded,
+		       int x, int y, int width, int height)
+{
+    GdkColormap *sys_lut = gdk_colormap_get_system ();
+    GdkGCValues old_values;
+    GdkColor color;
+    gdk_gc_get_values (gc, &old_values);
+
+    color = theme_data->insensitive_colors[1];
+    gdk_colormap_alloc_color (sys_lut, &color, FALSE, TRUE);
+    gdk_gc_set_foreground (gc, &color);
+    gdk_draw_rectangle (window, gc, TRUE, x, y, width, height);
+
+    color = theme_data->insensitive_colors[0];
+    gdk_colormap_alloc_color (sys_lut, &color, FALSE, TRUE);
+    gdk_gc_set_foreground (gc, &color);
+    paint_default (theme_data, window, gc, &color, rounded,
+		   FALSE, 1, x, y, width - 1, height - 1);
+
+    gdk_gc_set_foreground (gc, &old_values.foreground);
+}
+
+static void
+paint_arrow (GdkWindow *window, GdkGC *gc, GtkArrowType arrow_type,
+	     int x, int y, int width, int height)
+{
+    int half_width, half_height;
+    int center_x, center_y;
+
+    if ((width & 1) == 0)
+	width = width - 1;
+    if ((height & 1) == 0)
+	height = height - 1;
+
+    half_width = width / 2;
+    half_height = height / 2;
+
+    center_x = x + half_width;
+    center_y = y + half_height;
+  
+    switch (arrow_type)
+    {
+	int i;
+	static int offset[5] = { 0, -1, -2, -3, -4 };
+	static int length[5] = { 0, 2, 4, 6, 8 };
+	static const int size = 4;
+
+    case GTK_ARROW_UP:
+	for (i = 0; i < size; i++)
+	{
+	    gdk_draw_line (window, gc,
+			   center_x + offset[i],
+			   center_y - 2 + i,
+			   center_x + offset[i] + length[i],
+			   center_y - 2 + i);
+	}
+	break;
+
+    case GTK_ARROW_DOWN:
+	for (i = 0; i < size; i++)
+	{
+	    gdk_draw_line (window, gc,
+			   center_x + offset[i],
+			   center_y + 2 - i,
+			   center_x + offset[i] + length[i],
+			   center_y + 2 - i);
+	}
+	break;
+
+    case GTK_ARROW_LEFT:
+	for (i = 0; i < size; i++)
+	{
+	    gdk_draw_line (window, gc,
+			   center_x - 2 + i,
+			   center_y + offset[i],
+			   center_x - 2 + i,
+			   center_y + offset[i] + length[i]);
+	}
+	break;
+
+    case GTK_ARROW_RIGHT:
+	for (i = 0; i < size; i++)
+	{
+	    gdk_draw_line (window, gc,
+			   center_x + 2 - i,
+			   center_y + offset[i],
+			   center_x + 2 - i,
+			   center_y + offset[i] + length[i]);
+	}
+	break;
+    }
+}
+
+static void
+paint_tick (GdkWindow *window, GdkGC *gc, int x, int y)
+{
+#define PIXEL(a,b) gdk_draw_point (window, gc, x + a, y + b)
+
+    PIXEL (4, -4);
+    PIXEL (3, -3); PIXEL (4, -3); PIXEL (5, -3);
+    PIXEL (-2, -2);
+    PIXEL (2, -2); PIXEL (3, -2); PIXEL (4, -2);
+    PIXEL (-3, -1); PIXEL (-2, -1); PIXEL (-1, -1);
+    PIXEL (1, -1); PIXEL (2, -1); PIXEL (3, -1);
+    PIXEL (-2, 0); PIXEL (-1, 0); PIXEL (0, 0); PIXEL (1, 0); PIXEL (2, 0);
+    PIXEL (-1, 1); PIXEL (0, 1); PIXEL (1, 1);
+    PIXEL (0, 2);
+
+#undef PIXEL
+}
+
+static void
+paint_bullet (GdkWindow *window, GdkGC *gc, int x, int y)
+{
+#define PIXEL(a, b) gdk_draw_point (window, gc, x + a, x + b)
+
+    PIXEL (0, 0); PIXEL (0, -1); PIXEL (-1, 0); PIXEL (-1, -1);
+    PIXEL (1, -1); PIXEL (2, -1); PIXEL (-1, 1); PIXEL (-1, 2);
+
+    PIXEL (0, -2); PIXEL (1, -2);
+    PIXEL (-2, 0); PIXEL (-2, 1);
+    PIXEL (1, 0); PIXEL (2, 0); PIXEL (3, 0);
+    PIXEL (0, 1); PIXEL (1, 1); PIXEL (2, 1); PIXEL (3, 1);
+    PIXEL (0, 2); PIXEL (1, 2); PIXEL (2, 2);
+    PIXEL (0, 3); PIXEL (1, 3);
+
+    PIXEL (-1, -2); PIXEL (-2, -1); PIXEL (2, -2); PIXEL (3, -1);
+    PIXEL (-2, 2); PIXEL (-1, 3); PIXEL (2, 3); PIXEL (3, 2);
+
+#undef PIXEL
+}
+
+
+/* style functions */
+
+static void
+draw_hline (GtkStyle *style,
+	    GdkWindow *window,
+	    GtkStateType state_type,
+	    GdkRectangle *area,
+	    GtkWidget *widget,
+	    gchar *detail,
+	    gint x1, gint x2, gint y)
+{
+    gint thickness_light;
+    gint thickness_dark;
+    gint i;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_hline: detail=%s state=%d x1=%d x2=%d y=%d\n",
+	    detail, state_type, x1, x2, y);
+
+    thickness_light = style->klass->ythickness / 2;
+    thickness_dark = style->klass->ythickness - thickness_light;
+
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
+	gdk_gc_set_clip_rectangle (style->dark_gc[state_type], area);
+    }
+    for (i = 0; i < thickness_dark; i++)
+    {
+	gdk_draw_line (window, style->light_gc[state_type], x2 - i - 1,
+		       y + i, x2, y + i);
+	gdk_draw_line (window, style->dark_gc[state_type], x1, y + i,
+		       x2 - i - 1, y + i);
+    }
+
+    y += thickness_dark;
+    for (i = 0; i < thickness_light; i++)
+    {
+	gdk_draw_line (window, style->dark_gc[state_type], x1, y + i,
+		       x1 + thickness_light - i - 1, y + i);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x1 + thickness_light - i - 1, y + i, x2, y + i);
+    }
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
+	gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
+    }
+}
+
+static void
+draw_vline (GtkStyle *style,
+	    GdkWindow *window,
+	    GtkStateType state_type,
+	    GdkRectangle *area,
+	    GtkWidget *widget, gchar *detail, gint y1, gint y2, gint x)
+{
+    gint thickness_light;
+    gint thickness_dark;
+    gint i;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_vline: detail=%s state=%d x=%d y1=%d y2=%d\n",
+	    detail, state_type, x, y1, y2);
+
+    thickness_light = style->klass->xthickness / 2;
+    thickness_dark = style->klass->xthickness - thickness_light;
+
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
+	gdk_gc_set_clip_rectangle (style->dark_gc[state_type], area);
+    }
+    for (i = 0; i < thickness_dark; i++)
+    {
+	gdk_draw_line (window, style->light_gc[state_type], x + i,
+		       y2 - i - 1, x + i, y2);
+	gdk_draw_line (window, style->dark_gc[state_type], x + i, y1, x + i,
+		       y2 - i - 1);
+    }
+
+    x += thickness_dark;
+    for (i = 0; i < thickness_light; i++)
+    {
+	gdk_draw_line (window, style->dark_gc[state_type], x + i, y1, x + i,
+		       y1 + thickness_light - i);
+	gdk_draw_line (window, style->light_gc[state_type], x + i,
+		       y1 + thickness_light - i, x + i, y2);
+    }
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
+	gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
+    }
+}
+
+static void
+draw_shadow (GtkStyle *style,
+	     GdkWindow *window,
+	     GtkStateType state_type,
+	     GtkShadowType shadow_type,
+	     GdkRectangle *area,
+	     GtkWidget *widget,
+	     gchar *detail, gint x, gint y, gint width, gint height)
+{
+    GdkGC *gc1 = NULL;
+    GdkGC *gc2 = NULL;
+    GdkGC *gc3 = NULL;
+    GdkGC *gc4 = NULL;
+    GdkGC *gc_a, *gc_b, *gc_c, *gc_d;
+    gint thickness_light;
+    gint thickness_dark;
+    gboolean rounded = FALSE, rounded_inner = FALSE;
+    gboolean outline = TRUE;
+    gint i;
+
+    eazel_theme_data *theme_data;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    outline = theme_data->outline_shadow;
+
+    if (widget != 0 && !GTK_WIDGET_IS_SENSITIVE (widget))
+	state_type = GTK_STATE_INSENSITIVE;
+
+    debug ("draw_shadow: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+    g_return_if_fail (width >= -1);
+    g_return_if_fail (height >= -1);
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    switch (shadow_type)
+    {
+    case GTK_SHADOW_NONE:
+	return;
+    case GTK_SHADOW_IN:
+    case GTK_SHADOW_ETCHED_IN:
+	if (theme_data->inverse_shadow)
+	    goto out;
+    in:
+	gc1 = style->light_gc[state_type];
+	gc2 = style->dark_gc[state_type];
+	gc3 = style->mid_gc[state_type];
+	gc4 = style->bg_gc[state_type];
+	break;
+    case GTK_SHADOW_OUT:
+    case GTK_SHADOW_ETCHED_OUT:
+	if (theme_data->inverse_shadow)
+	    goto in;
+    out:
+	gc1 = style->dark_gc[state_type];
+	gc2 = style->light_gc[state_type];
+	gc3 = style->mid_gc[state_type];
+	gc4 = style->bg_gc[state_type];
+	break;
+    }
+
+    gc_a = gc2;
+    gc_b = gc4;
+    gc_c = 0;
+    gc_d = gc1;
+
+    if (DETAIL ("button") || DETAIL ("optionmenu"))
+    {
+	/* Clist title buttons have square edges */
+	if (widget == 0 || !GTK_IS_CLIST (widget->parent))
+	    rounded = rounded_inner = TRUE;
+    }
+    else if (DETAIL ("menuitem"))
+    {
+	paint_menuitem_shadow (window, style, x, y, width, height);
+	return;
+    }
+    else if (DETAIL ("entry") || DETAIL ("text"))
+    {
+	if (widget == 0 || GTK_WIDGET_IS_SENSITIVE (widget))
+	{
+	    paint_entry_shadow (window, style, state_type,
+				x, y, width, height);
+	    return;
+	}
+    }
+    else if (DETAIL ("spinbutton"))
+    {
+	gc_a = gc2;
+	gc_b = 0;
+	outline = FALSE;
+    }
+
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (gc1, area);
+	gdk_gc_set_clip_rectangle (gc2, area);
+	gdk_gc_set_clip_rectangle (gc3, area);
+	gdk_gc_set_clip_rectangle (gc4, area);
+	if ((shadow_type == GTK_SHADOW_IN) || (shadow_type == GTK_SHADOW_OUT))
+	{
+	    gdk_gc_set_clip_rectangle (style->black_gc, area);
+	    gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
+	}
+    }
+    switch (shadow_type)
+    {
+    case GTK_SHADOW_NONE:
+	break;
+
+    case GTK_SHADOW_IN:
+    case GTK_SHADOW_OUT:
+	if (state_type == GTK_STATE_INSENSITIVE)
+	{
+	    paint_insensitive_box (theme_data, window,
+				   style->bg_gc[state_type],
+				   rounded, x, y, width, height);
+	}
+	else if (outline)
+	{
+	    paint_outline (window, style->black_gc, rounded,
+			   x, y, width, height);
+	    if (!theme_data->no_shadow)
+	    {
+		paint_shadow (window, gc_a, gc_b, gc_c, gc_d, rounded,
+			      x + 1, y + 1, width - 2, height - 2);
+	    }
+	}
+	else
+	{
+	    if (!theme_data->no_shadow)
+	    {
+		paint_shadow (window, gc_a, gc_b, gc_c, gc_d, rounded,
+			      x, y, width, height);
+	    }
+	}
+	break;
+
+    case GTK_SHADOW_ETCHED_IN:
+    case GTK_SHADOW_ETCHED_OUT:
+	thickness_light = 1;
+	thickness_dark = 1;
+
+	for (i = 0; i < thickness_dark; i++)
+	{
+	    gdk_draw_line (window, gc1,
+			   x + i,
+			   y + height - i - 1,
+			   x + width - i - 1, y + height - i - 1);
+	    gdk_draw_line (window, gc1,
+			   x + width - i - 1,
+			   y + i, x + width - i - 1, y + height - i - 1);
+
+	    gdk_draw_line (window, gc2,
+			   x + i, y + i, x + width - i - 2, y + i);
+	    gdk_draw_line (window, gc2,
+			   x + i, y + i, x + i, y + height - i - 2);
+	}
+
+	for (i = 0; i < thickness_light; i++)
+	{
+	    gdk_draw_line (window, gc1,
+			   x + thickness_dark + i,
+			   y + thickness_dark + i,
+			   x + width - thickness_dark - i - 1,
+			   y + thickness_dark + i);
+	    gdk_draw_line (window, gc1,
+			   x + thickness_dark + i,
+			   y + thickness_dark + i,
+			   x + thickness_dark + i,
+			   y + height - thickness_dark - i - 1);
+
+	    gdk_draw_line (window, gc2,
+			   x + thickness_dark + i,
+			   y + height - thickness_light - i - 1,
+			   x + width - thickness_light - 1,
+			   y + height - thickness_light - i - 1);
+	    gdk_draw_line (window, gc2,
+			   x + width - thickness_light - i - 1,
+			   y + thickness_dark + i,
+			   x + width - thickness_light - i - 1,
+			   y + height - thickness_light - 1);
+	}
+	break;
+    }
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (gc1, NULL);
+	gdk_gc_set_clip_rectangle (gc2, NULL);
+	gdk_gc_set_clip_rectangle (gc3, NULL);
+	gdk_gc_set_clip_rectangle (gc4, NULL);
+	if ((shadow_type == GTK_SHADOW_IN) || (shadow_type == GTK_SHADOW_OUT))
+	{
+	    gdk_gc_set_clip_rectangle (style->black_gc, NULL);
+	    gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
+	}
+    }
+}
+
+static void
+draw_box (GtkStyle *style,
+	  GdkWindow *window,
+	  GtkStateType state_type,
+	  GtkShadowType shadow_type,
+	  GdkRectangle *area,
+	  GtkWidget *widget,
+	  gchar *detail, gint x, gint y, gint width, gint height)
+{
+    gboolean add_shadow = FALSE;
+    eazel_theme_data *theme_data;
+    gboolean set_bg = FALSE;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+    g_return_if_fail (width >= -1);
+    g_return_if_fail (height >= -1);
+
+    if ((width == -1) && (height == -1))
+    {
+	gdk_window_get_size (window, &width, &height);
+	if (gdk_window_get_type (window) != GDK_WINDOW_PIXMAP)
+	    set_bg = TRUE;
+    }
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    if (widget != 0 && !GTK_WIDGET_IS_SENSITIVE (widget))
+	state_type = GTK_STATE_INSENSITIVE;
+
+    debug ("draw_box: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    if ((!style->bg_pixmap[state_type]) ||
+	(gdk_window_get_type (window) == GDK_WINDOW_PIXMAP))
+    {
+	if (area)
+	{
+	    gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
+	    gdk_gc_set_clip_rectangle (style->fg_gc[state_type], area);
+	    gdk_gc_set_clip_rectangle (style->dark_gc[state_type], area);
+	    gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
+	    gdk_gc_set_clip_rectangle (style->black_gc, area);
+	}
+
+	if (DETAIL ("trough"))
+	{
+	    if (GTK_IS_PROGRESS_BAR (widget))
+	    {
+		if (state_type != GTK_STATE_INSENSITIVE)
+		{
+		    paint_stock_image (theme_data,
+				       EAZEL_ENGINE_PROGRESS_TROUGH,
+				       TRUE, FALSE,
+				       style, window, state_type, area,
+				       widget, x, y, width, height);
+		}
+		else
+		{
+		    paint_insensitive_box (theme_data, window,
+					   style->fg_gc[state_type],
+					   FALSE, x, y, width, height);
+		}
+	    }
+	    else if (GTK_IS_SCALE (widget))
+	    {
+		gboolean focused = GTK_WIDGET_HAS_FOCUS (widget);
+		paint_background_area (style, window, state_type, area,
+				       x, y, width, height);
+		paint_stock_image (theme_data,
+				   width > height
+				   ? (focused
+				      ? EAZEL_ENGINE_H_SLIDER_TROUGH_ACTIVE
+				      : EAZEL_ENGINE_H_SLIDER_TROUGH)
+				   : (focused
+				      ? EAZEL_ENGINE_V_SLIDER_TROUGH_ACTIVE
+				      : EAZEL_ENGINE_V_SLIDER_TROUGH),
+				   TRUE, FALSE, style, window, state_type,
+				   area, widget, x, y, width, height);
+	    }
+	    else
+	    {
+		paint_stock_image (theme_data,
+				   width > height ? EAZEL_ENGINE_H_TROUGH
+				   : EAZEL_ENGINE_V_TROUGH, TRUE, FALSE,
+				   style, window, state_type, area,
+				   widget, x, y, width, height);
+	    }
+	}
+	else if (DETAIL ("slider"))
+	{
+	    int thumb_x, thumb_y;
+	    gboolean focused;
+
+	    focused = eazel_engine_widget_in_focused_window_p (widget);
+
+	    /* XXX could be a gradient? */
+	    paint_stock_image (theme_data,
+			       width > height
+			       ? (state_type == GTK_STATE_PRELIGHT
+				  ? EAZEL_ENGINE_H_SCROLLBAR_HI
+				  : !focused
+				  ? EAZEL_ENGINE_H_SCROLLBAR_INACTIVE
+				  : EAZEL_ENGINE_H_SCROLLBAR)
+			       : (state_type == GTK_STATE_PRELIGHT
+				  ? EAZEL_ENGINE_V_SCROLLBAR_HI
+				  : !focused
+				  ? EAZEL_ENGINE_V_SCROLLBAR_INACTIVE
+				  : EAZEL_ENGINE_V_SCROLLBAR),
+			       TRUE, FALSE, style, window, state_type, area,
+			       widget, x, y, width, height);
+	    if (width > height)
+	    {
+		/* XXX `4' is 1/2 width of thumb */
+		thumb_x = x + width / 2 - 4;
+		thumb_y = y;
+	    }
+	    else
+	    {
+		thumb_x = x;
+		/* XXX `4' is 1/2 height of thumb */
+		thumb_y = y + height / 2 - 4;
+	    }
+
+	    paint_stock_image (theme_data,
+			       width > height
+			       ? (state_type == GTK_STATE_PRELIGHT
+				  ? EAZEL_ENGINE_H_SCROLLBAR_THUMB_HI
+				  : !focused
+				  ? EAZEL_ENGINE_H_SCROLLBAR_THUMB_INACTIVE
+				  : EAZEL_ENGINE_H_SCROLLBAR_THUMB)
+			       : (state_type == GTK_STATE_PRELIGHT
+				  ? EAZEL_ENGINE_V_SCROLLBAR_THUMB_HI
+				  : !focused
+				  ? EAZEL_ENGINE_V_SCROLLBAR_THUMB_INACTIVE
+				  : EAZEL_ENGINE_V_SCROLLBAR_THUMB),
+			       FALSE, FALSE, style, window, state_type, area,
+			       widget, thumb_x, thumb_y, -1, -1);
+	}
+	else if (DETAIL ("vscrollbar"))
+	{
+	}
+	else if (DETAIL ("hscrollbar"))
+	{
+	}
+	else if (DETAIL ("bar"))
+	{
+	    if (state_type != GTK_STATE_INSENSITIVE)
+	    {
+		gboolean focused;
+		focused = eazel_engine_widget_in_focused_window_p (widget);
+		paint_stock_image (theme_data,
+				   focused ? EAZEL_ENGINE_PROGRESS_BAR
+				   : EAZEL_ENGINE_PROGRESS_BAR_INACTIVE,
+				   TRUE, FALSE, style, window, state_type,
+				   area, widget, x, y, width, height);
+		if (x > style->klass->xthickness)
+		{
+		    paint_stock_image (theme_data,
+				       EAZEL_ENGINE_PROGRESS_BAR_LEFT,
+				       TRUE, FALSE, style, window, state_type,
+				       area, widget, x - 2, y, -1, height);
+		}
+		if (widget != 0
+		    && x + width < widget->allocation.width - style->klass->xthickness - 3)
+		{
+		    paint_stock_image (theme_data,
+				       EAZEL_ENGINE_PROGRESS_BAR_RIGHT,
+				       TRUE, FALSE, style, window,
+				       state_type, area, widget,
+				       x + width, y, -1, height);
+		}
+	    }
+	    else
+	    {
+		paint_insensitive_box (theme_data, window,
+				       style->fg_gc[state_type],
+				       FALSE, x, y, width, height);
+	    }
+	}
+	else if (DETAIL ("optionmenutab"))
+	{
+	    int real_width, real_height;
+	    int y1, y2;
+	    int center_x, center_y;
+
+	    gdk_window_get_size (window, &real_width, &real_height);
+
+	    y1 = style->klass->ythickness + 1;
+	    y2 = real_height - style->klass->ythickness - 2;
+	    gdk_draw_line (window, style->dark_gc[state_type]
+			   , x, y1, x, y2);
+	    gdk_draw_line (window, style->light_gc[state_type],
+			   x + 1, y1, x +1, y2);
+
+	    center_x = x + (real_width - x) / 2;
+	    center_y = real_height / 2;
+
+	    paint_arrow (window, style->fg_gc[state_type], GTK_ARROW_UP,
+			 center_x - 4, center_y - 6, 7, 7);
+	    paint_arrow (window, style->fg_gc[state_type], GTK_ARROW_DOWN,
+			 center_x - 4, center_y - 1, 7, 7);
+	}
+	else if (DETAIL ("buttondefault"))
+	{
+	    /* Don't draw default markings. */
+	}
+	else
+	{
+	    GdkRectangle full;
+
+	    eazel_engine_gradient *gradient = theme_data->gradients[state_type];
+	    add_shadow = (shadow_type != GTK_SHADOW_NONE);
+
+	    if (DETAIL ("button") && widget != 0
+		&& GTK_WIDGET_HAS_FOCUS (widget)
+		&& GTK_WIDGET_CAN_DEFAULT (widget))
+	    {
+		x -= 1;
+		y -= 1;
+		width += 2;
+		height += 2;
+	    }
+
+	    full.x = x;
+	    full.y = y;
+	    full.width = width;
+	    full.height = height;
+
+	    if (DETAIL ("menuitem"))
+	    {
+		full.x++; full.y++;
+		full.width -= 2; full.height -= 2;
+	    }
+
+	    if (gradient != NULL && gradient->direction != GRADIENT_NONE)
+	    {
+		if (!set_bg)
+		{
+		    eazel_engine_draw_gradient (window,
+						style->bg_gc[state_type],
+						&full, &full, gradient);
+		}
+		else
+		{
+		    GdkRectangle dest;
+		    if (area != 0)
+			gdk_rectangle_intersect (&full, area, &dest);
+		    else
+			dest = full;
+		    eazel_engine_set_bg_gradient (window, gradient);
+		    gdk_window_clear_area (window, dest.x, dest.y,
+					   dest.width, dest.height);
+		}
+	    }
+	    else
+	    {
+		if (!set_bg)
+		{
+		    gdk_draw_rectangle (window, style->bg_gc[state_type], TRUE,
+					x, y, width, height);
+		}
+		else
+		{
+		    GdkRectangle dest;
+		    if (area != 0)
+			gdk_rectangle_intersect (&full, area, &dest);
+		    else
+			dest = full;
+		    gdk_window_set_background (window, &style->bg[state_type]);
+		    gdk_window_clear_area (window, dest.x, dest.y,
+					   dest.width, dest.height);
+		}
+	    }
+
+	    if (DETAIL ("button") && widget != 0
+		&& GTK_WIDGET_HAS_DEFAULT (widget))
+	    {
+		void (*fun) (eazel_theme_data *, GdkWindow *, GdkGC *, gboolean, gboolean, int, int, int, int, int) = paint_default_box;
+
+		if (GTK_WIDGET_HAS_FOCUS (widget))
+		    fun = paint_focus_box;
+
+		fun (theme_data, window, style->black_gc, TRUE, TRUE,
+		     theme_data->default_thickness,
+		     x - (theme_data->default_thickness),
+		     y - (theme_data->default_thickness),
+		     width + theme_data->default_thickness * 2 - 1,
+		     height + theme_data->default_thickness * 2 - 1);
+	    }
+	}
+	if (area)
+	{
+	    gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
+	    gdk_gc_set_clip_rectangle (style->fg_gc[state_type], NULL);
+	    gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
+	    gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
+	    gdk_gc_set_clip_rectangle (style->black_gc, NULL);
+	}
+    }
+    else
+    {
+	gtk_style_apply_default_pixmap (style, window, state_type, area, x,
+					y, width, height);
+    }
+
+    if (add_shadow)
+    {
+	gtk_paint_shadow (style, window, state_type, shadow_type, area, widget,
+			  detail, x, y, width, height);
+    }
+}
+
+static void
+draw_polygon (GtkStyle *style,
+	      GdkWindow *window,
+	      GtkStateType state_type,
+	      GtkShadowType shadow_type,
+	      GdkRectangle *area,
+	      GtkWidget *widget,
+	      gchar *detail, GdkPoint *points, gint npoints, gint fill)
+{
+#ifndef M_PI
+#define M_PI    3.14159265358979323846
+#endif /*
+        * M_PI 
+        */
+#ifndef M_PI_4
+#define M_PI_4  0.78539816339744830962
+#endif /*
+        * M_PI_4 
+        */
+
+    static const gdouble pi_over_4 = M_PI_4;
+    static const gdouble pi_3_over_4 = M_PI_4 * 3;
+
+    GdkGC *gc1;
+    GdkGC *gc2;
+    GdkGC *gc3;
+    GdkGC *gc4;
+    gdouble angle;
+    gint xadjust;
+    gint yadjust;
+    gint i;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+    g_return_if_fail (points != NULL);
+
+    debug ("draw_polygon: detail=%s state=%d shadow=%d\n",
+	    detail, state_type, shadow_type);
+
+    switch (shadow_type)
+    {
+    case GTK_SHADOW_IN:
+	gc1 = style->light_gc[state_type];
+	gc2 = style->dark_gc[state_type];
+	gc3 = style->light_gc[state_type];
+	gc4 = style->dark_gc[state_type];
+	break;
+    case GTK_SHADOW_ETCHED_IN:
+	gc1 = style->light_gc[state_type];
+	gc2 = style->dark_gc[state_type];
+	gc3 = style->dark_gc[state_type];
+	gc4 = style->light_gc[state_type];
+	break;
+    case GTK_SHADOW_OUT:
+	gc1 = style->dark_gc[state_type];
+	gc2 = style->light_gc[state_type];
+	gc3 = style->dark_gc[state_type];
+	gc4 = style->light_gc[state_type];
+	break;
+    case GTK_SHADOW_ETCHED_OUT:
+	gc1 = style->dark_gc[state_type];
+	gc2 = style->light_gc[state_type];
+	gc3 = style->light_gc[state_type];
+	gc4 = style->dark_gc[state_type];
+	break;
+    default:
+	return;
+    }
+
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (gc1, area);
+	gdk_gc_set_clip_rectangle (gc2, area);
+	gdk_gc_set_clip_rectangle (gc3, area);
+	gdk_gc_set_clip_rectangle (gc4, area);
+    }
+
+    if (fill)
+	gdk_draw_polygon (window, style->bg_gc[state_type], TRUE, points,
+			  npoints);
+
+    npoints--;
+
+    for (i = 0; i < npoints; i++)
+    {
+	if ((points[i].x == points[i + 1].x) &&
+	    (points[i].y == points[i + 1].y))
+	{
+	    angle = 0;
+	}
+	else
+	{
+	    angle = atan2 (points[i + 1].y - points[i].y,
+			   points[i + 1].x - points[i].x);
+	}
+
+	if ((angle > -pi_3_over_4) && (angle < pi_over_4))
+	{
+	    if (angle > -pi_over_4)
+	    {
+		xadjust = 0;
+		yadjust = 1;
+	    }
+	    else
+	    {
+		xadjust = 1;
+		yadjust = 0;
+	    }
+
+	    gdk_draw_line (window, gc1,
+			   points[i].x - xadjust, points[i].y - yadjust,
+			   points[i + 1].x - xadjust,
+			   points[i + 1].y - yadjust);
+	    gdk_draw_line (window, gc3, points[i].x, points[i].y,
+			   points[i + 1].x, points[i + 1].y);
+	}
+	else
+	{
+	    if ((angle < -pi_3_over_4) || (angle > pi_3_over_4))
+	    {
+		xadjust = 0;
+		yadjust = 1;
+	    }
+	    else
+	    {
+		xadjust = 1;
+		yadjust = 0;
+	    }
+
+	    gdk_draw_line (window, gc4,
+			   points[i].x + xadjust, points[i].y + yadjust,
+			   points[i + 1].x + xadjust,
+			   points[i + 1].y + yadjust);
+	    gdk_draw_line (window, gc2, points[i].x, points[i].y,
+			   points[i + 1].x, points[i + 1].y);
+	}
+    }
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (gc1, NULL);
+	gdk_gc_set_clip_rectangle (gc2, NULL);
+	gdk_gc_set_clip_rectangle (gc3, NULL);
+	gdk_gc_set_clip_rectangle (gc4, NULL);
+    }
+}
+
+static void
+draw_arrow (GtkStyle *style,
+	    GdkWindow *window,
+	    GtkStateType state_type,
+	    GtkShadowType shadow_type,
+	    GdkRectangle *area,
+	    GtkWidget *widget,
+	    gchar *detail,
+	    GtkArrowType arrow_type,
+	    gint fill, gint x, gint y, gint width, gint height)
+{
+    eazel_theme_data *theme_data;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+    g_return_if_fail (width >= -1);
+    g_return_if_fail (height >= -1);
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    debug ("draw_arrow: detail=%s state=%d shadow=%d arrow_type=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, arrow_type, x, y, width, height);
+
+    if (DETAIL ("vscrollbar") || DETAIL ("hscrollbar"))
+    {
+	int type;
+	switch (arrow_type)
+	{
+	case GTK_ARROW_UP:
+	    type = EAZEL_ENGINE_ARROW_UP;
+	    break;
+
+	case GTK_ARROW_DOWN:
+	    type = EAZEL_ENGINE_ARROW_DOWN;
+	    break;
+
+	case GTK_ARROW_LEFT:
+	    type = EAZEL_ENGINE_ARROW_LEFT;
+	    break;
+
+	case GTK_ARROW_RIGHT:
+	    type = EAZEL_ENGINE_ARROW_RIGHT;
+	    break;
+	}
+
+	type += (state_type == GTK_STATE_ACTIVE ? 2
+		 : state_type == GTK_STATE_PRELIGHT ? 1 : 0);
+
+	paint_stock_image (theme_data, type, TRUE, FALSE,
+			   style, window, state_type,
+			   area, widget, x, y, width, height);
+    }
+    else if (DETAIL ("spinbutton"))
+    {
+	int window_width, window_height;
+	int tem_x, tem_y;
+
+	if (widget != 0 && !GTK_WIDGET_IS_SENSITIVE (widget))
+	    state_type = GTK_STATE_INSENSITIVE;
+
+	gdk_window_get_size (window, &window_width, &window_height);
+
+	if (state_type != GTK_STATE_INSENSITIVE)
+	{
+	    draw_box (style, window, state_type, shadow_type,
+		      area, widget, detail,
+		      x, y - (arrow_type == GTK_ARROW_DOWN),
+		      width, height + 1);
+	}
+	else if (arrow_type == GTK_ARROW_UP)
+	{
+	    /* XXX A hack, assumes that up arrow is drawn before
+	       XXX down arrow. (Currently it is) */
+
+	    draw_shadow (style, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
+			 NULL, widget, "entry", x - 2, 0,
+			 width + 4, window_height);
+	}
+
+	tem_x = x + (width / 2);
+	tem_y = y + (height / 2);
+	if (arrow_type == GTK_ARROW_UP)
+	{
+	    int i;
+	    tem_y--;
+	    for (i = 0; i < 4; i++)
+	    {
+		gdk_draw_line (window, style->fg_gc[state_type],
+			       tem_x - i, tem_y + i, tem_x + i, tem_y + i);
+	    }
+	}
+	else
+	{
+	    int i;
+	    tem_y -= 3;
+	    for (i = 0; i < 4; i++)
+	    {
+		gdk_draw_line (window, style->fg_gc[state_type],
+			       tem_x - i, tem_y + (4 - i),
+			       tem_x + i, tem_y + (4 - i));
+	    }
+	}
+
+	if (state_type != GTK_STATE_INSENSITIVE)
+	{
+	    draw_shadow (style, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
+			 NULL, widget, "entry", x - 2, 0,
+			 width + 4, window_height);
+	}
+    }
+    else
+    {
+	if (widget != 0 && !GTK_WIDGET_IS_SENSITIVE (widget))
+	    state_type = GTK_STATE_INSENSITIVE;
+
+	paint_arrow (window, style->fg_gc[state_type],
+		     arrow_type, x, y, width, height);
+    }
+}
+
+static void
+draw_diamond (GtkStyle *style,
+	      GdkWindow *window,
+	      GtkStateType state_type,
+	      GtkShadowType shadow_type,
+	      GdkRectangle *area,
+	      GtkWidget *widget,
+	      gchar *detail, gint x, gint y, gint width, gint height)
+{
+    gint half_width;
+    gint half_height;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_diamond: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+    g_return_if_fail (width >= -1);
+    g_return_if_fail (height >= -1);
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    half_width = width / 2;
+    half_height = height / 2;
+
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
+	gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
+	gdk_gc_set_clip_rectangle (style->dark_gc[state_type], area);
+	gdk_gc_set_clip_rectangle (style->black_gc, area);
+    }
+    switch (shadow_type)
+    {
+    case GTK_SHADOW_IN:
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + 2, y + half_height,
+		       x + half_width, y + height - 2);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + half_width, y + height - 2,
+		       x + width - 2, y + half_height);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + 1, y + half_height,
+		       x + half_width, y + height - 1);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + half_width, y + height - 1,
+		       x + width - 1, y + half_height);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x, y + half_height, x + half_width, y + height);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + half_width, y + height,
+		       x + width, y + half_height);
+
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + 2, y + half_height, x + half_width, y + 2);
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + half_width, y + 2, x + width - 2, y + half_height);
+	gdk_draw_line (window, style->dark_gc[state_type], x + 1,
+		       y + half_height, x + half_width, y + 1);
+	gdk_draw_line (window, style->dark_gc[state_type], x + half_width,
+		       y + 1, x + width - 1, y + half_height);
+	gdk_draw_line (window, style->dark_gc[state_type], x,
+		       y + half_height, x + half_width, y);
+	gdk_draw_line (window, style->dark_gc[state_type], x + half_width,
+		       y, x + width, y + half_height);
+	break;
+    case GTK_SHADOW_OUT:
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + 2, y + half_height,
+		       x + half_width, y + height - 2);
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + half_width, y + height - 2,
+		       x + width - 2, y + half_height);
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + 1, y + half_height,
+		       x + half_width, y + height - 1);
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + half_width, y + height - 1,
+		       x + width - 1, y + half_height);
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x, y + half_height, x + half_width, y + height);
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + half_width, y + height,
+		       x + width, y + half_height);
+
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + 2, y + half_height, x + half_width, y + 2);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + half_width, y + 2, x + width - 2, y + half_height);
+	gdk_draw_line (window, style->light_gc[state_type], x + 1,
+		       y + half_height, x + half_width, y + 1);
+	gdk_draw_line (window, style->light_gc[state_type], x + half_width,
+		       y + 1, x + width - 1, y + half_height);
+	gdk_draw_line (window, style->light_gc[state_type], x,
+		       y + half_height, x + half_width, y);
+	gdk_draw_line (window, style->light_gc[state_type], x + half_width,
+		       y, x + width, y + half_height);
+	break;
+    default:
+	break;
+    }
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
+	gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
+	gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
+	gdk_gc_set_clip_rectangle (style->black_gc, NULL);
+    }
+}
+
+static void
+draw_oval (GtkStyle *style,
+	   GdkWindow *window,
+	   GtkStateType state_type,
+	   GtkShadowType shadow_type,
+	   GdkRectangle *area,
+	   GtkWidget *widget,
+	   gchar *detail, gint x, gint y, gint width, gint height)
+{
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+}
+
+static void
+draw_string (GtkStyle *style,
+	     GdkWindow *window,
+	     GtkStateType state_type,
+	     GdkRectangle *area,
+	     GtkWidget *widget,
+	     gchar *detail, gint x, gint y, const gchar *string)
+{
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_string: detail=%s state=%d x=%d y=%d\n",
+	    detail, state_type, x, y);
+
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->white_gc, area);
+	gdk_gc_set_clip_rectangle (style->fg_gc[state_type], area);
+    }
+    if (state_type == GTK_STATE_INSENSITIVE)
+	gdk_draw_string (window, style->font, style->white_gc, x + 1, y + 1,
+			 string);
+    gdk_draw_string (window, style->font, style->fg_gc[state_type], x, y,
+		     string);
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->white_gc, NULL);
+	gdk_gc_set_clip_rectangle (style->fg_gc[state_type], NULL);
+    }
+}
+
+static void
+draw_flat_box (GtkStyle *style,
+	       GdkWindow *window,
+	       GtkStateType state_type,
+	       GtkShadowType shadow_type,
+	       GdkRectangle *area,
+	       GtkWidget *widget,
+	       gchar *detail, gint x, gint y, gint width, gint height)
+{
+    GdkGC *gc1;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+    g_return_if_fail (width >= -1);
+    g_return_if_fail (height >= -1);
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    debug ("draw_flat_box: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    gc1 = style->bg_gc[state_type];
+
+    if (DETAIL ("text") && (state_type == GTK_STATE_SELECTED))
+	gc1 = style->bg_gc[GTK_STATE_SELECTED];
+    else if (DETAIL ("viewportbin"))
+	gc1 = style->bg_gc[GTK_STATE_NORMAL];
+    else if (DETAIL ("entry_bg"))
+	gc1 = style->white_gc;
+
+    if ((!style->bg_pixmap[state_type])
+	|| (gc1 != style->bg_gc[state_type])
+	|| (gdk_window_get_type (window) == GDK_WINDOW_PIXMAP))
+    {
+	if (area)
+	{
+	    gdk_gc_set_clip_rectangle (gc1, area);
+	}
+	gdk_draw_rectangle (window, gc1, TRUE, x, y, width, height);
+	if ((detail) && (!strcmp ("tooltip", detail)))
+	    gdk_draw_rectangle (window, style->black_gc, FALSE,
+				x, y, width - 1, height - 1);
+	if (area)
+	{
+	    gdk_gc_set_clip_rectangle (gc1, NULL);
+	}
+    }
+    else
+	gtk_style_apply_default_pixmap (style, window, state_type, area, x,
+					y, width, height);
+}
+
+static void
+paint_check (GtkStyle *style,
+	     GdkWindow *window,
+	     GtkStateType state_type,
+	     GtkShadowType shadow_type,
+	     GdkRectangle *area,
+	     GtkWidget *widget,
+	     gchar *detail, gint x, gint y, gint width, gint height,
+	     eazel_engine_stock_image stock_base)
+{
+    eazel_engine_stock_image type;
+    gboolean active = (shadow_type != GTK_SHADOW_OUT);
+    gboolean has_focus = (widget != 0 && GTK_WIDGET_HAS_FOCUS (widget));
+    gboolean menu_item = (widget != 0 && gtk_widget_get_ancestor (widget, GTK_TYPE_MENU_ITEM));
+
+    eazel_theme_data *theme_data;
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    if (DETAIL ("checkbutton") || DETAIL ("radiobutton"))
+    {
+	/* correct for braindeath in gtk_real_check_button_draw_indicator */
+	if (widget != 0 && GTK_IS_TOGGLE_BUTTON (widget))
+	    active = GTK_TOGGLE_BUTTON (widget)->active;
+	if (widget != 0)
+	{
+	    state_type = GTK_WIDGET_STATE (widget);
+	    /* XXX the widget gives us no way to tell between
+	       XXX checked, and checked-and-clicked states.. */
+	    if (active && state_type == GTK_STATE_ACTIVE)
+		state_type = GTK_STATE_NORMAL;
+	}
+    }
+
+    if (!menu_item)
+    {
+	switch (state_type)
+	{
+	case GTK_STATE_INSENSITIVE:
+	    type = (!active ? EAZEL_ENGINE_CHECK_DISABLED
+		    : EAZEL_ENGINE_CHECK_ACTIVE_DISABLED);
+	    break;
+
+	case GTK_STATE_PRELIGHT:
+	    type = (active
+		    ? (has_focus ? EAZEL_ENGINE_CHECK_ACTIVE_HI_FOCUS
+		       : EAZEL_ENGINE_CHECK_ACTIVE_HI)
+		    : (has_focus ? EAZEL_ENGINE_CHECK_HI_FOCUS
+		       : EAZEL_ENGINE_CHECK_HI));
+	    break;
+
+	case GTK_STATE_ACTIVE:
+	    type = (active
+		    ? (has_focus ? EAZEL_ENGINE_CHECK_ACTIVE_PRESSED_FOCUS
+		       : EAZEL_ENGINE_CHECK_ACTIVE)
+		    : (has_focus ? EAZEL_ENGINE_CHECK_PRESSED_FOCUS
+		       : EAZEL_ENGINE_CHECK_PRESSED));
+	    break;
+
+	default:
+	    type = (active
+		    ? (has_focus ? EAZEL_ENGINE_CHECK_ACTIVE_FOCUS
+		       : EAZEL_ENGINE_CHECK_ACTIVE)
+		    : (has_focus ? EAZEL_ENGINE_CHECK_FOCUS
+		       : EAZEL_ENGINE_CHECK));
+	}
+
+	paint_stock_image (theme_data, type + stock_base,
+			   FALSE, FALSE, style, window,
+			   state_type, area, widget,
+			   x-3, y-3, width+6, height+6);
+    }
+    else
+    {
+	if (!active)
+	    return;
+
+	if (stock_base == EAZEL_ENGINE_CHECK)
+	{
+	    paint_tick (window, style->fg_gc[state_type],
+			x + width / 2, y + width / 2);
+	}
+	else
+	{
+	    paint_bullet (window, style->fg_gc[state_type],
+			  x + width / 2, y + width / 2);
+	}
+    }
+}
+
+static void
+draw_check (GtkStyle *style,
+	    GdkWindow *window,
+	    GtkStateType state_type,
+	    GtkShadowType shadow_type,
+	    GdkRectangle *area,
+	    GtkWidget *widget,
+	    gchar *detail, gint x, gint y, gint width, gint height)
+{
+    paint_check (style, window, state_type, shadow_type, area,
+		 widget, detail, x, y, width, height, EAZEL_ENGINE_CHECK);
+}
+
+static void
+draw_option (GtkStyle *style,
+	     GdkWindow *window,
+	     GtkStateType state_type,
+	     GtkShadowType shadow_type,
+	     GdkRectangle *area,
+	     GtkWidget *widget,
+	     gchar *detail, gint x, gint y, gint width, gint height)
+{
+    paint_check (style, window, state_type, shadow_type, area,
+		 widget, detail, x, y, width, height, EAZEL_ENGINE_OPTION);
+}
+
+static void
+draw_cross (GtkStyle *style,
+	    GdkWindow *window,
+	    GtkStateType state_type,
+	    GtkShadowType shadow_type,
+	    GdkRectangle *area,
+	    GtkWidget *widget,
+	    gchar *detail, gint x, gint y, gint width, gint height)
+{
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+}
+
+static void
+draw_ramp (GtkStyle *style,
+	   GdkWindow *window,
+	   GtkStateType state_type,
+	   GtkShadowType shadow_type,
+	   GdkRectangle *area,
+	   GtkWidget *widget,
+	   gchar *detail,
+	   GtkArrowType arrow_type, gint x, gint y, gint width, gint height)
+{
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+}
+
+static void
+draw_tab (GtkStyle *style,
+	  GdkWindow *window,
+	  GtkStateType state_type,
+	  GtkShadowType shadow_type,
+	  GdkRectangle *area,
+	  GtkWidget *widget,
+	  gchar *detail, gint x, gint y, gint width, gint height)
+{
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    gtk_paint_box (style, window, state_type, shadow_type, area, widget,
+		   detail, x, y, width, height);
+}
+
+static void
+draw_shadow_gap (GtkStyle *style,
+		 GdkWindow *window,
+		 GtkStateType state_type,
+		 GtkShadowType shadow_type,
+		 GdkRectangle *area,
+		 GtkWidget *widget,
+		 gchar *detail,
+		 gint x,
+		 gint y,
+		 gint width,
+		 gint height,
+		 GtkPositionType gap_side, gint gap_x, gint gap_width)
+{
+    GdkRectangle rect;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_shadow_gap: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    gtk_paint_shadow (style, window, state_type, shadow_type, area, widget,
+		      detail, x, y, width, height);
+
+    switch (gap_side)
+    {
+    case GTK_POS_TOP:
+	rect.x = x + gap_x;
+	rect.y = y;
+	rect.width = gap_width;
+	rect.height = 2;
+	break;
+    case GTK_POS_BOTTOM:
+	rect.x = x + gap_x;
+	rect.y = y + height - 2;
+	rect.width = gap_width;
+	rect.height = 2;
+	break;
+    case GTK_POS_LEFT:
+	rect.x = x;
+	rect.y = y + gap_x;
+	rect.width = 2;
+	rect.height = gap_width;
+	break;
+    case GTK_POS_RIGHT:
+	rect.x = x + width - 2;
+	rect.y = y + gap_x;
+	rect.width = 2;
+	rect.height = gap_width;
+	break;
+    }
+
+    gtk_style_apply_default_pixmap (style, window, state_type, area,
+				    rect.x, rect.y, rect.width, rect.height);
+}
+
+static void
+draw_box_gap (GtkStyle *style,
+	      GdkWindow *window,
+	      GtkStateType state_type,
+	      GtkShadowType shadow_type,
+	      GdkRectangle *area,
+	      GtkWidget *widget,
+	      gchar *detail,
+	      gint x,
+	      gint y,
+	      gint width,
+	      gint height,
+	      GtkPositionType gap_side, gint gap_x, gint gap_width)
+{
+    GdkRectangle rect;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_box_gap: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    gtk_paint_box (style, window, state_type, shadow_type, area, widget,
+		   detail, x, y, width, height);
+
+    /* XXX Eavel hack to prevent a hole being draw when the
+       XXX active tab is on the far left */
+    if (gap_x < 1)
+    {
+	gap_width -= (1 - gap_x);
+	gap_x = 1;
+    }
+
+    switch (gap_side)
+    {
+    case GTK_POS_TOP:
+	rect.x = x + gap_x;
+	rect.y = y;
+	rect.width = gap_width;
+	rect.height = 2;
+	break;
+    case GTK_POS_BOTTOM:
+	rect.x = x + gap_x;
+	rect.y = y + height - 2;
+	rect.width = gap_width;
+	rect.height = 2;
+	break;
+    case GTK_POS_LEFT:
+	rect.x = x;
+	rect.y = y + gap_x;
+	rect.width = 2;
+	rect.height = gap_width;
+	break;
+    case GTK_POS_RIGHT:
+	rect.x = x + width - 2;
+	rect.y = y + gap_x;
+	rect.width = 2;
+	rect.height = gap_width;
+	break;
+    }
+
+    gtk_style_apply_default_pixmap (style, window, state_type, area,
+				    rect.x, rect.y, rect.width, rect.height);
+}
+
+static void
+draw_extension (GtkStyle *style,
+		GdkWindow *window,
+		GtkStateType state_type,
+		GtkShadowType shadow_type,
+		GdkRectangle *area,
+		GtkWidget *widget,
+		gchar *detail,
+		gint x,
+		gint y, gint width, gint height, GtkPositionType gap_side)
+{
+    GdkRectangle rect;
+
+    eazel_theme_data *theme_data;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    debug ("draw_extension: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+
+    if (DETAIL ("tab"))
+    {
+	eazel_engine_stock_image type = 0;
+	switch (gap_side)
+	{
+	case GTK_POS_TOP:
+	    type = ((state_type != GTK_STATE_ACTIVE)
+		    ? EAZEL_ENGINE_TAB_BOTTOM_ACTIVE
+		    : (x < 10) ? EAZEL_ENGINE_TAB_BOTTOM_LEFT
+		    : EAZEL_ENGINE_TAB_BOTTOM);
+	    break;
+
+	case GTK_POS_BOTTOM:
+	    type = ((state_type != GTK_STATE_ACTIVE)
+		    ? EAZEL_ENGINE_TAB_TOP_ACTIVE
+		    : (x < 10) ? EAZEL_ENGINE_TAB_TOP_LEFT
+		    : EAZEL_ENGINE_TAB_TOP);
+	    break;
+
+	default:			/* gcc drugging */
+	}
+	paint_background_area (style, window, state_type, area,
+			       x, y, width, height);
+	if (type != 0)
+	{
+	    paint_stock_image (theme_data, type, TRUE, FALSE, style, window,
+			       state_type, area, widget, x, y, width, height);
+	    return;
+	}
+    }
+
+    gtk_paint_box (style, window, state_type, shadow_type, area, widget,
+		   detail, x, y, width, height);
+
+    switch (gap_side)
+    {
+    case GTK_POS_TOP:
+	rect.x = x + style->klass->xthickness;
+	rect.y = y;
+	rect.width = width - style->klass->xthickness * 2;
+	rect.height = style->klass->ythickness;
+	break;
+    case GTK_POS_BOTTOM:
+	rect.x = x + style->klass->xthickness;
+	rect.y = y + height - style->klass->ythickness;
+	rect.width = width - style->klass->xthickness * 2;
+	rect.height = style->klass->ythickness;
+	break;
+    case GTK_POS_LEFT:
+	rect.x = x;
+	rect.y = y + style->klass->ythickness;
+	rect.width = style->klass->xthickness;
+	rect.height = height - style->klass->ythickness * 2;
+	break;
+    case GTK_POS_RIGHT:
+	rect.x = x + width - style->klass->xthickness;
+	rect.y = y + style->klass->ythickness;
+	rect.width = style->klass->xthickness;
+	rect.height = height - style->klass->ythickness * 2;
+	break;
+    }
+
+    gtk_style_apply_default_pixmap (style, window, state_type, area,
+				    rect.x, rect.y, rect.width, rect.height);
+}
+
+static void
+draw_focus (GtkStyle *style,
+	    GdkWindow *window,
+	    GdkRectangle *area,
+	    GtkWidget *widget,
+	    gchar *detail, gint x, gint y, gint width, gint height)
+{
+    eazel_theme_data *theme_data;
+    gboolean rounded = TRUE, rounded_inner = TRUE;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    debug ("draw_focus: detail=%s x=%d y=%d w=%d h=%d\n",
+	    detail, x, y, width, height);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+    g_return_if_fail (width >= -1);
+    g_return_if_fail (height >= -1);
+
+    if ((DETAIL ("button") && widget != 0
+	 && GTK_IS_BUTTON (widget) && GTK_WIDGET_HAS_DEFAULT (widget))
+	|| DETAIL ("checkbutton") || DETAIL ("option") || DETAIL ("slider")
+	|| (widget != 0 && GTK_IS_SCALE (widget))
+	/* XXX reenable me */
+	|| DETAIL ("tab"))
+    {
+	return;
+    }
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    if (area)
+	gdk_gc_set_clip_rectangle (style->black_gc, area);
+
+    if (DETAIL ("button"))
+    {
+	x--; y--;
+	width += 2; height += 2;
+    }
+    else if (DETAIL ("text") || DETAIL ("entry"))
+    {
+	rounded_inner = FALSE;
+    }
+
+    paint_focus_box (theme_data, window, style->black_gc,
+		     rounded, rounded_inner, theme_data->focus_thickness,
+		     x, y, width, height);
+
+    if (area)
+	gdk_gc_set_clip_rectangle (style->black_gc, NULL);
+}
+
+static void
+draw_slider (GtkStyle *style,
+	     GdkWindow *window,
+	     GtkStateType state_type,
+	     GtkShadowType shadow_type,
+	     GdkRectangle *area,
+	     GtkWidget *widget,
+	     gchar *detail,
+	     gint x,
+	     gint y, gint width, gint height, GtkOrientation orientation)
+{
+    eazel_theme_data *theme_data;
+    gboolean focused;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    debug ("draw_slider: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+    g_return_if_fail (width >= -1);
+    g_return_if_fail (height >= -1);
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    if (area)
+	gdk_gc_set_clip_rectangle (style->black_gc, area);
+
+    focused = (widget != 0) && eazel_engine_widget_in_focused_window_p (widget);
+    paint_stock_image (theme_data,
+		       orientation == GTK_ORIENTATION_HORIZONTAL
+		       ? (focused ? EAZEL_ENGINE_H_SLIDER_THUMB
+			  : EAZEL_ENGINE_H_SLIDER_THUMB_INACTIVE)
+		       : (focused ? EAZEL_ENGINE_V_SLIDER_THUMB
+			  : EAZEL_ENGINE_V_SLIDER_THUMB_INACTIVE),
+		       TRUE, TRUE, style, window, state_type,
+		       area, widget, x, y, width, height);
+    if (area)
+	gdk_gc_set_clip_rectangle (style->black_gc, NULL);
+}
+
+static void
+draw_handle (GtkStyle *style,
+	     GdkWindow *window,
+	     GtkStateType state_type,
+	     GtkShadowType shadow_type,
+	     GdkRectangle *area,
+	     GtkWidget *widget,
+	     gchar *detail,
+	     gint x,
+	     gint y, gint width, gint height, GtkOrientation orientation)
+{
+    gint i, yy, xx;
+    gint xthick, ythick;
+    GdkGC *light_gc, *dark_gc;
+    GdkRectangle dest;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_handle: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	   detail, state_type, shadow_type, x, y, width, height);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+    g_return_if_fail (width >= -1);
+    g_return_if_fail (height >= -1);
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    if (DETAIL ("dockitem") && state_type == GTK_STATE_NORMAL)
+	state_type = GTK_STATE_ACTIVE;
+
+    gtk_paint_box (style, window, state_type, shadow_type, area, widget,
+		   detail, x, y, width, height);
+
+    light_gc = style->light_gc[state_type];
+    dark_gc = style->dark_gc[state_type];
+
+    xthick = style->klass->xthickness;
+    ythick = style->klass->ythickness;
+
+    dest.x = x + xthick;
+    dest.y = y + ythick;
+    dest.width = width - (xthick * 2);
+    dest.height = height - (ythick * 2);
+
+    gdk_gc_set_clip_rectangle (light_gc, &dest);
+    gdk_gc_set_clip_rectangle (dark_gc, &dest);
+
+    /* ORIENTATION parameters is unreliable */
+    if (height > width)
+    {
+	yy = y + height / 2 - 5;
+	for (i = 0; i < 10; i += 2)
+	{
+	    gdk_draw_line (window, dark_gc, xthick, yy + i,
+			   x + width - xthick, yy + i);
+	    gdk_draw_line (window, light_gc, xthick, yy + i + 1,
+			   x + width - xthick, yy + i + 1);
+	}
+    }
+    else
+    {
+	xx = x + width / 2 - 5;
+	for (i = 0; i < 10; i += 2)
+	{
+	    gdk_draw_line (window, dark_gc, xx + i, ythick,
+			   xx + i, y + height - ythick);
+	    gdk_draw_line (window, light_gc, xx + i + 1, ythick,
+			   xx + i + 1, y + height - ythick);
+	}
+    }
+
+    gdk_gc_set_clip_rectangle (light_gc, NULL);
+    gdk_gc_set_clip_rectangle (dark_gc, NULL);
+}
+
+
+/*
+ * class struct 
+ */
+
+GtkStyleClass eazel_class_0 = {
+    0, 0,
+    draw_hline,
+    draw_vline,
+    draw_shadow,
+    draw_polygon,
+    draw_arrow,
+    draw_diamond,
+    draw_oval,
+    draw_string,
+    draw_box,
+    draw_flat_box,
+    draw_check,
+    draw_option,
+    draw_cross,
+    draw_ramp,
+    draw_tab,
+    draw_shadow_gap,
+    draw_box_gap,
+    draw_extension,
+    draw_focus,
+    draw_slider,
+    draw_handle
+};
+
+GtkStyleClass eazel_class_1 = {
+    1, 1,
+    draw_hline,
+    draw_vline,
+    draw_shadow,
+    draw_polygon,
+    draw_arrow,
+    draw_diamond,
+    draw_oval,
+    draw_string,
+    draw_box,
+    draw_flat_box,
+    draw_check,
+    draw_option,
+    draw_cross,
+    draw_ramp,
+    draw_tab,
+    draw_shadow_gap,
+    draw_box_gap,
+    draw_extension,
+    draw_focus,
+    draw_slider,
+    draw_handle
+};
+
+GtkStyleClass eazel_class_2 = {
+    2, 2,
+    draw_hline,
+    draw_vline,
+    draw_shadow,
+    draw_polygon,
+    draw_arrow,
+    draw_diamond,
+    draw_oval,
+    draw_string,
+    draw_box,
+    draw_flat_box,
+    draw_check,
+    draw_option,
+    draw_cross,
+    draw_ramp,
+    draw_tab,
+    draw_shadow_gap,
+    draw_box_gap,
+    draw_extension,
+    draw_focus,
+    draw_slider,
+    draw_handle
+};
+
+GtkStyleClass eazel_class_3 = {
+    3, 3,
+    draw_hline,
+    draw_vline,
+    draw_shadow,
+    draw_polygon,
+    draw_arrow,
+    draw_diamond,
+    draw_oval,
+    draw_string,
+    draw_box,
+    draw_flat_box,
+    draw_check,
+    draw_option,
+    draw_cross,
+    draw_ramp,
+    draw_tab,
+    draw_shadow_gap,
+    draw_box_gap,
+    draw_extension,
+    draw_focus,
+    draw_slider,
+    draw_handle
+};
+
diff --git a/eazel-engine/src/eazel-theme-draw.c.dim b/eazel-engine/src/eazel-theme-draw.c.dim
new file mode 100644
index 0000000..6062b22
--- /dev/null
+++ b/eazel-engine/src/eazel-theme-draw.c.dim
@@ -0,0 +1,2342 @@
+/* eazel-theme-draw.c -- replacement drawing `primitives'
+
+   Copyright (C) 2000 Eazel, Inc.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program 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
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   $Id: eazel-theme-draw.c,v 1.21 2001/05/23 04:56:34 jsh Exp $
+
+   Authors: The Rasterman <raster@redhat.com>
+            Owen Taylor <otaylor@redhat.com>
+	    John Harper <jsh@eazel.com>   */
+
+/* Adapted from gtk-engines/notif/notif_theme_draw.c
+
+   Repeat after me: ``the implementation is unimportant, the only thing
+   that matters is the user-experience'' */
+
+#include "eazel-theme.h"
+#include <math.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+
+#define DEBUG 0
+
+#define DETAIL(xx) ((detail) != 0 && strcmp (xx, detail) == 0)
+
+
+/* utility functions */
+
+static inline void
+debug (const char *fmt, ...)
+{
+    if (DEBUG)
+    {
+	va_list args;
+	va_start (args, fmt);
+	vfprintf (stderr, fmt, args);
+	va_end (args);
+    }
+}
+
+/* adapted from nautilus-gdk-extensions.c */
+static void
+interpolate_color (GdkColor *dest, gdouble ratio,
+		   GdkColor *start, GdkColor *end)
+{
+	g_return_if_fail (ratio >= 0.0);
+	g_return_if_fail (ratio <= 1.0);
+
+	dest->red = start->red * (1.0 - ratio) + (end->red & 0xFF) * ratio;
+	dest->green = start->green * (1.0 - ratio) + end->green * ratio;
+	dest->blue = start->blue * (1.0 - ratio) + end->blue * ratio;
+}
+
+static void
+paint_background_area (GtkStyle *style,
+		       GdkWindow *window,
+		       GtkStateType state_type,
+		       GdkRectangle *area,
+		       int x, int y, int width, int height)
+{
+    GdkGC *gc = style->bg_gc[GTK_STATE_NORMAL];
+
+    if (area != 0)
+	gdk_gc_set_clip_rectangle (gc, area);
+
+    gdk_draw_rectangle (window, gc, TRUE, x, y, width, height);
+
+    if (area != 0)
+	gdk_gc_set_clip_rectangle (gc, 0);
+}
+
+static void
+paint_stock_image (eazel_theme_data *theme_data,
+		   eazel_engine_stock_image type,
+		   gboolean scaled, gboolean setbg,
+		   GtkStyle *style,
+		   GdkWindow *window,
+		   GtkStateType state_type,
+		   GdkRectangle *area,
+		   GtkWidget *widget,
+		   gint x, gint y, gint width, gint height)
+{
+    GdkPixmap *pixmap, *mask;
+
+    if (width == -1 || height == -1)
+    {
+	eazel_engine_stock_get_size (theme_data->stock, type,
+				     width == -1 ? &width : 0,
+				     height == -1 ? &height : 0);
+    }
+
+    if (scaled)
+    {
+	eazel_engine_stock_pixmap_and_mask_scaled (theme_data->stock, type,
+						   width, height,
+						   &pixmap, &mask);
+    }
+    else
+	eazel_engine_stock_pixmap_and_mask (theme_data->stock, type,
+					    &pixmap, &mask);
+
+    if (gdk_window_get_type (window) == GDK_WINDOW_PIXMAP)
+	setbg = FALSE;
+
+    if (setbg)
+    {
+	gdk_draw_pixmap (window, style->fg_gc[state_type], pixmap,
+			 0, 0, x, y, width, height);
+	if (mask != 0)
+	    gdk_window_shape_combine_mask (window, mask, 0, 0);
+    }
+    else
+    {
+	int xsrc = 0, ysrc = 0;
+
+	/* Install the mask before clipping.. */
+	if (mask != 0)
+	{
+	    gdk_gc_set_clip_mask (style->fg_gc[state_type], mask);
+	    gdk_gc_set_clip_origin (style->fg_gc[state_type], x, y);
+	}
+
+	if (area != 0)
+	{
+	    /* clip by hand to leave gc's clipping for the possible mask */
+	    GdkRectangle src = { x, y, width, height }, dest;
+
+	    if (!gdk_rectangle_intersect (&src, area, &dest))
+		return;
+
+	    xsrc -= x - dest.x;
+	    ysrc -= y - dest.y;
+	    x = dest.x;
+	    y = dest.y;
+	    width = dest.width;
+	    height = dest.height;
+
+	}
+
+	if (width > 0 && height > 0)
+	{
+	    gdk_draw_pixmap (window, style->fg_gc[state_type], pixmap,
+			     xsrc, ysrc, x, y, width, height);
+	} 
+
+	if (mask != 0)
+	{
+	    gdk_gc_set_clip_mask (style->fg_gc[state_type], 0);
+	    gdk_gc_set_clip_origin (style->fg_gc[state_type], 0, 0);
+	}
+   }
+    
+    eazel_engine_stock_free_pixmaps (theme_data->stock, type, pixmap, mask);
+}
+
+static void
+paint_outline (GdkWindow *window, GdkGC *gc, gboolean rounded,
+	       int x, int y, int width, int height)
+{
+    int corner = rounded ? 1 : 0;
+
+    /* left and top outermost */
+    gdk_draw_line (window, gc, x, y + corner,
+		   x, y + height - (corner + 1));
+    gdk_draw_line (window, gc, x + corner, y, x + width - (corner + 1), y);
+
+    /* right and bottom outermost */
+    gdk_draw_line (window, gc, x + width - 1, y + corner,
+		   x + width - 1, y + height - (corner + 1));
+    gdk_draw_line (window, gc, x + corner, y + height - 1,
+		   x + width - (corner + 1), y + height - 1);
+}
+
+static void
+paint_shadow (GdkWindow *window, GdkGC *a, GdkGC *b, GdkGC *c, GdkGC *d,
+	      gboolean rounded, int x, int y, int width, int height)
+{
+    int corner = rounded ? 1 : 0;
+
+    if (a != 0)
+    {
+	/* left and top outermost */
+	gdk_draw_line (window, a, x, y + corner,
+		       x, y + height - (corner + 1));
+	gdk_draw_line (window, a, x + corner, y, x + width - (corner + 1), y);
+    }
+
+    if (d != 0)
+    {
+	/* right and bottom outermost */
+	gdk_draw_line (window, d, x + width - 1, y + corner,
+		       x + width - 1, y + height - (corner + 1));
+	gdk_draw_line (window, d, x + corner, y + height - 1,
+		       x + width - (corner + 1), y + height - 1);
+    }
+
+    if (b != 0)
+    {
+	/* left and top inner */
+	gdk_draw_line (window, b, x + 1, y + 2, x + 1, y + height - 2);
+	gdk_draw_line (window, b, x + 1, y + 1, x + width - 2, y + 1);
+    }
+
+    if (c != 0)
+    {
+	/* right and bottom outermost */
+	gdk_draw_line (window, c, x + width - 2, y + 1,
+		       x + width - 2, y + height - 2);
+	gdk_draw_line (window, c, x + 1, y + height - 2,
+		       x + width - 2, y + height - 2);
+    }
+}
+
+static void
+paint_entry_shadow (GdkWindow *window, GtkStyle *style,
+		    GtkStateType state_type,
+		    int x, int y, int width, int height)
+{
+    gdk_draw_rectangle (window, style->black_gc, FALSE,
+			x + 1, y + 1, width - 3, height - 3);
+
+    gdk_draw_line (window, style->dark_gc[state_type],
+		   x, y, x + width - 1, y);
+    gdk_draw_line (window, style->dark_gc[state_type],
+		   x, y, x, y + height - 1);
+
+    gdk_draw_line (window, style->white_gc,
+		   x + 1, y + height - 1, x + width - 1, y + height - 1);
+    gdk_draw_line (window, style->white_gc,
+		   x + width - 1, y + 1, x + width - 1, y + height - 1);
+
+    gdk_draw_line (window, style->mid_gc[state_type],
+		   x + 2, y + 2, x + width - 3, y + 2);
+    gdk_draw_line (window, style->mid_gc[state_type],
+		   x + 2, y + 2, x + 2, y + height - 3);
+
+    gdk_draw_line (window, style->white_gc,
+		   x + 2, y + height - 3, x + width - 3, y + height - 3);
+    gdk_draw_line (window, style->white_gc,
+		   x + width - 3, y + 2, x + width - 3, y + height - 3);
+}
+
+static void
+paint_menuitem_shadow (GdkWindow *window, GtkStyle *style,
+		       int x, int y, int width, int height)
+{
+    gdk_draw_rectangle (window, style->black_gc, FALSE,
+			x + 2, y + 1, width - 5, height - 3);
+
+    gdk_draw_line (window, style->dark_gc[GTK_STATE_NORMAL],
+		   x + 1, y, x + width - 3, y);
+    gdk_draw_line (window, style->dark_gc[GTK_STATE_NORMAL],
+		   x + 1, y, x + 1, y + height - 2);
+    gdk_draw_line (window, style->white_gc,
+		   x + 2, y + height - 1, x + width - 2, y + height - 1);
+    gdk_draw_line (window, style->white_gc,
+		   x + width - 2, y + 1, x + width - 2, y + height - 1);
+}
+
+static void
+paint_default_highlight (eazel_theme_data *theme_data,
+			 GdkColor *hi_color, GdkColor *bg_color,
+			 GdkWindow *window, GdkGC *gc, int x, int y)
+{
+    GdkColormap *sys_lut = gdk_colormap_get_system ();
+    GdkGCValues old_values;
+    GdkColor spectrum[6];
+    int i;
+
+    gdk_gc_get_values (gc, &old_values);
+
+    /* Calculate pixel colors */
+    for (i = 0; i < 6; i++)
+    {
+	interpolate_color (spectrum + i, 1.0 / 7 * i, hi_color, bg_color);
+    }
+
+#define COLOR(i)							\
+    gdk_colormap_alloc_color (sys_lut, spectrum + i, FALSE, TRUE);	\
+    gdk_gc_set_foreground (gc, spectrum + i);
+
+#define PIXEL(a,b) gdk_draw_point (window, gc, x + a, y + b)
+
+    COLOR (0); PIXEL (2, 2);
+    COLOR (1); PIXEL (3, 2); PIXEL (2, 3); PIXEL (4, 1); PIXEL (1, 4);
+    COLOR (2); PIXEL (5, 1); PIXEL (1, 5);
+    COLOR (3); PIXEL (6, 1); PIXEL (1, 6);
+    COLOR (4); PIXEL (7, 1); PIXEL (1, 7); PIXEL (4, 2); PIXEL (2, 4);
+    COLOR (5); PIXEL (8, 1); PIXEL (1, 8);
+
+#undef PIXEL
+#undef COLOR
+
+    gdk_gc_set_foreground (gc, &old_values.foreground);
+}
+
+static void
+paint_default (eazel_theme_data *theme_data,
+	       GdkWindow *window, GdkGC *gc, GdkColor *bg,
+	       gboolean rounded, gboolean rounded_inner, int thickness,
+	       int x, int y, int width, int height)
+{
+    int corner = rounded ? ((thickness > 2) ? 3 : 1) : 0;
+    int window_width, window_height;
+    int i;
+
+    gdk_window_get_size (window, &window_width, &window_height);
+
+    /* If trying to draw a box that's too big for the dimensions of
+       the window, iteratively reduce the thickness until a value
+       is found that won't draw off the window edges */
+    while (x < 0 || y < 0 || x + width >= window_width
+	   || y + height >= window_height)
+    {
+	if (thickness <= 0 || width <= 0 || height <= 0)
+	    return;
+
+	thickness -= 1;
+	x += 1;
+	y += 1;
+	width -= 2;
+	height -= 2;
+    }
+
+    if (rounded)
+    {
+	/* XXX this doesn't work, the background of the window
+	   XXX is white, not grey */
+	gdk_window_clear_area (window, x, y, 1, 1);
+	gdk_window_clear_area (window, x + width, y, 1, 1);
+	gdk_window_clear_area (window, x, y + height, 1, 1);
+	gdk_window_clear_area (window, x + width, y + height, 1, 1);
+    }
+
+    for (i = 0; i < thickness; i++)
+    {
+	int x_i = x + i;
+	int y_i = y + i;
+	int w_i = width - (i * 2);
+	int h_i = height - (i * 2);
+
+	int d_corner = (corner && i == 0) ? corner : 0;
+
+	gdk_draw_line (window, gc, x_i + d_corner, y_i,
+		       x_i + w_i - d_corner , y_i);
+	gdk_draw_line (window, gc, x_i + w_i, y_i + d_corner,
+		       x_i + w_i, y_i + h_i - d_corner);
+	gdk_draw_line (window, gc, x_i + w_i - d_corner, y_i + h_i,
+		       x_i + d_corner, y_i + h_i);
+	gdk_draw_line (window, gc, x_i, y+i + h_i - d_corner,
+		       x_i, y_i + d_corner);
+    }
+
+    if (rounded_inner)
+    {
+	gdk_draw_point (window, gc, x + thickness, y + thickness);
+	gdk_draw_point (window, gc, x + thickness, y + height - thickness);
+	gdk_draw_point (window, gc, x + width - thickness, y + thickness);
+	gdk_draw_point (window, gc, x + width - thickness, y + height - thickness);
+    }
+
+    if (thickness >= 3 && rounded)
+    {
+	GdkColor white = { 0, 65535, 65535, 65535 };
+	paint_default_highlight (theme_data, &white, bg, window, gc, x, y);
+    }
+}
+
+static void
+paint_default_box (eazel_theme_data *theme_data,
+		   GdkWindow *window, GdkGC *gc,
+		   gboolean rounded, gboolean rounded_inner, int thickness,
+		   int x, int y, int width, int height)
+{
+    GdkColor black = { 0, 0, 0, 0 };
+    paint_default (theme_data, window, gc, &black,
+		   rounded, rounded_inner, thickness,
+		   x, y, width, height);
+}
+
+static void
+paint_focus_box (eazel_theme_data *theme_data, GdkWindow *window,
+		 GdkGC *gc, gboolean rounded, gboolean rounded_inner,
+		 int thickness, int x, int y, int width, int height)
+{
+    GdkColormap *sys_lut = gdk_colormap_get_system ();
+    GdkGCValues old_values;
+    GdkColor color;
+    gdk_gc_get_values (gc, &old_values);
+
+    color = theme_data->focus_color;
+    gdk_colormap_alloc_color (sys_lut, &color, FALSE, TRUE);
+    gdk_gc_set_foreground (gc, &color);
+
+    paint_default (theme_data, window, gc, &color, rounded,
+		   rounded_inner, thickness, x, y, width, height);
+
+    gdk_gc_set_foreground (gc, &old_values.foreground);
+}
+
+static void
+paint_insensitive_box (eazel_theme_data *theme_data,
+		       GdkWindow *window, GdkGC *gc, gboolean rounded,
+		       int x, int y, int width, int height)
+{
+    GdkColormap *sys_lut = gdk_colormap_get_system ();
+    GdkGCValues old_values;
+    GdkColor color;
+    gdk_gc_get_values (gc, &old_values);
+
+    color = theme_data->insensitive_colors[1];
+    gdk_colormap_alloc_color (sys_lut, &color, FALSE, TRUE);
+    gdk_gc_set_foreground (gc, &color);
+    gdk_draw_rectangle (window, gc, TRUE, x, y, width, height);
+
+    color = theme_data->insensitive_colors[0];
+    gdk_colormap_alloc_color (sys_lut, &color, FALSE, TRUE);
+    gdk_gc_set_foreground (gc, &color);
+    paint_default (theme_data, window, gc, &color, rounded,
+		   FALSE, 1, x, y, width - 1, height - 1);
+
+    gdk_gc_set_foreground (gc, &old_values.foreground);
+}
+
+static void
+paint_arrow (GdkWindow *window, GdkGC *gc, GtkArrowType arrow_type,
+	     int x, int y, int width, int height)
+{
+    int half_width, half_height;
+    int center_x, center_y;
+
+    if ((width & 1) == 0)
+	width = width - 1;
+    if ((height & 1) == 0)
+	height = height - 1;
+
+    half_width = width / 2;
+    half_height = height / 2;
+
+    center_x = x + half_width;
+    center_y = y + half_height;
+  
+    switch (arrow_type)
+    {
+	int i;
+	static int offset[5] = { 0, -1, -2, -3, -4 };
+	static int length[5] = { 0, 2, 4, 6, 8 };
+	static const int size = 4;
+
+    case GTK_ARROW_UP:
+	for (i = 0; i < size; i++)
+	{
+	    gdk_draw_line (window, gc,
+			   center_x + offset[i],
+			   center_y - 2 + i,
+			   center_x + offset[i] + length[i],
+			   center_y - 2 + i);
+	}
+	break;
+
+    case GTK_ARROW_DOWN:
+	for (i = 0; i < size; i++)
+	{
+	    gdk_draw_line (window, gc,
+			   center_x + offset[i],
+			   center_y + 2 - i,
+			   center_x + offset[i] + length[i],
+			   center_y + 2 - i);
+	}
+	break;
+
+    case GTK_ARROW_LEFT:
+	for (i = 0; i < size; i++)
+	{
+	    gdk_draw_line (window, gc,
+			   center_x - 2 + i,
+			   center_y + offset[i],
+			   center_x - 2 + i,
+			   center_y + offset[i] + length[i]);
+	}
+	break;
+
+    case GTK_ARROW_RIGHT:
+	for (i = 0; i < size; i++)
+	{
+	    gdk_draw_line (window, gc,
+			   center_x + 2 - i,
+			   center_y + offset[i],
+			   center_x + 2 - i,
+			   center_y + offset[i] + length[i]);
+	}
+	break;
+    }
+}
+
+static void
+paint_tick (GdkWindow *window, GdkGC *gc, int x, int y)
+{
+#define PIXEL(a,b) gdk_draw_point (window, gc, x + a, y + b)
+
+    PIXEL (4, -4);
+    PIXEL (3, -3); PIXEL (4, -3); PIXEL (5, -3);
+    PIXEL (-2, -2);
+    PIXEL (2, -2); PIXEL (3, -2); PIXEL (4, -2);
+    PIXEL (-3, -1); PIXEL (-2, -1); PIXEL (-1, -1);
+    PIXEL (1, -1); PIXEL (2, -1); PIXEL (3, -1);
+    PIXEL (-2, 0); PIXEL (-1, 0); PIXEL (0, 0); PIXEL (1, 0); PIXEL (2, 0);
+    PIXEL (-1, 1); PIXEL (0, 1); PIXEL (1, 1);
+    PIXEL (0, 2);
+
+#undef PIXEL
+}
+
+static void
+paint_bullet (GdkWindow *window, GdkGC *gc, int x, int y)
+{
+#define PIXEL(a, b) gdk_draw_point (window, gc, x + a, x + b)
+
+    PIXEL (0, 0); PIXEL (0, -1); PIXEL (-1, 0); PIXEL (-1, -1);
+    PIXEL (1, -1); PIXEL (2, -1); PIXEL (-1, 1); PIXEL (-1, 2);
+
+    PIXEL (0, -2); PIXEL (1, -2);
+    PIXEL (-2, 0); PIXEL (-2, 1);
+    PIXEL (1, 0); PIXEL (2, 0); PIXEL (3, 0);
+    PIXEL (0, 1); PIXEL (1, 1); PIXEL (2, 1); PIXEL (3, 1);
+    PIXEL (0, 2); PIXEL (1, 2); PIXEL (2, 2);
+    PIXEL (0, 3); PIXEL (1, 3);
+
+    PIXEL (-1, -2); PIXEL (-2, -1); PIXEL (2, -2); PIXEL (3, -1);
+    PIXEL (-2, 2); PIXEL (-1, 3); PIXEL (2, 3); PIXEL (3, 2);
+
+#undef PIXEL
+}
+
+
+/* style functions */
+
+static void
+draw_hline (GtkStyle *style,
+	    GdkWindow *window,
+	    GtkStateType state_type,
+	    GdkRectangle *area,
+	    GtkWidget *widget,
+	    gchar *detail,
+	    gint x1, gint x2, gint y)
+{
+    gint thickness_light;
+    gint thickness_dark;
+    gint i;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_hline: detail=%s state=%d x1=%d x2=%d y=%d\n",
+	    detail, state_type, x1, x2, y);
+
+    thickness_light = style->klass->ythickness / 2;
+    thickness_dark = style->klass->ythickness - thickness_light;
+
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
+	gdk_gc_set_clip_rectangle (style->dark_gc[state_type], area);
+    }
+    for (i = 0; i < thickness_dark; i++)
+    {
+	gdk_draw_line (window, style->light_gc[state_type], x2 - i - 1,
+		       y + i, x2, y + i);
+	gdk_draw_line (window, style->dark_gc[state_type], x1, y + i,
+		       x2 - i - 1, y + i);
+    }
+
+    y += thickness_dark;
+    for (i = 0; i < thickness_light; i++)
+    {
+	gdk_draw_line (window, style->dark_gc[state_type], x1, y + i,
+		       x1 + thickness_light - i - 1, y + i);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x1 + thickness_light - i - 1, y + i, x2, y + i);
+    }
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
+	gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
+    }
+}
+
+static void
+draw_vline (GtkStyle *style,
+	    GdkWindow *window,
+	    GtkStateType state_type,
+	    GdkRectangle *area,
+	    GtkWidget *widget, gchar *detail, gint y1, gint y2, gint x)
+{
+    gint thickness_light;
+    gint thickness_dark;
+    gint i;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_vline: detail=%s state=%d x=%d y1=%d y2=%d\n",
+	    detail, state_type, x, y1, y2);
+
+    thickness_light = style->klass->xthickness / 2;
+    thickness_dark = style->klass->xthickness - thickness_light;
+
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
+	gdk_gc_set_clip_rectangle (style->dark_gc[state_type], area);
+    }
+    for (i = 0; i < thickness_dark; i++)
+    {
+	gdk_draw_line (window, style->light_gc[state_type], x + i,
+		       y2 - i - 1, x + i, y2);
+	gdk_draw_line (window, style->dark_gc[state_type], x + i, y1, x + i,
+		       y2 - i - 1);
+    }
+
+    x += thickness_dark;
+    for (i = 0; i < thickness_light; i++)
+    {
+	gdk_draw_line (window, style->dark_gc[state_type], x + i, y1, x + i,
+		       y1 + thickness_light - i);
+	gdk_draw_line (window, style->light_gc[state_type], x + i,
+		       y1 + thickness_light - i, x + i, y2);
+    }
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
+	gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
+    }
+}
+
+static void
+draw_shadow (GtkStyle *style,
+	     GdkWindow *window,
+	     GtkStateType state_type,
+	     GtkShadowType shadow_type,
+	     GdkRectangle *area,
+	     GtkWidget *widget,
+	     gchar *detail, gint x, gint y, gint width, gint height)
+{
+    GdkGC *gc1 = NULL;
+    GdkGC *gc2 = NULL;
+    GdkGC *gc3 = NULL;
+    GdkGC *gc4 = NULL;
+    GdkGC *gc_a, *gc_b, *gc_c, *gc_d;
+    gint thickness_light;
+    gint thickness_dark;
+    gboolean rounded = FALSE, rounded_inner = FALSE;
+    gboolean outline = TRUE;
+    gint i;
+
+    eazel_theme_data *theme_data;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    outline = theme_data->outline_shadow;
+
+    if (widget != 0 && !GTK_WIDGET_IS_SENSITIVE (widget))
+	state_type = GTK_STATE_INSENSITIVE;
+
+    debug ("draw_shadow: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    switch (shadow_type)
+    {
+    case GTK_SHADOW_NONE:
+	return;
+    case GTK_SHADOW_IN:
+    case GTK_SHADOW_ETCHED_IN:
+	if (theme_data->inverse_shadow)
+	    goto out;
+    in:
+	gc1 = style->light_gc[state_type];
+	gc2 = style->dark_gc[state_type];
+	gc3 = style->mid_gc[state_type];
+	gc4 = style->bg_gc[state_type];
+	break;
+    case GTK_SHADOW_OUT:
+    case GTK_SHADOW_ETCHED_OUT:
+	if (theme_data->inverse_shadow)
+	    goto in;
+    out:
+	gc1 = style->dark_gc[state_type];
+	gc2 = style->light_gc[state_type];
+	gc3 = style->mid_gc[state_type];
+	gc4 = style->bg_gc[state_type];
+	break;
+    }
+
+    gc_a = gc2;
+    gc_b = gc4;
+    gc_c = 0;
+    gc_d = gc1;
+
+    if (DETAIL ("button") || DETAIL ("optionmenu"))
+    {
+	/* Clist title buttons have square edges */
+	if (widget == 0 || !GTK_IS_CLIST (widget->parent))
+	    rounded = rounded_inner = TRUE;
+    }
+    else if (DETAIL ("menuitem"))
+    {
+	paint_menuitem_shadow (window, style, x, y, width, height);
+	return;
+    }
+    else if (DETAIL ("entry") || DETAIL ("text"))
+    {
+	if (widget == 0 || GTK_WIDGET_IS_SENSITIVE (widget))
+	{
+	    paint_entry_shadow (window, style, state_type,
+				x, y, width, height);
+	    return;
+	}
+    }
+    else if (DETAIL ("spinbutton"))
+    {
+	gc_a = gc2;
+	gc_b = 0;
+	outline = FALSE;
+    }
+
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (gc1, area);
+	gdk_gc_set_clip_rectangle (gc2, area);
+	gdk_gc_set_clip_rectangle (gc3, area);
+	gdk_gc_set_clip_rectangle (gc4, area);
+	if ((shadow_type == GTK_SHADOW_IN) || (shadow_type == GTK_SHADOW_OUT))
+	{
+	    gdk_gc_set_clip_rectangle (style->black_gc, area);
+	    gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
+	}
+    }
+    switch (shadow_type)
+    {
+    case GTK_SHADOW_NONE:
+	break;
+
+    case GTK_SHADOW_IN:
+    case GTK_SHADOW_OUT:
+	if (state_type == GTK_STATE_INSENSITIVE)
+	{
+	    paint_insensitive_box (theme_data, window,
+				   style->bg_gc[state_type],
+				   rounded, x, y, width, height);
+	}
+	else if (outline)
+	{
+	    paint_outline (window, style->black_gc, rounded,
+			   x, y, width, height);
+	    if (!theme_data->no_shadow)
+	    {
+		paint_shadow (window, gc_a, gc_b, gc_c, gc_d, rounded,
+			      x + 1, y + 1, width - 2, height - 2);
+	    }
+	}
+	else
+	{
+	    if (!theme_data->no_shadow)
+	    {
+		paint_shadow (window, gc_a, gc_b, gc_c, gc_d, rounded,
+			      x, y, width, height);
+	    }
+	}
+	break;
+
+    case GTK_SHADOW_ETCHED_IN:
+    case GTK_SHADOW_ETCHED_OUT:
+	thickness_light = 1;
+	thickness_dark = 1;
+
+	for (i = 0; i < thickness_dark; i++)
+	{
+	    gdk_draw_line (window, gc1,
+			   x + i,
+			   y + height - i - 1,
+			   x + width - i - 1, y + height - i - 1);
+	    gdk_draw_line (window, gc1,
+			   x + width - i - 1,
+			   y + i, x + width - i - 1, y + height - i - 1);
+
+	    gdk_draw_line (window, gc2,
+			   x + i, y + i, x + width - i - 2, y + i);
+	    gdk_draw_line (window, gc2,
+			   x + i, y + i, x + i, y + height - i - 2);
+	}
+
+	for (i = 0; i < thickness_light; i++)
+	{
+	    gdk_draw_line (window, gc1,
+			   x + thickness_dark + i,
+			   y + thickness_dark + i,
+			   x + width - thickness_dark - i - 1,
+			   y + thickness_dark + i);
+	    gdk_draw_line (window, gc1,
+			   x + thickness_dark + i,
+			   y + thickness_dark + i,
+			   x + thickness_dark + i,
+			   y + height - thickness_dark - i - 1);
+
+	    gdk_draw_line (window, gc2,
+			   x + thickness_dark + i,
+			   y + height - thickness_light - i - 1,
+			   x + width - thickness_light - 1,
+			   y + height - thickness_light - i - 1);
+	    gdk_draw_line (window, gc2,
+			   x + width - thickness_light - i - 1,
+			   y + thickness_dark + i,
+			   x + width - thickness_light - i - 1,
+			   y + height - thickness_light - 1);
+	}
+	break;
+    }
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (gc1, NULL);
+	gdk_gc_set_clip_rectangle (gc2, NULL);
+	gdk_gc_set_clip_rectangle (gc3, NULL);
+	gdk_gc_set_clip_rectangle (gc4, NULL);
+	if ((shadow_type == GTK_SHADOW_IN) || (shadow_type == GTK_SHADOW_OUT))
+	{
+	    gdk_gc_set_clip_rectangle (style->black_gc, NULL);
+	    gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
+	}
+    }
+}
+
+static void
+draw_box (GtkStyle *style,
+	  GdkWindow *window,
+	  GtkStateType state_type,
+	  GtkShadowType shadow_type,
+	  GdkRectangle *area,
+	  GtkWidget *widget,
+	  gchar *detail, gint x, gint y, gint width, gint height)
+{
+    gboolean add_shadow = FALSE;
+    eazel_theme_data *theme_data;
+    gboolean set_bg = FALSE;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+
+    if ((width == -1) && (height == -1))
+    {
+	gdk_window_get_size (window, &width, &height);
+	if (gdk_window_get_type (window) != GDK_WINDOW_PIXMAP)
+	    set_bg = TRUE;
+    }
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    if (widget != 0 && !GTK_WIDGET_IS_SENSITIVE (widget))
+	state_type = GTK_STATE_INSENSITIVE;
+
+    debug ("draw_box: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    if ((!style->bg_pixmap[state_type]) ||
+	(gdk_window_get_type (window) == GDK_WINDOW_PIXMAP))
+    {
+	if (area)
+	{
+	    gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
+	    gdk_gc_set_clip_rectangle (style->fg_gc[state_type], area);
+	    gdk_gc_set_clip_rectangle (style->dark_gc[state_type], area);
+	    gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
+	    gdk_gc_set_clip_rectangle (style->black_gc, area);
+	}
+
+	if (DETAIL ("trough"))
+	{
+	    if (GTK_IS_PROGRESS_BAR (widget))
+	    {
+		if (state_type != GTK_STATE_INSENSITIVE)
+		{
+		    paint_stock_image (theme_data,
+				       EAZEL_ENGINE_PROGRESS_TROUGH,
+				       TRUE, FALSE,
+				       style, window, state_type, area,
+				       widget, x, y, width, height);
+		}
+		else
+		{
+		    paint_insensitive_box (theme_data, window,
+					   style->fg_gc[state_type],
+					   FALSE, x, y, width, height);
+		}
+	    }
+	    else if (GTK_IS_SCALE (widget))
+	    {
+		gboolean focused = GTK_WIDGET_HAS_FOCUS (widget);
+		paint_background_area (style, window, state_type, area,
+				       x, y, width, height);
+		paint_stock_image (theme_data,
+				   width > height
+				   ? (focused
+				      ? EAZEL_ENGINE_H_SLIDER_TROUGH_ACTIVE
+				      : EAZEL_ENGINE_H_SLIDER_TROUGH)
+				   : (focused
+				      ? EAZEL_ENGINE_V_SLIDER_TROUGH_ACTIVE
+				      : EAZEL_ENGINE_V_SLIDER_TROUGH),
+				   TRUE, FALSE, style, window, state_type,
+				   area, widget, x, y, width, height);
+	    }
+	    else
+	    {
+		paint_stock_image (theme_data,
+				   width > height ? EAZEL_ENGINE_H_TROUGH
+				   : EAZEL_ENGINE_V_TROUGH, TRUE, FALSE,
+				   style, window, state_type, area,
+				   widget, x, y, width, height);
+	    }
+	}
+	else if (DETAIL ("slider"))
+	{
+	    int thumb_x, thumb_y;
+	    gboolean focused;
+
+	    focused = eazel_engine_widget_in_focused_window_p (widget);
+
+	    /* XXX could be a gradient? */
+	    paint_stock_image (theme_data,
+			       width > height
+			       ? (state_type == GTK_STATE_PRELIGHT
+				  ? EAZEL_ENGINE_H_SCROLLBAR_HI
+				  : !focused
+				  ? EAZEL_ENGINE_H_SCROLLBAR_INACTIVE
+				  : EAZEL_ENGINE_H_SCROLLBAR)
+			       : (state_type == GTK_STATE_PRELIGHT
+				  ? EAZEL_ENGINE_V_SCROLLBAR_HI
+				  : !focused
+				  ? EAZEL_ENGINE_V_SCROLLBAR_INACTIVE
+				  : EAZEL_ENGINE_V_SCROLLBAR),
+			       TRUE, FALSE, style, window, state_type, area,
+			       widget, x, y, width, height);
+	    if (width > height)
+	    {
+		/* XXX `4' is 1/2 width of thumb */
+		thumb_x = x + width / 2 - 4;
+		thumb_y = y;
+	    }
+	    else
+	    {
+		thumb_x = x;
+		/* XXX `4' is 1/2 height of thumb */
+		thumb_y = y + height / 2 - 4;
+	    }
+
+	    paint_stock_image (theme_data,
+			       width > height
+			       ? (state_type == GTK_STATE_PRELIGHT
+				  ? EAZEL_ENGINE_H_SCROLLBAR_THUMB_HI
+				  : !focused
+				  ? EAZEL_ENGINE_H_SCROLLBAR_THUMB_INACTIVE
+				  : EAZEL_ENGINE_H_SCROLLBAR_THUMB)
+			       : (state_type == GTK_STATE_PRELIGHT
+				  ? EAZEL_ENGINE_V_SCROLLBAR_THUMB_HI
+				  : !focused
+				  ? EAZEL_ENGINE_V_SCROLLBAR_THUMB_INACTIVE
+				  : EAZEL_ENGINE_V_SCROLLBAR_THUMB),
+			       FALSE, FALSE, style, window, state_type, area,
+			       widget, thumb_x, thumb_y, -1, -1);
+	}
+	else if (DETAIL ("vscrollbar"))
+	{
+	}
+	else if (DETAIL ("hscrollbar"))
+	{
+	}
+	else if (DETAIL ("bar"))
+	{
+	    if (state_type != GTK_STATE_INSENSITIVE)
+	    {
+		gboolean focused;
+		focused = eazel_engine_widget_in_focused_window_p (widget);
+		paint_stock_image (theme_data,
+				   focused ? EAZEL_ENGINE_PROGRESS_BAR
+				   : EAZEL_ENGINE_PROGRESS_BAR_INACTIVE,
+				   TRUE, FALSE, style, window, state_type,
+				   area, widget, x, y, width, height);
+		if (x > style->klass->xthickness)
+		{
+		    paint_stock_image (theme_data,
+				       EAZEL_ENGINE_PROGRESS_BAR_LEFT,
+				       TRUE, FALSE, style, window, state_type,
+				       area, widget, x - 2, y, -1, height);
+		}
+		if (widget != 0
+		    && x + width < widget->allocation.width - style->klass->xthickness - 3)
+		{
+		    paint_stock_image (theme_data,
+				       EAZEL_ENGINE_PROGRESS_BAR_RIGHT,
+				       TRUE, FALSE, style, window,
+				       state_type, area, widget,
+				       x + width, y, -1, height);
+		}
+	    }
+	    else
+	    {
+		paint_insensitive_box (theme_data, window,
+				       style->fg_gc[state_type],
+				       FALSE, x, y, width, height);
+	    }
+	}
+	else if (DETAIL ("optionmenutab"))
+	{
+	    int real_width, real_height;
+	    int y1, y2;
+	    int center_x, center_y;
+
+	    gdk_window_get_size (window, &real_width, &real_height);
+
+	    y1 = style->klass->ythickness + 1;
+	    y2 = real_height - style->klass->ythickness - 2;
+	    gdk_draw_line (window, style->dark_gc[state_type]
+			   , x, y1, x, y2);
+	    gdk_draw_line (window, style->light_gc[state_type],
+			   x + 1, y1, x +1, y2);
+
+	    center_x = x + (real_width - x) / 2;
+	    center_y = real_height / 2;
+
+	    paint_arrow (window, style->fg_gc[state_type], GTK_ARROW_UP,
+			 center_x - 4, center_y - 6, 7, 7);
+	    paint_arrow (window, style->fg_gc[state_type], GTK_ARROW_DOWN,
+			 center_x - 4, center_y - 1, 7, 7);
+	}
+	else if (DETAIL ("buttondefault"))
+	{
+	    /* Don't draw default markings. */
+	}
+	else
+	{
+	    GdkRectangle full;
+
+	    eazel_engine_gradient *gradient = theme_data->gradients[state_type];
+	    add_shadow = (shadow_type != GTK_SHADOW_NONE);
+
+	    if (DETAIL ("button") && widget != 0
+		&& GTK_WIDGET_HAS_FOCUS (widget)
+		&& GTK_WIDGET_CAN_DEFAULT (widget))
+	    {
+		x -= 1;
+		y -= 1;
+		width += 2;
+		height += 2;
+	    }
+
+	    full.x = x;
+	    full.y = y;
+	    full.width = width;
+	    full.height = height;
+
+	    if (DETAIL ("menuitem"))
+	    {
+		full.x++; full.y++;
+		full.width -= 2; full.height -= 2;
+	    }
+
+	    if (gradient != NULL && gradient->direction != GRADIENT_NONE)
+	    {
+		if (!set_bg)
+		{
+		    eazel_engine_draw_gradient (window,
+						style->bg_gc[state_type],
+						&full, &full, gradient);
+		}
+		else
+		{
+		    GdkRectangle dest;
+		    if (area != 0)
+			gdk_rectangle_intersect (&full, area, &dest);
+		    else
+			dest = full;
+		    eazel_engine_set_bg_gradient (window, gradient);
+		    gdk_window_clear_area (window, dest.x, dest.y,
+					   dest.width, dest.height);
+		}
+	    }
+	    else
+	    {
+		if (!set_bg)
+		{
+		    gdk_draw_rectangle (window, style->bg_gc[state_type], TRUE,
+					x, y, width, height);
+		}
+		else
+		{
+		    GdkRectangle dest;
+		    if (area != 0)
+			gdk_rectangle_intersect (&full, area, &dest);
+		    else
+			dest = full;
+		    gdk_window_set_background (window, &style->bg[state_type]);
+		    gdk_window_clear_area (window, dest.x, dest.y,
+					   dest.width, dest.height);
+		}
+	    }
+
+	    if (DETAIL ("button") && widget != 0
+		&& GTK_WIDGET_HAS_DEFAULT (widget))
+	    {
+		void (*fun) (eazel_theme_data *, GdkWindow *, GdkGC *, gboolean, gboolean, int, int, int, int, int) = paint_default_box;
+
+		if (GTK_WIDGET_HAS_FOCUS (widget))
+		    fun = paint_focus_box;
+
+		fun (theme_data, window, style->black_gc, TRUE, TRUE,
+		     theme_data->default_thickness,
+		     x - (theme_data->default_thickness),
+		     y - (theme_data->default_thickness),
+		     width + theme_data->default_thickness * 2 - 1,
+		     height + theme_data->default_thickness * 2 - 1);
+	    }
+	}
+	if (area)
+	{
+	    gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
+	    gdk_gc_set_clip_rectangle (style->fg_gc[state_type], NULL);
+	    gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
+	    gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
+	    gdk_gc_set_clip_rectangle (style->black_gc, NULL);
+	}
+    }
+    else
+    {
+	gtk_style_apply_default_pixmap (style, window, state_type, area, x,
+					y, width, height);
+    }
+
+    if (add_shadow)
+    {
+	gtk_paint_shadow (style, window, state_type, shadow_type, area, widget,
+			  detail, x, y, width, height);
+    }
+}
+
+static void
+draw_polygon (GtkStyle *style,
+	      GdkWindow *window,
+	      GtkStateType state_type,
+	      GtkShadowType shadow_type,
+	      GdkRectangle *area,
+	      GtkWidget *widget,
+	      gchar *detail, GdkPoint *points, gint npoints, gint fill)
+{
+#ifndef M_PI
+#define M_PI    3.14159265358979323846
+#endif /*
+        * M_PI 
+        */
+#ifndef M_PI_4
+#define M_PI_4  0.78539816339744830962
+#endif /*
+        * M_PI_4 
+        */
+
+    static const gdouble pi_over_4 = M_PI_4;
+    static const gdouble pi_3_over_4 = M_PI_4 * 3;
+
+    GdkGC *gc1;
+    GdkGC *gc2;
+    GdkGC *gc3;
+    GdkGC *gc4;
+    gdouble angle;
+    gint xadjust;
+    gint yadjust;
+    gint i;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+    g_return_if_fail (points != NULL);
+
+    debug ("draw_polygon: detail=%s state=%d shadow=%d\n",
+	    detail, state_type, shadow_type);
+
+    switch (shadow_type)
+    {
+    case GTK_SHADOW_IN:
+	gc1 = style->light_gc[state_type];
+	gc2 = style->dark_gc[state_type];
+	gc3 = style->light_gc[state_type];
+	gc4 = style->dark_gc[state_type];
+	break;
+    case GTK_SHADOW_ETCHED_IN:
+	gc1 = style->light_gc[state_type];
+	gc2 = style->dark_gc[state_type];
+	gc3 = style->dark_gc[state_type];
+	gc4 = style->light_gc[state_type];
+	break;
+    case GTK_SHADOW_OUT:
+	gc1 = style->dark_gc[state_type];
+	gc2 = style->light_gc[state_type];
+	gc3 = style->dark_gc[state_type];
+	gc4 = style->light_gc[state_type];
+	break;
+    case GTK_SHADOW_ETCHED_OUT:
+	gc1 = style->dark_gc[state_type];
+	gc2 = style->light_gc[state_type];
+	gc3 = style->light_gc[state_type];
+	gc4 = style->dark_gc[state_type];
+	break;
+    default:
+	return;
+    }
+
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (gc1, area);
+	gdk_gc_set_clip_rectangle (gc2, area);
+	gdk_gc_set_clip_rectangle (gc3, area);
+	gdk_gc_set_clip_rectangle (gc4, area);
+    }
+
+    if (fill)
+	gdk_draw_polygon (window, style->bg_gc[state_type], TRUE, points,
+			  npoints);
+
+    npoints--;
+
+    for (i = 0; i < npoints; i++)
+    {
+	if ((points[i].x == points[i + 1].x) &&
+	    (points[i].y == points[i + 1].y))
+	{
+	    angle = 0;
+	}
+	else
+	{
+	    angle = atan2 (points[i + 1].y - points[i].y,
+			   points[i + 1].x - points[i].x);
+	}
+
+	if ((angle > -pi_3_over_4) && (angle < pi_over_4))
+	{
+	    if (angle > -pi_over_4)
+	    {
+		xadjust = 0;
+		yadjust = 1;
+	    }
+	    else
+	    {
+		xadjust = 1;
+		yadjust = 0;
+	    }
+
+	    gdk_draw_line (window, gc1,
+			   points[i].x - xadjust, points[i].y - yadjust,
+			   points[i + 1].x - xadjust,
+			   points[i + 1].y - yadjust);
+	    gdk_draw_line (window, gc3, points[i].x, points[i].y,
+			   points[i + 1].x, points[i + 1].y);
+	}
+	else
+	{
+	    if ((angle < -pi_3_over_4) || (angle > pi_3_over_4))
+	    {
+		xadjust = 0;
+		yadjust = 1;
+	    }
+	    else
+	    {
+		xadjust = 1;
+		yadjust = 0;
+	    }
+
+	    gdk_draw_line (window, gc4,
+			   points[i].x + xadjust, points[i].y + yadjust,
+			   points[i + 1].x + xadjust,
+			   points[i + 1].y + yadjust);
+	    gdk_draw_line (window, gc2, points[i].x, points[i].y,
+			   points[i + 1].x, points[i + 1].y);
+	}
+    }
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (gc1, NULL);
+	gdk_gc_set_clip_rectangle (gc2, NULL);
+	gdk_gc_set_clip_rectangle (gc3, NULL);
+	gdk_gc_set_clip_rectangle (gc4, NULL);
+    }
+}
+
+static void
+draw_arrow (GtkStyle *style,
+	    GdkWindow *window,
+	    GtkStateType state_type,
+	    GtkShadowType shadow_type,
+	    GdkRectangle *area,
+	    GtkWidget *widget,
+	    gchar *detail,
+	    GtkArrowType arrow_type,
+	    gint fill, gint x, gint y, gint width, gint height)
+{
+    eazel_theme_data *theme_data;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    debug ("draw_arrow: detail=%s state=%d shadow=%d arrow_type=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, arrow_type, x, y, width, height);
+
+    if (DETAIL ("vscrollbar") || DETAIL ("hscrollbar"))
+    {
+	int type;
+	switch (arrow_type)
+	{
+	case GTK_ARROW_UP:
+	    type = EAZEL_ENGINE_ARROW_UP;
+	    break;
+
+	case GTK_ARROW_DOWN:
+	    type = EAZEL_ENGINE_ARROW_DOWN;
+	    break;
+
+	case GTK_ARROW_LEFT:
+	    type = EAZEL_ENGINE_ARROW_LEFT;
+	    break;
+
+	case GTK_ARROW_RIGHT:
+	    type = EAZEL_ENGINE_ARROW_RIGHT;
+	    break;
+	}
+
+	type += (state_type == GTK_STATE_ACTIVE ? 2
+		 : state_type == GTK_STATE_PRELIGHT ? 1 : 0);
+
+	paint_stock_image (theme_data, type, TRUE, FALSE,
+			   style, window, state_type,
+			   area, widget, x, y, width, height);
+    }
+    else if (DETAIL ("spinbutton"))
+    {
+	int window_width, window_height;
+	int tem_x, tem_y;
+
+	if (widget != 0 && !GTK_WIDGET_IS_SENSITIVE (widget))
+	    state_type = GTK_STATE_INSENSITIVE;
+
+	gdk_window_get_size (window, &window_width, &window_height);
+
+	if (state_type != GTK_STATE_INSENSITIVE)
+	{
+	    draw_box (style, window, state_type, shadow_type,
+		      area, widget, detail,
+		      x, y - (arrow_type == GTK_ARROW_DOWN),
+		      width, height + 1);
+	}
+	else if (arrow_type == GTK_ARROW_UP)
+	{
+	    /* XXX A hack, assumes that up arrow is drawn before
+	       XXX down arrow. (Currently it is) */
+
+	    draw_shadow (style, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
+			 NULL, widget, "entry", x - 2, 0,
+			 width + 4, window_height);
+	}
+
+	tem_x = x + (width / 2);
+	tem_y = y + (height / 2);
+	if (arrow_type == GTK_ARROW_UP)
+	{
+	    int i;
+	    tem_y--;
+	    for (i = 0; i < 4; i++)
+	    {
+		gdk_draw_line (window, style->fg_gc[state_type],
+			       tem_x - i, tem_y + i, tem_x + i, tem_y + i);
+	    }
+	}
+	else
+	{
+	    int i;
+	    tem_y -= 3;
+	    for (i = 0; i < 4; i++)
+	    {
+		gdk_draw_line (window, style->fg_gc[state_type],
+			       tem_x - i, tem_y + (4 - i),
+			       tem_x + i, tem_y + (4 - i));
+	    }
+	}
+
+	if (state_type != GTK_STATE_INSENSITIVE)
+	{
+	    draw_shadow (style, window, GTK_STATE_NORMAL, GTK_SHADOW_OUT,
+			 NULL, widget, "entry", x - 2, 0,
+			 width + 4, window_height);
+	}
+    }
+    else
+    {
+	if (widget != 0 && !GTK_WIDGET_IS_SENSITIVE (widget))
+	    state_type = GTK_STATE_INSENSITIVE;
+
+	paint_arrow (window, style->fg_gc[state_type],
+		     arrow_type, x, y, width, height);
+    }
+}
+
+static void
+draw_diamond (GtkStyle *style,
+	      GdkWindow *window,
+	      GtkStateType state_type,
+	      GtkShadowType shadow_type,
+	      GdkRectangle *area,
+	      GtkWidget *widget,
+	      gchar *detail, gint x, gint y, gint width, gint height)
+{
+    gint half_width;
+    gint half_height;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_diamond: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    half_width = width / 2;
+    half_height = height / 2;
+
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
+	gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
+	gdk_gc_set_clip_rectangle (style->dark_gc[state_type], area);
+	gdk_gc_set_clip_rectangle (style->black_gc, area);
+    }
+    switch (shadow_type)
+    {
+    case GTK_SHADOW_IN:
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + 2, y + half_height,
+		       x + half_width, y + height - 2);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + half_width, y + height - 2,
+		       x + width - 2, y + half_height);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + 1, y + half_height,
+		       x + half_width, y + height - 1);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + half_width, y + height - 1,
+		       x + width - 1, y + half_height);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x, y + half_height, x + half_width, y + height);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + half_width, y + height,
+		       x + width, y + half_height);
+
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + 2, y + half_height, x + half_width, y + 2);
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + half_width, y + 2, x + width - 2, y + half_height);
+	gdk_draw_line (window, style->dark_gc[state_type], x + 1,
+		       y + half_height, x + half_width, y + 1);
+	gdk_draw_line (window, style->dark_gc[state_type], x + half_width,
+		       y + 1, x + width - 1, y + half_height);
+	gdk_draw_line (window, style->dark_gc[state_type], x,
+		       y + half_height, x + half_width, y);
+	gdk_draw_line (window, style->dark_gc[state_type], x + half_width,
+		       y, x + width, y + half_height);
+	break;
+    case GTK_SHADOW_OUT:
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + 2, y + half_height,
+		       x + half_width, y + height - 2);
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + half_width, y + height - 2,
+		       x + width - 2, y + half_height);
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + 1, y + half_height,
+		       x + half_width, y + height - 1);
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + half_width, y + height - 1,
+		       x + width - 1, y + half_height);
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x, y + half_height, x + half_width, y + height);
+	gdk_draw_line (window, style->dark_gc[state_type],
+		       x + half_width, y + height,
+		       x + width, y + half_height);
+
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + 2, y + half_height, x + half_width, y + 2);
+	gdk_draw_line (window, style->light_gc[state_type],
+		       x + half_width, y + 2, x + width - 2, y + half_height);
+	gdk_draw_line (window, style->light_gc[state_type], x + 1,
+		       y + half_height, x + half_width, y + 1);
+	gdk_draw_line (window, style->light_gc[state_type], x + half_width,
+		       y + 1, x + width - 1, y + half_height);
+	gdk_draw_line (window, style->light_gc[state_type], x,
+		       y + half_height, x + half_width, y);
+	gdk_draw_line (window, style->light_gc[state_type], x + half_width,
+		       y, x + width, y + half_height);
+	break;
+    default:
+	break;
+    }
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
+	gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
+	gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
+	gdk_gc_set_clip_rectangle (style->black_gc, NULL);
+    }
+}
+
+static void
+draw_oval (GtkStyle *style,
+	   GdkWindow *window,
+	   GtkStateType state_type,
+	   GtkShadowType shadow_type,
+	   GdkRectangle *area,
+	   GtkWidget *widget,
+	   gchar *detail, gint x, gint y, gint width, gint height)
+{
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+}
+
+static void
+draw_string (GtkStyle *style,
+	     GdkWindow *window,
+	     GtkStateType state_type,
+	     GdkRectangle *area,
+	     GtkWidget *widget,
+	     gchar *detail, gint x, gint y, const gchar *string)
+{
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_string: detail=%s state=%d x=%d y=%d\n",
+	    detail, state_type, x, y);
+
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->white_gc, area);
+	gdk_gc_set_clip_rectangle (style->fg_gc[state_type], area);
+    }
+    if (state_type == GTK_STATE_INSENSITIVE)
+	gdk_draw_string (window, style->font, style->white_gc, x + 1, y + 1,
+			 string);
+    gdk_draw_string (window, style->font, style->fg_gc[state_type], x, y,
+		     string);
+    if (area)
+    {
+	gdk_gc_set_clip_rectangle (style->white_gc, NULL);
+	gdk_gc_set_clip_rectangle (style->fg_gc[state_type], NULL);
+    }
+}
+
+static void
+draw_flat_box (GtkStyle *style,
+	       GdkWindow *window,
+	       GtkStateType state_type,
+	       GtkShadowType shadow_type,
+	       GdkRectangle *area,
+	       GtkWidget *widget,
+	       gchar *detail, gint x, gint y, gint width, gint height)
+{
+    GdkGC *gc1;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    debug ("draw_flat_box: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    gc1 = style->bg_gc[state_type];
+
+    if (DETAIL ("text") && (state_type == GTK_STATE_SELECTED))
+	gc1 = style->bg_gc[GTK_STATE_SELECTED];
+    else if (DETAIL ("viewportbin"))
+	gc1 = style->bg_gc[GTK_STATE_NORMAL];
+    else if (DETAIL ("entry_bg"))
+	gc1 = style->white_gc;
+
+    if ((!style->bg_pixmap[state_type])
+	|| (gc1 != style->bg_gc[state_type])
+	|| (gdk_window_get_type (window) == GDK_WINDOW_PIXMAP))
+    {
+	if (area)
+	{
+	    gdk_gc_set_clip_rectangle (gc1, area);
+	}
+	gdk_draw_rectangle (window, gc1, TRUE, x, y, width, height);
+	if ((detail) && (!strcmp ("tooltip", detail)))
+	    gdk_draw_rectangle (window, style->black_gc, FALSE,
+				x, y, width - 1, height - 1);
+	if (area)
+	{
+	    gdk_gc_set_clip_rectangle (gc1, NULL);
+	}
+    }
+    else
+	gtk_style_apply_default_pixmap (style, window, state_type, area, x,
+					y, width, height);
+}
+
+static void
+paint_check (GtkStyle *style,
+	     GdkWindow *window,
+	     GtkStateType state_type,
+	     GtkShadowType shadow_type,
+	     GdkRectangle *area,
+	     GtkWidget *widget,
+	     gchar *detail, gint x, gint y, gint width, gint height,
+	     eazel_engine_stock_image stock_base)
+{
+    eazel_engine_stock_image type;
+    gboolean active = (shadow_type != GTK_SHADOW_OUT);
+    gboolean has_focus = (widget != 0 && GTK_WIDGET_HAS_FOCUS (widget));
+    gboolean menu_item = (widget != 0 && gtk_widget_get_ancestor (widget, GTK_TYPE_MENU_ITEM));
+
+    eazel_theme_data *theme_data;
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    if (DETAIL ("checkbutton") || DETAIL ("radiobutton"))
+    {
+	/* correct for braindeath in gtk_real_check_button_draw_indicator */
+	if (widget != 0 && GTK_IS_TOGGLE_BUTTON (widget))
+	    active = GTK_TOGGLE_BUTTON (widget)->active;
+	if (widget != 0)
+	{
+	    state_type = GTK_WIDGET_STATE (widget);
+	    /* XXX the widget gives us no way to tell between
+	       XXX checked, and checked-and-clicked states.. */
+	    if (active && state_type == GTK_STATE_ACTIVE)
+		state_type = GTK_STATE_NORMAL;
+	}
+    }
+
+    if (!menu_item)
+    {
+	switch (state_type)
+	{
+	case GTK_STATE_INSENSITIVE:
+	    type = (!active ? EAZEL_ENGINE_CHECK_DISABLED
+		    : EAZEL_ENGINE_CHECK_ACTIVE_DISABLED);
+	    break;
+
+	case GTK_STATE_PRELIGHT:
+	    type = (active
+		    ? (has_focus ? EAZEL_ENGINE_CHECK_ACTIVE_HI_FOCUS
+		       : EAZEL_ENGINE_CHECK_ACTIVE_HI)
+		    : (has_focus ? EAZEL_ENGINE_CHECK_HI_FOCUS
+		       : EAZEL_ENGINE_CHECK_HI));
+	    break;
+
+	case GTK_STATE_ACTIVE:
+	    type = (active
+		    ? (has_focus ? EAZEL_ENGINE_CHECK_ACTIVE_PRESSED_FOCUS
+		       : EAZEL_ENGINE_CHECK_ACTIVE)
+		    : (has_focus ? EAZEL_ENGINE_CHECK_PRESSED_FOCUS
+		       : EAZEL_ENGINE_CHECK_PRESSED));
+	    break;
+
+	default:
+	    type = (active
+		    ? (has_focus ? EAZEL_ENGINE_CHECK_ACTIVE_FOCUS
+		       : EAZEL_ENGINE_CHECK_ACTIVE)
+		    : (has_focus ? EAZEL_ENGINE_CHECK_FOCUS
+		       : EAZEL_ENGINE_CHECK));
+	}
+
+	paint_stock_image (theme_data, type + stock_base,
+			   FALSE, FALSE, style, window,
+			   state_type, area, widget,
+			   x-3, y-3, width+6, height+6);
+    }
+    else
+    {
+	if (!active)
+	    return;
+
+	if (stock_base == EAZEL_ENGINE_CHECK)
+	{
+	    paint_tick (window, style->fg_gc[state_type],
+			x + width / 2, y + width / 2);
+	}
+	else
+	{
+	    paint_bullet (window, style->fg_gc[state_type],
+			  x + width / 2, y + width / 2);
+	}
+    }
+}
+
+static void
+draw_check (GtkStyle *style,
+	    GdkWindow *window,
+	    GtkStateType state_type,
+	    GtkShadowType shadow_type,
+	    GdkRectangle *area,
+	    GtkWidget *widget,
+	    gchar *detail, gint x, gint y, gint width, gint height)
+{
+    paint_check (style, window, state_type, shadow_type, area,
+		 widget, detail, x, y, width, height, EAZEL_ENGINE_CHECK);
+}
+
+static void
+draw_option (GtkStyle *style,
+	     GdkWindow *window,
+	     GtkStateType state_type,
+	     GtkShadowType shadow_type,
+	     GdkRectangle *area,
+	     GtkWidget *widget,
+	     gchar *detail, gint x, gint y, gint width, gint height)
+{
+    paint_check (style, window, state_type, shadow_type, area,
+		 widget, detail, x, y, width, height, EAZEL_ENGINE_OPTION);
+}
+
+static void
+draw_cross (GtkStyle *style,
+	    GdkWindow *window,
+	    GtkStateType state_type,
+	    GtkShadowType shadow_type,
+	    GdkRectangle *area,
+	    GtkWidget *widget,
+	    gchar *detail, gint x, gint y, gint width, gint height)
+{
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+}
+
+static void
+draw_ramp (GtkStyle *style,
+	   GdkWindow *window,
+	   GtkStateType state_type,
+	   GtkShadowType shadow_type,
+	   GdkRectangle *area,
+	   GtkWidget *widget,
+	   gchar *detail,
+	   GtkArrowType arrow_type, gint x, gint y, gint width, gint height)
+{
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+}
+
+static void
+draw_tab (GtkStyle *style,
+	  GdkWindow *window,
+	  GtkStateType state_type,
+	  GtkShadowType shadow_type,
+	  GdkRectangle *area,
+	  GtkWidget *widget,
+	  gchar *detail, gint x, gint y, gint width, gint height)
+{
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    gtk_paint_box (style, window, state_type, shadow_type, area, widget,
+		   detail, x, y, width, height);
+}
+
+static void
+draw_shadow_gap (GtkStyle *style,
+		 GdkWindow *window,
+		 GtkStateType state_type,
+		 GtkShadowType shadow_type,
+		 GdkRectangle *area,
+		 GtkWidget *widget,
+		 gchar *detail,
+		 gint x,
+		 gint y,
+		 gint width,
+		 gint height,
+		 GtkPositionType gap_side, gint gap_x, gint gap_width)
+{
+    GdkRectangle rect;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_shadow_gap: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    gtk_paint_shadow (style, window, state_type, shadow_type, area, widget,
+		      detail, x, y, width, height);
+
+    switch (gap_side)
+    {
+    case GTK_POS_TOP:
+	rect.x = x + gap_x;
+	rect.y = y;
+	rect.width = gap_width;
+	rect.height = 2;
+	break;
+    case GTK_POS_BOTTOM:
+	rect.x = x + gap_x;
+	rect.y = y + height - 2;
+	rect.width = gap_width;
+	rect.height = 2;
+	break;
+    case GTK_POS_LEFT:
+	rect.x = x;
+	rect.y = y + gap_x;
+	rect.width = 2;
+	rect.height = gap_width;
+	break;
+    case GTK_POS_RIGHT:
+	rect.x = x + width - 2;
+	rect.y = y + gap_x;
+	rect.width = 2;
+	rect.height = gap_width;
+	break;
+    }
+
+    gtk_style_apply_default_pixmap (style, window, state_type, area,
+				    rect.x, rect.y, rect.width, rect.height);
+}
+
+static void
+draw_box_gap (GtkStyle *style,
+	      GdkWindow *window,
+	      GtkStateType state_type,
+	      GtkShadowType shadow_type,
+	      GdkRectangle *area,
+	      GtkWidget *widget,
+	      gchar *detail,
+	      gint x,
+	      gint y,
+	      gint width,
+	      gint height,
+	      GtkPositionType gap_side, gint gap_x, gint gap_width)
+{
+    GdkRectangle rect;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_box_gap: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    gtk_paint_box (style, window, state_type, shadow_type, area, widget,
+		   detail, x, y, width, height);
+
+    /* XXX Eavel hack to prevent a hole being draw when the
+       XXX active tab is on the far left */
+    if (gap_x < 1)
+    {
+	gap_width -= (1 - gap_x);
+	gap_x = 1;
+    }
+
+    switch (gap_side)
+    {
+    case GTK_POS_TOP:
+	rect.x = x + gap_x;
+	rect.y = y;
+	rect.width = gap_width;
+	rect.height = 2;
+	break;
+    case GTK_POS_BOTTOM:
+	rect.x = x + gap_x;
+	rect.y = y + height - 2;
+	rect.width = gap_width;
+	rect.height = 2;
+	break;
+    case GTK_POS_LEFT:
+	rect.x = x;
+	rect.y = y + gap_x;
+	rect.width = 2;
+	rect.height = gap_width;
+	break;
+    case GTK_POS_RIGHT:
+	rect.x = x + width - 2;
+	rect.y = y + gap_x;
+	rect.width = 2;
+	rect.height = gap_width;
+	break;
+    }
+
+    gtk_style_apply_default_pixmap (style, window, state_type, area,
+				    rect.x, rect.y, rect.width, rect.height);
+}
+
+static void
+draw_extension (GtkStyle *style,
+		GdkWindow *window,
+		GtkStateType state_type,
+		GtkShadowType shadow_type,
+		GdkRectangle *area,
+		GtkWidget *widget,
+		gchar *detail,
+		gint x,
+		gint y, gint width, gint height, GtkPositionType gap_side)
+{
+    GdkRectangle rect;
+
+    eazel_theme_data *theme_data;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    debug ("draw_extension: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+
+    if (DETAIL ("tab"))
+    {
+	eazel_engine_stock_image type = 0;
+	switch (gap_side)
+	{
+	case GTK_POS_TOP:
+	    type = ((state_type != GTK_STATE_ACTIVE)
+		    ? EAZEL_ENGINE_TAB_BOTTOM_ACTIVE
+		    : (x < 10) ? EAZEL_ENGINE_TAB_BOTTOM_LEFT
+		    : EAZEL_ENGINE_TAB_BOTTOM);
+	    break;
+
+	case GTK_POS_BOTTOM:
+	    type = ((state_type != GTK_STATE_ACTIVE)
+		    ? EAZEL_ENGINE_TAB_TOP_ACTIVE
+		    : (x < 10) ? EAZEL_ENGINE_TAB_TOP_LEFT
+		    : EAZEL_ENGINE_TAB_TOP);
+	    break;
+
+	default:			/* gcc drugging */
+	}
+	paint_background_area (style, window, state_type, area,
+			       x, y, width, height);
+	if (type != 0)
+	{
+	    paint_stock_image (theme_data, type, TRUE, FALSE, style, window,
+			       state_type, area, widget, x, y, width, height);
+	    return;
+	}
+    }
+
+    gtk_paint_box (style, window, state_type, shadow_type, area, widget,
+		   detail, x, y, width, height);
+
+    switch (gap_side)
+    {
+    case GTK_POS_TOP:
+	rect.x = x + style->klass->xthickness;
+	rect.y = y;
+	rect.width = width - style->klass->xthickness * 2;
+	rect.height = style->klass->ythickness;
+	break;
+    case GTK_POS_BOTTOM:
+	rect.x = x + style->klass->xthickness;
+	rect.y = y + height - style->klass->ythickness;
+	rect.width = width - style->klass->xthickness * 2;
+	rect.height = style->klass->ythickness;
+	break;
+    case GTK_POS_LEFT:
+	rect.x = x;
+	rect.y = y + style->klass->ythickness;
+	rect.width = style->klass->xthickness;
+	rect.height = height - style->klass->ythickness * 2;
+	break;
+    case GTK_POS_RIGHT:
+	rect.x = x + width - style->klass->xthickness;
+	rect.y = y + style->klass->ythickness;
+	rect.width = style->klass->xthickness;
+	rect.height = height - style->klass->ythickness * 2;
+	break;
+    }
+
+    gtk_style_apply_default_pixmap (style, window, state_type, area,
+				    rect.x, rect.y, rect.width, rect.height);
+}
+
+static void
+draw_focus (GtkStyle *style,
+	    GdkWindow *window,
+	    GdkRectangle *area,
+	    GtkWidget *widget,
+	    gchar *detail, gint x, gint y, gint width, gint height)
+{
+    eazel_theme_data *theme_data;
+    gboolean rounded = TRUE, rounded_inner = TRUE;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    debug ("draw_focus: detail=%s x=%d y=%d w=%d h=%d\n",
+	    detail, x, y, width, height);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+
+    if ((DETAIL ("button") && widget != 0
+	 && GTK_IS_BUTTON (widget) && GTK_WIDGET_HAS_DEFAULT (widget))
+	|| DETAIL ("checkbutton") || DETAIL ("option") || DETAIL ("slider")
+	|| (widget != 0 && GTK_IS_SCALE (widget))
+	/* XXX reenable me */
+	|| DETAIL ("tab"))
+    {
+	return;
+    }
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    if (area)
+	gdk_gc_set_clip_rectangle (style->black_gc, area);
+
+    if (DETAIL ("button"))
+    {
+	x--; y--;
+	width += 2; height += 2;
+    }
+    else if (DETAIL ("text") || DETAIL ("entry"))
+    {
+	rounded_inner = FALSE;
+    }
+
+    paint_focus_box (theme_data, window, style->black_gc,
+		     rounded, rounded_inner, theme_data->focus_thickness,
+		     x, y, width, height);
+
+    if (area)
+	gdk_gc_set_clip_rectangle (style->black_gc, NULL);
+}
+
+static void
+draw_slider (GtkStyle *style,
+	     GdkWindow *window,
+	     GtkStateType state_type,
+	     GtkShadowType shadow_type,
+	     GdkRectangle *area,
+	     GtkWidget *widget,
+	     gchar *detail,
+	     gint x,
+	     gint y, gint width, gint height, GtkOrientation orientation)
+{
+    eazel_theme_data *theme_data;
+    gboolean focused;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    debug ("draw_slider: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	    detail, state_type, shadow_type, x, y, width, height);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    if (area)
+	gdk_gc_set_clip_rectangle (style->black_gc, area);
+
+    focused = (widget != 0) && eazel_engine_widget_in_focused_window_p (widget);
+    paint_stock_image (theme_data,
+		       orientation == GTK_ORIENTATION_HORIZONTAL
+		       ? (focused ? EAZEL_ENGINE_H_SLIDER_THUMB
+			  : EAZEL_ENGINE_H_SLIDER_THUMB_INACTIVE)
+		       : (focused ? EAZEL_ENGINE_V_SLIDER_THUMB
+			  : EAZEL_ENGINE_V_SLIDER_THUMB_INACTIVE),
+		       TRUE, TRUE, style, window, state_type,
+		       area, widget, x, y, width, height);
+    if (area)
+	gdk_gc_set_clip_rectangle (style->black_gc, NULL);
+}
+
+static void
+draw_handle (GtkStyle *style,
+	     GdkWindow *window,
+	     GtkStateType state_type,
+	     GtkShadowType shadow_type,
+	     GdkRectangle *area,
+	     GtkWidget *widget,
+	     gchar *detail,
+	     gint x,
+	     gint y, gint width, gint height, GtkOrientation orientation)
+{
+    gint i, yy, xx;
+    gint xthick, ythick;
+    GdkGC *light_gc, *dark_gc;
+    GdkRectangle dest;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    debug ("draw_handle: detail=%s state=%d shadow=%d x=%d y=%d w=%d h=%d\n",
+	   detail, state_type, shadow_type, x, y, width, height);
+
+    /* Protection against broken GTK+ widgets */
+    g_return_if_fail (width < 32768);
+    g_return_if_fail (height < 32768);
+
+    if ((width == -1) && (height == -1))
+	gdk_window_get_size (window, &width, &height);
+    else if (width == -1)
+	gdk_window_get_size (window, &width, NULL);
+    else if (height == -1)
+	gdk_window_get_size (window, NULL, &height);
+
+    if (DETAIL ("dockitem") && state_type == GTK_STATE_NORMAL)
+	state_type = GTK_STATE_ACTIVE;
+
+    gtk_paint_box (style, window, state_type, shadow_type, area, widget,
+		   detail, x, y, width, height);
+
+    light_gc = style->light_gc[state_type];
+    dark_gc = style->dark_gc[state_type];
+
+    xthick = style->klass->xthickness;
+    ythick = style->klass->ythickness;
+
+    dest.x = x + xthick;
+    dest.y = y + ythick;
+    dest.width = width - (xthick * 2);
+    dest.height = height - (ythick * 2);
+
+    gdk_gc_set_clip_rectangle (light_gc, &dest);
+    gdk_gc_set_clip_rectangle (dark_gc, &dest);
+
+    /* ORIENTATION parameters is unreliable */
+    if (height > width)
+    {
+	yy = y + height / 2 - 5;
+	for (i = 0; i < 10; i += 2)
+	{
+	    gdk_draw_line (window, dark_gc, xthick, yy + i,
+			   x + width - xthick, yy + i);
+	    gdk_draw_line (window, light_gc, xthick, yy + i + 1,
+			   x + width - xthick, yy + i + 1);
+	}
+    }
+    else
+    {
+	xx = x + width / 2 - 5;
+	for (i = 0; i < 10; i += 2)
+	{
+	    gdk_draw_line (window, dark_gc, xx + i, ythick,
+			   xx + i, y + height - ythick);
+	    gdk_draw_line (window, light_gc, xx + i + 1, ythick,
+			   xx + i + 1, y + height - ythick);
+	}
+    }
+
+    gdk_gc_set_clip_rectangle (light_gc, NULL);
+    gdk_gc_set_clip_rectangle (dark_gc, NULL);
+}
+
+
+/*
+ * class struct 
+ */
+
+GtkStyleClass eazel_class_0 = {
+    0, 0,
+    draw_hline,
+    draw_vline,
+    draw_shadow,
+    draw_polygon,
+    draw_arrow,
+    draw_diamond,
+    draw_oval,
+    draw_string,
+    draw_box,
+    draw_flat_box,
+    draw_check,
+    draw_option,
+    draw_cross,
+    draw_ramp,
+    draw_tab,
+    draw_shadow_gap,
+    draw_box_gap,
+    draw_extension,
+    draw_focus,
+    draw_slider,
+    draw_handle
+};
+
+GtkStyleClass eazel_class_1 = {
+    1, 1,
+    draw_hline,
+    draw_vline,
+    draw_shadow,
+    draw_polygon,
+    draw_arrow,
+    draw_diamond,
+    draw_oval,
+    draw_string,
+    draw_box,
+    draw_flat_box,
+    draw_check,
+    draw_option,
+    draw_cross,
+    draw_ramp,
+    draw_tab,
+    draw_shadow_gap,
+    draw_box_gap,
+    draw_extension,
+    draw_focus,
+    draw_slider,
+    draw_handle
+};
+
+GtkStyleClass eazel_class_2 = {
+    2, 2,
+    draw_hline,
+    draw_vline,
+    draw_shadow,
+    draw_polygon,
+    draw_arrow,
+    draw_diamond,
+    draw_oval,
+    draw_string,
+    draw_box,
+    draw_flat_box,
+    draw_check,
+    draw_option,
+    draw_cross,
+    draw_ramp,
+    draw_tab,
+    draw_shadow_gap,
+    draw_box_gap,
+    draw_extension,
+    draw_focus,
+    draw_slider,
+    draw_handle
+};
+
+GtkStyleClass eazel_class_3 = {
+    3, 3,
+    draw_hline,
+    draw_vline,
+    draw_shadow,
+    draw_polygon,
+    draw_arrow,
+    draw_diamond,
+    draw_oval,
+    draw_string,
+    draw_box,
+    draw_flat_box,
+    draw_check,
+    draw_option,
+    draw_cross,
+    draw_ramp,
+    draw_tab,
+    draw_shadow_gap,
+    draw_box_gap,
+    draw_extension,
+    draw_focus,
+    draw_slider,
+    draw_handle
+};
+
diff --git a/eazel-engine/src/eazel-theme-gradient.c b/eazel-engine/src/eazel-theme-gradient.c
new file mode 100644
index 0000000..fad6d4c
--- /dev/null
+++ b/eazel-engine/src/eazel-theme-gradient.c
@@ -0,0 +1,360 @@
+/* eazel-theme-gradient.c -- code for drawing gradients
+
+   Copyright (C) 2000 Eazel, Inc.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program 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
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   $Id: eazel-theme-gradient.c,v 1.6 2001/01/18 01:20:04 jsh Exp $
+
+   Authors: John Harper <jsh@eazel.com>  */
+
+/* AIX requires this to be the first thing in the file.  */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#ifndef __GNUC__
+# if HAVE_ALLOCA_H
+#  include <alloca.h>
+# else
+#  ifdef _AIX
+ #pragma alloca
+#  else
+#   ifndef alloca /* predefined by HP cc +Olibcalls */
+   char *alloca ();
+#   endif
+#  endif
+# endif
+#endif
+
+#include "eazel-theme.h"
+#include <gdk/gdkrgb.h>
+#include <stdlib.h>
+
+static GdkRgbDither dither_mode = GDK_RGB_DITHER_MAX;
+
+eazel_engine_gradient *
+eazel_engine_gradient_new (eazel_engine_gradient_direction direction,
+			   GdkColor *from, GSList *components)
+{
+    eazel_engine_gradient *g;
+
+    g_return_val_if_fail (from != NULL, NULL);
+
+    g = g_new (eazel_engine_gradient, 1);
+    g->refcount = 1;
+    g->direction = direction;
+    g->from = *from;
+    g->components = components;
+    return g;
+}
+
+eazel_engine_gradient *
+eazel_engine_gradient_ref (eazel_engine_gradient *g)
+{
+    g_return_val_if_fail (g != NULL, NULL);
+
+    g->refcount++;
+    return g;
+}
+
+void
+eazel_engine_gradient_unref (eazel_engine_gradient *g)
+{
+    g_return_if_fail (g != NULL);
+    g->refcount--;
+
+    if (g->refcount == 0)
+    {
+	GSList *x;
+	for (x = g->components; x != 0; x = x->next)
+	    g_free (x->data);
+	g_slist_free (g->components);
+	g_free (g);
+    }
+}
+
+eazel_engine_gradient *
+eazel_engine_make_two_point_gradient (eazel_engine_gradient_direction direction,
+				      gulong from_rgb, gulong to_rgb)
+{
+    GdkColor from, to;
+    eazel_engine_gradient_component *component;
+
+    g_return_val_if_fail (direction != GRADIENT_NONE, NULL);
+
+    from.red = (from_rgb >> 16) & 255;
+    from.red |= from.red << 8;
+    from.green = (from_rgb >> 8) & 255;
+    from.green |= from.green << 8;
+    from.blue = (from_rgb >> 0) & 255;
+    from.blue |= from.blue << 8;
+
+    to.red = (to_rgb >> 16) & 255;
+    to.red |= to.red << 8;
+    to.green = (to_rgb >> 8) & 255;
+    to.green |= to.green << 8;
+    to.blue = (to_rgb >> 0) & 255;
+    to.blue |= to.blue << 8;
+
+    component = g_new (eazel_engine_gradient_component, 1);
+    component->color = to;
+    component->weight = 1.0;
+
+    return eazel_engine_gradient_new (direction, &from,
+				      g_slist_prepend (NULL, component));
+}
+
+
+/* rendering */
+
+static inline void
+fill_gradient_rgb_buffer_1 (const GdkColor *from, const GdkColor *to,
+			    int rgb_total, guchar *rgb_buf,
+			    int rgb_first, int rgb_last)
+{
+    int delta_r = to->red - from->red;
+    int delta_g = to->green - from->green;
+    int delta_b = to->blue - from->blue;
+    guchar *rgb_ptr = rgb_buf;
+    int i;
+
+    g_return_if_fail (rgb_first <= rgb_last && rgb_last <= rgb_total);
+
+    for (i = rgb_first; i < rgb_last; i++)
+    {
+	*rgb_ptr++ = (from->red + (delta_r * i) / rgb_total) >> 8;
+	*rgb_ptr++ = (from->green + (delta_g * i) / rgb_total) >> 8;
+	*rgb_ptr++ = (from->blue + (delta_b * i) / rgb_total) >> 8;
+    }
+}
+
+void
+eazel_engine_fill_gradient_rgb_buffer (const eazel_engine_gradient *gradient,
+				       int rgb_total, guchar *rgb_buf,
+				       int rgb_first, int rgb_last)
+{
+    g_return_if_fail (gradient != NULL);
+    g_return_if_fail (rgb_buf != NULL);
+
+    if (gradient->components == 0)
+    {
+	/* Single color `gradient' */
+	fill_gradient_rgb_buffer_1 (&gradient->from, &gradient->from,
+				     rgb_total, rgb_buf, rgb_first, rgb_last);
+    }
+    else
+    {
+	float total_weight, weight_ptr;
+	int rgb_ptr;
+	GSList *x;
+	const GdkColor *pred;
+
+	total_weight = 0.0;
+	for (x = gradient->components; x != 0; x = x->next)
+	{
+	    eazel_engine_gradient_component *c = x->data;
+	    total_weight += c->weight;
+	}
+
+	rgb_ptr = 0;
+	weight_ptr = 0.0;
+	pred = &gradient->from;
+	for (x = gradient->components; x != 0; x = x->next)
+	{
+	    eazel_engine_gradient_component *c = x->data;
+	    int rgb_chunk = (c->weight * rgb_total) / total_weight;
+
+	    int first = MAX (rgb_first, rgb_ptr);
+	    int last = MIN (rgb_last, rgb_ptr + rgb_chunk);
+
+	    if (x->next == 0)
+		last = rgb_last;
+
+	    if (last > first)
+	    {
+		fill_gradient_rgb_buffer_1 (pred, &c->color,
+					    last - first,
+					    rgb_buf + rgb_ptr * 3,
+					    first - rgb_ptr,
+					    last - rgb_ptr);
+	    }
+
+	    pred = &c->color;
+	    weight_ptr += c->weight;
+	    rgb_ptr += rgb_chunk;
+	}
+    }
+}
+
+static void
+draw_vertical_gradient (GdkDrawable *drawable, GdkGC *gc,
+			const GdkRectangle *full_rect,
+			const GdkRectangle *clip_rect,
+			const eazel_engine_gradient *gradient)
+{
+    int rgb_size = clip_rect->height;
+    guchar *rgb = alloca (rgb_size * 3), *ptr;
+
+    eazel_engine_fill_gradient_rgb_buffer (gradient, full_rect->height, rgb,
+					   clip_rect->y - full_rect->y,
+					   (clip_rect->y + clip_rect->height)
+					   - full_rect->y);
+
+    if (dither_mode == GDK_RGB_DITHER_NONE)
+    {
+	GdkColormap *sys_lut = gdk_colormap_get_system ();
+	GdkGCValues old_values;
+	int y;
+
+	gdk_gc_get_values (gc, &old_values);
+
+	ptr = rgb;
+	for (y = clip_rect->y; y < clip_rect->y + clip_rect->height; y++)
+	{
+	    guchar r = *ptr++;
+	    guchar g = *ptr++;
+	    guchar b = *ptr++;
+	    GdkColor color = { 0, r << 8, g << 8, b << 8 };
+	    gdk_colormap_alloc_color (sys_lut, &color, FALSE, TRUE);
+	    gdk_gc_set_foreground (gc, &color);
+	    gdk_draw_line (drawable, gc, clip_rect->x, y,
+			   clip_rect->x + clip_rect->width - 1, y);
+	}
+
+	gdk_gc_set_foreground (gc, &old_values.foreground);
+    }
+    else
+    {
+	guchar *xrgb = alloca (clip_rect->width * clip_rect->height * 3);
+	int x, y;
+	guchar *ptr_in = rgb, *ptr_out = xrgb;
+	for (y = 0; y < clip_rect->height; y++)
+	{
+	    guchar r = *ptr_in++;
+	    guchar g = *ptr_in++;
+	    guchar b = *ptr_in++;
+	    for (x = 0; x < clip_rect->width; x++)
+	    {
+		*ptr_out++ = r;
+		*ptr_out++ = g;
+		*ptr_out++ = b;
+	    }
+	}
+	gdk_draw_rgb_image (drawable, gc, clip_rect->x, clip_rect->y,
+			    clip_rect->width, clip_rect->height,
+			    dither_mode, xrgb, clip_rect->width * 3);
+    }
+}
+
+static void
+draw_horizontal_gradient (GdkDrawable *drawable, GdkGC *gc,
+			  const GdkRectangle *full_rect,
+			  const GdkRectangle *clip_rect,
+			  const eazel_engine_gradient *gradient)
+{
+    int rgb_size = clip_rect->width;
+    guchar *rgb = alloca (rgb_size * 3), *ptr;
+
+    eazel_engine_fill_gradient_rgb_buffer (gradient, full_rect->width, rgb,
+					   clip_rect->x - full_rect->x,
+					   (clip_rect->x + clip_rect->width)
+					   - full_rect->x);
+
+    if (dither_mode == GDK_RGB_DITHER_NONE)
+    {
+	GdkColormap *sys_lut = gdk_colormap_get_system ();
+	GdkGCValues old_values;
+	int x;
+
+	gdk_gc_get_values (gc, &old_values);
+
+	ptr = rgb;
+	for (x = clip_rect->x; x < clip_rect->x + clip_rect->width; x++)
+	{
+	    guchar r = *ptr++;
+	    guchar g = *ptr++;
+	    guchar b = *ptr++;
+	    GdkColor color = { 0, r << 8, g << 8, b << 8 };
+	    gdk_colormap_alloc_color (sys_lut, &color, FALSE, TRUE);
+	    gdk_gc_set_foreground (gc, &color);
+	    gdk_draw_line (drawable, gc, x, clip_rect->y,
+			   x, clip_rect->y + clip_rect->height - 1);
+	}
+
+	gdk_gc_set_foreground (gc, &old_values.foreground);
+    }
+    else
+    {
+	/* Using a row-stride of zero means we only need a single
+	   row of rgb-data (inspired by nautilus-background.c) */
+	gdk_draw_rgb_image (drawable, gc, clip_rect->x, clip_rect->y,
+			    clip_rect->width, clip_rect->height,
+			    dither_mode, rgb, 0);
+    }
+}
+
+void
+eazel_engine_draw_gradient (GdkDrawable *drawable,
+			    GdkGC *gc,
+			    const GdkRectangle *full_rect,
+			    const GdkRectangle *clip_rect,
+			    const eazel_engine_gradient *gradient)
+{
+    if (gradient->direction == GRADIENT_VERTICAL)
+    {
+	draw_vertical_gradient (drawable, gc, full_rect, clip_rect, gradient);
+    }
+    else if (gradient->direction == GRADIENT_HORIZONTAL)
+    {
+	draw_horizontal_gradient (drawable, gc, full_rect, clip_rect, gradient);
+    }
+}
+
+void
+eazel_engine_set_bg_gradient (GdkWindow *window,
+			      eazel_engine_gradient *gradient)
+{
+    /* Render a tile of the specified gradient to a pixmap, then
+       set it as the background pixmap of the window. */
+
+    GdkRectangle area = { 0, 0 };
+    GdkPixmap *pixmap;
+    GdkGC *pixmap_gc;
+
+    int window_x, window_y, window_width, window_height, window_depth;
+
+    gdk_window_get_geometry (window, &window_x, &window_y,
+			     &window_width, &window_height, &window_depth);
+
+    if (gradient->direction == GRADIENT_VERTICAL)
+    {
+	area.width = 32;
+	area.height = window_height;
+    }
+    else
+    {
+	area.width = window_width;
+	area.height = 32;
+    }
+    
+    pixmap = gdk_pixmap_new (window, area.width, area.height, window_depth);
+    pixmap_gc = gdk_gc_new (pixmap);
+
+    eazel_engine_draw_gradient (pixmap, pixmap_gc, &area, &area, gradient);
+
+    gdk_window_set_back_pixmap (window, pixmap, FALSE);
+    gdk_gc_unref (pixmap_gc);
+    gdk_pixmap_unref (pixmap);
+}
diff --git a/eazel-engine/src/eazel-theme-hacks.c b/eazel-engine/src/eazel-theme-hacks.c
new file mode 100644
index 0000000..e045a09
--- /dev/null
+++ b/eazel-engine/src/eazel-theme-hacks.c
@@ -0,0 +1,143 @@
+/* eazel-theme-hacks.c -- override GtkWidgetClass methods
+
+   Copyright (C) 1998 Randy Gordon, Integrand Systems
+   Copyright (C) 2000 Eazel, Inc.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program 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
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   $Id: eazel-theme-hacks.c,v 1.4 2001/01/18 01:20:04 jsh Exp $
+
+   Authors: Randy Gordon <randy@integrand.com>
+	    John Harper <jsh@eazel.com>   */
+
+#include "eazel-theme.h"
+
+/* GTK+ sucks in places. This file contains dubious kludges to
+   force it to do what we want. */
+
+
+/* GtkRange code */
+
+static gint
+gtk_range_expose (GtkWidget *widget,
+		  GdkEventExpose *event)
+{
+  GtkRange *range;
+
+  /* The version of this method in gtkrange.c doesn't work
+   * when the slider is as wide as the trough.
+   */
+  g_return_val_if_fail (widget != NULL, FALSE);
+  g_return_val_if_fail (GTK_IS_RANGE (widget), FALSE);
+  g_return_val_if_fail (event != NULL, FALSE);
+
+  range = GTK_RANGE (widget);
+
+  if (event->window == range->trough)
+    {
+        gtk_range_draw_trough (range);
+    }
+  else if (event->window == widget->window)
+    {
+      gtk_range_draw_background (range);
+    }
+  else if (event->window == range->slider)
+    {
+      gtk_range_draw_slider (range);
+    }
+  else if (event->window == range->step_forw)
+    {
+      gtk_range_draw_step_forw (range);
+    }
+  else if (event->window == range->step_back)
+    {
+      gtk_range_draw_step_back (range);
+    }
+  return FALSE;
+}
+
+
+/* GtkWidgetClass method-override framework */
+
+typedef struct {
+    GtkType (*get_type) (void);
+    int offset;
+    gpointer replacement;
+    gpointer original;
+} eazel_engine_class_hack;
+
+static eazel_engine_class_hack class_hacks[] = {
+
+  { gtk_range_get_type,
+    G_STRUCT_OFFSET (GtkWidgetClass, expose_event),
+    gtk_range_expose },
+
+  { gtk_scale_get_type,
+    G_STRUCT_OFFSET (GtkWidgetClass, expose_event),
+    gtk_range_expose },
+
+  { NULL }
+};
+
+void
+eazel_engine_install_hacks (void)
+{
+    eazel_engine_class_hack *hack;
+    for (hack = class_hacks; hack->get_type != 0; hack++)
+    {
+	GtkWidgetClass *klass = gtk_type_class (hack->get_type ());
+	hack->original = G_STRUCT_MEMBER (gpointer, klass, hack->offset);
+	G_STRUCT_MEMBER (gpointer, klass, hack->offset) = hack->replacement;
+    }
+}
+
+static void
+restore_funcs (GtkObjectClass *klass,
+	       int member_offset,
+	       gpointer find_func,
+	       gpointer replace_func)
+{
+    GList *child_list, *child;
+    if (!GTK_IS_WIDGET_CLASS (klass))
+	g_error ("Warning: restoring methods for non-widget");
+    else
+    {
+	GtkWidgetClass *widget_klass = GTK_WIDGET_CLASS (klass);
+	if (G_STRUCT_MEMBER (gpointer, widget_klass, member_offset) == find_func)
+	    G_STRUCT_MEMBER (gpointer, widget_klass, member_offset) = replace_func;
+    }
+    child_list = gtk_type_children_types (klass->type);
+    for (child = child_list; child; child = child->next)
+    {
+	gpointer child_class = gtk_type_class (GPOINTER_TO_UINT (child->data));
+	restore_funcs (GTK_OBJECT_CLASS (child_class),
+		       member_offset, find_func, replace_func);
+    }
+}
+
+void
+eazel_engine_remove_hacks (void)
+{
+    eazel_engine_class_hack *hack;
+    for (hack = class_hacks; hack->get_type != 0; hack++)
+    {
+	/* This is nasty: the methods we installed in init() may have
+	   been copied into subclasses. */
+
+	GtkWidgetClass *klass = gtk_type_class (hack->get_type ());
+	restore_funcs (GTK_OBJECT_CLASS (klass), hack->offset,
+		       hack->replacement, hack->original);
+    }
+}
diff --git a/eazel-engine/src/eazel-theme-main.c b/eazel-engine/src/eazel-theme-main.c
new file mode 100644
index 0000000..9deebe0
--- /dev/null
+++ b/eazel-engine/src/eazel-theme-main.c
@@ -0,0 +1,1253 @@
+/* eazel-theme-main.c -- entry point
+
+   Copyright (C) 1998 Randy Gordon, Integrand Systems
+   Copyright (C) 2000 Eazel, Inc.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program 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
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   $Id: eazel-theme-main.c,v 1.15 2001/03/23 22:53:04 jsh Exp $
+
+   Authors: The Rasterman <raster@redhat.com>
+            Owen Taylor <otaylor@redhat.com>
+	    Randy Gordon <randy@integrand.com>
+	    John Harper <jsh@eazel.com>   */
+
+/* adapted from gtk-engines/notif/notif_theme_main.c
+   and gtk-engines/metal/metal_theme_main.c */
+
+#include "eazel-theme.h"
+#include <gdk/gdkrgb.h>
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <memory.h>
+#include <gmodule.h>
+
+#ifndef G_TOKEN_COLON
+# define G_TOKEN_COLON ((guint) ':')
+#endif
+#ifndef G_TOKEN_LESS_THAN
+# define G_TOKEN_LESS_THAN ((guint) '<')
+#endif
+#ifndef G_TOKEN_GREATER_THAN
+# define G_TOKEN_GREATER_THAN ((guint) '>')
+#endif
+
+#define WINDOW_FOCUS_DATA_KEY "eazel-engine-focus-data"
+static GQuark window_focus_data_key;
+
+/* saved values */
+static int range_slider_width, range_min_slider_size, range_stepper_size,
+    range_stepper_slider_spacing, scale_slider_length,
+    check_size, check_spacing;
+
+static void install_focus_hooks (GdkWindow *window);
+static void uninstall_all_focus_hooks (void);
+
+
+/* utilities */
+
+static char *
+read_line_from_file (char *filename)
+{
+    gboolean free_filename = FALSE;
+    FILE *fh;
+    char *ret = 0;
+
+    if (!g_path_is_absolute (filename))
+    {
+	char *home = g_get_home_dir ();
+	char buf[PATH_MAX];
+	g_snprintf (buf, PATH_MAX, "%s/%s", home, filename);
+	filename = g_strdup (buf);
+	free_filename = TRUE;
+    }
+
+    fh = fopen (filename, "r");
+    if (fh != 0)
+    {
+	char buf[256];
+	if (fgets (buf, sizeof (buf), fh) != 0)
+	{
+	    int len = strlen (buf);
+	    if (len > 0)
+		buf[len-1] = 0;
+	    ret = g_strdup (buf);
+	}
+	fclose (fh);
+    }
+
+    if (free_filename)
+	g_free (filename);
+
+    return ret;
+}
+
+
+/* internals */
+
+struct symbol_struct {
+    gchar *name;
+    guint token;
+};
+
+static struct symbol_struct theme_symbols[] = { THEME_SYMBOLS };
+
+static guint n_theme_symbols = (sizeof(theme_symbols) / sizeof(theme_symbols[0])) - 1;
+
+static struct symbol_struct stock_symbols[] = { STOCK_SYMBOLS };
+
+static guint n_stock_symbols = (sizeof(stock_symbols) / sizeof(stock_symbols[0])) - 1;
+
+static eazel_theme_data *default_theme_data;
+static eazel_engine_stock_table *default_stock_data;
+
+static eazel_theme_data original_theme_data = DEFAULT_THEME_DATA;
+
+static int
+stock_index (const char *symbol)
+{
+    int i;
+    for (i = 0; i < n_stock_symbols; i++)
+    {
+	if (strcmp (symbol, stock_symbols[i].name) == 0)
+	    return i;
+    }
+    g_error ("Unknown stock symbol: `%s'\n", symbol);
+    exit (1);
+}
+
+static void
+theme_data_ref (eazel_theme_data *theme_data)
+{
+    theme_data->refcount++;
+}
+
+static void
+theme_data_unref (eazel_theme_data *theme_data)
+{
+    theme_data->refcount--;
+    if (theme_data->refcount == 0)
+    {
+	int i;
+	for (i = 0; i < 5; i++)
+	{
+	    if (theme_data->gradients[i] != NULL)
+		eazel_engine_gradient_unref (theme_data->gradients[i]);
+	}
+	eazel_engine_stock_table_unref (theme_data->stock);
+	g_free (theme_data);
+    }
+}
+
+static guint
+parse_int_assign (GScanner *scanner, guint *value)
+{
+    guint token;
+
+    (void) g_scanner_get_next_token (scanner);
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_EQUAL_SIGN)
+	return G_TOKEN_EQUAL_SIGN;
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_INT)
+	return G_TOKEN_INT;
+
+    *value = scanner->value.v_int;
+    return G_TOKEN_NONE;
+}
+
+static guint
+parse_int_array_assign (GScanner *scanner, guint *value, int size)
+{
+    guint token;
+    int i;
+
+    (void) g_scanner_get_next_token (scanner);
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_EQUAL_SIGN)
+	return G_TOKEN_EQUAL_SIGN;
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_LEFT_CURLY)
+	return G_TOKEN_LEFT_CURLY;
+
+    for (i = 0; i < size; i++)
+    {
+	if (i != 0)
+	{
+	    token = g_scanner_get_next_token (scanner);
+	    if (token != G_TOKEN_COMMA)
+		return G_TOKEN_COMMA;
+	}
+
+	token = g_scanner_get_next_token (scanner);
+	if (token != G_TOKEN_INT)
+	    return G_TOKEN_INT;
+
+	value[i] = scanner->value.v_int;
+    }
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_RIGHT_CURLY)
+	return G_TOKEN_RIGHT_CURLY;
+
+    return G_TOKEN_NONE;
+}
+
+static guint
+parse_boolean_assign (GScanner *scanner, gboolean *value)
+{
+    guint token;
+
+    (void) g_scanner_get_next_token (scanner);
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_EQUAL_SIGN)
+	return G_TOKEN_EQUAL_SIGN;
+
+    token = g_scanner_get_next_token (scanner);
+    if (token == TOKEN_YES)
+    {
+	*value = TRUE;
+	return G_TOKEN_NONE;
+    }
+    else
+    {
+	*value = FALSE;
+	return G_TOKEN_NONE;
+    }
+}
+
+static guint
+parse_string_assign (GScanner *scanner, char **value)
+{
+    guint token;
+
+    (void) g_scanner_get_next_token (scanner);
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_EQUAL_SIGN)
+	return G_TOKEN_EQUAL_SIGN;
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_STRING)
+	return G_TOKEN_STRING;
+
+    *value = g_strdup (scanner->value.v_string);
+    return G_TOKEN_NONE;
+}
+
+static guint
+parse_color (eazel_theme_data *theme_data, GScanner *scanner, GdkColor *color)
+{
+    guint token;
+
+    token = g_scanner_peek_next_token (scanner);
+    if (theme_data != 0 && token == G_TOKEN_LESS_THAN)
+    {
+	(void) g_scanner_get_next_token (scanner);
+
+	token = g_scanner_get_next_token (scanner);
+
+	if (token == G_TOKEN_INT)
+	{
+	    int index = scanner->value.v_int;
+
+	    if (index < 0 || index >= EAZEL_ENGINE_PALETTE_SIZE)
+	    {
+		g_error ("Palette only has %d entries\n",
+			 EAZEL_ENGINE_PALETTE_SIZE);
+	    }
+		    
+	    index = CLAMP (index, 0, EAZEL_ENGINE_PALETTE_SIZE - 1);
+
+	    /* XXX just taking the first color of the gradient.. */
+	    if (theme_data->palette[index] != 0)
+		*color = theme_data->palette[index]->from;
+	    else
+		g_error ("No color in palette with index %d", index);
+
+	    token = g_scanner_peek_next_token (scanner);
+	    if (token == G_TOKEN_COMMA)
+	    {
+		float tem;
+
+		(void) g_scanner_get_next_token (scanner);
+
+		token = g_scanner_get_next_token (scanner);
+		if (token != G_TOKEN_FLOAT)
+		    return G_TOKEN_FLOAT;
+
+		tem = color->red;
+		tem *= scanner->value.v_float;
+		color->red = tem;
+
+		tem = color->green;
+		tem *= scanner->value.v_float;
+		color->green = tem;
+
+		tem = color->blue;
+		tem *= scanner->value.v_float;
+		color->blue = tem;
+	    }
+	}
+	else if (token == G_TOKEN_STRING)
+	{
+	    char *string;
+	    gboolean ret = FALSE;
+
+	    string = read_line_from_file (scanner->value.v_string);
+	    if (string != 0)
+		ret = gdk_color_parse (string, color);
+
+	    if (!ret)
+	    {
+		/* Default to the Eazel Teal color */
+		color->red = 0x5050;
+		color->green = 0x8080;
+		color->blue = 0x8383;
+	    }
+
+	    g_free (string);
+	}
+	else
+	    return G_TOKEN_INT;
+
+	token = g_scanner_get_next_token (scanner);
+	if (token != G_TOKEN_GREATER_THAN)
+	    return G_TOKEN_GREATER_THAN;
+
+	return G_TOKEN_NONE;
+    }
+    else
+	return gtk_rc_parse_color (scanner, color);
+}
+
+static guint
+parse_n_colors (eazel_theme_data *theme_data,
+		GScanner *scanner, GdkColor *value, int n)
+{
+    guint token;
+    int i;
+    for (i = 0; i < n; i++)
+    {
+	if (i != 0)
+	{
+	    token = g_scanner_get_next_token (scanner);
+	    if (token != G_TOKEN_COMMA)
+		return G_TOKEN_COMMA;
+	}
+
+	token = parse_color (theme_data, scanner, value + i);
+	if (token != G_TOKEN_NONE)
+	    return token;
+    }
+    return G_TOKEN_NONE;
+}
+
+static guint
+parse_n_color_assign (eazel_theme_data *theme_data,
+		      GScanner *scanner, GdkColor *value, int n)
+{
+    guint token;
+
+    (void) g_scanner_get_next_token (scanner);
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_EQUAL_SIGN)
+	return G_TOKEN_EQUAL_SIGN;
+
+    return parse_n_colors (theme_data, scanner, value, n);
+}
+
+static guint
+parse_color_assign (eazel_theme_data *theme_data,
+		    GScanner *scanner, GdkColor *color)
+{
+    return parse_n_color_assign (theme_data, scanner, color, 1);
+}
+
+static guint
+parse_standard_color_assign (eazel_theme_data *theme_data, GScanner *scanner,
+			     GtkRcStyle *rc_style, GdkColor *colors, int flag)
+{
+    GtkStateType state;
+    guint token;
+
+    (void) g_scanner_get_next_token (scanner);
+
+    token = gtk_rc_parse_state (scanner, &state);
+    if (token != G_TOKEN_NONE)
+	return token;
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_EQUAL_SIGN)
+	return G_TOKEN_EQUAL_SIGN;
+
+    token = parse_color (theme_data, scanner, colors + state);
+    if (token != G_TOKEN_NONE)
+	return token;
+
+    rc_style->color_flags[state] |= flag;
+    return G_TOKEN_NONE;
+}
+
+static guint
+parse_gradient (eazel_theme_data *theme_data, GScanner *scanner,
+		eazel_engine_gradient **gradient)
+{
+    eazel_engine_gradient_direction direction;
+    GdkColor from;
+    GSList *colors = NULL;
+
+    guint token;
+
+    token = g_scanner_get_next_token (scanner);
+
+    if (token == G_TOKEN_LESS_THAN)
+    {
+	int index;
+
+	/* a palette reference */
+
+	token = g_scanner_get_next_token (scanner);
+	if (token != G_TOKEN_INT)
+	    return G_TOKEN_INT;
+
+	index = scanner->value.v_int;
+	if (index < 0 || index >= EAZEL_ENGINE_PALETTE_SIZE)
+	{
+	    g_error ("Palette only has %d entries\n",
+		     EAZEL_ENGINE_PALETTE_SIZE);
+	}
+		    
+	if (theme_data->palette[index] != 0)
+	    *gradient = eazel_engine_gradient_ref (theme_data->palette[index]);
+	else
+	    g_error ("No color in palette with index %d", index);
+
+	token = g_scanner_get_next_token (scanner);
+	if (token != G_TOKEN_GREATER_THAN)
+	    return G_TOKEN_GREATER_THAN;
+
+	return G_TOKEN_NONE;
+    }
+    else if (token != G_TOKEN_LEFT_CURLY)
+	return G_TOKEN_LEFT_CURLY;
+
+    token = g_scanner_peek_next_token (scanner);
+    if (token == TOKEN_HORIZONTAL)
+    {
+	direction = GRADIENT_HORIZONTAL;
+	(void) g_scanner_get_next_token (scanner);
+
+	token = g_scanner_get_next_token (scanner);
+	if (token != G_TOKEN_COLON)
+	    return G_TOKEN_COLON;
+    }
+    else if (token == TOKEN_VERTICAL)
+    {
+	direction = GRADIENT_VERTICAL;
+	(void) g_scanner_get_next_token (scanner);
+
+	token = g_scanner_get_next_token (scanner);
+	if (token != G_TOKEN_COLON)
+	    return G_TOKEN_COLON;
+    }
+    else if (token == G_TOKEN_RIGHT_CURLY)
+	direction = GRADIENT_NONE;
+    else
+	direction = GRADIENT_VERTICAL;
+
+    if (direction != GRADIENT_NONE)
+    {
+	token = parse_color (theme_data, scanner, &from);
+	if (token != G_TOKEN_NONE)
+	    return token;
+
+	while (1)
+	{
+	    float weight = 1.0;
+	    GdkColor color;
+	    eazel_engine_gradient_component *component;
+
+	    token = g_scanner_peek_next_token (scanner);
+	    if (token == G_TOKEN_COMMA)
+		(void) g_scanner_get_next_token (scanner);
+	    else if (token == G_TOKEN_LEFT_BRACE)
+	    {
+		(void) g_scanner_get_next_token (scanner);
+
+		token = g_scanner_get_next_token (scanner);
+		if (token == G_TOKEN_FLOAT)
+		    weight = scanner->value.v_float;
+		else if (token == G_TOKEN_INT)
+		    weight = scanner->value.v_int;
+		else
+		    return G_TOKEN_FLOAT;
+
+		token = g_scanner_get_next_token (scanner);
+		if (token != G_TOKEN_RIGHT_BRACE)
+		    return G_TOKEN_RIGHT_BRACE;
+	    }
+	    else
+		break;
+
+	    token = parse_color (theme_data, scanner, &color);
+	    if (token != G_TOKEN_NONE)
+		return token;
+
+	    component = g_new (eazel_engine_gradient_component, 1);
+	    component->color = color;
+	    component->weight = weight;
+	    colors = g_slist_prepend (colors, component);
+	}
+
+	colors = g_slist_reverse (colors);
+    }
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_RIGHT_CURLY)
+	return G_TOKEN_RIGHT_CURLY;
+
+    if (*gradient != NULL)
+	eazel_engine_gradient_unref (*gradient);
+    *gradient = eazel_engine_gradient_new (direction, &from, colors);
+
+    return G_TOKEN_NONE;
+}
+
+static guint
+parse_gradient_assign (eazel_theme_data *theme_data, GScanner *scanner,
+		       eazel_engine_gradient **gradients)
+{
+    guint token, state;
+
+    (void) g_scanner_get_next_token (scanner);
+
+    token = gtk_rc_parse_state (scanner, &state);
+    if (token != G_TOKEN_NONE)
+	return token;
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_EQUAL_SIGN)
+	return G_TOKEN_EQUAL_SIGN;
+
+    token = parse_gradient (theme_data, scanner, gradients + state);
+    if (token != G_TOKEN_NONE)
+	return token;
+
+    return G_TOKEN_NONE;
+}
+
+static guint
+parse_1_gradient_assign (eazel_theme_data *theme_data, GScanner *scanner,
+			 eazel_engine_gradient **gradient)
+{
+    guint token;
+
+    (void) g_scanner_get_next_token (scanner);
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_EQUAL_SIGN)
+	return G_TOKEN_EQUAL_SIGN;
+
+    token = parse_gradient (theme_data, scanner, gradient);
+    if (token != G_TOKEN_NONE)
+	return token;
+
+    return G_TOKEN_NONE;
+}
+
+static guint
+parse_stock_stmt (GScanner *scanner, eazel_theme_data *theme_data,
+		  eazel_engine_stock_table **table_ptr)
+{
+    eazel_engine_stock_table *table = g_new0 (eazel_engine_stock_table, 1);
+    guint token;
+
+    table->ref_count = 1;
+
+    (void) g_scanner_get_next_token (scanner);
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_LEFT_CURLY)
+	return G_TOKEN_LEFT_CURLY;
+
+    token = g_scanner_peek_next_token (scanner);
+    while (token != G_TOKEN_RIGHT_CURLY)
+    {
+	switch (token)
+	{
+	    guint stock;
+	    eazel_engine_image *image;
+
+	case G_TOKEN_STRING:
+	    (void) g_scanner_get_next_token (scanner);
+
+	    stock = stock_index (scanner->value.v_string);
+	    image = &table->images[stock];
+
+	    token = g_scanner_get_next_token (scanner);
+	    if (token != G_TOKEN_LEFT_CURLY)
+		return G_TOKEN_LEFT_CURLY;
+
+	    token = g_scanner_peek_next_token (scanner);
+	    while (token != G_TOKEN_RIGHT_CURLY)
+	    {
+		switch (token)
+		{
+		case TOKEN_IMAGE:
+		    token = parse_string_assign (scanner, &image->filename);
+		    break;
+
+		case TOKEN_BORDER:
+		    token = parse_int_array_assign (scanner, image->border, 4);
+		    break;
+
+		case TOKEN_RECOLOR:
+		    token = parse_1_gradient_assign (theme_data, scanner,
+						     &image->recolor);
+		    break;
+
+		default:
+		    g_scanner_get_next_token (scanner);
+		    token = G_TOKEN_RIGHT_CURLY;
+		    break;
+		}
+
+		if (token != G_TOKEN_NONE)
+		    goto out;
+
+		token = g_scanner_peek_next_token (scanner);
+	    }
+
+	    token = g_scanner_get_next_token (scanner);
+	    if (token == G_TOKEN_RIGHT_CURLY)
+		token = G_TOKEN_NONE;
+	    else
+		token = G_TOKEN_RIGHT_CURLY;
+	    break;
+
+	default:
+	    g_scanner_get_next_token (scanner);
+	    token = G_TOKEN_RIGHT_CURLY;
+	    break;
+	}
+    
+    out:
+	if (token != G_TOKEN_NONE)
+	{
+	    g_free (table);
+	    return token;
+	}
+
+    	token = g_scanner_peek_next_token (scanner);
+    }
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_RIGHT_CURLY)
+	return G_TOKEN_RIGHT_CURLY;
+
+    *table_ptr = table;
+    return G_TOKEN_NONE;
+}
+
+static guint
+parse_palette_assign (GScanner *scanner, eazel_theme_data *theme_data)
+{
+    int index;
+    guint token;
+
+    (void) g_scanner_get_next_token (scanner);
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_LEFT_BRACE)
+	return G_TOKEN_LEFT_BRACE;
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_INT)
+	return G_TOKEN_INT;
+
+    index = scanner->value.v_int;
+    if (index < 0 || index >= EAZEL_ENGINE_PALETTE_SIZE)
+    {
+	g_error ("Only %d colors are allowed in the palette",
+		 EAZEL_ENGINE_PALETTE_SIZE);
+    }
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_RIGHT_BRACE)
+	return G_TOKEN_RIGHT_BRACE;
+
+    token = g_scanner_get_next_token (scanner);
+    if (token != G_TOKEN_EQUAL_SIGN)
+	return G_TOKEN_EQUAL_SIGN;
+
+    token = parse_gradient (theme_data, scanner, &theme_data->palette[index]);
+    if (token != G_TOKEN_NONE)
+	return token;
+
+    return G_TOKEN_NONE;
+}
+
+/* external theme functions called */
+
+static guint
+theme_parse_rc_style (GScanner *scanner, GtkRcStyle *rc_style)
+{
+    static GQuark scope_id = 0;
+    guint old_scope;
+    guint token;
+    eazel_theme_data *theme_data;
+    gint i;
+    gboolean had_stock_table = FALSE;
+
+    /* Set up a new scope in this scanner. */
+
+    if (!scope_id)
+	scope_id = g_quark_from_string ("theme_engine");
+
+    /* If we bail out due to errors, we *don't* reset the scope, so the
+       error messaging code can make sense of our tokens. */
+    old_scope = g_scanner_set_scope (scanner, scope_id);
+
+    /* Now check if we already added our symbols to this scope
+      (in some previous call to theme_parse_rc_style for the
+      same scanner. */
+
+    if (!g_scanner_lookup_symbol (scanner, theme_symbols[0].name))
+    {
+	g_scanner_freeze_symbol_table(scanner);
+	for (i = 0; i < n_theme_symbols; i++)
+	{
+	    g_scanner_scope_add_symbol (scanner, scope_id,
+					theme_symbols[i].name,
+					GINT_TO_POINTER(theme_symbols[i].token));
+	}
+	g_scanner_thaw_symbol_table (scanner);
+    }
+
+    /* We're ready to go, now parse the top level */
+
+    theme_data = g_new (eazel_theme_data, 1);
+    if (default_theme_data != 0)
+	memcpy (theme_data, default_theme_data, sizeof (eazel_theme_data));
+    else
+	memcpy (theme_data, &original_theme_data, sizeof (eazel_theme_data));
+
+    /* ref all gradients */
+    for (i = 0; i < 5; i++)
+    {
+	if (theme_data->gradients[i] != NULL)
+	    theme_data->gradients[i] = (eazel_engine_gradient_ref
+					(theme_data->gradients[i]));
+    }
+    for (i = 0; i < EAZEL_ENGINE_PALETTE_SIZE; i++)
+    {
+	if (theme_data->palette[i] != NULL)
+	    theme_data->palette[i] = (eazel_engine_gradient_ref
+				      (theme_data->palette[i]));
+    }
+
+    theme_data->refcount = 1;
+
+    if (default_stock_data != 0)
+	theme_data->stock = eazel_engine_stock_table_ref (default_stock_data);
+    else
+	theme_data->stock = 0;
+
+    token = g_scanner_peek_next_token(scanner);
+    while (token != G_TOKEN_RIGHT_CURLY)
+    {
+	switch (token)
+	{
+	    gboolean tem;
+	    eazel_engine_stock_table *stock_tem;
+
+	case TOKEN_THICKNESS:
+	    token = parse_int_assign (scanner, &theme_data->thickness);
+	    break;
+
+	case TOKEN_FOCUS_THICKNESS:
+	    token = parse_int_assign (scanner, &theme_data->focus_thickness);
+	    break;
+
+	case TOKEN_DEFAULT_THICKNESS:
+	    token = parse_int_assign (scanner, &theme_data->default_thickness);
+	    break;
+
+	case TOKEN_FOCUS_COLOR:
+	    token = parse_color_assign (theme_data, scanner,
+					&theme_data->focus_color);
+	    break;
+
+	case TOKEN_INSENSITIVE_COLORS:
+	    token = parse_n_color_assign (theme_data, scanner,
+					  theme_data->insensitive_colors, 2);
+	    break;
+
+	case TOKEN_GRADIENT:
+	    token = parse_gradient_assign (theme_data, scanner,
+					   theme_data->gradients);
+	    break;
+
+	case TOKEN_SHADOW:
+	    token = parse_boolean_assign (scanner, &tem);
+	    if (token == G_TOKEN_NONE)
+		theme_data->no_shadow = !tem;
+	    break;
+
+	case TOKEN_INVERSE_SHADOW:
+	    token = parse_boolean_assign (scanner, &tem);
+	    if (token == G_TOKEN_NONE)
+		theme_data->inverse_shadow = tem;
+	    break;
+
+	case TOKEN_OUTLINE_SHADOW:
+	    token = parse_boolean_assign (scanner, &tem);
+	    if (token == G_TOKEN_NONE)
+		theme_data->outline_shadow = !tem;
+	    break;
+
+	case TOKEN_PALETTE:
+	    token = parse_palette_assign (scanner, theme_data);
+	    break;
+
+	case TOKEN_STOCK:
+	    token = parse_stock_stmt (scanner, theme_data, &stock_tem);
+	    if (token == G_TOKEN_NONE)
+	    {
+		if (theme_data->stock != 0)
+		    eazel_engine_stock_table_unref (theme_data->stock);
+
+		theme_data->stock = stock_tem;
+		had_stock_table = TRUE;
+	    }
+	    break;
+
+	case TOKEN_FG:
+	    token = parse_standard_color_assign (theme_data, scanner, rc_style,
+						 rc_style->fg, GTK_RC_FG);
+	    break;
+
+	case TOKEN_BG:
+	    token = parse_standard_color_assign (theme_data, scanner, rc_style,
+						 rc_style->bg, GTK_RC_BG);
+	    break;
+
+	case TOKEN_BASE:
+	    token = parse_standard_color_assign (theme_data, scanner, rc_style,
+						 rc_style->base, GTK_RC_BASE);
+	    break;
+
+	case TOKEN_TEXT:
+	    token = parse_standard_color_assign (theme_data, scanner, rc_style,
+						 rc_style->text, GTK_RC_TEXT);
+	    break;
+
+	default:
+	    g_scanner_get_next_token (scanner);
+	    token = G_TOKEN_RIGHT_CURLY;
+	    break;
+	}
+
+	if (token != G_TOKEN_NONE)
+	{
+	    g_free (theme_data);
+	    return token;
+	}
+
+	token = g_scanner_peek_next_token (scanner);
+    }
+
+    g_scanner_get_next_token(scanner);
+
+    if (theme_data->stock == 0)
+	g_error ("First `engine' section must include a `stock' section.");
+
+    if (had_stock_table)
+    {
+	/* Defining a stock table makes it the default for any
+	   engine sections in the future that don't have one.. */
+
+	if (default_stock_data != 0)
+	    eazel_engine_stock_table_unref (default_stock_data);
+
+	default_stock_data = eazel_engine_stock_table_ref (theme_data->stock);
+
+	/* Engine data section with stock table (usually the first in
+	   in the file) sets some other default values. A hack, but
+	   a very useful one! */
+
+	if (default_theme_data != 0)
+	    theme_data_unref (default_theme_data);
+
+	theme_data_ref (theme_data);
+	default_theme_data = theme_data;
+    }
+
+    rc_style->engine_data = theme_data;
+    g_scanner_set_scope (scanner, old_scope);
+
+    return G_TOKEN_NONE;
+}
+
+static void
+theme_merge_rc_style (GtkRcStyle *dest, GtkRcStyle *src)
+{
+    eazel_theme_data *src_data = src->engine_data;
+
+    if (!dest->engine_data)
+    {
+	if (src_data)
+	{
+	    theme_data_ref (src_data);
+	    dest->engine_data = src_data;
+	}
+    }
+}
+
+static void
+theme_rc_style_to_style (GtkStyle *style, GtkRcStyle *rc_style)
+{
+    eazel_theme_data *data = rc_style->engine_data;
+
+    switch (data->thickness)
+    {
+    case 0:
+	style->klass = &eazel_class_0;
+	break;
+    case 1:
+	style->klass = &eazel_class_1;
+	break;
+    case 3:
+	style->klass = &eazel_class_3;
+	break;
+    default:
+	g_warning ("eazel theme: Invalid thickness %d in RC file\n",
+		   data->thickness);
+	/* FALL THROUGH */
+    case 2:
+	style->klass = &eazel_class_2;
+	break;
+    }
+    style->engine_data = data;
+    theme_data_ref (data);
+}
+
+static void
+theme_duplicate_style (GtkStyle *dest, GtkStyle *src)
+{
+    dest->klass = src->klass;
+    dest->engine_data = src->engine_data;
+    theme_data_ref (dest->engine_data);
+}
+
+static void
+theme_realize_style (GtkStyle *style)
+{
+}
+
+static void
+theme_unrealize_style (GtkStyle *style)
+{
+}
+
+static void
+theme_destroy_rc_style (GtkRcStyle *rc_style)
+{
+    theme_data_unref (rc_style->engine_data);
+    rc_style->engine_data = NULL;
+}
+
+static void
+theme_destroy_style (GtkStyle *style)
+{
+    theme_data_unref (style->engine_data);
+    style->engine_data = NULL;
+}
+
+static void
+theme_set_background(GtkStyle *style, GdkWindow *window,
+		     GtkStateType state_type)
+{
+    GdkPixmap *pixmap;
+    gint parent_relative;
+    eazel_theme_data *theme_data;
+
+    g_return_if_fail (style != NULL);
+    g_return_if_fail (window != NULL);
+
+    theme_data = STYLE_THEME_DATA (style);
+    g_assert (theme_data != NULL);
+
+    if (style->bg_pixmap[state_type])
+    {
+	if (style->bg_pixmap[state_type] == (GdkPixmap *) GDK_PARENT_RELATIVE)
+	{
+	    pixmap = NULL;
+	    parent_relative = TRUE;
+	}
+	else
+	{
+	    pixmap = style->bg_pixmap[state_type];
+	    parent_relative = FALSE;
+	}
+
+	gdk_window_set_back_pixmap (window, pixmap, parent_relative);
+    }
+    else
+	gdk_window_set_background (window, &style->bg[state_type]);
+
+    install_focus_hooks (window);
+}
+
+void
+theme_init (GtkThemeEngine * engine)
+{
+    GtkRangeClass *rangeclass;
+    GtkScaleClass *scaleclass;
+    GtkCheckButtonClass *checkclass;
+
+    window_focus_data_key = g_quark_from_static_string (WINDOW_FOCUS_DATA_KEY);
+
+    engine->parse_rc_style = theme_parse_rc_style;
+    engine->merge_rc_style = theme_merge_rc_style;
+    engine->rc_style_to_style = theme_rc_style_to_style;
+    engine->duplicate_style = theme_duplicate_style;
+    engine->realize_style = theme_realize_style;
+    engine->unrealize_style = theme_unrealize_style;
+    engine->destroy_rc_style = theme_destroy_rc_style;
+    engine->destroy_style = theme_destroy_style;
+    engine->set_background = theme_set_background;
+
+    /* make scrollbar the correct width */
+    rangeclass = (GtkRangeClass *) gtk_type_class (gtk_range_get_type ());
+    range_slider_width = rangeclass->slider_width;
+    range_min_slider_size = rangeclass->min_slider_size;
+    range_stepper_size = rangeclass->stepper_size;
+    range_stepper_slider_spacing = rangeclass->stepper_slider_spacing;
+    rangeclass->slider_width = RANGE_WIDTH - 4;
+    rangeclass->min_slider_size = MIN_THUMB_HEIGHT;
+    rangeclass->stepper_size = RANGE_WIDTH - 4;
+    rangeclass->stepper_slider_spacing = 0;
+
+    /* Make scale slider smaller */
+    scaleclass = (GtkScaleClass *)gtk_type_class(gtk_scale_get_type());
+    scale_slider_length = scaleclass->slider_length;
+    scaleclass->slider_length = SCALE_HEIGHT;
+
+    /* Make check/radio buttons bigger */
+    checkclass = (GtkCheckButtonClass *)gtk_type_class(gtk_check_button_get_type());
+    check_size = checkclass->indicator_size;
+    check_spacing = checkclass->indicator_spacing;
+    checkclass->indicator_size = CHECK_SIZE;
+    checkclass->indicator_spacing = CHECK_SPACING;
+
+    eazel_engine_install_hacks ();
+
+    gdk_rgb_init ();
+
+    /* Initialize default theme data */
+    original_theme_data.gradients[0] = eazel_engine_make_two_point_gradient (GRADIENT_VERTICAL, 0xeeeeee, 0xaaaaaa);
+    original_theme_data.gradients[1] = eazel_engine_make_two_point_gradient (GRADIENT_VERTICAL, 0xcccccc, 0x888888);
+    original_theme_data.gradients[2] = eazel_engine_make_two_point_gradient (GRADIENT_VERTICAL, 0xffffff, 0xbbbbbb);
+    original_theme_data.gradients[3] = eazel_engine_make_two_point_gradient (GRADIENT_VERTICAL, 0xcccccc, 0x888888);
+}
+
+void
+theme_exit (void)
+{
+    GtkRangeClass *rangeclass;
+    GtkScaleClass *scaleclass;
+    GtkCheckButtonClass *checkclass;
+
+    rangeclass = (GtkRangeClass *)gtk_type_class(gtk_range_get_type());
+    scaleclass = (GtkScaleClass *)gtk_type_class(gtk_scale_get_type());
+    checkclass = (GtkCheckButtonClass *)gtk_type_class(gtk_check_button_get_type());
+
+    rangeclass->slider_width = range_slider_width;
+    rangeclass->min_slider_size = range_min_slider_size;
+    rangeclass->stepper_size = range_stepper_size;
+    rangeclass->stepper_slider_spacing = range_stepper_slider_spacing;
+
+    scaleclass->slider_length = scale_slider_length;
+
+    checkclass->indicator_size = check_size;
+    checkclass->indicator_spacing = check_spacing;
+
+    eazel_engine_remove_hacks ();
+    uninstall_all_focus_hooks ();
+}
+
+
+/* Focus change hooks */
+
+typedef struct focus_change_data_struct focus_change_data;
+struct focus_change_data_struct {
+    GtkWidget *widget;
+
+    gboolean is_focused;
+    gboolean connected;
+
+    guint focus_in_signal_id;
+    guint focus_out_signal_id;
+    guint destroyed_signal_id;
+};
+
+static GSList *focus_data_list = NULL;
+
+static focus_change_data *
+get_focus_data (GtkWidget *widget, gboolean add)
+{
+    GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
+    focus_change_data *data = gtk_object_get_data_by_id (GTK_OBJECT (toplevel),
+							 window_focus_data_key);
+    if (data == 0 && add)
+    {
+	data = g_new0 (focus_change_data, 1);
+	data->widget = widget;
+	gtk_object_set_data_by_id_full (GTK_OBJECT (toplevel),
+					window_focus_data_key,
+					data, g_free);
+	focus_data_list = g_slist_prepend (focus_data_list, data);
+    }
+
+    return data;
+}
+
+static void
+focus_change_helper (GtkWidget *widget, gpointer data)
+{
+    if (GTK_IS_CONTAINER (widget))
+    {
+	gtk_container_forall (GTK_CONTAINER (widget),
+			      focus_change_helper, NULL);
+    }
+    else if (GTK_IS_RANGE (widget))
+    {
+	gtk_widget_queue_draw (widget);
+    }
+    else if (GTK_IS_PROGRESS (widget))
+    {
+	/* This is horrible. But the GtkProgress widget stores the
+	   progress bar in a pixmap, then blits it on expose. But
+	   it will refresh the pixmap when asked to resize.. */
+	if (GTK_WIDGET_DRAWABLE (widget))
+	    gtk_widget_queue_resize (widget);
+    }
+}
+
+static void
+window_focus_in_callback (GtkWidget *window, GdkEventFocus *event,
+			  focus_change_data *data)
+{
+    data->is_focused = TRUE;
+    gtk_container_forall (GTK_CONTAINER (window),
+			  focus_change_helper, NULL);
+}
+
+static void
+window_focus_out_callback (GtkWidget *window, GdkEventFocus *event,
+			   focus_change_data *data)
+{
+    data->is_focused = FALSE;
+    gtk_container_forall (GTK_CONTAINER (window),
+			  focus_change_helper, NULL);
+}
+
+static void
+window_destroyed_callback (GtkWidget *window, focus_change_data *data)
+{
+    focus_data_list = g_slist_remove (focus_data_list, data);
+}
+
+gboolean
+eazel_engine_widget_in_focused_window_p (GtkWidget *widget)
+{
+    focus_change_data *data = get_focus_data (widget, FALSE);
+    return (data != 0) ? data->is_focused : FALSE;
+}
+
+static void
+install_focus_hooks (GdkWindow *window)
+{
+    /* Evilness */
+    GtkWidget *widget;
+    gdk_window_get_user_data (window, (gpointer *) &widget);
+    if (widget != NULL && GTK_IS_WINDOW (widget))
+    {
+	focus_change_data *data = get_focus_data (widget, TRUE);
+	if (!data->connected)
+	{
+	    /* Connect to this window so we get focus-in/out events */
+	    data->focus_in_signal_id
+		= gtk_signal_connect (GTK_OBJECT (widget), "focus_in_event",
+				      window_focus_in_callback, data);
+	    data->focus_out_signal_id
+		= gtk_signal_connect (GTK_OBJECT (widget), "focus_out_event",
+				      window_focus_out_callback, data);
+	    data->destroyed_signal_id
+		= gtk_signal_connect (GTK_OBJECT (widget), "destroy",
+				      window_destroyed_callback, data);
+
+	    data->connected = TRUE;
+	}
+    }
+}
+
+static void
+uninstall_all_focus_hooks (void)
+{
+    GSList *ptr;
+    for (ptr = focus_data_list; ptr != 0; ptr = ptr->next)
+    {
+	focus_change_data *data = ptr->data;
+	if (data->connected)
+	{
+	    gtk_signal_disconnect (GTK_OBJECT (data->widget),
+				   data->focus_in_signal_id);
+	    gtk_signal_disconnect (GTK_OBJECT (data->widget),
+			       data->focus_out_signal_id);
+	    gtk_signal_disconnect (GTK_OBJECT (data->widget),
+				   data->destroyed_signal_id);
+	}
+	gtk_object_remove_data_by_id (GTK_OBJECT (data->widget),
+				      window_focus_data_key);
+    }
+    g_slist_free (focus_data_list);
+    focus_data_list = NULL;
+}
+
+
+/* The following function will be called by GTK+ when the module
+ * is loaded and checks to see if we are compatible with the
+ * version of GTK+ that loads us.
+ */
+
+G_MODULE_EXPORT const gchar *g_module_check_init (GModule *module);
+
+const gchar *
+g_module_check_init (GModule *module)
+{
+  return gtk_check_version (GTK_MAJOR_VERSION,
+			    GTK_MINOR_VERSION,
+			    GTK_MICRO_VERSION - GTK_INTERFACE_AGE);
+}
diff --git a/eazel-engine/src/eazel-theme-pixmaps.c b/eazel-engine/src/eazel-theme-pixmaps.c
new file mode 100644
index 0000000..933b57a
--- /dev/null
+++ b/eazel-engine/src/eazel-theme-pixmaps.c
@@ -0,0 +1,630 @@
+/* eazel-theme-pixmaps.c -- image manipulation and caching
+
+   Copyright (C) 2000 Eazel, Inc.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program 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
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   $Id: eazel-theme-pixmaps.c,v 1.5 2001/01/27 01:19:39 jsh Exp $
+
+   Authors: John Harper <jsh@eazel.com>  */
+
+/* AIX requires this to be the first thing in the file.  */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#ifndef __GNUC__
+# if HAVE_ALLOCA_H
+#  include <alloca.h>
+# else
+#  ifdef _AIX
+ #pragma alloca
+#  else
+#   ifndef alloca /* predefined by HP cc +Olibcalls */
+   char *alloca ();
+#   endif
+#  endif
+# endif
+#endif
+
+#include "eazel-theme.h"
+#include <gdk-pixbuf/gdk-pixbuf.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+
+/* pixmap caching, borrowed from sawfish */
+
+static gulong cached_pixels, max_cached_pixels = 64 * 1024;
+static gulong hits, misses;
+
+typedef struct pixmap_cache_node_struct pixmap_cache_node;
+
+struct pixmap_cache_node_struct {
+    pixmap_cache_node *next, *pred;
+    pixmap_cache_node *newer, *older;
+    eazel_engine_image *im;
+    int width, height;
+    GdkPixmap *p1;
+    GdkBitmap *p2;
+    int ref_count;
+};
+
+static pixmap_cache_node *oldest, *newest;
+
+/* list manipulators */
+
+static void
+remove_from_age_list (pixmap_cache_node *n)
+{
+    if (n->newer != 0)
+	n->newer->older = n->older;
+    else
+	newest = n->older;
+    if (n->older != 0)
+	n->older->newer = n->newer;
+    else
+	oldest = n->newer;
+}
+
+static void
+prepend_to_age_list (pixmap_cache_node *n)
+{
+    n->newer = oldest;
+    if (n->newer != 0)
+	n->newer->older = n;
+    oldest = n;
+    n->older = 0;
+    if (newest == 0)
+	newest = n;
+}
+
+static void
+remove_from_image (pixmap_cache_node *n)
+{
+    if (n->next != 0)
+	n->next->pred = n->pred;
+    else
+	n->im->pixmap_last = n->pred;
+    if (n->pred != 0)
+	n->pred->next = n->next;
+    else
+	n->im->pixmap_first = n->next;
+}
+
+static void
+prepend_to_image (pixmap_cache_node *n)
+{
+    eazel_engine_image *im = n->im;
+    n->next = im->pixmap_first;
+    if (n->next != 0)
+	n->next->pred = n;
+    im->pixmap_first = n;
+    n->pred = 0;
+    if (im->pixmap_last == 0)
+	im->pixmap_last = n;
+}
+
+static void
+free_node (pixmap_cache_node *n, gboolean dealloc)
+{
+    if (n->p1 != 0)
+	gdk_pixmap_unref (n->p1);
+    if (n->p2 != 0)
+	gdk_bitmap_unref (n->p2);
+    if (dealloc)
+	g_free (n);
+}
+
+static void
+delete_node (pixmap_cache_node *n, gboolean dealloc)
+{
+    remove_from_image (n);
+    remove_from_age_list (n);
+    cached_pixels -= n->width * n->height;
+    free_node (n, dealloc);
+}
+
+/* public interface */
+
+static gboolean
+pixmap_cache_ref (eazel_engine_image *im, int width, int height,
+		  GdkPixmap **p1, GdkBitmap **p2)
+{
+    pixmap_cache_node *n;
+    for (n = im->pixmap_first; n != 0; n = n->next)
+    {
+	if (n->width == width && n->height == height)
+	{
+	    remove_from_image (n);
+	    prepend_to_image (n);
+	    remove_from_age_list (n);
+	    prepend_to_age_list (n);
+	    n->ref_count++;
+	    *p1 = n->p1;
+	    *p2 = n->p2;
+	    hits++;
+	    return TRUE;
+	}
+    }
+    misses++;
+    return FALSE;
+}
+
+static void
+pixmap_cache_unref (eazel_engine_image *im, GdkPixmap *p1, GdkBitmap *p2)
+{
+    pixmap_cache_node *n;
+    for (n = im->pixmap_first; n != 0; n = n->next)
+    {
+	if (n->p1 == p1 && n->p2 == p2)
+	{
+	    n->ref_count--;
+#ifdef DISABLE_CACHE
+	    if (n->ref_count == 0)
+		delete_node (n, TRUE);
+#endif		
+	    return;
+	}
+    }
+    fprintf (stderr, "warning: unref'ing unknown image in pixmap-cache\n");
+}
+
+static void
+pixmap_cache_set (eazel_engine_image *im, int width, int height,
+		  GdkPixmap *p1, GdkBitmap *p2)
+{
+    int pixel_count = width * height;
+    pixmap_cache_node *n = 0;
+
+    while (pixel_count + cached_pixels > max_cached_pixels)
+    {
+	/* remove oldest node */
+	pixmap_cache_node *this = oldest;
+	while (this != 0 && this->ref_count > 0)
+	    this = this->newer;
+	if (this == 0)
+	    break;
+	delete_node (this, n != 0);
+	if (n == 0)
+	    n = this;
+    }
+
+    if (n == 0)
+	n = g_new0 (pixmap_cache_node, 1);
+
+    n->im = im;
+    n->width = width;
+    n->height = height;
+    n->p1 = p1;
+    n->p2 = p2;
+    n->ref_count = 1;
+
+    prepend_to_image (n);
+    prepend_to_age_list (n);
+    cached_pixels += pixel_count;
+}
+
+static void
+pixmap_cache_flush_image (eazel_engine_image *im)
+{
+    pixmap_cache_node *n, *next;
+    for (n = im->pixmap_first; n != 0; n = next)
+    {
+	next = n->next;
+	remove_from_age_list (n);
+	free_node (n, TRUE);
+    }
+    im->pixmap_first = im->pixmap_last = 0;
+}
+
+
+/* image filtering */
+
+typedef struct {
+    guchar red, green, blue;
+    guchar alpha;
+} pixbuf_pixel;
+
+/* Returns either a new pixbuf, or PIXBUF with its ref-count incremented */
+static GdkPixbuf *
+map_pixbuf (GdkPixbuf *pixbuf, void (*fun)(pixbuf_pixel *, void *), void *data)
+{
+    int width, height, row_stride;
+    guchar *pixels;
+    int x, y;
+
+    if (gdk_pixbuf_get_n_channels (pixbuf) == 3)
+	pixbuf = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
+    else
+	gdk_pixbuf_ref (pixbuf);
+
+    width = gdk_pixbuf_get_width (pixbuf);
+    height = gdk_pixbuf_get_height (pixbuf);
+    row_stride = gdk_pixbuf_get_rowstride (pixbuf);
+    pixels = gdk_pixbuf_get_pixels (pixbuf);
+
+    g_assert (gdk_pixbuf_get_n_channels (pixbuf) == 4);
+
+    for (y = 0; y < height; y++)
+    {
+	guchar *row_pixels = pixels +  y * row_stride;
+
+	for (x = 0; x < width; x++)
+	{
+	    pixbuf_pixel pixel;
+
+	    pixel.red = row_pixels[0];
+	    pixel.green = row_pixels[1];
+	    pixel.blue = row_pixels[2];
+	    pixel.alpha = row_pixels[3];
+
+	    fun (&pixel, data);
+
+	    row_pixels[0] = pixel.red;
+	    row_pixels[1] = pixel.green;
+	    row_pixels[2] = pixel.blue;
+	    row_pixels[3] = pixel.alpha;
+
+	    row_pixels += 4;
+	}
+    }
+
+    return pixbuf;
+}
+
+struct recolor_closure {
+    guchar rgb_buf[256*3];
+};
+
+static void
+recolor_callback (pixbuf_pixel *pixel, void *data)
+{
+    struct recolor_closure *rc = data;
+    int base;
+
+    /* The trick is this:
+
+       Recolorable pixels must have zero red and blue channels. The
+       green channel gives a notional grey-scale value that is multiplied
+       by the values in the closure */
+
+    if (pixel->red != 0 || pixel->blue != 0)
+	return;
+
+    base = pixel->green * 3;
+
+    pixel->red = rc->rgb_buf[base+0];
+    pixel->green = rc->rgb_buf[base+1];
+    pixel->blue = rc->rgb_buf[base+2];
+}
+
+static GdkPixbuf *
+recolor_pixbuf (GdkPixbuf *pixbuf, eazel_engine_gradient *gradient)
+{
+    struct recolor_closure rc;
+
+    eazel_engine_fill_gradient_rgb_buffer (gradient, 256, rc.rgb_buf, 0, 256);
+
+    return map_pixbuf (pixbuf, recolor_callback, &rc);
+}
+
+
+/* image loading */
+
+/* XXX move to gtkrc */
+static char *image_path[] = {
+    DATADIR,
+    0
+};
+
+static GdkPixbuf *
+load_image (const char *file)
+{
+    char **path = image_path;
+    while (*path != 0)
+    {
+	GdkPixbuf *pixbuf;
+	size_t len = strlen (*path) + strlen (file) + 2;
+	char *buf = alloca (len);
+	sprintf (buf, "%s/%s", *path, file);
+	pixbuf = gdk_pixbuf_new_from_file (buf);
+	if (pixbuf != 0)
+	    return pixbuf;
+	path++;
+    }
+    /* XXX error handling here */
+    g_error ("No such image: %s", file);
+    return 0;
+}
+
+static GdkPixbuf *
+eazel_engine_image_get_pixbuf (eazel_engine_image *p)
+{
+    if (p->pixbuf == 0)
+    {
+	g_assert (p->filename != 0);
+	p->pixbuf = load_image (p->filename);
+
+	if (p->pixbuf == 0)
+	    return 0;
+
+	if (p->recolor != 0)
+	{
+	    GdkPixbuf *new;
+	    new = recolor_pixbuf (p->pixbuf, p->recolor);
+	    if (new != NULL)
+	    {
+		gdk_pixbuf_unref (p->pixbuf);
+		p->pixbuf = new;
+	    }
+	}
+
+    }
+    return p->pixbuf;
+}
+
+
+/* image rendering */
+
+static void
+do_scale (GdkPixbuf *src, int src_x, int src_y, int src_w, int src_h,
+	  GdkPixbuf *dst, int dst_x, int dst_y, int dst_w, int dst_h)
+{
+    double scale_x, scale_y;
+    double off_x, off_y;
+
+    if (src_w <= 0 || src_h <= 0 || dst_w <= 0 || dst_h <= 0)
+	return;
+
+    scale_x = dst_w / (double) src_w;
+    scale_y = dst_h / (double) src_h;
+
+    off_x = dst_x - scale_x * src_x;
+    off_y = dst_y - scale_y * src_y;
+
+    gdk_pixbuf_scale (src, dst,
+		      dst_x, dst_y,
+		      dst_w, dst_h,
+		      off_x, off_y,
+		      scale_x, scale_y,
+		      GDK_INTERP_NEAREST);
+}
+
+static void
+eazel_engine_image_render (eazel_engine_image *image, int width, int height,
+			   GdkPixmap **pixmap, GdkBitmap **mask)
+{
+    GdkPixbuf *im = eazel_engine_image_get_pixbuf (image);
+    GdkPixbuf *scaled = im;
+    gboolean need_to_unref = FALSE;
+    int im_width = gdk_pixbuf_get_width (im);
+    int im_height = gdk_pixbuf_get_height (im);
+
+    g_assert (im != 0);
+    g_return_if_fail (width > 0);
+    g_return_if_fail (height > 0);
+
+    if (pixmap_cache_ref (image, width, height, pixmap, mask))
+	return;
+
+    /* XXX handle cases where combined image borders are larger
+       XXX than the destination image.. */
+
+    if (im_width != width || im_height != height)
+    {
+	/* need to scale to width by height */
+
+	int border[4];
+	border[0] = image->border[0];
+	border[1] = image->border[1];
+	border[2] = image->border[2];
+	border[3] = image->border[3];
+
+	/* truncate borders if dest image is too small */
+	if (border[0] + border[1] > width)
+	{
+	    border[0] = MIN (border[0], width / 2);
+	    border[1] = MIN (border[1], width / 2);
+	}
+	if (border[2] + border[3] > height
+	    || image->border[2] + image->border[3] >= im_height)
+	{
+	    border[2] = MIN (border[2], height / 2);
+	    border[3] = MIN (border[3], height / 2);
+	}
+
+	g_assert (border[0] + border[1] <= width);
+	g_assert (border[2] + border[3] <= height);
+
+	/* create a new buffer */
+	scaled = gdk_pixbuf_new (gdk_pixbuf_get_colorspace (im),
+				 gdk_pixbuf_get_has_alpha (im),
+				 gdk_pixbuf_get_bits_per_sample (im),
+				 width, height);
+	need_to_unref = TRUE;
+
+	/* stretch borders to fit scaled image */
+
+	if (border[0] > 0)
+	{
+	    do_scale (im, 0, image->border[2], image->border[0],
+		      im_height - (image->border[2] + image->border[3]),
+		      scaled, 0, border[2], border[0],
+		      height - (border[2] + border[3]));
+	}
+	if (border[1] > 0)
+	{
+	    do_scale (im, im_width - image->border[1], image->border[2],
+		      image->border[1],
+		      im_height - (image->border[2] + image->border[3]),
+		      scaled, width - border[1], border[2], border[1],
+		      height - (border[2] + border[3]));
+	}
+
+	if (border[2] > 0)
+	{
+	    do_scale (im, image->border[0], 0,
+		      im_width - (image->border[0] + image->border[1]),
+		      image->border[2],
+		      scaled, border[0], 0,
+		      width - (border[0] + border[1]), border[2]);
+	}
+	if (border[3] > 0)
+	{
+	    do_scale (im, image->border[0], im_height - image->border[3],
+		      im_width - (image->border[0] + image->border[1]),
+		      image->border[3],
+		      scaled, border[0], height - border[3],
+		      width - (border[0] + border[1]), border[3]);
+	}
+
+	/* now do corner intersections between borders */
+
+	if (border[0] > 0 && border[2] > 0)
+	{
+	    do_scale (im, 0, 0, image->border[0], image->border[2],
+		      scaled, 0, 0, border[0], border[2]);
+	}
+	if (border[1] > 0 && border[2] > 0)
+	{
+	    do_scale (im, im_width - image->border[1], 0,
+		      image->border[1], image->border[2],
+		      scaled, width - border[1], 0, border[1], border[2]);
+	}
+	if (border[0] > 0 && border[3] > 0)
+	{
+	    do_scale (im, 0, im_height - image->border[3],
+		      image->border[0], image->border[3],
+		      scaled, 0, height - border[3], border[0], border[3]);
+	}
+	if (border[1] > 0 && border[3] > 0)
+	{
+	    do_scale (im, im_width - image->border[1],
+		      im_height - image->border[3],
+		      image->border[1], image->border[3],
+		      scaled, width - border[1], height - border[3],
+		      border[1], border[3]);
+	}
+
+	/* scale the inner parts of the image */
+	if (border[0] + border[1] < width
+	    || border[2] + border[3] < height)
+	{
+	    do_scale (im, image->border[0], image->border[2],
+		      im_width - (image->border[0] + image->border[1]),
+		      im_height - (image->border[2] + image->border[3]),
+		      scaled, border[0], border[2],
+		      width - (border[0] + border[1]),
+		      height - (border[2] + border[3]));
+	}
+    }
+
+    gdk_pixbuf_render_pixmap_and_mask (scaled, pixmap, mask, 128);
+    if (need_to_unref)
+	gdk_pixbuf_unref (scaled);
+
+    pixmap_cache_set (image, width, height, *pixmap, *mask);
+}
+
+static void
+eazel_engine_image_free_pixmaps (eazel_engine_image *image,
+				 GdkPixmap *pixmap, GdkBitmap *mask)
+{
+    pixmap_cache_unref (image, pixmap, mask);
+}
+
+
+/* stock images */
+
+void
+eazel_engine_stock_table_unref (eazel_engine_stock_table *table)
+{
+    table->ref_count--;
+
+    if (table->ref_count == 0)
+    {
+	int i;
+	for (i = 0; i < EAZEL_ENGINE_STOCK_MAX; i++)
+	{
+	    if (table->images[i].pixbuf != 0)
+		gdk_pixbuf_unref (table->images[i].pixbuf);
+	    pixmap_cache_flush_image (&table->images[i]);
+	}
+	g_free (table);
+    }
+}
+
+eazel_engine_stock_table *
+eazel_engine_stock_table_ref (eazel_engine_stock_table *table)
+{
+    table->ref_count++;
+    return table;
+}
+
+static inline eazel_engine_image *
+get_stock_image (eazel_engine_stock_table *table,
+		 eazel_engine_stock_image type)
+{
+    g_assert (type >= 0 && type < EAZEL_ENGINE_STOCK_MAX);
+
+    return &table->images[type];
+}
+
+void
+eazel_engine_stock_pixmap_and_mask_scaled (eazel_engine_stock_table *table,
+					   eazel_engine_stock_image type,
+					   int width, int height,
+					   GdkPixmap **image, GdkBitmap **mask)
+{
+    eazel_engine_image *img = get_stock_image (table, type);
+    eazel_engine_image_render (img, width, height, image, mask);
+}
+
+void
+eazel_engine_stock_pixmap_and_mask (eazel_engine_stock_table *table,
+				    eazel_engine_stock_image type,
+				    GdkPixmap **image, GdkBitmap **mask)
+{
+    eazel_engine_image *img = get_stock_image (table, type);
+    GdkPixbuf *pixbuf = eazel_engine_image_get_pixbuf (img);
+
+    eazel_engine_image_render (img, gdk_pixbuf_get_width (pixbuf),
+			       gdk_pixbuf_get_height (pixbuf),
+			       image, mask);
+}
+
+void
+eazel_engine_stock_free_pixmaps (eazel_engine_stock_table *table,
+				 eazel_engine_stock_image type,
+				 GdkPixmap *image, GdkPixmap *mask)
+{
+    eazel_engine_image *img = get_stock_image (table, type);
+    eazel_engine_image_free_pixmaps (img, image, mask);
+}
+
+void
+eazel_engine_stock_get_size (eazel_engine_stock_table *table,
+			     eazel_engine_stock_image type,
+			     int *width, int *height)
+{
+    eazel_engine_image *img = get_stock_image (table, type);
+    GdkPixbuf *pixbuf = eazel_engine_image_get_pixbuf (img);
+
+    if (width != 0)
+	*width = gdk_pixbuf_get_width (pixbuf);
+    if (height != 0)
+	*height = gdk_pixbuf_get_height (pixbuf);
+}
diff --git a/eazel-engine/src/eazel-theme.h b/eazel-engine/src/eazel-theme.h
new file mode 100644
index 0000000..baa177e
--- /dev/null
+++ b/eazel-engine/src/eazel-theme.h
@@ -0,0 +1,383 @@
+/* eazel-theme.h -- definitions
+
+   Copyright (C) 2000 Eazel, Inc.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program 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
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public License
+   along with this program; if not, write to the Free Software
+   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+
+   $Id: eazel-theme.h,v 1.16 2001/01/27 01:19:39 jsh Exp $
+
+   Authors: John Harper <jsh@eazel.com>  */
+
+#ifndef EAZEL_THEME_H
+#define EAZEL_THEME_H
+
+#include <gtk/gtk.h>
+#include <gdk-pixbuf/gdk-pixbuf.h>
+
+#define RANGE_WIDTH 15
+#define MIN_THUMB_HEIGHT 24
+#define SCALE_HEIGHT 16
+#define CHECK_SIZE 10
+#define CHECK_SPACING 3
+
+
+/* parser / per-engine data */
+
+enum {
+    TOKEN_THICKNESS = GTK_RC_TOKEN_LAST + 1,
+    TOKEN_FOCUS_THICKNESS,
+    TOKEN_DEFAULT_THICKNESS,
+    TOKEN_FOCUS_COLOR,
+    TOKEN_INSENSITIVE_COLORS,
+    TOKEN_NONE,
+    TOKEN_VERTICAL,
+    TOKEN_HORIZONTAL,
+    TOKEN_GRADIENT,
+    TOKEN_SHADOW,
+    TOKEN_INVERSE_SHADOW,
+    TOKEN_OUTLINE_SHADOW,
+    TOKEN_YES,
+    TOKEN_NO,
+    TOKEN_STOCK,
+    TOKEN_BORDER,
+    TOKEN_RECOLOR,
+    TOKEN_PALETTE,
+    TOKEN_IMAGE,
+    TOKEN_FG,
+    TOKEN_BG,
+    TOKEN_BASE,
+    TOKEN_TEXT,
+};
+
+#define THEME_SYMBOLS						\
+  { "thickness", TOKEN_THICKNESS }, 				\
+  { "focus_thickness", TOKEN_FOCUS_THICKNESS },			\
+  { "default_thickness", TOKEN_DEFAULT_THICKNESS },		\
+  { "focus_color", TOKEN_FOCUS_COLOR },				\
+  { "insensitive_colors", TOKEN_INSENSITIVE_COLORS },		\
+  { "none", TOKEN_NONE },					\
+  { "vertical", TOKEN_VERTICAL },				\
+  { "horizontal", TOKEN_HORIZONTAL },				\
+  { "gradient", TOKEN_GRADIENT },				\
+  { "shadow", TOKEN_SHADOW },					\
+  { "inverse_shadow", TOKEN_INVERSE_SHADOW },			\
+  { "outline_shadow", TOKEN_OUTLINE_SHADOW },			\
+  { "yes", TOKEN_YES },						\
+  { "no", TOKEN_NO },						\
+  { "stock", TOKEN_STOCK },					\
+  { "border", TOKEN_BORDER },					\
+  { "recolor", TOKEN_RECOLOR },					\
+  { "palette", TOKEN_PALETTE },					\
+  { "image", TOKEN_IMAGE },					\
+  { "fg", TOKEN_FG },						\
+  { "bg", TOKEN_BG },						\
+  { "base", TOKEN_BASE },					\
+  { "text", TOKEN_TEXT },					\
+  { 0, G_TOKEN_NONE }
+
+typedef enum {
+    GRADIENT_NONE = 0,
+    GRADIENT_VERTICAL,
+    GRADIENT_HORIZONTAL,
+} eazel_engine_gradient_direction;
+
+typedef enum {
+    EAZEL_ENGINE_CHECK = 0,
+    EAZEL_ENGINE_CHECK_FOCUS,
+    EAZEL_ENGINE_CHECK_HI,
+    EAZEL_ENGINE_CHECK_HI_FOCUS,
+    EAZEL_ENGINE_CHECK_PRESSED,
+    EAZEL_ENGINE_CHECK_PRESSED_FOCUS,
+    EAZEL_ENGINE_CHECK_DISABLED,
+    EAZEL_ENGINE_CHECK_ACTIVE,
+    EAZEL_ENGINE_CHECK_ACTIVE_FOCUS,
+    EAZEL_ENGINE_CHECK_ACTIVE_HI,
+    EAZEL_ENGINE_CHECK_ACTIVE_HI_FOCUS,
+    EAZEL_ENGINE_CHECK_ACTIVE_PRESSED,
+    EAZEL_ENGINE_CHECK_ACTIVE_PRESSED_FOCUS,
+    EAZEL_ENGINE_CHECK_ACTIVE_DISABLED,
+    EAZEL_ENGINE_OPTION,
+    EAZEL_ENGINE_OPTION_FOCUS,
+    EAZEL_ENGINE_OPTION_HI,
+    EAZEL_ENGINE_OPTION_HI_FOCUS,
+    EAZEL_ENGINE_OPTION_PRESSED,
+    EAZEL_ENGINE_OPTION_PRESSED_FOCUS,
+    EAZEL_ENGINE_OPTION_DISABLED,
+    EAZEL_ENGINE_OPTION_ACTIVE,
+    EAZEL_ENGINE_OPTION_ACTIVE_FOCUS,
+    EAZEL_ENGINE_OPTION_ACTIVE_HI,
+    EAZEL_ENGINE_OPTION_ACTIVE_HI_FOCUS,
+    EAZEL_ENGINE_OPTION_ACTIVE_PRESSED,
+    EAZEL_ENGINE_OPTION_ACTIVE_PRESSED_FOCUS,
+    EAZEL_ENGINE_OPTION_ACTIVE_DISABLED,
+    EAZEL_ENGINE_H_TROUGH,
+    EAZEL_ENGINE_V_TROUGH,
+    EAZEL_ENGINE_ARROW_UP,
+    EAZEL_ENGINE_ARROW_UP_HI,
+    EAZEL_ENGINE_ARROW_UP_ACTIVE,
+    EAZEL_ENGINE_ARROW_DOWN,
+    EAZEL_ENGINE_ARROW_DOWN_HI,
+    EAZEL_ENGINE_ARROW_DOWN_ACTIVE,
+    EAZEL_ENGINE_ARROW_RIGHT,
+    EAZEL_ENGINE_ARROW_RIGHT_HI,
+    EAZEL_ENGINE_ARROW_RIGHT_ACTIVE,
+    EAZEL_ENGINE_ARROW_LEFT,
+    EAZEL_ENGINE_ARROW_LEFT_HI,
+    EAZEL_ENGINE_ARROW_LEFT_ACTIVE,
+    EAZEL_ENGINE_H_SCROLLBAR,
+    EAZEL_ENGINE_H_SCROLLBAR_HI,
+    EAZEL_ENGINE_H_SCROLLBAR_INACTIVE,
+    EAZEL_ENGINE_H_SCROLLBAR_THUMB,
+    EAZEL_ENGINE_H_SCROLLBAR_THUMB_HI,
+    EAZEL_ENGINE_H_SCROLLBAR_THUMB_INACTIVE,
+    EAZEL_ENGINE_V_SCROLLBAR,
+    EAZEL_ENGINE_V_SCROLLBAR_HI,
+    EAZEL_ENGINE_V_SCROLLBAR_INACTIVE,
+    EAZEL_ENGINE_V_SCROLLBAR_THUMB,
+    EAZEL_ENGINE_V_SCROLLBAR_THUMB_HI,
+    EAZEL_ENGINE_V_SCROLLBAR_THUMB_INACTIVE,
+    EAZEL_ENGINE_PROGRESS_BAR,
+    EAZEL_ENGINE_PROGRESS_BAR_LEFT,
+    EAZEL_ENGINE_PROGRESS_BAR_RIGHT,
+    EAZEL_ENGINE_PROGRESS_BAR_INACTIVE,
+    EAZEL_ENGINE_PROGRESS_TROUGH,
+    EAZEL_ENGINE_H_SLIDER_THUMB,
+    EAZEL_ENGINE_H_SLIDER_THUMB_INACTIVE,
+    EAZEL_ENGINE_H_SLIDER_TROUGH,
+    EAZEL_ENGINE_H_SLIDER_TROUGH_ACTIVE,
+    EAZEL_ENGINE_V_SLIDER_THUMB,
+    EAZEL_ENGINE_V_SLIDER_THUMB_INACTIVE,
+    EAZEL_ENGINE_V_SLIDER_TROUGH,
+    EAZEL_ENGINE_V_SLIDER_TROUGH_ACTIVE,
+    EAZEL_ENGINE_TAB_TOP,
+    EAZEL_ENGINE_TAB_TOP_LEFT,
+    EAZEL_ENGINE_TAB_TOP_ACTIVE,
+    EAZEL_ENGINE_TAB_BOTTOM,
+    EAZEL_ENGINE_TAB_BOTTOM_LEFT,
+    EAZEL_ENGINE_TAB_BOTTOM_ACTIVE,
+    EAZEL_ENGINE_SPIN_ARROW_UP,
+    EAZEL_ENGINE_SPIN_ARROW_DOWN,
+    EAZEL_ENGINE_STOCK_MAX,
+} eazel_engine_stock_image;
+
+#define STOCK_SYMBOLS 									\
+    { "CHECK", EAZEL_ENGINE_CHECK },							\
+    { "CHECK_FOCUS", EAZEL_ENGINE_CHECK_FOCUS },					\
+    { "CHECK_HI", EAZEL_ENGINE_CHECK_HI },						\
+    { "CHECK_HI_FOCUS", EAZEL_ENGINE_CHECK_HI_FOCUS },					\
+    { "CHECK_PRESSED", EAZEL_ENGINE_CHECK_PRESSED },					\
+    { "CHECK_PRESSED_FOCUS", EAZEL_ENGINE_CHECK_PRESSED_FOCUS },			\
+    { "CHECK_DISABLED", EAZEL_ENGINE_CHECK_DISABLED },					\
+    { "CHECK_ACTIVE", EAZEL_ENGINE_CHECK_ACTIVE },					\
+    { "CHECK_ACTIVE_FOCUS", EAZEL_ENGINE_CHECK_ACTIVE_FOCUS },				\
+    { "CHECK_ACTIVE_HI", EAZEL_ENGINE_CHECK_ACTIVE_HI },				\
+    { "CHECK_ACTIVE_HI_FOCUS", EAZEL_ENGINE_CHECK_ACTIVE_HI_FOCUS },			\
+    { "CHECK_ACTIVE_PRESSED", EAZEL_ENGINE_CHECK_ACTIVE_PRESSED },			\
+    { "CHECK_ACTIVE_PRESSED_FOCUS", EAZEL_ENGINE_CHECK_ACTIVE_PRESSED_FOCUS },		\
+    { "CHECK_ACTIVE_DISABLED", EAZEL_ENGINE_CHECK_ACTIVE_DISABLED },			\
+    { "OPTION", EAZEL_ENGINE_OPTION },							\
+    { "OPTION_FOCUS", EAZEL_ENGINE_OPTION_FOCUS },					\
+    { "OPTION_HI", EAZEL_ENGINE_OPTION_HI },						\
+    { "OPTION_HI_FOCUS", EAZEL_ENGINE_OPTION_HI_FOCUS },				\
+    { "OPTION_PRESSED", EAZEL_ENGINE_OPTION_PRESSED },					\
+    { "OPTION_PRESSED_FOCUS", EAZEL_ENGINE_OPTION_PRESSED_FOCUS },			\
+    { "OPTION_DISABLED", EAZEL_ENGINE_OPTION_DISABLED },				\
+    { "OPTION_ACTIVE", EAZEL_ENGINE_OPTION_ACTIVE },					\
+    { "OPTION_ACTIVE_FOCUS", EAZEL_ENGINE_OPTION_ACTIVE_FOCUS },			\
+    { "OPTION_ACTIVE_HI", EAZEL_ENGINE_OPTION_ACTIVE_HI },				\
+    { "OPTION_ACTIVE_HI_FOCUS", EAZEL_ENGINE_OPTION_ACTIVE_HI_FOCUS },			\
+    { "OPTION_ACTIVE_PRESSED", EAZEL_ENGINE_OPTION_ACTIVE_PRESSED },			\
+    { "OPTION_ACTIVE_PRESSED_FOCUS", EAZEL_ENGINE_OPTION_ACTIVE_PRESSED_FOCUS },	\
+    { "OPTION_ACTIVE_DISABLED", EAZEL_ENGINE_OPTION_ACTIVE_DISABLED },			\
+    { "H_TROUGH", EAZEL_ENGINE_H_TROUGH },						\
+    { "V_TROUGH", EAZEL_ENGINE_V_TROUGH },						\
+    { "ARROW_UP", EAZEL_ENGINE_ARROW_UP },						\
+    { "ARROW_UP_HI", EAZEL_ENGINE_ARROW_UP_HI },					\
+    { "ARROW_UP_ACTIVE", EAZEL_ENGINE_ARROW_UP_ACTIVE },				\
+    { "ARROW_DOWN", EAZEL_ENGINE_ARROW_DOWN },						\
+    { "ARROW_DOWN_HI", EAZEL_ENGINE_ARROW_DOWN_HI },					\
+    { "ARROW_DOWN_ACTIVE", EAZEL_ENGINE_ARROW_DOWN_ACTIVE },				\
+    { "ARROW_RIGHT", EAZEL_ENGINE_ARROW_RIGHT },					\
+    { "ARROW_RIGHT_HI", EAZEL_ENGINE_ARROW_RIGHT_HI },					\
+    { "ARROW_RIGHT_ACTIVE", EAZEL_ENGINE_ARROW_RIGHT_ACTIVE },				\
+    { "ARROW_LEFT", EAZEL_ENGINE_ARROW_LEFT },						\
+    { "ARROW_LEFT_HI", EAZEL_ENGINE_ARROW_LEFT_HI },					\
+    { "ARROW_LEFT_ACTIVE", EAZEL_ENGINE_ARROW_LEFT_ACTIVE },				\
+    { "H_SCROLLBAR", EAZEL_ENGINE_H_SCROLLBAR },					\
+    { "H_SCROLLBAR_HI", EAZEL_ENGINE_H_SCROLLBAR_HI },					\
+    { "H_SCROLLBAR_INACTIVE", EAZEL_ENGINE_H_SCROLLBAR_INACTIVE },			\
+    { "H_SCROLLBAR_THUMB", EAZEL_ENGINE_H_SCROLLBAR_THUMB },				\
+    { "H_SCROLLBAR_THUMB_HI", EAZEL_ENGINE_H_SCROLLBAR_THUMB_HI },			\
+    { "H_SCROLLBAR_THUMB_INACTIVE", EAZEL_ENGINE_H_SCROLLBAR_THUMB_INACTIVE },		\
+    { "V_SCROLLBAR", EAZEL_ENGINE_V_SCROLLBAR },					\
+    { "V_SCROLLBAR_HI", EAZEL_ENGINE_V_SCROLLBAR_HI },					\
+    { "V_SCROLLBAR_INACTIVE", EAZEL_ENGINE_V_SCROLLBAR_INACTIVE },			\
+    { "V_SCROLLBAR_THUMB", EAZEL_ENGINE_V_SCROLLBAR_THUMB },				\
+    { "V_SCROLLBAR_THUMB_HI", EAZEL_ENGINE_V_SCROLLBAR_THUMB_HI },			\
+    { "V_SCROLLBAR_THUMB_INACTIVE", EAZEL_ENGINE_V_SCROLLBAR_THUMB_INACTIVE },		\
+    { "PROGRESS_BAR", EAZEL_ENGINE_PROGRESS_BAR },					\
+    { "PROGRESS_BAR_LEFT", EAZEL_ENGINE_PROGRESS_BAR_LEFT },				\
+    { "PROGRESS_BAR_RIGHT", EAZEL_ENGINE_PROGRESS_BAR_RIGHT },				\
+    { "PROGRESS_BAR_INACTIVE", EAZEL_ENGINE_PROGRESS_BAR_INACTIVE },			\
+    { "PROGRESS_TROUGH", EAZEL_ENGINE_PROGRESS_TROUGH },				\
+    { "H_SLIDER_THUMB", EAZEL_ENGINE_H_SLIDER_THUMB },					\
+    { "H_SLIDER_THUMB_INACTIVE", EAZEL_ENGINE_H_SLIDER_THUMB_INACTIVE },		\
+    { "H_SLIDER_TROUGH", EAZEL_ENGINE_H_SLIDER_TROUGH },				\
+    { "H_SLIDER_TROUGH_ACTIVE", EAZEL_ENGINE_H_SLIDER_TROUGH_ACTIVE },			\
+    { "V_SLIDER_THUMB", EAZEL_ENGINE_V_SLIDER_THUMB },					\
+    { "V_SLIDER_THUMB_INACTIVE", EAZEL_ENGINE_V_SLIDER_THUMB_INACTIVE },		\
+    { "V_SLIDER_TROUGH", EAZEL_ENGINE_V_SLIDER_TROUGH },				\
+    { "V_SLIDER_TROUGH_ACTIVE", EAZEL_ENGINE_V_SLIDER_TROUGH_ACTIVE },			\
+    { "TAB_TOP", EAZEL_ENGINE_TAB_TOP },						\
+    { "TAB_TOP_LEFT", EAZEL_ENGINE_TAB_TOP_LEFT },					\
+    { "TAB_TOP_ACTIVE", EAZEL_ENGINE_TAB_TOP_ACTIVE },					\
+    { "TAB_BOTTOM", EAZEL_ENGINE_TAB_BOTTOM },						\
+    { "TAB_BOTTOM_LEFT", EAZEL_ENGINE_TAB_BOTTOM_LEFT },				\
+    { "TAB_BOTTOM_ACTIVE", EAZEL_ENGINE_TAB_BOTTOM_ACTIVE },				\
+    { "SPIN_ARROW_UP", EAZEL_ENGINE_SPIN_ARROW_UP },					\
+    { "SPIN_ARROW_DOWN", EAZEL_ENGINE_SPIN_ARROW_DOWN },				\
+    { 0, 0 }
+
+typedef struct eazel_engine_gradient_component_struct eazel_engine_gradient_component;
+struct eazel_engine_gradient_component_struct {
+    GdkColor color;
+    float weight;
+};
+
+typedef struct {
+    guint refcount;
+    eazel_engine_gradient_direction direction;
+    GdkColor from;
+    GSList *components;
+} eazel_engine_gradient;
+
+typedef struct pixmap_cache_node_struct eazel_engine_pixmap_cache_node;
+
+typedef struct {
+    char *filename;
+    int border[4];
+    eazel_engine_gradient *recolor;
+    GdkPixbuf *pixbuf;
+    eazel_engine_pixmap_cache_node *pixmap_first, *pixmap_last;
+} eazel_engine_image;
+
+typedef struct {
+    int ref_count;
+    eazel_engine_image images[EAZEL_ENGINE_STOCK_MAX];
+} eazel_engine_stock_table;
+
+#define EAZEL_ENGINE_PALETTE_SIZE 4
+
+/* Information about a single RC style */
+typedef struct {
+    guint refcount;
+
+    guint thickness;
+    guint focus_thickness;
+    guint default_thickness;
+
+    guint no_shadow : 1;
+    guint inverse_shadow : 1;
+    guint outline_shadow : 1;
+
+    GdkColor focus_color;
+    GdkColor insensitive_colors[2];	/* inner, outer */
+
+    eazel_engine_gradient *palette[EAZEL_ENGINE_PALETTE_SIZE];
+
+    /* for each GTK widget state */
+    eazel_engine_gradient *gradients[5];
+
+    eazel_engine_stock_table *stock;
+
+} eazel_theme_data;
+
+#define DEFAULT_THEME_DATA {			\
+  0, 2, 2, 3, FALSE, FALSE, TRUE,		\
+  { 0, 0x4a4a, 0x7d7d, 0x8484 },		\
+  { { 0, 0x6363, 0x6565, 0x6363 },		\
+    { 0, 0xcfcf, 0xd0d0, 0xcfcf } },		\
+ }
+
+#define STYLE_THEME_DATA(s) ((eazel_theme_data *) ((s)->engine_data))
+
+
+/* prototypes */
+
+/* from eazel-theme-main.c */
+extern gboolean eazel_engine_widget_in_focused_window_p (GtkWidget *widget);
+extern void theme_init (GtkThemeEngine *engine);
+extern void theme_exit (void);
+
+/* from eazel-theme-draw.c */
+extern GtkStyleClass eazel_class_0, eazel_class_1, eazel_class_2, eazel_class_3;
+
+/* from eazel-theme-gradient.c */
+extern eazel_engine_gradient *eazel_engine_gradient_new (eazel_engine_gradient_direction direction,
+							 GdkColor *from,
+							 GSList *components);
+extern eazel_engine_gradient *eazel_engine_gradient_ref (eazel_engine_gradient *g);
+extern void eazel_engine_gradient_unref (eazel_engine_gradient *g);
+extern eazel_engine_gradient *eazel_engine_make_two_point_gradient (eazel_engine_gradient_direction direction,
+								    gulong from_rgb,
+								    gulong to_rgb);
+
+extern void eazel_engine_fill_gradient_rgb_buffer (const eazel_engine_gradient *gradient,
+						   int rgb_total, guchar *rgb_buf,
+						   int rgb_first, int rgb_last);
+
+extern void eazel_engine_draw_gradient (GdkDrawable *drawable,
+					GdkGC *gc,
+					const GdkRectangle *full_rect,
+					const GdkRectangle *clip_rect,
+					const eazel_engine_gradient *gradient);
+
+extern void eazel_engine_set_bg_gradient (GdkWindow *window,
+					  eazel_engine_gradient *gradient);
+
+/* from eazel-theme-shadow.c */
+extern void eazel_engine_draw_shadow (GtkStyle *style,
+				      GdkWindow *window,
+				      GtkStateType state_type,
+				      GtkShadowType shadow_type,
+				      GdkRectangle *area,
+				      GtkWidget *widget,
+				      gchar *detail,
+				      gint x, gint y, gint width, gint height);
+
+/* from eazel-theme-pixmaps.c */
+extern void eazel_engine_stock_table_unref (eazel_engine_stock_table *table);
+extern eazel_engine_stock_table *eazel_engine_stock_table_ref (eazel_engine_stock_table *table);
+extern void eazel_engine_stock_pixmap_and_mask (eazel_engine_stock_table *table,
+						eazel_engine_stock_image type,
+						GdkPixmap **image,
+						GdkBitmap **mask);
+extern void eazel_engine_stock_pixmap_and_mask_scaled (eazel_engine_stock_table *table,
+						       eazel_engine_stock_image type,
+						       int width, int height,
+						       GdkPixmap **image,
+						       GdkBitmap **mask);
+extern void eazel_engine_stock_free_pixmaps (eazel_engine_stock_table *table,
+					     eazel_engine_stock_image type,
+					     GdkPixmap *image, GdkPixmap *mask);
+extern void eazel_engine_stock_get_size (eazel_engine_stock_table *table,
+					 eazel_engine_stock_image type,
+					 int *width, int *height);
+
+/* from eazel-theme-hacks.c */
+extern void eazel_engine_install_hacks (void);
+extern void eazel_engine_remove_hacks (void);
+
+#endif /* EAZEL_THEME_H */