ardour/livetrax
13
0
Fork 0
Code
bf0fac039e
livetrax/libs/clearlooks/clearlooks_draw.c

1294 lines
40 KiB
C
Raw Blame History

#include "clearlooks_draw.h"
#include "clearlooks_style.h"
#include "support.h"
/** WANTED:
FASTER GRADIENT FILL FUNCTION, POSSIBLY USING XRENDER. **/
static void cl_draw_borders (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x, int y, int width, int height, CLRectangle *r);
static void cl_draw_line (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x1, int y1, int x2, int y2, CLBorderType border,
CLRectangle *r);
static void cl_draw_corner (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x, int y, int width, int height,
CLRectangle *r, CLCornerSide corner);
static void cl_draw_fill (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x, int y, int width, int height, CLRectangle *r);
void cl_draw_rectangle (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x, int y, int width, int height, CLRectangle *r)
{
if (r->fillgc)
{
cl_draw_fill(window, widget, style, x, y, width, height, r);
}
if (r->bordergc)
{
cl_draw_borders(window, widget, style, x, y, width, height, r);
}
}
static void cl_get_coords ( CLBorderType border,
int x, int y, int width, int height,
CLRectangle *r, int *x1, int *y1, int *x2, int *y2)
{
switch (border)
{
case CL_BORDER_TOP:
*x1 = x + r->corners[CL_CORNER_TOPLEFT];
*x2 = *x1 + width - r->corners[CL_CORNER_TOPLEFT] - r->corners[CL_CORNER_TOPRIGHT] - 1;
*y1 = *y2 = y;
break;
case CL_BORDER_BOTTOM:
*x1 = x + r->corners[CL_CORNER_BOTTOMLEFT];
*x2 = *x1 + width - r->corners[CL_CORNER_BOTTOMLEFT] - r->corners[CL_CORNER_BOTTOMRIGHT] - 1;
*y1 = *y2 = y + height - 1;
break;
case CL_BORDER_LEFT:
*x1 = *x2 = x;
*y1 = y + r->corners[CL_CORNER_TOPLEFT];
*y2 = *y1 + height - r->corners[CL_CORNER_TOPLEFT] - r->corners[CL_CORNER_BOTTOMLEFT] - 1;
break;
case CL_BORDER_RIGHT:
*x1 = *x2 = x + width - 1;
*y1 = y + r->corners[CL_CORNER_TOPRIGHT];
*y2 = *y1 + height - r->corners[CL_CORNER_TOPRIGHT] - r->corners[CL_CORNER_BOTTOMRIGHT] - 1;
break;
}
}
void cl_draw_borders (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x, int y, int width, int height, CLRectangle *r)
{
int x1, y1, x2, y2, i;
if (r->bordergc == NULL)
return;
for ( i=0; i<4; i++) /* draw all four borders + corners */
{
cl_get_coords (i, x, y, width, height, r, &x1, &y1, &x2, &y2);
cl_draw_line (window, widget, style, x1, y1, x2, y2, i, r);
cl_draw_corner (window, widget, style, x, y, width, height, r, i );
}
}
static GdkColor cl_gc_get_foreground(GdkGC *gc)
{
GdkGCValues values;
gdk_gc_get_values (gc, &values);
return values.foreground;
}
static void cl_draw_line (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x1, int y1, int x2, int y2, CLBorderType border,
CLRectangle *r)
{
if (r->gradient_type == CL_GRADIENT_NONE ||
r->border_gradient.from == NULL || r->border_gradient.to == NULL )
{
gdk_draw_line (window, r->bordergc, x1, y1, x2, y2);
}
else if (r->gradient_type == CL_GRADIENT_HORIZONTAL && (border == CL_BORDER_TOP || border == CL_BORDER_BOTTOM))
{
draw_vgradient (window, r->bordergc, style,
x1, y1, x2-x1+1, 1,
r->border_gradient.from, r->border_gradient.to);
}
else if (r->gradient_type == CL_GRADIENT_VERTICAL && (border == CL_BORDER_LEFT || border == CL_BORDER_RIGHT))
{
draw_hgradient (window, r->bordergc, style,
x1, y1, 1, y2-y1+1,
r->border_gradient.from, r->border_gradient.to);
}
else
{
GdkColor tmp_color = cl_gc_get_foreground (r->bordergc);
if (r->gradient_type == CL_GRADIENT_HORIZONTAL && border == CL_BORDER_LEFT ||
r->gradient_type == CL_GRADIENT_VERTICAL && border == CL_BORDER_TOP)
gdk_gc_set_foreground (r->bordergc, r->border_gradient.from);
else
gdk_gc_set_foreground (r->bordergc, r->border_gradient.to);
gdk_draw_line (window, r->bordergc, x1, y1, x2, y2);
gdk_gc_set_foreground (r->bordergc, &tmp_color);
}
}
static GdkColor *cl_get_gradient_corner_color (CLRectangle *r, CLCornerSide corner)
{
GdkColor *color;
if (r->border_gradient.from == NULL || r->border_gradient.to == NULL)
{
color = NULL;
}
else if ((r->gradient_type == CL_GRADIENT_HORIZONTAL && (corner == CL_CORNER_TOPLEFT || corner == CL_CORNER_BOTTOMLEFT)) ||
(r->gradient_type == CL_GRADIENT_VERTICAL && (corner == CL_CORNER_TOPLEFT || corner == CL_CORNER_TOPRIGHT)))
{
color = r->border_gradient.from;
}
else /* no gradient or other corner */
{
color = r->border_gradient.to;
}
return color;
}
static void cl_draw_corner (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x, int y, int width, int height,
CLRectangle *r, CLCornerSide corner)
{
GdkColor *color;
GdkColor aacolor; /* anti-aliasing color */
GdkGCValues values;
GdkColor tmp;
GdkColor *bgcolor;
int x1;
int y1;
if (r->corners[corner] == CL_CORNER_NONE)
return;
color = cl_get_gradient_corner_color (r, corner);
gdk_gc_get_values (r->bordergc, &values);
if (color == NULL)
{
tmp = values.foreground;
gdk_colormap_query_color (gtk_widget_get_colormap(widget), values.foreground.pixel, &tmp);
color = &tmp;
}
bgcolor = get_parent_bgcolor(widget);
if (bgcolor == NULL)
{
bgcolor = color;
}
blend (style->colormap, bgcolor, color, &aacolor, 70);
if (r->corners[corner] == CL_CORNER_ROUND)
{
x1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_BOTTOMLEFT) ? x+1 : x+width - 2;
y1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_TOPRIGHT) ? y+1 : y+height - 2;
gdk_gc_set_foreground (r->bordergc, color);
gdk_draw_point (window, r->bordergc, x1, y1);
gdk_gc_set_foreground (r->bordergc, &aacolor);
x1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_BOTTOMLEFT) ? x+1 : x+width-2;
y1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_TOPRIGHT) ? y : y+height-1;
gdk_draw_point (window, r->bordergc, x1, y1);
x1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_BOTTOMLEFT) ? x : x+width-1;
y1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_TOPRIGHT) ? y+1 : y+height-2;
gdk_draw_point (window, r->bordergc, x1, y1);
}
else if (r->corners[corner] == CL_CORNER_NARROW)
{
x1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_BOTTOMLEFT) ? x : x+width-1;
y1 = (corner == CL_CORNER_TOPLEFT ||
corner == CL_CORNER_TOPRIGHT) ? y : y+height-1;
gdk_gc_set_foreground (r->bordergc, &aacolor);
gdk_draw_point (window, r->bordergc, x1, y1);
}
gdk_gc_set_foreground (r->bordergc, &values.foreground);
}
static void cl_draw_fill (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x, int y, int width, int height, CLRectangle *r)
{
if (r->gradient_type == CL_GRADIENT_NONE ||
r->fill_gradient.from == NULL || r->fill_gradient.to == NULL)
{
gdk_draw_rectangle (window, r->fillgc, TRUE,
x+1, y+1, width-2, height-2);
}
else if (r->gradient_type == CL_GRADIENT_HORIZONTAL)
{
draw_vgradient (window, r->fillgc, gtk_widget_get_style(widget),
x+1, y+1, width-2, height-2,
r->fill_gradient.from, r->fill_gradient.to);
}
else if (r->gradient_type == CL_GRADIENT_VERTICAL)
{
draw_hgradient (window, r->fillgc, gtk_widget_get_style(widget),
x+1, y+1, width-2, height-2,
r->fill_gradient.from, r->fill_gradient.to);
}
}
void cl_rectangle_set_button(CLRectangle *r, GtkStyle *style,
GtkStateType state_type, gboolean has_default,
gboolean has_focus,
CLBorderType tl, CLBorderType tr,
CLBorderType bl, CLBorderType br)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
int my_state_type = (state_type == GTK_STATE_ACTIVE) ? 2 : 0;
GdkGC *border_gc = clearlooks_style->border_gc[CL_BORDER_UPPER+my_state_type];
cl_rectangle_init (r, style->bg_gc[state_type],
clearlooks_style->border_gc[CL_BORDER_UPPER+my_state_type],
tl, tr, bl, br);
if (state_type != GTK_STATE_INSENSITIVE && !has_default)
{
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]);
}
else if (has_default)
r->bordergc = style->black_gc;
else
r->bordergc = clearlooks_style->shade_gc[4];
r->gradient_type = CL_GRADIENT_VERTICAL;
r->topleft = (state_type != GTK_STATE_ACTIVE) ? style->light_gc[state_type] : clearlooks_style->shade_gc[4];
r->bottomright = (state_type != GTK_STATE_ACTIVE) ? clearlooks_style->shade_gc[1] : NULL;
shade (&style->bg[state_type], &r->tmp_color, 0.93);
cl_rectangle_set_gradient (&r->fill_gradient,
&style->bg[state_type],
&r->tmp_color);
}
void cl_rectangle_set_entry (CLRectangle *r, GtkStyle *style,
GtkStateType state_type,
CLBorderType tl, CLBorderType tr,
CLBorderType bl, CLBorderType br,
gboolean has_focus)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
GdkGC *bordergc;
if (has_focus)
bordergc = clearlooks_style->spot3_gc;
else if (state_type != GTK_STATE_INSENSITIVE)
bordergc = clearlooks_style->border_gc[CL_BORDER_LOWER];
else
bordergc = clearlooks_style->shade_gc[3];
cl_rectangle_init (r, style->base_gc[state_type], bordergc,
tl, tr, bl, br);
if (state_type != GTK_STATE_INSENSITIVE )
r->topleft = (has_focus) ? clearlooks_style->spot1_gc
: style->bg_gc[GTK_STATE_NORMAL];
if (has_focus)
r->bottomright = clearlooks_style->spot1_gc;
else if (state_type == GTK_STATE_INSENSITIVE)
r->bottomright = style->base_gc[state_type];
}
void cl_draw_shadow(GdkWindow *window, GtkWidget *widget, GtkStyle *style,
int x, int y, int width, int height, CLRectangle *r)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
int x1, y1, x2, y2;
if (r->bottomright != NULL)
{
x1 = x+1+(r->corners[CL_CORNER_BOTTOMLEFT]/2);
y1 = y2 = y+height-2;
x2 = x+width - 1 - (1+r->corners[CL_CORNER_BOTTOMRIGHT]/2);
gdk_draw_line (window, r->bottomright, x1, y1, x2, y2);
x1 = x2 = x+width-2;
y1 = y+1+(r->corners[CL_CORNER_TOPRIGHT]/2);
y2 = y+height - 1 - (1+r->corners[CL_CORNER_BOTTOMRIGHT]/2);
gdk_draw_line (window, r->bottomright, x1, y1, x2, y2);
}
if (r->topleft != NULL)
{
x1 = x+1+(r->corners[CL_CORNER_TOPLEFT]/2);
y1 = y2 = y+1;
x2 = x+width-1-(1+r->corners[CL_CORNER_TOPRIGHT]/2);
gdk_draw_line (window, r->topleft, x1, y1, x2, y2);
x1 = x2 = x+1;
y1 = y+1+(r->corners[CL_CORNER_TOPLEFT]/2);
y2 = y+height-1-(1+r->corners[CL_CORNER_BOTTOMLEFT]/2);
gdk_draw_line (window, r->topleft, x1, y1, x2, y2);
}
}
void cl_rectangle_set_color (CLGradient *g, GdkColor *color)
{
g->from = color;
g->to = color;
}
void cl_rectangle_set_gradient (CLGradient *g, GdkColor *from, GdkColor *to)
{
g->from = from;
g->to = to;
}
void cl_rectangle_init (CLRectangle *r,
GdkGC *fillgc, GdkGC *bordergc,
int tl, int tr, int bl, int br)
{
r->gradient_type = CL_GRADIENT_NONE;
r->border_gradient.from = r->border_gradient.to = NULL;
r->fill_gradient.from = r->fill_gradient.to = NULL;
r->fillgc = fillgc;
r->bordergc = bordergc;
r->topleft = NULL;
r->bottomright = NULL;
r->corners[CL_CORNER_TOPLEFT] = tl;
r->corners[CL_CORNER_TOPRIGHT] = tr;
r->corners[CL_CORNER_BOTTOMLEFT] = bl;
r->corners[CL_CORNER_BOTTOMRIGHT] = br;
}
void cl_rectangle_set_corners (CLRectangle *r, int tl, int tr, int bl, int br)
{
r->corners[CL_CORNER_TOPLEFT] = tl;
r->corners[CL_CORNER_TOPRIGHT] = tr;
r->corners[CL_CORNER_BOTTOMLEFT] = bl;
r->corners[CL_CORNER_BOTTOMRIGHT] = br;
}
void cl_set_corner_sharpness (const gchar *detail, GtkWidget *widget, CLRectangle *r)
{
if (widget->parent && GTK_IS_COMBO_BOX_ENTRY (widget->parent) || GTK_IS_COMBO (widget->parent))
{
gboolean rtl = get_direction (widget->parent) == GTK_TEXT_DIR_RTL;
int cl = rtl ? CL_CORNER_ROUND : CL_CORNER_NONE;
int cr = rtl ? CL_CORNER_NONE : CL_CORNER_ROUND;
cl_rectangle_set_corners (r, cl, cr, cl, cr);
}
else if (detail && !strcmp (detail, "spinbutton_up"))
{
gboolean rtl = get_direction (widget->parent) == GTK_TEXT_DIR_RTL;
int tl = rtl ? CL_CORNER_ROUND : CL_CORNER_NONE;
int tr = rtl ? CL_CORNER_NONE : CL_CORNER_ROUND;
cl_rectangle_set_corners (r, tl, tr,
CL_CORNER_NONE, CL_CORNER_NONE);
}
else if (detail && !strcmp (detail, "spinbutton_down"))
{
gboolean rtl = get_direction (widget->parent) == GTK_TEXT_DIR_RTL;
int bl = rtl ? CL_CORNER_ROUND : CL_CORNER_NONE;
int br = rtl ? CL_CORNER_NONE : CL_CORNER_ROUND;
cl_rectangle_set_corners (r, CL_CORNER_NONE, CL_CORNER_NONE,
bl, br);
}
else
{
cl_rectangle_set_corners (r, CL_CORNER_ROUND, CL_CORNER_ROUND,
CL_CORNER_ROUND, CL_CORNER_ROUND);
};
}
void cl_rectangle_set_clip_rectangle (CLRectangle *r, GdkRectangle *area)
{
if (area == NULL)
return;
if (r->fillgc)
gdk_gc_set_clip_rectangle (r->fillgc, area);
if (r->bordergc)
gdk_gc_set_clip_rectangle (r->bordergc, area);
if (r->topleft)
gdk_gc_set_clip_rectangle (r->topleft, area);
if (r->bottomright)
gdk_gc_set_clip_rectangle (r->bottomright, area);
}
void cl_rectangle_reset_clip_rectangle (CLRectangle *r)
{
if (r->fillgc)
gdk_gc_set_clip_rectangle (r->fillgc, NULL);
if (r->bordergc)
gdk_gc_set_clip_rectangle (r->bordergc, NULL);
if (r->topleft)
gdk_gc_set_clip_rectangle (r->topleft, NULL);
if (r->bottomright)
gdk_gc_set_clip_rectangle (r->bottomright, NULL);
}
void cl_rectangle_reset (CLRectangle *r, GtkStyle *style)
{
cl_rectangle_init (r,
NULL, NULL,
CL_CORNER_ROUND, CL_CORNER_ROUND,
CL_CORNER_ROUND, CL_CORNER_ROUND);
}
static void cl_progressbar_points_transform (GdkPoint *points, int npoints,
int offset, gboolean is_horizontal)
{
int i;
for ( i=0; i<npoints; i++) {
if ( is_horizontal )
points[i].x += offset;
else
points[i].y += offset;
}
}
GdkPixmap* cl_progressbar_tile_new (GdkDrawable *drawable, GtkWidget *widget,
GtkStyle *style, gint height, gint offset)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
int width = height;
int line = 0;
int center = width/2;
int xdir = 1;
int trans;
int stripe_width = height/2;
int topright = height + stripe_width;
int topright_div_2 = topright/2;
double shift;
GdkPoint points[4];
GtkProgressBarOrientation orientation = gtk_progress_bar_get_orientation (GTK_PROGRESS_BAR (widget));
gboolean is_horizontal = (orientation == GTK_PROGRESS_LEFT_TO_RIGHT || orientation == GTK_PROGRESS_RIGHT_TO_LEFT) ? 1 : 0;
GdkPixmap *tmp = gdk_pixmap_new (widget->window, width, height, -1);
GdkColor tmp_color;
shade (&clearlooks_style->spot2, &tmp_color, 0.90);
if (is_horizontal)
draw_hgradient (tmp, style->black_gc, style, 0, 0, width, height,
&clearlooks_style->spot2, &tmp_color );
else
draw_vgradient (tmp, style->black_gc, style, 0, 0, width, height,
&tmp_color, &clearlooks_style->spot2); /* TODO: swap for RTL */
if (orientation == GTK_PROGRESS_RIGHT_TO_LEFT ||
orientation == GTK_PROGRESS_BOTTOM_TO_TOP)
{
offset = -offset;
xdir = -1;
}
if (get_direction (widget) == GTK_TEXT_DIR_RTL)
offset = -offset;
if (is_horizontal)
{
points[0] = (GdkPoint){xdir*(topright - stripe_width - topright_div_2), 0}; /* topleft */
points[1] = (GdkPoint){xdir*(topright - topright_div_2), 0}; /* topright */
points[2] = (GdkPoint){xdir*(stripe_width - topright_div_2), height}; /* bottomright */
points[3] = (GdkPoint){xdir*(-topright_div_2), height}; /* bottomleft */
}
else
{
points[0] = (GdkPoint){height, xdir*(topright - stripe_width - topright_div_2)}; /* topleft */
points[1] = (GdkPoint){height, xdir*(topright - topright_div_2)}; /* topright */
points[2] = (GdkPoint){0, xdir*(stripe_width - topright_div_2)}; /* bottomright */
points[3] = (GdkPoint){0, xdir*(-topright_div_2)}; /* bottomleft */
}
shift = (stripe_width*2)/(double)10;
cl_progressbar_points_transform (points, 4, (offset*shift), is_horizontal);
trans = (width/2)-1-(stripe_width*2);
cl_progressbar_points_transform (points, 4, trans, is_horizontal);
gdk_draw_polygon (tmp, clearlooks_style->spot2_gc, TRUE, points, 4);
cl_progressbar_points_transform (points, 4, -trans, is_horizontal);
trans = width/2-1;
cl_progressbar_points_transform (points, 4, trans, is_horizontal);
gdk_draw_polygon (tmp, clearlooks_style->spot2_gc, TRUE, points, 4);
cl_progressbar_points_transform (points, 4, -trans, is_horizontal);
trans = (width/2)-1+(stripe_width*2);
cl_progressbar_points_transform (points, 4, trans, is_horizontal);
gdk_draw_polygon (tmp, clearlooks_style->spot2_gc, TRUE, points, 4);
return tmp;
}
/* could be improved, I think. */
void cl_progressbar_fill (GdkDrawable *drawable, GtkWidget *widget,
GtkStyle *style, GdkGC *gc,
gint x, gint y,
gint width, gint height,
guint8 offset, GdkRectangle *area)
{
GtkProgressBarOrientation orientation = gtk_progress_bar_get_orientation (GTK_PROGRESS_BAR (widget));
gint size = (orientation == GTK_PROGRESS_LEFT_TO_RIGHT || orientation == GTK_PROGRESS_RIGHT_TO_LEFT) ? height : width;
GdkPixmap *tile = cl_progressbar_tile_new (widget->window, widget, style, size, offset);
gint nx = x,
ny = y,
nwidth = height,
nheight = width;
gdk_gc_set_clip_rectangle (gc, area);
switch (orientation)
{
case GTK_PROGRESS_LEFT_TO_RIGHT:
{
while (nx <= x + width )
{
if (nx + nwidth > x+width ) nwidth = (x+width) - nx;
gdk_draw_drawable (drawable, gc, tile, 0, 0, nx, y, nwidth, height);
if (height <= 1)
nx += 1;
else
nx += (height-1 + !(height % 2));
}
break;
}
case GTK_PROGRESS_RIGHT_TO_LEFT:
{
gint src_x = 0, dst_x;
nx += width;
while (nx >= x )
{
dst_x = nx - height;
if (dst_x < x )
{
src_x = x - dst_x;
dst_x = x;
}
gdk_draw_drawable (drawable, gc, tile, src_x, 0, dst_x, y, nwidth, height);
if (height <= 1)
nx -= 1;
else
nx -= (height-1 + !(height % 2));
}
break;
}
case GTK_PROGRESS_TOP_TO_BOTTOM:
{
while (ny <= y + height )
{
if (ny + nheight > y+height ) nheight = (y+height) - ny;
gdk_draw_drawable (drawable, gc, tile, 0, 0, x, ny, width, nheight);
if (width <= 1)
ny += 1;
else
ny += (width-1 + !(width % 2));
}
break;
}
case GTK_PROGRESS_BOTTOM_TO_TOP:
{
gint src_y = 0, dst_y;
ny += height;
while (ny >= y )
{
dst_y = ny - width;
if (dst_y < y )
{
src_y = y - dst_y;
dst_y = y;
}
gdk_draw_drawable (drawable, gc, tile, 0, src_y, x, dst_y, width, width);
if (width <= 1)
ny -= 1;
else
ny -= (width-1 + !(width % 2));
}
break;
}
}
gdk_gc_set_clip_rectangle (gc, NULL);
g_object_unref (tile);
}
GdkColor cl_gc_set_fg_color_shade (GdkGC *gc, GdkColormap *colormap,
GdkColor *from, gfloat s)
{
GdkColor tmp_color;
GdkGCValues values;
shade (from, &tmp_color, s);
gdk_gc_get_values (gc, &values);
gdk_rgb_find_color (colormap, &tmp_color);
gdk_gc_set_foreground (gc, &tmp_color);
return values.foreground;
}
/* #warning MOVE THIS TO SUPPORT.C/H SO THE DRAW_CORNER FUNCTION CAN USE IT. OR, MAKE DRAW_CORNER USE IT SOME OTHER WAY. */
static void cl_get_window_style_state (GtkWidget *widget, GtkStyle **style, GtkStateType *state_type)
{
GtkStyle *windowstyle = NULL;
GtkWidget *tmpwidget = widget;
GtkStateType windowstate;
if (widget && GTK_IS_ENTRY (widget))
tmpwidget = tmpwidget->parent;
while (tmpwidget && GTK_WIDGET_NO_WINDOW (tmpwidget) && !GTK_IS_NOTEBOOK(tmpwidget))
{
tmpwidget = tmpwidget->parent;
}
*style = tmpwidget->style;
*state_type = GTK_WIDGET_STATE(tmpwidget);
}
static GdkGC *cl_get_window_bg_gc (GtkWidget *widget)
{
GtkStyle *style;
GtkStateType state_type;
cl_get_window_style_state (widget, &style, &state_type);
return style->bg_gc[state_type];
}
/******************************************************************************
* DRAW THE MIGHTY WIDGETS! *
******************************************************************************/
void cl_draw_inset (GtkStyle *style, GdkWindow *window, GtkWidget *widget,
GdkRectangle *area,
gint x, gint y, gint width, gint height,
int tl, int tr, int bl, int br )
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE(style);
ClearlooksStyle *clwindowstyle; /* style of the window this widget is on */
GtkStateType windowstate;
CLRectangle r;
cl_rectangle_init (&r, NULL, style->black_gc,
tl, tr, bl, br);
r.gradient_type = CL_GRADIENT_VERTICAL;
cl_get_window_style_state(widget, (GtkStyle**)&clwindowstyle, &windowstate);
g_assert (clwindowstyle != NULL);
if (GTK_WIDGET_HAS_DEFAULT (widget))
{
r.bordergc = style->mid_gc[GTK_STATE_NORMAL];
}
else
{
cl_rectangle_set_gradient (&r.border_gradient,
&clwindowstyle->inset_dark[windowstate],
&clwindowstyle->inset_light[windowstate]);
}
cl_rectangle_set_clip_rectangle (&r, area);
cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
cl_rectangle_reset_clip_rectangle (&r);
}
/* Draw a normal (toggle)button. Not spinbuttons.*/
void cl_draw_button(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)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE(style);
int my_state_type = (state_type == GTK_STATE_ACTIVE) ? 2 : 0;
GdkGC *bg_gc = NULL;
gboolean is_active = FALSE;
CLRectangle r;
/* Get the background color of the window we're on */
bg_gc = cl_get_window_bg_gc(widget);
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 (state_type == GTK_STATE_ACTIVE)
is_active = TRUE;
if (GTK_IS_TOGGLE_BUTTON(widget) &&
gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget)) &&
state_type == GTK_STATE_PRELIGHT)
{
cl_rectangle_set_gradient (&r.fill_gradient, &clearlooks_style->shade[1], &clearlooks_style->shade[1]);
r.topleft = clearlooks_style->shade_gc[3];
r.bottomright = clearlooks_style->shade_gc[1];
is_active = TRUE;
}
if (!is_active)
r.fillgc = NULL;
if (!GTK_IS_NOTEBOOK (widget->parent))
{
gdk_draw_rectangle (window, bg_gc, FALSE, x, y, width-1, height-1);
/* Draw "sunken" look when border thickness is more than 2 pixels. */
if (style->xthickness > 2 && style->ythickness > 2)
cl_draw_inset (style, window, widget, area, x, y, width, height,
CL_CORNER_ROUND, CL_CORNER_ROUND,
CL_CORNER_ROUND, CL_CORNER_ROUND);
}
/* Draw "sunken" look when border thickness is more than 2 pixels.*/
if (style->xthickness > 2 && style->ythickness > 2)
{
x++;
y++;
height-=2;
width-=2;
}
/* Don't draw the normal gradient for normal buttons. */
cl_rectangle_set_clip_rectangle (&r, area);
cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
if (!is_active)
{
int tmp_height = (float)height*0.25;
gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
draw_hgradient (window, style->bg_gc[state_type], style,
x+2,y+2,width-4,tmp_height,
&clearlooks_style->button_g1[state_type],
&clearlooks_style->button_g2[state_type]);
draw_hgradient (window, style->bg_gc[state_type], style,
x+2, y+2+tmp_height, width-4, height-3-tmp_height*2,
&clearlooks_style->button_g2[state_type],
&clearlooks_style->button_g3[state_type]);
draw_hgradient (window, style->bg_gc[state_type], style,
x+2,y+height-tmp_height-1,width-4,tmp_height,
&clearlooks_style->button_g3[state_type],
&clearlooks_style->button_g4[state_type]);
gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
}
cl_draw_shadow (window, widget, style, x, y, width, height, &r);
cl_rectangle_reset_clip_rectangle (&r);
}
/* Draw spinbuttons. */
void cl_draw_spinbutton(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)
{
CLRectangle r;
GdkRectangle new_area;
int tl = CL_CORNER_NONE, tr = CL_CORNER_NONE,
bl = CL_CORNER_NONE, br = CL_CORNER_NONE;
if (area == NULL)
{
new_area.x = x;
new_area.y = y;
new_area.width = width;
new_area.height = height;
area = &new_area;
}
if (!strcmp (detail, "spinbutton")) /* draws the 'back' of the spinbutton */
{
GdkGC *bg_gc = cl_get_window_bg_gc(widget);
gdk_gc_set_clip_rectangle (bg_gc, area);
gdk_draw_rectangle (window, bg_gc, FALSE, x, y, width-1, height-1);
gdk_gc_set_clip_rectangle (bg_gc, NULL);
if (style->xthickness > 2 && style->ythickness > 2)
cl_draw_inset (style, window, widget, area, x, y, width, height,
CL_CORNER_NONE, CL_CORNER_ROUND,
CL_CORNER_NONE, CL_CORNER_ROUND);
return;
}
if (!strcmp (detail, "spinbutton_up"))
{
tr = CL_CORNER_ROUND;
(style->xthickness > 2 && style->ythickness > 2) ? y++ : height++;
}
if (!strcmp (detail, "spinbutton_down"))
{
br = CL_CORNER_ROUND;
if (style->xthickness > 2 && style->ythickness > 2)
height--;
}
cl_rectangle_set_button (&r, style, state_type,
GTK_WIDGET_HAS_DEFAULT (widget),
GTK_WIDGET_HAS_FOCUS (widget),
tl, tr,
bl, br);
width--;
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);
}
void cl_draw_combobox_entry (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)
{
CLRectangle r;
gboolean rtl = get_direction (widget->parent) == GTK_TEXT_DIR_RTL;
gboolean has_focus = GTK_WIDGET_HAS_FOCUS (widget);
int cl = rtl ? CL_CORNER_NONE : CL_CORNER_ROUND,
cr = rtl ? CL_CORNER_ROUND : CL_CORNER_NONE;
GdkGC *bg_gc = cl_get_window_bg_gc(widget);
if (rtl)
{
if (!has_focus)
{
x -= 1;
width +=1;
}
}
else
{
width += 2;
if (has_focus) width--; /* this gives us a 2px focus line at the right side. */
}
cl_rectangle_set_entry (&r, style, state_type,
cl, cr, cl, cr,
has_focus);
gdk_gc_set_clip_rectangle (bg_gc, area);
gdk_draw_rectangle (window, bg_gc, FALSE, x, y, width-1, height-1);
gdk_gc_set_clip_rectangle (bg_gc, NULL);
/* Draw "sunken" look when border thickness is more than 2 pixels. */
if (style->xthickness > 2 && style->ythickness > 2)
{
cl_draw_inset (style, window, widget, area, x, y, width, height,
cl, cr, cl, cr);
y++;
x++;
width-=2;
height-=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);
}
void cl_draw_combobox_button (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)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE(style);
gboolean is_active = FALSE;
gboolean draw_inset = FALSE;
CLRectangle r;
cl_rectangle_set_button (&r, style, state_type,
GTK_WIDGET_HAS_DEFAULT (widget),
GTK_WIDGET_HAS_FOCUS (widget),
CL_CORNER_NONE, CL_CORNER_ROUND,
CL_CORNER_NONE, CL_CORNER_ROUND);
if (state_type == GTK_STATE_ACTIVE)
is_active = TRUE;
else
r.fillgc = NULL;
/* Seriously, why can't non-gtk-apps at least try to be decent citizens?
Take this fscking OpenOffice.org 1.9 for example. The morons responsible
for this utter piece of crap give the clip size wrong values! :'( */
if (area)
{
area->x = x;
area->y = y;
area->width = width;
area->height = height;
}
x--;
width++;
/* Draw "sunken" look when border thickness is more than 2 pixels. */
if (GTK_IS_COMBO(widget->parent))
draw_inset = (widget->parent->style->xthickness > 2 &&
widget->parent->style->ythickness > 2);
else
draw_inset = (style->xthickness > 2 && style->ythickness > 2);
if (draw_inset)
{
cl_draw_inset (style, window, widget, area, x, y, width, height,
CL_CORNER_NONE, CL_CORNER_ROUND,
CL_CORNER_NONE, CL_CORNER_ROUND);
x++;
y++;
height-=2;
width-=2;
}
else
{
x++;
width--;
}
if (area)
cl_rectangle_set_clip_rectangle (&r, area);
cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
if (!is_active)
{
int tmp_height = (float)height*0.25;
gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
draw_hgradient (window, style->bg_gc[state_type], style,
x+2,y+2,width-4,tmp_height,
&clearlooks_style->button_g1[state_type],
&clearlooks_style->button_g2[state_type]);
draw_hgradient (window, style->bg_gc[state_type], style,
x+2, y+2+tmp_height, width-4, height-3-tmp_height*2,
&clearlooks_style->button_g2[state_type],
&clearlooks_style->button_g3[state_type]);
draw_hgradient (window, style->bg_gc[state_type], style,
x+2,y+height-tmp_height-1,width-4,tmp_height,
&clearlooks_style->button_g3[state_type],
&clearlooks_style->button_g4[state_type]);
gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
}
cl_draw_shadow (window, widget, style, x, y, width, height, &r);
if (area)
cl_rectangle_reset_clip_rectangle (&r);
}
/* Draw text Entry */
void cl_draw_entry (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)
{
CLRectangle r;
gboolean has_focus = GTK_WIDGET_HAS_FOCUS(widget);
GdkGC *bg_gc = cl_get_window_bg_gc(widget);
gdk_draw_rectangle (window, bg_gc, FALSE, x, y, width-1, height-1);
gtk_style_apply_default_background (style, window, TRUE, state_type,
area, x+1, y+1, width-2, height-2);
cl_rectangle_set_entry (&r, style, state_type,
CL_CORNER_ROUND, CL_CORNER_ROUND,
CL_CORNER_ROUND, CL_CORNER_ROUND,
has_focus);
/* Draw "sunken" look when border thickness is more than 2 pixels. */
if (style->xthickness > 2 && style->ythickness > 2)
{
cl_draw_inset (style, window, widget, area, x, y, width, height,
CL_CORNER_ROUND, CL_CORNER_ROUND,
CL_CORNER_ROUND, CL_CORNER_ROUND);
x++;
y++;
width-=2;
height-=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);
}
void cl_draw_optionmenu(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)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE(style);
GtkRequisition indicator_size;
GtkBorder indicator_spacing;
int line_pos;
option_menu_get_props (widget, &indicator_size, &indicator_spacing);
if (get_direction (widget) == GTK_TEXT_DIR_RTL)
line_pos = x + (indicator_size.width + indicator_spacing.left + indicator_spacing.right) + style->xthickness;
else
line_pos = x + width - (indicator_size.width + indicator_spacing.left + indicator_spacing.right) - style->xthickness;
cl_draw_button (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
gdk_draw_line (window, clearlooks_style->shade_gc[3],
line_pos, y + style->ythickness - 1, line_pos,
y + height - style->ythickness);
gdk_draw_line (window, style->light_gc[state_type],
line_pos+1, y + style->ythickness - 1, line_pos+1,
y + height - style->ythickness);
}
void cl_draw_menuitem_button (GdkDrawable *window, GtkWidget *widget, GtkStyle *style,
GdkRectangle *area, GtkStateType state_type,
int x, int y, int width, int height, CLRectangle *r)
{
ClearlooksStyle *clearlooks_style = (ClearlooksStyle*)style;
gboolean menubar = (widget->parent && GTK_IS_MENU_BAR(widget->parent)) ? TRUE : FALSE;
int corner = CL_CORNER_NARROW;
GdkColor lower_color;
shade (&style->base[GTK_STATE_SELECTED], &lower_color, 0.85);
if (menubar)
{
height++;
corner = CL_CORNER_NONE;
r->bordergc = clearlooks_style->border_gc[CL_BORDER_UPPER];
}
else
{
r->bordergc = clearlooks_style->spot3_gc;
}
cl_rectangle_set_corners (r, corner, corner, corner, corner);
cl_rectangle_set_gradient (&r->fill_gradient,
&style->base[GTK_STATE_SELECTED], &lower_color);
r->gradient_type = CL_GRADIENT_VERTICAL;
r->fillgc = clearlooks_style->spot2_gc;
r->topleft = clearlooks_style->spot1_gc;
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);
}
void cl_draw_menuitem_flat (GdkDrawable *window, GtkWidget *widget, GtkStyle *style,
GdkRectangle *area, GtkStateType state_type,
int x, int y, int width, int height, CLRectangle *r)
{
ClearlooksStyle *clearlooks_style = (ClearlooksStyle*)style;
gboolean menubar = (widget->parent && GTK_IS_MENU_BAR(widget->parent)) ? TRUE : FALSE;
GdkColor tmp;
cl_rectangle_set_corners (r, CL_CORNER_NARROW, CL_CORNER_NARROW,
CL_CORNER_NARROW, CL_CORNER_NARROW);
tmp = cl_gc_set_fg_color_shade (style->black_gc, style->colormap,
&style->base[GTK_STATE_PRELIGHT], 0.8);
r->bordergc = style->black_gc;
r->fillgc = style->base_gc[GTK_STATE_PRELIGHT];
if (menubar) height++;
cl_rectangle_set_clip_rectangle (r, area);
cl_draw_rectangle (window, widget, style, x, y, width, height, r);
cl_rectangle_reset_clip_rectangle (r);
gdk_gc_set_foreground (style->black_gc, &tmp);
}
void cl_draw_menuitem_gradient (GdkDrawable *window, GtkWidget *widget, GtkStyle *style,
GdkRectangle *area, GtkStateType state_type,
int x, int y, int width, int height, CLRectangle *r)
{
ClearlooksStyle *clearlooks_style = (ClearlooksStyle*)style;
gboolean menubar = (widget->parent && GTK_IS_MENU_BAR(widget->parent)) ? TRUE : FALSE;
GdkColor tmp;
GdkColor lower_color;
shade (&style->base[GTK_STATE_SELECTED], &lower_color, 0.8);
cl_rectangle_set_corners (r, CL_CORNER_NARROW, CL_CORNER_NARROW,
CL_CORNER_NARROW, CL_CORNER_NARROW);
cl_rectangle_set_gradient (&r->fill_gradient,
&style->base[GTK_STATE_SELECTED], &lower_color);
r->gradient_type = CL_GRADIENT_VERTICAL;
tmp = cl_gc_set_fg_color_shade (style->black_gc, style->colormap,
&style->base[GTK_STATE_PRELIGHT], 0.8);
r->bordergc = style->black_gc;
r->fillgc = style->base_gc[GTK_STATE_PRELIGHT];
if (menubar) height++;
cl_rectangle_set_clip_rectangle (r, area);
cl_draw_rectangle (window, widget, style, x, y, width, height, r);
cl_rectangle_reset_clip_rectangle (r);
gdk_gc_set_foreground (style->black_gc, &tmp);
}
void cl_draw_treeview_header (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)
{
ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
gint columns = 0, column_index = -1, fill_width = width;
gboolean is_etree = strcmp("ETree", G_OBJECT_TYPE_NAME(widget->parent)) == 0;
gboolean resizable = TRUE;
GdkGC *bottom = clearlooks_style->shade_gc[5];
if ( width < 2 || height < 2 )
return;
if (GTK_IS_TREE_VIEW (widget->parent))
{
gtk_treeview_get_header_index (GTK_TREE_VIEW(widget->parent),
widget, &column_index, &columns,
&resizable);
}
else if (GTK_IS_CLIST (widget->parent))
{
gtk_clist_get_header_index (GTK_CLIST(widget->parent),
widget, &column_index, &columns);
}
if (area)
{
gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], area);
gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[4], area);
gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[5], area);
}
if (state_type != GTK_STATE_NORMAL)
fill_width-=2;
gdk_draw_rectangle (window, style->bg_gc[state_type], TRUE, x, y, fill_width, height-(height/3)+1);
draw_hgradient (window, style->bg_gc[state_type], style,
x, 1+y+height-(height/3), fill_width, height/3,
&style->bg[state_type], &clearlooks_style->inset_dark[state_type]);
if (resizable || (column_index != columns-1))
{
gdk_draw_line (window, clearlooks_style->shade_gc[4], x+width-2, y+4, x+width-2, y+height-5);
gdk_draw_line (window, clearlooks_style->shade_gc[0], x+width-1, y+4, x+width-1, y+height-5);
}
/* left light line */
if (column_index == 0)
gdk_draw_line (window, clearlooks_style->shade_gc[0], x, y+1, x, y+height-2);
/* top light line */
gdk_draw_line (window, clearlooks_style->shade_gc[0], x, y, x+width-1, y);
/* bottom dark line */
if (state_type == GTK_STATE_INSENSITIVE)
bottom = clearlooks_style->shade_gc[3];
gdk_draw_line (window, bottom, x, y+height-1, x+width-1, 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[4], NULL);
gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[5], NULL);
}
}
View Git Blame Copy Permalink