~ubuntu-branches/ubuntu/utopic/ardour3/utopic

« back to all changes in this revision

Viewing changes to libs/clearlooks-newer/clearlooks_draw_glossy.c

  • Committer: Package Import Robot
  • Author(s): Felipe Sateler
  • Date: 2013-09-21 19:05:02 UTC
  • Revision ID: package-import@ubuntu.com-20130921190502-8gsftrku6jnzhd7v
Tags: upstream-3.4~dfsg
ImportĀ upstreamĀ versionĀ 3.4~dfsg

Show diffs side-by-side

added added

removed removed

Lines of Context:
 
1
/* Clearlooks Glossy style
 
2
 * Copyright (C) 2006 Benjamin Berg
 
3
 * Copyright (C) 2007 Andrea Cimitan
 
4
 *
 
5
 * This library is free software; you can redistribute it and/or
 
6
 * modify it under the terms of the GNU Library General Public
 
7
 * License as published by the Free Software Foundation; either
 
8
 * version 2 of the License, or (at your option) any later version.
 
9
 *
 
10
 * This library is distributed in the hope that it will be useful,
 
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 
13
 * Library General Public License for more details.
 
14
 *
 
15
 * You should have received a copy of the GNU Library General Public
 
16
 * License along with this library; if not, write to the
 
17
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 
18
 * Boston, MA 02111-1307, USA.
 
19
 *
 
20
 * Written by Andrea Cimitan <andrea.cimitan@gmail.com>
 
21
 *        and Benjamin Berg <benjamin@sipsolutions.net>
 
22
 * Based on code by Richard Stellingwerff <remenic@gmail.com>
 
23
 *              and Daniel Borgmann <daniel.borgmann@gmail.com>
 
24
 * from the ubuntulooks engine.
 
25
 */
 
26
 
 
27
#include "clearlooks_draw.h"
 
28
#include "clearlooks_style.h"
 
29
#include "clearlooks_types.h"
 
30
 
 
31
#include "support.h"
 
32
#include <ge-support.h>
 
33
 
 
34
#include <cairo.h>
 
35
 
 
36
#ifndef M_PI
 
37
#define M_PI 3.14159265358979323846
 
38
#endif
 
39
 
 
40
static void
 
41
clearlooks_draw_glossy_gradient (cairo_t         *cr,
 
42
                                double x, double y, int width, int height,
 
43
                                const CairoColor *color,
 
44
                                gboolean disabled, gboolean radius, CairoCorners corners)
 
45
{
 
46
        CairoColor a, b, c, d;
 
47
        cairo_pattern_t *pt;
 
48
 
 
49
        ge_shade_color (color, disabled? 1.06 : 1.16, &a);
 
50
        ge_shade_color (color, disabled? 1.02 : 1.08, &b);
 
51
        ge_shade_color (color, disabled? 0.98 : 1.00, &c);
 
52
        ge_shade_color (color, disabled? 1.02 : 1.08, &d);
 
53
 
 
54
        pt = cairo_pattern_create_linear (x, y, x, y+height);
 
55
        cairo_pattern_add_color_stop_rgb (pt, 0.0,  a.r, a.g, a.b);
 
56
        cairo_pattern_add_color_stop_rgb (pt, 0.5,  b.r, b.g, b.b);
 
57
        cairo_pattern_add_color_stop_rgb (pt, 0.5,  c.r, c.g, c.b);
 
58
        cairo_pattern_add_color_stop_rgb (pt, 1.0,  d.r, d.g, d.b);
 
59
 
 
60
        cairo_set_source (cr, pt);
 
61
        ge_cairo_rounded_rectangle (cr, x, y, width, height, radius, corners);
 
62
        cairo_fill (cr);
 
63
        
 
64
        cairo_pattern_destroy (pt);
 
65
}
 
66
 
 
67
static void
 
68
clearlooks_set_mixed_color (cairo_t          *cr, 
 
69
                            const CairoColor *color1, 
 
70
                            const CairoColor *color2, 
 
71
                            gdouble mix_factor)
 
72
{
 
73
        CairoColor composite;
 
74
 
 
75
        ge_mix_color (color1, color2, mix_factor, &composite);
 
76
        ge_cairo_set_color (cr, &composite);
 
77
}
 
78
 
 
79
static void
 
80
clearlooks_glossy_draw_inset (cairo_t          *cr, 
 
81
                              const CairoColor *bg_color,
 
82
                              double x, double y, double w, double h,
 
83
                              double radius, uint8 corners)
 
84
{
 
85
        CairoColor shadow;
 
86
        CairoColor highlight;
 
87
 
 
88
        /* not really sure of shading ratios... we will think */
 
89
        ge_shade_color (bg_color, 0.93, &shadow);
 
90
        ge_shade_color (bg_color, 1.07, &highlight);
 
91
 
 
92
        /* highlight */
 
93
        cairo_move_to (cr, x + w + (radius * -0.2928932188), y - (radius * -0.2928932188)); /* 0.2928932... 1-sqrt(2)/2 gives middle of curve */
 
94
 
 
95
        if (corners & CR_CORNER_TOPRIGHT)
 
96
                cairo_arc (cr, x + w - radius, y + radius, radius, G_PI * 1.75, G_PI * 2);
 
97
        else
 
98
                cairo_line_to (cr, x + w, y);
 
99
 
 
100
        if (corners & CR_CORNER_BOTTOMRIGHT)
 
101
                cairo_arc (cr, x + w - radius, y + h - radius, radius, 0, G_PI * 0.5);
 
102
        else
 
103
                cairo_line_to (cr, x + w, y + h);
 
104
 
 
105
        if (corners & CR_CORNER_BOTTOMLEFT)
 
106
                cairo_arc (cr, x + radius, y + h - radius, radius, G_PI * 0.5, G_PI * 0.75);
 
107
        else
 
108
                cairo_line_to (cr, x, y + h);
 
109
 
 
110
        ge_cairo_set_color (cr, &highlight);
 
111
        cairo_stroke (cr);
 
112
 
 
113
        /* shadow */
 
114
        cairo_move_to (cr, x + (radius * 0.2928932188), y + h + (radius * -0.2928932188));
 
115
 
 
116
        if (corners & CR_CORNER_BOTTOMLEFT)
 
117
                cairo_arc (cr, x + radius, y + h - radius, radius, M_PI * 0.75, M_PI);
 
118
        else
 
119
                cairo_line_to (cr, x, y + h);
 
120
 
 
121
        if (corners & CR_CORNER_TOPLEFT)
 
122
                cairo_arc (cr, x + radius, y + radius, radius, M_PI, M_PI * 1.5);
 
123
        else
 
124
                cairo_line_to (cr, x, y);
 
125
 
 
126
        if (corners & CR_CORNER_TOPRIGHT)
 
127
            cairo_arc (cr, x + w - radius, y + radius, radius, M_PI * 1.5, M_PI * 1.75);
 
128
        else
 
129
                cairo_line_to (cr, x + w, y);
 
130
 
 
131
        ge_cairo_set_color (cr, &shadow);
 
132
        cairo_stroke (cr);
 
133
}
 
134
 
 
135
static void
 
136
clearlooks_glossy_draw_light_inset (cairo_t          *cr, 
 
137
                                    const CairoColor *bg_color, 
 
138
                                    double x, double y, double w, double h, 
 
139
                                    double radius, uint8 corners)
 
140
{
 
141
        CairoColor shadow;
 
142
        CairoColor highlight;
 
143
 
 
144
        /* not really sure of shading ratios... we will think */
 
145
        ge_shade_color (bg_color, 0.95, &shadow);
 
146
        ge_shade_color (bg_color, 1.05, &highlight);
 
147
 
 
148
        /* highlight */
 
149
        cairo_move_to (cr, x + w + (radius * -0.2928932188), y - (radius * -0.2928932188)); /* 0.2928932... 1-sqrt(2)/2 gives middle of curve */
 
150
 
 
151
        if (corners & CR_CORNER_TOPRIGHT)
 
152
                cairo_arc (cr, x + w - radius, y + radius, radius, G_PI * 1.75, G_PI * 2);
 
153
        else
 
154
                cairo_line_to (cr, x + w, y);
 
155
 
 
156
        if (corners & CR_CORNER_BOTTOMRIGHT)
 
157
                cairo_arc (cr, x + w - radius, y + h - radius, radius, 0, G_PI * 0.5);
 
158
        else
 
159
                cairo_line_to (cr, x + w, y + h);
 
160
 
 
161
        if (corners & CR_CORNER_BOTTOMLEFT)
 
162
                cairo_arc (cr, x + radius, y + h - radius, radius, G_PI * 0.5, G_PI * 0.75);
 
163
        else
 
164
                cairo_line_to (cr, x, y + h);
 
165
 
 
166
        ge_cairo_set_color (cr, &highlight);
 
167
        cairo_stroke (cr);
 
168
 
 
169
        /* shadow */
 
170
        cairo_move_to (cr, x + (radius * 0.2928932188), y + h + (radius * -0.2928932188));
 
171
 
 
172
        if (corners & CR_CORNER_BOTTOMLEFT)
 
173
                cairo_arc (cr, x + radius, y + h - radius, radius, M_PI * 0.75, M_PI);
 
174
        else
 
175
                cairo_line_to (cr, x, y + h);
 
176
 
 
177
        if (corners & CR_CORNER_TOPLEFT)
 
178
                cairo_arc (cr, x + radius, y + radius, radius, M_PI, M_PI * 1.5);
 
179
        else
 
180
                cairo_line_to (cr, x, y);
 
181
 
 
182
        if (corners & CR_CORNER_TOPRIGHT)
 
183
            cairo_arc (cr, x + w - radius, y + radius, radius, M_PI * 1.5, M_PI * 1.75);
 
184
        else
 
185
                cairo_line_to (cr, x + w, y);
 
186
 
 
187
        ge_cairo_set_color (cr, &shadow);
 
188
        cairo_stroke (cr);
 
189
}
 
