static void
clearlooks_glossy_draw_menubaritem (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *params,
int x, int y, int width, int height)
{
const CairoColor *fill = &colors->spot[1];
const CairoColor *border = &colors->spot[2];
CairoColor shade1, shade2, shade3;
cairo_pattern_t *pattern;
ge_shade_color (fill, 1.16, &shade1);
ge_shade_color (fill, 1.08, &shade2);
ge_shade_color (fill, 1.08, &shade3);
cairo_set_line_width (cr, 1.0);
ge_cairo_rounded_rectangle (cr, x+0.5, y+0.5, width - 1, height - 1, params->radius, params->corners);
pattern = cairo_pattern_create_linear (x, y, x, y + height);
cairo_pattern_add_color_stop_rgb (pattern, 0, shade1.r, shade1.g, shade1.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade2.r, shade2.g, shade2.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.5, fill->r, fill->g, fill->b);
cairo_pattern_add_color_stop_rgb (pattern, 1, shade3.r, shade3.g, shade3.b);
cairo_set_source (cr, pattern);
cairo_fill_preserve (cr);
cairo_pattern_destroy (pattern);
ge_cairo_set_color (cr, border);
cairo_stroke (cr);
}
void
do_glide_draw_simple_circle (cairo_t *canvas,
CairoColor * tl,
CairoColor * br,
gint center_x,
gint center_y,
gint radius)
{
cairo_new_path (canvas);
cairo_move_to(canvas, center_x + (radius + 2), center_y + (radius + 2));
cairo_line_to(canvas, center_x + (radius + 2)*sin(G_PI/4.0), center_y - (radius + 2)*cos(G_PI/4.0));
cairo_line_to(canvas, center_x - (radius + 2)*sin(G_PI/4.0), center_y + (radius + 2)*cos(G_PI/4.0));
cairo_line_to(canvas, center_x + (radius + 2), center_y + (radius + 2));
cairo_close_path (canvas);
cairo_save(canvas);
cairo_clip (canvas);
ge_cairo_set_color(canvas, br);
cairo_arc(canvas, center_x, center_y, radius, 0, 2*G_PI);
cairo_fill(canvas);
cairo_restore(canvas);
cairo_save(canvas);
cairo_new_path (canvas);
cairo_move_to(canvas, center_x - (radius + 2), center_y - (radius + 2));
cairo_line_to(canvas, center_x + (radius + 2)*sin(G_PI/4.0), center_y - (radius + 2)*cos(G_PI/4.0));
cairo_line_to(canvas, center_x - (radius + 2)*sin(G_PI/4.0), center_y + (radius + 2)*cos(G_PI/4.0));
cairo_line_to(canvas, center_x - (radius + 2), center_y - (radius + 2));
cairo_close_path (canvas);
cairo_clip (canvas);
ge_cairo_set_color(canvas, tl);
cairo_arc(canvas, center_x, center_y, radius, 0, 2*G_PI);
cairo_fill(canvas);
cairo_restore(canvas);
}
void
do_hc_draw_dot (cairo_t *canvas,
CairoColor * light,
CairoColor * dark,
gint x,
gint y)
{
ge_cairo_set_color (canvas, dark);
cairo_rectangle (canvas, x - 1, y - 1, 1, 1);
cairo_rectangle (canvas, x - 1, y, 1, 1);
cairo_rectangle (canvas, x, y - 1, 1, 1);
cairo_fill (canvas);
ge_cairo_set_color (canvas, light);
cairo_rectangle (canvas, x + 1, y + 1, 1, 1);
cairo_rectangle (canvas, x + 1, y, 1, 1);
cairo_rectangle (canvas, x, y + 1, 1, 1);
cairo_fill (canvas);
}
static void
thinice_style_draw_check(GtkStyle * style,
cairo_t * cr,
GtkStateType state_type,
GtkShadowType shadow_type,
GtkWidget * widget,
const gchar *detail,
gint x,
gint y,
gint width,
gint height)
{
ThiniceStyle *thinice_style = THINICE_STYLE (style);
CairoColor *color1 = NULL;
CHECK_ARGS
if (shadow_type == GTK_SHADOW_IN)
{
color1 = &thinice_style->color_cube.bg[GTK_STATE_ACTIVE];
}
if (state_type == GTK_STATE_INSENSITIVE)
{
ge_cairo_set_color(cr, &thinice_style->color_cube.dark[state_type]);
ge_cairo_stroke_rectangle(cr, x + 0.5, y + 0.5, width - 1, height - 1);
}
else
{
thinice_style_draw_box(style, cr, state_type, shadow_type, widget,
detail, x, y, width, height);
if (color1)
{
ge_cairo_set_color(cr, color1);
cairo_rectangle(cr, x+1, y+1, width-2, height-2);
cairo_fill(cr);
}
}
}
/* Border Function For Frame && Notebook,
With Gap For Text and/or Tabs
*/
void
hc_draw_shadow_gap (GtkStyle *style,
cairo_t *cr,
GtkStateType state_type,
GtkShadowType shadow_type,
GtkWidget *widget,
const gchar *detail,
gint x,
gint y,
gint width,
gint height,
GtkPositionType gap_side,
gint gap_pos,
gint gap_size)
{
/* Border Uses Foreground Color */
CairoColor *foreground = &HC_STYLE(style)->color_cube.fg[state_type];
gint line_width;
/***********************************************/
/* GTK Sanity Checks */
/***********************************************/
CHECK_ARGS
if (shadow_type == GTK_SHADOW_NONE)
return;
/***********************************************/
/* GTK Special Cases - adjust Size/Offset */
/***********************************************/
line_width = HC_STYLE(style)->edge_thickness;
if (CHECK_DETAIL (detail, "notebook"))
{
gap_pos += line_width;
gap_size -= 2*line_width;
}
/***********************************************/
/* Draw Border */
/***********************************************/
/* Create And Clip Too Path To Ignore Gap */
hc_simple_border_gap_clip(cr, line_width, x, y, width, height, gap_side, gap_pos, gap_size);
/* Set Line Style */
ge_cairo_set_color(cr, foreground);
cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT);
cairo_set_line_width (cr, line_width);
ge_cairo_inner_rectangle (cr, x, y, width, height);
cairo_stroke(cr);
}
static void
clearlooks_set_mixed_color (cairo_t *cr,
const CairoColor *color1,
const CairoColor *color2,
gdouble mix_factor)
{
CairoColor composite;
ge_mix_color (color1, color2, mix_factor, &composite);
ge_cairo_set_color (cr, &composite);
}
static void
clearlooks_glossy_draw_progressbar_trough (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *params,
int x, int y, int width, int height)
{
const CairoColor *border = &colors->shade[6];
CairoColor shadow;
cairo_pattern_t *pattern;
double radius = MIN (params->radius, MIN ((height-2.0) / 2.0, (width-2.0) / 2.0));
cairo_save (cr);
cairo_set_line_width (cr, 1.0);
/* Create trough box */
ge_cairo_rounded_rectangle (cr, x+1, y+1, width-2, height-2, radius, params->corners);
ge_cairo_set_color (cr, &colors->shade[2]);
cairo_fill (cr);
/* Draw border */
ge_cairo_rounded_rectangle (cr, x+0.5, y+0.5, width-1, height-1, radius, params->corners);
clearlooks_set_mixed_color (cr, border, &colors->shade[2], 0.3);
cairo_stroke (cr);
/* clip the corners of the shadows */
ge_cairo_rounded_rectangle (cr, x+1, y+1, width-2, height-2, radius, params->corners);
cairo_clip (cr);
ge_shade_color (border, 0.92, &shadow);
/* Top shadow */
cairo_rectangle (cr, x+1, y+1, width-2, 4);
pattern = cairo_pattern_create_linear (x, y, x, y+4);
cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.3);
cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
/* Left shadow */
cairo_rectangle (cr, x+1, y+1, 4, height-2);
pattern = cairo_pattern_create_linear (x, y, x+4, y);
cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.3);
cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
cairo_restore (cr);
}
/***********************************************
* do_glide_draw_line -
*
* A simple routine to draw a redmond style
* spacer line.
***********************************************/
void
do_glide_draw_line(cairo_t *canvas,
CairoColor * dark,
CairoColor * light,
gint start,
gint end,
gint base,
gboolean horizontal)
{
cairo_set_line_width (canvas, 1);
if (horizontal)
{
ge_cairo_set_color(canvas, dark);
cairo_move_to(canvas, start + 1.5, base + 0.5);
cairo_line_to(canvas, end - 1.5, base + 0.5);
cairo_stroke(canvas);
ge_cairo_set_color(canvas, light);
cairo_move_to(canvas, start + 1.5, base + 1.5);
cairo_line_to(canvas, end - 1.5, base + 1.5);
cairo_stroke(canvas);
}
else
{
ge_cairo_set_color(canvas, dark);
cairo_move_to(canvas, base + 0.5, start + 1.5);
cairo_line_to(canvas, base + 0.5, end - 1.5);
cairo_stroke(canvas);
ge_cairo_set_color(canvas, light);
cairo_move_to(canvas, base + 1.5, start + 1.5);
cairo_line_to(canvas, base + 1.5, end - 1.5);
cairo_stroke(canvas);
}
}
static void
clearlooks_inverted_draw_selected_cell (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *params,
int x, int y, int width, int height)
{
CairoColor upper_color;
CairoColor lower_color;
CairoColor border;
cairo_pattern_t *pattern;
cairo_save (cr);
cairo_translate (cr, x, y);
if (params->focus)
upper_color = colors->base[params->state_type];
else
upper_color = colors->base[GTK_STATE_ACTIVE];
ge_shade_color(&upper_color, 0.9, &lower_color);
pattern = cairo_pattern_create_linear (0, 0, 0, height);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, lower_color.r,
lower_color.g,
lower_color.b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, upper_color.r,
upper_color.g,
upper_color.b);
cairo_set_source (cr, pattern);
cairo_rectangle (cr, 0, 0, width, height);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
ge_shade_color(&upper_color, 0.8, &border);
cairo_move_to (cr, 0, 0.5);
cairo_rel_line_to (cr, width, 0);
cairo_move_to (cr, 0, height-0.5);
cairo_rel_line_to (cr, width, 0);
ge_cairo_set_color (cr, &border);
cairo_stroke (cr);
cairo_restore (cr);
}
static void
clearlooks_glossy_draw_slider (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *params,
int x, int y, int width, int height)
{
const CairoColor *border = &colors->shade[7];
CairoColor fill;
CairoColor hilight;
CairoColor a, b, c, d;
cairo_pattern_t *pattern;
cairo_set_line_width (cr, 1.0);
cairo_translate (cr, x, y);
cairo_translate (cr, -0.5, -0.5);
ge_shade_color (&colors->bg[params->state_type], 1.0, &fill);
if (params->prelight)
ge_shade_color (&fill, 1.1, &fill);
ge_shade_color (&fill, 1.25, &hilight);
ge_shade_color (&fill, 1.16, &a);
ge_shade_color (&fill, 1.08, &b);
ge_shade_color (&fill, 1.0, &c);
ge_shade_color (&fill, 1.08, &d);
pattern = cairo_pattern_create_linear (1, 1, 1, height-2);
cairo_pattern_add_color_stop_rgb (pattern, 0, a.r, a.g, a.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.5, b.r, b.g, b.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.5, c.r, c.g, c.b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, d.r, d.g, d.b);
cairo_rectangle (cr, 1, 1, width-2, height-2);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
clearlooks_set_mixed_color (cr, border, &fill, 0.2);
if (params->prelight)
ge_cairo_set_color (cr, &colors->spot[2]);
ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, 2.5, params->corners);
cairo_stroke (cr);
cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.5);
ge_cairo_rounded_rectangle (cr, 1.5, 1.5, width-3, height-3, 2.0, params->corners);
cairo_stroke (cr);
}
/*#warning - do_glide_draw_option_check needs smarter sizing - perhaps draw check at base size, and scale/translate? */
static void
do_glide_draw_option_check(cairo_t *canvas,
CairoColor *check_color,
GlideCheckState check_state,
gint center_x,
gint center_y,
gint radius)
{
cairo_save(canvas);
ge_cairo_set_color(canvas, check_color);
switch (check_state)
{
case GLIDE_CHECK_ON:
{
cairo_arc(canvas, center_x, center_y, radius*0.68, 0, 2 * G_PI);
cairo_fill(canvas);
}
break;
case GLIDE_CHECK_INCONSISTENT:
{
gdouble line_width = radius;
cairo_set_line_cap(canvas, CAIRO_LINE_CAP_ROUND);
cairo_set_line_width (canvas, line_width);
cairo_move_to(canvas, center_x - radius + line_width/2, center_y);
cairo_line_to(canvas, center_x + radius - line_width/2, center_y);
cairo_stroke (canvas);
}
break;
case GLIDE_CHECK_OFF:
default:
{
}
break;
}
cairo_restore(canvas);
}
void ge_cairo_line (cairo_t *cr,
const CairoColor *color,
gint x1,
gint y1,
gint x2,
gint y2)
{
cairo_save(cr);
ge_cairo_set_color(cr, color);
cairo_set_line_width (cr, 1);
cairo_move_to(cr, x1 + 0.5, y1 + 0.5);
cairo_line_to(cr, x2 + 0.5, y2 + 0.5);
cairo_stroke(cr);
cairo_restore(cr);
}
void do_hc_draw_line (cairo_t *cr,
CairoColor *color,
gdouble thickness,
gdouble x1,
gdouble y1,
gdouble x2,
gdouble y2)
{
cairo_save(cr);
ge_cairo_set_color(cr, color);
cairo_set_line_width (cr, thickness);
cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT);
cairo_move_to(cr, x1, y1);
cairo_line_to(cr, x2, y2);
cairo_stroke(cr);
cairo_restore(cr);
}
/* Thanks to Evan Lawrence */
static void
thinice_style_draw_option(GtkStyle * style,
cairo_t * cr,
GtkStateType state_type,
GtkShadowType shadow_type,
GtkWidget * widget,
const gchar *detail,
gint x,
gint y,
gint width,
gint height)
{
ThiniceStyle *thinice_style = THINICE_STYLE (style);
CairoColor *color1 = NULL, *color2 = NULL, *color3 = NULL;
gint centerX;
gint centerY;
gint radius;
CHECK_ARGS
if (shadow_type == GTK_SHADOW_IN ||
shadow_type == GTK_SHADOW_ETCHED_IN)
{
color1 = &thinice_style->color_cube.dark[state_type];
color2 = &thinice_style->color_cube.light[state_type];
color3 = &thinice_style->color_cube.bg[GTK_STATE_ACTIVE];
}
else
{
color1 = &thinice_style->color_cube.light[state_type];
color2 = &thinice_style->color_cube.dark[state_type];
color3 = &thinice_style->color_cube.bg[state_type];
}
cairo_set_line_width (cr, 0.5);
centerX = x + floor(width/2);
centerY = y + floor(height/2);
radius = floor(MIN(width, height)/2) - 0.5;
switch (shadow_type)
{
case GTK_SHADOW_ETCHED_IN:
ge_cairo_set_color(cr, color2);
cairo_arc(cr, centerX + 1, centerY + 1, radius + 1, 0, 2 * G_PI);
cairo_stroke(cr);
ge_cairo_set_color(cr, color1);
cairo_arc(cr, centerX, centerY, radius + 1, 0, 2 * G_PI);
cairo_stroke(cr);
break;
case GTK_SHADOW_ETCHED_OUT:
ge_cairo_set_color(cr, color1);
cairo_arc(cr, centerX - 1, centerY - 1, radius + 1, 0, 2 * G_PI);
cairo_stroke(cr);
ge_cairo_set_color(cr, color2);
cairo_arc(cr, centerX, centerY, radius + 1, 0, 2 * G_PI);
cairo_stroke(cr);
break;
default:
cairo_set_line_width (cr, 0.5);
cairo_new_path (cr);
cairo_move_to(cr, centerX + (radius + 2), centerY + (radius + 2));
cairo_line_to(cr, centerX + (radius + 2)*sin(G_PI/4.0), centerY - (radius + 2)*cos(G_PI/4.0));
cairo_line_to(cr, centerX - (radius + 2)*sin(G_PI/4.0), centerY + (radius + 2)*cos(G_PI/4.0));
cairo_line_to(cr, centerX + (radius + 2), centerY + (radius + 2));
cairo_close_path (cr);
cairo_save(cr);
cairo_clip (cr);
ge_cairo_set_color(cr, color2);
cairo_arc(cr, centerX, centerY, radius + 1, 0, 2*G_PI);
cairo_fill(cr);
cairo_restore(cr);
cairo_new_path (cr);
cairo_move_to(cr, centerX - (radius + 2), centerY - (radius + 2));
cairo_line_to(cr, centerX + (radius + 2)*sin(G_PI/4.0), centerY - (radius + 2)*cos(G_PI/4.0));
cairo_line_to(cr, centerX - (radius + 2)*sin(G_PI/4.0), centerY + (radius + 2)*cos(G_PI/4.0));
cairo_line_to(cr, centerX - (radius + 2), centerY - (radius + 2));
cairo_close_path (cr);
cairo_save(cr);
cairo_clip (cr);
ge_cairo_set_color(cr, color1);
cairo_arc(cr, centerX, centerY, radius + 1, 0, 2*G_PI);
cairo_fill(cr);
cairo_restore(cr);
ge_cairo_set_color(cr, color3);
cairo_arc(cr, centerX, centerY, radius, 0, 2 * G_PI);
cairo_fill(cr);
break;
}
}
static void
thinice_style_draw_box(GtkStyle * style,
cairo_t *cr,
GtkStateType state_type,
GtkShadowType shadow_type,
GtkWidget * widget,
const gchar *detail,
gint x,
gint y,
gint width,
gint height)
{
ThiniceStyle *thinice_style = THINICE_STYLE (style);
gboolean draw_border = TRUE;
/***********************************************/
/* GTK Sanity Checks */
/***********************************************/
CHECK_ARGS
/***********************************************/
/* GTK Special Cases - Ignored Widgets */
/***********************************************/
if ((CHECK_DETAIL(detail, "optionmenutab")) ||
(CHECK_DETAIL (detail, "slider")) ||
(CHECK_DETAIL (detail, "buttondefault")) ||
(CHECK_DETAIL (detail, "bar") &&
((height < 1) && (width < 1))))
{
return;
}
/***********************************************/
/* GTK Special Cases - adjust Size/Offset */
/***********************************************/
if ((CHECK_DETAIL (detail, "bar")))
{
x += 1;
y += 1;
width -= 2;
height -= 2;
draw_border=FALSE;
}
else if (CHECK_DETAIL (detail, "handlebox_bin"))
{
draw_border=FALSE;
}
else if (CHECK_DETAIL (detail, "entry-progress"))
{
draw_border=FALSE;
}
/***********************************************/
/* Fill Box */
/***********************************************/
gtk_style_apply_default_background(style, cr,
gtk_widget_get_window (widget),
state_type,
x, y, width, height);
/***********************************************/
/* Draw Box Border */
/***********************************************/
if (draw_border)
{
thinice_style_draw_shadow(style, cr, state_type, shadow_type, widget,
detail, x, y, width, height);
}
/***********************************************/
/* Draw Widget Specific Sub-Parts */
/***********************************************/
if (CHECK_DETAIL (detail, "button"))
{
/* Paint a triangle here instead of in "buttondefault"
which is drawn _behind_ the current button */
if (widget && GE_WIDGET_HAS_DEFAULT (widget))
{
ge_cairo_set_color(cr, &thinice_style->color_cube.bg[GTK_STATE_SELECTED]);
cairo_move_to(cr, x+2.5, y+2.5);
cairo_line_to(cr, x+10.5, y+2.5);
cairo_line_to(cr, x+2.5, y+10.5);
cairo_line_to(cr, x+2.5, y+2.5);
cairo_fill(cr);
ge_cairo_set_color(cr, &thinice_style->color_cube.dark[state_type]);
cairo_move_to(cr, x + 2.5, y + 11);
cairo_line_to(cr, x + 2.5, y + 2.5);
cairo_line_to(cr, x + 11, y + 2.5);
cairo_stroke(cr);
cairo_set_line_width (cr, 0.5);
ge_cairo_set_color(cr, &thinice_style->color_cube.light[state_type]);
cairo_move_to(cr, x+11, y+3);
cairo_line_to(cr, x+3, y+11);
cairo_stroke(cr);
}
}
/* Draw Option Menus and Combo Box "Tab" The Same Way Here */
if (CHECK_DETAIL(detail, "optionmenu") || (CHECK_DETAIL(detail, "button") &&
(ge_is_combo_box(widget, FALSE)) && !(ge_is_combo_box_entry(widget))))
{
GtkRequisition indicator_size;
GtkBorder indicator_spacing;
CairoColor *dark;
CairoColor *light;
gint vline_x;
if (state_type != GTK_STATE_INSENSITIVE)
state_type = GTK_STATE_NORMAL;
ge_option_menu_get_props (widget, &indicator_size, &indicator_spacing);
if ((!widget) || (gtk_widget_get_direction (widget) == GTK_TEXT_DIR_RTL))
vline_x = x + indicator_size.width + indicator_spacing.left + indicator_spacing.right;
else
vline_x = x + width - (indicator_size.width + indicator_spacing.left +
indicator_spacing.right) - style->xthickness;
dark = &thinice_style->color_cube.dark[state_type];
light = &thinice_style->color_cube.light[state_type];
thinice_draw_separator(cr, dark, light, FALSE,
vline_x, y + style->ythickness + 1,
style->xthickness, height - 2*style->ythickness - 2);
if ((widget) && (gtk_widget_get_direction (GTK_WIDGET (widget)) == GTK_TEXT_DIR_RTL))
x += indicator_spacing.right + style->xthickness;
else
x += width - indicator_size.width - indicator_spacing.right - style->xthickness;
y += ((height - indicator_size.height) / 2) + 1;
width = indicator_size.width;
height = indicator_size.height;
thinice_style_draw_arrow (style, cr, state_type, shadow_type, NULL, "optionmenu",
GTK_ARROW_DOWN, TRUE, x, y, width, height);
}
}
static void
clearlooks_style_draw_shadow (DRAW_ARGS)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
ClearlooksColors *colors = &clearlooks_style->colors;
cairo_t *cr = ge_gdk_drawable_to_cairo (window, area);
CHECK_ARGS
SANITIZE_SIZE
if ((DETAIL ("entry") && !(widget && widget->parent && GE_IS_TREE_VIEW (widget->parent))) ||
(DETAIL ("frame") && ge_is_in_combo_box (widget)))
{
WidgetParameters params;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
/* Override the entries state type, because we are too lame to handle this via
* the focus ring, and GtkEntry doesn't even set the INSENSITIVE state ... */
if (state_type == GTK_STATE_NORMAL && widget && GE_IS_ENTRY (widget))
params.state_type = GTK_WIDGET_STATE (widget);
if (widget && (ge_is_in_combo_box (widget) || GE_IS_SPIN_BUTTON (widget)))
{
width += style->xthickness;
if (!params.ltr)
x -= style->xthickness;
if (params.ltr)
params.corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
else
params.corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
}
STYLE_FUNCTION (draw_entry) (cr, &clearlooks_style->colors, ¶ms,
x, y, width, height);
}
else if (DETAIL ("frame") && widget && GE_IS_STATUSBAR (widget->parent))
{
WidgetParameters params;
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
gtk_style_apply_default_background (style, window, TRUE, state_type,
area, x, y, width, height);
STYLE_FUNCTION (draw_statusbar) (cr, colors, ¶ms,
x, y, width, height);
}
else if (DETAIL ("frame"))
{
WidgetParameters params;
FrameParameters frame;
frame.shadow = shadow_type;
frame.gap_x = -1; /* No gap will be drawn */
frame.border = &colors->shade[4];
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
params.corners = CR_CORNER_NONE;
if (widget && !g_str_equal ("XfcePanelWindow", gtk_widget_get_name (gtk_widget_get_toplevel (widget))))
STYLE_FUNCTION(draw_frame) (cr, colors, ¶ms, &frame,
x, y, width, height);
}
else if (DETAIL ("scrolled_window") || DETAIL ("viewport") || detail == NULL)
{
CairoColor *border = (CairoColor*)&colors->shade[5];
cairo_rectangle (cr, x+0.5, y+0.5, width-1, height-1);
ge_cairo_set_color (cr, border);
cairo_set_line_width (cr, 1);
cairo_stroke (cr);
}
else
{
WidgetParameters params;
FrameParameters frame;
frame.shadow = shadow_type;
frame.gap_x = -1;
frame.border = &colors->shade[5];
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
params.corners = CR_CORNER_ALL;
STYLE_FUNCTION(draw_frame) (cr, colors, ¶ms, &frame, x, y, width, height);
}
cairo_destroy (cr);
}
static void
clearlooks_style_draw_box_gap (DRAW_ARGS,
GtkPositionType gap_side,
gint gap_x,
gint gap_width)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
ClearlooksColors *colors = &clearlooks_style->colors;
cairo_t *cr;
CHECK_ARGS
SANITIZE_SIZE
cr = ge_gdk_drawable_to_cairo (window, area);
if (DETAIL ("notebook"))
{
WidgetParameters params;
FrameParameters frame;
gboolean start, end;
frame.shadow = shadow_type;
frame.gap_side = gap_side;
frame.gap_x = gap_x;
frame.gap_width = gap_width;
frame.border = &colors->shade[5];
clearlooks_set_widget_parameters (widget, style, state_type, ¶ms);
clearlooks_get_notebook_tab_position (widget, &start, &end);
params.corners = CR_CORNER_ALL;
switch (gap_side) {
case GTK_POS_LEFT:
if (start)
params.corners ^= CR_CORNER_TOPLEFT;
if (end)
params.corners ^= CR_CORNER_BOTTOMLEFT;
break;
case GTK_POS_RIGHT:
if (start)
params.corners ^= CR_CORNER_TOPRIGHT;
if (end)
params.corners ^= CR_CORNER_BOTTOMRIGHT;
break;
case GTK_POS_TOP:
if (ge_widget_is_ltr (widget)) {
if (start)
params.corners ^= CR_CORNER_TOPLEFT;
if (end)
params.corners ^= CR_CORNER_TOPRIGHT;
} else {
if (start)
params.corners ^= CR_CORNER_TOPRIGHT;
if (end)
params.corners ^= CR_CORNER_TOPLEFT;
}
break;
case GTK_POS_BOTTOM:
if (ge_widget_is_ltr (widget)) {
if (start)
params.corners ^= CR_CORNER_BOTTOMLEFT;
if (end)
params.corners ^= CR_CORNER_BOTTOMRIGHT;
} else {
if (start)
params.corners ^= CR_CORNER_BOTTOMRIGHT;
if (end)
params.corners ^= CR_CORNER_BOTTOMLEFT;
}
break;
}
/* Fill the background with bg[NORMAL] */
ge_cairo_rounded_rectangle (cr, x, y, width, height, params.radius, params.corners);
ge_cairo_set_color (cr, &colors->bg[GTK_STATE_NORMAL]);
cairo_fill (cr);
STYLE_FUNCTION(draw_frame) (cr, colors, ¶ms, &frame,
x, y, width, height);
}
else
{
clearlooks_parent_class->draw_box_gap (style, window, state_type, shadow_type,
area, widget, detail,
x, y, width, height,
gap_side, gap_x, gap_width);
}
cairo_destroy (cr);
}
static void
clearlooks_glossy_draw_button (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *params,
int x, int y, int width, int height)
{
double xoffset = 0, yoffset = 0;
CairoColor fill = colors->bg[params->state_type];
CairoColor border_normal = colors->shade[6];
CairoColor border_disabled = colors->shade[4];
double radius;
cairo_pattern_t *pattern;
cairo_save (cr);
cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1.0);
/* Shadows and shadow */
if (params->xthickness == 3 || params->ythickness == 3)
{
if (params->xthickness == 3)
xoffset = 1;
if (params->ythickness == 3)
yoffset = 1;
}
radius = MIN (params->radius, MIN ((width - 2.0 - 2*xoffset) / 2.0, (height - 2.0 - 2*yoffset) / 2.0));
if (params->xthickness == 3 || params->ythickness == 3)
{
/* if (params->enable_shadow && !params->active && !params->disabled) */
if (!params->active && (params->prelight || params->enable_shadow))
{
/* shadow becomes a shadow to have 3d prelight buttons :) */
CairoColor shadow;
radius = MIN (params->radius, MIN ((width - 2.0 - 2*xoffset) / 2.0 - 1.0, (height - 2.0 - 2*yoffset) / 2.0 - 1.0));
ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius+1, params->corners);
ge_shade_color (¶ms->parentbg, 0.96, &shadow);
ge_cairo_set_color (cr, &shadow);
cairo_stroke (cr);
ge_cairo_rounded_rectangle (cr, 1.5, 1.5, width-2, height-2, radius+1, params->corners);
ge_shade_color (¶ms->parentbg, 0.92, &shadow);
ge_cairo_set_color (cr, &shadow);
cairo_stroke (cr);
}
else
{
if (!(params->disabled))
params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width, height, params->radius+1, params->corners);
else
/*Draw a lighter inset */
clearlooks_glossy_draw_light_inset (cr, ¶ms->parentbg, 0, 0, width, height, params->radius+1, params->corners);
}
}
clearlooks_draw_glossy_gradient (cr, xoffset+1, yoffset+1,
width-(xoffset*2)-2, height-(yoffset*2)-2,
&fill, params->disabled, radius, params->corners);
/* Pressed button shadow */
if (params->active)
{
CairoColor shadow;
ge_shade_color (&fill, 0.92, &shadow);
cairo_save (cr);
ge_cairo_rounded_rectangle (cr, xoffset+1, yoffset+1, width-(xoffset*2)-2, height, radius, params->corners & (CR_CORNER_TOPLEFT | CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMLEFT));
cairo_clip (cr);
cairo_rectangle (cr, xoffset+1, yoffset+1, width-(xoffset*2)-2, 3);
pattern = cairo_pattern_create_linear (xoffset+1, yoffset+1, xoffset+1, yoffset+4);
cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.58);
cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.0);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
cairo_rectangle (cr, xoffset+1, yoffset+1, 3, height-(yoffset*2)-2);
pattern = cairo_pattern_create_linear (xoffset+1, yoffset+1, xoffset+4, yoffset+1);
cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.58);
cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.0);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
cairo_restore (cr);
}
/* Default button highlight */
if (params->is_default && !params->active && !params->disabled)
{
const CairoColor *shadow = &colors->spot[0];
double hh = (height-5)/2.0 + 1;
cairo_rectangle (cr, 3.5, 3.5, width-7, height-7);
ge_cairo_set_color (cr, shadow);
cairo_stroke (cr);
shadow = &colors->spot[0];
cairo_move_to (cr, 2.5, 2.5+hh); cairo_rel_line_to (cr, 0, -hh);
cairo_rel_line_to (cr, width-5, 0); cairo_rel_line_to (cr, 0, hh);
ge_cairo_set_color (cr, shadow);
cairo_stroke (cr);
hh--;
shadow = &colors->spot[1];
cairo_move_to (cr, 2.5, 2.5+hh); cairo_rel_line_to (cr, 0, hh);
cairo_rel_line_to (cr, width-5, 0); cairo_rel_line_to (cr, 0, -hh);
ge_cairo_set_color (cr, shadow);
cairo_stroke (cr);
}
/* Border */
if (params->is_default || (params->prelight && params->enable_shadow))
border_normal = colors->spot[2];
/* ge_mix_color (&border_normal, &colors->spot[2], 0.5, &border_normal); */
if (params->disabled)
ge_cairo_set_color (cr, &border_disabled);
else
clearlooks_set_mixed_color (cr, &border_normal, &fill, 0.2);
ge_cairo_rounded_rectangle (cr, xoffset + 0.5, yoffset + 0.5,
width-(xoffset*2)-1, height-(yoffset*2)-1,
radius, params->corners);
cairo_stroke (cr);
cairo_restore (cr);
}
/* Border Function For Notebooks Tabs */
void
hc_draw_extension (GtkStyle *style,
cairo_t *cr,
GtkStateType state_type,
GtkShadowType shadow_type,
GtkWidget *widget,
const gchar *detail,
gint x,
gint y,
gint width,
gint height,
GtkPositionType gap_side)
{
/* Fill Uses Background Color */
CairoColor *background = &HC_STYLE(style)->color_cube.bg[state_type];
/* Border Uses Foreground Color */
CairoColor *foreground = &HC_STYLE(style)->color_cube.fg[state_type];
gint line_width;
gint widget_x = 0, widget_y = 0, widget_width = 0, widget_height = 0;
gint clip_x = x, clip_y = y, clip_width = width, clip_height = height;
/***********************************************/
/* GTK Sanity Checks */
/***********************************************/
CHECK_ARGS
/***********************************************/
/* GTK Special Cases - adjust Size/Offset */
/***********************************************/
line_width = HC_STYLE(style)->edge_thickness;
/* What all this is for -
GTK doesn't overlap Extensions and Notebooks,
but rather a tab is drawn with a "gap" side.
Instead of long draw cases per gap side,
perform a standard draw, but clipped to size,
and overdraw edge thickness + one on gap side.
To fake the apearance of overlap on edge aligned tabs
increase clip by edge thickness on gap side.
*/
if (widget && (GE_IS_NOTEBOOK (widget)))
{
GtkAllocation allocation;
gtk_widget_get_allocation (widget, &allocation);
widget_x = (allocation.x + gtk_container_get_border_width (GTK_CONTAINER (widget)));
widget_y = (allocation.y + gtk_container_get_border_width (GTK_CONTAINER (widget)));
widget_width = (allocation.width - 2*gtk_container_get_border_width (GTK_CONTAINER (widget)));
widget_height = (allocation.height - 2*gtk_container_get_border_width (GTK_CONTAINER (widget)));
}
switch (gap_side)
{
case GTK_POS_TOP:
if (GTK_CHECK_VERSION(2,10,0) ||
((widget && GE_IS_NOTEBOOK (widget)) &&
((x==widget_x) ||
((x + width) == (widget_x + widget_width)))))
{
clip_height += line_width;
if (!GTK_CHECK_VERSION(2,10,0))
{
height -= floor(line_width/2.0);
}
}
y -= (line_width + 1);
height += (line_width + 1);
break;
case GTK_POS_LEFT:
if (GTK_CHECK_VERSION(2,10,0) ||
((widget && GE_IS_NOTEBOOK (widget)) &&
((y==widget_y) ||
((y + height) == (widget_y + widget_height)))))
{
clip_width += line_width;
if (!GTK_CHECK_VERSION(2,10,0))
{
x -= floor(line_width/2.0);
}
}
x -= (line_width + 1);
width += (line_width + 1);
break;
default:
case GTK_POS_BOTTOM:
height += (line_width + 1);
break;
case GTK_POS_RIGHT:
width += (line_width + 1);
break;
}
/***********************************************/
/* Draw Border */
/***********************************************/
/* Clip Too Size */
cairo_rectangle(cr, clip_x, clip_y, clip_width, clip_height);
cairo_clip(cr);
/* Set Fill Style */
ge_cairo_set_color(cr, background);
/* Fill Rectangle */
cairo_rectangle (cr, x, y, width, height);
cairo_fill(cr);
/* Set Line Style */
ge_cairo_set_color(cr, foreground);
cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT);
cairo_set_line_width (cr, line_width);
ge_cairo_inner_rectangle (cr, x, y, width, height);
cairo_stroke(cr);
}
static void
clearlooks_inverted_draw_slider (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *params,
int x, int y, int width, int height)
{
const CairoColor *border = &colors->shade[params->disabled ? 4 : 6];
const CairoColor *spot = &colors->spot[1];
const CairoColor *fill = &colors->shade[2];
double radius = MIN (params->radius, MIN ((width - 1.0) / 2.0, (height - 1.0) / 2.0));
cairo_pattern_t *pattern;
cairo_set_line_width (cr, 1.0);
cairo_translate (cr, x, y);
if (params->disabled)
border = &colors->shade[4];
else if (params->prelight)
border = &colors->spot[2];
else
border = &colors->shade[6];
/* fill the widget */
cairo_rectangle (cr, 1.0, 1.0, width-2, height-2);
/* Fake light */
if (!params->disabled)
{
const CairoColor *top = &colors->shade[2];
const CairoColor *bot = &colors->shade[0];
pattern = cairo_pattern_create_linear (0, 0, 0, height);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, top->r, top->g, top->b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, bot->r, bot->g, bot->b);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
}
else
{
ge_cairo_set_color (cr, fill);
cairo_rectangle (cr, 1.0, 1.0, width-2, height-2);
cairo_fill (cr);
}
/* Set the clip */
cairo_save (cr);
cairo_rectangle (cr, 1.0, 1.0, 6, height-2);
cairo_rectangle (cr, width-7.0, 1.0, 6, height-2);
cairo_clip_preserve (cr);
cairo_new_path (cr);
/* Draw the handles */
ge_cairo_rounded_rectangle (cr, 1.0, 1.0, width-1, height-1, radius, params->corners);
pattern = cairo_pattern_create_linear (0.5, 0.5, 0.5, 0.5+height);
if (params->prelight)
{
CairoColor highlight;
ge_shade_color (spot, 1.5, &highlight);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, spot->r, spot->g, spot->b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, highlight.r, highlight.g, highlight.b);
cairo_set_source (cr, pattern);
}
else {
CairoColor hilight;
ge_shade_color (fill, 1.5, &hilight);
cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.5);
}
cairo_fill (cr);
cairo_pattern_destroy (pattern);
cairo_restore (cr);
/* Draw the border */
ge_cairo_inner_rounded_rectangle (cr, 0, 0, width, height, radius, params->corners);
if (params->prelight || params->disabled)
ge_cairo_set_color (cr, border);
else
clearlooks_set_border_gradient (cr, border, 1.2, 0, height);
cairo_stroke (cr);
/* Draw handle lines */
if (width > 14)
{
cairo_move_to (cr, 6.5, 1.0);
cairo_line_to (cr, 6.5, height-1);
cairo_move_to (cr, width-6.5, 1.0);
cairo_line_to (cr, width-6.5, height-1);
cairo_set_line_width (cr, 1.0);
cairo_set_source_rgba (cr, border->r,
border->g,
border->b,
0.3);
cairo_stroke (cr);
}
}
static void
clearlooks_inverted_draw_list_view_header (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *params,
const ListViewHeaderParameters *header,
int x, int y, int width, int height)
{
const CairoColor *fill = &colors->bg[params->state_type];
const CairoColor *border = &colors->shade[4];
cairo_pattern_t *pattern;
CairoColor hilight_header;
CairoColor hilight;
CairoColor shadow;
ge_shade_color (border, 1.5, &hilight);
ge_shade_color (fill, 1.05, &hilight_header);
ge_shade_color (fill, 0.95, &shadow);
cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1.0);
/* Draw highlight */
if (header->order & CL_ORDER_FIRST)
{
cairo_move_to (cr, 0.5, height-1);
cairo_line_to (cr, 0.5, 0.5);
}
else
cairo_move_to (cr, 0.0, 0.5);
cairo_line_to (cr, width, 0.5);
ge_cairo_set_color (cr, &hilight);
cairo_stroke (cr);
/* Draw bottom border */
cairo_move_to (cr, 0.0, height-0.5);
cairo_line_to (cr, width, height-0.5);
ge_cairo_set_color (cr, border);
cairo_stroke (cr);
/* Draw bottom shade */
pattern = cairo_pattern_create_linear (0.0, 0, 0.0, height-1.0);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, shadow.r, shadow.g, shadow.b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, hilight_header.r, hilight_header.g, hilight_header.b);
cairo_rectangle (cr, 0, 1, width, height-2);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
/* Draw resize grip */
if ((params->ltr && !(header->order & CL_ORDER_LAST)) ||
(!params->ltr && !(header->order & CL_ORDER_FIRST)) || header->resizable)
{
SeparatorParameters separator;
separator.horizontal = FALSE;
if (params->ltr)
params->style_functions->draw_separator (cr, colors, params, &separator,
width-1.5, 4.0, 2, height-8.0);
else
params->style_functions->draw_separator (cr, colors, params, &separator,
1.5, 4.0, 2, height-8.0);
}
}
static void
clearlooks_inverted_draw_tab (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *params,
const TabParameters *tab,
int x, int y, int width, int height)
{
const CairoColor *border1 = &colors->shade[6];
const CairoColor *border2 = &colors->shade[5];
const CairoColor *stripe_fill = &colors->spot[1];
const CairoColor *stripe_border = &colors->spot[2];
const CairoColor *fill;
CairoColor hilight;
CairoColor shadow;
cairo_pattern_t *pattern;
double radius;
double strip_size;
double length;
radius = MIN (params->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
/* Set clip */
cairo_rectangle (cr, x, y, width, height);
cairo_clip (cr);
cairo_new_path (cr);
/* Translate and set line width */
cairo_set_line_width (cr, 1.0);
cairo_translate (cr, x+0.5, y+0.5);
/* Make the tabs slightly bigger than they should be, to create a gap */
/* And calculate the strip size too, while you're at it */
if (tab->gap_side == CL_GAP_TOP || tab->gap_side == CL_GAP_BOTTOM)
{
height += 3.0;
length = height;
strip_size = 2.0/height; /* 2 pixel high strip */
if (tab->gap_side == CL_GAP_TOP)
cairo_translate (cr, 0.0, -3.0); /* gap at the other side */
}
else
{
width += 3.0;
length = width;
strip_size = 2.0/width;
if (tab->gap_side == CL_GAP_LEFT)
cairo_translate (cr, -3.0, 0.0); /* gap at the other side */
}
/* Set the fill color */
fill = &colors->bg[params->state_type];
/* Set tab shape */
ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1,
radius, params->corners);
/* Draw fill */
ge_cairo_set_color (cr, fill);
cairo_fill (cr);
ge_shade_color (fill, 1.3, &hilight);
/* Draw highlight */
if (!params->active)
{
ShadowParameters shadow;
shadow.shadow = CL_SHADOW_OUT;
shadow.corners = params->corners;
/*
clearlooks_draw_highlight_and_shade (cr, colors, &shadow,
width,
height, radius);*/
}
if (params->active)
{
switch (tab->gap_side)
{
case CL_GAP_TOP:
pattern = cairo_pattern_create_linear (0, height-2, 0, 0);
break;
case CL_GAP_BOTTOM:
pattern = cairo_pattern_create_linear (0, 1, 0, height);
break;
case CL_GAP_LEFT:
pattern = cairo_pattern_create_linear (width-2, 0, 1, 0);
break;
case CL_GAP_RIGHT:
pattern = cairo_pattern_create_linear (1, 0, width-2, 0);
break;
default:
pattern = NULL;
}
ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
ge_shade_color (fill, 0.92, &shadow);
cairo_pattern_add_color_stop_rgba (pattern, 0.0, hilight.r, hilight.g, hilight.b, 0.4);
cairo_pattern_add_color_stop_rgba (pattern, 1.0/height, hilight.r, hilight.g, hilight.b, 0.4);
cairo_pattern_add_color_stop_rgb (pattern, 1.0/height, fill->r,fill->g,fill->b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, shadow.r,shadow.g,shadow.b);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
}
else
{
/* Draw shade */
switch (tab->gap_side)
{
case CL_GAP_TOP:
pattern = cairo_pattern_create_linear (0, height-2, 0, 0);
break;
case CL_GAP_BOTTOM:
pattern = cairo_pattern_create_linear (0, 0, 0, height);
break;
case CL_GAP_LEFT:
pattern = cairo_pattern_create_linear (width-2, 0, 0, 0);
break;
case CL_GAP_RIGHT:
pattern = cairo_pattern_create_linear (0, 0, width, 0);
break;
default:
pattern = NULL;
}
ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, stripe_fill->r, stripe_fill->g, stripe_fill->b);
cairo_pattern_add_color_stop_rgb (pattern, strip_size, stripe_fill->r, stripe_fill->g, stripe_fill->b);
cairo_pattern_add_color_stop_rgba (pattern, strip_size, hilight.r, hilight.g, hilight.b, 0.0);
cairo_pattern_add_color_stop_rgba (pattern, 0.8, hilight.r, hilight.g, hilight.b, 0.0);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
}
ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
if (params->active)
{
ge_cairo_set_color (cr, border2);
cairo_stroke (cr);
}
else
{
switch (tab->gap_side)
{
case CL_GAP_TOP:
pattern = cairo_pattern_create_linear (2, height-2, 2, 2);
break;
case CL_GAP_BOTTOM:
pattern = cairo_pattern_create_linear (2, 2, 2, height);
break;
case CL_GAP_LEFT:
pattern = cairo_pattern_create_linear (width-2, 2, 2, 2);
break;
case CL_GAP_RIGHT:
pattern = cairo_pattern_create_linear (2, 2, width, 2);
break;
default:
pattern = NULL;
}
cairo_pattern_add_color_stop_rgb (pattern, 0.0, stripe_border->r, stripe_border->g, stripe_border->b);
cairo_pattern_add_color_stop_rgb (pattern, strip_size, stripe_border->r, stripe_border->g, stripe_border->b);
cairo_pattern_add_color_stop_rgb (pattern, strip_size, border1->r, border1->g, border1->b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, border2->r, border2->g, border2->b);
cairo_set_source (cr, pattern);
cairo_stroke (cr);
cairo_pattern_destroy (pattern);
}
}
static void
clearlooks_inverted_draw_button (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *params,
int x, int y, int width, int height)
{
double xoffset = 0, yoffset = 0;
double radius = params->radius;
const CairoColor *fill = &colors->bg[params->state_type];
const CairoColor *border_disabled = &colors->shade[4];
CairoColor border_normal;
CairoColor shadow;
ge_shade_color(&colors->shade[6], 1.05, &border_normal);
ge_shade_color (&border_normal, 0.925, &shadow);
cairo_save (cr);
cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1.0);
if (params->xthickness == 3 || params->ythickness == 3)
{
if (params->xthickness == 3)
xoffset = 1;
if (params->ythickness == 3)
yoffset = 1;
}
radius = MIN (radius, MIN ((width - 2.0 - xoffset * 2.0) / 2.0, (height - 2.0 - yoffset * 2) / 2.0));
if (params->xthickness == 3 || params->ythickness == 3)
{
params->style_functions->draw_inset (cr, ¶ms->parentbg, 0, 0, width, height, radius+1, params->corners);
}
ge_cairo_rounded_rectangle (cr, xoffset+1, yoffset+1,
width-(xoffset*2)-2,
height-(yoffset*2)-2,
radius, params->corners);
if (!params->active)
{
cairo_pattern_t *pattern;
CairoColor top_shade, bottom_shade;
ge_shade_color (fill, 0.95, &top_shade);
ge_shade_color (fill, 1.05, &bottom_shade);
pattern = cairo_pattern_create_linear (0, 0, 0, height);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, top_shade.r, top_shade.g, top_shade.b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, bottom_shade.r, bottom_shade.g, bottom_shade.b);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
}
else
{
cairo_pattern_t *pattern;
ge_cairo_set_color (cr, fill);
cairo_fill_preserve (cr);
pattern = cairo_pattern_create_linear (0, 0, 0, height);
cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.0);
cairo_pattern_add_color_stop_rgba (pattern, 0.4, shadow.r, shadow.g, shadow.b, 0.0);
cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.2);
cairo_set_source (cr, pattern);
cairo_fill_preserve (cr);
cairo_pattern_destroy (pattern);
pattern = cairo_pattern_create_linear (0, yoffset+1, 0, 3+yoffset);
cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, params->disabled ? 0.125 : 0.3);
cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.0);
cairo_set_source (cr, pattern);
cairo_fill_preserve (cr);
cairo_pattern_destroy (pattern);
pattern = cairo_pattern_create_linear (xoffset+1, 0, 3+xoffset, 0);
cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, params->disabled ? 0.125 : 0.3);
cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.0);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
}
/* Drawing the border */
if (!params->active && params->is_default)
{
const CairoColor *l = &colors->shade[4];
const CairoColor *d = &colors->shade[4];
ge_cairo_set_color (cr, l);
ge_cairo_stroke_rectangle (cr, 2.5, 2.5, width-5, height-5);
ge_cairo_set_color (cr, d);
ge_cairo_stroke_rectangle (cr, 3.5, 3.5, width-7, height-7);
}
if (params->disabled)
ge_cairo_set_color (cr, border_disabled);
else
if (!params->active)
clearlooks_set_border_gradient (cr, &border_normal, 1.32, 0, height);
else
ge_cairo_set_color (cr, &border_normal);
ge_cairo_rounded_rectangle (cr, xoffset + 0.5, yoffset + 0.5,
width-(xoffset*2)-1, height-(yoffset*2)-1,
radius, params->corners);
cairo_stroke (cr);
/* Draw the "shadow" */
if (!params->active)
{
/* Draw right shadow */
cairo_move_to (cr, width-xoffset-1.5, yoffset + radius);
cairo_line_to (cr, width-xoffset-1.5, height - yoffset - radius);
cairo_set_source_rgba (cr, shadow.r, shadow.g, shadow.b, 0.1);
cairo_stroke (cr);
/* Draw topleft shadow */
params->style_functions->draw_top_left_highlight (cr, fill, params,
xoffset+1, yoffset+1,
width-2*(xoffset+1), height-2*(yoffset+1),
radius, params->corners);
}
cairo_restore (cr);
}
static void
clearlooks_inverted_draw_progressbar_fill (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *params,
const ProgressBarParameters *progressbar,
int x, int y, int width, int height,
gint offset)
{
boolean is_horizontal = progressbar->orientation < 2;
double tile_pos = 0;
double stroke_width;
double radius;
int x_step;
cairo_pattern_t *pattern;
CairoColor bg_shade;
CairoColor border;
CairoColor shadow;
CairoColor top_shade;
radius = MAX (0, params->radius - params->xthickness);
cairo_save (cr);
if (!is_horizontal)
ge_cairo_exchange_axis (cr, &x, &y, &width, &height);
if ((progressbar->orientation == CL_ORIENTATION_RIGHT_TO_LEFT) || (progressbar->orientation == CL_ORIENTATION_BOTTOM_TO_TOP))
ge_cairo_mirror (cr, CR_MIRROR_HORIZONTAL, &x, &y, &width, &height);
/* Clamp the radius so that the _height_ fits ... */
radius = MIN (radius, height / 2.0);
stroke_width = height*2;
x_step = (((float)stroke_width/10)*offset); /* This looks weird ... */
cairo_translate (cr, x, y);
cairo_save (cr);
/* This is kind of nasty ... Clip twice from each side in case the length
* of the fill is smaller than twice the radius. */
ge_cairo_rounded_rectangle (cr, 0, 0, width + radius, height, radius, CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT);
cairo_clip (cr);
ge_cairo_rounded_rectangle (cr, -radius, 0, width + radius, height, radius, CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT);
cairo_clip (cr);
ge_shade_color (&colors->spot[1], 1.05, &top_shade);
/* Draw the background gradient */
ge_shade_color (&colors->spot[1], 0.925, &bg_shade);
pattern = cairo_pattern_create_linear (0, 0, 0, height);
cairo_pattern_add_color_stop_rgb (pattern, 0.0, bg_shade.r, bg_shade.g, bg_shade.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.5, top_shade.r, top_shade.g, top_shade.b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, bg_shade.r, bg_shade.g, bg_shade.b);
cairo_set_source (cr, pattern);
cairo_paint (cr);
cairo_pattern_destroy (pattern);
/* Draw the Strokes */
while (stroke_width > 0 && tile_pos <= width+x_step)
{
cairo_move_to (cr, stroke_width/2-x_step, 0);
cairo_line_to (cr, stroke_width-x_step, 0);
cairo_line_to (cr, stroke_width/2-x_step, height);
cairo_line_to (cr, -x_step, height);
cairo_translate (cr, stroke_width, 0);
tile_pos += stroke_width;
}
cairo_set_source_rgba (cr, colors->spot[2].r,
colors->spot[2].g,
colors->spot[2].b,
0.15);
cairo_fill (cr);
cairo_restore (cr); /* rounded clip region */
/* inner highlight border
* This is again kinda ugly. Draw once from each side, clipping away the other. */
cairo_set_source_rgba (cr, colors->spot[0].r, colors->spot[0].g, colors->spot[0].b, 0.5);
/* left side */
cairo_save (cr);
cairo_rectangle (cr, 0, 0, width / 2, height);
cairo_clip (cr);
if (progressbar->pulsing)
ge_cairo_rounded_rectangle (cr, 1.5, 0.5, width + radius, height - 1, radius, CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT);
else
ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width + radius, height - 1, radius, CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT);
cairo_stroke (cr);
cairo_restore (cr); /* clip */
/* right side */
cairo_save (cr);
cairo_rectangle (cr, width / 2, 0, (width+1) / 2, height);
cairo_clip (cr);
if (progressbar->value < 1.0 || progressbar->pulsing)
ge_cairo_rounded_rectangle (cr, -1.5 - radius, 0.5, width + radius, height - 1, radius, CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT);
else
ge_cairo_rounded_rectangle (cr, -0.5 - radius, 0.5, width + radius, height - 1, radius, CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT);
cairo_stroke (cr);
cairo_restore (cr); /* clip */
/* Draw the dark lines and the shadow */
cairo_save (cr);
/* Again, this weird clip area. */
ge_cairo_rounded_rectangle (cr, -1.0, 0, width + radius + 2.0, height, radius, CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT);
cairo_clip (cr);
ge_cairo_rounded_rectangle (cr, -radius - 1.0, 0, width + radius + 2.0, height, radius, CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT);
cairo_clip (cr);
border = colors->spot[2];
border.a = 0.5;
shadow.r = 0.0;
shadow.g = 0.0;
shadow.b = 0.0;
shadow.a = 0.1;
if (progressbar->pulsing)
{
/* At the beginning of the bar. */
cairo_move_to (cr, 0.5 + radius, height + 0.5);
ge_cairo_rounded_corner (cr, 0.5, height + 0.5, radius + 1, CR_CORNER_BOTTOMLEFT);
ge_cairo_rounded_corner (cr, 0.5, -0.5, radius + 1, CR_CORNER_TOPLEFT);
ge_cairo_set_color (cr, &border);
cairo_stroke (cr);
cairo_move_to (cr, -0.5 + radius, height + 0.5);
ge_cairo_rounded_corner (cr, -0.5, height + 0.5, radius + 1, CR_CORNER_BOTTOMLEFT);
ge_cairo_rounded_corner (cr, -0.5, -0.5, radius + 1, CR_CORNER_TOPLEFT);
ge_cairo_set_color (cr, &shadow);
cairo_stroke (cr);
}
if (progressbar->value < 1.0 || progressbar->pulsing)
{
/* At the end of the bar. */
cairo_move_to (cr, width - 0.5 - radius, -0.5);
ge_cairo_rounded_corner (cr, width - 0.5, -0.5, radius + 1, CR_CORNER_TOPRIGHT);
ge_cairo_rounded_corner (cr, width - 0.5, height + 0.5, radius + 1, CR_CORNER_BOTTOMRIGHT);
ge_cairo_set_color (cr, &border);
cairo_stroke (cr);
cairo_move_to (cr, width + 0.5 - radius, -0.5);
ge_cairo_rounded_corner (cr, width + 0.5, -0.5, radius + 1, CR_CORNER_TOPRIGHT);
ge_cairo_rounded_corner (cr, width + 0.5, height + 0.5, radius + 1, CR_CORNER_BOTTOMRIGHT);
ge_cairo_set_color (cr, &shadow);
cairo_stroke (cr);
}
cairo_restore (cr);
cairo_restore (cr); /* rotation, mirroring */
}
/* Standard Border Function */
void
hc_draw_shadow(GtkStyle * style,
cairo_t * cr,
GtkStateType state_type,
GtkShadowType shadow_type,
GtkWidget * widget,
const gchar * detail,
gint x,
gint y,
gint width,
gint height)
{
/* Border Uses Foreground Color */
CairoColor foreground = HC_STYLE(style)->color_cube.fg[state_type];
gint line_width;
gint clip_x = x, clip_y = y, clip_width = width, clip_height = height;
/***********************************************/
/* GTK Sanity Checks */
/***********************************************/
CHECK_ARGS
/***********************************************/
/* GTK Special Cases - adjust Size/Offset */
/***********************************************/
line_width = HC_STYLE(style)->edge_thickness;
if (CHECK_DETAIL (detail, "menubar") && ge_is_panel_widget_item(widget))
{
return;
}
/* Spin Button */
if ((CHECK_DETAIL(detail, "spinbutton_up")) || (CHECK_DETAIL(detail, "spinbutton_down")))
{
/* Overdraw Height By Half The Line Width -
Prevents Double line Between buttons */
height += floor(line_width / 2);
/* If Down Button Offset By Half Line Width */
if (CHECK_DETAIL(detail, "spinbutton_down"))
{
y -= floor(line_width / 2);
}
/* Overdraw Width By Line Width -
Prevents Double line Between Entry And Buttons */
width += line_width;
/* If LTR Offset X By Line Width */
if (ge_widget_is_ltr (widget))
{
x -= line_width;
}
/* Force Border To Use Foreground Widget State */
if (widget)
{
foreground = HC_STYLE(style)->color_cube.fg[gtk_widget_get_state(widget)];
}
}
/* Entry - Force Border To Use Foreground Matching Widget State */
if (CHECK_DETAIL(detail, "entry") && !ge_is_combo(widget))
{
foreground = HC_STYLE(style)->color_cube.fg[widget ? gtk_widget_get_state(widget) : GTK_STATE_NORMAL];
}
/* Combo Box Button's */
if (CHECK_DETAIL(detail, "button") && ge_is_in_combo_box(widget))
{
/* Overdraw Width By Line Width -
Prevents Double Line Between Entry and Button. */
width += line_width;
/* If LTR Offset X By Line Width */
if (ge_widget_is_ltr (widget))
{
x -= line_width;
}
/* Force Border To Use Foreground Matching Parent State */
if ((widget) && (gtk_widget_get_parent(widget)))
{
gtk_widget_ensure_style(gtk_widget_get_parent(widget));
ge_gdk_color_to_cairo(>k_widget_get_style(gtk_widget_get_parent(widget))->fg[gtk_widget_get_state (widget)], &foreground);
}
}
/***********************************************/
/* Draw Border */
/***********************************************/
/* Clip Border Too Passed Size */
cairo_rectangle(cr, clip_x, clip_y, clip_width, clip_height);
cairo_clip(cr);
/* Set Line Style */
ge_cairo_set_color(cr, &foreground);
cairo_set_line_cap(cr, CAIRO_LINE_CAP_BUTT);
cairo_set_line_width (cr, line_width);
ge_cairo_inner_rectangle (cr, x, y, width, height);
cairo_stroke(cr);
}
static void
clearlooks_glossy_draw_radiobutton (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *widget,
const CheckboxParameters *checkbox,
int x, int y, int width, int height)
{
const CairoColor *border;
const CairoColor *dot;
CairoColor shadow;
CairoColor highlight;
cairo_pattern_t *pt;
gboolean inconsistent;
gboolean draw_bullet = (checkbox->shadow_type == GTK_SHADOW_IN);
gdouble w, h, cx, cy, radius;
w = (gdouble) width;
h = (gdouble) height;
cx = width / 2.0;
cy = height / 2.0;
radius = MIN (width, height) / 2.0;
inconsistent = (checkbox->shadow_type == GTK_SHADOW_ETCHED_IN);
draw_bullet |= inconsistent;
if (widget->disabled)
{
border = &colors->shade[5];
dot = &colors->shade[6];
}
else
{
if (widget->prelight)
border = &colors->spot[2];
else
border = &colors->shade[6];
dot = &colors->text[0];
}
ge_shade_color (&widget->parentbg, 0.9, &shadow);
ge_shade_color (&widget->parentbg, 1.1, &highlight);
pt = cairo_pattern_create_linear (0, 0, radius * 2.0, radius * 2.0);
cairo_pattern_add_color_stop_rgb (pt, 0.0, shadow.r, shadow.b, shadow.g);
cairo_pattern_add_color_stop_rgba (pt, 0.5, shadow.r, shadow.b, shadow.g, 0.5);
cairo_pattern_add_color_stop_rgba (pt, 0.5, highlight.r, highlight.g, highlight.b, 0.5);
cairo_pattern_add_color_stop_rgb (pt, 1.0, highlight.r, highlight.g, highlight.b);
cairo_translate (cr, x, y);
cairo_set_line_width (cr, MAX (1.0, floor (radius/3)));
cairo_arc (cr, ceil (cx), ceil (cy), floor (radius - 0.1), 0, G_PI*2);
cairo_set_source (cr, pt);
cairo_stroke (cr);
cairo_pattern_destroy (pt);
cairo_set_line_width (cr, MAX (1.0, floor (radius/6)));
cairo_arc (cr, ceil (cx), ceil (cy), MAX (1.0, ceil (radius) - 1.5), 0, G_PI*2);
if (!widget->disabled)
{
if (widget->prelight)
clearlooks_set_mixed_color (cr, &colors->base[0], &colors->spot[1], 0.5);
else
ge_cairo_set_color (cr, &colors->base[0]);
cairo_fill_preserve (cr);
}
ge_cairo_set_color (cr, border);
cairo_stroke (cr);
if (draw_bullet)
{
if (inconsistent)
{
cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
cairo_set_line_width (cr, ceil (radius * 2 / 3));
cairo_move_to (cr, ceil (cx - radius/3.0), ceil (cy));
cairo_line_to (cr, ceil (cx + radius/3.0), ceil (cy));
ge_cairo_set_color (cr, dot);
cairo_stroke (cr);
}
else
{
cairo_arc (cr, ceil (cx), ceil (cy), floor (radius/2.0), 0, G_PI*2);
ge_cairo_set_color (cr, dot);
cairo_fill (cr);
cairo_arc (cr, floor (cx - radius/10.0), floor (cy - radius/10.0), floor (radius/6.0), 0, G_PI*2);
cairo_set_source_rgba (cr, highlight.r, highlight.g, highlight.b, 0.5);
cairo_fill (cr);
}
}
}
static void
thinice_style_draw_slider(GtkStyle * style,
cairo_t * cr,
GtkStateType state_type,
GtkShadowType shadow_type,
GtkWidget * widget,
const gchar *detail,
gint x,
gint y,
gint width,
gint height,
GtkOrientation orientation)
{
ThiniceStyle *thinice_style = THINICE_STYLE (style);
GdkPoint pointsh[7];
gint i, rect = FALSE, midlines = MARKS_SLASH;
gint modx, mody;
CHECK_ARGS
#ifdef DEBUG
printf("draw_slider(%s, %d, %d, %d)\n", detail, x, y, orientation);
#endif
#ifdef DEBUG
printf("Slider... x,y=%d,%d width = %d, height = %d (%d)\n",x,y,width,height, state_type);
#endif
midlines = THINICE_RC_STYLE (style->rc_style)->mark_type1;
#ifdef DEBUG
printf("Midlines = %d\n", midlines);
#endif
if (THINICE_RC_STYLE (style->rc_style)->scrollbar_type == SCROLL_RECT)
{
rect = TRUE;
}
/* too small, use rect & no midlines */
if ((width <= SMALLEST_HANDLE) && (height <= SMALLEST_HANDLE))
{
midlines = MARKS_NOTHING;
rect = TRUE;
}
if (rect)
{
pointsh[0].x = x; pointsh[0].y = y;
pointsh[1].x = x + width - 1; pointsh[1].y = y;
pointsh[2].x = x + width - 1; pointsh[2].y = y + height - 1;
pointsh[3].x = x; pointsh[3].y = y + height - 1;
pointsh[4].x = x; pointsh[4].y = y;
}
else
{
int chopoff;
if (orientation == GTK_ORIENTATION_HORIZONTAL) {
chopoff = CLAMP(width-SMALLEST_HANDLE, 0, 6);
} else {
chopoff = CLAMP(height-SMALLEST_HANDLE, 0, 6);
}
pointsh[0].x = x; pointsh[0].y = y+height-1;
pointsh[1].x = x; pointsh[1].y = y+chopoff;
pointsh[2].x = x+chopoff; pointsh[2].y = y;
pointsh[3].x = x+width-1; pointsh[3].y = y;
pointsh[4].x = x+width-1; pointsh[4].y = y+height-1-chopoff;
pointsh[5].x = x+width-1-chopoff; pointsh[5].y = y+height-1;
pointsh[6].x = x; pointsh[6].y = y+height-1;
}
if (rect)
{
ge_cairo_set_color(cr, &thinice_style->color_cube.bg[state_type]);
cairo_rectangle(cr, x, y, width, height);
cairo_fill(cr);
thinice_style_draw_shadow(style, cr, state_type, shadow_type,
widget, detail, x, y, width, height);
}
else
{
/* Fill the polygon */
ge_cairo_polygon(cr, &thinice_style->color_cube.bg[state_type],
pointsh, 6);
/* Draw the light border */
for (i=0;i<3;i++)
{
ge_cairo_line(cr, &thinice_style->color_cube.light[state_type],
pointsh[i].x,pointsh[i].y,
pointsh[i+1].x,pointsh[i+1].y);
}
/* Draw the dark border */
for (i=3;i<6;i++)
{
ge_cairo_line(cr, &thinice_style->color_cube.dark[state_type],
pointsh[i].x,pointsh[i].y,
pointsh[i+1].x,pointsh[i+1].y);
}
}
if (orientation == GTK_ORIENTATION_HORIZONTAL)
{ modx = 4; mody = 0; }
else
{ modx = 0; mody = 4; }
switch (midlines)
{
case MARKS_NOTHING:
break;
case MARKS_INVSLASH: /* Inverse //:es */
thinice_slash_two(cr,
&thinice_style->color_cube.dark[state_type],
&thinice_style->color_cube.light[state_type],
x, y, width, height);
break;
case MARKS_DOT:
thinice_dot(cr,
&thinice_style->color_cube.light[state_type],
&thinice_style->color_cube.dark[state_type],
x + width / 2 - modx,
y + height / 2 - mody);
thinice_dot(cr,
&thinice_style->color_cube.light[state_type],
&thinice_style->color_cube.dark[state_type],
x + width / 2,
y + height / 2);
thinice_dot(cr,
&thinice_style->color_cube.light[state_type],
&thinice_style->color_cube.dark[state_type],
x + width / 2 + modx,
y + height / 2 + mody);
break;
case MARKS_INVDOT: /* Inverted */
thinice_dot(cr,
&thinice_style->color_cube.dark[state_type],
&thinice_style->color_cube.light[state_type],
x + width / 2 - modx,
y + height / 2 - mody);
thinice_dot(cr,
&thinice_style->color_cube.dark[state_type],
&thinice_style->color_cube.light[state_type],
x + width / 2,
y + height / 2);
thinice_dot(cr,
&thinice_style->color_cube.dark[state_type],
&thinice_style->color_cube.light[state_type],
x + width / 2 + modx,
y + height / 2 + mody);
break;
case MARKS_SLASH:
default:
thinice_slash_two(cr,
&thinice_style->color_cube.light[state_type],
&thinice_style->color_cube.dark[state_type],
x, y, width, height);
break;
}
}
static void
clearlooks_inverted_draw_scrollbar_slider (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *widget,
const ScrollBarParameters *scrollbar,
int x, int y, int width, int height)
{
if (scrollbar->junction & CL_JUNCTION_BEGIN)
{
if (scrollbar->horizontal)
{
x -= 1;
width += 1;
}
else
{
y -= 1;
height += 1;
}
}
if (scrollbar->junction & CL_JUNCTION_END)
{
if (scrollbar->horizontal)
width += 1;
else
height += 1;
}
if (!scrollbar->horizontal)
ge_cairo_exchange_axis (cr, &x, &y, &width, &height);
cairo_translate (cr, x, y);
if (scrollbar->has_color)
{
const CairoColor *border = &colors->shade[8];
CairoColor fill = scrollbar->color;
CairoColor hilight;
CairoColor shade1, shade2, shade3;
cairo_pattern_t *pattern;
if (widget->prelight)
ge_shade_color (&fill, 1.1, &fill);
cairo_set_line_width (cr, 1);
ge_shade_color (&fill, 1.3, &hilight);
ge_shade_color (&fill, 1.1, &shade1);
ge_shade_color (&fill, 1.05, &shade2);
ge_shade_color (&fill, 0.98, &shade3);
pattern = cairo_pattern_create_linear (1, 1, 1, height-2);
cairo_pattern_add_color_stop_rgb (pattern, 0, fill.r, fill.g, fill.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade3.r, shade3.g, shade3.b);
cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade2.r, shade2.g, shade2.b);
cairo_pattern_add_color_stop_rgb (pattern, 1.0, shade1.r, shade1.g, shade1.b);
cairo_rectangle (cr, 1, 1, width-2, height-2);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.5);
ge_cairo_stroke_rectangle (cr, 1.5, 1.5, width-3, height-3);
ge_cairo_set_color (cr, border);
ge_cairo_stroke_rectangle (cr, 0.5, 0.5, width-1, height-1);
}
else
{
CairoColor border;
CairoColor s1, s2, s3;
cairo_pattern_t *pattern;
int bar_x, i;
const CairoColor *dark = &colors->shade[4];
const CairoColor *light = &colors->shade[0];
ge_shade_color(&colors->shade[6], 1.05, &border);
pattern = cairo_pattern_create_linear(1, 1, 1, height-1);
s1 = colors->bg[widget->state_type];
ge_shade_color(&s1, 0.95, &s2);
ge_shade_color(&s1, 1.05, &s3);
cairo_pattern_add_color_stop_rgb(pattern, 0, s2.r, s2.g, s2.b);
cairo_pattern_add_color_stop_rgb(pattern, 1.0, s3.r, s3.g, s3.b);
cairo_rectangle (cr, 1, 1, width-2, height-2);
cairo_set_source(cr, pattern);
cairo_fill(cr);
cairo_pattern_destroy(pattern);
widget->style_functions->draw_top_left_highlight (cr, &s2, widget, 1, 1, width-2, height-2, 0, widget->corners);
clearlooks_set_border_gradient (cr, &border, 1.2, 0, height);
ge_cairo_stroke_rectangle (cr, 0.5, 0.5, width-1, height-1);
/* draw handles */
cairo_set_line_width (cr, 1);
bar_x = width/2 - 4;
cairo_translate(cr, 0.5, 0.5);
for (i=0; i<3; i++)
{
cairo_move_to (cr, bar_x, 4);
cairo_line_to (cr, bar_x, height-5);
ge_cairo_set_color (cr, dark);
cairo_stroke (cr);
cairo_move_to (cr, bar_x+1, 4);
cairo_line_to (cr, bar_x+1, height-5);
ge_cairo_set_color (cr, light);
cairo_stroke (cr);
bar_x += 3;
}
}
}
static void
clearlooks_glossy_draw_scrollbar_stepper (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *widget,
const ScrollBarParameters *scrollbar,
const ScrollBarStepperParameters *stepper,
int x, int y, int width, int height)
{
CairoCorners corners = CR_CORNER_NONE;
const CairoColor *border = &colors->shade[7];
CairoColor fill, s1, s2, s4;
cairo_pattern_t *pattern;
ShadowParameters shadow;
double radius = MIN (widget->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
if (scrollbar->horizontal)
{
if (stepper->stepper == CL_STEPPER_START)
corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
else if (stepper->stepper == CL_STEPPER_END)
corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
if (stepper->stepper == CL_STEPPER_START_INNER)
{
x -= 1;
width += 1;
}
else if (stepper->stepper == CL_STEPPER_END_INNER)
{
width += 1;
}
}
else
{
if (stepper->stepper == CL_STEPPER_START)
corners = CR_CORNER_TOPLEFT | CR_CORNER_TOPRIGHT;
else if (stepper->stepper == CL_STEPPER_END)
corners = CR_CORNER_BOTTOMLEFT | CR_CORNER_BOTTOMRIGHT;
if (stepper->stepper == CL_STEPPER_START_INNER)
{
y -= 1;
height += 1;
}
else if (stepper->stepper == CL_STEPPER_END_INNER)
{
height += 1;
}
}
cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1);
ge_cairo_rounded_rectangle (cr, 1, 1, width-2, height-2, radius, corners);
if (scrollbar->horizontal)
pattern = cairo_pattern_create_linear (0, 0, 0, height);
else
pattern = cairo_pattern_create_linear (0, 0, width, 0);
fill = colors->bg[widget->state_type];
ge_shade_color(&fill, 1.16, &s1);
ge_shade_color(&fill, 1.08, &s2);
ge_shade_color(&fill, 1.08, &s4);
cairo_pattern_add_color_stop_rgb(pattern, 0, s1.r, s1.g, s1.b);
cairo_pattern_add_color_stop_rgb(pattern, 0.5, s2.r, s2.g, s2.b);
cairo_pattern_add_color_stop_rgb(pattern, 0.5, fill.r, fill.g, fill.b);
cairo_pattern_add_color_stop_rgb(pattern, 1.0, s4.r, s4.g, s4.b);
cairo_set_source (cr, pattern);
cairo_fill (cr);
cairo_pattern_destroy (pattern);
ge_cairo_inner_rounded_rectangle (cr, 0, 0, width, height, radius, corners);
clearlooks_set_mixed_color (cr, border, &fill, 0.2);
if (widget->prelight)
ge_cairo_set_color (cr, &colors->spot[2]);
cairo_stroke (cr);
shadow.shadow = CL_SHADOW_OUT;
shadow.corners = corners;
}
static void
clearlooks_glossy_draw_checkbox (cairo_t *cr,
const ClearlooksColors *colors,
const WidgetParameters *widget,
const CheckboxParameters *checkbox,
int x, int y, int width, int height)
{
const CairoColor *border;
const CairoColor *dot;
gboolean inconsistent = FALSE;
gboolean draw_bullet = (checkbox->shadow_type == GTK_SHADOW_IN);
inconsistent = (checkbox->shadow_type == GTK_SHADOW_ETCHED_IN);
draw_bullet |= inconsistent;
if (widget->disabled)
{
border = &colors->shade[5];
dot = &colors->shade[6];
}
else
{
if (widget->prelight)
border = &colors->spot[2];
else
border = &colors->shade[6];
dot = &colors->text[GTK_STATE_NORMAL];
}
cairo_translate (cr, x, y);
cairo_set_line_width (cr, 1);
if (widget->xthickness > 2 && widget->ythickness > 2)
{
widget->style_functions->draw_inset (cr, &widget->parentbg, 0, 0,
width, height, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
/* Draw the rectangle for the checkbox itself */
ge_cairo_rounded_rectangle (cr, 1.5, 1.5,
width-3, height-3, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
}
else
{
/* Draw the rectangle for the checkbox itself */
ge_cairo_rounded_rectangle (cr, 0.5, 0.5,
width-1, height-1, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
}
if (!widget->disabled)
{
if (widget->prelight)
clearlooks_set_mixed_color (cr, &colors->base[0], &colors->spot[1], 0.5);
else
ge_cairo_set_color (cr, &colors->base[0]);
cairo_fill_preserve (cr);
}
ge_cairo_set_color (cr, border);
cairo_stroke (cr);
if (draw_bullet)
{
if (inconsistent) /* Inconsistent */
{
cairo_set_line_width (cr, 2.0);
cairo_move_to (cr, 3, height*0.5);
cairo_line_to (cr, width-3, height*0.5);
}
else
{
cairo_set_line_width (cr, 1.7);
cairo_move_to (cr, 0.5 + (width*0.2), (height*0.5));
cairo_line_to (cr, 0.5 + (width*0.4), (height*0.7));
cairo_curve_to (cr, 0.5 + (width*0.4), (height*0.7),
0.5 + (width*0.5), (height*0.4),
0.5 + (width*0.70), (height*0.25));
}
ge_cairo_set_color (cr, dot);
cairo_stroke (cr);
}
}
