2658 lines
77 KiB
C
2658 lines
77 KiB
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;
|
|
|
|
gdk_gc_set_clip_mask (gc, clearlooks_style->radio_pixmap_mask);
|
|
gdk_gc_set_clip_origin (gc, x, y);
|
|
|
|
gdk_draw_drawable (window, gc, pixmap, 0, 0, x, y,
|
|
RADIO_SIZE, RADIO_SIZE);
|
|
|
|
gdk_gc_set_clip_origin (gc, 0, 0);
|
|
gdk_gc_set_clip_mask (gc, NULL);
|
|
|
|
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);
|
|
}
|