190
 
 
191
static void
 
192
clearlooks_glossy_draw_highlight_and_shade (cairo_t          *cr, 
 
193
                                            const CairoColor *bg_color,
 
194
                                            const ShadowParameters *params,
 
195
                                            int width, int height, gdouble radius)
 
196
{
 
197
        CairoColor shadow;
 
198
        CairoColor highlight;
 
199
        uint8 corners = params->corners;
 
200
        double x = 1.0;
 
201
        double y = 1.0;
 
202
 
 
203
        /* not really sure of shading ratios... we will think */
 
204
        ge_shade_color (bg_color, 0.8, &shadow);
 
205
        ge_shade_color (bg_color, 1.2, &highlight);
 
206
        
 
207
        cairo_save (cr);
 
208
        
 
209
        /* Top/Left highlight */
 
210
        if (corners & CR_CORNER_BOTTOMLEFT)
 
211
                cairo_move_to (cr, x, y+height-radius);
 
212
        else
 
213
                cairo_move_to (cr, x, y+height);
 
214
        
 
215
        ge_cairo_rounded_corner (cr, x, y, radius, corners & CR_CORNER_TOPLEFT);
 
216
 
 
217
        if (corners & CR_CORNER_TOPRIGHT)
 
218
                cairo_line_to (cr, x+width-radius, y);
 
219
        else
 
220
                cairo_line_to (cr, x+width, y);
 
221
        
 
222
        if (params->shadow & CL_SHADOW_OUT)
 
223
                cairo_set_source_rgba (cr, highlight.r, highlight.g, highlight.b, 0.5);
 
224
        else
 
225
                cairo_set_source_rgba (cr, shadow.r, shadow.g, shadow.b, 0.5);
 
226
        
 
227
        cairo_stroke (cr);
 
228
        
 
229
        /* Bottom/Right highlight -- this includes the corners */
 
230
        cairo_move_to (cr, x+width-radius, y); /* topright and by radius to the left */
 
231
        ge_cairo_rounded_corner (cr, x+width, y, radius, corners & CR_CORNER_TOPRIGHT);
 
232
        ge_cairo_rounded_corner (cr, x+width, y+height, radius, corners & CR_CORNER_BOTTOMRIGHT);
 
233
        ge_cairo_rounded_corner (cr, x, y+height, radius, corners & CR_CORNER_BOTTOMLEFT);
 
234
        
 
235
        if (params->shadow & CL_SHADOW_OUT)
 
236
                cairo_set_source_rgba (cr, shadow.r, shadow.g, shadow.b, 0.5);
 
237
        else
 
238
                cairo_set_source_rgba (cr, highlight.r, highlight.g, highlight.b, 0.5);
 
239
        
 
240
        cairo_stroke (cr);
 
241
        
 
242
        cairo_restore (cr);
 
243
}
 
244
 
 
245
static void
 
246
clearlooks_glossy_draw_button (cairo_t *cr,
 
247
                                   const ClearlooksColors *colors,
 
248
                                   const WidgetParameters *params,
 
249
                                   int x, int y, int width, int height)
 
250
{
 
251
        double xoffset = 0, yoffset = 0;
 
252
        CairoColor fill            = colors->bg[params->state_type];
 
253
        CairoColor border_normal   = colors->shade[6];
 
254
        CairoColor border_disabled = colors->shade[4];
 
255
        double radius;
 
256
 
 
257
        cairo_pattern_t *pattern;
 
258
        
 
259
        cairo_save (cr);
 
260
        cairo_translate (cr, x, y);
 
261
        cairo_set_line_width (cr, 1.0);
 
262
 
 
263
        /* Shadows and Glow */
 
264
        if (params->xthickness == 3 || params->ythickness == 3)
 
265
        {
 
266
                if (params->xthickness == 3)
 
267
                        xoffset = 1;
 
268
                if (params->ythickness == 3)
 
269
                        yoffset = 1;
 
270
        }
 
271
 
 
272
        radius = MIN (params->radius, MIN ((width - 2.0 - 2*xoffset) / 2.0, (height - 2.0 - 2*yoffset) / 2.0));
 
273
 
 
274
        if (params->xthickness == 3 || params->ythickness == 3)
 
275
        {
 
276
                cairo_translate (cr, 0.5, 0.5);
 
277
 
 
278
                /* if (params->enable_glow && !params->active && !params->disabled) */
 
279
                if (params->prelight && params->enable_glow && !params->active)
 
280
                {
 
281
                        /* Glow becomes a shadow to have 3d prelight buttons :) */
 
282
                        CairoColor glow;
 
283
 
 
284
                        radius = MIN (params->radius, MIN ((width - 2.0 - 2*xoffset) / 2.0 - 1.0, (height - 2.0 - 2*yoffset) / 2.0 - 1.0));
 
285
 
 
286
                        ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius+1, params->corners);
 
287
                        ge_shade_color (&params->parentbg, 0.96, &glow);
 
288
                        ge_cairo_set_color (cr, &glow);
 
289
                        cairo_stroke (cr);
 
290
 
 
291
                        ge_cairo_rounded_rectangle (cr, 1, 1, width-2, height-2, radius+1, params->corners);
 
292
                        ge_shade_color (&params->parentbg, 0.92, &glow);
 
293
                        ge_cairo_set_color (cr, &glow);
 
294
                        cairo_stroke (cr);
 
295
                }
 
296
                
 
297
                /* if (!(params->enable_glow && !params->active && !params->disabled)) */
 
298
                if (!(params->prelight && params->enable_glow && !params->active)) {
 
299
                        if (!(params->disabled))
 
300
                                params->style_functions->draw_inset (cr, &params->parentbg, 0, 0, width-1, height-1, params->radius+1, params->corners);
 
301
                        else
 
302
                                /*Draw a lighter inset */
 
303
                                clearlooks_glossy_draw_light_inset (cr, &params->parentbg, 0, 0, width-1, height-1, params->radius+1, params->corners);
 
304
                }
 
305
                cairo_translate (cr, -0.5, -0.5);
 
306
        }
 
307
 
 
308
        clearlooks_draw_glossy_gradient (cr, xoffset+1, yoffset+1, 
 
309
                                      width-(xoffset*2)-2, height-(yoffset*2)-2, 
 
310
                                      &fill, params->disabled, radius, params->corners);
 
311
        
 
312
        /* Pressed button shadow */
 
313
        if (params->active)
 
314
        {
 
315
                CairoColor shadow;
 
316
                ge_shade_color (&fill, 0.92, &shadow);
 
317
 
 
318
                cairo_save (cr);
 
319
 
 
320
                ge_cairo_rounded_rectangle (cr, xoffset+1, yoffset+1, width-(xoffset*2)-2, height, radius, params->corners & (CR_CORNER_TOPLEFT | CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMLEFT));
 
321
                cairo_clip (cr);
 
322
                cairo_rectangle (cr, xoffset+1, yoffset+1, width-(xoffset*2)-2, 3);
 
323
        
 
324
                pattern = cairo_pattern_create_linear (xoffset+1, yoffset+1, xoffset+1, yoffset+4);
 
325
                cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.58);
 
326
                cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.0);
 
327
                cairo_set_source (cr, pattern);
 
328
                cairo_fill (cr);
 
329
                cairo_pattern_destroy (pattern);
 
330
                
 
331
                cairo_rectangle (cr, xoffset+1, yoffset+1, 3, height-(yoffset*2)-2);
 
332
        
 
333
                pattern = cairo_pattern_create_linear (xoffset+1, yoffset+1, xoffset+4, yoffset+1);
 
334
                cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.58);
 
335
                cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.0);
 
336
                cairo_set_source (cr, pattern);
 
337
                cairo_fill (cr);
 
338
                cairo_pattern_destroy (pattern);
 
339
 
 
340
                cairo_restore (cr);
 
341
        }
 
342
        
 
343
        /* Default button highlight */
 
344
        if (params->is_default && !params->active && !params->disabled)
 
345
        {
 
346
                const CairoColor *glow = &colors->spot[0];
 
347
                double hh = (height-5)/2.0 + 1;
 
348
                
 
349
                cairo_rectangle (cr, 3.5, 3.5, width-7, height-7);
 
350
                ge_cairo_set_color (cr, glow);
 
351
                cairo_stroke (cr);
 
352
 
 
353
                glow = &colors->spot[0];
 
354
                cairo_move_to (cr, 2.5, 2.5+hh); cairo_rel_line_to (cr, 0, -hh);
 
355
                cairo_rel_line_to (cr, width-5, 0); cairo_rel_line_to (cr, 0, hh);
 
356
                ge_cairo_set_color (cr, glow);
 
357
                cairo_stroke (cr);
 
358
                
 
359
                hh--;
 
360
 
 
361
                glow = &colors->spot[1];
 
362
                cairo_move_to (cr, 2.5, 2.5+hh); cairo_rel_line_to (cr, 0, hh);
 
363
                cairo_rel_line_to (cr, width-5, 0); cairo_rel_line_to (cr, 0, -hh);
 
364
                ge_cairo_set_color (cr, glow);
 
365
                cairo_stroke (cr);
 
366
        }
 
