From bc89fe0147c04b67141936d109c00dfd4d69cc4b Mon Sep 17 00:00:00 2001 From: Paul Davis Date: Fri, 12 Dec 2008 14:43:24 +0000 Subject: most of the 2.X->3.0 commit (up to rev 4299) except for gtk2_ardour/editor_canvas.cc; builds and runs and does a few specific things but expect it to be buggy for a while yet git-svn-id: svn://localhost/ardour2/branches/3.0@4313 d708f5d6-7413-0410-9779-e7cbd77b26cf --- libs/clearlooks-older/clearlooks_style.c | 2661 ++++++++++++++++++++++++++++++ 1 file changed, 2661 insertions(+) create mode 100644 libs/clearlooks-older/clearlooks_style.c (limited to 'libs/clearlooks-older/clearlooks_style.c') diff --git a/libs/clearlooks-older/clearlooks_style.c b/libs/clearlooks-older/clearlooks_style.c new file mode 100644 index 0000000000..074f1604b1 --- /dev/null +++ b/libs/clearlooks-older/clearlooks_style.c @@ -0,0 +1,2661 @@ +#include + +#include "clearlooks_style.h" +#include "clearlooks_rc_style.h" +#include "clearlooks_draw.h" + +#include +#include + +#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); +} -- cgit v1.2.3