gtk/gtk/gtkstyle.c

/* GTK - The GIMP Toolkit
 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Library General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Library General Public License for more details.
 *
 * You should have received a copy of the GNU Library General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 */
#include <math.h>
#include "gtkgc.h"
#include "gtkrc.h"
#include "gtkstyle.h"
#include "gtkthemes.h"
#include "gtkwidget.h"
#include "gtkthemes.h"
#include "gdk/gdkprivate.h"


#define LIGHTNESS_MULT  1.3
#define DARKNESS_MULT   0.7

static void         gtk_style_init         (GtkStyle    *style,
					    GdkColormap *colormap,
					    gint         depth);
static void         gtk_style_destroy      (GtkStyle    *style);

static void gtk_default_draw_hline   (GtkStyle      *style,
				      GdkWindow     *window,
				      GtkStateType   state_type,
				      GdkRectangle  *area,
				      GtkWidget     *widget,
				      gchar         *detail,
				      gint           x1,
				      gint           x2,
				      gint           y);
static void gtk_default_draw_vline   (GtkStyle      *style,
				      GdkWindow     *window,
				      GtkStateType   state_type,
				      GdkRectangle  *area,
				      GtkWidget     *widget,
				      gchar         *detail,
				      gint           y1,
				      gint           y2,
				      gint           x);
static void gtk_default_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);
static void gtk_default_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);
static void gtk_default_draw_polygon (GtkStyle      *style,
				      GdkWindow     *window,
				      GtkStateType   state_type,
				      GtkShadowType  shadow_type,
				      GdkRectangle  *area,
				      GtkWidget     *widget,
				      gchar         *detail,
				      GdkPoint      *points,
				      gint           npoints,
				      gboolean       fill);
static void gtk_default_draw_arrow   (GtkStyle      *style,
				      GdkWindow     *window,
				      GtkStateType   state_type,
				      GtkShadowType  shadow_type,
				      GdkRectangle  *area,
				      GtkWidget     *widget,
				      gchar         *detail,
				      GtkArrowType   arrow_type,
				      gboolean       fill,
				      gint           x,
				      gint           y,
				      gint           width,
				      gint           height);
static void gtk_default_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);
static void gtk_default_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);
static void gtk_default_draw_string  (GtkStyle      *style,
				      GdkWindow     *window,
				      GtkStateType   state_type,
				      GdkRectangle  *area,
				      GtkWidget     *widget,
				      gchar         *detail,
				      gint           x,
				      gint           y,
				      const gchar   *string);
static void gtk_default_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);
static void gtk_default_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);
static void gtk_default_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);
static void gtk_default_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);
static void gtk_default_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);
static void gtk_default_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);
static void gtk_default_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);
static void gtk_default_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);
static void gtk_default_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);
static void gtk_default_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);
static void gtk_default_draw_focus   (GtkStyle      *style,
				      GdkWindow     *window,
				      GdkRectangle  *area,
				      GtkWidget     *widget,
				      gchar         *detail,
				      gint           x,
				      gint           y,
				      gint           width,
				      gint           height);
static void gtk_default_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);
static void gtk_default_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);


static void gtk_style_shade (GdkColor *a, GdkColor *b, gdouble k);
static void rgb_to_hls (gdouble *r, gdouble *g, gdouble *b);
static void hls_to_rgb (gdouble *h, gdouble *l, gdouble *s);


static const GtkStyleClass default_class =
{
  2,
  2,
  gtk_default_draw_hline,
  gtk_default_draw_vline,
  gtk_default_draw_shadow,
  gtk_default_draw_polygon,
  gtk_default_draw_arrow,
  gtk_default_draw_diamond,
  gtk_default_draw_oval,
  gtk_default_draw_string,
  gtk_default_draw_box,
  gtk_default_draw_flat_box,
  gtk_default_draw_check,
  gtk_default_draw_option,
  gtk_default_draw_cross,
  gtk_default_draw_ramp,
  gtk_default_draw_tab,
  gtk_default_draw_shadow_gap,
  gtk_default_draw_box_gap,
  gtk_default_draw_extension,
  gtk_default_draw_focus,
  gtk_default_draw_slider,
  gtk_default_draw_handle
};
GdkFont *default_font = NULL;

static GdkColor gtk_default_normal_fg =      { 0,      0,      0,      0 };
static GdkColor gtk_default_active_fg =      { 0,      0,      0,      0 };
static GdkColor gtk_default_prelight_fg =    { 0,      0,      0,      0 };
static GdkColor gtk_default_selected_fg =    { 0, 0xffff, 0xffff, 0xffff };
static GdkColor gtk_default_insensitive_fg = { 0, 0x7530, 0x7530, 0x7530 };

static GdkColor gtk_default_normal_bg =      { 0, 0xd6d6, 0xd6d6, 0xd6d6 };
static GdkColor gtk_default_active_bg =      { 0, 0xc350, 0xc350, 0xc350 };
static GdkColor gtk_default_prelight_bg =    { 0, 0xea60, 0xea60, 0xea60 };
static GdkColor gtk_default_selected_bg =    { 0,      0,      0, 0x9c40 };
static GdkColor gtk_default_insensitive_bg = { 0, 0xd6d6, 0xd6d6, 0xd6d6 };

GtkStyle*
gtk_style_copy (GtkStyle     *style)
{
  GtkStyle *new_style;
  guint i;
  
  g_return_val_if_fail (style != NULL, NULL);
  
  new_style = gtk_style_new ();
  
  for (i = 0; i < 5; i++)
    {
      new_style->fg[i] = style->fg[i];
      new_style->bg[i] = style->bg[i];
      new_style->text[i] = style->text[i];
      new_style->base[i] = style->base[i];
      
      new_style->bg_pixmap[i] = style->bg_pixmap[i];
    }
  
  new_style->font = style->font;
  gdk_font_ref (new_style->font);
  
  return new_style;
}

static GtkStyle*
gtk_style_duplicate (GtkStyle     *style)
{
  GtkStyle *new_style;
  
  g_return_val_if_fail (style != NULL, NULL);
  
  new_style = gtk_style_copy (style);
  
  style->styles = g_slist_append (style->styles, new_style);
  new_style->styles = style->styles;  
  
  if (style->rc_style)
    {
      new_style->rc_style = style->rc_style;
      gtk_rc_style_ref (style->rc_style);
    }
  
  if (style->engine)
    {
      new_style->engine = style->engine;
      new_style->engine->duplicate_style (new_style, style);
    }
  
  return new_style;
}