367
        
 
368
        /* Border */
 
369
        if (params->is_default || (params->prelight && params->enable_glow))
 
370
                border_normal = colors->spot[2];
 
371
                /* ge_mix_color (&border_normal, &colors->spot[2], 0.5, &border_normal); */
 
372
        if (params->disabled)
 
373
                ge_cairo_set_color (cr, &border_disabled);
 
374
        else
 
375
                clearlooks_set_mixed_color (cr, &border_normal, &fill, 0.2);
 
376
        ge_cairo_rounded_rectangle (cr, xoffset + 0.5, yoffset + 0.5,
 
377
                                  width-(xoffset*2)-1, height-(yoffset*2)-1,
 
378
                                  radius, params->corners);
 
379
        cairo_stroke (cr);
 
380
        cairo_restore (cr);
 
381
}
 
382
 
 
383
static void
 
384
clearlooks_glossy_draw_progressbar_trough (cairo_t *cr,
 
385
                                    const ClearlooksColors *colors,
 
386
                                    const WidgetParameters *params,
 
387
                                    int x, int y, int width, int height)
 
388
{
 
389
        const CairoColor *border = &colors->shade[6];
 
390
        CairoColor        shadow;
 
391
        cairo_pattern_t  *pattern;
 
392
        double           radius = MIN (params->radius, MIN ((height-2.0) / 2.0, (width-2.0) / 2.0));
 
393
        
 
394
        cairo_save (cr);
 
395
 
 
396
        cairo_set_line_width (cr, 1.0);
 
397
        
 
398
        /* Fill with bg color */
 
399
        ge_cairo_set_color (cr, &colors->bg[params->state_type]);
 
400
        
 
401
        cairo_rectangle (cr, x, y, width, height);
 
402
        cairo_fill (cr);
 
403
 
 
404
        /* Create trough box */
 
405
        ge_cairo_rounded_rectangle (cr, x+1, y+1, width-2, height-2, radius, params->corners);
 
406
        ge_cairo_set_color (cr, &colors->shade[2]);
 
407
        cairo_fill (cr);
 
408
 
 
409
        /* Draw border */
 
410
        ge_cairo_rounded_rectangle (cr, x+0.5, y+0.5, width-1, height-1, radius, params->corners);
 
411
        clearlooks_set_mixed_color (cr, border, &colors->shade[2], 0.3);
 
412
        cairo_stroke (cr);
 
413
 
 
414
        /* clip the corners of the shadows */
 
415
        ge_cairo_rounded_rectangle (cr, x+1, y+1, width-2, height-2, radius, params->corners);
 
416
        cairo_clip (cr);
 
417
 
 
418
        ge_shade_color (border, 0.92, &shadow);
 
419
 
 
420
        /* Top shadow */
 
421
        cairo_rectangle (cr, x+1, y+1, width-2, 4);
 
422
        pattern = cairo_pattern_create_linear (x, y, x, y+4);
 
423
        cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.3);
 
424
        cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.);
 
425
        cairo_set_source (cr, pattern);
 
426
        cairo_fill (cr);
 
427
        cairo_pattern_destroy (pattern);
 
428
 
 
429
        /* Left shadow */
 
430
        cairo_rectangle (cr, x+1, y+1, 4, height-2);
 
431
        pattern = cairo_pattern_create_linear (x, y, x+4, y);
 
432
        cairo_pattern_add_color_stop_rgba (pattern, 0.0, shadow.r, shadow.g, shadow.b, 0.3);
 
433
        cairo_pattern_add_color_stop_rgba (pattern, 1.0, shadow.r, shadow.g, shadow.b, 0.);
 
434
        cairo_set_source (cr, pattern);
 
435
        cairo_fill (cr);
 
436
        cairo_pattern_destroy (pattern);
 
437
 
 
438
        cairo_restore (cr);
 
439
}
 
440
 
 
441
static void
 
442
clearlooks_glossy_draw_progressbar_fill (cairo_t *cr,
 
443
                                  const ClearlooksColors *colors,
 
444
                                  const WidgetParameters *params,
 
445
                                  const ProgressBarParameters *progressbar,
 
446
                                  int x, int y, int width, int height,
 
447
                                  gint offset)
 
448
{
 
449
        boolean      is_horizontal = progressbar->orientation < 2;
 
450
        double       tile_pos = 0;
 
451
        double       stroke_width;
 
452
        double       radius;
 
453
        int          x_step;
 
454
 
 
455
        cairo_pattern_t *pattern;
 
456
        CairoColor       a;
 
457
        CairoColor       b;
 
458
        CairoColor       e;
 
459
        CairoColor       border;
 
460
        CairoColor       shadow;
 
461
 
 
462
        radius = MAX (0, params->radius - params->xthickness);
 
463
 
 
464
        cairo_save (cr);
 
465
 
 
466
        if (!is_horizontal)
 
467
                ge_cairo_exchange_axis (cr, &x, &y, &width, &height);
 
468
 
 
469
        if ((progressbar->orientation == CL_ORIENTATION_RIGHT_TO_LEFT) || (progressbar->orientation == CL_ORIENTATION_BOTTOM_TO_TOP))
 
470
                ge_cairo_mirror (cr, CR_MIRROR_HORIZONTAL, &x, &y, &width, &height);
 
471
 
 
472
        /* Clamp the radius so that the _height_ fits ...  */
 
473
        radius = MIN (radius, height / 2.0);
 
474
 
 
475
        stroke_width = height*2;
 
476
        x_step = (((float)stroke_width/10)*offset); /* This looks weird ... */
 
477
        
 
478
        cairo_translate (cr, x, y);
 
479
 
 
480
        cairo_save (cr);
 
481
        /* This is kind of nasty ... Clip twice from each side in case the length
 
482
         * of the fill is smaller than twice the radius. */
 
483
        ge_cairo_rounded_rectangle (cr, 0, 0, width + radius, height, radius, CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT);
 
484
        cairo_clip (cr);
 
485
        ge_cairo_rounded_rectangle (cr, -radius, 0, width + radius, height, radius, CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT);
 
486
        cairo_clip (cr);
 
487
 
 
488
        /* Draw the background gradient */
 
489
        ge_shade_color (&colors->spot[1], 1.16, &a);
 
490
        ge_shade_color (&colors->spot[1], 1.08, &b);
 
491
        ge_shade_color (&colors->spot[1], 1.08, &e);
 
492
        pattern = cairo_pattern_create_linear (0, 0, 0, height);
 
493
        cairo_pattern_add_color_stop_rgb (pattern, 0.0, a.r, a.g, a.b);
 
494
        cairo_pattern_add_color_stop_rgb (pattern, 0.5, b.r, b.g, b.b);
 
495
        cairo_pattern_add_color_stop_rgb (pattern, 0.5, colors->spot[1].r, colors->spot[1].g, colors->spot[1].b);
 
496
        cairo_pattern_add_color_stop_rgb (pattern, 1.0, e.r, e.g, e.b);
 
497
        cairo_set_source (cr, pattern);
 
498
        cairo_paint (cr);
 
499
        cairo_pattern_destroy (pattern);
 
500
 
 
501
        /* Draw the Strokes */
 
502
        while (tile_pos <= width+x_step)
 
503
        {
 
504
                cairo_move_to (cr, stroke_width/2-x_step, 0);
 
505
                cairo_line_to (cr, stroke_width-x_step,   0);
 
506
                cairo_line_to (cr, stroke_width/2-x_step, height);
 
507
                cairo_line_to (cr, -x_step, height);
 
508
                
 
509
                cairo_translate (cr, stroke_width, 0);
 
510
                tile_pos += stroke_width;
 
511
        }
 
512
        
 
513
        cairo_set_source_rgba (cr, colors->spot[2].r,
 
514
                                   colors->spot[2].g,
 
515
                                   colors->spot[2].b,
 
516
                                   0.15);
 
517
        
 
518
        cairo_fill (cr);
 
519
        cairo_restore (cr); /* rounded clip region */
 
520
 
 
521
        /* inner highlight border
 
522
         * This is again kinda ugly. Draw once from each side, clipping away the other. */
 
523
        cairo_set_source_rgba (cr, colors->spot[0].r, colors->spot[0].g, colors->spot[0].b, 0.3);
 
524
 
 
525
        /* left side */
 
526
        cairo_save (cr);
 
527
        cairo_rectangle (cr, 0, 0, width / 2, height);
 
528
        cairo_clip (cr);
 
529
 
 
530
        if (progressbar->pulsing)
 
531
                ge_cairo_rounded_rectangle (cr, 1.5, 0.5, width + radius, height - 1, radius, CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT);
 
532
        else
 
533
                ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width + radius, height - 1, radius, CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT);
 
534
 
 
535
        cairo_stroke (cr);
 
