livetrax/libs/clearlooks-older/clearlooks_style.c

#include <gtk/gtk.h>

#include "clearlooks_style.h"
#include "clearlooks_rc_style.h"
#include "clearlooks_draw.h"

#include <math.h>
#include <string.h>

#include "bits.c"
#include "support.h"
//#include "config.h"

/* #define DEBUG 1 */

#define SCALE_SIZE 5

#define DETAIL(xx)   ((detail) && (!strcmp(xx, detail)))
#define COMPARE_COLORS(a,b) (a.red == b.red && a.green == b.green && a.blue == b.blue)

#define DRAW_ARGS    GtkStyle       *style, \
                     GdkWindow      *window, \
                     GtkStateType    state_type, \
                     GtkShadowType   shadow_type, \
                     GdkRectangle   *area, \
                     GtkWidget      *widget, \
                     const gchar    *detail, \
                     gint            x, \
                     gint            y, \
                     gint            width, \
                     gint            height

static GdkGC *realize_color (GtkStyle * style, GdkColor * color);
static GtkStyleClass *parent_class;
static GList *progressbars = NULL;
static gint8 pboffset = 10;
static int timer_id = 0;

static void cl_progressbar_remove (gpointer data)
{
	if (g_list_find (progressbars, data) == NULL)
		return;

	progressbars = g_list_remove (progressbars, data);
	g_object_unref (data);

	if (g_list_first(progressbars) == NULL) {
		g_source_remove(timer_id);
		timer_id = 0;
	}
}

static void update_progressbar (gpointer data, gpointer user_data)
{
	gfloat fraction;

	if (data == NULL)
		return;

	fraction = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (data));

	/* update only if not filled */
	if (fraction < 1.0)
		gtk_widget_queue_resize ((GtkWidget*)data);

	if (fraction >= 1.0 || GTK_PROGRESS (data)->activity_mode)
		cl_progressbar_remove (data);
}

static gboolean timer_func (gpointer data)
{
	g_list_foreach (progressbars, update_progressbar, NULL);
	if (--pboffset < 0) pboffset = 9;
	return (g_list_first(progressbars) != NULL);
}

static gboolean cl_progressbar_known(gconstpointer data)
{
	return (g_list_find (progressbars, data) != NULL);
}


static void cl_progressbar_add (gpointer data)
{
	if (!GTK_IS_PROGRESS_BAR (data))
		return;

	progressbars = g_list_append (progressbars, data);

	g_object_ref (data);
	g_signal_connect ((GObject*)data, "unrealize", G_CALLBACK (cl_progressbar_remove), data);

	if (timer_id == 0)
		timer_id = g_timeout_add (100, timer_func, NULL);
}

static GdkColor *
clearlooks_get_spot_color (ClearlooksRcStyle *clearlooks_rc)
{
	GtkRcStyle *rc = GTK_RC_STYLE (clearlooks_rc);

	if (clearlooks_rc->has_spot_color)
		return &clearlooks_rc->spot_color;
	else
		return &rc->base[GTK_STATE_SELECTED];
}

/**************************************************************************/

/* used for optionmenus... */
static void
draw_tab (GtkStyle      *style,
	  GdkWindow     *window,
	  GtkStateType   state_type,
	  GtkShadowType  shadow_type,
	  GdkRectangle  *area,
	  GtkWidget     *widget,
	  const gchar   *detail,
	  gint           x,
	  gint           y,
	  gint           width,
	  gint           height)
{
#define ARROW_SPACE 2
#define ARROW_LINE_HEIGHT 2
#define ARROW_LINE_WIDTH 5
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	GtkRequisition indicator_size;
	GtkBorder indicator_spacing;
	gint arrow_height;

	option_menu_get_props (widget, &indicator_size, &indicator_spacing);

	indicator_size.width += (indicator_size.width % 2) - 1;
	arrow_height = indicator_size.width / 2 + 2;

	x += (width - indicator_size.width) / 2;
	y += height/2;

	if (state_type == GTK_STATE_INSENSITIVE)
	{
		draw_arrow (window, style->light_gc[state_type], area,
		            GTK_ARROW_UP, 1+x, 1+y-arrow_height,
		            indicator_size.width, arrow_height);

		draw_arrow (window, style->light_gc[state_type], area,
		            GTK_ARROW_DOWN, 1+x, 1+y+1,
		            indicator_size.width, arrow_height);
	}

	draw_arrow (window, style->fg_gc[state_type], area,
	            GTK_ARROW_UP, x, y-arrow_height,
	            indicator_size.width, arrow_height);

	draw_arrow (window, style->fg_gc[state_type], area,
	            GTK_ARROW_DOWN, x, y+1,
	            indicator_size.width, arrow_height);
}

static void
clearlooks_draw_arrow (GtkStyle      *style,
                       GdkWindow     *window,
                       GtkStateType   state,
                       GtkShadowType  shadow,
                       GdkRectangle  *area,
                       GtkWidget     *widget,
                       const gchar   *detail,
                       GtkArrowType   arrow_type,
                       gboolean       fill,
                       gint           x,
                       gint           y,
                       gint           width,
                       gint           height)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	gint original_width, original_x;
	GdkGC *gc;

	sanitize_size (window, &width, &height);

	if (is_combo_box (widget))
	{
		width = 7;
		height = 5;
		x+=2;
		y+=4;
		if (state == GTK_STATE_INSENSITIVE)
		{
			draw_arrow (window, style->light_gc[state], area,
			            GTK_ARROW_UP, 1+x, 1+y-height,
			            width, height);

			draw_arrow (window, style->light_gc[state], area,
			            GTK_ARROW_DOWN, 1+x, 1+y+1,
			            width, height);
		}

		draw_arrow (window, style->fg_gc[state], area,
		            GTK_ARROW_UP, x, y-height,
		            width, height);

		draw_arrow (window, style->fg_gc[state], area,
		            GTK_ARROW_DOWN, x, y+1,
		            width, height);

		return;
	}

	original_width = width;
	original_x = x;

	/* Make spinbutton arrows and arrows in menus
	* slightly larger to get the right pixels drawn */
	if (DETAIL ("spinbutton"))
		height += 1;

	if (DETAIL("menuitem"))
	{
		width = 6;
		height = 7;
	}

	/* Compensate arrow position for "sunken" look */
	if (DETAIL ("spinbutton") && arrow_type == GTK_ARROW_DOWN &&
	    style->xthickness > 2 && style->ythickness > 2)
			y -= 1;

	if (widget && widget->parent && GTK_IS_COMBO (widget->parent->parent))
	{
		width -= 2;
		height -=2;
		x++;
	}

	calculate_arrow_geometry (arrow_type, &x, &y, &width, &height);

	if (DETAIL ("menuitem"))
		x = original_x + original_width - width;

	if (DETAIL ("spinbutton") && (arrow_type == GTK_ARROW_DOWN))
		y += 1;

	if (state == GTK_STATE_INSENSITIVE)
		draw_arrow (window, style->light_gc[state], area, arrow_type, x + 1, y + 1, width, height);

	gc = style->fg_gc[state];

	draw_arrow (window, gc, area, arrow_type, x, y, width, height);
}


static void
draw_flat_box (DRAW_ARGS)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);

	g_return_if_fail (GTK_IS_STYLE (style));
	g_return_if_fail (window != NULL);

	sanitize_size (window, &width, &height);

	if (detail &&
	    clearlooks_style->listviewitemstyle == 1 &&
	    state_type == GTK_STATE_SELECTED && (
	    !strncmp ("cell_even", detail, strlen ("cell_even")) ||
	    !strncmp ("cell_odd", detail, strlen ("cell_odd"))))
	{
		GdkGC    *gc;
		GdkColor  lower_color;
		GdkColor *upper_color;

		if (GTK_WIDGET_HAS_FOCUS (widget))
		{
			gc = style->base_gc[state_type];
			upper_color = &style->base[state_type];
		}
		else
		{
			gc = style->base_gc[GTK_STATE_ACTIVE];
			upper_color = &style->base[GTK_STATE_ACTIVE];
		}

		if (GTK_IS_TREE_VIEW (widget) && 0)
		{
			GtkTreeSelection *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));

			if (gtk_tree_selection_count_selected_rows (sel) > 1)
			{
				parent_class->draw_flat_box (style, window, state_type, shadow_type,
				                             area, widget, detail,
				                             x, y, width, height);
				return;
			}
		}

		shade (upper_color, &lower_color, 0.8);

		if (area)
			gdk_gc_set_clip_rectangle (gc, area);

		draw_hgradient (window, gc, style,
				x, y, width, height, upper_color, &lower_color);

		if (area)
			gdk_gc_set_clip_rectangle (gc, NULL);
	}
	else
	{
		parent_class->draw_flat_box (style, window, state_type,
				             shadow_type,
			                     area, widget, detail,
			                     x, y, width, height);
	}
}
/**************************************************************************/

static void
draw_shadow (DRAW_ARGS)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	CLRectangle r;

	GdkGC *outer_gc = clearlooks_style->shade_gc[4];
	GdkGC *gc1 = NULL;
	GdkGC *gc2 = NULL;
	gint thickness_light;
	gint thickness_dark;
	gboolean interior_focus = FALSE;

#if DEBUG
		printf("draw_shadow: %s %d %d %d %d\n", detail, x, y, width, height);