GtkStyle*
gtk_style_new (void)
{
  GtkStyle *style;
  gint i;
  
  style = g_new0 (GtkStyle, 1);
  
  if (!default_font)
    default_font =
      gdk_font_load ("-adobe-helvetica-medium-r-normal--*-120-*-*-*-*-*-*");
  
  style->font = default_font;
  gdk_font_ref (style->font);
  
  style->ref_count = 1;
  style->attach_count = 0;
  style->colormap = NULL;
  style->depth = -1;
  style->klass = &default_class;
  
  style->black.red = 0;
  style->black.green = 0;
  style->black.blue = 0;
  
  style->white.red = 65535;
  style->white.green = 65535;
  style->white.blue = 65535;
  
  style->black_gc = NULL;
  style->white_gc = NULL;
  
  style->fg[GTK_STATE_NORMAL] = gtk_default_normal_fg;
  style->fg[GTK_STATE_ACTIVE] = gtk_default_active_fg;
  style->fg[GTK_STATE_PRELIGHT] = gtk_default_prelight_fg;
  style->fg[GTK_STATE_SELECTED] = gtk_default_selected_fg;
  style->fg[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_fg;
  
  style->bg[GTK_STATE_NORMAL] = gtk_default_normal_bg;
  style->bg[GTK_STATE_ACTIVE] = gtk_default_active_bg;
  style->bg[GTK_STATE_PRELIGHT] = gtk_default_prelight_bg;
  style->bg[GTK_STATE_SELECTED] = gtk_default_selected_bg;
  style->bg[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
  
  for (i = 0; i < 4; i++)
    {
      style->text[i] = style->fg[i];
      style->base[i] = style->white;
    }
  
  style->base[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
  style->text[GTK_STATE_INSENSITIVE] = gtk_default_insensitive_bg;
  
  for (i = 0; i < 5; i++)
    style->bg_pixmap[i] = NULL;
  
  style->engine = NULL;
  style->engine_data = NULL;
  
  style->rc_style = NULL;
  
  for (i = 0; i < 5; i++)
    {
      style->fg_gc[i] = NULL;
      style->bg_gc[i] = NULL;
      style->light_gc[i] = NULL;
      style->dark_gc[i] = NULL;
      style->mid_gc[i] = NULL;
      style->text_gc[i] = NULL;
      style->base_gc[i] = NULL;
    }
  
  return style;
}

GtkStyle *
gtk_style_attach (GtkStyle  *style,
		  GdkWindow *window)
{
  GSList *styles;
  GtkStyle *new_style = NULL;
  GdkColormap *colormap;
  gint depth;
  
  g_return_val_if_fail (style != NULL, NULL);
  g_return_val_if_fail (window != NULL, NULL);
  
  colormap = gdk_window_get_colormap (window);
  depth = gdk_window_get_visual (window)->depth;
  
  if (!style->styles)
    style->styles = g_slist_append (NULL, style);
  
  styles = style->styles;
  while (styles)
    {
      new_style = styles->data;
      
      if (new_style->attach_count == 0)
	{
	  gtk_style_init (new_style, colormap, depth);
	  break;
	}
      else if ((new_style->colormap == colormap) &&
	       (new_style->depth == depth))
	break;
      
      new_style = NULL;
      styles = styles->next;
    }
  
  if (!new_style)
    {
      new_style = gtk_style_duplicate (style);
      gtk_style_init (new_style, colormap, depth);
    }
  
  if (new_style->attach_count == 0)
    gtk_style_ref (new_style);
  
  
  
  new_style->attach_count++;
  
  return new_style;
}

void
gtk_style_detach (GtkStyle *style)
{
  gint i;
  
  g_return_if_fail (style != NULL);
  
  style->attach_count -= 1;
  if (style->attach_count == 0)
    {
      if (style->engine)
	style->engine->unrealize_style (style);
      
      gtk_gc_release (style->black_gc);
      gtk_gc_release (style->white_gc);
      
      for (i = 0; i < 5; i++)
	{
	  gtk_gc_release (style->fg_gc[i]);
	  gtk_gc_release (style->bg_gc[i]);
	  gtk_gc_release (style->light_gc[i]);
	  gtk_gc_release (style->dark_gc[i]);
	  gtk_gc_release (style->mid_gc[i]);
	  gtk_gc_release (style->text_gc[i]);
	  gtk_gc_release (style->base_gc[i]);
	}
      
      gtk_style_unref (style);
    }
}

GtkStyle*
gtk_style_ref (GtkStyle *style)
{
  g_return_val_if_fail (style != NULL, NULL);
  
  style->ref_count += 1;
  return style;
}

void
gtk_style_unref (GtkStyle *style)
{
  g_return_if_fail (style != NULL);
  
  style->ref_count -= 1;
  if (style->ref_count == 0)
    gtk_style_destroy (style);
}

static void
gtk_style_init (GtkStyle *style,
		GdkColormap *colormap,
		gint         depth)
{
  GdkGCValues gc_values;
  GdkGCValuesMask gc_values_mask;
  gint i;
  
  g_return_if_fail (style != NULL);
  
  style->colormap = colormap;
  style->depth = depth;
  
  for (i = 0; i < 5; i++)
    {
      gtk_style_shade (&style->bg[i], &style->light[i], LIGHTNESS_MULT);
      gtk_style_shade (&style->bg[i], &style->dark[i], DARKNESS_MULT);
      
      style->mid[i].red = (style->light[i].red + style->dark[i].red) / 2;
      style->mid[i].green = (style->light[i].green + style->dark[i].green) / 2;
      style->mid[i].blue = (style->light[i].blue + style->dark[i].blue) / 2;
    }
  
  gdk_color_black (colormap, &style->black);
  gdk_color_white (colormap, &style->white);
  
  gc_values_mask = GDK_GC_FOREGROUND | GDK_GC_FONT;
  if (style->font->type == GDK_FONT_FONT)
    {
      gc_values.font = style->font;
    }
  else if (style->font->type == GDK_FONT_FONTSET)
    {
      gc_values.font = default_font;
    }
  
  gc_values.foreground = style->black;
  style->black_gc = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
  
  gc_values.foreground = style->white;
  style->white_gc = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
  
  for (i = 0; i < 5; i++)
    {
      if (style->rc_style && style->rc_style->bg_pixmap_name[i])
	style->bg_pixmap[i] = gtk_rc_load_image (style->colormap,
						 &style->bg[i],
						 style->rc_style->bg_pixmap_name[i]);
      
      if (!gdk_color_alloc (colormap, &style->fg[i]))
	g_warning ("unable to allocate color: ( %d %d %d )",
		   style->fg[i].red, style->fg[i].green, style->fg[i].blue);
      if (!gdk_color_alloc (colormap, &style->bg[i]))
	g_warning ("unable to allocate color: ( %d %d %d )",
		   style->bg[i].red, style->bg[i].green, style->bg[i].blue);
      if (!gdk_color_alloc (colormap, &style->light[i]))
	g_warning ("unable to allocate color: ( %d %d %d )",
		   style->light[i].red, style->light[i].green, style->light[i].blue);
      if (!gdk_color_alloc (colormap, &style->dark[i]))
	g_warning ("unable to allocate color: ( %d %d %d )",
		   style->dark[i].red, style->dark[i].green, style->dark[i].blue);
      if (!gdk_color_alloc (colormap, &style->mid[i]))
	g_warning ("unable to allocate color: ( %d %d %d )",
		   style->mid[i].red, style->mid[i].green, style->mid[i].blue);
      if (!gdk_color_alloc (colormap, &style->text[i]))
	g_warning ("unable to allocate color: ( %d %d %d )",
		   style->text[i].red, style->text[i].green, style->text[i].blue);
      if (!gdk_color_alloc (colormap, &style->base[i]))
	g_warning ("unable to allocate color: ( %d %d %d )",
		   style->base[i].red, style->base[i].green, style->base[i].blue);
      
      gc_values.foreground = style->fg[i];
      style->fg_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
      
      gc_values.foreground = style->bg[i];
      style->bg_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
      
      gc_values.foreground = style->light[i];
      style->light_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
      
      gc_values.foreground = style->dark[i];
      style->dark_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
      
      gc_values.foreground = style->mid[i];
      style->mid_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
      
      gc_values.foreground = style->text[i];
      style->text_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
      
      gc_values.foreground = style->base[i];
      style->base_gc[i] = gtk_gc_get (style->depth, style->colormap, &gc_values, gc_values_mask);
    }
  if (style->engine)
    style->engine->realize_style (style);
}

static void
gtk_style_destroy (GtkStyle *style)
{
  g_return_if_fail (style->attach_count == 0);
  
  if (style->styles)
    {
      if (style->styles->data != style)
	g_slist_remove (style->styles, style);
      else
	{
	  GSList *tmp_list = style->styles->next;
	  while (tmp_list)
	    {
	      ((GtkStyle *)tmp_list->data)->styles = style->styles->next;
	      tmp_list = tmp_list->next;
	    }
	  g_slist_free_1 (style->styles);
	}
    }
  
  if (style->engine)
    {
      style->engine->destroy_style (style);
      gtk_theme_engine_unref (style->engine);
    }
  
  gdk_font_unref (style->font);
  if (style->rc_style)
    gtk_rc_style_unref (style->rc_style);
  
  g_free (style);
}

void
gtk_draw_hline (GtkStyle     *style,
		GdkWindow    *window,
		GtkStateType  state_type,
		gint          x1,
		gint          x2,
		gint          y)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_hline != NULL);
  
  (*style->klass->draw_hline) (style, window, state_type, NULL, NULL, NULL, x1, x2, y);
}


void
gtk_draw_vline (GtkStyle     *style,
		GdkWindow    *window,
		GtkStateType  state_type,
		gint          y1,
		gint          y2,
		gint          x)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_vline != NULL);
  
  (*style->klass->draw_vline) (style, window, state_type, NULL, NULL, NULL, y1, y2, x);
}


void
gtk_draw_shadow (GtkStyle      *style,
		 GdkWindow     *window,
		 GtkStateType   state_type,
		 GtkShadowType  shadow_type,
		 gint           x,
		 gint           y,
		 gint           width,
		 gint           height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_shadow != NULL);
  
  (*style->klass->draw_shadow) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
}

void
gtk_draw_polygon (GtkStyle      *style,
		  GdkWindow     *window,
		  GtkStateType   state_type,
		  GtkShadowType  shadow_type,
		  GdkPoint      *points,
		  gint           npoints,
		  gboolean       fill)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_shadow != NULL);
  
  (*style->klass->draw_polygon) (style, window, state_type, shadow_type, NULL, NULL, NULL, points, npoints, fill);
}

void
gtk_draw_arrow (GtkStyle      *style,
		GdkWindow     *window,
		GtkStateType   state_type,
		GtkShadowType  shadow_type,
		GtkArrowType   arrow_type,
		gboolean       fill,
		gint           x,
		gint           y,
		gint           width,
		gint           height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_arrow != NULL);
  
  (*style->klass->draw_arrow) (style, window, state_type, shadow_type, NULL, NULL, NULL, arrow_type, fill, x, y, width, height);
}


void
gtk_draw_diamond (GtkStyle      *style,
		  GdkWindow     *window,
		  GtkStateType   state_type,
		  GtkShadowType  shadow_type,
		  gint           x,
		  gint           y,
		  gint           width,
		  gint           height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_diamond != NULL);
  
  (*style->klass->draw_diamond) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
}


void
gtk_draw_oval (GtkStyle      *style,
	       GdkWindow     *window,
	       GtkStateType   state_type,
	       GtkShadowType  shadow_type,
	       gint           x,
	       gint           y,
	       gint           width,
	       gint           height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_oval != NULL);
  
  (*style->klass->draw_oval) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
}

void
gtk_draw_string (GtkStyle      *style,
		 GdkWindow     *window,
		 GtkStateType   state_type,
		 gint           x,
		 gint           y,
		 const gchar   *string)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_oval != NULL);
  
  (*style->klass->draw_string) (style, window, state_type, NULL, NULL, NULL, x, y, string);
}