536
        cairo_restore (cr); /* clip */
 
537
 
 
538
        /* right side */
 
539
        cairo_save (cr);
 
540
        cairo_rectangle (cr, width / 2, 0, (width+1) / 2, height);
 
541
        cairo_clip (cr);
 
542
 
 
543
        if (progressbar->value < 1.0 || progressbar->pulsing)
 
544
                ge_cairo_rounded_rectangle (cr, -1.5 - radius, 0.5, width + radius, height - 1, radius, CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT);
 
545
        else
 
546
                ge_cairo_rounded_rectangle (cr, -0.5 - radius, 0.5, width + radius, height - 1, radius, CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT);
 
547
 
 
548
        cairo_stroke (cr);
 
549
        cairo_restore (cr); /* clip */
 
550
 
 
551
 
 
552
        /* Draw the dark lines and the shadow */
 
553
        cairo_save (cr);
 
554
        /* Again, this weird clip area. */
 
555
        ge_cairo_rounded_rectangle (cr, -1.0, 0, width + radius + 2.0, height, radius, CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT);
 
556
        cairo_clip (cr);
 
557
        ge_cairo_rounded_rectangle (cr, -radius - 1.0, 0, width + radius + 2.0, height, radius, CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT);
 
558
        cairo_clip (cr);
 
559
 
 
560
        border = colors->spot[2];
 
561
        border.a = 0.5;
 
562
        ge_shade_color (&colors->shade[6], 0.92, &shadow);
 
563
        shadow.a = 0.2;
 
564
 
 
565
        if (progressbar->pulsing)
 
566
        {
 
567
                /* At the beginning of the bar. */
 
568
                cairo_move_to (cr, 0.5 + radius, height + 0.5);
 
569
                ge_cairo_rounded_corner (cr, 0.5, height + 0.5, radius + 1, CR_CORNER_BOTTOMLEFT);
 
570
                ge_cairo_rounded_corner (cr, 0.5, -0.5, radius + 1, CR_CORNER_TOPLEFT);
 
571
                ge_cairo_set_color (cr, &border);
 
572
                cairo_stroke (cr);
 
573
 
 
574
                cairo_move_to (cr, -0.5 + radius, height + 0.5);
 
575
                ge_cairo_rounded_corner (cr, -0.5, height + 0.5, radius + 1, CR_CORNER_BOTTOMLEFT);
 
576
                ge_cairo_rounded_corner (cr, -0.5, -0.5, radius + 1, CR_CORNER_TOPLEFT);
 
577
                ge_cairo_set_color (cr, &shadow);
 
578
                cairo_stroke (cr);
 
579
        }
 
580
        if (progressbar->value < 1.0 || progressbar->pulsing)
 
581
        {
 
582
                /* At the end of the bar. */
 
583
                cairo_move_to (cr, width - 0.5 - radius, -0.5);
 
584
                ge_cairo_rounded_corner (cr, width - 0.5, -0.5, radius + 1, CR_CORNER_TOPRIGHT);
 
585
                ge_cairo_rounded_corner (cr, width - 0.5, height + 0.5, radius + 1, CR_CORNER_BOTTOMRIGHT);
 
586
                ge_cairo_set_color (cr, &border);
 
587
                cairo_stroke (cr);
 
588
 
 
589
                cairo_move_to (cr, width + 0.5 - radius, -0.5);
 
590
                ge_cairo_rounded_corner (cr, width + 0.5, -0.5, radius + 1, CR_CORNER_TOPRIGHT);
 
591
                ge_cairo_rounded_corner (cr, width + 0.5, height + 0.5, radius + 1, CR_CORNER_BOTTOMRIGHT);
 
592
                ge_cairo_set_color (cr, &shadow);
 
593
                cairo_stroke (cr);
 
594
        }
 
595
        
 
596
        cairo_restore (cr);
 
597
 
 
598
        cairo_restore (cr); /* rotation, mirroring */
 
599
}
 
600
 
 
601
static void
 
602
clearlooks_glossy_scale_draw_gradient (cairo_t *cr,
 
603
                                const CairoColor *c1,
 
604
                                const CairoColor *c2,
 
605
                                const CairoColor *c3,
 
606
                                int x, int y, int width, int height,
 
607
                                boolean horizontal)
 
608
{
 
609
        cairo_pattern_t *pattern;
 
610
 
 
611
        pattern = cairo_pattern_create_linear (0, 0, horizontal ? 0 :  width, horizontal ? height : 0);
 
612
        cairo_pattern_add_color_stop_rgb (pattern, 0.0, c1->r, c1->g, c1->b);
 
613
        cairo_pattern_add_color_stop_rgb (pattern, 1.0, c2->r, c2->g, c2->b);
 
614
 
 
615
        cairo_rectangle (cr, x+0.5, y+0.5, width-1, height-1);
 
616
        cairo_set_source (cr, pattern);
 
617
        cairo_fill (cr);
 
618
        cairo_pattern_destroy (pattern);
 
619
        
 
620
        clearlooks_set_mixed_color (cr, c3, c1, 0.3);
 
621
        ge_cairo_stroke_rectangle (cr, x, y, width, height);
 
622
}
 
623
 
 
624
#define TROUGH_SIZE 6
 
625
static void
 
626
clearlooks_glossy_draw_scale_trough (cairo_t *cr,
 
627
                              const ClearlooksColors *colors,
 
628
                              const WidgetParameters *params,
 
629
                              const SliderParameters *slider,
 
630
                              int x, int y, int width, int height)
 
631
{
 
632
        int     trough_width, trough_height;
 
633
        double  translate_x, translate_y;
 
634
 
 
635
        if (slider->horizontal)
 
636
        {
 
637
                trough_width  = width-3;
 
638
                trough_height = TROUGH_SIZE-2;
 
639
                
 
640
                translate_x   = x + 0.5;
 
641
                translate_y   = y + 0.5 + (height/2) - (TROUGH_SIZE/2);
 
642
        }
 
643
        else
 
644
        {
 
645
                trough_width  = TROUGH_SIZE-2;
 
646
                trough_height = height-3;
 
647
                
 
648
                translate_x   = x + 0.5 + (width/2) - (TROUGH_SIZE/2);
 
649
                translate_y  = y + 0.5;
 
650
        }
 
651
 
 
652
        cairo_set_line_width (cr, 1.0);
 
653
        cairo_translate (cr, translate_x, translate_y);
 
654
 
 
655
        if (!slider->fill_level)
 
656
                params->style_functions->draw_inset (cr, &params->parentbg, 0, 0, trough_width+2, trough_height+2, 0, 0);
 
657
        
 
658
        cairo_translate (cr, 1, 1);
 
659
        
 
660
        if (!slider->lower && !slider->fill_level)
 
661
                clearlooks_glossy_scale_draw_gradient (cr, &colors->shade[3], /* top */
 
662
                                                    &colors->shade[2], /* bottom */
 
663
                                                    &colors->shade[6], /* border */
 
664
                                                    0, 0, trough_width, trough_height,
 
665
                                                    slider->horizontal);
 
666
        else
 
667
                clearlooks_glossy_scale_draw_gradient (cr, &colors->spot[1], /* top */
 
668
                                                    &colors->spot[0], /* bottom */
 
669
                                                    &colors->spot[2], /* border */
 
670
                                                    0, 0, trough_width, trough_height,
 
671
                                                    slider->horizontal);
 
672
}
 
673
 
 
674
static void
 
675
clearlooks_glossy_draw_tab (cairo_t *cr,
 
676
                            const ClearlooksColors *colors,
 
677
                            const WidgetParameters *params,
 
678
                            const TabParameters    *tab,
 
679
                            int x, int y, int width, int height)
 