#endif

	if (widget == NULL)
	{
		gdk_draw_rectangle (window, outer_gc, FALSE,
		                    x, y, width - 1, height - 1);
		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);

	cl_rectangle_reset (&r, style);

	if (DETAIL ("frame") && widget->parent &&
	    GTK_IS_STATUSBAR (widget->parent))
	{
		gtk_style_apply_default_background (style, window,widget && !GTK_WIDGET_NO_WINDOW (widget),
		                                    state_type, area, x, y, width, height);

		if (area)
		{
			gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], area);
			gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], area);
		}

		gdk_draw_line (window, clearlooks_style->shade_gc[3],
		               x, y, x + width, y);
		gdk_draw_line (window, clearlooks_style->shade_gc[0],
		               x, y + 1, x + width, y + 1);

		if (area)
		{
			gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], NULL);
			gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], NULL);
		}
	}
	else if (detail && !strcmp (detail, "entry"))
	{
		if ( widget->parent && (GTK_IS_COMBO_BOX_ENTRY (widget->parent) ||
		                        GTK_IS_SPIN_BUTTON(widget) ||
		                        GTK_IS_COMBO (widget->parent)))
		{
			cl_draw_combobox_entry (style, window, GTK_WIDGET_STATE(widget), shadow_type, area, widget, detail, x, y, width, height);
		}
		else
		{
			cl_draw_entry (style, window, GTK_WIDGET_STATE(widget), shadow_type, area, widget, detail, x, y, width, height);
		}
	}
	else if (DETAIL ("viewport") || DETAIL ("scrolled_window"))
	{
		gdk_draw_rectangle (window, clearlooks_style->shade_gc[4], FALSE,
		                    x, y, width - 1, height - 1);
	}
	else
	{
		if (DETAIL ("menuitem"))
			outer_gc = clearlooks_style->spot3_gc;
		else
			outer_gc = clearlooks_style->shade_gc[4];

		if (shadow_type == GTK_SHADOW_IN)
			gdk_draw_rectangle (window, outer_gc, FALSE,
			                    x, y, width - 1, height - 1);
		else if (shadow_type == GTK_SHADOW_OUT)
		{
			gdk_draw_rectangle (window, outer_gc, FALSE,
			                    x, y, width - 1, height - 1);
			gdk_draw_line (window, style->light_gc[state_type],
			               x+1, y+1, x+width-2, y+1);
			gdk_draw_line (window, style->light_gc[state_type],
			               x+1, y+1, x+1, y+height-2);
		}
		else if (shadow_type == GTK_SHADOW_ETCHED_IN)
		{
			GdkGC *a = clearlooks_style->shade_gc[(shadow_type == GTK_SHADOW_ETCHED_IN) ? 0 : 3];
			GdkGC *b = clearlooks_style->shade_gc[(shadow_type == GTK_SHADOW_ETCHED_IN) ? 3 : 0];

			cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
			                              CL_CORNER_NONE, CL_CORNER_NONE);

			r.bordergc = a;
			cl_rectangle_set_clip_rectangle (&r, area);
			cl_draw_rectangle (window, widget, style, x+1, y+1, width-1, height-1, &r);
			cl_rectangle_reset_clip_rectangle (&r);

			r.bordergc = b;
			cl_rectangle_set_clip_rectangle (&r, area);
			cl_draw_rectangle (window, widget, style, x, y, width-1, height-1, &r);
			cl_rectangle_reset_clip_rectangle (&r);
		}
		else if (shadow_type == GTK_SHADOW_ETCHED_IN)
		{
			GdkGC *a = clearlooks_style->shade_gc[(shadow_type == GTK_SHADOW_ETCHED_IN) ? 3 : 0];
			GdkGC *b = clearlooks_style->shade_gc[(shadow_type == GTK_SHADOW_ETCHED_IN) ? 0 : 3];

			cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
			                              CL_CORNER_NONE, CL_CORNER_NONE);

			r.bordergc = a;
			cl_rectangle_set_clip_rectangle (&r, area);
			cl_draw_rectangle (window, widget, style, x+1, y+1, width-1, height-1, &r);
			cl_rectangle_reset_clip_rectangle (&r);

			r.bordergc = b;
			cl_rectangle_set_clip_rectangle (&r, area);
			cl_draw_rectangle (window, widget, style, x, y, width-1, height-1, &r);
			cl_rectangle_reset_clip_rectangle (&r);
		}
		else
			parent_class->draw_shadow (style, window, state_type, shadow_type,
			                           area, widget, detail,
			                           x, y, width, height);
	}
}

#define GDK_RECTANGLE_SET(rect,a,b,c,d) rect.x = a; \
                                        rect.y = b; \
                                        rect.width = c; \
                                        rect.height = d;


static void
draw_box_gap (DRAW_ARGS,
	      GtkPositionType gap_side,
	      gint            gap_x,
	      gint            gap_width)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	CLRectangle r;

	GdkRegion *area_region = NULL,
	          *gap_region  = NULL;
	GdkRectangle light_rect;
	GdkRectangle dark_rect;

#if DEBUG
		printf("draw_box_gap: %s %d %d %d %d\n", detail, x, y, width, height);
#endif

	g_return_if_fail (GTK_IS_STYLE (style));
	g_return_if_fail (window != NULL);

	sanitize_size (window, &width, &height);

	cl_rectangle_reset (&r, style);

	r.bordergc = clearlooks_style->shade_gc[5];

	r.topleft     = style->light_gc[state_type];
	r.bottomright = clearlooks_style->shade_gc[1];

	if (area)
		area_region = gdk_region_rectangle (area);
	else
	{
		GdkRectangle tmp = { x, y, width, height };
		area_region = gdk_region_rectangle (&tmp);
	}

	switch (gap_side)
	{
		case GTK_POS_TOP:
		{
			GdkRectangle rect = { x+gap_x+1, y, gap_width-2, 2 };
			gap_region = gdk_region_rectangle (&rect);

			GDK_RECTANGLE_SET (light_rect, x+gap_x+1, y, x+gap_x+1, y+1);
			GDK_RECTANGLE_SET (dark_rect, x+gap_x+gap_width-2, y, x+gap_x+gap_width-2, y);

			cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
			                              CL_CORNER_ROUND, CL_CORNER_ROUND);

			break;
		}
		case GTK_POS_BOTTOM:
		{
			GdkRectangle rect = { x+gap_x+1, y+height-2, gap_width-2, 2 };
			gap_region = gdk_region_rectangle (&rect);

			GDK_RECTANGLE_SET (light_rect, x+gap_x+1, y+height-2, x+gap_x+1, y+height-1);
			GDK_RECTANGLE_SET (dark_rect, x+gap_x+gap_width-2, y+height-2, x+gap_x+gap_width-2, y+height-1);

			cl_rectangle_set_corners (&r, CL_CORNER_ROUND, CL_CORNER_ROUND,
			                              CL_CORNER_NONE, CL_CORNER_NONE);

			break;
		}
		case GTK_POS_LEFT:
		{
			GdkRectangle rect = { x, y+gap_x+1, 2, gap_width-2 };
			gap_region = gdk_region_rectangle (&rect);

			GDK_RECTANGLE_SET (light_rect, x, y+gap_x+1, x+1, y+gap_x+1);
			GDK_RECTANGLE_SET (dark_rect, x, y+gap_x+gap_width-2, x, y+gap_x+gap_width-2);

			cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_ROUND,
			                              CL_CORNER_NONE, CL_CORNER_ROUND);
			break;
		}
		case GTK_POS_RIGHT:
		{
			GdkRectangle rect = { x+width-2, y+gap_x+1, 2, gap_width-2 };
			gap_region = gdk_region_rectangle (&rect);

			GDK_RECTANGLE_SET (light_rect, x+width-2, y+gap_x+1, x+width-1, y+gap_x+1);
			GDK_RECTANGLE_SET (dark_rect, x+width-2, y+gap_x+gap_width-2, x+width-1, y+gap_x+gap_width-2);

			cl_rectangle_set_corners (&r, CL_CORNER_ROUND, CL_CORNER_NONE,
			                              CL_CORNER_ROUND, CL_CORNER_NONE);
			break;
		}
	}

	gdk_region_subtract (area_region, gap_region);

	gdk_gc_set_clip_region (r.bordergc,    area_region);
	gdk_gc_set_clip_region (r.topleft,     area_region);
	gdk_gc_set_clip_region (r.bottomright, area_region);

	gdk_region_destroy (area_region);
	gdk_region_destroy (gap_region);

	gdk_draw_rectangle (window, style->bg_gc[state_type], TRUE, x, y, width, height);

	cl_draw_rectangle (window, widget, style, x, y, width, height, &r);

	cl_draw_shadow (window, widget, style, x, y, width, height, &r);

	gdk_gc_set_clip_region (r.bordergc,    NULL);
	gdk_gc_set_clip_region (r.topleft,     NULL);
	gdk_gc_set_clip_region (r.bottomright, NULL);

	/* it's a semi hack */
	gdk_draw_line (window, style->light_gc[state_type],
	               light_rect.x, light_rect.y,
	               light_rect.width, light_rect.height);

	gdk_draw_line (window, clearlooks_style->shade_gc[1],
	               dark_rect.x, dark_rect.y,
	               dark_rect.width, dark_rect.height);
}

/**************************************************************************/

static void
draw_extension (DRAW_ARGS, GtkPositionType gap_side)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	int              my_state_type = (state_type == GTK_STATE_ACTIVE) ? 2 : 0;
	CLRectangle      r;

#if DEBUG
		printf("draw_extension: %s %d %d %d %d\n", detail, x, y, width, height);
#endif

	g_return_if_fail (GTK_IS_STYLE (style));
	g_return_if_fail (window != NULL);

	sanitize_size (window, &width, &height);

	if (DETAIL ("tab"))
	{
		GdkRectangle new_area;
		GdkColor tmp_color;

		cl_rectangle_set_button (&r, style, state_type, FALSE, FALSE,
								CL_CORNER_ROUND, CL_CORNER_ROUND,
								CL_CORNER_ROUND, CL_CORNER_ROUND);

		if (state_type == GTK_STATE_ACTIVE)
			shade (&style->bg[state_type], &tmp_color, 1.08);
		else
			shade (&style->bg[state_type], &tmp_color, 1.05);

		if (area)
		{
			new_area = *area;
		}
		else
		{
			new_area.x = x;
			new_area.y = y;
			new_area.width = width;
			new_area.height = height;
		}

		switch (gap_side)
		{
			case GTK_POS_BOTTOM:
				height+=2;
				new_area.y = y;
				new_area.height = height-2;
				r.gradient_type = CL_GRADIENT_VERTICAL;
				cl_rectangle_set_gradient (&r.fill_gradient, &tmp_color, &style->bg[state_type]);
				cl_rectangle_set_gradient (&r.border_gradient,
	                                       &clearlooks_style->border[CL_BORDER_UPPER+my_state_type],
	                                       &clearlooks_style->border[CL_BORDER_LOWER+my_state_type]);
				break;
			case GTK_POS_TOP:
				y-=2;
				height+=2;
				new_area.y = y+2;
				new_area.height = height;
				r.gradient_type = CL_GRADIENT_VERTICAL;
				cl_rectangle_set_gradient (&r.fill_gradient, &style->bg[state_type], &tmp_color);
				cl_rectangle_set_gradient (&r.border_gradient,
	                                       &clearlooks_style->border[CL_BORDER_LOWER+my_state_type],
	                                       &clearlooks_style->border[CL_BORDER_UPPER+my_state_type]);
				break;
			case GTK_POS_LEFT:
				x-=2;
				width+=2;
				new_area.x = x+2;
				new_area.width = width;
				r.gradient_type = CL_GRADIENT_HORIZONTAL;
				cl_rectangle_set_gradient (&r.fill_gradient, &style->bg[state_type], &tmp_color);
				cl_rectangle_set_gradient (&r.border_gradient,
	                                       &clearlooks_style->border[CL_BORDER_LOWER+my_state_type],
	                                       &clearlooks_style->border[CL_BORDER_UPPER+my_state_type]);
				break;
			case GTK_POS_RIGHT:
				width+=2;
				new_area.x = x;
				new_area.width = width-2;
				r.gradient_type = CL_GRADIENT_HORIZONTAL;
				cl_rectangle_set_gradient (&r.fill_gradient, &tmp_color, &style->bg[state_type]);
				cl_rectangle_set_gradient (&r.border_gradient,
	                                       &clearlooks_style->border[CL_BORDER_UPPER+my_state_type],
	                                       &clearlooks_style->border[CL_BORDER_LOWER+my_state_type]);
				break;
		}

		r.topleft = style->light_gc[state_type];
		r.bottomright = (state_type == GTK_STATE_NORMAL) ? clearlooks_style->shade_gc[1] : NULL;

		cl_rectangle_set_clip_rectangle (&r, &new_area);
		cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
		cl_draw_shadow (window, widget, style, x, y, width, height, &r);
		cl_rectangle_reset_clip_rectangle (&r);

		/* draw the selection stripe */
		if (state_type != GTK_STATE_ACTIVE) {
			cl_rectangle_set_gradient (&r.fill_gradient, NULL, NULL);
			r.fillgc = clearlooks_style->spot2_gc;

			switch (gap_side)
			{
				case GTK_POS_BOTTOM:
					cl_rectangle_set_corners (&r, CL_CORNER_ROUND, CL_CORNER_ROUND,
					                              CL_CORNER_NONE, CL_CORNER_NONE);
					cl_rectangle_set_gradient (&r.border_gradient, &clearlooks_style->spot3, &clearlooks_style->spot2);
					r.gradient_type = CL_GRADIENT_VERTICAL;

					cl_rectangle_set_clip_rectangle (&r, &new_area);
					cl_draw_rectangle (window, widget, style, x, y, width, 3, &r);
					cl_rectangle_reset_clip_rectangle (&r);
					break;
				case GTK_POS_TOP:
					cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
					                              CL_CORNER_ROUND, CL_CORNER_ROUND);
					cl_rectangle_set_gradient (&r.border_gradient, &clearlooks_style->spot2, &clearlooks_style->spot3);
					r.gradient_type = CL_GRADIENT_VERTICAL;

					cl_rectangle_set_clip_rectangle (&r, &new_area);
					cl_draw_rectangle (window, widget, style, x, y + height - 3, width, 3, &r);
					cl_rectangle_reset_clip_rectangle (&r);
					break;
				case GTK_POS_LEFT:
					cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_ROUND,
					                              CL_CORNER_NONE, CL_CORNER_ROUND);
					cl_rectangle_set_gradient (&r.border_gradient, &clearlooks_style->spot2, &clearlooks_style->spot3);
					r.gradient_type = CL_GRADIENT_HORIZONTAL;

					cl_rectangle_set_clip_rectangle (&r, &new_area);
					cl_draw_rectangle (window, widget, style, x + width - 3, y, 3, height, &r);
					cl_rectangle_reset_clip_rectangle (&r);
					break;
				case GTK_POS_RIGHT:
					cl_rectangle_set_corners (&r, CL_CORNER_ROUND, CL_CORNER_NONE,
					                              CL_CORNER_ROUND, CL_CORNER_NONE);
					cl_rectangle_set_gradient (&r.border_gradient, &clearlooks_style->spot3, &clearlooks_style->spot2);
					r.gradient_type = CL_GRADIENT_HORIZONTAL;

					cl_rectangle_set_clip_rectangle (&r, &new_area);
					cl_draw_rectangle (window, widget, style, x, y, 3, height, &r);
					cl_rectangle_reset_clip_rectangle (&r);
					break;
			}
		}


	}
	else
	{
		parent_class->draw_extension (style, window, state_type, shadow_type, area,
		                              widget, detail, x, y, width, height,
		                              gap_side);
	}
}