void
gtk_draw_box (GtkStyle      *style,
	      GdkWindow     *window,
	      GtkStateType   state_type,
	      GtkShadowType  shadow_type,
	      gint           x,
	      gint           y,
	      gint           width,
	      gint           height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_box != NULL);
  
  (*style->klass->draw_box) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
}

void
gtk_draw_flat_box (GtkStyle      *style,
		   GdkWindow     *window,
		   GtkStateType   state_type,
		   GtkShadowType  shadow_type,
		   gint           x,
		   gint           y,
		   gint           width,
		   gint           height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_flat_box != NULL);
  
  (*style->klass->draw_flat_box) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
}

void
gtk_draw_check   (GtkStyle      *style,
		  GdkWindow     *window,
		  GtkStateType   state_type,
		  GtkShadowType  shadow_type,
		  gint           x,
		  gint           y,
		  gint           width,
		  gint           height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_check != NULL);
  
  (*style->klass->draw_check) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
}

void
gtk_draw_option  (GtkStyle      *style,
		  GdkWindow     *window,
		  GtkStateType   state_type,
		  GtkShadowType  shadow_type,
		  gint           x,
		  gint           y,
		  gint           width,
		  gint           height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_option != NULL);
  
  (*style->klass->draw_option) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
}

void
gtk_draw_cross   (GtkStyle      *style,
		  GdkWindow     *window,
		  GtkStateType   state_type,
		  GtkShadowType  shadow_type,
		  gint           x,
		  gint           y,
		  gint           width,
		  gint           height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_cross != NULL);
  
  (*style->klass->draw_cross) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
}

void
gtk_draw_ramp    (GtkStyle      *style,
		  GdkWindow     *window,
		  GtkStateType   state_type,
		  GtkShadowType  shadow_type,
		  GtkArrowType   arrow_type,
		  gint           x,
		  gint           y,
		  gint           width,
		  gint           height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_ramp != NULL);
  
  (*style->klass->draw_ramp) (style, window, state_type, shadow_type, NULL, NULL, NULL, arrow_type, x, y, width, height);
}

void
gtk_draw_tab     (GtkStyle      *style,
		  GdkWindow     *window,
		  GtkStateType   state_type,
		  GtkShadowType  shadow_type,
		  gint           x,
		  gint           y,
		  gint           width,
		  gint           height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_tab != NULL);
  
  (*style->klass->draw_tab) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height);
}

void
gtk_draw_shadow_gap (GtkStyle       *style,
		     GdkWindow      *window,
		     GtkStateType    state_type,
		     GtkShadowType   shadow_type,
		     gint            x,
		     gint            y,
		     gint            width,
		     gint            height,
		     GtkPositionType gap_side,
		     gint            gap_x,
		     gint            gap_width)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_shadow_gap != NULL);
  
  (*style->klass->draw_shadow_gap) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, gap_side, gap_x, gap_width);
}

void
gtk_draw_box_gap (GtkStyle       *style,
		  GdkWindow      *window,
		  GtkStateType    state_type,
		  GtkShadowType   shadow_type,
		  gint            x,
		  gint            y,
		  gint            width,
		  gint            height,
		  GtkPositionType gap_side,
		  gint            gap_x,
		  gint            gap_width)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_box_gap != NULL);
  
  (*style->klass->draw_box_gap) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, gap_side, gap_x, gap_width);
}

void
gtk_draw_extension (GtkStyle       *style,
		    GdkWindow      *window,
		    GtkStateType    state_type,
		    GtkShadowType   shadow_type,
		    gint            x,
		    gint            y,
		    gint            width,
		    gint            height,
		    GtkPositionType gap_side)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_extension != NULL);
  
  (*style->klass->draw_extension) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, gap_side);
}

void
gtk_draw_focus  (GtkStyle      *style,
		 GdkWindow     *window,
		 gint           x,
		 gint           y,
		 gint           width,
		 gint           height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_focus != NULL);
  
  (*style->klass->draw_focus) (style, window, NULL, NULL, NULL, x, y, width, height);
}

void 
gtk_draw_slider  (GtkStyle      *style,
		  GdkWindow     *window,
		  GtkStateType   state_type,
		  GtkShadowType  shadow_type,
		  gint           x,
		  gint           y,
		  gint           width,
		  gint           height,
		  GtkOrientation orientation)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_slider != NULL);
  
  (*style->klass->draw_slider) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, orientation);
}

void 
gtk_draw_handle  (GtkStyle      *style,
		  GdkWindow     *window,
		  GtkStateType   state_type,
		  GtkShadowType  shadow_type,
		  gint           x,
		  gint           y,
		  gint           width,
		  gint           height,
		  GtkOrientation orientation)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_handle != NULL);
  
  (*style->klass->draw_handle) (style, window, state_type, shadow_type, NULL, NULL, NULL, x, y, width, height, orientation);
}

void
gtk_style_set_background (GtkStyle     *style,
			  GdkWindow    *window,
			  GtkStateType  state_type)
{
  GdkPixmap *pixmap;
  gint parent_relative;
  
  if (style->engine && style->engine->set_background)
    {
      (*style->engine->set_background) (style, window, state_type);
      return;
    }
  
  g_return_if_fail (style != NULL);
  g_return_if_fail (window != 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]);
}


/* Default functions */
void
gtk_style_apply_default_background (GtkStyle     *style,
				    GdkWindow    *window,
				    gboolean	  set_bg,
				    GtkStateType  state_type, 
				    GdkRectangle *area, 
				    gint          x, 
				    gint          y, 
				    gint          width, 
				    gint          height)
{
  GdkRectangle new_rect, old_rect;
  

  if (area)
    {
      old_rect.x = x;
      old_rect.y = y;
      old_rect.width = width;
      old_rect.height = height;
      
      if (!gdk_rectangle_intersect (area, &old_rect, &new_rect))
	return;
    }
  else
    {
      new_rect.x = x;
      new_rect.y = y;
      new_rect.width = width;
      new_rect.height = height;
    }
  
  if (!style->bg_pixmap[state_type] ||
      (gdk_window_get_type (window) == GDK_WINDOW_PIXMAP) ||
      (!set_bg && (style->bg_pixmap[state_type]  != (GdkPixmap *) GDK_PARENT_RELATIVE)))
    {
      GdkGC *gc = style->bg_gc[state_type];

      if (style->bg_pixmap[state_type])
	{
	  gdk_gc_set_fill (gc, GDK_TILED);
	  gdk_gc_set_tile (gc, style->bg_pixmap[state_type]);
	}
	
      gdk_draw_rectangle (window, gc, TRUE, 
			  new_rect.x, new_rect.y, new_rect.width, new_rect.height);
      if (style->bg_pixmap[state_type])
	gdk_gc_set_fill (gc, GDK_SOLID);
    }
  else
    {
      if (set_bg)
	{
	  if (style->bg_pixmap[state_type] == (GdkPixmap*) GDK_PARENT_RELATIVE)
	    gdk_window_set_back_pixmap (window, NULL, TRUE);
	  else
	    gdk_window_set_back_pixmap (window, style->bg_pixmap[state_type], FALSE);
	}
      
      gdk_window_clear_area (window, 
			     new_rect.x, new_rect.y, 
			     new_rect.width, new_rect.height);
    }
}

void 
gtk_style_apply_default_pixmap (GtkStyle     *style,
				GdkWindow    *window,
				GtkStateType  state_type, 
				GdkRectangle *area, 
				gint          x, 
				gint          y, 
				gint          width, 
				gint          height)
{
  gtk_style_apply_default_background (style, window, TRUE, state_type,
				      area, x, y, width, height);
}

static void
gtk_default_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);
  
  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);
    }
  
  if (detail && !strcmp (detail, "label"))
    {
      if (state_type == GTK_STATE_INSENSITIVE)
	gdk_draw_line (window, style->white_gc, x1 + 1, y + 1, x2 + 1, y + 1);	 
      gdk_draw_line (window, style->fg_gc[state_type], x1, y, x2, y);     
    }
  else
    {
      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
gtk_default_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);
  
  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