680
{
 
681
 
 
682
        const CairoColor    *border       = &colors->shade[5];
 
683
        const CairoColor    *stripe_fill   = &colors->spot[1];
 
684
        const CairoColor    *stripe_border = &colors->spot[2];
 
685
        const CairoColor    *fill;
 
686
        CairoColor           hilight;
 
687
 
 
688
        cairo_pattern_t     *pattern;
 
689
        
 
690
        double               radius;
 
691
 
 
692
        radius = MIN (params->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
 
693
 
 
694
        /* Set clip */
 
695
        cairo_rectangle      (cr, x, y, width, height);
 
696
        cairo_clip           (cr);
 
697
        cairo_new_path       (cr);
 
698
 
 
699
        /* Translate and set line width */
 
700
        cairo_set_line_width (cr, 1.0);
 
701
        cairo_translate      (cr, x+0.5, y+0.5);
 
702
 
 
703
 
 
704
        /* Make the tabs slightly bigger than they should be, to create a gap */
 
705
        /* And calculate the strip size too, while you're at it */
 
706
        if (tab->gap_side == CL_GAP_TOP || tab->gap_side == CL_GAP_BOTTOM)
 
707
        {
 
708
                height += 3.0;
 
709
                
 
710
                if (tab->gap_side == CL_GAP_TOP)
 
711
                        cairo_translate (cr, 0.0, -3.0); /* gap at the other side */
 
712
        }
 
713
        else
 
714
        {
 
715
                width += 3.0;
 
716
                
 
717
                if (tab->gap_side == CL_GAP_LEFT) 
 
718
                        cairo_translate (cr, -3.0, 0.0); /* gap at the other side */
 
719
        }
 
720
        
 
721
        /* Set the fill color */
 
722
        fill = &colors->bg[params->state_type];
 
723
 
 
724
        /* Set tab shape */
 
725
        ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1,
 
726
                                    radius, params->corners);
 
727
        
 
728
        /* Draw fill */
 
729
        ge_cairo_set_color (cr, fill);
 
730
        cairo_fill   (cr);
 
731
 
 
732
        ge_shade_color (fill, 1.3, &hilight);
 
733
 
 
734
        /* Draw highlight */
 
735
        if (!params->active)
 
736
        {
 
737
                ShadowParameters shadow;
 
738
                
 
739
                shadow.shadow  = CL_SHADOW_OUT;
 
740
                shadow.corners = params->corners;
 
741
                
 
742
                clearlooks_glossy_draw_highlight_and_shade (cr, &colors->bg[0], &shadow,
 
743
                                                     width,
 
744
                                                     height, radius);
 
745
        }
 
746
 
 
747
        if (params->active)
 
748
        {
 
749
                CairoColor shadow, hilight, f1, f2;
 
750
 
 
751
                pattern = cairo_pattern_create_linear (tab->gap_side == CL_GAP_LEFT   ? width-1  : 0,
 
752
                                                       tab->gap_side == CL_GAP_TOP    ? height-2 : 1,
 
753
                                                       tab->gap_side == CL_GAP_RIGHT  ? width    : 0,
 
754
                                                       tab->gap_side == CL_GAP_BOTTOM ? height   : 0);
 
755
 
 
756
                ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
 
757
                
 
758
                ge_shade_color (fill, 1.06, &shadow);
 
759
                ge_shade_color (fill, 1.18, &hilight);
 
760
                ge_shade_color (fill, 1.12, &f1);
 
761
                ge_shade_color (fill, 1.06, &f2);
 
762
 
 
763
                cairo_pattern_add_color_stop_rgb (pattern, 0.0,        hilight.r, hilight.g, hilight.b);
 
764
                cairo_pattern_add_color_stop_rgb (pattern, 1.0/height, hilight.r, hilight.g, hilight.b);
 
765
                cairo_pattern_add_color_stop_rgb (pattern, 1.0/height, f1.r, f1.g, f1.b);
 
766
                cairo_pattern_add_color_stop_rgb (pattern, 0.45,       f2.r, f2.g, f2.b);
 
767
                cairo_pattern_add_color_stop_rgb (pattern, 0.45,       fill->r, fill->g, fill->b);
 
768
                cairo_pattern_add_color_stop_rgb (pattern, 1.0,        shadow.r, shadow.g, shadow.b);
 
769
                cairo_set_source (cr, pattern);
 
770
                cairo_fill (cr);
 
771
                cairo_pattern_destroy (pattern);
 
772
        }
 
773
        else
 
774
        {
 
775
                /* Draw shade */
 
776
                pattern = cairo_pattern_create_linear (tab->gap_side == CL_GAP_LEFT   ? width-2  : 0,
 
777
                                                       tab->gap_side == CL_GAP_TOP    ? height-2 : 0,
 
778
                                                       tab->gap_side == CL_GAP_RIGHT  ? width    : 0,
 
779
                                                       tab->gap_side == CL_GAP_BOTTOM ? height   : 0);
 
780
        
 
781
                ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
 
782
                
 
783
 
 
784
                cairo_pattern_add_color_stop_rgba (pattern, 0.0, stripe_fill->r, stripe_fill->g, stripe_fill->b, 0.5);
 
785
                cairo_pattern_add_color_stop_rgba (pattern, 0.8, fill->r, fill->g, fill->b, 0.0);
 
786
                cairo_set_source (cr, pattern);
 
787
                cairo_fill (cr);
 
788
                cairo_pattern_destroy (pattern);
 
789
        }
 
790
 
 
791
        ge_cairo_rounded_rectangle (cr, 0, 0, width-1, height-1, radius, params->corners);
 
792
        
 
793
        if (params->active)
 
794
        {
 
795
                ge_cairo_set_color (cr, border);
 
796
                cairo_stroke (cr);
 
797
        }
 
798
        else
 
799
        {
 
800
                pattern = cairo_pattern_create_linear (tab->gap_side == CL_GAP_LEFT   ? width-2  : 2,
 
801
                                                       tab->gap_side == CL_GAP_TOP    ? height-2 : 2,
 
802
                                                       tab->gap_side == CL_GAP_RIGHT  ? width    : 2,
 
803
                                                       tab->gap_side == CL_GAP_BOTTOM ? height   : 2);
 
804
                
 
805
                cairo_pattern_add_color_stop_rgb (pattern, 0.0, stripe_border->r, stripe_border->g, stripe_border->b);
 
806
                cairo_pattern_add_color_stop_rgb (pattern, 0.8, border->r,        border->g,        border->b);
 
807
                cairo_set_source (cr, pattern);
 
808
                cairo_stroke (cr);
 
809
                cairo_pattern_destroy (pattern);
 
810
        }
 
811
}
 
812
 
 
813
static void
 
814
clearlooks_glossy_draw_slider (cairo_t *cr,
 
815
                        const ClearlooksColors *colors,
 
816
                        const WidgetParameters *params,
 
817
                        int x, int y, int width, int height)
 
818
{
 
819
        const CairoColor *border  = &colors->shade[7];
 
820
        CairoColor  fill;
 
821
        CairoColor  hilight;
 
822
        CairoColor  a, b, c, d;
 
823
        cairo_pattern_t *pattern;
 
824
 
 
825
        cairo_set_line_width (cr, 1.0); 
 
826
        cairo_translate      (cr, x, y);
 
827
 
 
828
        cairo_translate (cr, -0.5, -0.5);
 
829
 
 
830
        ge_shade_color (&colors->bg[params->state_type], 1.0, &fill);
 
831
        if (params->prelight)
 
832
                ge_shade_color (&fill, 1.1, &fill);
 
833
 
 
834
        ge_shade_color (&fill, 1.25, &hilight);
 
835
        ge_shade_color (&fill, 1.16, &a);
 
836
        ge_shade_color (&fill, 1.08, &b);
 
837
        ge_shade_color (&fill, 1.0,  &c);
 
838
        ge_shade_color (&fill, 1.08, &d);
 
839
 
 
840
        pattern = cairo_pattern_create_linear (1, 1, 1, height-2);
 
841
        cairo_pattern_add_color_stop_rgb (pattern, 0,   a.r, a.g, a.b);
 
842
        cairo_pattern_add_color_stop_rgb (pattern, 0.5, b.r, b.g, b.b);
 
843
        cairo_pattern_add_color_stop_rgb (pattern, 0.5, c.r, c.g, c.b); 
 
844
        cairo_pattern_add_color_stop_rgb (pattern, 1.0, d.r, d.g, d.b);
 
845
        cairo_rectangle (cr, 1, 1, width-2, height-2);
 
846
        cairo_set_source (cr, pattern);
 
847
        cairo_fill (cr);
 
848
        cairo_pattern_destroy (pattern);
 
849
 
 
850
        clearlooks_set_mixed_color (cr, border, &fill, 0.2);
 
851
        if (params->prelight)
 
852
                ge_cairo_set_color (cr, &colors->spot[2]);
 
853
        ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, 2.5, params->corners);
 
854
        cairo_stroke (cr);
 
855
 
 
856
        cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.5);
 
857
        ge_cairo_rounded_rectangle (cr, 1.5, 1.5, width-3, height-3, 2.0, params->corners);
 
858
        cairo_stroke (cr);
 
859
}
 
860
 
 
861
static void
 
862
clearlooks_glossy_draw_slider_button (cairo_t *cr,
 
863
                                      const ClearlooksColors *colors,
 
864
                                      const WidgetParameters *params,
 
865
                                      const SliderParameters *slider,
 
866
                                      int x, int y, int width, int height)
 
867
{
 
868
        double radius = MIN (params->radius, MIN ((width - 1.0) / 2.0, (height - 1.0) / 2.0));
 
869
 
 
870
        cairo_set_line_width (cr, 1.0);
 
871
        
 
872
        if (!slider->horizontal)
 
873
                ge_cairo_exchange_axis (cr, &x, &y, &width, &height);
 
874
 
 
875
        cairo_translate (cr, x+0.5, y+0.5);
 
876
        
 
877
        params->style_functions->draw_shadow (cr, colors, radius, width-1, height-1);
 
878
        params->style_functions->draw_slider (cr, colors, params, 1, 1, width-2, height-2);
 
879
}
 
880
 
 
881
static void
 
882
clearlooks_glossy_draw_scrollbar_stepper (cairo_t *cr,
 
883
                                   const ClearlooksColors           *colors,
 
884
                                   const WidgetParameters           *widget,
 
885
                                   const ScrollBarParameters        *scrollbar,
 
886
                                   const ScrollBarStepperParameters *stepper,
 
887
                                   int x, int y, int width, int height)
 