/**************************************************************************/

static void
draw_handle (DRAW_ARGS, GtkOrientation orientation)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	gint xx, yy;
	gint xthick, ythick;
	GdkGC *light_gc, *dark_gc;
	GdkRectangle rect;
	GdkRectangle dest;
	gint intersect;
	gint h;
	int i;
	int n_lines;
	int offset;

#if DEBUG
		printf("draw_handle: %s %d %d %d %d\n", detail, x, y, width, height);
#endif

	g_return_if_fail (GTK_IS_STYLE (style));
	g_return_if_fail (window != NULL);

	sanitize_size (window, &width, &height);

	if (state_type == GTK_STATE_PRELIGHT)
		gtk_style_apply_default_background (style, window,
	                                  widget && !GTK_WIDGET_NO_WINDOW (widget),
	                                  state_type, area, x, y, width, height);

	/* orientation is totally bugged, but this actually works... */
	orientation = (width > height) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL;

	if (!strcmp (detail, "paned"))
	{
		/* we want to ignore the shadow border in paned widgets */
		xthick = 0;
		ythick = 0;
	}
	else
	{
		xthick = style->xthickness;
		ythick = style->ythickness;
	}

	if ( ((DETAIL ("handlebox") && widget && GTK_IS_HANDLE_BOX (widget)) || DETAIL ("dockitem")) &&
	     orientation == GTK_ORIENTATION_VERTICAL )
	{
		/* The line in the toolbar */

		light_gc = style->light_gc[state_type];
		dark_gc = clearlooks_style->shade_gc[3];

		if (area)
		{
			gdk_gc_set_clip_rectangle (light_gc, area);
			gdk_gc_set_clip_rectangle (dark_gc, area);
		}

		if (area)
		{
			gdk_gc_set_clip_rectangle (light_gc, NULL);
			gdk_gc_set_clip_rectangle (dark_gc, NULL);
		}

		if (area)
		{
			gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], area);
			gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], area);
		}

		gdk_draw_line (window, clearlooks_style->shade_gc[0], x, y, x + width, y);
		gdk_draw_line (window, clearlooks_style->shade_gc[3], x, y + height - 1, x + width, y + height - 1);

		if (area)
		{
			gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], NULL);
			gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], NULL);
		}
	}

	light_gc = clearlooks_style->shade_gc[0];
	dark_gc = clearlooks_style->shade_gc[4];

	rect.x = x + xthick;
	rect.y = y + ythick;
	rect.width = width - (xthick * 2);
	rect.height = height - (ythick * 2);

	if (area)
		intersect = gdk_rectangle_intersect (area, &rect, &dest);
	else
	{
		intersect = TRUE;
		dest = rect;
	}

	if (!intersect)
		return;

	gdk_gc_set_clip_rectangle (light_gc, &dest);
	gdk_gc_set_clip_rectangle (dark_gc, &dest);

	n_lines = (!strcmp (detail, "paned")) ? 21 : 11;

	if (orientation == GTK_ORIENTATION_VERTICAL)
	{
		h = width - 2 * xthick;
		h = MAX (3, h - 6);

		xx = x + (width - h) / 2;
		offset = (height - 2*ythick - 2*n_lines)/2 + 1;
		if (offset < 0)
			offset = 0;

		for (i = 0, yy = y + ythick + offset; yy <= (y + height - ythick - 1) && i < n_lines; yy += 2, i++)
		{
			gdk_draw_line (window, dark_gc, xx, yy, xx + h, yy);
			gdk_draw_line (window, light_gc, xx, yy + 1, xx + h, yy + 1);
		}
	}
	else
	{
		h = height - 2 * ythick;
		h = MAX (3, h - 6);

		yy = y + (height - h) / 2;
		offset = (width - 2*xthick - 2*n_lines)/2 + 1;
		if (offset < 0)
			offset = 0;

		for (i = 0, xx = x + xthick + offset;  i < n_lines; xx += 2, i++)
		{
			gdk_draw_line (window, dark_gc, xx, yy, xx, yy + h);
			gdk_draw_line (window, light_gc, xx + 1, yy, xx + 1, yy + h);
		}
	}

	gdk_gc_set_clip_rectangle (light_gc, NULL);
	gdk_gc_set_clip_rectangle (dark_gc, NULL);
}

/**************************************************************************/

static void
draw_box (DRAW_ARGS)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	CLRectangle r;
	gboolean false_size = FALSE;

#ifdef DEBUG
		printf("draw_box: %s %d %d %d %d\n", detail, x, y, width, height);