gtk_default_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;
  gint thickness_light;
  gint thickness_dark;
  gint i;
  
  g_return_if_fail (style != NULL);
  g_return_if_fail (window != 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);
  
  switch (shadow_type)
    {
    case GTK_SHADOW_NONE:
      return;
    case GTK_SHADOW_IN:
    case GTK_SHADOW_ETCHED_IN:
      gc1 = style->light_gc[state_type];
      gc2 = style->dark_gc[state_type];
      break;
    case GTK_SHADOW_OUT:
    case GTK_SHADOW_ETCHED_OUT:
      gc1 = style->dark_gc[state_type];
      gc2 = style->light_gc[state_type];
      break;
    }
  
  if (area)
    {
      gdk_gc_set_clip_rectangle (gc1, area);
      gdk_gc_set_clip_rectangle (gc2, 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:
      gdk_draw_line (window, gc1,
                     x, y + height - 1, x + width - 1, y + height - 1);
      gdk_draw_line (window, gc1,
                     x + width - 1, y, x + width - 1, y + height - 1);
      
      gdk_draw_line (window, style->bg_gc[state_type],
                     x + 1, y + height - 2, x + width - 2, y + height - 2);
      gdk_draw_line (window, style->bg_gc[state_type],
                     x + width - 2, y + 1, x + width - 2, y + height - 2);
      
      gdk_draw_line (window, style->black_gc,
                     x + 1, y + 1, x + width - 2, y + 1);
      gdk_draw_line (window, style->black_gc,
                     x + 1, y + 1, x + 1, y + height - 2);
      
      gdk_draw_line (window, gc2,
                     x, y, x + width - 1, y);
      gdk_draw_line (window, gc2,
                     x, y, x, y + height - 1);
      break;
      
    case GTK_SHADOW_OUT:
      gdk_draw_line (window, gc1,
                     x + 1, y + height - 2, x + width - 2, y + height - 2);
      gdk_draw_line (window, gc1,
                     x + width - 2, y + 1, x + width - 2, y + height - 2);
      
      gdk_draw_line (window, gc2,
                     x, y, x + width - 1, y);
      gdk_draw_line (window, gc2,
                     x, y, x, y + height - 1);
      
      gdk_draw_line (window, style->bg_gc[state_type],
                     x + 1, y + 1, x + width - 2, y + 1);
      gdk_draw_line (window, style->bg_gc[state_type],
                     x + 1, y + 1, x + 1, y + height - 2);
      
      gdk_draw_line (window, style->black_gc,
                     x, y + height - 1, x + width - 1, y + height - 1);
      gdk_draw_line (window, style->black_gc,
                     x + width - 1, y, x + width - 1, y + height - 1);
      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);
      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
gtk_default_draw_polygon (GtkStyle      *style,
			  GdkWindow     *window,
			  GtkStateType   state_type,
			  GtkShadowType  shadow_type,
			  GdkRectangle  *area,
			  GtkWidget     *widget,
			  gchar         *detail,
			  GdkPoint      *points,
			  gint           npoints,
			  gboolean       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);
  
  switch (shadow_type)
    {
    case GTK_SHADOW_IN:
      gc1 = style->bg_gc[state_type];
      gc2 = style->dark_gc[state_type];
      gc3 = style->light_gc[state_type];
      gc4 = style->black_gc;
      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->black_gc;
      gc4 = style->bg_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
gtk_default_draw_arrow (GtkStyle      *style,
			GdkWindow     *window,
			GtkStateType   state_type,
			GtkShadowType  shadow_type,
			GdkRectangle  *area,
			GtkWidget     *widget,
			gchar         *detail,
			GtkArrowType   arrow_type,
			gboolean       fill,
			gint           x,
			gint           y,
			gint           width,
			gint           height)
{
  GdkGC *gc1;
  GdkGC *gc2;
  GdkGC *gc3;
  GdkGC *gc4;
  gint half_width;
  gint half_height;
  GdkPoint points[3];
  
  g_return_if_fail (style != NULL);
  g_return_if_fail (window != NULL);
  
  switch (shadow_type)
    {
    case GTK_SHADOW_IN:
      gc1 = style->bg_gc[state_type];
      gc2 = style->dark_gc[state_type];
      gc3 = style->light_gc[state_type];
      gc4 = style->black_gc;
      break;
    case GTK_SHADOW_OUT:
      gc1 = style->dark_gc[state_type];
      gc2 = style->light_gc[state_type];
      gc3 = style->black_gc;
      gc4 = style->bg_gc[state_type];
      break;
    case GTK_SHADOW_ETCHED_IN:
      gc1 = style->light_gc[state_type];
      gc2 = style->dark_gc[state_type];
      gc3 = NULL;
      gc4 = NULL;
      break;
    case GTK_SHADOW_ETCHED_OUT:
      gc1 = style->dark_gc[state_type];
      gc2 = style->light_gc[state_type];
      gc3 = NULL;
      gc4 = NULL;
      break;
    default:
      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);
  
  half_width = width / 2;
  half_height = height / 2;
  
  if (area)
    {
      gdk_gc_set_clip_rectangle (gc1, area);
      gdk_gc_set_clip_rectangle (gc2, area);
      if ((gc3) && (gc4))
	{
	  gdk_gc_set_clip_rectangle (gc3, area);
	  gdk_gc_set_clip_rectangle (gc4, area);
	}
    }
  
  switch (arrow_type)
    {
    case GTK_ARROW_UP:
      if (fill)
	{
	  points[0].x = x + half_width;
	  points[0].y = y;
	  points[1].x = x;
	  points[1].y = y + height - 1;
	  points[2].x = x + width - 1;
	  points[2].y = y + height - 1;
	  
	  gdk_draw_polygon (window, style->bg_gc[state_type], TRUE, points, 3);
	}
      
      switch (shadow_type)
	{
	case GTK_SHADOW_IN:
	case GTK_SHADOW_OUT:
	  
	  gdk_draw_line (window, gc1,
			 x + 1, y + height - 2,
			 x + width - 2, y + height - 2);
	  gdk_draw_line (window, gc3,
			 x + 0, y + height - 1,
			 x + width - 1, y + height - 1);
	  
	  gdk_draw_line (window, gc1,
			 x + width - 2, y + height - 1,
			 x + half_width, y + 1);
	  gdk_draw_line (window, gc3,
			 x + width - 1, y + height - 1,
			 x + half_width, y);
	  
	  gdk_draw_line (window, gc4,
			 x + half_width, y + 1,
			 x + 1, y + height - 1);
	  gdk_draw_line (window, gc2,
			 x + half_width, y,
			 x, y + height - 1);
	  break;
	  
	case GTK_SHADOW_ETCHED_IN:
	case GTK_SHADOW_ETCHED_OUT:
	  gdk_draw_line (window, gc1,
			 x + half_width, y + 1,
			 x + 1, y + height - 1);
	  gdk_draw_line (window, gc1,
			 x + 1, y + height - 1,
			 x + width - 1, y + height - 1);
	  gdk_draw_line (window, gc1,
			 x + width - 1, y + height - 1,
			 x + half_width + 1, y + 1);
	  
	  points[0].x = x + half_width;
	  points[0].y = y;
	  points[1].x = x;
	  points[1].y = y + height - 2;
	  points[2].x = x + width - 2;
	  points[2].y = y + height - 2;
	  
	  gdk_draw_polygon (window, gc2, FALSE, points, 3);
	  break;
	  
	default:
	  break;
	}
      break;
      
    case GTK_ARROW_DOWN:
      if (fill)
	{
	  points[0].x = x + width - 1;
	  points[0].y = y;
          points[1].x = x;
	  points[1].y = y;
	  points[2].x = x + half_width;
	  points[2].y = y + height - 1;
	  
	  gdk_draw_polygon (window, style->bg_gc[state_type], TRUE, points, 3);
	}
      switch (shadow_type)
	{
	case GTK_SHADOW_IN:
	case GTK_SHADOW_OUT:
	  gdk_draw_line (window, gc4,
			 x + width - 2,
			 y + 1, x + 1, y + 1);
	  gdk_draw_line (window, gc2,
			 x + width - 1, y,
			 x, y);
	  
	  gdk_draw_line (window, gc4,
			 x + 1, y,
			 x + half_width, y + height - 2);
	  gdk_draw_line (window, gc2,
			 x, y,
			 x + half_width, y + height - 1);
	  
	  gdk_draw_line (window, gc1,
			 x + half_width, y + height - 2,
			 x + width - 2, y);
	  gdk_draw_line (window, gc3,
			 x + half_width, y + height - 1,
			 x + width - 1, y);
	  break;
	  
	case GTK_SHADOW_ETCHED_IN:
	case GTK_SHADOW_ETCHED_OUT:
	  gdk_draw_line (window, gc1,
			 x + width - 1, y + 1,
			 x + 1, y + 1);
	  gdk_draw_line (window, gc1,
			 x + 1, y + 1,
			 x + half_width + 1, y + height - 1);
	  gdk_draw_line (window, gc1,
			 x + half_width + 1, y + height - 2,
			 x + width - 1, y);
	  
	  points[0].x = x + width - 2;
	  points[0].y = y;
	  points[1].x = x;
	  points[1].y = y;
	  points[2].x = x + half_width;
	  points[2].y = y + height - 2;
	  
	  gdk_draw_polygon (window, gc2, FALSE, points, 3);
	  break;
	  
	default:
	  break;
	}
      break;
    case GTK_ARROW_LEFT:
      if (fill)
	{
	  points[0].x = x;
	  points[0].y = y + half_height;
	  points[1].x = x + width - 1;
	  points[1].y = y + height - 1;
	  points[2].x = x + width - 1;
	  points[2].y = y;
	  
	  gdk_draw_polygon (window, style->bg_gc[state_type], TRUE, points, 3);
	}
      
      switch (shadow_type)
	{
	case GTK_SHADOW_IN:
	case GTK_SHADOW_OUT:
	  gdk_draw_line (window, gc1,
			 x + 1, y + half_height,
			 x + width - 1, y + height - 1);
	  gdk_draw_line (window, gc3,
			 x, y + half_height,
			 x + width - 1, y + height - 1);
	  
	  gdk_draw_line (window, gc1,
			 x + width - 2, y + height - 1,
			 x + width - 2, y + 1);
	  gdk_draw_line (window, gc3,
			 x + width - 1, y + height - 1,
			 x + width - 1, y);
	  
	  gdk_draw_line (window, gc4,
			 x + width - 1, y + 1,
			 x + 1, y + half_height);
	  gdk_draw_line (window, gc2,
			 x + width - 1, y,
			 x, y + half_height);
	  break;
	  
	case GTK_SHADOW_ETCHED_IN:
	case GTK_SHADOW_ETCHED_OUT:
	  gdk_draw_line (window, gc1,
			 x + width - 1, y + 1,
			 x + 1, y + half_height);
	  gdk_draw_line (window, gc1,
			 x + 1, y + half_height + 1,
			 x + width - 1, y + height - 1);
	  gdk_draw_line (window, gc1,
			 x + width - 1, y + height - 1,
			 x + width - 1, y + 1);
	  
	  points[0].x = x + width - 2;
	  points[0].y = y;
	  points[1].x = x;
	  points[1].y = y + half_height;
	  points[2].x = x + width - 2;
	  points[2].y = y + height - 2;
	  
	  gdk_draw_polygon (window, gc2, FALSE, points, 3);
	  break;
	  
	default:
	  break;
	}
      break;
    case GTK_ARROW_RIGHT:
      if (fill)
	{
	  points[0].x = x + width - 1;
	  points[0].y = y + half_height;
	  points[1].x = x;
	  points[1].y = y;
	  points[2].x = x;
	  points[2].y = y + height - 1;
	  
	  gdk_draw_polygon (window, style->bg_gc[state_type], TRUE, points, 3);
	}
      
      switch (shadow_type)
	{
	case GTK_SHADOW_IN:
	case GTK_SHADOW_OUT:
	  gdk_draw_line (window, gc4,
			 x + width - 1, y + half_height,
			 x + 1, y + 1);
	  gdk_draw_line (window, gc2,
			 x + width - 1, y + half_height,
			 x, y);
	  gdk_draw_line (window, gc4,
			 x + 1, y + 1,
			 x + 1, y + height - 2);
	  gdk_draw_line (window, gc2,
			 x, y,
			 x, y + height - 1);
	  
	  gdk_draw_line (window, gc1,
			 x + 1, y + height - 2,
			 x + width - 1, y + half_height);
	  gdk_draw_line (window, gc3,
			 x, y + height - 1,
			 x + width - 1, y + half_height);
	  break;
	  
	case GTK_SHADOW_ETCHED_IN:
	case GTK_SHADOW_ETCHED_OUT:
	  gdk_draw_line (window, gc1,
			 x + width - 1, y + half_height + 1,
			 x + 1, y + 1);
	  gdk_draw_line (window, gc1,
			 x + 1, y + 1,
			 x + 1, y + height - 1);
	  gdk_draw_line (window, gc1,
			 x + 1, y + height - 1,
			 x + width - 1, y + half_height + 1);
	  
	  points[0].x = x + width - 2;
	  points[0].y = y + half_height;
	  points[1].x = x;
	  points[1].y = y;
	  points[2].x = x;
	  points[2].y = y + height - 1;
	  
	  gdk_draw_polygon (window, gc2, FALSE, points, 3);
	  break;
	  
	default:
	  break;
	}
      break;
    }
  if (area)
    {
      gdk_gc_set_clip_rectangle (gc1, NULL);
      gdk_gc_set_clip_rectangle (gc2, NULL);
      if (gc3)
	{
	  gdk_gc_set_clip_rectangle (gc3, NULL);
	  gdk_gc_set_clip_rectangle (gc4, NULL);
	}
    }
}

static void
gtk_default_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);
  
  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->bg_gc[state_type],
		     x + 2, y + half_height,
		     x + half_width, y + height - 2);
      gdk_draw_line (window, style->bg_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->black_gc,
		     x + 2, y + half_height,
		     x + half_width, y + 2);
      gdk_draw_line (window, style->black_gc,
		     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->black_gc,
		     x, y + half_height,
		     x + half_width, y + height);
      gdk_draw_line (window, style->black_gc,
		     x + half_width, y + height,
		     x + width, y + half_height);
      
      gdk_draw_line (window, style->bg_gc[state_type],
		     x + 2, y + half_height,
		     x + half_width, y + 2);
      gdk_draw_line (window, style->bg_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
gtk_default_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
gtk_default_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);
  
  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 