888
{
 
889
        CairoCorners corners = CR_CORNER_NONE;
 
890
        const CairoColor *border = &colors->shade[7];
 
891
        CairoColor  fill, s1, s2, s4;
 
892
        cairo_pattern_t *pattern;
 
893
        double radius = MIN (widget->radius, MIN ((width - 2.0) / 2.0, (height - 2.0) / 2.0));
 
894
        
 
895
        if (scrollbar->horizontal)
 
896
        {
 
897
                if (stepper->stepper == CL_STEPPER_A)
 
898
                        corners = CR_CORNER_TOPLEFT | CR_CORNER_BOTTOMLEFT;
 
899
                else if (stepper->stepper == CL_STEPPER_D)
 
900
                        corners = CR_CORNER_TOPRIGHT | CR_CORNER_BOTTOMRIGHT;
 
901
        }
 
902
        else
 
903
        {
 
904
                if (stepper->stepper == CL_STEPPER_A)
 
905
                        corners = CR_CORNER_TOPLEFT | CR_CORNER_TOPRIGHT;
 
906
                else if (stepper->stepper == CL_STEPPER_D)
 
907
                        corners = CR_CORNER_BOTTOMLEFT | CR_CORNER_BOTTOMRIGHT;
 
908
        }
 
909
        
 
910
        cairo_translate (cr, x, y);
 
911
        cairo_set_line_width (cr, 1);
 
912
        
 
913
        ge_cairo_rounded_rectangle (cr, 1, 1, width-2, height-2, radius, corners);
 
914
        
 
915
        if (scrollbar->horizontal)
 
916
                pattern = cairo_pattern_create_linear (0, 0, 0, height);
 
917
        else
 
918
                pattern = cairo_pattern_create_linear (0, 0, width, 0);
 
919
                                
 
920
        fill = colors->bg[widget->state_type];
 
921
        ge_shade_color(&fill, 1.16, &s1);
 
922
        ge_shade_color(&fill, 1.08, &s2);
 
923
        ge_shade_color(&fill, 1.08, &s4);
 
924
        
 
925
        cairo_pattern_add_color_stop_rgb(pattern, 0,    s1.r, s1.g, s1.b);
 
926
        cairo_pattern_add_color_stop_rgb(pattern, 0.5,  s2.r, s2.g, s2.b);
 
927
        cairo_pattern_add_color_stop_rgb(pattern, 0.5,  fill.r, fill.g, fill.b);
 
928
        cairo_pattern_add_color_stop_rgb(pattern, 1.0,  s4.r, s4.g, s4.b);
 
929
        cairo_set_source (cr, pattern);
 
930
        cairo_fill (cr);
 
931
        cairo_pattern_destroy (pattern);
 
932
        
 
933
        cairo_translate (cr, 0.5, 0.5);
 
934
        cairo_translate (cr, -0.5, -0.5);
 
935
        
 
936
        ge_cairo_rounded_rectangle (cr, 0.5, 0.5, width-1, height-1, radius, corners);
 
937
        clearlooks_set_mixed_color (cr, border, &fill, 0.2);
 
938
        if (widget->prelight)
 
939
                ge_cairo_set_color (cr, &colors->spot[2]);
 
940
        cairo_stroke (cr);
 
941
        
 
942
        cairo_translate (cr, 0.5, 0.5);
 
943
}
 
944
 
 
945
static void
 
946
clearlooks_glossy_draw_scrollbar_slider (cairo_t *cr,
 
947
                                   const ClearlooksColors          *colors,
 
948
                                   const WidgetParameters          *widget,
 
949
                                   const ScrollBarParameters       *scrollbar,
 
950
                                   int x, int y, int width, int height)
 
951
{
 
952
        const CairoColor *border  = &colors->shade[7];
 
953
        CairoColor  fill  = scrollbar->color;
 
954
        CairoColor  hilight;
 
955
        CairoColor  shade1, shade2, shade3;
 
956
        cairo_pattern_t *pattern;
 
957
 
 
958
        if (scrollbar->junction & CL_JUNCTION_BEGIN)
 
959
        {
 
960
                if (scrollbar->horizontal)
 
961
                {
 
962
                        x -= 1;
 
963
                        width += 1;
 
964
                }
 
965
                else
 
966
                {
 
967
                        y -= 1;
 
968
                        height += 1;
 
969
                }
 
970
        }
 
971
        if (scrollbar->junction & CL_JUNCTION_END)
 
972
        {
 
973
                if (scrollbar->horizontal)
 
974
                        width += 1;
 
975
                else
 
976
                        height += 1;
 
977
        }
 
978
        
 
979
        if (!scrollbar->horizontal)
 
980
                ge_cairo_exchange_axis (cr, &x, &y, &width, &height);
 
981
 
 
982
        cairo_translate (cr, x, y);
 
983
 
 
984
        if (widget->prelight)
 
985
                ge_shade_color (&fill, 1.1, &fill);
 
986
                
 
987
        cairo_set_line_width (cr, 1);
 
988
        
 
989
        ge_shade_color (&fill, 1.25, &hilight);
 
990
        ge_shade_color (&fill, 1.16, &shade1);
 
991
        ge_shade_color (&fill, 1.08, &shade2);
 
992
        ge_shade_color (&fill, 1.08, &shade3);
 
993
        
 
994
        pattern = cairo_pattern_create_linear (1, 1, 1, height-2);
 
995
        cairo_pattern_add_color_stop_rgb (pattern, 0,   shade1.r, shade1.g, shade1.b);
 
996
        cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade2.r, shade2.g, shade2.b);
 
997
        cairo_pattern_add_color_stop_rgb (pattern, 0.5,         fill.r,  fill.g,  fill.b);
 
998
        cairo_pattern_add_color_stop_rgb (pattern, 1,   shade3.r, shade3.g, shade3.b);
 
999
        cairo_rectangle (cr, 1, 1, width-2, height-2);
 
1000
        cairo_set_source (cr, pattern);
 
1001
        cairo_fill (cr);
 
1002
        cairo_pattern_destroy (pattern);
 
1003
        
 
1004
        if (scrollbar->has_color) 
 
1005
        {
 
1006
                cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.5);
 
1007
                ge_cairo_stroke_rectangle (cr, 1.5, 1.5, width-3, height-3);
 
1008
        }
 
1009
 
 
1010
        clearlooks_set_mixed_color (cr, border, &fill, scrollbar->has_color? 0.4 : 0.2);
 
1011
        ge_cairo_stroke_rectangle (cr, 0.5, 0.5, width-1, height-1);
 
1012
}
 
1013
 
 
1014
static void
 
1015
clearlooks_glossy_draw_list_view_header (cairo_t *cr,
 
1016
                                  const ClearlooksColors          *colors,
 
1017
                                  const WidgetParameters          *params,
 
1018
                                  const ListViewHeaderParameters  *header,
 
1019
                                  int x, int y, int width, int height)
 
1020
{
 
1021
/*
 
1022
        CairoColor *border = !params->prelight? (CairoColor*)&colors->shade[4] : (CairoColor*)&colors->spot[1];
 
1023
*/
 
1024
        const CairoColor *border = &colors->shade[4];
 
1025
        const CairoColor *fill   = &colors->bg[params->state_type];
 
1026
        CairoColor hilight;
 
1027
        CairoColor shade1, shade2, shade3;
 
1028
 
 
1029
        cairo_pattern_t *pattern;
 
1030
 
 
1031
        ge_shade_color (fill, 1.2, &hilight);
 
1032
        ge_shade_color (fill, 1.08, &shade1);
 
1033
        ge_shade_color (fill, 1.04, &shade2);
 
1034
        ge_shade_color (fill, 1.04, &shade3);
 
1035
 
 
1036
        cairo_translate (cr, x, y);
 
1037
        cairo_set_line_width (cr, 1.0);
 
1038
 
 
1039
        /* Draw the fill */
 
1040
        pattern = cairo_pattern_create_linear (0, 0, 0, height);
 
1041
        cairo_pattern_add_color_stop_rgb (pattern, 0.0, shade1.r, shade1.g, shade1.b);
 
1042
        cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade2.r, shade2.g, shade2.b);
 
1043
        cairo_pattern_add_color_stop_rgb (pattern, 0.5, fill->r, fill->g, fill->b);
 
1044
        cairo_pattern_add_color_stop_rgb (pattern, 1.0-1.0/height, shade3.r, shade3.g, shade3.b);
 
1045
        cairo_pattern_add_color_stop_rgb (pattern, 1.0-1.0/height, border->r, border->g, border->b);
 
1046
        cairo_pattern_add_color_stop_rgb (pattern, 1.0, border->r, border->g, border->b);
 
1047
 
 
1048
        cairo_set_source (cr, pattern);
 
1049
        cairo_rectangle (cr, 0, 0, width, height);
 
1050
        cairo_fill (cr);
 
1051
 
 
1052
        cairo_pattern_destroy (pattern);
 
1053
        
 
1054
        /* Draw highlight */
 
1055
        if (header->order == CL_ORDER_FIRST)
 
1056
        {
 
1057
                cairo_move_to (cr, 0.5, height-1);
 
1058
                cairo_line_to (cr, 0.5, 0.5);
 
1059
        }
 
1060
        else
 
1061
                cairo_move_to (cr, 0.0, 0.5);
 
1062
        
 
1063
        cairo_line_to (cr, width, 0.5);
 
1064
        
 
1065
        cairo_set_source_rgba (cr, hilight.r, hilight.g, hilight.b, 0.5);
 
1066
        cairo_stroke (cr);
 