#endif

	g_return_if_fail (style != NULL);
	g_return_if_fail (window != NULL);

	if (width == -1 || height == -1)
		false_size = TRUE;

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

	cl_rectangle_reset (&r, style);

	if (widget == NULL)
		return;

	/* listview headers */
	if (widget && DETAIL ("button") && widget->parent &&
	         (GTK_IS_TREE_VIEW(widget->parent) ||
	          GTK_IS_CLIST (widget->parent) ||
			  strcmp(G_OBJECT_TYPE_NAME (widget->parent), "ETree") == 0))
	{
		cl_draw_treeview_header (style, window, state_type, shadow_type,
		                         area, widget, detail, x, y, width, height);
	}
	else if (detail && (!strcmp (detail, "button") ||
		                !strcmp (detail, "buttondefault")))
	{
		if (GTK_IS_COMBO_BOX_ENTRY(widget->parent) || GTK_IS_COMBO(widget->parent))
		{
			cl_draw_combobox_button (style, window, state_type, shadow_type,
			                         area, widget,
		                             detail, x, y, width, height);
		}
		else
		{
			cl_draw_button (style, window, state_type, shadow_type, area, widget,
		                    detail, x, y, width, height);
		}
	}
	else if (detail && (
	         !strcmp (detail, "spinbutton_up") ||
	         !strcmp (detail, "spinbutton_down") ||
	         !strcmp (detail, "spinbutton")))
	{
		cl_draw_spinbutton (style, window, state_type, shadow_type, area,
		                    widget, detail, x, y, width, height);
	}
	else if (detail && (
		     !strcmp (detail, "hscale") || !strcmp (detail, "vscale")))
	{
		cl_rectangle_set_button (&r, style, state_type,
		                GTK_WIDGET_HAS_DEFAULT  (widget), GTK_WIDGET_HAS_FOCUS (widget),
		                CL_CORNER_ROUND, CL_CORNER_ROUND,
		                CL_CORNER_ROUND, CL_CORNER_ROUND);

		if (!strcmp (detail, "hscale") || !strcmp (detail, "vscale"))
		{
			r.fill_gradient.to = &clearlooks_style->shade[2];
			r.bottomright = clearlooks_style->shade_gc[2];
		}

		cl_set_corner_sharpness (detail, widget, &r);

		if (!strcmp (detail, "spinbutton_up"))
		{
			r.border_gradient.to = r.border_gradient.from;
			height++;
			gtk_style_apply_default_background (style, window, FALSE, state_type,
			                                    area, x, y, width, height);
		}
		else if (!strcmp (detail, "spinbutton_down"))
		{
			r.border_gradient.to = r.border_gradient.from;
			gtk_style_apply_default_background (style, window, FALSE, state_type,
			                                    area, x, y, width, height);
		}

		cl_rectangle_set_clip_rectangle (&r, area);
		cl_draw_rectangle (window, widget, style, x+1, y+1, width-2, height-2, &r);
		cl_draw_shadow (window, widget, style, x+1, y+1, width-2, height-2, &r);
		cl_rectangle_reset_clip_rectangle (&r);
	}
	else if (DETAIL ("trough") && GTK_IS_PROGRESS_BAR (widget))
	{
		GdkPoint points[4] = { {x,y}, {x+width-1,y}, {x,y+height-1}, {x+width-1,y+height-1} };

		gdk_draw_points (window, style->bg_gc[state_type], points, 4);

		r.bordergc = clearlooks_style->shade_gc[5];
		r.fillgc   = clearlooks_style->shade_gc[2];

		cl_rectangle_set_corners (&r, CL_CORNER_NARROW, CL_CORNER_NARROW,
			                          CL_CORNER_NARROW, CL_CORNER_NARROW);

		cl_rectangle_set_clip_rectangle (&r, area);
		cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
		cl_rectangle_reset_clip_rectangle (&r);
	}
	else if (DETAIL ("trough") &&
		     (GTK_IS_VSCALE (widget) || GTK_IS_HSCALE (widget)))
	{
		GdkGC   *inner  = clearlooks_style->shade_gc[3],
		        *outer  = clearlooks_style->shade_gc[5],
			    *shadow = clearlooks_style->shade_gc[4];
		GdkColor upper_color = *clearlooks_get_spot_color (CLEARLOOKS_RC_STYLE (style->rc_style)),
				 lower_color;

		GtkAdjustment *adjustment = gtk_range_get_adjustment (GTK_RANGE (widget));

		GtkOrientation orientation = GTK_RANGE (widget)->orientation;

		gint fill_size = (orientation ? height : width) *
		                 (1 / ((adjustment->upper - adjustment->lower) /
		                      (adjustment->value - adjustment->lower)));

		if (orientation == GTK_ORIENTATION_HORIZONTAL)
		{
			y += (height - SCALE_SIZE) / 2;
			height = SCALE_SIZE;
		}
		else
		{
			x += (width - SCALE_SIZE) / 2;
			width = SCALE_SIZE;
		}

		if (state_type == GTK_STATE_INSENSITIVE)
		{
			outer  = clearlooks_style->shade_gc[4];
			inner  = clearlooks_style->shade_gc[2];
			shadow = clearlooks_style->shade_gc[3];
		}

		cl_rectangle_init (&r, inner, outer, CL_CORNER_NONE, CL_CORNER_NONE,
		                                     CL_CORNER_NONE, CL_CORNER_NONE );

		r.topleft = shadow;

		cl_rectangle_set_clip_rectangle (&r, area);
		cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
		cl_draw_shadow (window, widget, style, x, y, width, height, &r);
		cl_rectangle_reset_clip_rectangle (&r);

		/* DRAW FILL */
		shade (&upper_color, &lower_color, 1.3);

		r.bordergc = clearlooks_style->spot3_gc;
		r.fillgc   = style->bg_gc[state_type];

		r.gradient_type = (orientation == GTK_ORIENTATION_HORIZONTAL ) ? CL_GRADIENT_VERTICAL
																	   : CL_GRADIENT_HORIZONTAL;

		cl_rectangle_set_gradient (&r.fill_gradient, &upper_color, &lower_color);

		cl_rectangle_set_clip_rectangle (&r, area);
		if (orientation == GTK_ORIENTATION_HORIZONTAL && fill_size > 1)
		{
			if (gtk_range_get_inverted(GTK_RANGE(widget)) != (get_direction(widget) == GTK_TEXT_DIR_RTL))
				cl_draw_rectangle (window, widget, style, x+width-fill_size, y, fill_size, height, &r);
			else
				cl_draw_rectangle (window, widget, style, x, y, fill_size, height, &r);
		}
		else if (fill_size > 1)
		{
			if (gtk_range_get_inverted (GTK_RANGE (widget)))
				cl_draw_rectangle (window, widget, style, x, y+height-fill_size, width, fill_size, &r);
			else
				cl_draw_rectangle (window, widget, style, x, y, width, fill_size, &r);
		}
		cl_rectangle_reset_clip_rectangle (&r);
	}
	else if (DETAIL ("trough"))
	{
		GdkGC *inner  = clearlooks_style->shade_gc[3],
		      *outer  = clearlooks_style->shade_gc[5];

		cl_rectangle_init (&r, inner, outer, CL_CORNER_NONE, CL_CORNER_NONE,
		                                     CL_CORNER_NONE, CL_CORNER_NONE );

		if (GTK_RANGE (widget)->orientation == GTK_ORIENTATION_VERTICAL)
		{
			y+=1;
			height-=2;
		}
		else
		{
			x+=1;
			width-=2;
		}

		cl_rectangle_set_clip_rectangle (&r, area);
		cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
		cl_rectangle_reset_clip_rectangle (&r);
	}
	else if (detail && (!strcmp (detail, "vscrollbar") ||
	                    !strcmp (detail, "hscrollbar") ||
			    !strcmp (detail, "stepper")))
	{
		ClScrollButtonType button_type = CL_SCROLLBUTTON_OTHER;
		gboolean horizontal = TRUE;

		if (GTK_IS_VSCROLLBAR(widget))
		{
			if (y == widget->allocation.y)
				button_type = CL_SCROLLBUTTON_BEGIN;
			else if (y+height == widget->allocation.y+widget->allocation.height)
				button_type = CL_SCROLLBUTTON_END;

			horizontal = FALSE;
		}
		else if (GTK_IS_HSCROLLBAR(widget))
		{
			if (x == widget->allocation.x)
				button_type = CL_SCROLLBUTTON_BEGIN;
			else if (x+width == widget->allocation.x+widget->allocation.width)
				button_type = CL_SCROLLBUTTON_END;
		}

		cl_rectangle_set_button (&r, style, state_type, FALSE, FALSE, 0,0,0,0);

		cl_rectangle_set_gradient (&r.fill_gradient, NULL, NULL);
		cl_rectangle_set_gradient (&r.fill_gradient, &clearlooks_style->inset_light[state_type],
		                           &clearlooks_style->inset_dark[state_type]);


		r.gradient_type = horizontal ? CL_GRADIENT_VERTICAL
		                             : CL_GRADIENT_HORIZONTAL;

		r.bottomright = clearlooks_style->shade_gc[1];
		r.border_gradient.to = r.border_gradient.from;

		if (button_type == CL_SCROLLBUTTON_OTHER)
		{
			cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
			                              CL_CORNER_NONE, CL_CORNER_NONE);
		}
		else if (button_type == CL_SCROLLBUTTON_BEGIN)
		{
			if (horizontal)
				cl_rectangle_set_corners (&r, CL_CORNER_ROUND, CL_CORNER_NONE,
											  CL_CORNER_ROUND, CL_CORNER_NONE);
			else
				cl_rectangle_set_corners (&r, CL_CORNER_ROUND, CL_CORNER_ROUND,
											  CL_CORNER_NONE,  CL_CORNER_NONE);
		}
		else
		{
			if (horizontal)
				cl_rectangle_set_corners (&r, CL_CORNER_NONE,  CL_CORNER_ROUND,
											  CL_CORNER_NONE,  CL_CORNER_ROUND);
			else
				cl_rectangle_set_corners (&r, CL_CORNER_NONE,  CL_CORNER_NONE,
											  CL_CORNER_ROUND, CL_CORNER_ROUND);
		}

		cl_rectangle_set_clip_rectangle (&r, area);
		cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
		cl_draw_shadow (window, widget, style, x, y, width, height, &r);
		cl_rectangle_reset_clip_rectangle (&r);

	}
	else if (DETAIL ("slider"))
	{
		if (DETAIL("slider") && widget && GTK_IS_RANGE (widget))
		{
			GtkAdjustment *adj = GTK_RANGE (widget)->adjustment;

			if (adj->value <= adj->lower &&
				(GTK_RANGE (widget)->has_stepper_a || GTK_RANGE (widget)->has_stepper_b))
			{
				if (GTK_IS_VSCROLLBAR (widget))
				{
					y-=1;
					height+=1;
				}
				else if (GTK_IS_HSCROLLBAR (widget))
				{
					x-=1;
					width+=1;
				}
			}
			if (adj->value >= adj->upper - adj->page_size &&
			    (GTK_RANGE (widget)->has_stepper_c || GTK_RANGE (widget)->has_stepper_d))
			{
				if (GTK_IS_VSCROLLBAR (widget))
					height+=1;
				else if (GTK_IS_HSCROLLBAR (widget))
					width+=1;
			}
		}

		cl_rectangle_set_button (&r, style, state_type, FALSE, GTK_WIDGET_HAS_FOCUS (widget),
		                        CL_CORNER_NONE, CL_CORNER_NONE,
		                        CL_CORNER_NONE, CL_CORNER_NONE);

		r.gradient_type = GTK_IS_HSCROLLBAR (widget) ? CL_GRADIENT_VERTICAL
		                                             : CL_GRADIENT_HORIZONTAL;

		cl_rectangle_set_gradient (&r.fill_gradient, &clearlooks_style->inset_light[state_type],
		                           &clearlooks_style->inset_dark[state_type]);

		r.bottomright = clearlooks_style->shade_gc[1];
		r.border_gradient.to = r.border_gradient.from;

		cl_rectangle_set_clip_rectangle (&r, area);
		cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
		cl_draw_shadow (window, widget, style, x, y, width, height, &r);
		cl_rectangle_reset_clip_rectangle (&r);
	}
	else if (detail && !strcmp (detail, "optionmenu")) /* supporting deprecated */
	{
		cl_draw_optionmenu(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
	}
	else if (DETAIL ("menuitem"))
	{
		if (clearlooks_style->menuitemstyle == 0)
		{
			cl_draw_menuitem_flat (window, widget, style, area, state_type,
			                       x, y, width, height, &r);
		}
		else if (clearlooks_style->menuitemstyle == 1)
		{
			cl_draw_menuitem_gradient (window, widget, style, area, state_type,
			                           x, y, width, height, &r);
		}
		else
		{
			cl_draw_menuitem_button (window, widget, style, area, state_type,
			                         x, y, width, height, &r);
		}
	}
	else if (DETAIL ("menubar") && (clearlooks_style->sunkenmenubar || clearlooks_style->menubarstyle > 0))
	{
		GdkGC *dark = clearlooks_style->shade_gc[2];
		GdkColor upper_color, lower_color;

		/* don't draw sunken menubar on gnome panel
		   IT'S A HACK! HORRIBLE HACK! HIDEOUS HACK!
		   BUT IT WORKS FOR ME(tm)! */
		if (widget->parent &&
			strcmp(G_OBJECT_TYPE_NAME (widget->parent), "PanelWidget") == 0)
			return;

		shade(&style->bg[state_type], &upper_color, 1.0);
		shade(&style->bg[state_type], &lower_color, 0.95);

		cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
		                              CL_CORNER_NONE, CL_CORNER_NONE);

		r.fillgc = style->bg_gc[state_type];
		r.bordergc = clearlooks_style->shade_gc[2];
		r.gradient_type = CL_GRADIENT_VERTICAL;

		cl_rectangle_set_gradient (&r.border_gradient, &clearlooks_style->shade[2],
		                                               &clearlooks_style->shade[3]);
		cl_rectangle_set_gradient (&r.fill_gradient, &upper_color, &lower_color);

		/* make vertical and top borders invisible for style 2 */
		if (clearlooks_style->menubarstyle == 2) {
			x--; width+=2;
			y--; height+=1;
		}

		cl_rectangle_set_clip_rectangle (&r, area);
		cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
		cl_rectangle_reset_clip_rectangle (&r);
	}
	else if (DETAIL ("menu") && widget->parent &&
	         GDK_IS_WINDOW (widget->parent->window))
	{
		cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
		                              CL_CORNER_NONE, CL_CORNER_NONE);

		r.bordergc    = clearlooks_style->border_gc[CL_BORDER_UPPER];
		r.topleft     = style->light_gc[state_type];
		r.bottomright = clearlooks_style->shade_gc[1];

		cl_rectangle_set_clip_rectangle (&r, area);
		cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
		cl_draw_shadow (window, widget, style, x, y, width, height, &r);
		cl_rectangle_reset_clip_rectangle (&r);

		return;
	}
	else if (DETAIL ("bar") && widget && GTK_IS_PROGRESS_BAR (widget))
	{
		GdkColor upper_color = *clearlooks_get_spot_color (CLEARLOOKS_RC_STYLE (style->rc_style)),
		         lower_color,
		         prev_foreground;
		gboolean activity_mode = GTK_PROGRESS (widget)->activity_mode;

#ifdef HAVE_ANIMATION
		if (!activity_mode && gtk_progress_bar_get_fraction (widget) != 1.0 &&
			!cl_progressbar_known((gconstpointer)widget))
		{
			cl_progressbar_add ((gpointer)widget);
		}
#endif
		cl_progressbar_fill (window, widget, style, style->black_gc,
		                     x, y, width, height,
#ifdef HAVE_ANIMATION
		                     activity_mode ? 0 : pboffset,
#else
		                     0,
#endif
		                     area);

		cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
		                              CL_CORNER_NONE, CL_CORNER_NONE);

		r.bordergc = clearlooks_style->spot3_gc;
		r.topleft = clearlooks_style->spot2_gc;

		prev_foreground = cl_gc_set_fg_color_shade (clearlooks_style->spot2_gc,
		                                            style->colormap,
		                                            &clearlooks_style->spot2,
		                                            1.2);

		cl_rectangle_set_clip_rectangle (&r, area);
		cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
		cl_draw_shadow (window, widget, style, x, y, width, height, &r);
		cl_rectangle_reset_clip_rectangle (&r);

		gdk_gc_set_foreground (clearlooks_style->spot2_gc, &prev_foreground);
	}

	else if ( widget && (DETAIL ("menubar") || DETAIL ("toolbar") || DETAIL ("dockitem_bin") || DETAIL ("handlebox_bin")) && shadow_type != GTK_SHADOW_NONE) /* Toolbars and menus */
	{
		if (area)
		{
			gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], area);
			gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], area);
		}

		gtk_style_apply_default_background (style, window,
				widget && !GTK_WIDGET_NO_WINDOW (widget),
				state_type, area, x, y, width, height);

		/* we only want the borders on horizontal toolbars */
		if ( DETAIL ("menubar") || height < 2*width ) {
			if (!DETAIL ("menubar"))
				gdk_draw_line (window, clearlooks_style->shade_gc[0],
				               x, y, x + width, y); /* top */

			gdk_draw_line (window, clearlooks_style->shade_gc[3],
			               x, y + height - 1, x + width, y + height - 1); /* bottom */
		}

		if (area)
		{
			gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], NULL);
			gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], NULL);
		}
	}
	else
	{
		parent_class->draw_box (style, window, state_type, shadow_type, area,
		                        widget, detail, x, y, width, height);
	}
}

