?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
use -r argument with JACK if realtime is not requested in engine dialog (also applied...
[ArdourMidi.git] / libs / clearlooks-older / clearlooks_draw.c
blob144be35152fd689277f1e1ff58b43b5ccb169649
1 #include "clearlooks_draw.h"
2 #include "clearlooks_style.h"
3
4 #include "support.h"
5
6 /** WANTED:
7 FASTER GRADIENT FILL FUNCTION, POSSIBLY USING XRENDER. **/
8
9 static void cl_draw_borders (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
10 int x, int y, int width, int height, CLRectangle *r);
11
12 static void cl_draw_line (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
13 int x1, int y1, int x2, int y2, CLBorderType border,
14 CLRectangle *r);
15
16 static void cl_draw_corner (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
17 int x, int y, int width, int height,
18 CLRectangle *r, CLCornerSide corner);
19
20 static void cl_draw_fill (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
21 int x, int y, int width, int height, CLRectangle *r);
22
23 void cl_draw_rectangle (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
24 int x, int y, int width, int height, CLRectangle *r)
25 {
26 if (r->fillgc)
27 {
28 cl_draw_fill(window, widget, style, x, y, width, height, r);
29 }
30
31 if (r->bordergc)
32 {
33 cl_draw_borders(window, widget, style, x, y, width, height, r);
34 }
35 }
36
37
38 static void cl_get_coords ( CLBorderType border,
39 int x, int y, int width, int height,
40 CLRectangle *r, int *x1, int *y1, int *x2, int *y2)
41 {
42 switch (border)
43 {
44 case CL_BORDER_TOP:
45 *x1 = x + r->corners[CL_CORNER_TOPLEFT];
46 *x2 = *x1 + width - r->corners[CL_CORNER_TOPLEFT] - r->corners[CL_CORNER_TOPRIGHT] - 1;
47 *y1 = *y2 = y;
48 break;
49 case CL_BORDER_BOTTOM:
50 *x1 = x + r->corners[CL_CORNER_BOTTOMLEFT];
51 *x2 = *x1 + width - r->corners[CL_CORNER_BOTTOMLEFT] - r->corners[CL_CORNER_BOTTOMRIGHT] - 1;
52 *y1 = *y2 = y + height - 1;
53 break;
54 case CL_BORDER_LEFT:
55 *x1 = *x2 = x;
56 *y1 = y + r->corners[CL_CORNER_TOPLEFT];
57 *y2 = *y1 + height - r->corners[CL_CORNER_TOPLEFT] - r->corners[CL_CORNER_BOTTOMLEFT] - 1;
58 break;
59 case CL_BORDER_RIGHT:
60 *x1 = *x2 = x + width - 1;
61 *y1 = y + r->corners[CL_CORNER_TOPRIGHT];
62 *y2 = *y1 + height - r->corners[CL_CORNER_TOPRIGHT] - r->corners[CL_CORNER_BOTTOMRIGHT] - 1;
63 break;
64 }
65 }
66
67 void cl_draw_borders (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
68 int x, int y, int width, int height, CLRectangle *r)
69 {
70 int x1, y1, x2, y2, i;
71
72 if (r->bordergc == NULL)
73 return;
74
75 for ( i=0; i<4; i++) /* draw all four borders + corners */
76 {
77 cl_get_coords (i, x, y, width, height, r, &x1, &y1, &x2, &y2);
78 cl_draw_line (window, widget, style, x1, y1, x2, y2, i, r);
79 cl_draw_corner (window, widget, style, x, y, width, height, r, i );
80 }
81 }
82
83
84 static GdkColor cl_gc_get_foreground(GdkGC *gc)
85 {
86 GdkGCValues values;
87 gdk_gc_get_values (gc, &values);
88 return values.foreground;
89 }
90
91 static void cl_draw_line (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
92 int x1, int y1, int x2, int y2, CLBorderType border,
93 CLRectangle *r)
94 {
95 if (r->gradient_type == CL_GRADIENT_NONE ||
96 r->border_gradient.from == NULL || r->border_gradient.to == NULL )
97 {
98 gdk_draw_line (window, r->bordergc, x1, y1, x2, y2);
99 }
100 else if (r->gradient_type == CL_GRADIENT_HORIZONTAL && (border == CL_BORDER_TOP || border == CL_BORDER_BOTTOM))
101 {
102 draw_vgradient (window, r->bordergc, style,
103 x1, y1, x2-x1+1, 1,
104 r->border_gradient.from, r->border_gradient.to);
105 }
106 else if (r->gradient_type == CL_GRADIENT_VERTICAL && (border == CL_BORDER_LEFT || border == CL_BORDER_RIGHT))
107 {
108 draw_hgradient (window, r->bordergc, style,
109 x1, y1, 1, y2-y1+1,
110 r->border_gradient.from, r->border_gradient.to);
111 }
112 else
113 {
114 GdkColor tmp_color = cl_gc_get_foreground (r->bordergc);
115
116 if (r->gradient_type == CL_GRADIENT_HORIZONTAL && border == CL_BORDER_LEFT ||
117 r->gradient_type == CL_GRADIENT_VERTICAL && border == CL_BORDER_TOP)
118 gdk_gc_set_foreground (r->bordergc, r->border_gradient.from);
119 else
120 gdk_gc_set_foreground (r->bordergc, r->border_gradient.to);
121
122 gdk_draw_line (window, r->bordergc, x1, y1, x2, y2);
123
124 gdk_gc_set_foreground (r->bordergc, &tmp_color);
125 }
126 }
127
128 static GdkColor *cl_get_gradient_corner_color (CLRectangle *r, CLCornerSide corner)
129 {
130 GdkColor *color;
131
132 if (r->border_gradient.from == NULL || r->border_gradient.to == NULL)
133 {
134 color = NULL;
135 }
136 else if ((r->gradient_type == CL_GRADIENT_HORIZONTAL && (corner == CL_CORNER_TOPLEFT || corner == CL_CORNER_BOTTOMLEFT)) ||
137 (r->gradient_type == CL_GRADIENT_VERTICAL && (corner == CL_CORNER_TOPLEFT || corner == CL_CORNER_TOPRIGHT)))
138 {
139 color = r->border_gradient.from;
140 }
141 else /* no gradient or other corner */
142 {
143 color = r->border_gradient.to;
144 }
145
146 return color;
147 }
148
149 static void cl_draw_corner (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
150 int x, int y, int width, int height,
151 CLRectangle *r, CLCornerSide corner)
152 {
153 GdkColor *color;
154 GdkColor aacolor; /* anti-aliasing color */
155 GdkGCValues values;
156 GdkColor tmp;
157 GdkColor *bgcolor;
158
159 int x1;
160 int y1;
161
162 if (r->corners[corner] == CL_CORNER_NONE)
163 return;
164
165 color = cl_get_gradient_corner_color (r, corner);
166 gdk_gc_get_values (r->bordergc, &values);
167
168 if (color == NULL)
169 {
170 tmp = values.foreground;
171 gdk_colormap_query_color (gtk_widget_get_colormap(widget), values.foreground.pixel, &tmp);
172 color = &tmp;
173 }
174
175 bgcolor = get_parent_bgcolor(widget);
176
177 if (bgcolor == NULL)
178 {
179 bgcolor = color;
180 }
181
182 blend (style->colormap, bgcolor, color, &aacolor, 70);
183
184 if (r->corners[corner] == CL_CORNER_ROUND)
185 {
186 x1 = (corner == CL_CORNER_TOPLEFT ||
187 corner == CL_CORNER_BOTTOMLEFT) ? x+1 : x+width - 2;
188
189 y1 = (corner == CL_CORNER_TOPLEFT ||
190 corner == CL_CORNER_TOPRIGHT) ? y+1 : y+height - 2;
191
192 gdk_gc_set_foreground (r->bordergc, color);
193 gdk_draw_point (window, r->bordergc, x1, y1);
194
195 gdk_gc_set_foreground (r->bordergc, &aacolor);
196
197 x1 = (corner == CL_CORNER_TOPLEFT ||
198 corner == CL_CORNER_BOTTOMLEFT) ? x+1 : x+width-2;
199
200 y1 = (corner == CL_CORNER_TOPLEFT ||
201 corner == CL_CORNER_TOPRIGHT) ? y : y+height-1;
202
203 gdk_draw_point (window, r->bordergc, x1, y1);
204
205 x1 = (corner == CL_CORNER_TOPLEFT ||
206 corner == CL_CORNER_BOTTOMLEFT) ? x : x+width-1;
207
208 y1 = (corner == CL_CORNER_TOPLEFT ||
209 corner == CL_CORNER_TOPRIGHT) ? y+1 : y+height-2;
210
211 gdk_draw_point (window, r->bordergc, x1, y1);
212
213 }
214 else if (r->corners[corner] == CL_CORNER_NARROW)
215 {
216 x1 = (corner == CL_CORNER_TOPLEFT ||
217 corner == CL_CORNER_BOTTOMLEFT) ? x : x+width-1;
218
219 y1 = (corner == CL_CORNER_TOPLEFT ||
220 corner == CL_CORNER_TOPRIGHT) ? y : y+height-1;
221
222 gdk_gc_set_foreground (r->bordergc, &aacolor);
223 gdk_draw_point (window, r->bordergc, x1, y1);
224 }
225
226 gdk_gc_set_foreground (r->bordergc, &values.foreground);
227 }
228
229 static void cl_draw_fill (GdkWindow *window, GtkWidget *widget, GtkStyle *style,
230 int x, int y, int width, int height, CLRectangle *r)
231 {
232 if (r->gradient_type == CL_GRADIENT_NONE ||
233 r->fill_gradient.from == NULL || r->fill_gradient.to == NULL)
234 {
235 gdk_draw_rectangle (window, r->fillgc, TRUE,
236 x+1, y+1, width-2, height-2);
237 }
238 else if (r->gradient_type == CL_GRADIENT_HORIZONTAL)
239 {
240 draw_vgradient (window, r->fillgc, gtk_widget_get_style(widget),
241 x+1, y+1, width-2, height-2,
242 r->fill_gradient.from, r->fill_gradient.to);
243 }
244 else if (r->gradient_type == CL_GRADIENT_VERTICAL)
245 {
246 draw_hgradient (window, r->fillgc, gtk_widget_get_style(widget),
247 x+1, y+1, width-2, height-2,
248 r->fill_gradient.from, r->fill_gradient.to);
249 }
250 }
251
252 void cl_rectangle_set_button(CLRectangle *r, GtkStyle *style,
253 GtkStateType state_type, gboolean has_default,
254 gboolean has_focus,
255 CLBorderType tl, CLBorderType tr,
256 CLBorderType bl, CLBorderType br)
257 {
258 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
259 int my_state_type = (state_type == GTK_STATE_ACTIVE) ? 2 : 0;
260 GdkGC *border_gc = clearlooks_style->border_gc[CL_BORDER_UPPER+my_state_type];
261
262
263 cl_rectangle_init (r, style->bg_gc[state_type],
264 clearlooks_style->border_gc[CL_BORDER_UPPER+my_state_type],
265 tl, tr, bl, br);
266
267 if (state_type != GTK_STATE_INSENSITIVE && !has_default)
268 {
269 cl_rectangle_set_gradient (&r->border_gradient,
270 &clearlooks_style->border[CL_BORDER_UPPER+my_state_type],
271 &clearlooks_style->border[CL_BORDER_LOWER+my_state_type]);
272 }
273 else if (has_default)
274 r->bordergc = style->black_gc;
275 else
276 r->bordergc = clearlooks_style->shade_gc[4];
277
278 r->gradient_type = CL_GRADIENT_VERTICAL;
279
280 r->topleft = (state_type != GTK_STATE_ACTIVE) ? style->light_gc[state_type] : clearlooks_style->shade_gc[4];
281 r->bottomright = (state_type != GTK_STATE_ACTIVE) ? clearlooks_style->shade_gc[1] : NULL;
282
283 shade (&style->bg[state_type], &r->tmp_color, 0.93);
284
285
286 cl_rectangle_set_gradient (&r->fill_gradient,
287 &style->bg[state_type],
288 &r->tmp_color);
289 }
290
291 void cl_rectangle_set_entry (CLRectangle *r, GtkStyle *style,
292 GtkStateType state_type,
293 CLBorderType tl, CLBorderType tr,
294 CLBorderType bl, CLBorderType br,
295 gboolean has_focus)
296 {
297 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
298 GdkGC *bordergc;
299
300 if (has_focus)
301 bordergc = clearlooks_style->spot3_gc;
302 else if (state_type != GTK_STATE_INSENSITIVE)
303 bordergc = clearlooks_style->border_gc[CL_BORDER_LOWER];
304 else
305 bordergc = clearlooks_style->shade_gc[3];
306
307 cl_rectangle_init (r, style->base_gc[state_type], bordergc,
308 tl, tr, bl, br);
309
310 if (state_type != GTK_STATE_INSENSITIVE )
311 r->topleft = (has_focus) ? clearlooks_style->spot1_gc
312 : style->bg_gc[GTK_STATE_NORMAL];
313
314 if (has_focus)
315 r->bottomright = clearlooks_style->spot1_gc;
316 else if (state_type == GTK_STATE_INSENSITIVE)
317 r->bottomright = style->base_gc[state_type];
318 }
319
320 void cl_draw_shadow(GdkWindow *window, GtkWidget *widget, GtkStyle *style,
321 int x, int y, int width, int height, CLRectangle *r)
322 {
323 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
324 int x1, y1, x2, y2;
325
326 if (r->bottomright != NULL)
327 {
328 x1 = x+1+(r->corners[CL_CORNER_BOTTOMLEFT]/2);
329 y1 = y2 = y+height-2;
330 x2 = x+width - 1 - (1+r->corners[CL_CORNER_BOTTOMRIGHT]/2);
331
332 gdk_draw_line (window, r->bottomright, x1, y1, x2, y2);
333
334 x1 = x2 = x+width-2;
335 y1 = y+1+(r->corners[CL_CORNER_TOPRIGHT]/2);
336 y2 = y+height - 1 - (1+r->corners[CL_CORNER_BOTTOMRIGHT]/2);
337
338 gdk_draw_line (window, r->bottomright, x1, y1, x2, y2);
339 }
340
341 if (r->topleft != NULL)
342 {
343 x1 = x+1+(r->corners[CL_CORNER_TOPLEFT]/2);
344 y1 = y2 = y+1;
345 x2 = x+width-1-(1+r->corners[CL_CORNER_TOPRIGHT]/2);
346
347 gdk_draw_line (window, r->topleft, x1, y1, x2, y2);
348
349 x1 = x2 = x+1;
350 y1 = y+1+(r->corners[CL_CORNER_TOPLEFT]/2);
351 y2 = y+height-1-(1+r->corners[CL_CORNER_BOTTOMLEFT]/2);
352
353 gdk_draw_line (window, r->topleft, x1, y1, x2, y2);
354 }
355 }
356
357 void cl_rectangle_set_color (CLGradient *g, GdkColor *color)
358 {
359 g->from = color;
360 g->to = color;
361 }
362
363 void cl_rectangle_set_gradient (CLGradient *g, GdkColor *from, GdkColor *to)
364 {
365 g->from = from;
366 g->to = to;
367 }
368
369 void cl_rectangle_init (CLRectangle *r,
370 GdkGC *fillgc, GdkGC *bordergc,
371 int tl, int tr, int bl, int br)
372 {
373 r->gradient_type = CL_GRADIENT_NONE;
374
375 r->border_gradient.from = r->border_gradient.to = NULL;
376 r->fill_gradient.from = r->fill_gradient.to = NULL;
377
378 r->fillgc = fillgc;
379 r->bordergc = bordergc;
380
381 r->topleft = NULL;
382 r->bottomright = NULL;
383
384 r->corners[CL_CORNER_TOPLEFT] = tl;
385 r->corners[CL_CORNER_TOPRIGHT] = tr;
386 r->corners[CL_CORNER_BOTTOMLEFT] = bl;
387 r->corners[CL_CORNER_BOTTOMRIGHT] = br;
388 }
389
390 void cl_rectangle_set_corners (CLRectangle *r, int tl, int tr, int bl, int br)
391 {
392 r->corners[CL_CORNER_TOPLEFT] = tl;
393 r->corners[CL_CORNER_TOPRIGHT] = tr;
394 r->corners[CL_CORNER_BOTTOMLEFT] = bl;
395 r->corners[CL_CORNER_BOTTOMRIGHT] = br;
396 }
397
398 void cl_set_corner_sharpness (const gchar *detail, GtkWidget *widget, CLRectangle *r)
399 {
400 if (widget->parent && GTK_IS_COMBO_BOX_ENTRY (widget->parent) || GTK_IS_COMBO (widget->parent))
401 {
402 gboolean rtl = get_direction (widget->parent) == GTK_TEXT_DIR_RTL;
403 int cl = rtl ? CL_CORNER_ROUND : CL_CORNER_NONE;
404 int cr = rtl ? CL_CORNER_NONE : CL_CORNER_ROUND;
405
406 cl_rectangle_set_corners (r, cl, cr, cl, cr);
407 }
408 else if (detail && !strcmp (detail, "spinbutton_up"))
409 {
410 gboolean rtl = get_direction (widget->parent) == GTK_TEXT_DIR_RTL;
411 int tl = rtl ? CL_CORNER_ROUND : CL_CORNER_NONE;
412 int tr = rtl ? CL_CORNER_NONE : CL_CORNER_ROUND;
413
414 cl_rectangle_set_corners (r, tl, tr,
415 CL_CORNER_NONE, CL_CORNER_NONE);
416 }
417 else if (detail && !strcmp (detail, "spinbutton_down"))
418 {
419 gboolean rtl = get_direction (widget->parent) == GTK_TEXT_DIR_RTL;
420 int bl = rtl ? CL_CORNER_ROUND : CL_CORNER_NONE;
421 int br = rtl ? CL_CORNER_NONE : CL_CORNER_ROUND;
422
423 cl_rectangle_set_corners (r, CL_CORNER_NONE, CL_CORNER_NONE,
424 bl, br);
425 }
426 else
427 {
428 cl_rectangle_set_corners (r, CL_CORNER_ROUND, CL_CORNER_ROUND,
429 CL_CORNER_ROUND, CL_CORNER_ROUND);
430 };
431 }
432
433 void cl_rectangle_set_clip_rectangle (CLRectangle *r, GdkRectangle *area)
434 {
435 if (area == NULL)
436 return;
437
438 if (r->fillgc)
439 gdk_gc_set_clip_rectangle (r->fillgc, area);
440
441 if (r->bordergc)
442 gdk_gc_set_clip_rectangle (r->bordergc, area);
443
444 if (r->topleft)
445 gdk_gc_set_clip_rectangle (r->topleft, area);
446
447 if (r->bottomright)
448 gdk_gc_set_clip_rectangle (r->bottomright, area);
449 }
450
451 void cl_rectangle_reset_clip_rectangle (CLRectangle *r)
452 {
453 if (r->fillgc)
454 gdk_gc_set_clip_rectangle (r->fillgc, NULL);
455
456 if (r->bordergc)
457 gdk_gc_set_clip_rectangle (r->bordergc, NULL);
458
459 if (r->topleft)
460 gdk_gc_set_clip_rectangle (r->topleft, NULL);
461
462 if (r->bottomright)
463 gdk_gc_set_clip_rectangle (r->bottomright, NULL);
464 }
465
466 void cl_rectangle_reset (CLRectangle *r, GtkStyle *style)
467 {
468 cl_rectangle_init (r,
469 NULL, NULL,
470 CL_CORNER_ROUND, CL_CORNER_ROUND,
471 CL_CORNER_ROUND, CL_CORNER_ROUND);
472 }
473
474 static void cl_progressbar_points_transform (GdkPoint *points, int npoints,
475 int offset, gboolean is_horizontal)
476 {
477 int i;
478 for ( i=0; i<npoints; i++) {
479 if ( is_horizontal )
480 points[i].x += offset;
481 else
482 points[i].y += offset;
483 }
484 }
485
486 GdkPixmap* cl_progressbar_tile_new (GdkDrawable *drawable, GtkWidget *widget,
487 GtkStyle *style, gint height, gint offset)
488 {
489 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
490 int width = height;
491 int line = 0;
492 int center = width/2;
493 int xdir = 1;
494 int trans;
495
496 int stripe_width = height/2;
497 int topright = height + stripe_width;
498 int topright_div_2 = topright/2;
499
500 double shift;
501 GdkPoint points[4];
502
503 GtkProgressBarOrientation orientation = gtk_progress_bar_get_orientation (GTK_PROGRESS_BAR (widget));
504 gboolean is_horizontal = (orientation == GTK_PROGRESS_LEFT_TO_RIGHT || orientation == GTK_PROGRESS_RIGHT_TO_LEFT) ? 1 : 0;
505
506 GdkPixmap *tmp = gdk_pixmap_new (widget->window, width, height, -1);
507
508 GdkColor tmp_color;
509 shade (&clearlooks_style->spot2, &tmp_color, 0.90);
510
511 if (is_horizontal)
512 draw_hgradient (tmp, style->black_gc, style, 0, 0, width, height,
513 &clearlooks_style->spot2, &tmp_color );
514 else
515 draw_vgradient (tmp, style->black_gc, style, 0, 0, width, height,
516 &tmp_color, &clearlooks_style->spot2); /* TODO: swap for RTL */
517
518 if (orientation == GTK_PROGRESS_RIGHT_TO_LEFT ||
519 orientation == GTK_PROGRESS_BOTTOM_TO_TOP)
520 {
521 offset = -offset;
522 xdir = -1;
523 }
524
525 if (get_direction (widget) == GTK_TEXT_DIR_RTL)
526 offset = -offset;
527
528 if (is_horizontal)
529 {
530 points[0] = (GdkPoint){xdir*(topright - stripe_width - topright_div_2), 0}; /* topleft */
531 points[1] = (GdkPoint){xdir*(topright - topright_div_2), 0}; /* topright */
532 points[2] = (GdkPoint){xdir*(stripe_width - topright_div_2), height}; /* bottomright */
533 points[3] = (GdkPoint){xdir*(-topright_div_2), height}; /* bottomleft */
534 }
535 else
536 {
537 points[0] = (GdkPoint){height, xdir*(topright - stripe_width - topright_div_2)}; /* topleft */
538 points[1] = (GdkPoint){height, xdir*(topright - topright_div_2)}; /* topright */
539 points[2] = (GdkPoint){0, xdir*(stripe_width - topright_div_2)}; /* bottomright */
540 points[3] = (GdkPoint){0, xdir*(-topright_div_2)}; /* bottomleft */
541 }
542
543
544 shift = (stripe_width*2)/(double)10;
545 cl_progressbar_points_transform (points, 4, (offset*shift), is_horizontal);
546
547 trans = (width/2)-1-(stripe_width*2);
548 cl_progressbar_points_transform (points, 4, trans, is_horizontal);
549 gdk_draw_polygon (tmp, clearlooks_style->spot2_gc, TRUE, points, 4);
550 cl_progressbar_points_transform (points, 4, -trans, is_horizontal);
551
552 trans = width/2-1;
553 cl_progressbar_points_transform (points, 4, trans, is_horizontal);
554 gdk_draw_polygon (tmp, clearlooks_style->spot2_gc, TRUE, points, 4);
555 cl_progressbar_points_transform (points, 4, -trans, is_horizontal);
556
557 trans = (width/2)-1+(stripe_width*2);
558 cl_progressbar_points_transform (points, 4, trans, is_horizontal);
559 gdk_draw_polygon (tmp, clearlooks_style->spot2_gc, TRUE, points, 4);
560
561 return tmp;
562 }
563
564 /* could be improved, I think. */
565 void cl_progressbar_fill (GdkDrawable *drawable, GtkWidget *widget,
566 GtkStyle *style, GdkGC *gc,
567 gint x, gint y,
568 gint width, gint height,
569 guint8 offset, GdkRectangle *area)
570 {
571 GtkProgressBarOrientation orientation = gtk_progress_bar_get_orientation (GTK_PROGRESS_BAR (widget));
572 gint size = (orientation == GTK_PROGRESS_LEFT_TO_RIGHT || orientation == GTK_PROGRESS_RIGHT_TO_LEFT) ? height : width;
573 GdkPixmap *tile = cl_progressbar_tile_new (widget->window, widget, style, size, offset);
574
575 gint nx = x,
576 ny = y,
577 nwidth = height,
578 nheight = width;
579
580 gdk_gc_set_clip_rectangle (gc, area);
581
582 switch (orientation)
583 {
584 case GTK_PROGRESS_LEFT_TO_RIGHT:
585 {
586 while (nx <= x + width )
587 {
588 if (nx + nwidth > x+width ) nwidth = (x+width) - nx;
589 gdk_draw_drawable (drawable, gc, tile, 0, 0, nx, y, nwidth, height);
590 if (height <= 1)
591 nx += 1;
592 else
593 nx += (height-1 + !(height % 2));
594 }
595 break;
596 }
597 case GTK_PROGRESS_RIGHT_TO_LEFT:
598 {
599 gint src_x = 0, dst_x;
600 nx += width;
601 while (nx >= x )
602 {
603 dst_x = nx - height;
604 if (dst_x < x )
605 {
606 src_x = x - dst_x;
607 dst_x = x;
608 }
609 gdk_draw_drawable (drawable, gc, tile, src_x, 0, dst_x, y, nwidth, height);
610 if (height <= 1)
611 nx -= 1;
612 else
613 nx -= (height-1 + !(height % 2));
614 }
615 break;
616 }
617 case GTK_PROGRESS_TOP_TO_BOTTOM:
618 {
619 while (ny <= y + height )
620 {
621 if (ny + nheight > y+height ) nheight = (y+height) - ny;
622 gdk_draw_drawable (drawable, gc, tile, 0, 0, x, ny, width, nheight);
623 if (width <= 1)
624 ny += 1;
625 else
626 ny += (width-1 + !(width % 2));
627 }
628 break;
629 }
630 case GTK_PROGRESS_BOTTOM_TO_TOP:
631 {
632 gint src_y = 0, dst_y;
633 ny += height;
634 while (ny >= y )
635 {
636 dst_y = ny - width;
637 if (dst_y < y )
638 {
639 src_y = y - dst_y;
640 dst_y = y;
641 }
642 gdk_draw_drawable (drawable, gc, tile, 0, src_y, x, dst_y, width, width);
643 if (width <= 1)
644 ny -= 1;
645 else
646 ny -= (width-1 + !(width % 2));
647 }
648 break;
649 }
650 }
651
652 gdk_gc_set_clip_rectangle (gc, NULL);
653
654 g_object_unref (tile);
655 }
656
657 GdkColor cl_gc_set_fg_color_shade (GdkGC *gc, GdkColormap *colormap,
658 GdkColor *from, gfloat s)
659 {
660 GdkColor tmp_color;
661 GdkGCValues values;
662
663 shade (from, &tmp_color, s);
664 gdk_gc_get_values (gc, &values);
665 gdk_rgb_find_color (colormap, &tmp_color);
666 gdk_gc_set_foreground (gc, &tmp_color);
667
668 return values.foreground;
669 }
670
671 /* #warning MOVE THIS TO SUPPORT.C/H SO THE DRAW_CORNER FUNCTION CAN USE IT. OR, MAKE DRAW_CORNER USE IT SOME OTHER WAY. */
672
673 static void cl_get_window_style_state (GtkWidget *widget, GtkStyle **style, GtkStateType *state_type)
674 {
675 GtkStyle *windowstyle = NULL;
676 GtkWidget *tmpwidget = widget;
677 GtkStateType windowstate;
678
679 if (widget && GTK_IS_ENTRY (widget))
680 tmpwidget = tmpwidget->parent;
681
682 while (tmpwidget && GTK_WIDGET_NO_WINDOW (tmpwidget) && !GTK_IS_NOTEBOOK(tmpwidget))
683 {
684 tmpwidget = tmpwidget->parent;
685 }
686
687 *style = tmpwidget->style;
688 *state_type = GTK_WIDGET_STATE(tmpwidget);
689 }
690
691 static GdkGC *cl_get_window_bg_gc (GtkWidget *widget)
692 {
693 GtkStyle *style;
694 GtkStateType state_type;
695
696 cl_get_window_style_state (widget, &style, &state_type);
697
698 return style->bg_gc[state_type];
699 }
700
701 /******************************************************************************
702 * DRAW THE MIGHTY WIDGETS! *
703 ******************************************************************************/
704
705 void cl_draw_inset (GtkStyle *style, GdkWindow *window, GtkWidget *widget,
706 GdkRectangle *area,
707 gint x, gint y, gint width, gint height,
708 int tl, int tr, int bl, int br )
709 {
710 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE(style);
711 ClearlooksStyle *clwindowstyle; /* style of the window this widget is on */
712 GtkStateType windowstate;
713 CLRectangle r;
714
715 cl_rectangle_init (&r, NULL, style->black_gc,
716 tl, tr, bl, br);
717
718 r.gradient_type = CL_GRADIENT_VERTICAL;
719
720 cl_get_window_style_state(widget, (GtkStyle**)&clwindowstyle, &windowstate);
721
722 g_assert (clwindowstyle != NULL);
723
724 if (GTK_WIDGET_HAS_DEFAULT (widget))
725 {
726 r.bordergc = style->mid_gc[GTK_STATE_NORMAL];
727 }
728 else
729 {
730 cl_rectangle_set_gradient (&r.border_gradient,
731 &clwindowstyle->inset_dark[windowstate],
732 &clwindowstyle->inset_light[windowstate]);
733 }
734 cl_rectangle_set_clip_rectangle (&r, area);
735 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
736 cl_rectangle_reset_clip_rectangle (&r);
737 }
738
739 /* Draw a normal (toggle)button. Not spinbuttons.*/
740 void cl_draw_button(GtkStyle *style, GdkWindow *window,
741 GtkStateType state_type, GtkShadowType shadow_type,
742 GdkRectangle *area,
743 GtkWidget *widget, const gchar *detail,
744 gint x, gint y, gint width, gint height)
745 {
746 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE(style);
747 int my_state_type = (state_type == GTK_STATE_ACTIVE) ? 2 : 0;
748 GdkGC *bg_gc = NULL;
749 gboolean is_active = FALSE;
750 CLRectangle r;
751
752 /* Get the background color of the window we're on */
753 bg_gc = cl_get_window_bg_gc(widget);
754
755 cl_rectangle_set_button (&r, style, state_type,
756 GTK_WIDGET_HAS_DEFAULT (widget),
757 GTK_WIDGET_HAS_FOCUS (widget),
758 CL_CORNER_ROUND, CL_CORNER_ROUND,
759 CL_CORNER_ROUND, CL_CORNER_ROUND);
760
761 if (state_type == GTK_STATE_ACTIVE)
762 is_active = TRUE;
763
764 if (GTK_IS_TOGGLE_BUTTON(widget) &&
765 gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON(widget)) &&
766 state_type == GTK_STATE_PRELIGHT)
767 {
768 cl_rectangle_set_gradient (&r.fill_gradient, &clearlooks_style->shade[1], &clearlooks_style->shade[1]);
769 r.topleft = clearlooks_style->shade_gc[3];
770 r.bottomright = clearlooks_style->shade_gc[1];
771
772 is_active = TRUE;
773 }
774
775 if (!is_active)
776 r.fillgc = NULL;
777
778 if (!GTK_IS_NOTEBOOK (widget->parent))
779 {
780 gdk_draw_rectangle (window, bg_gc, FALSE, x, y, width-1, height-1);
781
782 /* Draw "sunken" look when border thickness is more than 2 pixels. */
783 if (style->xthickness > 2 && style->ythickness > 2)
784 cl_draw_inset (style, window, widget, area, x, y, width, height,
785 CL_CORNER_ROUND, CL_CORNER_ROUND,
786 CL_CORNER_ROUND, CL_CORNER_ROUND);
787 }
788
789 /* Draw "sunken" look when border thickness is more than 2 pixels.*/
790 if (style->xthickness > 2 && style->ythickness > 2)
791 {
792 x++;
793 y++;
794 height-=2;
795 width-=2;
796 }
797
798 /* Don't draw the normal gradient for normal buttons. */
799
800 cl_rectangle_set_clip_rectangle (&r, area);
801 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
802
803
804 if (!is_active)
805 {
806 int tmp_height = (float)height*0.25;
807
808 gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
809
810 draw_hgradient (window, style->bg_gc[state_type], style,
811 x+2,y+2,width-4,tmp_height,
812 &clearlooks_style->button_g1[state_type],
813 &clearlooks_style->button_g2[state_type]);
814
815 draw_hgradient (window, style->bg_gc[state_type], style,
816 x+2, y+2+tmp_height, width-4, height-3-tmp_height*2,
817 &clearlooks_style->button_g2[state_type],
818 &clearlooks_style->button_g3[state_type]);
819
820 draw_hgradient (window, style->bg_gc[state_type], style,
821 x+2,y+height-tmp_height-1,width-4,tmp_height,
822 &clearlooks_style->button_g3[state_type],
823 &clearlooks_style->button_g4[state_type]);
824
825 gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
826 }
827
828 cl_draw_shadow (window, widget, style, x, y, width, height, &r);
829 cl_rectangle_reset_clip_rectangle (&r);
830 }
831
832 /* Draw spinbuttons. */
833 void cl_draw_spinbutton(GtkStyle *style, GdkWindow *window,
834 GtkStateType state_type, GtkShadowType shadow_type,
835 GdkRectangle *area,
836 GtkWidget *widget, const gchar *detail,
837 gint x, gint y, gint width, gint height)
838 {
839 CLRectangle r;
840 GdkRectangle new_area;
841
842 int tl = CL_CORNER_NONE, tr = CL_CORNER_NONE,
843 bl = CL_CORNER_NONE, br = CL_CORNER_NONE;
844
845 if (area == NULL)
846 {
847 new_area.x = x;
848 new_area.y = y;
849 new_area.width = width;
850 new_area.height = height;
851 area = &new_area;
852 }
853
854 if (!strcmp (detail, "spinbutton")) /* draws the 'back' of the spinbutton */
855 {
856 GdkGC *bg_gc = cl_get_window_bg_gc(widget);
857
858 gdk_gc_set_clip_rectangle (bg_gc, area);
859 gdk_draw_rectangle (window, bg_gc, FALSE, x, y, width-1, height-1);
860 gdk_gc_set_clip_rectangle (bg_gc, NULL);
861
862 if (style->xthickness > 2 && style->ythickness > 2)
863 cl_draw_inset (style, window, widget, area, x, y, width, height,
864 CL_CORNER_NONE, CL_CORNER_ROUND,
865 CL_CORNER_NONE, CL_CORNER_ROUND);
866
867 return;
868 }
869
870 if (!strcmp (detail, "spinbutton_up"))
871 {
872 tr = CL_CORNER_ROUND;
873
874 (style->xthickness > 2 && style->ythickness > 2) ? y++ : height++;
875 }
876
877 if (!strcmp (detail, "spinbutton_down"))
878 {
879 br = CL_CORNER_ROUND;
880
881 if (style->xthickness > 2 && style->ythickness > 2)
882 height--;
883 }
884
885 cl_rectangle_set_button (&r, style, state_type,
886 GTK_WIDGET_HAS_DEFAULT (widget),
887 GTK_WIDGET_HAS_FOCUS (widget),
888 tl, tr,
889 bl, br);
890 width--;
891
892 cl_rectangle_set_clip_rectangle (&r, area);
893 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
894 cl_draw_shadow (window, widget, style, x, y, width, height, &r);
895 cl_rectangle_reset_clip_rectangle (&r);
896 }
897
898 void cl_draw_combobox_entry (GtkStyle *style, GdkWindow *window,
899 GtkStateType state_type, GtkShadowType shadow_type,
900 GdkRectangle *area,
901 GtkWidget *widget, const gchar *detail,
902 gint x, gint y, gint width, gint height)
903 {
904 CLRectangle r;
905
906 gboolean rtl = get_direction (widget->parent) == GTK_TEXT_DIR_RTL;
907 gboolean has_focus = GTK_WIDGET_HAS_FOCUS (widget);
908
909 int cl = rtl ? CL_CORNER_NONE : CL_CORNER_ROUND,
910 cr = rtl ? CL_CORNER_ROUND : CL_CORNER_NONE;
911
912 GdkGC *bg_gc = cl_get_window_bg_gc(widget);
913
914 if (rtl)
915 {
916 if (!has_focus)
917 {
918 x -= 1;
919 width +=1;
920 }
921 }
922 else
923 {
924 width += 2;
925 if (has_focus) width--; /* this gives us a 2px focus line at the right side. */
926 }
927
928 cl_rectangle_set_entry (&r, style, state_type,
929 cl, cr, cl, cr,
930 has_focus);
931
932 gdk_gc_set_clip_rectangle (bg_gc, area);
933 gdk_draw_rectangle (window, bg_gc, FALSE, x, y, width-1, height-1);
934 gdk_gc_set_clip_rectangle (bg_gc, NULL);
935
936 /* Draw "sunken" look when border thickness is more than 2 pixels. */
937 if (style->xthickness > 2 && style->ythickness > 2)
938 {
939 cl_draw_inset (style, window, widget, area, x, y, width, height,
940 cl, cr, cl, cr);
941
942 y++;
943 x++;
944 width-=2;
945 height-=2;
946 }
947
948 cl_rectangle_set_clip_rectangle (&r, area);
949
950 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
951 cl_draw_shadow (window, widget, style, x, y, width, height, &r);
952
953 cl_rectangle_reset_clip_rectangle (&r);
954 }
955
956 void cl_draw_combobox_button (GtkStyle *style, GdkWindow *window,
957 GtkStateType state_type, GtkShadowType shadow_type,
958 GdkRectangle *area,
959 GtkWidget *widget, const gchar *detail,
960 gint x, gint y, gint width, gint height)
961 {
962 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE(style);
963 gboolean is_active = FALSE;
964 gboolean draw_inset = FALSE;
965 CLRectangle r;
966
967 cl_rectangle_set_button (&r, style, state_type,
968 GTK_WIDGET_HAS_DEFAULT (widget),
969 GTK_WIDGET_HAS_FOCUS (widget),
970 CL_CORNER_NONE, CL_CORNER_ROUND,
971 CL_CORNER_NONE, CL_CORNER_ROUND);
972
973 if (state_type == GTK_STATE_ACTIVE)
974 is_active = TRUE;
975 else
976 r.fillgc = NULL;
977
978 /* Seriously, why can't non-gtk-apps at least try to be decent citizens?
979 Take this fscking OpenOffice.org 1.9 for example. The morons responsible
980 for this utter piece of crap give the clip size wrong values! :'( */
981
982 if (area)
983 {
984 area->x = x;
985 area->y = y;
986 area->width = width;
987 area->height = height;
988 }
989
990 x--;
991 width++;
992
993 /* Draw "sunken" look when border thickness is more than 2 pixels. */
994 if (GTK_IS_COMBO(widget->parent))
995 draw_inset = (widget->parent->style->xthickness > 2 &&
996 widget->parent->style->ythickness > 2);
997 else
998 draw_inset = (style->xthickness > 2 && style->ythickness > 2);
999
1000 if (draw_inset)
1001 {
1002 cl_draw_inset (style, window, widget, area, x, y, width, height,
1003 CL_CORNER_NONE, CL_CORNER_ROUND,
1004 CL_CORNER_NONE, CL_CORNER_ROUND);
1005
1006 x++;
1007 y++;
1008 height-=2;
1009 width-=2;
1010 }
1011 else
1012 {
1013 x++;
1014 width--;
1015 }
1016
1017 if (area)
1018 cl_rectangle_set_clip_rectangle (&r, area);
1019
1020 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
1021
1022 if (!is_active)
1023 {
1024 int tmp_height = (float)height*0.25;
1025
1026 gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
1027
1028 draw_hgradient (window, style->bg_gc[state_type], style,
1029 x+2,y+2,width-4,tmp_height,
1030 &clearlooks_style->button_g1[state_type],
1031 &clearlooks_style->button_g2[state_type]);
1032
1033 draw_hgradient (window, style->bg_gc[state_type], style,
1034 x+2, y+2+tmp_height, width-4, height-3-tmp_height*2,
1035 &clearlooks_style->button_g2[state_type],
1036 &clearlooks_style->button_g3[state_type]);
1037
1038 draw_hgradient (window, style->bg_gc[state_type], style,
1039 x+2,y+height-tmp_height-1,width-4,tmp_height,
1040 &clearlooks_style->button_g3[state_type],
1041 &clearlooks_style->button_g4[state_type]);
1042
1043 gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
1044 }
1045
1046 cl_draw_shadow (window, widget, style, x, y, width, height, &r);
1047
1048 if (area)
1049 cl_rectangle_reset_clip_rectangle (&r);
1050 }
1051
1052 /* Draw text Entry */
1053 void cl_draw_entry (GtkStyle *style, GdkWindow *window,
1054 GtkStateType state_type, GtkShadowType shadow_type,
1055 GdkRectangle *area,
1056 GtkWidget *widget, const gchar *detail,
1057 gint x, gint y, gint width, gint height)
1058 {
1059 CLRectangle r;
1060 gboolean has_focus = GTK_WIDGET_HAS_FOCUS(widget);
1061 GdkGC *bg_gc = cl_get_window_bg_gc(widget);
1062
1063 gdk_draw_rectangle (window, bg_gc, FALSE, x, y, width-1, height-1);
1064
1065 gtk_style_apply_default_background (style, window, TRUE, state_type,
1066 area, x+1, y+1, width-2, height-2);
1067
1068
1069 cl_rectangle_set_entry (&r, style, state_type,
1070 CL_CORNER_ROUND, CL_CORNER_ROUND,
1071 CL_CORNER_ROUND, CL_CORNER_ROUND,
1072 has_focus);
1073
1074 /* Draw "sunken" look when border thickness is more than 2 pixels. */
1075 if (style->xthickness > 2 && style->ythickness > 2)
1076 {
1077 cl_draw_inset (style, window, widget, area, x, y, width, height,
1078 CL_CORNER_ROUND, CL_CORNER_ROUND,
1079 CL_CORNER_ROUND, CL_CORNER_ROUND);
1080
1081 x++;
1082 y++;
1083 width-=2;
1084 height-=2;
1085 }
1086
1087 cl_rectangle_set_clip_rectangle (&r, area);
1088 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
1089 cl_draw_shadow (window, widget, style, x, y, width, height, &r);
1090 cl_rectangle_reset_clip_rectangle (&r);
1091 }
1092
1093 void cl_draw_optionmenu(GtkStyle *style, GdkWindow *window,
1094 GtkStateType state_type, GtkShadowType shadow_type,
1095 GdkRectangle *area, GtkWidget *widget,
1096 const gchar *detail,
1097 gint x, gint y, gint width, gint height)
1098 {
1099 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE(style);
1100 GtkRequisition indicator_size;
1101 GtkBorder indicator_spacing;
1102 int line_pos;
1103
1104 option_menu_get_props (widget, &indicator_size, &indicator_spacing);
1105
1106 if (get_direction (widget) == GTK_TEXT_DIR_RTL)
1107 line_pos = x + (indicator_size.width + indicator_spacing.left + indicator_spacing.right) + style->xthickness;
1108 else
1109 line_pos = x + width - (indicator_size.width + indicator_spacing.left + indicator_spacing.right) - style->xthickness;
1110
1111 cl_draw_button (style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
1112
1113 gdk_draw_line (window, clearlooks_style->shade_gc[3],
1114 line_pos, y + style->ythickness - 1, line_pos,
1115 y + height - style->ythickness);
1116
1117 gdk_draw_line (window, style->light_gc[state_type],
1118 line_pos+1, y + style->ythickness - 1, line_pos+1,
1119 y + height - style->ythickness);
1120 }
1121
1122
1123 void cl_draw_menuitem_button (GdkDrawable *window, GtkWidget *widget, GtkStyle *style,
1124 GdkRectangle *area, GtkStateType state_type,
1125 int x, int y, int width, int height, CLRectangle *r)
1126 {
1127 ClearlooksStyle *clearlooks_style = (ClearlooksStyle*)style;
1128 gboolean menubar = (widget->parent && GTK_IS_MENU_BAR(widget->parent)) ? TRUE : FALSE;
1129 int corner = CL_CORNER_NARROW;
1130 GdkColor lower_color;
1131
1132 shade (&style->base[GTK_STATE_SELECTED], &lower_color, 0.85);
1133
1134 if (menubar)
1135 {
1136 height++;
1137 corner = CL_CORNER_NONE;
1138 r->bordergc = clearlooks_style->border_gc[CL_BORDER_UPPER];
1139 }
1140 else
1141 {
1142 r->bordergc = clearlooks_style->spot3_gc;
1143 }
1144
1145 cl_rectangle_set_corners (r, corner, corner, corner, corner);
1146
1147 cl_rectangle_set_gradient (&r->fill_gradient,
1148 &style->base[GTK_STATE_SELECTED], &lower_color);
1149
1150 r->gradient_type = CL_GRADIENT_VERTICAL;
1151
1152 r->fillgc = clearlooks_style->spot2_gc;
1153 r->topleft = clearlooks_style->spot1_gc;
1154
1155 cl_rectangle_set_clip_rectangle (r, area);
1156 cl_draw_rectangle (window, widget, style, x, y, width, height, r);
1157 cl_draw_shadow (window, widget, style, x, y, width, height, r);
1158 cl_rectangle_reset_clip_rectangle (r);
1159 }
1160
1161 void cl_draw_menuitem_flat (GdkDrawable *window, GtkWidget *widget, GtkStyle *style,
1162 GdkRectangle *area, GtkStateType state_type,
1163 int x, int y, int width, int height, CLRectangle *r)
1164 {
1165 ClearlooksStyle *clearlooks_style = (ClearlooksStyle*)style;
1166 gboolean menubar = (widget->parent && GTK_IS_MENU_BAR(widget->parent)) ? TRUE : FALSE;
1167 GdkColor tmp;
1168
1169 cl_rectangle_set_corners (r, CL_CORNER_NARROW, CL_CORNER_NARROW,
1170 CL_CORNER_NARROW, CL_CORNER_NARROW);
1171
1172 tmp = cl_gc_set_fg_color_shade (style->black_gc, style->colormap,
1173 &style->base[GTK_STATE_PRELIGHT], 0.8);
1174
1175 r->bordergc = style->black_gc;
1176 r->fillgc = style->base_gc[GTK_STATE_PRELIGHT];
1177
1178 if (menubar) height++;
1179
1180 cl_rectangle_set_clip_rectangle (r, area);
1181 cl_draw_rectangle (window, widget, style, x, y, width, height, r);
1182 cl_rectangle_reset_clip_rectangle (r);
1183
1184 gdk_gc_set_foreground (style->black_gc, &tmp);
1185 }
1186
1187 void cl_draw_menuitem_gradient (GdkDrawable *window, GtkWidget *widget, GtkStyle *style,
1188 GdkRectangle *area, GtkStateType state_type,
1189 int x, int y, int width, int height, CLRectangle *r)
1190 {
1191 ClearlooksStyle *clearlooks_style = (ClearlooksStyle*)style;
1192 gboolean menubar = (widget->parent && GTK_IS_MENU_BAR(widget->parent)) ? TRUE : FALSE;
1193 GdkColor tmp;
1194 GdkColor lower_color;
1195
1196 shade (&style->base[GTK_STATE_SELECTED], &lower_color, 0.8);
1197
1198 cl_rectangle_set_corners (r, CL_CORNER_NARROW, CL_CORNER_NARROW,
1199 CL_CORNER_NARROW, CL_CORNER_NARROW);
1200
1201 cl_rectangle_set_gradient (&r->fill_gradient,
1202 &style->base[GTK_STATE_SELECTED], &lower_color);
1203
1204 r->gradient_type = CL_GRADIENT_VERTICAL;
1205
1206 tmp = cl_gc_set_fg_color_shade (style->black_gc, style->colormap,
1207 &style->base[GTK_STATE_PRELIGHT], 0.8);
1208
1209 r->bordergc = style->black_gc;
1210 r->fillgc = style->base_gc[GTK_STATE_PRELIGHT];
1211
1212 if (menubar) height++;
1213
1214 cl_rectangle_set_clip_rectangle (r, area);
1215 cl_draw_rectangle (window, widget, style, x, y, width, height, r);
1216 cl_rectangle_reset_clip_rectangle (r);
1217
1218 gdk_gc_set_foreground (style->black_gc, &tmp);
1219 }
1220
1221 void cl_draw_treeview_header (GtkStyle *style, GdkWindow *window,
1222 GtkStateType state_type, GtkShadowType shadow_type,
1223 GdkRectangle *area,
1224 GtkWidget *widget, const gchar *detail,
1225 gint x, gint y, gint width, gint height)
1226 {
1227 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1228 gint columns = 0, column_index = -1, fill_width = width;
1229 gboolean is_etree = strcmp("ETree", G_OBJECT_TYPE_NAME(widget->parent)) == 0;
1230 gboolean resizable = TRUE;
1231
1232 GdkGC *bottom = clearlooks_style->shade_gc[5];
1233
1234 if ( width < 2 || height < 2 )
1235 return;
1236
1237 if (GTK_IS_TREE_VIEW (widget->parent))
1238 {
1239 gtk_treeview_get_header_index (GTK_TREE_VIEW(widget->parent),
1240 widget, &column_index, &columns,
1241 &resizable);
1242 }
1243 else if (GTK_IS_CLIST (widget->parent))
1244 {
1245 gtk_clist_get_header_index (GTK_CLIST(widget->parent),
1246 widget, &column_index, &columns);
1247 }
1248
1249 if (area)
1250 {
1251 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], area);
1252 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[4], area);
1253 gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
1254 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[5], area);
1255 }
1256
1257 if (state_type != GTK_STATE_NORMAL)
1258 fill_width-=2;
1259
1260 gdk_draw_rectangle (window, style->bg_gc[state_type], TRUE, x, y, fill_width, height-(height/3)+1);
1261
1262 draw_hgradient (window, style->bg_gc[state_type], style,
1263 x, 1+y+height-(height/3), fill_width, height/3,
1264 &style->bg[state_type], &clearlooks_style->inset_dark[state_type]);
1265
1266 if (resizable || (column_index != columns-1))
1267 {
1268 gdk_draw_line (window, clearlooks_style->shade_gc[4], x+width-2, y+4, x+width-2, y+height-5);
1269 gdk_draw_line (window, clearlooks_style->shade_gc[0], x+width-1, y+4, x+width-1, y+height-5);
1270 }
1271
1272 /* left light line */
1273 if (column_index == 0)
1274 gdk_draw_line (window, clearlooks_style->shade_gc[0], x, y+1, x, y+height-2);
1275
1276 /* top light line */
1277 gdk_draw_line (window, clearlooks_style->shade_gc[0], x, y, x+width-1, y);
1278
1279 /* bottom dark line */
1280 if (state_type == GTK_STATE_INSENSITIVE)
1281 bottom = clearlooks_style->shade_gc[3];
1282
1283
1284 gdk_draw_line (window, bottom, x, y+height-1, x+width-1, y+height-1);
1285
1286 if (area)
1287 {
1288 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], NULL);
1289 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[4], NULL);
1290 gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
1291 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[5], NULL);
1292 }
1293 }
Testbed for new Ardour MIDI features