1067
        
 
1068
        /* Draw resize grip */
 
1069
        if ((params->ltr && header->order != CL_ORDER_LAST) ||
 
1070
            (!params->ltr && header->order != CL_ORDER_FIRST) || header->resizable)
 
1071
        {
 
1072
                SeparatorParameters separator;
 
1073
                separator.horizontal = FALSE;
 
1074
                
 
1075
                if (params->ltr)
 
1076
                        params->style_functions->draw_separator (cr, colors, params, &separator,
 
1077
                                                                 width-1.5, 4.0, 2, height-8.0);
 
1078
                else
 
1079
                        params->style_functions->draw_separator (cr, colors, params, &separator,
 
1080
                                                                 1.5, 4.0, 2, height-8.0);
 
1081
        }
 
1082
}
 
1083
 
 
1084
static void 
 
1085
clearlooks_glossy_draw_toolbar (cairo_t *cr,
 
1086
                         const ClearlooksColors          *colors,
 
1087
                         const WidgetParameters          *widget,
 
1088
                         const ToolbarParameters         *toolbar,
 
1089
                         int x, int y, int width, int height)
 
1090
{
 
1091
        (void) widget;
 
1092
        (void) width;
 
1093
        (void) height;
 
1094
        
 
1095
        const CairoColor *fill  = &colors->bg[GTK_STATE_NORMAL];
 
1096
        const CairoColor *dark  = &colors->shade[3];
 
1097
        CairoColor light;
 
1098
        ge_shade_color (fill, 1.1, &light);
 
1099
        
 
1100
        cairo_set_line_width (cr, 1.0);
 
1101
        cairo_translate (cr, x, y);
 
1102
        
 
1103
        if (toolbar->style == 1) /* Enable Extra features */
 
1104
        { 
 
1105
                cairo_pattern_t *pattern;
 
1106
                CairoColor shade1, shade2, shade3;
 
1107
                
 
1108
                ge_shade_color (fill, 1.08, &shade1);
 
1109
                ge_shade_color (fill, 1.04, &shade2);
 
1110
                ge_shade_color (fill, 1.04, &shade3);
 
1111
 
 
1112
                /* Draw the fill */
 
1113
                pattern = cairo_pattern_create_linear (0, 0, 0, height);
 
1114
                cairo_pattern_add_color_stop_rgb (pattern, 0.0, shade1.r, shade1.g, shade1.b);
 
1115
                cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade2.r, shade2.g, shade2.b);
 
1116
                cairo_pattern_add_color_stop_rgb (pattern, 0.5, fill->r, fill->g, fill->b);
 
1117
                cairo_pattern_add_color_stop_rgb (pattern, 1.0, shade3.r, shade3.g, shade3.b);
 
1118
 
 
1119
                cairo_set_source (cr, pattern);
 
1120
                cairo_rectangle (cr, 0, 0, width, height);
 
1121
                cairo_fill (cr);
 
1122
 
 
1123
                cairo_pattern_destroy (pattern);
 
1124
        }
 
1125
        else /* Flat */
 
1126
        { 
 
1127
                ge_cairo_set_color (cr, fill);
 
1128
                cairo_paint (cr);
 
1129
 
 
1130
                if (!toolbar->topmost) 
 
1131
                {
 
1132
                        /* Draw highlight */
 
1133
                        cairo_move_to       (cr, 0, 0.5);
 
1134
                        cairo_line_to       (cr, width-1, 0.5);
 
1135
                        ge_cairo_set_color  (cr, &light);
 
1136
                        cairo_stroke        (cr);
 
1137
                }       
 
1138
        }
 
1139
 
 
1140
        /* Draw shadow */
 
1141
        cairo_move_to       (cr, 0, height-0.5);
 
1142
        cairo_line_to       (cr, width-1, height-0.5);
 
1143
        ge_cairo_set_color  (cr, dark);
 
1144
        cairo_stroke        (cr);
 
1145
}
 
1146
 
 
1147
static void
 
1148
clearlooks_glossy_draw_menuitem (cairo_t                   *cr,
 
1149
                                 const ClearlooksColors    *colors,
 
1150
                                 const WidgetParameters    *params,
 
1151
                                 int x, int y, int width, int height)
 
1152
{
 
1153
        const CairoColor *fill = &colors->spot[1];
 
1154
        const CairoColor *border = &colors->spot[2];
 
1155
        CairoColor shade1, shade2, shade3;
 
1156
        cairo_pattern_t *pattern;
 
1157
 
 
1158
        ge_shade_color (fill, 1.16, &shade1);
 
1159
        ge_shade_color (fill, 1.08, &shade2);
 
1160
        ge_shade_color (fill, 1.08, &shade3);
 
1161
        cairo_set_line_width (cr, 1.0);
 
1162
 
 
1163
        ge_cairo_rounded_rectangle (cr, x+0.5, y+0.5, width - 1, height - 1, params->radius, params->corners);
 
1164
 
 
1165
        pattern = cairo_pattern_create_linear (x, y, x, y + height);
 
1166
        cairo_pattern_add_color_stop_rgb (pattern, 0,   shade1.r, shade1.g, shade1.b);
 
1167
        cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade2.r, shade2.g, shade2.b);
 
1168
        cairo_pattern_add_color_stop_rgb (pattern, 0.5, fill->r,  fill->g,  fill->b);
 
1169
        cairo_pattern_add_color_stop_rgb (pattern, 1,   shade3.r, shade3.g, shade3.b);
 
1170
 
 
1171
        cairo_set_source (cr, pattern);
 
1172
        cairo_fill_preserve  (cr);
 
1173
        cairo_pattern_destroy (pattern);
 
1174
 
 
1175
        ge_cairo_set_color (cr, border);
 
1176
        cairo_stroke (cr);
 
1177
}
 
1178
 
 
1179
static void
 
1180
clearlooks_glossy_draw_menubaritem (cairo_t                   *cr,
 
1181
                                    const ClearlooksColors    *colors,
 
1182
                                    const WidgetParameters    *params,
 
1183
                                    int x, int y, int width, int height)
 
1184
{
 
1185
        const CairoColor *fill = &colors->spot[1];
 
1186
        const CairoColor *border = &colors->spot[2];
 
1187
        CairoColor shade1, shade2, shade3;
 
1188
        cairo_pattern_t *pattern;
 
1189
 
 
1190
        ge_shade_color (fill, 1.16, &shade1);
 
1191
        ge_shade_color (fill, 1.08, &shade2);
 
1192
        ge_shade_color (fill, 1.08, &shade3);
 
1193
        cairo_set_line_width (cr, 1.0);
 
1194
 
 
1195
        ge_cairo_rounded_rectangle (cr, x+0.5, y+0.5, width - 1, height - 1, params->radius, params->corners);
 
1196
 
 
1197
        pattern = cairo_pattern_create_linear (x, y, x, y + height);
 
1198
        cairo_pattern_add_color_stop_rgb (pattern, 0,   shade1.r, shade1.g, shade1.b);
 
1199
        cairo_pattern_add_color_stop_rgb (pattern, 0.5, shade2.r, shade2.g, shade2.b);
 
1200
        cairo_pattern_add_color_stop_rgb (pattern, 0.5, fill->r,  fill->g,  fill->b);
 
1201
        cairo_pattern_add_color_stop_rgb (pattern, 1,   shade3.r, shade3.g, shade3.b);
 
1202
 
 
1203
        cairo_set_source (cr, pattern);
 
1204
        cairo_fill_preserve  (cr);
 
1205
        cairo_pattern_destroy (pattern);
 
1206
 
 
1207
        ge_cairo_set_color (cr, border);
 
1208
        cairo_stroke (cr);
 
1209
}
 
1210
 
 
1211
static void
 
1212
clearlooks_glossy_draw_selected_cell (cairo_t                  *cr,
 
1213
                                      const ClearlooksColors   *colors,
 
1214
                                      const WidgetParameters   *params,
 
1215
                                      int x, int y, int width, int height)
 
1216
{
 
1217
        CairoColor color;
 
1218
 
 
1219
        if (params->focus)
 
1220
                color = colors->base[params->state_type];
 
1221
        else
 
1222
                color = colors->base[GTK_STATE_ACTIVE];
 
1223
 
 
1224
        clearlooks_draw_glossy_gradient (cr, x, y, width, height, &color, params->disabled, 0.0, CR_CORNER_NONE);
 
1225
}
 
1226
 
 
1227
 
 
1228
static void
 
1229
clearlooks_glossy_draw_radiobutton (cairo_t *cr,
 
1230
                             const ClearlooksColors  *colors,
 
1231
                             const WidgetParameters  *widget,
 
1232
                             const CheckboxParameters *checkbox,
 
1233
                             int x, int y, int width, int height)
 