/**************************************************************************/

static void
ensure_check_pixmaps (GtkStyle     *style,
                      GtkStateType  state,
                      GdkScreen    *screen,
                      gboolean      treeview)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	ClearlooksRcStyle *clearlooks_rc = CLEARLOOKS_RC_STYLE (style->rc_style);
	GdkPixbuf *check, *base, *inconsistent, *composite;
	GdkColor *spot_color = clearlooks_get_spot_color (clearlooks_rc);

	if (clearlooks_style->check_pixmap_nonactive[state] != NULL)
		return;

	if (state == GTK_STATE_ACTIVE || state == GTK_STATE_SELECTED) {
		check = generate_bit (check_alpha, &style->text[GTK_STATE_NORMAL], 1.0);
		inconsistent = generate_bit (check_inconsistent_alpha, &style->text[GTK_STATE_NORMAL], 1.0);
	} else {
		check = generate_bit (check_alpha, &style->text[state], 1.0);
		inconsistent = generate_bit (check_inconsistent_alpha, &style->text[state], 1.0);
	}

	if (state == GTK_STATE_ACTIVE && !treeview)
		base = generate_bit (check_base_alpha, &style->bg[state], 1.0);
	else
		base = generate_bit (check_base_alpha, &style->base[GTK_STATE_NORMAL], 1.0);

	if (treeview)
		composite = generate_bit (NULL, &clearlooks_style->shade[6], 1.0);
	else
		composite = generate_bit (NULL, &clearlooks_style->shade[5], 1.0);

	gdk_pixbuf_composite (base, composite,
	                      0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
	                      1.0, 1.0, GDK_INTERP_NEAREST, 255);

	clearlooks_style->check_pixmap_nonactive[state] =
		pixbuf_to_pixmap (style, composite, screen);

	gdk_pixbuf_composite (check, composite,
	                      0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
	                      1.0, 1.0, GDK_INTERP_NEAREST, 255);

	clearlooks_style->check_pixmap_active[state] =
		pixbuf_to_pixmap (style, composite, screen);

	g_object_unref (composite);

	composite = generate_bit (NULL, &clearlooks_style->shade[6], 1.0);

	gdk_pixbuf_composite (base, composite,
	                      0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
	                      1.0, 1.0, GDK_INTERP_NEAREST, 255);

	gdk_pixbuf_composite (inconsistent, composite,
	                      0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
	                      1.0, 1.0, GDK_INTERP_NEAREST, 255);

	clearlooks_style->check_pixmap_inconsistent[state] =
		pixbuf_to_pixmap (style, composite, screen);

	g_object_unref (composite);
	g_object_unref (base);
	g_object_unref (check);
	g_object_unref (inconsistent);
}

static void
draw_check (DRAW_ARGS)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	GdkGC *gc = style->base_gc[state_type];
	GdkPixmap *pixmap;
	gboolean treeview;

	if (DETAIL ("check")) /* Menu item */
	{
		parent_class->draw_check (style, window, state_type, shadow_type, area,
					widget, detail, x, y, width, height);
		return;
	}

	treeview = widget && GTK_IS_TREE_VIEW(widget);
	ensure_check_pixmaps (style, state_type, gtk_widget_get_screen (widget), treeview);

	if (area)
		gdk_gc_set_clip_rectangle (gc, area);

	if (shadow_type == GTK_SHADOW_IN)
		pixmap = clearlooks_style->check_pixmap_active[state_type];
	else if (shadow_type == GTK_SHADOW_ETCHED_IN) /* inconsistent */
		pixmap = clearlooks_style->check_pixmap_inconsistent[state_type];
	else
		pixmap = clearlooks_style->check_pixmap_nonactive[state_type];

	x += (width - CHECK_SIZE)/2;
	y += (height - CHECK_SIZE)/2;

	gdk_draw_drawable (window, gc, pixmap, 0, 0, x, y, CHECK_SIZE, CHECK_SIZE);

	if (area)
		gdk_gc_set_clip_rectangle (gc, NULL);
}

/**************************************************************************/
static void
draw_slider (DRAW_ARGS, GtkOrientation orientation)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	GdkGC *shade_gc = clearlooks_style->shade_gc[4];
	GdkGC *white_gc = clearlooks_style->shade_gc[0];
	int x1, y1;

#if DEBUG
		printf("draw_slider: %s %d %d %d %d\n", detail, x, y, width, height);
#endif

	g_return_if_fail (GTK_IS_STYLE (style));
	g_return_if_fail (window != NULL);

	sanitize_size (window, &width, &height);

	gtk_paint_box (style, window, state_type, shadow_type,
	               area, widget, detail, x, y, width, height);

	if ((orientation == GTK_ORIENTATION_VERTICAL && height < 20) ||
		(orientation == GTK_ORIENTATION_HORIZONTAL && width < 20))
		return;

	if (detail && strcmp ("slider", detail) == 0)
	{
		if (area)
		{
			gdk_gc_set_clip_rectangle (shade_gc, area);
			gdk_gc_set_clip_rectangle (white_gc, area);
		}
		if (orientation == GTK_ORIENTATION_HORIZONTAL)
		{
			x1 = x + width / 2 - 4;
			y1 = y + (height - 6) / 2;
			gdk_draw_line (window, shade_gc, x1, y1, x1, y1 + 6);
			gdk_draw_line (window, white_gc, x1 + 1, y1, x1 + 1, y1 + 6);
			gdk_draw_line (window, shade_gc, x1 + 3, y1, x1 + 3, y1 + 6);
			gdk_draw_line (window, white_gc, x1 + 3 + 1, y1, x1 + 3 + 1, y1 + 6);
			gdk_draw_line (window, shade_gc, x1 + 3*2, y1, x1 + 3*2, y1 + 6);
			gdk_draw_line (window, white_gc, x1 + 3*2 + 1, y1, x1 + 3*2 + 1, y1 + 6);
		}
		else
		{
			x1 = x + (width - 6) / 2;
			y1 = y + height / 2 - 4;
			gdk_draw_line (window, shade_gc, x1 + 6, y1, x1, y1);
			gdk_draw_line (window, white_gc, x1 + 6, y1 + 1, x1, y1 + 1);
			gdk_draw_line (window, shade_gc, x1 + 6, y1 + 3, x1, y1 + 3);
			gdk_draw_line (window, white_gc, x1 + 6, y1 + 3 + 1, x1, y1 + 3 + 1);
			gdk_draw_line (window, shade_gc, x1 + 6, y1 + 3*2, x1, y1 + 3*2);
			gdk_draw_line (window, white_gc, x1 + 6, y1 + 3*2 + 1, x1, y1 + 3*2 + 1);
		}
		if (area)
		{
			gdk_gc_set_clip_rectangle (shade_gc, NULL);
			gdk_gc_set_clip_rectangle (white_gc, NULL);
		}
	}
	else if (detail && (strcmp ("hscale", detail) == 0 || strcmp ("vscale", detail) == 0))
	{
		if (area)
		{
			gdk_gc_set_clip_rectangle (shade_gc, area);
			gdk_gc_set_clip_rectangle (white_gc, area);
		}

		if (orientation == GTK_ORIENTATION_HORIZONTAL)
		{
			x1 = x + width / 2 - 3;
			y1 = y + (height - 7) / 2;
			gdk_draw_line (window, shade_gc, x1 + 0, y1 + 5, x1 + 0, y1 + 1);
			gdk_draw_line (window, white_gc, x1 + 1, y1 + 5, x1 + 1, y1 + 1);
			gdk_draw_line (window, shade_gc, x1 + 3, y1 + 5, x1 + 3, y1 + 1);
			gdk_draw_line (window, white_gc, x1 + 4, y1 + 5, x1 + 4, y1 + 1);
			gdk_draw_line (window, shade_gc, x1 + 6,  y1 + 5, x1 + 6, y1 + 1);
			gdk_draw_line (window, white_gc, x1 + 7,  y1 + 5, x1 + 7, y1 + 1);
		}
		else
		{
			x1 = x + (width - 7) / 2;
			y1 = y + height / 2 - 3;
			gdk_draw_line (window, shade_gc, x1 + 5, y1 + 0, x1 + 1, y1 + 0);
			gdk_draw_line (window, white_gc, x1 + 5, y1 + 1, x1 + 1, y1 + 1);
			gdk_draw_line (window, shade_gc, x1 + 5, y1 + 3, x1 + 1, y1 + 3);
			gdk_draw_line (window, white_gc, x1 + 5, y1 + 4, x1 + 1, y1 + 4);
			gdk_draw_line (window, shade_gc, x1 + 5, y1 + 6, x1 + 1, y1 + 6);
			gdk_draw_line (window, white_gc, x1 + 5, y1 + 7, x1 + 1, y1 + 7);
		}
		if (area)
		{
			gdk_gc_set_clip_rectangle (shade_gc, NULL);
			gdk_gc_set_clip_rectangle (white_gc, NULL);
		}
	}
}