gtk_default_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)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (window != 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);
  
  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_draw_rectangle (window, style->bg_gc[state_type], TRUE,
			  x, y, width, height);
      if (area)
	{
	  gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
	}
    }
  else
    gtk_style_apply_default_background (style, window,
					widget && !GTK_WIDGET_NO_WINDOW (widget),
					state_type, area, x, y, width, height);
  
  gtk_paint_shadow (style, window, state_type, shadow_type, area, widget, detail,
		    x, y, width, height);
}

static void 
gtk_default_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);
  
  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) && (!strcmp("text",detail)) && (state_type == GTK_STATE_SELECTED))
    gc1 = style->bg_gc[GTK_STATE_SELECTED];
  else if ((detail) && (!strcmp("viewportbin",detail)))
    gc1 = style->bg_gc[GTK_STATE_NORMAL];
  else if ((detail) && (!strcmp("entry_bg",detail)))
    gc1 = style->base_gc[state_type];
  else
    gc1 = style->bg_gc[state_type];
  
  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_background (style, window,
					widget && !GTK_WIDGET_NO_WINDOW (widget),
					state_type, area, x, y, width, height);
}

static void 
gtk_default_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)
{
  gtk_paint_box (style, window, state_type, shadow_type, area, widget, detail,
		 x, y, width, height);
}

static void 
gtk_default_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)
{
  gtk_paint_diamond (style, window, state_type, shadow_type, area, widget, 
		     detail, x, y, width, height);
}