1234
{
 
1235
        (void) width;
 
1236
        (void) height;
 
1237
        
 
1238
        const CairoColor *border;
 
1239
        const CairoColor *dot;
 
1240
        CairoColor shadow;
 
1241
        CairoColor highlight;
 
1242
        cairo_pattern_t *pt;
 
1243
        gboolean inconsistent;
 
1244
        gboolean draw_bullet = (checkbox->shadow_type == GTK_SHADOW_IN);
 
1245
 
 
1246
        inconsistent = (checkbox->shadow_type == GTK_SHADOW_ETCHED_IN);
 
1247
        draw_bullet |= inconsistent;
 
1248
 
 
1249
        if (widget->disabled)
 
1250
        {
 
1251
                border = &colors->shade[5];
 
1252
                dot    = &colors->shade[6];
 
1253
        }
 
1254
        else
 
1255
        {
 
1256
                if (widget->prelight)
 
1257
                        border = &colors->spot[2];
 
1258
                else
 
1259
                        border = &colors->shade[6];
 
1260
                dot    = &colors->text[0];
 
1261
        }
 
1262
 
 
1263
        ge_shade_color (&widget->parentbg, 0.9, &shadow);
 
1264
        ge_shade_color (&widget->parentbg, 1.1, &highlight);
 
1265
 
 
1266
        pt = cairo_pattern_create_linear (0, 0, 13, 13);
 
1267
        cairo_pattern_add_color_stop_rgb (pt, 0.0, shadow.r, shadow.b, shadow.g);
 
1268
        cairo_pattern_add_color_stop_rgba (pt, 0.5, shadow.r, shadow.b, shadow.g, 0.5);
 
1269
        cairo_pattern_add_color_stop_rgba (pt, 0.5, highlight.r, highlight.g, highlight.b, 0.5);
 
1270
        cairo_pattern_add_color_stop_rgb (pt, 1.0, highlight.r, highlight.g, highlight.b);
 
1271
        
 
1272
        cairo_translate (cr, x, y);
 
1273
        
 
1274
        cairo_set_line_width (cr, 2);
 
1275
        cairo_arc       (cr, 7, 7, 6, 0, G_PI*2);
 
1276
        cairo_set_source (cr, pt);
 
1277
        cairo_stroke (cr);
 
1278
        cairo_pattern_destroy (pt);
 
1279
 
 
1280
        cairo_set_line_width (cr, 1);
 
1281
 
 
1282
        cairo_arc       (cr, 7, 7, 5.5, 0, G_PI*2);
 
1283
        
 
1284
        if (!widget->disabled)
 
1285
        {
 
1286
                if (widget->prelight)
 
1287
                        clearlooks_set_mixed_color (cr, &colors->base[0], &colors->spot[1], 0.5);
 
1288
                else            
 
1289
                        ge_cairo_set_color (cr, &colors->base[0]);
 
1290
                cairo_fill_preserve (cr);
 
1291
        }
 
1292
        
 
1293
        ge_cairo_set_color (cr, border);
 
1294
        cairo_stroke (cr);
 
1295
        
 
1296
        if (draw_bullet)
 
1297
        {
 
1298
                if (inconsistent)
 
1299
                {
 
1300
                        cairo_set_line_cap(cr, CAIRO_LINE_CAP_ROUND);
 
1301
                        cairo_set_line_width (cr, 4);
 
1302
 
 
1303
                        cairo_move_to(cr, 5, 7);
 
1304
                        cairo_line_to(cr, 9, 7);
 
1305
 
 
1306
                        ge_cairo_set_color (cr, dot);
 
1307
                        cairo_stroke (cr);
 
1308
                }
 
1309
                else
 
1310
                {
 
1311
                        cairo_arc (cr, 7, 7, 3, 0, G_PI*2);
 
1312
                        ge_cairo_set_color (cr, dot);
 
1313
                        cairo_fill (cr);
 
1314
                
 
1315
                        cairo_arc (cr, 6, 6, 1, 0, G_PI*2);
 
1316
                        cairo_set_source_rgba (cr, highlight.r, highlight.g, highlight.b, 0.5);
 
1317
                        cairo_fill (cr);
 
1318
                }
 
1319
        }
 
1320
}
 
1321
 
 
1322
static void
 
1323
clearlooks_glossy_draw_checkbox (cairo_t *cr,
 
1324
                          const ClearlooksColors  *colors,
 
1325
                          const WidgetParameters  *widget,
 
1326
                          const CheckboxParameters *checkbox,
 
1327
                          int x, int y, int width, int height)
 
1328
{
 
1329
        const CairoColor *border;
 
1330
        const CairoColor *dot; 
 
1331
        gboolean inconsistent = FALSE;
 
1332
        gboolean draw_bullet = (checkbox->shadow_type == GTK_SHADOW_IN);
 
1333
 
 
1334
        inconsistent = (checkbox->shadow_type == GTK_SHADOW_ETCHED_IN);
 
1335
        draw_bullet |= inconsistent;
 
1336
        
 
1337
        if (widget->disabled)
 
1338
        {
 
1339
                border = &colors->shade[5];
 
1340
                dot    = &colors->shade[6];
 
1341
        }
 
1342
        else
 
1343
        {
 
1344
                if (widget->prelight)
 
1345
                        border = &colors->spot[2];
 
1346
                else            
 
1347
                        border = &colors->shade[6];
 
1348
                dot    = &colors->text[GTK_STATE_NORMAL];
 
1349
        }
 
1350
 
 
1351
        cairo_translate (cr, x, y);
 
1352
        cairo_set_line_width (cr, 1);
 
1353
        
 
1354
        if (widget->xthickness > 2 && widget->ythickness > 2)
 
1355
        {
 
1356
                widget->style_functions->draw_inset (cr, &widget->parentbg, 0.5, 0.5, 
 
1357
                                           width-1, height-1, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
 
1358
                
 
1359
                /* Draw the rectangle for the checkbox itself */
 
1360
                ge_cairo_rounded_rectangle (cr, 1.5, 1.5, 
 
1361
                                  width-3, height-3, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
 
1362
        }
 
1363
        else
 
1364
        {
 
1365
                /* Draw the rectangle for the checkbox itself */
 
1366
                ge_cairo_rounded_rectangle (cr, 0.5, 0.5, 
 
1367
                                  width-1, height-1, (widget->radius > 0)? 1 : 0, CR_CORNER_ALL);
 
1368
        }
 
1369
        
 
1370
        if (!widget->disabled)
 
1371
        {
 
1372
                if (widget->prelight)
 
1373
                        clearlooks_set_mixed_color (cr, &colors->base[0], &colors->spot[1], 0.5);
 
1374
                else
 
1375
                        ge_cairo_set_color (cr, &colors->base[0]);
 
1376
                cairo_fill_preserve (cr);
 
1377
        }
 
1378
        
 
1379
        ge_cairo_set_color (cr, border);
 
1380
        cairo_stroke (cr);
 
1381
 
 
1382
        if (draw_bullet)
 
1383
        {
 
1384
                if (inconsistent) /* Inconsistent */
 
1385
                {
 
1386
                        cairo_set_line_width (cr, 2.0);
 
1387
                        cairo_move_to (cr, 3, height*0.5);
 
1388
                        cairo_line_to (cr, width-3, height*0.5);
 
1389
                }
 
1390
                else
 
1391
                {
 
1392
                        cairo_set_line_width (cr, 1.7);
 
1393
                        cairo_move_to (cr, 0.5 + (width*0.2), (height*0.5));
 
1394
                        cairo_line_to (cr, 0.5 + (width*0.4), (height*0.7));
 
1395
                
 
1396
                        cairo_curve_to (cr, 0.5 + (width*0.4), (height*0.7),
 
1397
                                            0.5 + (width*0.5), (height*0.4),
 
1398
                                            0.5 + (width*0.70), (height*0.25));
 
1399
 
 
1400
                }
 
1401
                
 
1402
                ge_cairo_set_color (cr, dot);
 
1403
                cairo_stroke (cr);
 
1404
        }
 
1405
}
 
1406
 
 
1407
void
 
1408
clearlooks_register_style_glossy (ClearlooksStyleFunctions *functions)
 
1409
{
 
1410
        functions->draw_inset              = clearlooks_glossy_draw_inset;
 
1411
        functions->draw_button             = clearlooks_glossy_draw_button;
 
1412
        functions->draw_progressbar_trough = clearlooks_glossy_draw_progressbar_trough;
 
1413
        functions->draw_progressbar_fill   = clearlooks_glossy_draw_progressbar_fill;
 
1414
        functions->draw_scale_trough       = clearlooks_glossy_draw_scale_trough;
 
1415
        functions->draw_tab                = clearlooks_glossy_draw_tab;
 
1416
        functions->draw_slider             = clearlooks_glossy_draw_slider;
 
1417
        functions->draw_slider_button      = clearlooks_glossy_draw_slider_button;
 
1418
        functions->draw_scrollbar_stepper  = clearlooks_glossy_draw_scrollbar_stepper;
 
1419
        functions->draw_scrollbar_slider   = clearlooks_glossy_draw_scrollbar_slider;
 
1420
        functions->draw_list_view_header   = clearlooks_glossy_draw_list_view_header;
 
1421
        functions->draw_toolbar            = clearlooks_glossy_draw_toolbar;
 
1422
        functions->draw_menuitem           = clearlooks_glossy_draw_menuitem;
 
1423
        functions->draw_menubaritem        = clearlooks_glossy_draw_menubaritem;
 
1424
        functions->draw_selected_cell      = clearlooks_glossy_draw_selected_cell;
 
1425
        functions->draw_checkbox           = clearlooks_glossy_draw_checkbox;
 
1426
        functions->draw_radiobutton        = clearlooks_glossy_draw_radiobutton;
 
1427
}