Logo Search packages:      
Sourcecode: ardour version File versions  Download package

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

Generated by  Doxygen 1.6.0   Back to index