static void 
gtk_default_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 
gtk_default_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 gtk_default_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 
gtk_default_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)
{
  GdkGC *gc1 = NULL;
  GdkGC *gc2 = NULL;
  GdkGC *gc3 = NULL;
  GdkGC *gc4 = NULL;
  
  g_return_if_fail (style != NULL);
  g_return_if_fail (window != 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);
  
  switch (shadow_type)
    {
    case GTK_SHADOW_NONE:
      return;
    case GTK_SHADOW_IN:
      gc1 = style->dark_gc[state_type];
      gc2 = style->black_gc;
      gc3 = style->bg_gc[state_type];
      gc4 = style->light_gc[state_type];
      break;
    case GTK_SHADOW_ETCHED_IN:
      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_OUT:
      gc1 = style->light_gc[state_type];
      gc2 = style->bg_gc[state_type];
      gc3 = style->dark_gc[state_type];
      gc4 = style->black_gc;
      break;
    case GTK_SHADOW_ETCHED_OUT:
      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;
    }
  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);
    }
  
  switch (shadow_type)
    {
    case GTK_SHADOW_NONE:
    case GTK_SHADOW_IN:
    case GTK_SHADOW_OUT:
    case GTK_SHADOW_ETCHED_IN:
    case GTK_SHADOW_ETCHED_OUT:
      switch (gap_side)
	{
	case GTK_POS_TOP:
	  gdk_draw_line (window, gc1,
			 x, y, x, y + height - 1);
	  gdk_draw_line (window, gc2,
			 x + 1, y, x + 1, y + height - 2);
	  
	  gdk_draw_line (window, gc3,
			 x + 1, y + height - 2, x + width - 2, y + height - 2);
	  gdk_draw_line (window, gc3,
			 x + width - 2, y, x + width - 2, y + height - 2);
	  gdk_draw_line (window, gc4,
			 x, y + height - 1, x + width - 1, y + height - 1);
	  gdk_draw_line (window, gc4,
			 x + width - 1, y, x + width - 1, y + height - 1);
	  if (gap_x > 0)
	    {
	      gdk_draw_line (window, gc1,
			     x, y, x + gap_x - 1, y);
	      gdk_draw_line (window, gc2,
			     x + 1, y + 1, x + gap_x - 1, y + 1);
	      gdk_draw_line (window, gc2,
			     x + gap_x, y, x + gap_x, y);
	    }
	  if ((width - (gap_x + gap_width)) > 0)
	    {
	      gdk_draw_line (window, gc1,
			     x + gap_x + gap_width, y, x + width - 2, y);
	      gdk_draw_line (window, gc2,
			     x + gap_x + gap_width, y + 1, x + width - 2, y + 1);
	      gdk_draw_line (window, gc2,
			     x + gap_x + gap_width - 1, y, x + gap_x + gap_width - 1, y);
	    }
	  break;
	case GTK_POS_BOTTOM:
	  gdk_draw_line (window, gc1,
			 x, y, x + width - 1, y);
	  gdk_draw_line (window, gc1,
			 x, y, x, y + height - 1);
	  gdk_draw_line (window, gc2,
			 x + 1, y + 1, x + width - 2, y + 1);
	  gdk_draw_line (window, gc2,
			 x + 1, y + 1, x + 1, y + height - 1);
	  
	  gdk_draw_line (window, gc3,
			 x + width - 2, y + 1, x + width - 2, y + height - 1);
	  gdk_draw_line (window, gc4,
			 x + width - 1, y, x + width - 1, y + height - 1);
	  if (gap_x > 0)
	    {
	      gdk_draw_line (window, gc4,
			     x, y + height - 1, x + gap_x - 1, y + height - 1);
	      gdk_draw_line (window, gc3,
			     x + 1, y + height - 2, x + gap_x - 1, y + height - 2);
	      gdk_draw_line (window, gc3,
			     x + gap_x, y + height - 1, x + gap_x, y + height - 1);
	    }
	  if ((width - (gap_x + gap_width)) > 0)
	    {
	      gdk_draw_line (window, gc4,
			     x + gap_x + gap_width, y + height - 1, x + width - 2, y + height - 1);
	      gdk_draw_line (window, gc3,
			     x + gap_x + gap_width, y + height - 2, x + width - 2, y + height - 2);
	      gdk_draw_line (window, gc3,
			     x + gap_x + gap_width - 1, y + height - 1, x + gap_x + gap_width - 1, y + height - 1);
	    }
	  break;
	case GTK_POS_LEFT:
	  gdk_draw_line (window, gc1,
			 x, y, x + width - 1, y);
	  gdk_draw_line (window, gc2,
			 x, y + 1, x + width - 2, y + 1);
	  
	  gdk_draw_line (window, gc3,
			 x, y + height - 2, x + width - 2, y + height - 2);
	  gdk_draw_line (window, gc3,
			 x + width - 2, y + 1, x + width - 2, y + height - 2);
	  gdk_draw_line (window, gc4,
			 x, y + height - 1, x + width - 1, y + height - 1);
	  gdk_draw_line (window, gc4,
			 x + width - 1, y, x + width - 1, y + height - 1);
	  if (gap_x > 0)
	    {
	      gdk_draw_line (window, gc1,
			     x, y, x, y + gap_x - 1);
	      gdk_draw_line (window, gc2,
			     x + 1, y + 1, x + 1, y + gap_x - 1);
	      gdk_draw_line (window, gc2,
			     x, y + gap_x, x, y + gap_x);
	    }
	  if ((width - (gap_x + gap_width)) > 0)
	    {
	      gdk_draw_line (window, gc1,
			     x, y + gap_x + gap_width, x, y + height - 2);
	      gdk_draw_line (window, gc2,
			     x + 1, y + gap_x + gap_width, x + 1, y + height - 2);
	      gdk_draw_line (window, gc2,
			     x, y + gap_x + gap_width - 1, x, y + gap_x + gap_width - 1);
	    }
	  break;
	case GTK_POS_RIGHT:
	  gdk_draw_line (window, gc1,
			 x, y, x + width - 1, y);
	  gdk_draw_line (window, gc1,
			 x, y, x, y + height - 1);
	  gdk_draw_line (window, gc2,
			 x + 1, y + 1, x + width - 1, y + 1);
	  gdk_draw_line (window, gc2,
			 x + 1, y + 1, x + 1, y + height - 2);
	  
	  gdk_draw_line (window, gc3,
			 x + 1, y + height - 2, x + width - 1, y + height - 2);
	  gdk_draw_line (window, gc4,
			 x, y + height - 1, x + width - 1, y + height - 1);
	  if (gap_x > 0)
	    {
	      gdk_draw_line (window, gc4,
			     x + width - 1, y, x + width - 1, y + gap_x - 1);
	      gdk_draw_line (window, gc3,
			     x + width - 2, y + 1, x + width - 2, y + gap_x - 1);
	      gdk_draw_line (window, gc3,
			     x + width - 1, y + gap_x, x + width - 1, y + gap_x);
	    }
	  if ((width - (gap_x + gap_width)) > 0)
	    {
	      gdk_draw_line (window, gc4,
			     x + width - 1, y + gap_x + gap_width, x + width - 1, y + height - 2);
	      gdk_draw_line (window, gc3,
			     x + width - 2, y + gap_x + gap_width, x + width - 2, y + height - 2);
	      gdk_draw_line (window, gc3,
			     x + width - 1, y + gap_x + gap_width - 1, x + width - 1, y + gap_x + gap_width - 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);
    }
}

static void 
gtk_default_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)
{
  GdkGC *gc1 = NULL;
  GdkGC *gc2 = NULL;
  GdkGC *gc3 = NULL;
  GdkGC *gc4 = NULL;
  
  g_return_if_fail (style != NULL);
  g_return_if_fail (window != NULL);
  
  gtk_style_apply_default_background (style, window,
				      widget && !GTK_WIDGET_NO_WINDOW (widget),
				      state_type, area, x, y, width, height);
  
  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:
      gc1 = style->dark_gc[state_type];
      gc2 = style->black_gc;
      gc3 = style->bg_gc[state_type];
      gc4 = style->light_gc[state_type];
      break;
    case GTK_SHADOW_ETCHED_IN:
      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_OUT:
      gc1 = style->light_gc[state_type];
      gc2 = style->bg_gc[state_type];
      gc3 = style->dark_gc[state_type];
      gc4 = style->black_gc;
      break;
    case GTK_SHADOW_ETCHED_OUT:
      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;
    }
  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);
    }
  
  switch (shadow_type)
    {
    case GTK_SHADOW_NONE:
    case GTK_SHADOW_IN:
    case GTK_SHADOW_OUT:
    case GTK_SHADOW_ETCHED_IN:
    case GTK_SHADOW_ETCHED_OUT:
      switch (gap_side)
	{
	case GTK_POS_TOP:
	  gdk_draw_line (window, gc1,
			 x, y, x, y + height - 1);
	  gdk_draw_line (window, gc2,
			 x + 1, y, x + 1, y + height - 2);
	  
	  gdk_draw_line (window, gc3,
			 x + 1, y + height - 2, x + width - 2, y + height - 2);
	  gdk_draw_line (window, gc3,
			 x + width - 2, y, x + width - 2, y + height - 2);
	  gdk_draw_line (window, gc4,
			 x, y + height - 1, x + width - 1, y + height - 1);
	  gdk_draw_line (window, gc4,
			 x + width - 1, y, x + width - 1, y + height - 1);
	  if (gap_x > 0)
	    {
	      gdk_draw_line (window, gc1,
			     x, y, x + gap_x - 1, y);
	      gdk_draw_line (window, gc2,
			     x + 1, y + 1, x + gap_x - 1, y + 1);
	      gdk_draw_line (window, gc2,
			     x + gap_x, y, x + gap_x, y);
	    }
	  if ((width - (gap_x + gap_width)) > 0)
	    {
	      gdk_draw_line (window, gc1,
			     x + gap_x + gap_width, y, x + width - 2, y);
	      gdk_draw_line (window, gc2,
			     x + gap_x + gap_width, y + 1, x + width - 2, y + 1);
	      gdk_draw_line (window, gc2,
			     x + gap_x + gap_width - 1, y, x + gap_x + gap_width - 1, y);
	    }
	  break;
	case  GTK_POS_BOTTOM:
	  gdk_draw_line (window, gc1,
			 x, y, x + width - 1, y);
	  gdk_draw_line (window, gc1,
			 x, y, x, y + height - 1);
	  gdk_draw_line (window, gc2,
			 x + 1, y + 1, x + width - 2, y + 1);
	  gdk_draw_line (window, gc2,
			 x + 1, y + 1, x + 1, y + height - 1);
	  
	  gdk_draw_line (window, gc3,
			 x + width - 2, y + 1, x + width - 2, y + height - 1);
	  gdk_draw_line (window, gc4,
			 x + width - 1, y, x + width - 1, y + height - 1);
	  if (gap_x > 0)
	    {
	      gdk_draw_line (window, gc4,
			     x, y + height - 1, x + gap_x - 1, y + height - 1);
	      gdk_draw_line (window, gc3,
			     x + 1, y + height - 2, x + gap_x - 1, y + height - 2);
	      gdk_draw_line (window, gc3,
			     x + gap_x, y + height - 1, x + gap_x, y + height - 1);
	    }
	  if ((width - (gap_x + gap_width)) > 0)
	    {
	      gdk_draw_line (window, gc4,
			     x + gap_x + gap_width, y + height - 1, x + width - 2, y + height - 1);
	      gdk_draw_line (window, gc3,
			     x + gap_x + gap_width, y + height - 2, x + width - 2, y + height - 2);
	      gdk_draw_line (window, gc3,
			     x + gap_x + gap_width - 1, y + height - 1, x + gap_x + gap_width - 1, y + height - 1);
	    }
	  break;
	case GTK_POS_LEFT:
	  gdk_draw_line (window, gc1,
			 x, y, x + width - 1, y);
	  gdk_draw_line (window, gc2,
			 x, y + 1, x + width - 2, y + 1);
	  
	  gdk_draw_line (window, gc3,
			 x, y + height - 2, x + width - 2, y + height - 2);
	  gdk_draw_line (window, gc3,
			 x + width - 2, y + 1, x + width - 2, y + height - 2);
	  gdk_draw_line (window, gc4,
			 x, y + height - 1, x + width - 1, y + height - 1);
	  gdk_draw_line (window, gc4,
			 x + width - 1, y, x + width - 1, y + height - 1);
	  if (gap_x > 0)
	    {
	      gdk_draw_line (window, gc1,
			     x, y, x, y + gap_x - 1);
	      gdk_draw_line (window, gc2,
			     x + 1, y + 1, x + 1, y + gap_x - 1);
	      gdk_draw_line (window, gc2,
			     x, y + gap_x, x, y + gap_x);
	    }
	  if ((width - (gap_x + gap_width)) > 0)
	    {
	      gdk_draw_line (window, gc1,
			     x, y + gap_x + gap_width, x, y + height - 2);
	      gdk_draw_line (window, gc2,
			     x + 1, y + gap_x + gap_width, x + 1, y + height - 2);
	      gdk_draw_line (window, gc2,
			     x, y + gap_x + gap_width - 1, x, y + gap_x + gap_width - 1);
	    }
	  break;
	case GTK_POS_RIGHT:
	  gdk_draw_line (window, gc1,
			 x, y, x + width - 1, y);
	  gdk_draw_line (window, gc1,
			 x, y, x, y + height - 1);
	  gdk_draw_line (window, gc2,
			 x + 1, y + 1, x + width - 1, y + 1);
	  gdk_draw_line (window, gc2,
			 x + 1, y + 1, x + 1, y + height - 2);
	  
	  gdk_draw_line (window, gc3,
			 x + 1, y + height - 2, x + width - 1, y + height - 2);
	  gdk_draw_line (window, gc4,
			 x, y + height - 1, x + width - 1, y + height - 1);
	  if (gap_x > 0)
	    {
	      gdk_draw_line (window, gc4,
			     x + width - 1, y, x + width - 1, y + gap_x - 1);
	      gdk_draw_line (window, gc3,
			     x + width - 2, y + 1, x + width - 2, y + gap_x - 1);
	      gdk_draw_line (window, gc3,
			     x + width - 1, y + gap_x, x + width - 1, y + gap_x);
	    }
	  if ((width - (gap_x + gap_width)) > 0)
	    {
	      gdk_draw_line (window, gc4,
			     x + width - 1, y + gap_x + gap_width, x + width - 1, y + height - 2);
	      gdk_draw_line (window, gc3,
			     x + width - 2, y + gap_x + gap_width, x + width - 2, y + height - 2);
	      gdk_draw_line (window, gc3,
			     x + width - 1, y + gap_x + gap_width - 1, x + width - 1, y + gap_x + gap_width - 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);
    }
}

static void 
gtk_default_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)
{
  GdkGC *gc1 = NULL;
  GdkGC *gc2 = NULL;
  GdkGC *gc3 = NULL;
  GdkGC *gc4 = NULL;
  
  g_return_if_fail (style != NULL);
  g_return_if_fail (window != NULL);
  
  gtk_style_apply_default_background (style, window,
				      widget && !GTK_WIDGET_NO_WINDOW (widget),
				      GTK_STATE_NORMAL, area, x, y, width, height);
  
  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:
      gc1 = style->dark_gc[state_type];
      gc2 = style->black_gc;
      gc3 = style->bg_gc[state_type];
      gc4 = style->light_gc[state_type];
      break;
    case GTK_SHADOW_ETCHED_IN:
      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_OUT:
      gc1 = style->light_gc[state_type];
      gc2 = style->bg_gc[state_type];
      gc3 = style->dark_gc[state_type];
      gc4 = style->black_gc;
      break;
    case GTK_SHADOW_ETCHED_OUT:
      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;
    }
  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);
    }
  switch (shadow_type)
    {
    case GTK_SHADOW_NONE:
    case GTK_SHADOW_IN:
    case GTK_SHADOW_OUT:
    case GTK_SHADOW_ETCHED_IN:
    case GTK_SHADOW_ETCHED_OUT:
      switch (gap_side)
	{
	case GTK_POS_TOP:
	  gtk_style_apply_default_background (style, window,
					      widget && !GTK_WIDGET_NO_WINDOW (widget),
					      state_type, area,
					      x + style->klass->xthickness, 
					      y, 
					      width - (2 * style->klass->xthickness), 
					      height - (style->klass->ythickness));
	  gdk_draw_line (window, gc1,
			 x, y, x, y + height - 2);
	  gdk_draw_line (window, gc2,
			 x + 1, y, x + 1, y + height - 2);
	  
	  gdk_draw_line (window, gc3,
			 x + 2, y + height - 2, x + width - 2, y + height - 2);
	  gdk_draw_line (window, gc3,
			 x + width - 2, y, x + width - 2, y + height - 2);
	  gdk_draw_line (window, gc4,
			 x + 1, y + height - 1, x + width - 2, y + height - 1);
	  gdk_draw_line (window, gc4,
			 x + width - 1, y, x + width - 1, y + height - 2);
	  break;
	case GTK_POS_BOTTOM:
	  gtk_style_apply_default_background (style, window,
					      widget && !GTK_WIDGET_NO_WINDOW (widget),
					      state_type, area,
					      x + style->klass->xthickness, 
					      y + style->klass->ythickness, 
					      width - (2 * style->klass->xthickness), 
					      height - (style->klass->ythickness));
	  gdk_draw_line (window, gc1,
			 x + 1, y, x + width - 2, y);
	  gdk_draw_line (window, gc1,
			 x, y + 1, x, y + height - 1);
	  gdk_draw_line (window, gc2,
			 x + 1, y + 1, x + width - 2, y + 1);
	  gdk_draw_line (window, gc2,
			 x + 1, y + 1, x + 1, y + height - 1);
	  
	  gdk_draw_line (window, gc3,
			 x + width - 2, y + 2, x + width - 2, y + height - 1);
	  gdk_draw_line (window, gc4,
			 x + width - 1, y + 1, x + width - 1, y + height - 1);
	  break;
	case GTK_POS_LEFT:
	  gtk_style_apply_default_background (style, window,
					      widget && !GTK_WIDGET_NO_WINDOW (widget),
					      state_type, area,
					      x, 
					      y + style->klass->ythickness, 
					      width - (style->klass->xthickness), 
					      height - (2 * style->klass->ythickness));
	  gdk_draw_line (window, gc1,
			 x, y, x + width - 2, y);
	  gdk_draw_line (window, gc2,
			 x + 1, y + 1, x + width - 2, y + 1);
	  
	  gdk_draw_line (window, gc3,
			 x, y + height - 2, x + width - 2, y + height - 2);
	  gdk_draw_line (window, gc3,
			 x + width - 2, y + 2, x + width - 2, y + height - 2);
	  gdk_draw_line (window, gc4,
			 x, y + height - 1, x + width - 2, y + height - 1);
	  gdk_draw_line (window, gc4,
			 x + width - 1, y + 1, x + width - 1, y + height - 2);
	  break;
	case GTK_POS_RIGHT:
	  gtk_style_apply_default_background (style, window,
					      widget && !GTK_WIDGET_NO_WINDOW (widget),
					      state_type, area,
					      x + style->klass->xthickness, 
					      y + style->klass->ythickness, 
					      width - (style->klass->xthickness), 
					      height - (2 * style->klass->ythickness));
	  gdk_draw_line (window, gc1,
			 x + 1, y, x + width - 1, y);
	  gdk_draw_line (window, gc1,
			 x, y + 1, x, y + height - 2);
	  gdk_draw_line (window, gc2,
			 x + 1, y + 1, x + width - 1, y + 1);
	  gdk_draw_line (window, gc2,
			 x + 1, y + 1, x + 1, y + height - 2);
	  
	  gdk_draw_line (window, gc3,
			 x + 2, y + height - 2, x + width - 1, y + height - 2);
	  gdk_draw_line (window, gc4,
			 x + 1, y + height - 1, x + width - 1, y + height - 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);
    }
}