/**************************************************************************/
static void
ensure_radio_pixmaps (GtkStyle     *style,
		      GtkStateType  state,
		      GdkScreen    *screen)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	ClearlooksRcStyle *clearlooks_rc = CLEARLOOKS_RC_STYLE (style->rc_style);
	GdkPixbuf *dot, *circle, *outline, *inconsistent, *composite;
	GdkColor *spot_color = clearlooks_get_spot_color (clearlooks_rc);
	GdkColor *composite_color;

	if (clearlooks_style->radio_pixmap_nonactive[state] != NULL)
		return;

	if (state == GTK_STATE_ACTIVE || state == GTK_STATE_SELECTED) {
		dot = colorize_bit (dot_intensity, dot_alpha, &style->text[GTK_STATE_NORMAL]);
		inconsistent = generate_bit (inconsistent_alpha, &style->text[GTK_STATE_NORMAL], 1.0);
	} else {
		dot = colorize_bit (dot_intensity, dot_alpha, &style->text[state]);
		inconsistent = generate_bit (inconsistent_alpha, &style->text[state], 1.0);
	}

	outline = generate_bit (outline_alpha, &clearlooks_style->shade[5], 1.0);

	if (clearlooks_style->radio_pixmap_mask == NULL)
	{
		gdk_pixbuf_render_pixmap_and_mask (outline,
		                                   NULL,
		                                   &clearlooks_style->radio_pixmap_mask,
		                                   1);
	}

	if (state == GTK_STATE_ACTIVE)
	{
		composite_color = &style->bg[GTK_STATE_PRELIGHT];
		circle = generate_bit (circle_alpha, &style->bg[state], 1.0);
	}
	else
	{
		composite_color = &style->bg[state];
		circle = generate_bit (circle_alpha, &style->base[GTK_STATE_NORMAL], 1.0);
	}

	composite = generate_bit (NULL, composite_color, 1.0);

	gdk_pixbuf_composite (outline, composite,
	                      0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
	                      1.0, 1.0, GDK_INTERP_NEAREST, 255);

	gdk_pixbuf_composite (circle, composite,
	                      0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
	                      1.0, 1.0, GDK_INTERP_NEAREST, 255);

	clearlooks_style->radio_pixmap_nonactive[state] =
		pixbuf_to_pixmap (style, composite, screen);

	gdk_pixbuf_composite (dot, composite,
	                      0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
	                      1.0, 1.0, GDK_INTERP_NEAREST, 255);

	clearlooks_style->radio_pixmap_active[state] =
		pixbuf_to_pixmap (style, composite, screen);

	g_object_unref (composite);

	composite = generate_bit (NULL, composite_color,1.0);

	gdk_pixbuf_composite (outline, composite,
	                      0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
	                      1.0, 1.0, GDK_INTERP_NEAREST, 255);
	gdk_pixbuf_composite (circle, composite,
	                      0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
	                      1.0, 1.0, GDK_INTERP_NEAREST, 255);
	gdk_pixbuf_composite (inconsistent, composite,
	                      0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
	                      1.0, 1.0, GDK_INTERP_NEAREST, 255);

	clearlooks_style->radio_pixmap_inconsistent[state] =
		pixbuf_to_pixmap (style, composite, screen);

	g_object_unref (composite);
	g_object_unref (circle);
	g_object_unref (dot);
	g_object_unref (inconsistent);
	g_object_unref (outline);
}

static void
draw_option (DRAW_ARGS)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	GdkGC *gc = style->base_gc[state_type];
	GdkPixmap *pixmap;

	if (DETAIL ("option")) /* Menu item */
	{
		parent_class->draw_option (style, window, state_type, shadow_type,
		                           area, widget, detail, x, y, width, height);
		return;
	}

	ensure_radio_pixmaps (style, state_type, gtk_widget_get_screen (widget));

	if (area)
		gdk_gc_set_clip_rectangle (gc, area);

	if (shadow_type == GTK_SHADOW_IN)
		pixmap = clearlooks_style->radio_pixmap_active[state_type];
	else if (shadow_type == GTK_SHADOW_ETCHED_IN) /* inconsistent */
		pixmap = clearlooks_style->radio_pixmap_inconsistent[state_type];
	else
		pixmap = clearlooks_style->radio_pixmap_nonactive[state_type];

	x += (width - RADIO_SIZE)/2;
	y += (height - RADIO_SIZE)/2;

#ifndef GTKOSX
	gdk_gc_set_clip_mask (gc, clearlooks_style->radio_pixmap_mask);
	gdk_gc_set_clip_origin (gc, x, y);
#endif

	gdk_draw_drawable (window, gc, pixmap, 0, 0, x, y,
	                   RADIO_SIZE, RADIO_SIZE);

#ifndef GTKOSX
	gdk_gc_set_clip_origin (gc, 0, 0);
	gdk_gc_set_clip_mask (gc, NULL);
#endif

	if (area)
		gdk_gc_set_clip_rectangle (gc, NULL);
}

/**************************************************************************/

static void
draw_shadow_gap (DRAW_ARGS,
                 GtkPositionType gap_side,
                 gint            gap_x,
                 gint            gap_width)
{
	/* I need to improve this function. */
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	CLRectangle r;
	GdkRegion *area_region = NULL,
	          *gap_region  = NULL;

#if DEBUG
		printf("draw_shadow_gap: %s %d %d %d %d\n", detail, x, y, width, height);
#endif

	g_return_if_fail (GTK_IS_STYLE (style));
	g_return_if_fail (window != NULL);

	sanitize_size (window, &width, &height);

	cl_rectangle_reset (&r, style);
	cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
								  CL_CORNER_NONE, CL_CORNER_NONE);

	if (area)
	{
		area_region = gdk_region_rectangle (area);

		switch (gap_side)
		{
			case GTK_POS_TOP:
			{
				GdkRectangle rect = { x+gap_x, y, gap_width, 2 };
				gap_region = gdk_region_rectangle (&rect);
				break;
			}
			case GTK_POS_BOTTOM:
			{
				GdkRectangle rect = { x+gap_x, y+height-2, gap_width, 2 };
				gap_region = gdk_region_rectangle (&rect);
				break;
			}
			case GTK_POS_LEFT:
			{
				GdkRectangle rect = { x, y+gap_x, 2, gap_width };
				gap_region = gdk_region_rectangle (&rect);
				break;
			}
			case GTK_POS_RIGHT:
			{
				GdkRectangle rect = { x+width-2, y+gap_x, 2, gap_width };
				gap_region = gdk_region_rectangle (&rect);
				break;
			}
		}

		gdk_region_subtract (area_region, gap_region);
	}

	if (shadow_type == GTK_SHADOW_ETCHED_IN ||
	    shadow_type == GTK_SHADOW_ETCHED_OUT)
	{
		GdkGC *a;
		GdkGC *b;

		if (shadow_type == GTK_SHADOW_ETCHED_IN)
		{
			a = style->light_gc[state_type];
			b = clearlooks_style->shade_gc[3];
		}
		else
		{
			a = clearlooks_style->shade_gc[3];
			b = style->light_gc[state_type];
		}

		gdk_gc_set_clip_region (a, area_region);
		gdk_gc_set_clip_region (b, area_region);

		r.bordergc = a;
		cl_draw_rectangle (window, widget, style, x+1, y+1, width-1, height-1, &r);

		r.bordergc = b;
		cl_draw_rectangle (window, widget, style, x, y, width-1, height-1, &r);

		gdk_gc_set_clip_region (a, NULL);
		gdk_gc_set_clip_region (b, NULL);
	}
	else if (shadow_type == GTK_SHADOW_IN || shadow_type == GTK_SHADOW_OUT)
	{
		r.topleft     = (shadow_type == GTK_SHADOW_OUT) ? style->light_gc[state_type] : clearlooks_style->shade_gc[1];
		r.bottomright = (shadow_type == GTK_SHADOW_OUT) ? clearlooks_style->shade_gc[1] : style->light_gc[state_type];
		r.bordergc    = clearlooks_style->shade_gc[5];

		gdk_gc_set_clip_region (r.bordergc,    area_region);
		gdk_gc_set_clip_region (r.topleft,     area_region);
		gdk_gc_set_clip_region (r.bottomright, area_region);

		cl_draw_rectangle (window, widget, style, x, y, width, height, &r);

		cl_draw_shadow (window, widget, style, x, y, width, height, &r);

		gdk_gc_set_clip_region (r.bordergc,    NULL);
		gdk_gc_set_clip_region (r.topleft,     NULL);
		gdk_gc_set_clip_region (r.bottomright, NULL);
	}

	if (area_region)
		gdk_region_destroy (area_region);
}

/**************************************************************************/
static void
draw_hline (GtkStyle     *style,
            GdkWindow    *window,
            GtkStateType  state_type,
            GdkRectangle  *area,
            GtkWidget     *widget,
            const gchar   *detail,
            gint          x1,
            gint          x2,
            gint          y)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);

#if DEBUG
		printf("draw_hline\n");
#endif

	g_return_if_fail (GTK_IS_STYLE (style));
	g_return_if_fail (window != NULL);

	if (area)
		gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[2], area);

	if (detail && !strcmp (detail, "label"))
	{
		if (state_type == GTK_STATE_INSENSITIVE)
			gdk_draw_line (window, style->light_gc[state_type], x1 + 1, y + 1, x2 + 1, y + 1);

		gdk_draw_line (window, style->fg_gc[state_type], x1, y, x2, y);
	}
	else
	{
		gdk_draw_line (window, clearlooks_style->shade_gc[2], x1, y, x2, y);

		/* if (DETAIL ("menuitem")) */
		gdk_draw_line (window, clearlooks_style->shade_gc[0], x1, y+1, x2, y+1);
	}

	if (area)
		gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[2], NULL);
}

/**************************************************************************/
static void
draw_vline (GtkStyle     *style,
            GdkWindow    *window,
            GtkStateType  state_type,
            GdkRectangle  *area,
            GtkWidget     *widget,
            const gchar   *detail,
            gint          y1,
            gint          y2,
            gint          x)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	gint thickness_light;
	gint thickness_dark;

#if DEBUG
		printf("draw_vline\n");
#endif

	g_return_if_fail (GTK_IS_STYLE (style));
	g_return_if_fail (window != NULL);

	thickness_light = style->xthickness / 2;
	thickness_dark = style->xthickness - thickness_light;

	if (area)
		gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[2], area);

	gdk_draw_line (window, clearlooks_style->shade_gc[2], x, y1, x, y2 - 1);
	gdk_draw_line (window, clearlooks_style->shade_gc[0], x+1, y1, x+1, y2 - 1);

	if (area)
		gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[2], NULL);
}

