Initial revision

1 files changed, 1253 insertions, 0 deletions

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);
+}