static void 
gtk_default_draw_focus (GtkStyle      *style,
			GdkWindow     *window,
			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);
  
  if ((width == -1) && (height == -1))
    {
      gdk_window_get_size (window, &width, &height);
      width -= 1;
      height -= 1;
    }
  else if (width == -1)
    {
      gdk_window_get_size (window, &width, NULL);
      width -= 1;
    }
  else if (height == -1)
    {
      gdk_window_get_size (window, NULL, &height);
      height -= 1;
    }
  if (area)
    {
      gdk_gc_set_clip_rectangle (style->black_gc, area);
    }
  if (detail && !strcmp (detail, "add-mode"))
    {
      gdk_gc_set_line_attributes (style->black_gc, 1, GDK_LINE_ON_OFF_DASH, 0, 0);
      gdk_gc_set_dashes (style->black_gc, 0, "\4\4", 2);
      
      gdk_draw_rectangle (window,
			  style->black_gc, FALSE,
			  x, y, width, height);
      
      gdk_gc_set_line_attributes (style->black_gc, 1, GDK_LINE_SOLID, 0, 0);
    }
  else
    {
      gdk_draw_rectangle (window,
			  style->black_gc, FALSE,
			  x, y, width, height);
    }
  if (area)
    {
      gdk_gc_set_clip_rectangle (style->black_gc, NULL);
    }
}

static void 
gtk_default_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)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (window != 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);
  
  gtk_paint_box (style, window, state_type, shadow_type,
		 area, widget, detail, x, y, width, height);
  if (orientation == GTK_ORIENTATION_HORIZONTAL)
    gtk_paint_vline (style, window, state_type, area, widget, detail, 
		     style->klass->ythickness, 
		     height - style->klass->ythickness - 1, width / 2);
  else
    gtk_paint_hline (style, window, state_type, area, widget, detail, 
		     style->klass->xthickness, 
		     width - style->klass->xthickness - 1, height / 2);
}