/**************************************************************************/
static void
draw_focus (GtkStyle      *style,
	    GdkWindow     *window,
	    GtkStateType   state_type,
	    GdkRectangle  *area,
	    GtkWidget     *widget,
	    const gchar   *detail,
	    gint           x,
	    gint           y,
	    gint           width,
	    gint           height)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	GdkPoint points[5];
	GdkGC    *gc;
	gboolean free_dash_list = FALSE;
	gint line_width = 1;
	gchar *dash_list = "\1\1";
	gint dash_len;

#if DEBUG
		printf("draw_focus: %s %d %d %d %d\n", detail, x, y, width, height);
#endif

	gc = clearlooks_style->shade_gc[6];

	if (widget)
	{
		gtk_widget_style_get (widget,
		                      "focus-line-width", &line_width,
		                      "focus-line-pattern", (gchar *)&dash_list,
		                      NULL);

		free_dash_list = TRUE;
	}

	sanitize_size (window, &width, &height);

	if (area)
		gdk_gc_set_clip_rectangle (gc, area);

	gdk_gc_set_line_attributes (gc, line_width,
	                            dash_list[0] ? GDK_LINE_ON_OFF_DASH : GDK_LINE_SOLID,
	                            GDK_CAP_BUTT, GDK_JOIN_MITER);


	if (detail && !strcmp (detail, "add-mode"))
	{
		if (free_dash_list)
			g_free (dash_list);

		dash_list = "\4\4";
		free_dash_list = FALSE;
	}

	points[0].x = x + line_width / 2;
	points[0].y = y + line_width / 2;
	points[1].x = x + width - line_width + line_width / 2;
	points[1].y = y + line_width / 2;
	points[2].x = x + width - line_width + line_width / 2;
	points[2].y = y + height - line_width + line_width / 2;
	points[3].x = x + line_width / 2;
	points[3].y = y + height - line_width + line_width / 2;
	points[4] = points[0];

	if (!dash_list[0])
	{
		gdk_draw_lines (window, gc, points, 5);
	}
	else
	{
		dash_len = strlen (dash_list);

		if (dash_list[0])
			gdk_gc_set_dashes (gc, 0, dash_list, dash_len);

		gdk_draw_lines (window, gc, points, 3);

		points[2].x += 1;

		if (dash_list[0])
		{
			gint dash_pixels = 0;
			gint i;

			/* Adjust the dash offset for the bottom and left so we
			* match up at the upper left.
			*/
			for (i = 0; i < dash_len; i++)
				dash_pixels += dash_list[i];

			if (dash_len % 2 == 1)
				dash_pixels *= 2;

			gdk_gc_set_dashes (gc,
							dash_pixels - (width + height - 2 * line_width) % dash_pixels,
							dash_list, dash_len);
		}

		gdk_draw_lines (window, gc, points + 2, 3);
	}

	gdk_gc_set_line_attributes (gc, 0, GDK_LINE_SOLID, GDK_CAP_BUTT, GDK_JOIN_MITER);

	if (area)
		gdk_gc_set_clip_rectangle (gc, NULL);

	if (free_dash_list)
		g_free (dash_list);
}

static void
draw_layout(GtkStyle * style,
            GdkWindow * window,
            GtkStateType state_type,
            gboolean use_text,
            GdkRectangle * area,
            GtkWidget * widget,
            const gchar * detail, gint x, gint y, PangoLayout * layout)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);

	g_return_if_fail(GTK_IS_STYLE (style));
	g_return_if_fail(window != NULL);

	parent_class->draw_layout(style, window, state_type, use_text,
	                          area, widget, detail, x, y, layout);


}

/**************************************************************************/
static void
draw_resize_grip (GtkStyle       *style,
		  GdkWindow      *window,
		  GtkStateType    state_type,
		  GdkRectangle   *area,
		  GtkWidget      *widget,
		  const gchar    *detail,
		  GdkWindowEdge   edge,
		  gint            x,
		  gint            y,
		  gint            width,
		  gint            height)
{
  ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
  g_return_if_fail (GTK_IS_STYLE (style));
  g_return_if_fail (window != NULL);

  if (area)
    {
      gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
      gdk_gc_set_clip_rectangle (style->dark_gc[state_type], area);
      gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
    }

  switch (edge)
    {
    case GDK_WINDOW_EDGE_NORTH_WEST:
      /* make it square */
      if (width < height)
	{
	  height = width;
	}
      else if (height < width)
	{
	  width = height;
	}
      break;
    case GDK_WINDOW_EDGE_NORTH:
      if (width < height)
	{
	  height = width;
	}
      break;
    case GDK_WINDOW_EDGE_NORTH_EAST:
      /* make it square, aligning to top right */
      if (width < height)
	{
	  height = width;
	}
      else if (height < width)
	{
	  x += (width - height);
	  width = height;
	}
      break;
    case GDK_WINDOW_EDGE_WEST:
      if (height < width)
	{
	   width = height;
	}
      break;
    case GDK_WINDOW_EDGE_EAST:
      /* aligning to right */
      if (height < width)
	{
	  x += (width - height);
	  width = height;
	}
      break;
    case GDK_WINDOW_EDGE_SOUTH_WEST:
      /* make it square, aligning to bottom left */
      if (width < height)
	{
	  y += (height - width);
	  height = width;
	}
      else if (height < width)
	{
	  width = height;
	}
      break;
    case GDK_WINDOW_EDGE_SOUTH:
      /* align to bottom */
      if (width < height)
	{
	  y += (height - width);
	  height = width;
	}
      break;
    case GDK_WINDOW_EDGE_SOUTH_EAST:
      /* make it square, aligning to bottom right */
      if (width < height)
	{
	  y += (height - width);
	  height = width;
	}
      else if (height < width)
	{
	  x += (width - height);
	  width = height;
	}
      break;
    default:
      g_assert_not_reached ();
    }

  /* Clear background */
  gtk_style_apply_default_background (style, window, FALSE,
				      state_type, area,
				      x, y, width, height);

  switch (edge)
    {
    case GDK_WINDOW_EDGE_WEST:
    case GDK_WINDOW_EDGE_EAST:
      {
	gint xi;

	xi = x;

	while (xi < x + width)
	  {
	    gdk_draw_line (window,
			   style->light_gc[state_type],
			   xi, y,
			   xi, y + height);

	    xi++;
	    gdk_draw_line (window,
			   clearlooks_style->shade_gc[4],
			   xi, y,
			   xi, y + height);

	    xi += 2;
	  }
      }
      break;
    case GDK_WINDOW_EDGE_NORTH:
    case GDK_WINDOW_EDGE_SOUTH:
      {
	gint yi;

	yi = y;

	while (yi < y + height)
	  {
	    gdk_draw_line (window,
			   style->light_gc[state_type],
			   x, yi,
			   x + width, yi);

	    yi++;
	    gdk_draw_line (window,
			   clearlooks_style->shade_gc[4],
			   x, yi,
			   x + width, yi);

	    yi+= 2;
	  }
      }
      break;
    case GDK_WINDOW_EDGE_NORTH_WEST:
      {
	gint xi, yi;

	xi = x + width;
	yi = y + height;

	while (xi > x + 3)
	  {
	    gdk_draw_line (window,
			   clearlooks_style->shade_gc[4],
			   xi, y,
			   x, yi);

	    --xi;
	    --yi;

	    gdk_draw_line (window,
			   style->light_gc[state_type],
			   xi, y,
			   x, yi);

	    xi -= 3;
	    yi -= 3;

	  }
      }
      break;
    case GDK_WINDOW_EDGE_NORTH_EAST:
      {
        gint xi, yi;

        xi = x;
        yi = y + height;

        while (xi < (x + width - 3))
          {
            gdk_draw_line (window,
                           style->light_gc[state_type],
                           xi, y,
                           x + width, yi);

            ++xi;
            --yi;

            gdk_draw_line (window,
                           clearlooks_style->shade_gc[4],
                           xi, y,
                           x + width, yi);

            xi += 3;
            yi -= 3;
          }
      }
      break;
    case GDK_WINDOW_EDGE_SOUTH_WEST:
      {
	gint xi, yi;

	xi = x + width;
	yi = y;

	while (xi > x + 3)
	  {
	    gdk_draw_line (window,
			   clearlooks_style->shade_gc[4],
			   x, yi,
			   xi, y + height);

	    --xi;
	    ++yi;

	    gdk_draw_line (window,
			   style->light_gc[state_type],
			   x, yi,
			   xi, y + height);

	    xi -= 3;
	    yi += 3;

	  }
      }
      break;

    case GDK_WINDOW_EDGE_SOUTH_EAST:
      {
        gint xi, yi;

        xi = x;
        yi = y;

        while (xi < (x + width - 3))
          {
            gdk_draw_line (window,
                           style->light_gc[state_type],
                           xi, y + height,
                           x + width, yi);

            ++xi;
            ++yi;

            gdk_draw_line (window,
                           clearlooks_style->shade_gc[4],
                           xi, y + height,
                           x + width, yi);

            xi += 3;
            yi += 3;
          }
      }
      break;
    default:
      g_assert_not_reached ();
      break;
    }

  if (area)
    {
      gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
      gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
      gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
    }
}

/**************************************************************************/

static void
clearlooks_style_init_from_rc (GtkStyle * style,
			       GtkRcStyle * rc_style)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	GdkColor *spot_color;
	double shades[] = {1.065, 0.93, 0.896, 0.85, 0.768, 0.665, 0.4, 0.205};
	int i;
	double contrast;

	parent_class->init_from_rc (style, rc_style);

	contrast = CLEARLOOKS_RC_STYLE (rc_style)->contrast;

	clearlooks_style->sunkenmenubar = CLEARLOOKS_RC_STYLE (rc_style)->sunkenmenubar;
	clearlooks_style->progressbarstyle = CLEARLOOKS_RC_STYLE (rc_style)->progressbarstyle;
	clearlooks_style->menubarstyle = CLEARLOOKS_RC_STYLE (rc_style)->menubarstyle;
	clearlooks_style->menuitemstyle = CLEARLOOKS_RC_STYLE (rc_style)->menuitemstyle;
	clearlooks_style->listviewitemstyle = CLEARLOOKS_RC_STYLE (rc_style)->listviewitemstyle;

	/* Lighter to darker */
	for (i = 0; i < 8; i++)
	{
		shade (&style->bg[GTK_STATE_NORMAL], &clearlooks_style->shade[i],
		       (shades[i]-0.7) * contrast + 0.7);
	}

	spot_color = clearlooks_get_spot_color (CLEARLOOKS_RC_STYLE (rc_style));

	clearlooks_style->spot_color = *spot_color;
	shade (&clearlooks_style->spot_color, &clearlooks_style->spot1, 1.42);
	shade (&clearlooks_style->spot_color, &clearlooks_style->spot2, 1.05);
	shade (&clearlooks_style->spot_color, &clearlooks_style->spot3, 0.65);

	shade (&style->bg[GTK_STATE_NORMAL], &clearlooks_style->border[CL_BORDER_UPPER],        0.5);
	shade (&style->bg[GTK_STATE_NORMAL], &clearlooks_style->border[CL_BORDER_LOWER],        0.62);
	shade (&style->bg[GTK_STATE_ACTIVE], &clearlooks_style->border[CL_BORDER_UPPER_ACTIVE], 0.5);
	shade (&style->bg[GTK_STATE_ACTIVE], &clearlooks_style->border[CL_BORDER_LOWER_ACTIVE], 0.55);
}

