?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
newly created files for use in recording appear in a .stubs folder, and are moved...
[ardour2.git] / libs / clearlooks-older / clearlooks_style.c
blob074f1604b1a36081c1413b00b8f130b080ce3bb5
1 #include <gtk/gtk.h>
2
3 #include "clearlooks_style.h"
4 #include "clearlooks_rc_style.h"
5 #include "clearlooks_draw.h"
6
7 #include <math.h>
8 #include <string.h>
9
10 #include "bits.c"
11 #include "support.h"
12 //#include "config.h"
13
14 /* #define DEBUG 1 */
15
16 #define SCALE_SIZE 5
17
18 #define DETAIL(xx) ((detail) && (!strcmp(xx, detail)))
19 #define COMPARE_COLORS(a,b) (a.red == b.red && a.green == b.green && a.blue == b.blue)
20
21 #define DRAW_ARGS GtkStyle *style, \
22 GdkWindow *window, \
23 GtkStateType state_type, \
24 GtkShadowType shadow_type, \
25 GdkRectangle *area, \
26 GtkWidget *widget, \
27 const gchar *detail, \
28 gint x, \
29 gint y, \
30 gint width, \
31 gint height
32
33 static GdkGC *realize_color (GtkStyle * style, GdkColor * color);
34 static GtkStyleClass *parent_class;
35 static GList *progressbars = NULL;
36 static gint8 pboffset = 10;
37 static int timer_id = 0;
38
39 static void cl_progressbar_remove (gpointer data)
40 {
41 if (g_list_find (progressbars, data) == NULL)
42 return;
43
44 progressbars = g_list_remove (progressbars, data);
45 g_object_unref (data);
46
47 if (g_list_first(progressbars) == NULL) {
48 g_source_remove(timer_id);
49 timer_id = 0;
50 }
51 }
52
53 static void update_progressbar (gpointer data, gpointer user_data)
54 {
55 gfloat fraction;
56
57 if (data == NULL)
58 return;
59
60 fraction = gtk_progress_bar_get_fraction (GTK_PROGRESS_BAR (data));
61
62 /* update only if not filled */
63 if (fraction < 1.0)
64 gtk_widget_queue_resize ((GtkWidget*)data);
65
66 if (fraction >= 1.0 || GTK_PROGRESS (data)->activity_mode)
67 cl_progressbar_remove (data);
68 }
69
70 static gboolean timer_func (gpointer data)
71 {
72 g_list_foreach (progressbars, update_progressbar, NULL);
73 if (--pboffset < 0) pboffset = 9;
74 return (g_list_first(progressbars) != NULL);
75 }
76
77 static gboolean cl_progressbar_known(gconstpointer data)
78 {
79 return (g_list_find (progressbars, data) != NULL);
80 }
81
82
83 static void cl_progressbar_add (gpointer data)
84 {
85 if (!GTK_IS_PROGRESS_BAR (data))
86 return;
87
88 progressbars = g_list_append (progressbars, data);
89
90 g_object_ref (data);
91 g_signal_connect ((GObject*)data, "unrealize", G_CALLBACK (cl_progressbar_remove), data);
92
93 if (timer_id == 0)
94 timer_id = g_timeout_add (100, timer_func, NULL);
95 }
96
97 static GdkColor *
98 clearlooks_get_spot_color (ClearlooksRcStyle *clearlooks_rc)
99 {
100 GtkRcStyle *rc = GTK_RC_STYLE (clearlooks_rc);
101
102 if (clearlooks_rc->has_spot_color)
103 return &clearlooks_rc->spot_color;
104 else
105 return &rc->base[GTK_STATE_SELECTED];
106 }
107
108 /**************************************************************************/
109
110 /* used for optionmenus... */
111 static void
112 draw_tab (GtkStyle *style,
113 GdkWindow *window,
114 GtkStateType state_type,
115 GtkShadowType shadow_type,
116 GdkRectangle *area,
117 GtkWidget *widget,
118 const gchar *detail,
119 gint x,
120 gint y,
121 gint width,
122 gint height)
123 {
124 #define ARROW_SPACE 2
125 #define ARROW_LINE_HEIGHT 2
126 #define ARROW_LINE_WIDTH 5
127 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
128 GtkRequisition indicator_size;
129 GtkBorder indicator_spacing;
130 gint arrow_height;
131
132 option_menu_get_props (widget, &indicator_size, &indicator_spacing);
133
134 indicator_size.width += (indicator_size.width % 2) - 1;
135 arrow_height = indicator_size.width / 2 + 2;
136
137 x += (width - indicator_size.width) / 2;
138 y += height/2;
139
140 if (state_type == GTK_STATE_INSENSITIVE)
141 {
142 draw_arrow (window, style->light_gc[state_type], area,
143 GTK_ARROW_UP, 1+x, 1+y-arrow_height,
144 indicator_size.width, arrow_height);
145
146 draw_arrow (window, style->light_gc[state_type], area,
147 GTK_ARROW_DOWN, 1+x, 1+y+1,
148 indicator_size.width, arrow_height);
149 }
150
151 draw_arrow (window, style->fg_gc[state_type], area,
152 GTK_ARROW_UP, x, y-arrow_height,
153 indicator_size.width, arrow_height);
154
155 draw_arrow (window, style->fg_gc[state_type], area,
156 GTK_ARROW_DOWN, x, y+1,
157 indicator_size.width, arrow_height);
158 }
159
160 static void
161 clearlooks_draw_arrow (GtkStyle *style,
162 GdkWindow *window,
163 GtkStateType state,
164 GtkShadowType shadow,
165 GdkRectangle *area,
166 GtkWidget *widget,
167 const gchar *detail,
168 GtkArrowType arrow_type,
169 gboolean fill,
170 gint x,
171 gint y,
172 gint width,
173 gint height)
174 {
175 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
176 gint original_width, original_x;
177 GdkGC *gc;
178
179 sanitize_size (window, &width, &height);
180
181 if (is_combo_box (widget))
182 {
183 width = 7;
184 height = 5;
185 x+=2;
186 y+=4;
187 if (state == GTK_STATE_INSENSITIVE)
188 {
189 draw_arrow (window, style->light_gc[state], area,
190 GTK_ARROW_UP, 1+x, 1+y-height,
191 width, height);
192
193 draw_arrow (window, style->light_gc[state], area,
194 GTK_ARROW_DOWN, 1+x, 1+y+1,
195 width, height);
196 }
197
198 draw_arrow (window, style->fg_gc[state], area,
199 GTK_ARROW_UP, x, y-height,
200 width, height);
201
202 draw_arrow (window, style->fg_gc[state], area,
203 GTK_ARROW_DOWN, x, y+1,
204 width, height);
205
206 return;
207 }
208
209 original_width = width;
210 original_x = x;
211
212 /* Make spinbutton arrows and arrows in menus
213 * slightly larger to get the right pixels drawn */
214 if (DETAIL ("spinbutton"))
215 height += 1;
216
217 if (DETAIL("menuitem"))
218 {
219 width = 6;
220 height = 7;
221 }
222
223 /* Compensate arrow position for "sunken" look */
224 if (DETAIL ("spinbutton") && arrow_type == GTK_ARROW_DOWN &&
225 style->xthickness > 2 && style->ythickness > 2)
226 y -= 1;
227
228 if (widget && widget->parent && GTK_IS_COMBO (widget->parent->parent))
229 {
230 width -= 2;
231 height -=2;
232 x++;
233 }
234
235 calculate_arrow_geometry (arrow_type, &x, &y, &width, &height);
236
237 if (DETAIL ("menuitem"))
238 x = original_x + original_width - width;
239
240 if (DETAIL ("spinbutton") && (arrow_type == GTK_ARROW_DOWN))
241 y += 1;
242
243 if (state == GTK_STATE_INSENSITIVE)
244 draw_arrow (window, style->light_gc[state], area, arrow_type, x + 1, y + 1, width, height);
245
246 gc = style->fg_gc[state];
247
248 draw_arrow (window, gc, area, arrow_type, x, y, width, height);
249 }
250
251
252 static void
253 draw_flat_box (DRAW_ARGS)
254 {
255 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
256
257 g_return_if_fail (GTK_IS_STYLE (style));
258 g_return_if_fail (window != NULL);
259
260 sanitize_size (window, &width, &height);
261
262 if (detail &&
263 clearlooks_style->listviewitemstyle == 1 &&
264 state_type == GTK_STATE_SELECTED && (
265 !strncmp ("cell_even", detail, strlen ("cell_even")) ||
266 !strncmp ("cell_odd", detail, strlen ("cell_odd"))))
267 {
268 GdkGC *gc;
269 GdkColor lower_color;
270 GdkColor *upper_color;
271
272 if (GTK_WIDGET_HAS_FOCUS (widget))
273 {
274 gc = style->base_gc[state_type];
275 upper_color = &style->base[state_type];
276 }
277 else
278 {
279 gc = style->base_gc[GTK_STATE_ACTIVE];
280 upper_color = &style->base[GTK_STATE_ACTIVE];
281 }
282
283 if (GTK_IS_TREE_VIEW (widget) && 0)
284 {
285 GtkTreeSelection *sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (widget));
286
287 if (gtk_tree_selection_count_selected_rows (sel) > 1)
288 {
289 parent_class->draw_flat_box (style, window, state_type, shadow_type,
290 area, widget, detail,
291 x, y, width, height);
292 return;
293 }
294 }
295
296 shade (upper_color, &lower_color, 0.8);
297
298 if (area)
299 gdk_gc_set_clip_rectangle (gc, area);
300
301 draw_hgradient (window, gc, style,
302 x, y, width, height, upper_color, &lower_color);
303
304 if (area)
305 gdk_gc_set_clip_rectangle (gc, NULL);
306 }
307 else
308 {
309 parent_class->draw_flat_box (style, window, state_type,
310 shadow_type,
311 area, widget, detail,
312 x, y, width, height);
313 }
314 }
315 /**************************************************************************/
316
317 static void
318 draw_shadow (DRAW_ARGS)
319 {
320 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
321 CLRectangle r;
322
323 GdkGC *outer_gc = clearlooks_style->shade_gc[4];
324 GdkGC *gc1 = NULL;
325 GdkGC *gc2 = NULL;
326 gint thickness_light;
327 gint thickness_dark;
328 gboolean interior_focus = FALSE;
329
330 #if DEBUG
331 printf("draw_shadow: %s %d %d %d %d\n", detail, x, y, width, height);
332 #endif
333
334 if (widget == NULL)
335 {
336 gdk_draw_rectangle (window, outer_gc, FALSE,
337 x, y, width - 1, height - 1);
338 return;
339 }
340
341 if ((width == -1) && (height == -1))
342 gdk_window_get_size (window, &width, &height);
343 else if (width == -1)
344 gdk_window_get_size (window, &width, NULL);
345 else if (height == -1)
346 gdk_window_get_size (window, NULL, &height);
347
348 cl_rectangle_reset (&r, style);
349
350 if (DETAIL ("frame") && widget->parent &&
351 GTK_IS_STATUSBAR (widget->parent))
352 {
353 gtk_style_apply_default_background (style, window,widget && !GTK_WIDGET_NO_WINDOW (widget),
354 state_type, area, x, y, width, height);
355
356 if (area)
357 {
358 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], area);
359 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], area);
360 }
361
362 gdk_draw_line (window, clearlooks_style->shade_gc[3],
363 x, y, x + width, y);
364 gdk_draw_line (window, clearlooks_style->shade_gc[0],
365 x, y + 1, x + width, y + 1);
366
367 if (area)
368 {
369 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], NULL);
370 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], NULL);
371 }
372 }
373 else if (detail && !strcmp (detail, "entry"))
374 {
375 if ( widget->parent && (GTK_IS_COMBO_BOX_ENTRY (widget->parent) ||
376 GTK_IS_SPIN_BUTTON(widget) ||
377 GTK_IS_COMBO (widget->parent)))
378 {
379 cl_draw_combobox_entry (style, window, GTK_WIDGET_STATE(widget), shadow_type, area, widget, detail, x, y, width, height);
380 }
381 else
382 {
383 cl_draw_entry (style, window, GTK_WIDGET_STATE(widget), shadow_type, area, widget, detail, x, y, width, height);
384 }
385 }
386 else if (DETAIL ("viewport") || DETAIL ("scrolled_window"))
387 {
388 gdk_draw_rectangle (window, clearlooks_style->shade_gc[4], FALSE,
389 x, y, width - 1, height - 1);
390 }
391 else
392 {
393 if (DETAIL ("menuitem"))
394 outer_gc = clearlooks_style->spot3_gc;
395 else
396 outer_gc = clearlooks_style->shade_gc[4];
397
398 if (shadow_type == GTK_SHADOW_IN)
399 gdk_draw_rectangle (window, outer_gc, FALSE,
400 x, y, width - 1, height - 1);
401 else if (shadow_type == GTK_SHADOW_OUT)
402 {
403 gdk_draw_rectangle (window, outer_gc, FALSE,
404 x, y, width - 1, height - 1);
405 gdk_draw_line (window, style->light_gc[state_type],
406 x+1, y+1, x+width-2, y+1);
407 gdk_draw_line (window, style->light_gc[state_type],
408 x+1, y+1, x+1, y+height-2);
409 }
410 else if (shadow_type == GTK_SHADOW_ETCHED_IN)
411 {
412 GdkGC *a = clearlooks_style->shade_gc[(shadow_type == GTK_SHADOW_ETCHED_IN) ? 0 : 3];
413 GdkGC *b = clearlooks_style->shade_gc[(shadow_type == GTK_SHADOW_ETCHED_IN) ? 3 : 0];
414
415 cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
416 CL_CORNER_NONE, CL_CORNER_NONE);
417
418 r.bordergc = a;
419 cl_rectangle_set_clip_rectangle (&r, area);
420 cl_draw_rectangle (window, widget, style, x+1, y+1, width-1, height-1, &r);
421 cl_rectangle_reset_clip_rectangle (&r);
422
423 r.bordergc = b;
424 cl_rectangle_set_clip_rectangle (&r, area);
425 cl_draw_rectangle (window, widget, style, x, y, width-1, height-1, &r);
426 cl_rectangle_reset_clip_rectangle (&r);
427 }
428 else if (shadow_type == GTK_SHADOW_ETCHED_IN)
429 {
430 GdkGC *a = clearlooks_style->shade_gc[(shadow_type == GTK_SHADOW_ETCHED_IN) ? 3 : 0];
431 GdkGC *b = clearlooks_style->shade_gc[(shadow_type == GTK_SHADOW_ETCHED_IN) ? 0 : 3];
432
433 cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
434 CL_CORNER_NONE, CL_CORNER_NONE);
435
436 r.bordergc = a;
437 cl_rectangle_set_clip_rectangle (&r, area);
438 cl_draw_rectangle (window, widget, style, x+1, y+1, width-1, height-1, &r);
439 cl_rectangle_reset_clip_rectangle (&r);
440
441 r.bordergc = b;
442 cl_rectangle_set_clip_rectangle (&r, area);
443 cl_draw_rectangle (window, widget, style, x, y, width-1, height-1, &r);
444 cl_rectangle_reset_clip_rectangle (&r);
445 }
446 else
447 parent_class->draw_shadow (style, window, state_type, shadow_type,
448 area, widget, detail,
449 x, y, width, height);
450 }
451 }
452
453 #define GDK_RECTANGLE_SET(rect,a,b,c,d) rect.x = a; \
454 rect.y = b; \
455 rect.width = c; \
456 rect.height = d;
457
458
459 static void
460 draw_box_gap (DRAW_ARGS,
461 GtkPositionType gap_side,
462 gint gap_x,
463 gint gap_width)
464 {
465 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
466 CLRectangle r;
467
468 GdkRegion *area_region = NULL,
469 *gap_region = NULL;
470 GdkRectangle light_rect;
471 GdkRectangle dark_rect;
472
473 #if DEBUG
474 printf("draw_box_gap: %s %d %d %d %d\n", detail, x, y, width, height);
475 #endif
476
477 g_return_if_fail (GTK_IS_STYLE (style));
478 g_return_if_fail (window != NULL);
479
480 sanitize_size (window, &width, &height);
481
482 cl_rectangle_reset (&r, style);
483
484 r.bordergc = clearlooks_style->shade_gc[5];
485
486 r.topleft = style->light_gc[state_type];
487 r.bottomright = clearlooks_style->shade_gc[1];
488
489 if (area)
490 area_region = gdk_region_rectangle (area);
491 else
492 {
493 GdkRectangle tmp = { x, y, width, height };
494 area_region = gdk_region_rectangle (&tmp);
495 }
496
497 switch (gap_side)
498 {
499 case GTK_POS_TOP:
500 {
501 GdkRectangle rect = { x+gap_x+1, y, gap_width-2, 2 };
502 gap_region = gdk_region_rectangle (&rect);
503
504 GDK_RECTANGLE_SET (light_rect, x+gap_x+1, y, x+gap_x+1, y+1);
505 GDK_RECTANGLE_SET (dark_rect, x+gap_x+gap_width-2, y, x+gap_x+gap_width-2, y);
506
507 cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
508 CL_CORNER_ROUND, CL_CORNER_ROUND);
509
510 break;
511 }
512 case GTK_POS_BOTTOM:
513 {
514 GdkRectangle rect = { x+gap_x+1, y+height-2, gap_width-2, 2 };
515 gap_region = gdk_region_rectangle (&rect);
516
517 GDK_RECTANGLE_SET (light_rect, x+gap_x+1, y+height-2, x+gap_x+1, y+height-1);
518 GDK_RECTANGLE_SET (dark_rect, x+gap_x+gap_width-2, y+height-2, x+gap_x+gap_width-2, y+height-1);
519
520 cl_rectangle_set_corners (&r, CL_CORNER_ROUND, CL_CORNER_ROUND,
521 CL_CORNER_NONE, CL_CORNER_NONE);
522
523 break;
524 }
525 case GTK_POS_LEFT:
526 {
527 GdkRectangle rect = { x, y+gap_x+1, 2, gap_width-2 };
528 gap_region = gdk_region_rectangle (&rect);
529
530 GDK_RECTANGLE_SET (light_rect, x, y+gap_x+1, x+1, y+gap_x+1);
531 GDK_RECTANGLE_SET (dark_rect, x, y+gap_x+gap_width-2, x, y+gap_x+gap_width-2);
532
533 cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_ROUND,
534 CL_CORNER_NONE, CL_CORNER_ROUND);
535 break;
536 }
537 case GTK_POS_RIGHT:
538 {
539 GdkRectangle rect = { x+width-2, y+gap_x+1, 2, gap_width-2 };
540 gap_region = gdk_region_rectangle (&rect);
541
542 GDK_RECTANGLE_SET (light_rect, x+width-2, y+gap_x+1, x+width-1, y+gap_x+1);
543 GDK_RECTANGLE_SET (dark_rect, x+width-2, y+gap_x+gap_width-2, x+width-1, y+gap_x+gap_width-2);
544
545 cl_rectangle_set_corners (&r, CL_CORNER_ROUND, CL_CORNER_NONE,
546 CL_CORNER_ROUND, CL_CORNER_NONE);
547 break;
548 }
549 }
550
551 gdk_region_subtract (area_region, gap_region);
552
553 gdk_gc_set_clip_region (r.bordergc, area_region);
554 gdk_gc_set_clip_region (r.topleft, area_region);
555 gdk_gc_set_clip_region (r.bottomright, area_region);
556
557 gdk_region_destroy (area_region);
558 gdk_region_destroy (gap_region);
559
560 gdk_draw_rectangle (window, style->bg_gc[state_type], TRUE, x, y, width, height);
561
562 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
563
564 cl_draw_shadow (window, widget, style, x, y, width, height, &r);
565
566 gdk_gc_set_clip_region (r.bordergc, NULL);
567 gdk_gc_set_clip_region (r.topleft, NULL);
568 gdk_gc_set_clip_region (r.bottomright, NULL);
569
570 /* it's a semi hack */
571 gdk_draw_line (window, style->light_gc[state_type],
572 light_rect.x, light_rect.y,
573 light_rect.width, light_rect.height);
574
575 gdk_draw_line (window, clearlooks_style->shade_gc[1],
576 dark_rect.x, dark_rect.y,
577 dark_rect.width, dark_rect.height);
578 }
579
580 /**************************************************************************/
581
582 static void
583 draw_extension (DRAW_ARGS, GtkPositionType gap_side)
584 {
585 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
586 int my_state_type = (state_type == GTK_STATE_ACTIVE) ? 2 : 0;
587 CLRectangle r;
588
589 #if DEBUG
590 printf("draw_extension: %s %d %d %d %d\n", detail, x, y, width, height);
591 #endif
592
593 g_return_if_fail (GTK_IS_STYLE (style));
594 g_return_if_fail (window != NULL);
595
596 sanitize_size (window, &width, &height);
597
598 if (DETAIL ("tab"))
599 {
600 GdkRectangle new_area;
601 GdkColor tmp_color;
602
603 cl_rectangle_set_button (&r, style, state_type, FALSE, FALSE,
604 CL_CORNER_ROUND, CL_CORNER_ROUND,
605 CL_CORNER_ROUND, CL_CORNER_ROUND);
606
607 if (state_type == GTK_STATE_ACTIVE)
608 shade (&style->bg[state_type], &tmp_color, 1.08);
609 else
610 shade (&style->bg[state_type], &tmp_color, 1.05);
611
612 if (area)
613 {
614 new_area = *area;
615 }
616 else
617 {
618 new_area.x = x;
619 new_area.y = y;
620 new_area.width = width;
621 new_area.height = height;
622 }
623
624 switch (gap_side)
625 {
626 case GTK_POS_BOTTOM:
627 height+=2;
628 new_area.y = y;
629 new_area.height = height-2;
630 r.gradient_type = CL_GRADIENT_VERTICAL;
631 cl_rectangle_set_gradient (&r.fill_gradient, &tmp_color, &style->bg[state_type]);
632 cl_rectangle_set_gradient (&r.border_gradient,
633 &clearlooks_style->border[CL_BORDER_UPPER+my_state_type],
634 &clearlooks_style->border[CL_BORDER_LOWER+my_state_type]);
635 break;
636 case GTK_POS_TOP:
637 y-=2;
638 height+=2;
639 new_area.y = y+2;
640 new_area.height = height;
641 r.gradient_type = CL_GRADIENT_VERTICAL;
642 cl_rectangle_set_gradient (&r.fill_gradient, &style->bg[state_type], &tmp_color);
643 cl_rectangle_set_gradient (&r.border_gradient,
644 &clearlooks_style->border[CL_BORDER_LOWER+my_state_type],
645 &clearlooks_style->border[CL_BORDER_UPPER+my_state_type]);
646 break;
647 case GTK_POS_LEFT:
648 x-=2;
649 width+=2;
650 new_area.x = x+2;
651 new_area.width = width;
652 r.gradient_type = CL_GRADIENT_HORIZONTAL;
653 cl_rectangle_set_gradient (&r.fill_gradient, &style->bg[state_type], &tmp_color);
654 cl_rectangle_set_gradient (&r.border_gradient,
655 &clearlooks_style->border[CL_BORDER_LOWER+my_state_type],
656 &clearlooks_style->border[CL_BORDER_UPPER+my_state_type]);
657 break;
658 case GTK_POS_RIGHT:
659 width+=2;
660 new_area.x = x;
661 new_area.width = width-2;
662 r.gradient_type = CL_GRADIENT_HORIZONTAL;
663 cl_rectangle_set_gradient (&r.fill_gradient, &tmp_color, &style->bg[state_type]);
664 cl_rectangle_set_gradient (&r.border_gradient,
665 &clearlooks_style->border[CL_BORDER_UPPER+my_state_type],
666 &clearlooks_style->border[CL_BORDER_LOWER+my_state_type]);
667 break;
668 }
669
670 r.topleft = style->light_gc[state_type];
671 r.bottomright = (state_type == GTK_STATE_NORMAL) ? clearlooks_style->shade_gc[1] : NULL;
672
673 cl_rectangle_set_clip_rectangle (&r, &new_area);
674 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
675 cl_draw_shadow (window, widget, style, x, y, width, height, &r);
676 cl_rectangle_reset_clip_rectangle (&r);
677
678 /* draw the selection stripe */
679 if (state_type != GTK_STATE_ACTIVE) {
680 cl_rectangle_set_gradient (&r.fill_gradient, NULL, NULL);
681 r.fillgc = clearlooks_style->spot2_gc;
682
683 switch (gap_side)
684 {
685 case GTK_POS_BOTTOM:
686 cl_rectangle_set_corners (&r, CL_CORNER_ROUND, CL_CORNER_ROUND,
687 CL_CORNER_NONE, CL_CORNER_NONE);
688 cl_rectangle_set_gradient (&r.border_gradient, &clearlooks_style->spot3, &clearlooks_style->spot2);
689 r.gradient_type = CL_GRADIENT_VERTICAL;
690
691 cl_rectangle_set_clip_rectangle (&r, &new_area);
692 cl_draw_rectangle (window, widget, style, x, y, width, 3, &r);
693 cl_rectangle_reset_clip_rectangle (&r);
694 break;
695 case GTK_POS_TOP:
696 cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
697 CL_CORNER_ROUND, CL_CORNER_ROUND);
698 cl_rectangle_set_gradient (&r.border_gradient, &clearlooks_style->spot2, &clearlooks_style->spot3);
699 r.gradient_type = CL_GRADIENT_VERTICAL;
700
701 cl_rectangle_set_clip_rectangle (&r, &new_area);
702 cl_draw_rectangle (window, widget, style, x, y + height - 3, width, 3, &r);
703 cl_rectangle_reset_clip_rectangle (&r);
704 break;
705 case GTK_POS_LEFT:
706 cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_ROUND,
707 CL_CORNER_NONE, CL_CORNER_ROUND);
708 cl_rectangle_set_gradient (&r.border_gradient, &clearlooks_style->spot2, &clearlooks_style->spot3);
709 r.gradient_type = CL_GRADIENT_HORIZONTAL;
710
711 cl_rectangle_set_clip_rectangle (&r, &new_area);
712 cl_draw_rectangle (window, widget, style, x + width - 3, y, 3, height, &r);
713 cl_rectangle_reset_clip_rectangle (&r);
714 break;
715 case GTK_POS_RIGHT:
716 cl_rectangle_set_corners (&r, CL_CORNER_ROUND, CL_CORNER_NONE,
717 CL_CORNER_ROUND, CL_CORNER_NONE);
718 cl_rectangle_set_gradient (&r.border_gradient, &clearlooks_style->spot3, &clearlooks_style->spot2);
719 r.gradient_type = CL_GRADIENT_HORIZONTAL;
720
721 cl_rectangle_set_clip_rectangle (&r, &new_area);
722 cl_draw_rectangle (window, widget, style, x, y, 3, height, &r);
723 cl_rectangle_reset_clip_rectangle (&r);
724 break;
725 }
726 }
727
728
729 }
730 else
731 {
732 parent_class->draw_extension (style, window, state_type, shadow_type, area,
733 widget, detail, x, y, width, height,
734 gap_side);
735 }
736 }
737
738
739 /**************************************************************************/
740
741 static void
742 draw_handle (DRAW_ARGS, GtkOrientation orientation)
743 {
744 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
745 gint xx, yy;
746 gint xthick, ythick;
747 GdkGC *light_gc, *dark_gc;
748 GdkRectangle rect;
749 GdkRectangle dest;
750 gint intersect;
751 gint h;
752 int i;
753 int n_lines;
754 int offset;
755
756 #if DEBUG
757 printf("draw_handle: %s %d %d %d %d\n", detail, x, y, width, height);
758 #endif
759
760 g_return_if_fail (GTK_IS_STYLE (style));
761 g_return_if_fail (window != NULL);
762
763 sanitize_size (window, &width, &height);
764
765 if (state_type == GTK_STATE_PRELIGHT)
766 gtk_style_apply_default_background (style, window,
767 widget && !GTK_WIDGET_NO_WINDOW (widget),
768 state_type, area, x, y, width, height);
769
770 /* orientation is totally bugged, but this actually works... */
771 orientation = (width > height) ? GTK_ORIENTATION_HORIZONTAL : GTK_ORIENTATION_VERTICAL;
772
773 if (!strcmp (detail, "paned"))
774 {
775 /* we want to ignore the shadow border in paned widgets */
776 xthick = 0;
777 ythick = 0;
778 }
779 else
780 {
781 xthick = style->xthickness;
782 ythick = style->ythickness;
783 }
784
785 if ( ((DETAIL ("handlebox") && widget && GTK_IS_HANDLE_BOX (widget)) || DETAIL ("dockitem")) &&
786 orientation == GTK_ORIENTATION_VERTICAL )
787 {
788 /* The line in the toolbar */
789
790 light_gc = style->light_gc[state_type];
791 dark_gc = clearlooks_style->shade_gc[3];
792
793 if (area)
794 {
795 gdk_gc_set_clip_rectangle (light_gc, area);
796 gdk_gc_set_clip_rectangle (dark_gc, area);
797 }
798
799 if (area)
800 {
801 gdk_gc_set_clip_rectangle (light_gc, NULL);
802 gdk_gc_set_clip_rectangle (dark_gc, NULL);
803 }
804
805 if (area)
806 {
807 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], area);
808 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], area);
809 }
810
811 gdk_draw_line (window, clearlooks_style->shade_gc[0], x, y, x + width, y);
812 gdk_draw_line (window, clearlooks_style->shade_gc[3], x, y + height - 1, x + width, y + height - 1);
813
814 if (area)
815 {
816 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], NULL);
817 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], NULL);
818 }
819 }
820
821 light_gc = clearlooks_style->shade_gc[0];
822 dark_gc = clearlooks_style->shade_gc[4];
823
824 rect.x = x + xthick;
825 rect.y = y + ythick;
826 rect.width = width - (xthick * 2);
827 rect.height = height - (ythick * 2);
828
829 if (area)
830 intersect = gdk_rectangle_intersect (area, &rect, &dest);
831 else
832 {
833 intersect = TRUE;
834 dest = rect;
835 }
836
837 if (!intersect)
838 return;
839
840 gdk_gc_set_clip_rectangle (light_gc, &dest);
841 gdk_gc_set_clip_rectangle (dark_gc, &dest);
842
843 n_lines = (!strcmp (detail, "paned")) ? 21 : 11;
844
845 if (orientation == GTK_ORIENTATION_VERTICAL)
846 {
847 h = width - 2 * xthick;
848 h = MAX (3, h - 6);
849
850 xx = x + (width - h) / 2;
851 offset = (height - 2*ythick - 2*n_lines)/2 + 1;
852 if (offset < 0)
853 offset = 0;
854
855 for (i = 0, yy = y + ythick + offset; yy <= (y + height - ythick - 1) && i < n_lines; yy += 2, i++)
856 {
857 gdk_draw_line (window, dark_gc, xx, yy, xx + h, yy);
858 gdk_draw_line (window, light_gc, xx, yy + 1, xx + h, yy + 1);
859 }
860 }
861 else
862 {
863 h = height - 2 * ythick;
864 h = MAX (3, h - 6);
865
866 yy = y + (height - h) / 2;
867 offset = (width - 2*xthick - 2*n_lines)/2 + 1;
868 if (offset < 0)
869 offset = 0;
870
871 for (i = 0, xx = x + xthick + offset; i < n_lines; xx += 2, i++)
872 {
873 gdk_draw_line (window, dark_gc, xx, yy, xx, yy + h);
874 gdk_draw_line (window, light_gc, xx + 1, yy, xx + 1, yy + h);
875 }
876 }
877
878 gdk_gc_set_clip_rectangle (light_gc, NULL);
879 gdk_gc_set_clip_rectangle (dark_gc, NULL);
880 }
881
882 /**************************************************************************/
883
884 static void
885 draw_box (DRAW_ARGS)
886 {
887 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
888 CLRectangle r;
889 gboolean false_size = FALSE;
890
891 #ifdef DEBUG
892 printf("draw_box: %s %d %d %d %d\n", detail, x, y, width, height);
893 #endif
894
895 g_return_if_fail (style != NULL);
896 g_return_if_fail (window != NULL);
897
898 if (width == -1 || height == -1)
899 false_size = TRUE;
900
901 if ((width == -1) && (height == -1))
902 gdk_window_get_size (window, &width, &height);
903 else if (width == -1)
904 gdk_window_get_size (window, &width, NULL);
905 else if (height == -1)
906 gdk_window_get_size (window, NULL, &height);
907
908 cl_rectangle_reset (&r, style);
909
910 if (widget == NULL)
911 return;
912
913 /* listview headers */
914 if (widget && DETAIL ("button") && widget->parent &&
915 (GTK_IS_TREE_VIEW(widget->parent) ||
916 GTK_IS_CLIST (widget->parent) ||
917 strcmp(G_OBJECT_TYPE_NAME (widget->parent), "ETree") == 0))
918 {
919 cl_draw_treeview_header (style, window, state_type, shadow_type,
920 area, widget, detail, x, y, width, height);
921 }
922 else if (detail && (!strcmp (detail, "button") ||
923 !strcmp (detail, "buttondefault")))
924 {
925 if (GTK_IS_COMBO_BOX_ENTRY(widget->parent) || GTK_IS_COMBO(widget->parent))
926 {
927 cl_draw_combobox_button (style, window, state_type, shadow_type,
928 area, widget,
929 detail, x, y, width, height);
930 }
931 else
932 {
933 cl_draw_button (style, window, state_type, shadow_type, area, widget,
934 detail, x, y, width, height);
935 }
936 }
937 else if (detail && (
938 !strcmp (detail, "spinbutton_up") ||
939 !strcmp (detail, "spinbutton_down") ||
940 !strcmp (detail, "spinbutton")))
941 {
942 cl_draw_spinbutton (style, window, state_type, shadow_type, area,
943 widget, detail, x, y, width, height);
944 }
945 else if (detail && (
946 !strcmp (detail, "hscale") || !strcmp (detail, "vscale")))
947 {
948 cl_rectangle_set_button (&r, style, state_type,
949 GTK_WIDGET_HAS_DEFAULT (widget), GTK_WIDGET_HAS_FOCUS (widget),
950 CL_CORNER_ROUND, CL_CORNER_ROUND,
951 CL_CORNER_ROUND, CL_CORNER_ROUND);
952
953 if (!strcmp (detail, "hscale") || !strcmp (detail, "vscale"))
954 {
955 r.fill_gradient.to = &clearlooks_style->shade[2];
956 r.bottomright = clearlooks_style->shade_gc[2];
957 }
958
959 cl_set_corner_sharpness (detail, widget, &r);
960
961 if (!strcmp (detail, "spinbutton_up"))
962 {
963 r.border_gradient.to = r.border_gradient.from;
964 height++;
965 gtk_style_apply_default_background (style, window, FALSE, state_type,
966 area, x, y, width, height);
967 }
968 else if (!strcmp (detail, "spinbutton_down"))
969 {
970 r.border_gradient.to = r.border_gradient.from;
971 gtk_style_apply_default_background (style, window, FALSE, state_type,
972 area, x, y, width, height);
973 }
974
975 cl_rectangle_set_clip_rectangle (&r, area);
976 cl_draw_rectangle (window, widget, style, x+1, y+1, width-2, height-2, &r);
977 cl_draw_shadow (window, widget, style, x+1, y+1, width-2, height-2, &r);
978 cl_rectangle_reset_clip_rectangle (&r);
979 }
980 else if (DETAIL ("trough") && GTK_IS_PROGRESS_BAR (widget))
981 {
982 GdkPoint points[4] = { {x,y}, {x+width-1,y}, {x,y+height-1}, {x+width-1,y+height-1} };
983
984 gdk_draw_points (window, style->bg_gc[state_type], points, 4);
985
986 r.bordergc = clearlooks_style->shade_gc[5];
987 r.fillgc = clearlooks_style->shade_gc[2];
988
989 cl_rectangle_set_corners (&r, CL_CORNER_NARROW, CL_CORNER_NARROW,
990 CL_CORNER_NARROW, CL_CORNER_NARROW);
991
992 cl_rectangle_set_clip_rectangle (&r, area);
993 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
994 cl_rectangle_reset_clip_rectangle (&r);
995 }
996 else if (DETAIL ("trough") &&
997 (GTK_IS_VSCALE (widget) || GTK_IS_HSCALE (widget)))
998 {
999 GdkGC *inner = clearlooks_style->shade_gc[3],
1000 *outer = clearlooks_style->shade_gc[5],
1001 *shadow = clearlooks_style->shade_gc[4];
1002 GdkColor upper_color = *clearlooks_get_spot_color (CLEARLOOKS_RC_STYLE (style->rc_style)),
1003 lower_color;
1004
1005 GtkAdjustment *adjustment = gtk_range_get_adjustment (GTK_RANGE (widget));
1006
1007 GtkOrientation orientation = GTK_RANGE (widget)->orientation;
1008
1009 gint fill_size = (orientation ? height : width) *
1010 (1 / ((adjustment->upper - adjustment->lower) /
1011 (adjustment->value - adjustment->lower)));
1012
1013 if (orientation == GTK_ORIENTATION_HORIZONTAL)
1014 {
1015 y += (height - SCALE_SIZE) / 2;
1016 height = SCALE_SIZE;
1017 }
1018 else
1019 {
1020 x += (width - SCALE_SIZE) / 2;
1021 width = SCALE_SIZE;
1022 }
1023
1024 if (state_type == GTK_STATE_INSENSITIVE)
1025 {
1026 outer = clearlooks_style->shade_gc[4];
1027 inner = clearlooks_style->shade_gc[2];
1028 shadow = clearlooks_style->shade_gc[3];
1029 }
1030
1031 cl_rectangle_init (&r, inner, outer, CL_CORNER_NONE, CL_CORNER_NONE,
1032 CL_CORNER_NONE, CL_CORNER_NONE );
1033
1034 r.topleft = shadow;
1035
1036 cl_rectangle_set_clip_rectangle (&r, area);
1037 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
1038 cl_draw_shadow (window, widget, style, x, y, width, height, &r);
1039 cl_rectangle_reset_clip_rectangle (&r);
1040
1041 /* DRAW FILL */
1042 shade (&upper_color, &lower_color, 1.3);
1043
1044 r.bordergc = clearlooks_style->spot3_gc;
1045 r.fillgc = style->bg_gc[state_type];
1046
1047 r.gradient_type = (orientation == GTK_ORIENTATION_HORIZONTAL ) ? CL_GRADIENT_VERTICAL
1048 : CL_GRADIENT_HORIZONTAL;
1049
1050 cl_rectangle_set_gradient (&r.fill_gradient, &upper_color, &lower_color);
1051
1052 cl_rectangle_set_clip_rectangle (&r, area);
1053 if (orientation == GTK_ORIENTATION_HORIZONTAL && fill_size > 1)
1054 {
1055 if (gtk_range_get_inverted(GTK_RANGE(widget)) != (get_direction(widget) == GTK_TEXT_DIR_RTL))
1056 cl_draw_rectangle (window, widget, style, x+width-fill_size, y, fill_size, height, &r);
1057 else
1058 cl_draw_rectangle (window, widget, style, x, y, fill_size, height, &r);
1059 }
1060 else if (fill_size > 1)
1061 {
1062 if (gtk_range_get_inverted (GTK_RANGE (widget)))
1063 cl_draw_rectangle (window, widget, style, x, y+height-fill_size, width, fill_size, &r);
1064 else
1065 cl_draw_rectangle (window, widget, style, x, y, width, fill_size, &r);
1066 }
1067 cl_rectangle_reset_clip_rectangle (&r);
1068 }
1069 else if (DETAIL ("trough"))
1070 {
1071 GdkGC *inner = clearlooks_style->shade_gc[3],
1072 *outer = clearlooks_style->shade_gc[5];
1073
1074 cl_rectangle_init (&r, inner, outer, CL_CORNER_NONE, CL_CORNER_NONE,
1075 CL_CORNER_NONE, CL_CORNER_NONE );
1076
1077 if (GTK_RANGE (widget)->orientation == GTK_ORIENTATION_VERTICAL)
1078 {
1079 y+=1;
1080 height-=2;
1081 }
1082 else
1083 {
1084 x+=1;
1085 width-=2;
1086 }
1087
1088 cl_rectangle_set_clip_rectangle (&r, area);
1089 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
1090 cl_rectangle_reset_clip_rectangle (&r);
1091 }
1092 else if (detail && (!strcmp (detail, "vscrollbar") ||
1093 !strcmp (detail, "hscrollbar") ||
1094 !strcmp (detail, "stepper")))
1095 {
1096 ClScrollButtonType button_type = CL_SCROLLBUTTON_OTHER;
1097 gboolean horizontal = TRUE;
1098
1099 if (GTK_IS_VSCROLLBAR(widget))
1100 {
1101 if (y == widget->allocation.y)
1102 button_type = CL_SCROLLBUTTON_BEGIN;
1103 else if (y+height == widget->allocation.y+widget->allocation.height)
1104 button_type = CL_SCROLLBUTTON_END;
1105
1106 horizontal = FALSE;
1107 }
1108 else if (GTK_IS_HSCROLLBAR(widget))
1109 {
1110 if (x == widget->allocation.x)
1111 button_type = CL_SCROLLBUTTON_BEGIN;
1112 else if (x+width == widget->allocation.x+widget->allocation.width)
1113 button_type = CL_SCROLLBUTTON_END;
1114 }
1115
1116 cl_rectangle_set_button (&r, style, state_type, FALSE, FALSE, 0,0,0,0);
1117
1118 cl_rectangle_set_gradient (&r.fill_gradient, NULL, NULL);
1119 cl_rectangle_set_gradient (&r.fill_gradient, &clearlooks_style->inset_light[state_type],
1120 &clearlooks_style->inset_dark[state_type]);
1121
1122
1123 r.gradient_type = horizontal ? CL_GRADIENT_VERTICAL
1124 : CL_GRADIENT_HORIZONTAL;
1125
1126 r.bottomright = clearlooks_style->shade_gc[1];
1127 r.border_gradient.to = r.border_gradient.from;
1128
1129 if (button_type == CL_SCROLLBUTTON_OTHER)
1130 {
1131 cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
1132 CL_CORNER_NONE, CL_CORNER_NONE);
1133 }
1134 else if (button_type == CL_SCROLLBUTTON_BEGIN)
1135 {
1136 if (horizontal)
1137 cl_rectangle_set_corners (&r, CL_CORNER_ROUND, CL_CORNER_NONE,
1138 CL_CORNER_ROUND, CL_CORNER_NONE);
1139 else
1140 cl_rectangle_set_corners (&r, CL_CORNER_ROUND, CL_CORNER_ROUND,
1141 CL_CORNER_NONE, CL_CORNER_NONE);
1142 }
1143 else
1144 {
1145 if (horizontal)
1146 cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_ROUND,
1147 CL_CORNER_NONE, CL_CORNER_ROUND);
1148 else
1149 cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
1150 CL_CORNER_ROUND, CL_CORNER_ROUND);
1151 }
1152
1153 cl_rectangle_set_clip_rectangle (&r, area);
1154 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
1155 cl_draw_shadow (window, widget, style, x, y, width, height, &r);
1156 cl_rectangle_reset_clip_rectangle (&r);
1157
1158 }
1159 else if (DETAIL ("slider"))
1160 {
1161 if (DETAIL("slider") && widget && GTK_IS_RANGE (widget))
1162 {
1163 GtkAdjustment *adj = GTK_RANGE (widget)->adjustment;
1164
1165 if (adj->value <= adj->lower &&
1166 (GTK_RANGE (widget)->has_stepper_a || GTK_RANGE (widget)->has_stepper_b))
1167 {
1168 if (GTK_IS_VSCROLLBAR (widget))
1169 {
1170 y-=1;
1171 height+=1;
1172 }
1173 else if (GTK_IS_HSCROLLBAR (widget))
1174 {
1175 x-=1;
1176 width+=1;
1177 }
1178 }
1179 if (adj->value >= adj->upper - adj->page_size &&
1180 (GTK_RANGE (widget)->has_stepper_c || GTK_RANGE (widget)->has_stepper_d))
1181 {
1182 if (GTK_IS_VSCROLLBAR (widget))
1183 height+=1;
1184 else if (GTK_IS_HSCROLLBAR (widget))
1185 width+=1;
1186 }
1187 }
1188
1189 cl_rectangle_set_button (&r, style, state_type, FALSE, GTK_WIDGET_HAS_FOCUS (widget),
1190 CL_CORNER_NONE, CL_CORNER_NONE,
1191 CL_CORNER_NONE, CL_CORNER_NONE);
1192
1193 r.gradient_type = GTK_IS_HSCROLLBAR (widget) ? CL_GRADIENT_VERTICAL
1194 : CL_GRADIENT_HORIZONTAL;
1195
1196 cl_rectangle_set_gradient (&r.fill_gradient, &clearlooks_style->inset_light[state_type],
1197 &clearlooks_style->inset_dark[state_type]);
1198
1199 r.bottomright = clearlooks_style->shade_gc[1];
1200 r.border_gradient.to = r.border_gradient.from;
1201
1202 cl_rectangle_set_clip_rectangle (&r, area);
1203 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
1204 cl_draw_shadow (window, widget, style, x, y, width, height, &r);
1205 cl_rectangle_reset_clip_rectangle (&r);
1206 }
1207 else if (detail && !strcmp (detail, "optionmenu")) /* supporting deprecated */
1208 {
1209 cl_draw_optionmenu(style, window, state_type, shadow_type, area, widget, detail, x, y, width, height);
1210 }
1211 else if (DETAIL ("menuitem"))
1212 {
1213 if (clearlooks_style->menuitemstyle == 0)
1214 {
1215 cl_draw_menuitem_flat (window, widget, style, area, state_type,
1216 x, y, width, height, &r);
1217 }
1218 else if (clearlooks_style->menuitemstyle == 1)
1219 {
1220 cl_draw_menuitem_gradient (window, widget, style, area, state_type,
1221 x, y, width, height, &r);
1222 }
1223 else
1224 {
1225 cl_draw_menuitem_button (window, widget, style, area, state_type,
1226 x, y, width, height, &r);
1227 }
1228 }
1229 else if (DETAIL ("menubar") && (clearlooks_style->sunkenmenubar || clearlooks_style->menubarstyle > 0))
1230 {
1231 GdkGC *dark = clearlooks_style->shade_gc[2];
1232 GdkColor upper_color, lower_color;
1233
1234 /* don't draw sunken menubar on gnome panel
1235 IT'S A HACK! HORRIBLE HACK! HIDEOUS HACK!
1236 BUT IT WORKS FOR ME(tm)! */
1237 if (widget->parent &&
1238 strcmp(G_OBJECT_TYPE_NAME (widget->parent), "PanelWidget") == 0)
1239 return;
1240
1241 shade(&style->bg[state_type], &upper_color, 1.0);
1242 shade(&style->bg[state_type], &lower_color, 0.95);
1243
1244 cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
1245 CL_CORNER_NONE, CL_CORNER_NONE);
1246
1247 r.fillgc = style->bg_gc[state_type];
1248 r.bordergc = clearlooks_style->shade_gc[2];
1249 r.gradient_type = CL_GRADIENT_VERTICAL;
1250
1251 cl_rectangle_set_gradient (&r.border_gradient, &clearlooks_style->shade[2],
1252 &clearlooks_style->shade[3]);
1253 cl_rectangle_set_gradient (&r.fill_gradient, &upper_color, &lower_color);
1254
1255 /* make vertical and top borders invisible for style 2 */
1256 if (clearlooks_style->menubarstyle == 2) {
1257 x--; width+=2;
1258 y--; height+=1;
1259 }
1260
1261 cl_rectangle_set_clip_rectangle (&r, area);
1262 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
1263 cl_rectangle_reset_clip_rectangle (&r);
1264 }
1265 else if (DETAIL ("menu") && widget->parent &&
1266 GDK_IS_WINDOW (widget->parent->window))
1267 {
1268 cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
1269 CL_CORNER_NONE, CL_CORNER_NONE);
1270
1271 r.bordergc = clearlooks_style->border_gc[CL_BORDER_UPPER];
1272 r.topleft = style->light_gc[state_type];
1273 r.bottomright = clearlooks_style->shade_gc[1];
1274
1275 cl_rectangle_set_clip_rectangle (&r, area);
1276 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
1277 cl_draw_shadow (window, widget, style, x, y, width, height, &r);
1278 cl_rectangle_reset_clip_rectangle (&r);
1279
1280 return;
1281 }
1282 else if (DETAIL ("bar") && widget && GTK_IS_PROGRESS_BAR (widget))
1283 {
1284 GdkColor upper_color = *clearlooks_get_spot_color (CLEARLOOKS_RC_STYLE (style->rc_style)),
1285 lower_color,
1286 prev_foreground;
1287 gboolean activity_mode = GTK_PROGRESS (widget)->activity_mode;
1288
1289 #ifdef HAVE_ANIMATION
1290 if (!activity_mode && gtk_progress_bar_get_fraction (widget) != 1.0 &&
1291 !cl_progressbar_known((gconstpointer)widget))
1292 {
1293 cl_progressbar_add ((gpointer)widget);
1294 }
1295 #endif
1296 cl_progressbar_fill (window, widget, style, style->black_gc,
1297 x, y, width, height,
1298 #ifdef HAVE_ANIMATION
1299 activity_mode ? 0 : pboffset,
1300 #else
1301 0,
1302 #endif
1303 area);
1304
1305 cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
1306 CL_CORNER_NONE, CL_CORNER_NONE);
1307
1308 r.bordergc = clearlooks_style->spot3_gc;
1309 r.topleft = clearlooks_style->spot2_gc;
1310
1311 prev_foreground = cl_gc_set_fg_color_shade (clearlooks_style->spot2_gc,
1312 style->colormap,
1313 &clearlooks_style->spot2,
1314 1.2);
1315
1316 cl_rectangle_set_clip_rectangle (&r, area);
1317 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
1318 cl_draw_shadow (window, widget, style, x, y, width, height, &r);
1319 cl_rectangle_reset_clip_rectangle (&r);
1320
1321 gdk_gc_set_foreground (clearlooks_style->spot2_gc, &prev_foreground);
1322 }
1323
1324 else if ( widget && (DETAIL ("menubar") || DETAIL ("toolbar") || DETAIL ("dockitem_bin") || DETAIL ("handlebox_bin")) && shadow_type != GTK_SHADOW_NONE) /* Toolbars and menus */
1325 {
1326 if (area)
1327 {
1328 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], area);
1329 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], area);
1330 }
1331
1332 gtk_style_apply_default_background (style, window,
1333 widget && !GTK_WIDGET_NO_WINDOW (widget),
1334 state_type, area, x, y, width, height);
1335
1336 /* we only want the borders on horizontal toolbars */
1337 if ( DETAIL ("menubar") || height < 2*width ) {
1338 if (!DETAIL ("menubar"))
1339 gdk_draw_line (window, clearlooks_style->shade_gc[0],
1340 x, y, x + width, y); /* top */
1341
1342 gdk_draw_line (window, clearlooks_style->shade_gc[3],
1343 x, y + height - 1, x + width, y + height - 1); /* bottom */
1344 }
1345
1346 if (area)
1347 {
1348 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[0], NULL);
1349 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[3], NULL);
1350 }
1351 }
1352 else
1353 {
1354 parent_class->draw_box (style, window, state_type, shadow_type, area,
1355 widget, detail, x, y, width, height);
1356 }
1357 }
1358
1359 /**************************************************************************/
1360
1361 static void
1362 ensure_check_pixmaps (GtkStyle *style,
1363 GtkStateType state,
1364 GdkScreen *screen,
1365 gboolean treeview)
1366 {
1367 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1368 ClearlooksRcStyle *clearlooks_rc = CLEARLOOKS_RC_STYLE (style->rc_style);
1369 GdkPixbuf *check, *base, *inconsistent, *composite;
1370 GdkColor *spot_color = clearlooks_get_spot_color (clearlooks_rc);
1371
1372 if (clearlooks_style->check_pixmap_nonactive[state] != NULL)
1373 return;
1374
1375 if (state == GTK_STATE_ACTIVE || state == GTK_STATE_SELECTED) {
1376 check = generate_bit (check_alpha, &style->text[GTK_STATE_NORMAL], 1.0);
1377 inconsistent = generate_bit (check_inconsistent_alpha, &style->text[GTK_STATE_NORMAL], 1.0);
1378 } else {
1379 check = generate_bit (check_alpha, &style->text[state], 1.0);
1380 inconsistent = generate_bit (check_inconsistent_alpha, &style->text[state], 1.0);
1381 }
1382
1383 if (state == GTK_STATE_ACTIVE && !treeview)
1384 base = generate_bit (check_base_alpha, &style->bg[state], 1.0);
1385 else
1386 base = generate_bit (check_base_alpha, &style->base[GTK_STATE_NORMAL], 1.0);
1387
1388 if (treeview)
1389 composite = generate_bit (NULL, &clearlooks_style->shade[6], 1.0);
1390 else
1391 composite = generate_bit (NULL, &clearlooks_style->shade[5], 1.0);
1392
1393 gdk_pixbuf_composite (base, composite,
1394 0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1395 1.0, 1.0, GDK_INTERP_NEAREST, 255);
1396
1397 clearlooks_style->check_pixmap_nonactive[state] =
1398 pixbuf_to_pixmap (style, composite, screen);
1399
1400 gdk_pixbuf_composite (check, composite,
1401 0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1402 1.0, 1.0, GDK_INTERP_NEAREST, 255);
1403
1404 clearlooks_style->check_pixmap_active[state] =
1405 pixbuf_to_pixmap (style, composite, screen);
1406
1407 g_object_unref (composite);
1408
1409 composite = generate_bit (NULL, &clearlooks_style->shade[6], 1.0);
1410
1411 gdk_pixbuf_composite (base, composite,
1412 0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1413 1.0, 1.0, GDK_INTERP_NEAREST, 255);
1414
1415 gdk_pixbuf_composite (inconsistent, composite,
1416 0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1417 1.0, 1.0, GDK_INTERP_NEAREST, 255);
1418
1419 clearlooks_style->check_pixmap_inconsistent[state] =
1420 pixbuf_to_pixmap (style, composite, screen);
1421
1422 g_object_unref (composite);
1423 g_object_unref (base);
1424 g_object_unref (check);
1425 g_object_unref (inconsistent);
1426 }
1427
1428 static void
1429 draw_check (DRAW_ARGS)
1430 {
1431 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1432 GdkGC *gc = style->base_gc[state_type];
1433 GdkPixmap *pixmap;
1434 gboolean treeview;
1435
1436 if (DETAIL ("check")) /* Menu item */
1437 {
1438 parent_class->draw_check (style, window, state_type, shadow_type, area,
1439 widget, detail, x, y, width, height);
1440 return;
1441 }
1442
1443 treeview = widget && GTK_IS_TREE_VIEW(widget);
1444 ensure_check_pixmaps (style, state_type, gtk_widget_get_screen (widget), treeview);
1445
1446 if (area)
1447 gdk_gc_set_clip_rectangle (gc, area);
1448
1449 if (shadow_type == GTK_SHADOW_IN)
1450 pixmap = clearlooks_style->check_pixmap_active[state_type];
1451 else if (shadow_type == GTK_SHADOW_ETCHED_IN) /* inconsistent */
1452 pixmap = clearlooks_style->check_pixmap_inconsistent[state_type];
1453 else
1454 pixmap = clearlooks_style->check_pixmap_nonactive[state_type];
1455
1456 x += (width - CHECK_SIZE)/2;
1457 y += (height - CHECK_SIZE)/2;
1458
1459 gdk_draw_drawable (window, gc, pixmap, 0, 0, x, y, CHECK_SIZE, CHECK_SIZE);
1460
1461 if (area)
1462 gdk_gc_set_clip_rectangle (gc, NULL);
1463 }
1464
1465 /**************************************************************************/
1466 static void
1467 draw_slider (DRAW_ARGS, GtkOrientation orientation)
1468 {
1469 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1470 GdkGC *shade_gc = clearlooks_style->shade_gc[4];
1471 GdkGC *white_gc = clearlooks_style->shade_gc[0];
1472 int x1, y1;
1473
1474 #if DEBUG
1475 printf("draw_slider: %s %d %d %d %d\n", detail, x, y, width, height);
1476 #endif
1477
1478 g_return_if_fail (GTK_IS_STYLE (style));
1479 g_return_if_fail (window != NULL);
1480
1481 sanitize_size (window, &width, &height);
1482
1483 gtk_paint_box (style, window, state_type, shadow_type,
1484 area, widget, detail, x, y, width, height);
1485
1486 if ((orientation == GTK_ORIENTATION_VERTICAL && height < 20) ||
1487 (orientation == GTK_ORIENTATION_HORIZONTAL && width < 20))
1488 return;
1489
1490 if (detail && strcmp ("slider", detail) == 0)
1491 {
1492 if (area)
1493 {
1494 gdk_gc_set_clip_rectangle (shade_gc, area);
1495 gdk_gc_set_clip_rectangle (white_gc, area);
1496 }
1497 if (orientation == GTK_ORIENTATION_HORIZONTAL)
1498 {
1499 x1 = x + width / 2 - 4;
1500 y1 = y + (height - 6) / 2;
1501 gdk_draw_line (window, shade_gc, x1, y1, x1, y1 + 6);
1502 gdk_draw_line (window, white_gc, x1 + 1, y1, x1 + 1, y1 + 6);
1503 gdk_draw_line (window, shade_gc, x1 + 3, y1, x1 + 3, y1 + 6);
1504 gdk_draw_line (window, white_gc, x1 + 3 + 1, y1, x1 + 3 + 1, y1 + 6);
1505 gdk_draw_line (window, shade_gc, x1 + 3*2, y1, x1 + 3*2, y1 + 6);
1506 gdk_draw_line (window, white_gc, x1 + 3*2 + 1, y1, x1 + 3*2 + 1, y1 + 6);
1507 }
1508 else
1509 {
1510 x1 = x + (width - 6) / 2;
1511 y1 = y + height / 2 - 4;
1512 gdk_draw_line (window, shade_gc, x1 + 6, y1, x1, y1);
1513 gdk_draw_line (window, white_gc, x1 + 6, y1 + 1, x1, y1 + 1);
1514 gdk_draw_line (window, shade_gc, x1 + 6, y1 + 3, x1, y1 + 3);
1515 gdk_draw_line (window, white_gc, x1 + 6, y1 + 3 + 1, x1, y1 + 3 + 1);
1516 gdk_draw_line (window, shade_gc, x1 + 6, y1 + 3*2, x1, y1 + 3*2);
1517 gdk_draw_line (window, white_gc, x1 + 6, y1 + 3*2 + 1, x1, y1 + 3*2 + 1);
1518 }
1519 if (area)
1520 {
1521 gdk_gc_set_clip_rectangle (shade_gc, NULL);
1522 gdk_gc_set_clip_rectangle (white_gc, NULL);
1523 }
1524 }
1525 else if (detail && (strcmp ("hscale", detail) == 0 || strcmp ("vscale", detail) == 0))
1526 {
1527 if (area)
1528 {
1529 gdk_gc_set_clip_rectangle (shade_gc, area);
1530 gdk_gc_set_clip_rectangle (white_gc, area);
1531 }
1532
1533 if (orientation == GTK_ORIENTATION_HORIZONTAL)
1534 {
1535 x1 = x + width / 2 - 3;
1536 y1 = y + (height - 7) / 2;
1537 gdk_draw_line (window, shade_gc, x1 + 0, y1 + 5, x1 + 0, y1 + 1);
1538 gdk_draw_line (window, white_gc, x1 + 1, y1 + 5, x1 + 1, y1 + 1);
1539 gdk_draw_line (window, shade_gc, x1 + 3, y1 + 5, x1 + 3, y1 + 1);
1540 gdk_draw_line (window, white_gc, x1 + 4, y1 + 5, x1 + 4, y1 + 1);
1541 gdk_draw_line (window, shade_gc, x1 + 6, y1 + 5, x1 + 6, y1 + 1);
1542 gdk_draw_line (window, white_gc, x1 + 7, y1 + 5, x1 + 7, y1 + 1);
1543 }
1544 else
1545 {
1546 x1 = x + (width - 7) / 2;
1547 y1 = y + height / 2 - 3;
1548 gdk_draw_line (window, shade_gc, x1 + 5, y1 + 0, x1 + 1, y1 + 0);
1549 gdk_draw_line (window, white_gc, x1 + 5, y1 + 1, x1 + 1, y1 + 1);
1550 gdk_draw_line (window, shade_gc, x1 + 5, y1 + 3, x1 + 1, y1 + 3);
1551 gdk_draw_line (window, white_gc, x1 + 5, y1 + 4, x1 + 1, y1 + 4);
1552 gdk_draw_line (window, shade_gc, x1 + 5, y1 + 6, x1 + 1, y1 + 6);
1553 gdk_draw_line (window, white_gc, x1 + 5, y1 + 7, x1 + 1, y1 + 7);
1554 }
1555 if (area)
1556 {
1557 gdk_gc_set_clip_rectangle (shade_gc, NULL);
1558 gdk_gc_set_clip_rectangle (white_gc, NULL);
1559 }
1560 }
1561 }
1562
1563 /**************************************************************************/
1564 static void
1565 ensure_radio_pixmaps (GtkStyle *style,
1566 GtkStateType state,
1567 GdkScreen *screen)
1568 {
1569 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1570 ClearlooksRcStyle *clearlooks_rc = CLEARLOOKS_RC_STYLE (style->rc_style);
1571 GdkPixbuf *dot, *circle, *outline, *inconsistent, *composite;
1572 GdkColor *spot_color = clearlooks_get_spot_color (clearlooks_rc);
1573 GdkColor *composite_color;
1574
1575 if (clearlooks_style->radio_pixmap_nonactive[state] != NULL)
1576 return;
1577
1578 if (state == GTK_STATE_ACTIVE || state == GTK_STATE_SELECTED) {
1579 dot = colorize_bit (dot_intensity, dot_alpha, &style->text[GTK_STATE_NORMAL]);
1580 inconsistent = generate_bit (inconsistent_alpha, &style->text[GTK_STATE_NORMAL], 1.0);
1581 } else {
1582 dot = colorize_bit (dot_intensity, dot_alpha, &style->text[state]);
1583 inconsistent = generate_bit (inconsistent_alpha, &style->text[state], 1.0);
1584 }
1585
1586 outline = generate_bit (outline_alpha, &clearlooks_style->shade[5], 1.0);
1587
1588 if (clearlooks_style->radio_pixmap_mask == NULL)
1589 {
1590 gdk_pixbuf_render_pixmap_and_mask (outline,
1591 NULL,
1592 &clearlooks_style->radio_pixmap_mask,
1593 1);
1594 }
1595
1596 if (state == GTK_STATE_ACTIVE)
1597 {
1598 composite_color = &style->bg[GTK_STATE_PRELIGHT];
1599 circle = generate_bit (circle_alpha, &style->bg[state], 1.0);
1600 }
1601 else
1602 {
1603 composite_color = &style->bg[state];
1604 circle = generate_bit (circle_alpha, &style->base[GTK_STATE_NORMAL], 1.0);
1605 }
1606
1607 composite = generate_bit (NULL, composite_color, 1.0);
1608
1609 gdk_pixbuf_composite (outline, composite,
1610 0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1611 1.0, 1.0, GDK_INTERP_NEAREST, 255);
1612
1613 gdk_pixbuf_composite (circle, composite,
1614 0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1615 1.0, 1.0, GDK_INTERP_NEAREST, 255);
1616
1617 clearlooks_style->radio_pixmap_nonactive[state] =
1618 pixbuf_to_pixmap (style, composite, screen);
1619
1620 gdk_pixbuf_composite (dot, composite,
1621 0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1622 1.0, 1.0, GDK_INTERP_NEAREST, 255);
1623
1624 clearlooks_style->radio_pixmap_active[state] =
1625 pixbuf_to_pixmap (style, composite, screen);
1626
1627 g_object_unref (composite);
1628
1629 composite = generate_bit (NULL, composite_color,1.0);
1630
1631 gdk_pixbuf_composite (outline, composite,
1632 0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1633 1.0, 1.0, GDK_INTERP_NEAREST, 255);
1634 gdk_pixbuf_composite (circle, composite,
1635 0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1636 1.0, 1.0, GDK_INTERP_NEAREST, 255);
1637 gdk_pixbuf_composite (inconsistent, composite,
1638 0, 0, RADIO_SIZE, RADIO_SIZE, 0, 0,
1639 1.0, 1.0, GDK_INTERP_NEAREST, 255);
1640
1641 clearlooks_style->radio_pixmap_inconsistent[state] =
1642 pixbuf_to_pixmap (style, composite, screen);
1643
1644 g_object_unref (composite);
1645 g_object_unref (circle);
1646 g_object_unref (dot);
1647 g_object_unref (inconsistent);
1648 g_object_unref (outline);
1649 }
1650
1651 static void
1652 draw_option (DRAW_ARGS)
1653 {
1654 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1655 GdkGC *gc = style->base_gc[state_type];
1656 GdkPixmap *pixmap;
1657
1658 if (DETAIL ("option")) /* Menu item */
1659 {
1660 parent_class->draw_option (style, window, state_type, shadow_type,
1661 area, widget, detail, x, y, width, height);
1662 return;
1663 }
1664
1665 ensure_radio_pixmaps (style, state_type, gtk_widget_get_screen (widget));
1666
1667 if (area)
1668 gdk_gc_set_clip_rectangle (gc, area);
1669
1670 if (shadow_type == GTK_SHADOW_IN)
1671 pixmap = clearlooks_style->radio_pixmap_active[state_type];
1672 else if (shadow_type == GTK_SHADOW_ETCHED_IN) /* inconsistent */
1673 pixmap = clearlooks_style->radio_pixmap_inconsistent[state_type];
1674 else
1675 pixmap = clearlooks_style->radio_pixmap_nonactive[state_type];
1676
1677 x += (width - RADIO_SIZE)/2;
1678 y += (height - RADIO_SIZE)/2;
1679
1680 #ifndef GTKOSX
1681 gdk_gc_set_clip_mask (gc, clearlooks_style->radio_pixmap_mask);
1682 gdk_gc_set_clip_origin (gc, x, y);
1683 #endif
1684
1685 gdk_draw_drawable (window, gc, pixmap, 0, 0, x, y,
1686 RADIO_SIZE, RADIO_SIZE);
1687
1688 #ifndef GTKOSX
1689 gdk_gc_set_clip_origin (gc, 0, 0);
1690 gdk_gc_set_clip_mask (gc, NULL);
1691 #endif
1692
1693 if (area)
1694 gdk_gc_set_clip_rectangle (gc, NULL);
1695 }
1696
1697 /**************************************************************************/
1698
1699 static void
1700 draw_shadow_gap (DRAW_ARGS,
1701 GtkPositionType gap_side,
1702 gint gap_x,
1703 gint gap_width)
1704 {
1705 /* I need to improve this function. */
1706 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1707 CLRectangle r;
1708 GdkRegion *area_region = NULL,
1709 *gap_region = NULL;
1710
1711 #if DEBUG
1712 printf("draw_shadow_gap: %s %d %d %d %d\n", detail, x, y, width, height);
1713 #endif
1714
1715 g_return_if_fail (GTK_IS_STYLE (style));
1716 g_return_if_fail (window != NULL);
1717
1718 sanitize_size (window, &width, &height);
1719
1720 cl_rectangle_reset (&r, style);
1721 cl_rectangle_set_corners (&r, CL_CORNER_NONE, CL_CORNER_NONE,
1722 CL_CORNER_NONE, CL_CORNER_NONE);
1723
1724 if (area)
1725 {
1726 area_region = gdk_region_rectangle (area);
1727
1728 switch (gap_side)
1729 {
1730 case GTK_POS_TOP:
1731 {
1732 GdkRectangle rect = { x+gap_x, y, gap_width, 2 };
1733 gap_region = gdk_region_rectangle (&rect);
1734 break;
1735 }
1736 case GTK_POS_BOTTOM:
1737 {
1738 GdkRectangle rect = { x+gap_x, y+height-2, gap_width, 2 };
1739 gap_region = gdk_region_rectangle (&rect);
1740 break;
1741 }
1742 case GTK_POS_LEFT:
1743 {
1744 GdkRectangle rect = { x, y+gap_x, 2, gap_width };
1745 gap_region = gdk_region_rectangle (&rect);
1746 break;
1747 }
1748 case GTK_POS_RIGHT:
1749 {
1750 GdkRectangle rect = { x+width-2, y+gap_x, 2, gap_width };
1751 gap_region = gdk_region_rectangle (&rect);
1752 break;
1753 }
1754 }
1755
1756 gdk_region_subtract (area_region, gap_region);
1757 }
1758
1759 if (shadow_type == GTK_SHADOW_ETCHED_IN ||
1760 shadow_type == GTK_SHADOW_ETCHED_OUT)
1761 {
1762 GdkGC *a;
1763 GdkGC *b;
1764
1765 if (shadow_type == GTK_SHADOW_ETCHED_IN)
1766 {
1767 a = style->light_gc[state_type];
1768 b = clearlooks_style->shade_gc[3];
1769 }
1770 else
1771 {
1772 a = clearlooks_style->shade_gc[3];
1773 b = style->light_gc[state_type];
1774 }
1775
1776 gdk_gc_set_clip_region (a, area_region);
1777 gdk_gc_set_clip_region (b, area_region);
1778
1779 r.bordergc = a;
1780 cl_draw_rectangle (window, widget, style, x+1, y+1, width-1, height-1, &r);
1781
1782 r.bordergc = b;
1783 cl_draw_rectangle (window, widget, style, x, y, width-1, height-1, &r);
1784
1785 gdk_gc_set_clip_region (a, NULL);
1786 gdk_gc_set_clip_region (b, NULL);
1787 }
1788 else if (shadow_type == GTK_SHADOW_IN || shadow_type == GTK_SHADOW_OUT)
1789 {
1790 r.topleft = (shadow_type == GTK_SHADOW_OUT) ? style->light_gc[state_type] : clearlooks_style->shade_gc[1];
1791 r.bottomright = (shadow_type == GTK_SHADOW_OUT) ? clearlooks_style->shade_gc[1] : style->light_gc[state_type];
1792 r.bordergc = clearlooks_style->shade_gc[5];
1793
1794 gdk_gc_set_clip_region (r.bordergc, area_region);
1795 gdk_gc_set_clip_region (r.topleft, area_region);
1796 gdk_gc_set_clip_region (r.bottomright, area_region);
1797
1798 cl_draw_rectangle (window, widget, style, x, y, width, height, &r);
1799
1800 cl_draw_shadow (window, widget, style, x, y, width, height, &r);
1801
1802 gdk_gc_set_clip_region (r.bordergc, NULL);
1803 gdk_gc_set_clip_region (r.topleft, NULL);
1804 gdk_gc_set_clip_region (r.bottomright, NULL);
1805 }
1806
1807 if (area_region)
1808 gdk_region_destroy (area_region);
1809 }
1810
1811 /**************************************************************************/
1812 static void
1813 draw_hline (GtkStyle *style,
1814 GdkWindow *window,
1815 GtkStateType state_type,
1816 GdkRectangle *area,
1817 GtkWidget *widget,
1818 const gchar *detail,
1819 gint x1,
1820 gint x2,
1821 gint y)
1822 {
1823 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1824
1825 #if DEBUG
1826 printf("draw_hline\n");
1827 #endif
1828
1829 g_return_if_fail (GTK_IS_STYLE (style));
1830 g_return_if_fail (window != NULL);
1831
1832 if (area)
1833 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[2], area);
1834
1835 if (detail && !strcmp (detail, "label"))
1836 {
1837 if (state_type == GTK_STATE_INSENSITIVE)
1838 gdk_draw_line (window, style->light_gc[state_type], x1 + 1, y + 1, x2 + 1, y + 1);
1839
1840 gdk_draw_line (window, style->fg_gc[state_type], x1, y, x2, y);
1841 }
1842 else
1843 {
1844 gdk_draw_line (window, clearlooks_style->shade_gc[2], x1, y, x2, y);
1845
1846 /* if (DETAIL ("menuitem")) */
1847 gdk_draw_line (window, clearlooks_style->shade_gc[0], x1, y+1, x2, y+1);
1848 }
1849
1850 if (area)
1851 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[2], NULL);
1852 }
1853
1854 /**************************************************************************/
1855 static void
1856 draw_vline (GtkStyle *style,
1857 GdkWindow *window,
1858 GtkStateType state_type,
1859 GdkRectangle *area,
1860 GtkWidget *widget,
1861 const gchar *detail,
1862 gint y1,
1863 gint y2,
1864 gint x)
1865 {
1866 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1867 gint thickness_light;
1868 gint thickness_dark;
1869
1870 #if DEBUG
1871 printf("draw_vline\n");
1872 #endif
1873
1874 g_return_if_fail (GTK_IS_STYLE (style));
1875 g_return_if_fail (window != NULL);
1876
1877 thickness_light = style->xthickness / 2;
1878 thickness_dark = style->xthickness - thickness_light;
1879
1880 if (area)
1881 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[2], area);
1882
1883 gdk_draw_line (window, clearlooks_style->shade_gc[2], x, y1, x, y2 - 1);
1884 gdk_draw_line (window, clearlooks_style->shade_gc[0], x+1, y1, x+1, y2 - 1);
1885
1886 if (area)
1887 gdk_gc_set_clip_rectangle (clearlooks_style->shade_gc[2], NULL);
1888 }
1889
1890 /**************************************************************************/
1891 static void
1892 draw_focus (GtkStyle *style,
1893 GdkWindow *window,
1894 GtkStateType state_type,
1895 GdkRectangle *area,
1896 GtkWidget *widget,
1897 const gchar *detail,
1898 gint x,
1899 gint y,
1900 gint width,
1901 gint height)
1902 {
1903 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
1904 GdkPoint points[5];
1905 GdkGC *gc;
1906 gboolean free_dash_list = FALSE;
1907 gint line_width = 1;
1908 gchar *dash_list = "\1\1";
1909 gint dash_len;
1910
1911 #if DEBUG
1912 printf("draw_focus: %s %d %d %d %d\n", detail, x, y, width, height);
1913 #endif
1914
1915 gc = clearlooks_style->shade_gc[6];
1916
1917 if (widget)
1918 {
1919 gtk_widget_style_get (widget,
1920 "focus-line-width", &line_width,
1921 "focus-line-pattern", (gchar *)&dash_list,
1922 NULL);
1923
1924 free_dash_list = TRUE;
1925 }
1926
1927 sanitize_size (window, &width, &height);
1928
1929 if (area)
1930 gdk_gc_set_clip_rectangle (gc, area);
1931
1932 gdk_gc_set_line_attributes (gc, line_width,
1933 dash_list[0] ? GDK_LINE_ON_OFF_DASH : GDK_LINE_SOLID,
1934 GDK_CAP_BUTT, GDK_JOIN_MITER);
1935
1936
1937 if (detail && !strcmp (detail, "add-mode"))
1938 {
1939 if (free_dash_list)
1940 g_free (dash_list);
1941
1942 dash_list = "\4\4";
1943 free_dash_list = FALSE;
1944 }
1945
1946 points[0].x = x + line_width / 2;
1947 points[0].y = y + line_width / 2;
1948 points[1].x = x + width - line_width + line_width / 2;
1949 points[1].y = y + line_width / 2;
1950 points[2].x = x + width - line_width + line_width / 2;
1951 points[2].y = y + height - line_width + line_width / 2;
1952 points[3].x = x + line_width / 2;
1953 points[3].y = y + height - line_width + line_width / 2;
1954 points[4] = points[0];
1955
1956 if (!dash_list[0])
1957 {
1958 gdk_draw_lines (window, gc, points, 5);
1959 }
1960 else
1961 {
1962 dash_len = strlen (dash_list);
1963
1964 if (dash_list[0])
1965 gdk_gc_set_dashes (gc, 0, dash_list, dash_len);
1966
1967 gdk_draw_lines (window, gc, points, 3);
1968
1969 points[2].x += 1;
1970
1971 if (dash_list[0])
1972 {
1973 gint dash_pixels = 0;
1974 gint i;
1975
1976 /* Adjust the dash offset for the bottom and left so we
1977 * match up at the upper left.
1978 */
1979 for (i = 0; i < dash_len; i++)
1980 dash_pixels += dash_list[i];
1981
1982 if (dash_len % 2 == 1)
1983 dash_pixels *= 2;
1984
1985 gdk_gc_set_dashes (gc,
1986 dash_pixels - (width + height - 2 * line_width) % dash_pixels,
1987 dash_list, dash_len);
1988 }
1989
1990 gdk_draw_lines (window, gc, points + 2, 3);
1991 }
1992
1993 gdk_gc_set_line_attributes (gc, 0, GDK_LINE_SOLID, GDK_CAP_BUTT, GDK_JOIN_MITER);
1994
1995 if (area)
1996 gdk_gc_set_clip_rectangle (gc, NULL);
1997
1998 if (free_dash_list)
1999 g_free (dash_list);
2000 }
2001
2002 static void
2003 draw_layout(GtkStyle * style,
2004 GdkWindow * window,
2005 GtkStateType state_type,
2006 gboolean use_text,
2007 GdkRectangle * area,
2008 GtkWidget * widget,
2009 const gchar * detail, gint x, gint y, PangoLayout * layout)
2010 {
2011 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
2012
2013 g_return_if_fail(GTK_IS_STYLE (style));
2014 g_return_if_fail(window != NULL);
2015
2016 parent_class->draw_layout(style, window, state_type, use_text,
2017 area, widget, detail, x, y, layout);
2018
2019
2020 }
2021
2022 /**************************************************************************/
2023 static void
2024 draw_resize_grip (GtkStyle *style,
2025 GdkWindow *window,
2026 GtkStateType state_type,
2027 GdkRectangle *area,
2028 GtkWidget *widget,
2029 const gchar *detail,
2030 GdkWindowEdge edge,
2031 gint x,
2032 gint y,
2033 gint width,
2034 gint height)
2035 {
2036 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
2037 g_return_if_fail (GTK_IS_STYLE (style));
2038 g_return_if_fail (window != NULL);
2039
2040 if (area)
2041 {
2042 gdk_gc_set_clip_rectangle (style->light_gc[state_type], area);
2043 gdk_gc_set_clip_rectangle (style->dark_gc[state_type], area);
2044 gdk_gc_set_clip_rectangle (style->bg_gc[state_type], area);
2045 }
2046
2047 switch (edge)
2048 {
2049 case GDK_WINDOW_EDGE_NORTH_WEST:
2050 /* make it square */
2051 if (width < height)
2052 {
2053 height = width;
2054 }
2055 else if (height < width)
2056 {
2057 width = height;
2058 }
2059 break;
2060 case GDK_WINDOW_EDGE_NORTH:
2061 if (width < height)
2062 {
2063 height = width;
2064 }
2065 break;
2066 case GDK_WINDOW_EDGE_NORTH_EAST:
2067 /* make it square, aligning to top right */
2068 if (width < height)
2069 {
2070 height = width;
2071 }
2072 else if (height < width)
2073 {
2074 x += (width - height);
2075 width = height;
2076 }
2077 break;
2078 case GDK_WINDOW_EDGE_WEST:
2079 if (height < width)
2080 {
2081 width = height;
2082 }
2083 break;
2084 case GDK_WINDOW_EDGE_EAST:
2085 /* aligning to right */
2086 if (height < width)
2087 {
2088 x += (width - height);
2089 width = height;
2090 }
2091 break;
2092 case GDK_WINDOW_EDGE_SOUTH_WEST:
2093 /* make it square, aligning to bottom left */
2094 if (width < height)
2095 {
2096 y += (height - width);
2097 height = width;
2098 }
2099 else if (height < width)
2100 {
2101 width = height;
2102 }
2103 break;
2104 case GDK_WINDOW_EDGE_SOUTH:
2105 /* align to bottom */
2106 if (width < height)
2107 {
2108 y += (height - width);
2109 height = width;
2110 }
2111 break;
2112 case GDK_WINDOW_EDGE_SOUTH_EAST:
2113 /* make it square, aligning to bottom right */
2114 if (width < height)
2115 {
2116 y += (height - width);
2117 height = width;
2118 }
2119 else if (height < width)
2120 {
2121 x += (width - height);
2122 width = height;
2123 }
2124 break;
2125 default:
2126 g_assert_not_reached ();
2127 }
2128
2129 /* Clear background */
2130 gtk_style_apply_default_background (style, window, FALSE,
2131 state_type, area,
2132 x, y, width, height);
2133
2134 switch (edge)
2135 {
2136 case GDK_WINDOW_EDGE_WEST:
2137 case GDK_WINDOW_EDGE_EAST:
2138 {
2139 gint xi;
2140
2141 xi = x;
2142
2143 while (xi < x + width)
2144 {
2145 gdk_draw_line (window,
2146 style->light_gc[state_type],
2147 xi, y,
2148 xi, y + height);
2149
2150 xi++;
2151 gdk_draw_line (window,
2152 clearlooks_style->shade_gc[4],
2153 xi, y,
2154 xi, y + height);
2155
2156 xi += 2;
2157 }
2158 }
2159 break;
2160 case GDK_WINDOW_EDGE_NORTH:
2161 case GDK_WINDOW_EDGE_SOUTH:
2162 {
2163 gint yi;
2164
2165 yi = y;
2166
2167 while (yi < y + height)
2168 {
2169 gdk_draw_line (window,
2170 style->light_gc[state_type],
2171 x, yi,
2172 x + width, yi);
2173
2174 yi++;
2175 gdk_draw_line (window,
2176 clearlooks_style->shade_gc[4],
2177 x, yi,
2178 x + width, yi);
2179
2180 yi+= 2;
2181 }
2182 }
2183 break;
2184 case GDK_WINDOW_EDGE_NORTH_WEST:
2185 {
2186 gint xi, yi;
2187
2188 xi = x + width;
2189 yi = y + height;
2190
2191 while (xi > x + 3)
2192 {
2193 gdk_draw_line (window,
2194 clearlooks_style->shade_gc[4],
2195 xi, y,
2196 x, yi);
2197
2198 --xi;
2199 --yi;
2200
2201 gdk_draw_line (window,
2202 style->light_gc[state_type],
2203 xi, y,
2204 x, yi);
2205
2206 xi -= 3;
2207 yi -= 3;
2208
2209 }
2210 }
2211 break;
2212 case GDK_WINDOW_EDGE_NORTH_EAST:
2213 {
2214 gint xi, yi;
2215
2216 xi = x;
2217 yi = y + height;
2218
2219 while (xi < (x + width - 3))
2220 {
2221 gdk_draw_line (window,
2222 style->light_gc[state_type],
2223 xi, y,
2224 x + width, yi);
2225
2226 ++xi;
2227 --yi;
2228
2229 gdk_draw_line (window,
2230 clearlooks_style->shade_gc[4],
2231 xi, y,
2232 x + width, yi);
2233
2234 xi += 3;
2235 yi -= 3;
2236 }
2237 }
2238 break;
2239 case GDK_WINDOW_EDGE_SOUTH_WEST:
2240 {
2241 gint xi, yi;
2242
2243 xi = x + width;
2244 yi = y;
2245
2246 while (xi > x + 3)
2247 {
2248 gdk_draw_line (window,
2249 clearlooks_style->shade_gc[4],
2250 x, yi,
2251 xi, y + height);
2252
2253 --xi;
2254 ++yi;
2255
2256 gdk_draw_line (window,
2257 style->light_gc[state_type],
2258 x, yi,
2259 xi, y + height);
2260
2261 xi -= 3;
2262 yi += 3;
2263
2264 }
2265 }
2266 break;
2267
2268 case GDK_WINDOW_EDGE_SOUTH_EAST:
2269 {
2270 gint xi, yi;
2271
2272 xi = x;
2273 yi = y;
2274
2275 while (xi < (x + width - 3))
2276 {
2277 gdk_draw_line (window,
2278 style->light_gc[state_type],
2279 xi, y + height,
2280 x + width, yi);
2281
2282 ++xi;
2283 ++yi;
2284
2285 gdk_draw_line (window,
2286 clearlooks_style->shade_gc[4],
2287 xi, y + height,
2288 x + width, yi);
2289
2290 xi += 3;
2291 yi += 3;
2292 }
2293 }
2294 break;
2295 default:
2296 g_assert_not_reached ();
2297 break;
2298 }
2299
2300 if (area)
2301 {
2302 gdk_gc_set_clip_rectangle (style->light_gc[state_type], NULL);
2303 gdk_gc_set_clip_rectangle (style->dark_gc[state_type], NULL);
2304 gdk_gc_set_clip_rectangle (style->bg_gc[state_type], NULL);
2305 }
2306 }
2307
2308 /**************************************************************************/
2309
2310 static void
2311 clearlooks_style_init_from_rc (GtkStyle * style,
2312 GtkRcStyle * rc_style)
2313 {
2314 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
2315 GdkColor *spot_color;
2316 double shades[] = {1.065, 0.93, 0.896, 0.85, 0.768, 0.665, 0.4, 0.205};
2317 int i;
2318 double contrast;
2319
2320 parent_class->init_from_rc (style, rc_style);
2321
2322 contrast = CLEARLOOKS_RC_STYLE (rc_style)->contrast;
2323
2324 clearlooks_style->sunkenmenubar = CLEARLOOKS_RC_STYLE (rc_style)->sunkenmenubar;
2325 clearlooks_style->progressbarstyle = CLEARLOOKS_RC_STYLE (rc_style)->progressbarstyle;
2326 clearlooks_style->menubarstyle = CLEARLOOKS_RC_STYLE (rc_style)->menubarstyle;
2327 clearlooks_style->menuitemstyle = CLEARLOOKS_RC_STYLE (rc_style)->menuitemstyle;
2328 clearlooks_style->listviewitemstyle = CLEARLOOKS_RC_STYLE (rc_style)->listviewitemstyle;
2329
2330 /* Lighter to darker */
2331 for (i = 0; i < 8; i++)
2332 {
2333 shade (&style->bg[GTK_STATE_NORMAL], &clearlooks_style->shade[i],
2334 (shades[i]-0.7) * contrast + 0.7);
2335 }
2336
2337 spot_color = clearlooks_get_spot_color (CLEARLOOKS_RC_STYLE (rc_style));
2338
2339 clearlooks_style->spot_color = *spot_color;
2340 shade (&clearlooks_style->spot_color, &clearlooks_style->spot1, 1.42);
2341 shade (&clearlooks_style->spot_color, &clearlooks_style->spot2, 1.05);
2342 shade (&clearlooks_style->spot_color, &clearlooks_style->spot3, 0.65);
2343
2344 shade (&style->bg[GTK_STATE_NORMAL], &clearlooks_style->border[CL_BORDER_UPPER], 0.5);
2345 shade (&style->bg[GTK_STATE_NORMAL], &clearlooks_style->border[CL_BORDER_LOWER], 0.62);
2346 shade (&style->bg[GTK_STATE_ACTIVE], &clearlooks_style->border[CL_BORDER_UPPER_ACTIVE], 0.5);
2347 shade (&style->bg[GTK_STATE_ACTIVE], &clearlooks_style->border[CL_BORDER_LOWER_ACTIVE], 0.55);
2348 }
2349
2350 static GdkGC *
2351 realize_color (GtkStyle * style,
2352 GdkColor * color)
2353 {
2354 GdkGCValues gc_values;
2355
2356 gdk_colormap_alloc_color (style->colormap, color, FALSE, TRUE);
2357
2358 gc_values.foreground = *color;
2359
2360 return gtk_gc_get (style->depth, style->colormap, &gc_values, GDK_GC_FOREGROUND);
2361 }
2362
2363 static void
2364 clearlooks_style_realize (GtkStyle * style)
2365 {
2366 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
2367 int i;
2368
2369 parent_class->realize (style);
2370
2371 for (i = 0; i < 8; i++)
2372 clearlooks_style->shade_gc[i] = realize_color (style, &clearlooks_style->shade[i]);
2373
2374 for (i=0; i < CL_BORDER_COUNT; i++)
2375 clearlooks_style->border_gc[i] = realize_color (style, &clearlooks_style->border[i]);
2376
2377 clearlooks_style->spot1_gc = realize_color (style, &clearlooks_style->spot1);
2378 clearlooks_style->spot2_gc = realize_color (style, &clearlooks_style->spot2);
2379 clearlooks_style->spot3_gc = realize_color (style, &clearlooks_style->spot3);
2380
2381 /* set light inset color */
2382 for (i=0; i<5; i++)
2383 {
2384 shade (&style->bg[i], &clearlooks_style->inset_dark[i], 0.93);
2385 gdk_rgb_find_color (style->colormap, &clearlooks_style->inset_dark[i]);
2386
2387 shade (&style->bg[i], &clearlooks_style->inset_light[i], 1.055);
2388 gdk_rgb_find_color (style->colormap, &clearlooks_style->inset_light[i]);
2389
2390 shade (&style->bg[i], &clearlooks_style->listview_bg[i], 1.015);
2391 gdk_rgb_find_color (style->colormap, &clearlooks_style->listview_bg[i]);
2392
2393 /* CREATE GRADIENT FOR BUTTONS */
2394 shade (&style->bg[i], &clearlooks_style->button_g1[i], 1.055);
2395 gdk_rgb_find_color (style->colormap, &clearlooks_style->button_g1[i]);
2396
2397 shade (&style->bg[i], &clearlooks_style->button_g2[i], 1.005);
2398 gdk_rgb_find_color (style->colormap, &clearlooks_style->button_g2[i]);
2399
2400 shade (&style->bg[i], &clearlooks_style->button_g3[i], 0.98);
2401 gdk_rgb_find_color (style->colormap, &clearlooks_style->button_g3[i]);
2402
2403 shade (&style->bg[i], &clearlooks_style->button_g4[i], 0.91);
2404 gdk_rgb_find_color (style->colormap, &clearlooks_style->button_g4[i]);
2405 }
2406
2407 }
2408
2409 static void
2410 clearlooks_style_unrealize (GtkStyle * style)
2411 {
2412 ClearlooksStyle *clearlooks_style = CLEARLOOKS_STYLE (style);
2413 int i;
2414
2415 /* We don't free the colors, because we don't know if
2416 * gtk_gc_release() actually freed the GC. FIXME - need
2417 * a way of ref'ing colors explicitely so GtkGC can
2418 * handle things properly.
2419 */
2420 for (i=0; i < 8; i++)
2421 gtk_gc_release (clearlooks_style->shade_gc[i]);
2422
2423 gtk_gc_release (clearlooks_style->spot1_gc);
2424 gtk_gc_release (clearlooks_style->spot2_gc);
2425 gtk_gc_release (clearlooks_style->spot3_gc);
2426
2427 for (i = 0; i < 5; i++)
2428 {
2429 if (clearlooks_style->radio_pixmap_nonactive[i] != NULL)
2430 {
2431 g_object_unref (clearlooks_style->radio_pixmap_nonactive[i]);
2432 clearlooks_style->radio_pixmap_nonactive[i] = NULL;
2433 g_object_unref (clearlooks_style->radio_pixmap_active[i]);
2434 clearlooks_style->radio_pixmap_active[i] = NULL;
2435 g_object_unref (clearlooks_style->radio_pixmap_inconsistent[i]);
2436 clearlooks_style->radio_pixmap_inconsistent[i] = NULL;
2437 }
2438
2439 if (clearlooks_style->check_pixmap_nonactive[i] != NULL)
2440 {
2441 g_object_unref (clearlooks_style->check_pixmap_nonactive[i]);
2442 clearlooks_style->check_pixmap_nonactive[i] = NULL;
2443 g_object_unref (clearlooks_style->check_pixmap_active[i]);
2444 clearlooks_style->check_pixmap_active[i] = NULL;
2445 g_object_unref (clearlooks_style->check_pixmap_inconsistent[i]);
2446 clearlooks_style->check_pixmap_inconsistent[i] = NULL;
2447 }
2448 }
2449
2450 if (clearlooks_style->radio_pixmap_mask != NULL)
2451 g_object_unref (clearlooks_style->radio_pixmap_mask);
2452
2453 clearlooks_style->radio_pixmap_mask = NULL;
2454
2455 while (progressbars = g_list_first (progressbars))
2456 cl_progressbar_remove (progressbars->data);
2457
2458 if (timer_id != 0)
2459 {
2460 g_source_remove(timer_id);
2461 timer_id = 0;
2462 }
2463
2464 parent_class->unrealize (style);
2465 }
2466
2467 static GdkPixbuf *
2468 set_transparency (const GdkPixbuf *pixbuf, gdouble alpha_percent)
2469 {
2470 GdkPixbuf *target;
2471 guchar *data, *current;
2472 guint x, y, rowstride, height, width;
2473
2474 g_return_val_if_fail (pixbuf != NULL, NULL);
2475 g_return_val_if_fail (GDK_IS_PIXBUF (pixbuf), NULL);
2476
2477 /* Returns a copy of pixbuf with it's non-completely-transparent pixels to
2478 have an alpha level "alpha_percent" of their original value. */
2479
2480 target = gdk_pixbuf_add_alpha (pixbuf, FALSE, 0, 0, 0);
2481
2482 if (alpha_percent == 1.0)
2483 return target;
2484 width = gdk_pixbuf_get_width (target);
2485 height = gdk_pixbuf_get_height (target);
2486 rowstride = gdk_pixbuf_get_rowstride (target);
2487 data = gdk_pixbuf_get_pixels (target);
2488
2489 for (y = 0; y < height; y++) {
2490 for (x = 0; x < width; x++) {
2491 /* The "4" is the number of chars per pixel, in this case, RGBA,
2492 the 3 means "skip to the alpha" */
2493 current = data + (y * rowstride) + (x * 4) + 3;
2494 *(current) = (guchar) (*(current) * alpha_percent);
2495 }
2496 }
2497
2498 return target;
2499 }
2500
2501 static GdkPixbuf*
2502 scale_or_ref (GdkPixbuf *src,
2503 int width,
2504 int height)
2505 {
2506 if (width == gdk_pixbuf_get_width (src) &&
2507 height == gdk_pixbuf_get_height (src)) {
2508 return g_object_ref (src);
2509 } else {
2510 return gdk_pixbuf_scale_simple (src,
2511 width, height,
2512 GDK_INTERP_BILINEAR);
2513 }
2514 }
2515
2516 static GdkPixbuf *
2517 render_icon (GtkStyle *style,
2518 const GtkIconSource *source,
2519 GtkTextDirection direction,
2520 GtkStateType state,
2521 GtkIconSize size,
2522 GtkWidget *widget,
2523 const char *detail)
2524 {
2525 int width = 1;
2526 int height = 1;
2527 GdkPixbuf *scaled;
2528 GdkPixbuf *stated;
2529 GdkPixbuf *base_pixbuf;
2530 GdkScreen *screen;
2531 GtkSettings *settings;
2532
2533 /* Oddly, style can be NULL in this function, because
2534 * GtkIconSet can be used without a style and if so
2535 * it uses this function.
2536 */
2537
2538 base_pixbuf = gtk_icon_source_get_pixbuf (source);
2539
2540 g_return_val_if_fail (base_pixbuf != NULL, NULL);
2541
2542 if (widget && gtk_widget_has_screen (widget)) {
2543 screen = gtk_widget_get_screen (widget);
2544 settings = gtk_settings_get_for_screen (screen);
2545 } else if (style->colormap) {
2546 screen = gdk_colormap_get_screen (style->colormap);
2547 settings = gtk_settings_get_for_screen (screen);
2548 } else {
2549 settings = gtk_settings_get_default ();
2550 GTK_NOTE (MULTIHEAD,
2551 g_warning ("Using the default screen for gtk_default_render_icon()"));
2552 }
2553
2554
2555 if (size != (GtkIconSize) -1 && !gtk_icon_size_lookup_for_settings (settings, size, &width, &height)) {
2556 g_warning (G_STRLOC ": invalid icon size '%d'", size);
2557 return NULL;
2558 }
2559
2560 /* If the size was wildcarded, and we're allowed to scale, then scale; otherwise,
2561 * leave it alone.
2562 */
2563 if (size != (GtkIconSize)-1 && gtk_icon_source_get_size_wildcarded (source))
2564 scaled = scale_or_ref (base_pixbuf, width, height);
2565 else
2566 scaled = g_object_ref (base_pixbuf);
2567
2568 /* If the state was wildcarded, then generate a state. */
2569 if (gtk_icon_source_get_state_wildcarded (source)) {
2570 if (state == GTK_STATE_INSENSITIVE) {
2571 stated = set_transparency (scaled, 0.3);
2572 #if 0
2573 stated =
2574 gdk_pixbuf_composite_color_simple (scaled,
2575 gdk_pixbuf_get_width (scaled),
2576 gdk_pixbuf_get_height (scaled),
2577 GDK_INTERP_BILINEAR, 128,
2578 gdk_pixbuf_get_width (scaled),
2579 style->bg[state].pixel,
2580 style->bg[state].pixel);
2581 #endif
2582 gdk_pixbuf_saturate_and_pixelate (stated, stated,
2583 0.1, FALSE);
2584
2585 g_object_unref (scaled);
2586 } else if (state == GTK_STATE_PRELIGHT) {
2587 stated = gdk_pixbuf_copy (scaled);
2588
2589 gdk_pixbuf_saturate_and_pixelate (scaled, stated,
2590 1.2, FALSE);
2591
2592 g_object_unref (scaled);
2593 } else {
2594 stated = scaled;
2595 }
2596 }
2597 else
2598 stated = scaled;
2599
2600 return stated;
2601 }
2602
2603 static void
2604 clearlooks_style_init (ClearlooksStyle * style)
2605 {
2606 }
2607
2608 static void
2609 clearlooks_style_class_init (ClearlooksStyleClass * klass)
2610 {
2611 GtkStyleClass *style_class = GTK_STYLE_CLASS (klass);
2612
2613 parent_class = g_type_class_peek_parent (klass);
2614
2615 style_class->realize = clearlooks_style_realize;
2616 style_class->unrealize = clearlooks_style_unrealize;
2617 style_class->init_from_rc = clearlooks_style_init_from_rc;
2618 style_class->draw_focus = draw_focus;
2619 style_class->draw_resize_grip = draw_resize_grip;
2620 style_class->draw_handle = draw_handle;
2621 style_class->draw_vline = draw_vline;
2622 style_class->draw_hline = draw_hline;
2623 style_class->draw_slider = draw_slider;
2624 style_class->draw_shadow_gap = draw_shadow_gap;
2625 style_class->draw_arrow = clearlooks_draw_arrow;
2626 style_class->draw_check = draw_check;
2627 style_class->draw_tab = draw_tab;
2628 style_class->draw_box = draw_box;
2629 style_class->draw_shadow = draw_shadow;
2630 style_class->draw_box_gap = draw_box_gap;
2631 style_class->draw_extension = draw_extension;
2632 style_class->draw_option = draw_option;
2633 style_class->draw_layout = draw_layout;
2634 style_class->render_icon = render_icon;
2635 style_class->draw_flat_box = draw_flat_box;
2636 }
2637
2638 GType clearlooks_type_style = 0;
2639
2640 void
2641 clearlooks_style_register_type (GTypeModule * module)
2642 {
2643 static const GTypeInfo object_info =
2644 {
2645 sizeof (ClearlooksStyleClass),
2646 (GBaseInitFunc) NULL,
2647 (GBaseFinalizeFunc) NULL,
2648 (GClassInitFunc) clearlooks_style_class_init,
2649 NULL, /* class_finalize */
2650 NULL, /* class_data */
2651 sizeof (ClearlooksStyle),
2652 0, /* n_preallocs */
2653 (GInstanceInitFunc) clearlooks_style_init,
2654 NULL
2655 };
2656
2657 clearlooks_type_style = g_type_module_register_type (module,
2658 GTK_TYPE_STYLE,
2659 "ClearlooksStyle",
2660 &object_info, 0);
2661 }
Digital Audio Workstation