static void 
gtk_default_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 xx, yy;
  gint xthick, ythick;
  GdkGC *light_gc, *dark_gc;
  GdkRectangle dest;
  
  g_return_if_fail (style != NULL);
  g_return_if_fail (window != 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);
  
  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);
  
  for (yy = y + ythick; yy < (y + height - ythick); yy += 3)
    for (xx = x + xthick; xx < (x + width - xthick); xx += 6)
      {
	gdk_draw_point (window, light_gc, xx, yy);
	gdk_draw_point (window, dark_gc, xx + 1, yy + 1);
	
	gdk_draw_point (window, light_gc, xx + 3, yy + 1);
	gdk_draw_point (window, dark_gc, xx + 4, yy + 2);
      }
  gdk_gc_set_clip_rectangle (light_gc, NULL);
  gdk_gc_set_clip_rectangle (dark_gc, NULL);
}

static void
gtk_style_shade (GdkColor *a,
		 GdkColor *b,
		 gdouble   k)
{
  gdouble red;
  gdouble green;
  gdouble blue;
  
  red = (gdouble) a->red / 65535.0;
  green = (gdouble) a->green / 65535.0;
  blue = (gdouble) a->blue / 65535.0;
  
  rgb_to_hls (&red, &green, &blue);
  
  green *= k;
  if (green > 1.0)
    green = 1.0;
  else if (green < 0.0)
    green = 0.0;
  
  blue *= k;
  if (blue > 1.0)
    blue = 1.0;
  else if (blue < 0.0)
    blue = 0.0;
  
  hls_to_rgb (&red, &green, &blue);
  
  b->red = red * 65535.0;
  b->green = green * 65535.0;
  b->blue = blue * 65535.0;
}

static void
rgb_to_hls (gdouble *r,
	    gdouble *g,
	    gdouble *b)
{
  gdouble min;
  gdouble max;
  gdouble red;
  gdouble green;
  gdouble blue;
  gdouble h, l, s;
  gdouble delta;
  
  red = *r;
  green = *g;
  blue = *b;
  
  if (red > green)
    {
      if (red > blue)
	max = red;
      else
	max = blue;
      
      if (green < blue)
	min = green;
      else
	min = blue;
    }
  else
    {
      if (green > blue)
	max = green;
      else
	max = blue;
      
      if (red < blue)
	min = red;
      else
	min = blue;
    }
  
  l = (max + min) / 2;
  s = 0;
  h = 0;
  
  if (max != min)
    {
      if (l <= 0.5)
	s = (max - min) / (max + min);
      else
	s = (max - min) / (2 - max - min);
      
      delta = max -min;
      if (red == max)
	h = (green - blue) / delta;
      else if (green == max)
	h = 2 + (blue - red) / delta;
      else if (blue == max)
	h = 4 + (red - green) / delta;
      
      h *= 60;
      if (h < 0.0)
	h += 360;
    }
  
  *r = h;
  *g = l;
  *b = s;
}

static void
hls_to_rgb (gdouble *h,
	    gdouble *l,
	    gdouble *s)
{
  gdouble hue;
  gdouble lightness;
  gdouble saturation;
  gdouble m1, m2;
  gdouble r, g, b;
  
  lightness = *l;
  saturation = *s;
  
  if (lightness <= 0.5)
    m2 = lightness * (1 + saturation);
  else
    m2 = lightness + saturation - lightness * saturation;
  m1 = 2 * lightness - m2;
  
  if (saturation == 0)
    {
      *h = lightness;
      *l = lightness;
      *s = lightness;
    }
  else
    {
      hue = *h + 120;
      while (hue > 360)
	hue -= 360;
      while (hue < 0)
	hue += 360;
      
      if (hue < 60)
	r = m1 + (m2 - m1) * hue / 60;
      else if (hue < 180)
	r = m2;
      else if (hue < 240)
	r = m1 + (m2 - m1) * (240 - hue) / 60;
      else
	r = m1;
      
      hue = *h;
      while (hue > 360)
	hue -= 360;
      while (hue < 0)
	hue += 360;
      
      if (hue < 60)
	g = m1 + (m2 - m1) * hue / 60;
      else if (hue < 180)
	g = m2;
      else if (hue < 240)
	g = m1 + (m2 - m1) * (240 - hue) / 60;
      else
	g = m1;
      
      hue = *h - 120;
      while (hue > 360)
	hue -= 360;
      while (hue < 0)
	hue += 360;
      
      if (hue < 60)
	b = m1 + (m2 - m1) * hue / 60;
      else if (hue < 180)
	b = m2;
      else if (hue < 240)
	b = m1 + (m2 - m1) * (240 - hue) / 60;
      else
	b = m1;
      
      *h = r;
      *l = g;
      *s = b;
    }
}

void 
gtk_paint_hline (GtkStyle      *style,
		 GdkWindow     *window,
		 GtkStateType   state_type,
		 GdkRectangle  *area,
		 GtkWidget     *widget,
		 gchar         *detail,
		 gint	       x1,
		 gint	       x2,
		 gint	       y)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_hline != NULL);
  
  (*style->klass->draw_hline) (style, window, state_type, area, widget, detail, x1, x2, y);
}

void
gtk_paint_vline (GtkStyle      *style,
		 GdkWindow     *window,
		 GtkStateType   state_type,
		 GdkRectangle  *area,
		 GtkWidget     *widget,
		 gchar         *detail,
		 gint	       y1,
		 gint	       y2,
		 gint	       x)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_vline != NULL);
  
  (*style->klass->draw_vline) (style, window, state_type, area, widget, detail, y1, y2, x);
}

void
gtk_paint_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)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_shadow != NULL);
  
  (*style->klass->draw_shadow) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}

void
gtk_paint_polygon (GtkStyle      *style,
		   GdkWindow     *window,
		   GtkStateType   state_type,
		   GtkShadowType  shadow_type,
		   GdkRectangle  *area,
		   GtkWidget     *widget,
		   gchar         *detail,
		   GdkPoint      *points,
		   gint	          npoints,
		   gboolean       fill)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_shadow != NULL);
  
  (*style->klass->draw_polygon) (style, window, state_type, shadow_type, area, widget, detail, points, npoints, fill);
}

void
gtk_paint_arrow (GtkStyle      *style,
		 GdkWindow     *window,
		 GtkStateType   state_type,
		 GtkShadowType  shadow_type,
		 GdkRectangle  *area,
		 GtkWidget     *widget,
		 gchar         *detail,
		 GtkArrowType   arrow_type,
		 gboolean       fill,
		 gint	        x,
		 gint	        y,
		 gint	        width,
		 gint	        height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_arrow != NULL);
  
  (*style->klass->draw_arrow) (style, window, state_type, shadow_type, area, widget, detail, arrow_type, fill, x, y, width, height);
}

void
gtk_paint_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)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_diamond != NULL);
  
  (*style->klass->draw_diamond) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}

void
gtk_paint_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 (style->klass != NULL);
  g_return_if_fail (style->klass->draw_oval != NULL);
  
  (*style->klass->draw_oval) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}

void
gtk_paint_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 (style->klass != NULL);
  g_return_if_fail (style->klass->draw_oval != NULL);
  
  (*style->klass->draw_string) (style, window, state_type, area, widget, detail, x, y, string);
}

void
gtk_paint_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)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_box != NULL);
  
  (*style->klass->draw_box) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}

void
gtk_paint_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)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_flat_box != NULL);
  
  (*style->klass->draw_flat_box) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}

void
gtk_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)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_check != NULL);
  
  (*style->klass->draw_check) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}

void
gtk_paint_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)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_option != NULL);
  
  (*style->klass->draw_option) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}

void
gtk_paint_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 (style->klass != NULL);
  g_return_if_fail (style->klass->draw_cross != NULL);
  
  (*style->klass->draw_cross) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}

void
gtk_paint_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 (style->klass != NULL);
  g_return_if_fail (style->klass->draw_ramp != NULL);
  
  (*style->klass->draw_ramp) (style, window, state_type, shadow_type, area, widget, detail, arrow_type, x, y, width, height);
}

void
gtk_paint_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 (style->klass != NULL);
  g_return_if_fail (style->klass->draw_tab != NULL);
  
  (*style->klass->draw_tab) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
}

void
gtk_paint_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)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_shadow_gap != NULL);
  
  (*style->klass->draw_shadow_gap) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
}


void
gtk_paint_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)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_box_gap != NULL);
  
  (*style->klass->draw_box_gap) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side, gap_x, gap_width);
}

void
gtk_paint_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)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_extension != NULL);
  
  (*style->klass->draw_extension) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, gap_side);
}

void
gtk_paint_focus (GtkStyle      *style,
		 GdkWindow     *window,
		 GdkRectangle  *area,
		 GtkWidget     *widget,
		 gchar         *detail,
		 gint           x,
		 gint           y,
		 gint           width,
		 gint           height)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_focus != NULL);
  
  (*style->klass->draw_focus) (style, window, area, widget, detail, x, y, width, height);
}

void
gtk_paint_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)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_slider != NULL);
  
  (*style->klass->draw_slider) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
}

void
gtk_paint_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)
{
  g_return_if_fail (style != NULL);
  g_return_if_fail (style->klass != NULL);
  g_return_if_fail (style->klass->draw_handle != NULL);
  
  (*style->klass->draw_handle) (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height, orientation);
}