static GdkGC *
realize_color (GtkStyle * style,
	       GdkColor * color)
{
	GdkGCValues gc_values;

	gdk_colormap_alloc_color (style->colormap, color, FALSE, TRUE);

	gc_values.foreground = *color;

	return gtk_gc_get (style->depth, style->colormap, &gc_values, GDK_GC_FOREGROUND);
}

static void
clearlooks_style_realize (GtkStyle * style)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	int i;

	parent_class->realize (style);

	for (i = 0; i < 8; i++)
		clearlooks_style->shade_gc[i] = realize_color (style, &clearlooks_style->shade[i]);

	for (i=0; i < CL_BORDER_COUNT; i++)
		clearlooks_style->border_gc[i] = realize_color (style, &clearlooks_style->border[i]);

	clearlooks_style->spot1_gc = realize_color (style, &clearlooks_style->spot1);
	clearlooks_style->spot2_gc = realize_color (style, &clearlooks_style->spot2);
	clearlooks_style->spot3_gc = realize_color (style, &clearlooks_style->spot3);

	/* set light inset color */
	for (i=0; i<5; i++)
	{
		shade (&style->bg[i], &clearlooks_style->inset_dark[i], 0.93);
		gdk_rgb_find_color (style->colormap, &clearlooks_style->inset_dark[i]);

		shade (&style->bg[i], &clearlooks_style->inset_light[i], 1.055);
		gdk_rgb_find_color (style->colormap, &clearlooks_style->inset_light[i]);

		shade (&style->bg[i], &clearlooks_style->listview_bg[i], 1.015);
		gdk_rgb_find_color (style->colormap, &clearlooks_style->listview_bg[i]);

		/* CREATE GRADIENT FOR BUTTONS */
		shade (&style->bg[i], &clearlooks_style->button_g1[i], 1.055);
		gdk_rgb_find_color (style->colormap, &clearlooks_style->button_g1[i]);

		shade (&style->bg[i], &clearlooks_style->button_g2[i], 1.005);
		gdk_rgb_find_color (style->colormap, &clearlooks_style->button_g2[i]);

		shade (&style->bg[i], &clearlooks_style->button_g3[i], 0.98);
		gdk_rgb_find_color (style->colormap, &clearlooks_style->button_g3[i]);

		shade (&style->bg[i], &clearlooks_style->button_g4[i], 0.91);
		gdk_rgb_find_color (style->colormap, &clearlooks_style->button_g4[i]);
	}

}

static void
clearlooks_style_unrealize (GtkStyle * style)
{
	ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
	int i;

	/* We don't free the colors, because we don't know if
	* gtk_gc_release() actually freed the GC. FIXME - need
	* a way of ref'ing colors explicitely so GtkGC can
	* handle things properly.
	*/
	for (i=0; i < 8; i++)
		gtk_gc_release (clearlooks_style->shade_gc[i]);

	gtk_gc_release (clearlooks_style->spot1_gc);
	gtk_gc_release (clearlooks_style->spot2_gc);
	gtk_gc_release (clearlooks_style->spot3_gc);

	for (i = 0; i < 5; i++)
	{
		if (clearlooks_style->radio_pixmap_nonactive[i] != NULL)
		{
			g_object_unref (clearlooks_style->radio_pixmap_nonactive[i]);
			clearlooks_style->radio_pixmap_nonactive[i] = NULL;
			g_object_unref (clearlooks_style->radio_pixmap_active[i]);
			clearlooks_style->radio_pixmap_active[i] = NULL;
			g_object_unref (clearlooks_style->radio_pixmap_inconsistent[i]);
			clearlooks_style->radio_pixmap_inconsistent[i] = NULL;
		}

		if (clearlooks_style->check_pixmap_nonactive[i] != NULL)
		{
			g_object_unref (clearlooks_style->check_pixmap_nonactive[i]);
			clearlooks_style->check_pixmap_nonactive[i] = NULL;
			g_object_unref (clearlooks_style->check_pixmap_active[i]);
			clearlooks_style->check_pixmap_active[i] = NULL;
			g_object_unref (clearlooks_style->check_pixmap_inconsistent[i]);
			clearlooks_style->check_pixmap_inconsistent[i] = NULL;
		}
	}

	if (clearlooks_style->radio_pixmap_mask != NULL)
		g_object_unref (clearlooks_style->radio_pixmap_mask);

	clearlooks_style->radio_pixmap_mask = NULL;

	while (progressbars = g_list_first (progressbars))
		cl_progressbar_remove (progressbars->data);

	if (timer_id != 0)
	{
		g_source_remove(timer_id);
		timer_id = 0;
	}

	parent_class->unrealize (style);
}

static GdkPixbuf *
set_transparency (const GdkPixbuf *pixbuf, gdouble alpha_percent)
{
	GdkPixbuf *target;
	guchar *data, *current;
	guint x, y, rowstride, height, width;

	g_return_val_if_fail (pixbuf != NULL, NULL);
	g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);

	/* Returns a copy of pixbuf with it's non-completely-transparent pixels to
	   have an alpha level "alpha_percent" of their original value. */

	target = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);

	if (alpha_percent == 1.0)
		return target;
	width = gdk_pixbuf_get_width (target);
	height = gdk_pixbuf_get_height (target);
	rowstride = gdk_pixbuf_get_rowstride (target);
	data = gdk_pixbuf_get_pixels (target);

	for (y = 0; y < height; y++) {
		for (x = 0; x < width; x++) {
			/* The "4" is the number of chars per pixel, in this case, RGBA,
			   the 3 means "skip to the alpha" */
			current = data + (y * rowstride) + (x * 4) + 3;
			*(current) = (guchar) (*(current) * alpha_percent);
		}
	}

	return target;
}

static GdkPixbuf*
scale_or_ref (GdkPixbuf *src,
              int width,
              int height)
{
	if (width == gdk_pixbuf_get_width (src) &&
	    height == gdk_pixbuf_get_height (src)) {
		return g_object_ref (src);
	} else {
		return gdk_pixbuf_scale_simple (src,
						width, height,
						GDK_INTERP_BILINEAR);
	}
}

static GdkPixbuf *
render_icon (GtkStyle            *style,
	     const GtkIconSource *source,
	     GtkTextDirection     direction,
	     GtkStateType         state,
	     GtkIconSize          size,
	     GtkWidget           *widget,
	     const char          *detail)
{
	int width = 1;
	int height = 1;
	GdkPixbuf *scaled;
	GdkPixbuf *stated;
	GdkPixbuf *base_pixbuf;
	GdkScreen *screen;
	GtkSettings *settings;

	/* Oddly, style can be NULL in this function, because
	 * GtkIconSet can be used without a style and if so
	 * it uses this function.
	 */

	base_pixbuf = gtk_icon_source_get_pixbuf (source);

	g_return_val_if_fail (base_pixbuf != NULL, NULL);

	if (widget && gtk_widget_has_screen (widget)) {
		screen = gtk_widget_get_screen (widget);
		settings = gtk_settings_get_for_screen (screen);
	} else if (style->colormap) {
		screen = gdk_colormap_get_screen (style->colormap);
		settings = gtk_settings_get_for_screen (screen);
	} else {
		settings = gtk_settings_get_default ();
		GTK_NOTE (MULTIHEAD,
			  g_warning ("Using the default screen for gtk_default_render_icon()"));
	}


	if (size != (GtkIconSize) -1 && !gtk_icon_size_lookup_for_settings (settings, size, &width, &height)) {
		g_warning (G_STRLOC ": invalid icon size '%d'", size);
		return NULL;
	}

	/* If the size was wildcarded, and we're allowed to scale, then scale; otherwise,
	 * leave it alone.
	 */
	if (size != (GtkIconSize)-1 && gtk_icon_source_get_size_wildcarded (source))
		scaled = scale_or_ref (base_pixbuf, width, height);
	else
		scaled = g_object_ref (base_pixbuf);

	/* If the state was wildcarded, then generate a state. */
	if (gtk_icon_source_get_state_wildcarded (source)) {
		if (state == GTK_STATE_INSENSITIVE) {
			stated = set_transparency (scaled, 0.3);
#if 0
			stated =
				gdk_pixbuf_composite_color_simple (scaled,
								   gdk_pixbuf_get_width (scaled),
								   gdk_pixbuf_get_height (scaled),
								   GDK_INTERP_BILINEAR, 128,
								   gdk_pixbuf_get_width (scaled),
								   style->bg[state].pixel,
								   style->bg[state].pixel);
#endif
			gdk_pixbuf_saturate_and_pixelate (stated, stated,
							  0.1, FALSE);

			g_object_unref (scaled);
		} else if (state == GTK_STATE_PRELIGHT) {
			stated = gdk_pixbuf_copy (scaled);

			gdk_pixbuf_saturate_and_pixelate (scaled, stated,
							  1.2, FALSE);

			g_object_unref (scaled);
		} else {
			stated = scaled;
		}
	}
	else
		stated = scaled;

  return stated;
}

static void
clearlooks_style_init (ClearlooksStyle * style)
{
}

static void
clearlooks_style_class_init (ClearlooksStyleClass * klass)
{
	GtkStyleClass *style_class = GTK_STYLE_CLASS (klass);

	parent_class = g_type_class_peek_parent (klass);

	style_class->realize = clearlooks_style_realize;
	style_class->unrealize = clearlooks_style_unrealize;
	style_class->init_from_rc = clearlooks_style_init_from_rc;
	style_class->draw_focus = draw_focus;
	style_class->draw_resize_grip = draw_resize_grip;
	style_class->draw_handle = draw_handle;
	style_class->draw_vline = draw_vline;
	style_class->draw_hline = draw_hline;
	style_class->draw_slider = draw_slider;
	style_class->draw_shadow_gap = draw_shadow_gap;
	style_class->draw_arrow = clearlooks_draw_arrow;
	style_class->draw_check = draw_check;
	style_class->draw_tab = draw_tab;
	style_class->draw_box = draw_box;
	style_class->draw_shadow = draw_shadow;
	style_class->draw_box_gap = draw_box_gap;
	style_class->draw_extension = draw_extension;
	style_class->draw_option = draw_option;
	style_class->draw_layout = draw_layout;
	style_class->render_icon = render_icon;
	style_class->draw_flat_box = draw_flat_box;
}

GType clearlooks_type_style = 0;

void
clearlooks_style_register_type (GTypeModule * module)
{
	static const GTypeInfo object_info =
	{
		sizeof (ClearlooksStyleClass),
		(GBaseInitFunc) NULL,
		(GBaseFinalizeFunc) NULL,
		(GClassInitFunc) clearlooks_style_class_init,
		NULL,         /* class_finalize */
		NULL,         /* class_data */
		sizeof (ClearlooksStyle),
		0,            /* n_preallocs */
		(GInstanceInitFunc) clearlooks_style_init,
		NULL
	};

	clearlooks_type_style = g_type_module_register_type (module,
	                                                     GTK_TYPE_STYLE,
	                                                     "ClearlooksStyle",
	                                                     &object_info, 0);
}