← Back to branch summary

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

« back to all changes in this revision

Viewing changes to libs/gtkmm2ext/prolooks_helpers.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:
libs/gtkmm2ext/prolooks_helpers.c
 
1
/* Helpers.c generated by valac, the Vala compiler
 
2
 * generated from Helpers.vala, do not modify */
 
3
 
 
4
/* 
 
5
    Copyright 2009 by Hans Baier
 
6
    License: LGPLv2+ 
 
7
*/
 
8
 
 
9
#include "gtkmm2ext/prolooks-helpers.h"
 
10
 
 
11
static gpointer cairo_color_parent_class = NULL;
 
12
static gpointer prolooks_hsl_parent_class = NULL;
 
13
static gpointer prolooks_hsv_parent_class = NULL;
 
14
 
 
15
CairoColor* cairo_color_construct (GType object_type, double red, double green, double blue, double alpha) {
 
16
        CairoColor* self;
 
17
        self = (CairoColor*) g_type_create_instance (object_type);
 
18
        cairo_color_set_red (self, red);
 
19
        cairo_color_set_green (self, green);
 
20
        cairo_color_set_blue (self, blue);
 
21
        cairo_color_set_alpha (self, alpha);
 
22
        return self;
 
23
}
 
24
 
 
25
 
 
26
CairoColor* cairo_color_new (double red, double green, double blue, double alpha) {
 
27
        return cairo_color_construct (CAIRO_TYPE_COLOR, red, green, blue, alpha);
 
28
}
 
29
 
 
30
 
 
31
CairoColor* cairo_color_copy (CairoColor* self) {
 
32
        CairoColor* result = NULL;
 
33
        g_return_val_if_fail (self != NULL, NULL);
 
34
        result = cairo_color_new (self->priv->_red, self->priv->_green, self->priv->_blue, self->priv->_alpha);
 
35
        return result;
 
36
}
 
37
 
 
38
 
 
39
CairoColor* cairo_color_construct_from_string (GType object_type, const char* webcolor) {
 
40
        CairoColor* self;
 
41
        g_return_val_if_fail (webcolor != NULL, NULL);
 
42
        self = (CairoColor*) g_type_create_instance (object_type);
 
43
        cairo_color_set_from_string (self, webcolor);
 
44
        return self;
 
45
}
 
46
 
 
47
 
 
48
CairoColor* cairo_color_new_from_string (const char* webcolor) {
 
49
        return cairo_color_construct_from_string (CAIRO_TYPE_COLOR, webcolor);
 
50
}
 
51
 
 
52
 
 
53
CairoColor* cairo_color_shade (CairoColor* self, double shade_factor) {
 
54
        CairoColor* result = NULL;
 
55
        ProlooksHSL* hsl;
 
56
        g_return_val_if_fail (self != NULL, NULL);
 
57
        hsl = prolooks_hsl_new ();
 
58
        prolooks_hsl_from_cairo_color (hsl, self);
 
59
        prolooks_hsl_set_lightness (hsl, fmin (prolooks_hsl_get_lightness (hsl) * shade_factor, 1.0));
 
60
        prolooks_hsl_set_lightness (hsl, fmax (prolooks_hsl_get_lightness (hsl), 0.0));
 
61
        prolooks_hsl_set_saturation (hsl, fmin (prolooks_hsl_get_saturation (hsl) * shade_factor, 1.0));
 
62
        prolooks_hsl_set_saturation (hsl, fmax (prolooks_hsl_get_saturation (hsl), 0.0));
 
63
        result = prolooks_hsl_to_cairo_color (hsl);
 
64
        _prolooks_hsl_unref0 (hsl);
 
65
        return result;
 
66
}
 
67
 
 
68
 
 
69
void cairo_color_set_to (CairoColor* self, CairoColor* a_color) {
 
70
        g_return_if_fail (self != NULL);
 
71
        g_return_if_fail (a_color != NULL);
 
72
        cairo_color_set_red (self, a_color->priv->_red);
 
73
        cairo_color_set_green (self, a_color->priv->_green);
 
74
        cairo_color_set_blue (self, a_color->priv->_blue);
 
75
        cairo_color_set_alpha (self, a_color->priv->_alpha);
 
76
}
 
77
 
 
78
 
 
79
void cairo_color_set_as_source_in (CairoColor* self, cairo_t* cr) {
 
80
        g_return_if_fail (self != NULL);
 
81
        g_return_if_fail (cr != NULL);
 
82
        cairo_set_source_rgba (cr, self->priv->_red, self->priv->_green, self->priv->_blue, self->priv->_alpha);
 
83
}
 
84
 
 
85
 
 
86
void cairo_color_add_color_stop_to (CairoColor* self, cairo_pattern_t* p, double offset) {
 
87
        g_return_if_fail (self != NULL);
 
88
        g_return_if_fail (p != NULL);
 
89
        cairo_pattern_add_color_stop_rgba (p, offset, self->priv->_red, self->priv->_green, self->priv->_blue, self->priv->_alpha);
 
90
}
 
91
 
 
92
 
 
93
void cairo_color_set_from_string (CairoColor* self, const char* webcolor) {
 
94
        CairoColor* _tmp2_;
 
95
        GdkColor _tmp1_;
 
96
        GdkColor _tmp0_ = {0,0,0,0};
 
97
        g_return_if_fail (self != NULL);
 
98
        g_return_if_fail (webcolor != NULL);
 
99
        cairo_color_set_to (self, _tmp2_ = prolooks_gdk_color_to_cairo ((_tmp1_ = (prolooks_color_from_string (webcolor, &_tmp0_), _tmp0_), &_tmp1_)));
 
100
        _cairo_color_unref0 (_tmp2_);
 
101
}
 
102
 
 
103
 
 
104
double cairo_color_get_red (CairoColor* self) {
 
105
        double result;
 
106
        g_return_val_if_fail (self != NULL, 0.0);
 
107
        result = self->priv->_red;
 
108
        return result;
 
109
}
 
110
 
 
111
 
 
112
void cairo_color_set_red (CairoColor* self, double value) {
 
113
        g_return_if_fail (self != NULL);
 
114
        self->priv->_red = value;
 
115
}
 
116
 
 
117
 
 
118
double cairo_color_get_green (CairoColor* self) {
 
119
        double result;
 
120
        g_return_val_if_fail (self != NULL, 0.0);
 
121
        result = self->priv->_green;
 
122
        return result;
 
123
}
 
124
 
 
125
 
 
126
void cairo_color_set_green (CairoColor* self, double value) {
 
127
        g_return_if_fail (self != NULL);
 
128
        self->priv->_green = value;
 
129
}
 
130
 
 
131
 
 
132
double cairo_color_get_blue (CairoColor* self) {
 
133
        double result;
 
134
        g_return_val_if_fail (self != NULL, 0.0);
 
135
        result = self->priv->_blue;
 
136
        return result;
 
137
}
 
138
 
 
139
 
 
140
void cairo_color_set_blue (CairoColor* self, double value) {
 
141
        g_return_if_fail (self != NULL);
 
142
        self->priv->_blue = value;
 
143
}
 
144
 
 
145
 
 
146
double cairo_color_get_alpha (CairoColor* self) {
 
147
        double result;
 
148
        g_return_val_if_fail (self != NULL, 0.0);
 
149
        result = self->priv->_alpha;
 
150
        return result;
 
151
}
 
152
 
 
153
 
 
154
void cairo_color_set_alpha (CairoColor* self, double value) {
 
155
        g_return_if_fail (self != NULL);
 
156
        self->priv->_alpha = value;
 
157
}
 
158
 
 
159
 
 
160
static void cairo_value_color_init (GValue* value) {
 
161
        value->data[0].v_pointer = NULL;
 
162
}
 
163
 
 
164
 
 
165
static void cairo_value_color_free_value (GValue* value) {
 
166
        if (value->data[0].v_pointer) {
 
167
                cairo_color_unref (value->data[0].v_pointer);
 
168
        }
 
169
}
 
170
 
 
171
 
 
172
static void cairo_value_color_copy_value (const GValue* src_value, GValue* dest_value) {
 
173
        if (src_value->data[0].v_pointer) {
 
174
                dest_value->data[0].v_pointer = cairo_color_ref (src_value->data[0].v_pointer);
 
175
        } else {
 
176
                dest_value->data[0].v_pointer = NULL;
 
177
        }
 
178
}
 
179
 
 
180
 
 
181
static gpointer cairo_value_color_peek_pointer (const GValue* value) {
 
182
        return value->data[0].v_pointer;
 
183
}
 
184
 
 
185
 
 
186
static gchar* cairo_value_color_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 
187
        (void) n_collect_values;
 
188
        (void) collect_flags;
 
189
        if (collect_values[0].v_pointer) {
 
190
                CairoColor* object;
 
191
                object = collect_values[0].v_pointer;
 
192
                if (object->parent_instance.g_class == NULL) {
 
193
                        return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 
194
                } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
 
195
                        return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 
196
                }
 
197
                value->data[0].v_pointer = cairo_color_ref (object);
 
198
        } else {
 
199
                value->data[0].v_pointer = NULL;
 
200
        }
 
201
        return NULL;
 
202
}
 
203
 
 
204
 
 
205
static gchar* cairo_value_color_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 
206
        CairoColor** object_p;
 
207
        (void) n_collect_values;
 
208
        object_p = collect_values[0].v_pointer;
 
209
        if (!object_p) {
 
210
                return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME ((GValue*)value));
 
211
        }
 
212
        if (!value->data[0].v_pointer) {
 
213
                *object_p = NULL;
 
214
        } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
 
215
                *object_p = value->data[0].v_pointer;
 
216
        } else {
 
217
                *object_p = cairo_color_ref (value->data[0].v_pointer);
 
218
        }
 
219
        return NULL;
 
220
}
 
221
 
 
222
 
 
223
GParamSpec* cairo_param_spec_color (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
 
224
        CairoParamSpecColor* spec;
 
225
        g_return_val_if_fail (g_type_is_a (object_type, CAIRO_TYPE_COLOR), NULL);
 
226
        spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
 
227
        G_PARAM_SPEC (spec)->value_type = object_type;
 
228
        return G_PARAM_SPEC (spec);
 
229
}
 
230
 
 
231
 
 
232
gpointer cairo_value_get_color (const GValue* value) {
 
233
        g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE ((GValue*)value, CAIRO_TYPE_COLOR), NULL);
 
234
        return value->data[0].v_pointer;
 
235
}
 
236
 
 
237
 
 
238
void cairo_value_set_color (GValue* value, gpointer v_object) {
 
239
        CairoColor* old;
 
240
        g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, CAIRO_TYPE_COLOR));
 
241
        old = value->data[0].v_pointer;
 
242
        if (v_object) {
 
243
                g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, CAIRO_TYPE_COLOR));
 
244
                g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 
245
                value->data[0].v_pointer = v_object;
 
246
                cairo_color_ref (value->data[0].v_pointer);
 
247
        } else {
 
248
                value->data[0].v_pointer = NULL;
 
249
        }
 
250
        if (old) {
 
251
                cairo_color_unref (old);
 
252
        }
 
253
}
 
254
 
 
255
 
 
256
void cairo_value_take_color (GValue* value, gpointer v_object) {
 
257
        CairoColor* old;
 
258
        g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, CAIRO_TYPE_COLOR));
 
259
        old = value->data[0].v_pointer;
 
260
        if (v_object) {
 
261
                g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, CAIRO_TYPE_COLOR));
 
262
                g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 
263
                value->data[0].v_pointer = v_object;
 
264
        } else {
 
265
                value->data[0].v_pointer = NULL;
 
266
        }
 
267
        if (old) {
 
268
                cairo_color_unref (old);
 
269
        }
 
270
}
 
271
 
 
272
static void cairo_color_finalize (CairoColor* obj) {
 
273
        CairoColor * self;
 
274
        self = CAIRO_COLOR (obj);
 
275
}
 
276
 
 
277
static void cairo_color_class_init (CairoColorClass * klass) {
 
278
        cairo_color_parent_class = g_type_class_peek_parent (klass);
 
279
        CAIRO_COLOR_CLASS (klass)->finalize = cairo_color_finalize;
 
280
        g_type_class_add_private (klass, sizeof (CairoColorPrivate));
 
281
}
 
282
 
 
283
 
 
284
static void cairo_color_instance_init (CairoColor * self) {
 
285
        self->priv = CAIRO_COLOR_GET_PRIVATE (self);
 
286
        self->ref_count = 1;
 
287
}
 
288
 
 
289
 
 
290
 
 
291
GType cairo_color_get_type (void) {
 
292
        static volatile gsize cairo_color_type_id__volatile = 0;
 
293
        if (g_once_init_enter (&cairo_color_type_id__volatile)) {
 
294
                static const GTypeValueTable g_define_type_value_table = { cairo_value_color_init, cairo_value_color_free_value, cairo_value_color_copy_value, cairo_value_color_peek_pointer, "p", cairo_value_color_collect_value, "p", cairo_value_color_lcopy_value };
 
295
                static const GTypeInfo g_define_type_info = { sizeof (CairoColorClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) cairo_color_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (CairoColor), 0, (GInstanceInitFunc) cairo_color_instance_init, &g_define_type_value_table };
 
296
                static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
 
297
                GType cairo_color_type_id;
 
298
                cairo_color_type_id = g_type_register_fundamental (g_type_fundamental_next (), "CairoColor", &g_define_type_info, &g_define_type_fundamental_info, 0);
 
299
                g_once_init_leave (&cairo_color_type_id__volatile, cairo_color_type_id);
 
300
        }
 
301
        return cairo_color_type_id__volatile;
 
302
}
 
303
 
 
304
 
 
305
gpointer cairo_color_ref (gpointer instance) {
 
306
        CairoColor* self;
 
307
        self = instance;
 
308
        g_atomic_int_inc (&self->ref_count);
 
309
        return instance;
 
310
}
 
311
 
 
312
 
 
313
void cairo_color_unref (gpointer instance) {
 
314
        CairoColor* self;
 
315
        self = instance;
 
316
        if (g_atomic_int_dec_and_test (&self->ref_count)) {
 
317
                CAIRO_COLOR_GET_CLASS (self)->finalize (self);
 
318
                g_type_free_instance ((GTypeInstance *) self);
 
319
        }
 
320
}
 
321
 
 
322
 
 
323
GType prolooks_button_state_get_type (void) {
 
324
        static volatile gsize prolooks_button_state_type_id__volatile = 0;
 
325
        if (g_once_init_enter (&prolooks_button_state_type_id__volatile)) {
 
326
                static const GEnumValue values[] = {{PROLOOKS_BUTTON_STATE_NORMAL, "PROLOOKS_BUTTON_STATE_NORMAL", "normal"}, {PROLOOKS_BUTTON_STATE_PRESSED, "PROLOOKS_BUTTON_STATE_PRESSED", "pressed"}, {0, NULL, NULL}};
 
327
                GType prolooks_button_state_type_id;
 
328
                prolooks_button_state_type_id = g_enum_register_static ("ProlooksButtonState", values);
 
329
                g_once_init_leave (&prolooks_button_state_type_id__volatile, prolooks_button_state_type_id);
 
330
        }
 
331
        return prolooks_button_state_type_id__volatile;
 
332
}
 
333
 
 
334
 
 
335
GType prolooks_button_type_get_type (void) {
 
336
        static volatile gsize prolooks_button_type_type_id__volatile = 0;
 
337
        if (g_once_init_enter (&prolooks_button_type_type_id__volatile)) {
 
338
                static const GEnumValue values[] = {{PROLOOKS_BUTTON_TYPE_PRESS_BUTTON, "PROLOOKS_BUTTON_TYPE_PRESS_BUTTON", "press-button"}, {PROLOOKS_BUTTON_TYPE_TOGGLE_BUTTON, "PROLOOKS_BUTTON_TYPE_TOGGLE_BUTTON", "toggle-button"}, {0, NULL, NULL}};
 
339
                GType prolooks_button_type_type_id;
 
340
                prolooks_button_type_type_id = g_enum_register_static ("ProlooksButtonType", values);
 
341
                g_once_init_leave (&prolooks_button_type_type_id__volatile, prolooks_button_type_type_id);
 
342
        }
 
343
        return prolooks_button_type_type_id__volatile;
 
344
}
 
345
 
 
346
 
 
347
void prolooks_set_line_width_from_device (cairo_t* cr) {
 
348
        double ux;
 
349
        double uy;
 
350
        g_return_if_fail (cr != NULL);
 
351
        ux = (double) 1;
 
352
        uy = (double) 1;
 
353
        cairo_device_to_user (cr, &ux, &uy);
 
354
        if (ux < uy) {
 
355
                ux = uy;
 
356
        }
 
357
        cairo_set_line_width (cr, ux);
 
358
}
 
359
 
 
360
 
 
361
void prolooks_color_from_string (const char* webcolor, GdkColor* result) {
 
362
        GdkColor color = {0,0,0,0};
 
363
        g_return_if_fail (webcolor != NULL);
 
364
        gdk_color_parse (webcolor, &color);
 
365
        *result = color;
 
366
        return;
 
367
}
 
368
 
 
369
 
 
370
char* prolooks_color_to_string (const GdkColor* color) {
 
371
        char* result = NULL;
 
372
        guint16 scale;
 
373
        scale = G_MAXUINT16 / G_MAXUINT8;
 
374
        result = g_strdup_printf ("#%02x%02x%02x", (guint) ((*color).red / scale), (guint) ((*color).green / scale), (guint) ((*color).blue / scale));
 
375
        return result;
 
376
}
 
377
 
 
378
 
 
379
CairoColor* prolooks_cairo_color_from_string (const char* webcolor) {
 
380
        CairoColor* result = NULL;
 
381
        GdkColor _tmp1_;
 
382
        GdkColor _tmp0_ = {0,0,0,0};
 
383
        g_return_val_if_fail (webcolor != NULL, NULL);
 
384
        result = prolooks_gdk_color_to_cairo ((_tmp1_ = (prolooks_color_from_string (webcolor, &_tmp0_), _tmp0_), &_tmp1_));
 
385
        return result;
 
386
}
 
387
 
 
388
 
 
389
void prolooks_set_source_color (cairo_t* cr, const GdkColor* color, double alpha) {
 
390
        g_return_if_fail (cr != NULL);
 
391
        cairo_set_source_rgba (cr, ((double) (*color).red) / ((double) G_MAXUINT16), ((double) (*color).green) / ((double) G_MAXUINT16), ((double) (*color).blue) / ((double) G_MAXUINT16), alpha);
 
392
}
 
393
 
 
394
 
 
395
void prolooks_gdk_color_to_cairo_color (const GdkColor* color, double* red, double* green, double* blue) {
 
396
        *red = ((double) (*color).red) / ((double) G_MAXUINT16);
 
397
        *green = ((double) (*color).green) / ((double) G_MAXUINT16);
 
398
        *blue = ((double) (*color).blue) / ((double) G_MAXUINT16);
 
399
}
 
400
 
 
401
 
 
402
CairoColor* prolooks_gdk_color_to_cairo (const GdkColor* color) {
 
403
        CairoColor* result = NULL;
 
404
        double r;
 
405
        double g;
 
406
        double b;
 
407
        r = (double) 0;
 
408
        g = (double) 0;
 
409
        b = (double) 0;
 
410
        prolooks_gdk_color_to_cairo_color (color, &r, &g, &b);
 
411
        result = cairo_color_new (r, g, b, 1.0);
 
412
        return result;
 
413
}
 
414
 
 
415
 
 
416
void prolooks_cairo_color_to_gdk (CairoColor* cairo_color, GdkColor* result) {
 
417
        GdkColor color = {0,0,0,0};
 
418
        g_return_if_fail (cairo_color != NULL);
 
419
        memset (&color, 0, sizeof (GdkColor));
 
420
        color.red = (guint16) (cairo_color_get_red (cairo_color) * ((double) G_MAXUINT16));
 
421
        color.green = (guint16) (cairo_color_get_green (cairo_color) * ((double) G_MAXUINT16));
 
422
        color.blue = (guint16) (cairo_color_get_blue (cairo_color) * ((double) G_MAXUINT16));
 
423
        *result = color;
 
424
        return;
 
425
}
 
426
 
 
427
 
 
428
void prolooks_set_source_color_string (cairo_t* cr, const char* color, double alpha) {
 
429
        GdkColor _tmp1_;
 
430
        GdkColor _tmp0_ = {0,0,0,0};
 
431
        g_return_if_fail (cr != NULL);
 
432
        g_return_if_fail (color != NULL);
 
433
        prolooks_set_source_color (cr, (_tmp1_ = (prolooks_color_from_string (color, &_tmp0_), _tmp0_), &_tmp1_), alpha);
 
434
}
 
435
 
 
436
 
 
437
void prolooks_add_color_stop (cairo_pattern_t* p, double offset, const GdkColor* color, double alpha) {
 
438
        g_return_if_fail (p != NULL);
 
439
        cairo_pattern_add_color_stop_rgba (p, offset, ((double) (*color).red) / ((double) G_MAXUINT16), ((double) (*color).green) / ((double) G_MAXUINT16), ((double) (*color).blue) / ((double) G_MAXUINT16), alpha);
 
440
}
 
441
 
 
442
 
 
443
void prolooks_add_color_stop_str (cairo_pattern_t* p, double offset, const char* color, double alpha) {
 
444
        GdkColor _tmp1_;
 
445
        GdkColor _tmp0_ = {0,0,0,0};
 
446
        g_return_if_fail (p != NULL);
 
447
        g_return_if_fail (color != NULL);
 
448
        prolooks_add_color_stop (p, offset, (_tmp1_ = (prolooks_color_from_string (color, &_tmp0_), _tmp0_), &_tmp1_), alpha);
 
449
}
 
450
 
 
451
 
 
452
cairo_pattern_t* prolooks_create_gradient (double x1, double y1, double x2, double y2, const GdkColor* start, const GdkColor* stop, double alpha_start, double alpha_stop) {
 
453
        cairo_pattern_t* result = NULL;
 
454
        cairo_pattern_t* gradient;
 
455
        gradient = cairo_pattern_create_linear (x1, y1, x2, y2);
 
456
        prolooks_add_color_stop (gradient, (double) 0, start, alpha_start);
 
457
        prolooks_add_color_stop (gradient, (double) 1, stop, alpha_stop);
 
458
        result = gradient;
 
459
        return result;
 
460
}
 
461
 
 
462
 
 
463
cairo_pattern_t* prolooks_create_gradient_str (double x1, double y1, double x2, double y2, const char* start, const char* stop, double alpha_start, double alpha_stop) {
 
464
        cairo_pattern_t* result = NULL;
 
465
        GdkColor _tmp3_;
 
466
        GdkColor _tmp2_;
 
467
        GdkColor _tmp1_ = {0,0,0,0};
 
468
        GdkColor _tmp0_ = {0,0,0,0};
 
469
        g_return_val_if_fail (start != NULL, NULL);
 
470
        g_return_val_if_fail (stop != NULL, NULL);
 
471
        result = prolooks_create_gradient (x1, y1, x2, y2, (_tmp2_ = (prolooks_color_from_string (start, &_tmp0_), _tmp0_), &_tmp2_), (_tmp3_ = (prolooks_color_from_string (stop, &_tmp1_), _tmp1_), &_tmp3_), alpha_start, alpha_stop);
 
472
        return result;
 
473
}
 
474
 
 
475
 
 
476
void prolooks_rounded_rect (cairo_t* cr, double x, double y, double w, double h, double radius_x, double radius_y) {
 
477
        double ARC_TO_BEZIER;
 
478
        double c1;
 
479
        double c2;
 
480
        g_return_if_fail (cr != NULL);
 
481
        ARC_TO_BEZIER = 0.55228475;
 
482
        if (radius_x > (w - radius_x)) {
 
483
                radius_x = w / 2;
 
484
        }
 
485
        if (radius_y > (h - radius_y)) {
 
486
                radius_y = h / 2;
 
487
        }
 
488
        c1 = ARC_TO_BEZIER * radius_x;
 
489
        c2 = ARC_TO_BEZIER * radius_y;
 
490
        cairo_new_path (cr);
 
491
        cairo_move_to (cr, x + radius_x, y);
 
492
        cairo_rel_line_to (cr, w - (2 * radius_x), 0.0);
 
493
        cairo_rel_curve_to (cr, c1, 0.0, radius_x, c2, radius_x, radius_y);
 
494
        cairo_rel_line_to (cr, (double) 0, h - (2 * radius_y));
 
495
        cairo_rel_curve_to (cr, 0.0, c2, c1 - radius_x, radius_y, -radius_x, radius_y);
 
496
        cairo_rel_line_to (cr, (-w) + (2 * radius_x), (double) 0);
 
497
        cairo_rel_curve_to (cr, -c1, (double) 0, -radius_x, -c2, -radius_x, -radius_y);
 
498
        cairo_rel_line_to (cr, (double) 0, (-h) + (2 * radius_y));
 
499
        cairo_rel_curve_to (cr, 0.0, -c2, radius_x - c1, -radius_y, radius_x, -radius_y);
 
500
        cairo_close_path (cr);
 
501
}
 
502
 
 
503
 
 
504
void prolooks_background_gradient (cairo_t* cr, double w, double h) {
 
505
        GdkColor background_gradient_start = {0,0,0,0};
 
506
        GdkColor background_gradient_stop = {0,0,0,0};
 
507
        cairo_pattern_t* background_gradient;
 
508
        g_return_if_fail (cr != NULL);
 
509
        gdk_color_parse ("#bebdc2", &background_gradient_start);
 
510
        gdk_color_parse ("#b1b4b9", &background_gradient_stop);
 
511
        cairo_rectangle (cr, (double) 0, (double) 0, w, h);
 
512
        background_gradient = cairo_pattern_create_linear ((double) 0, (double) 0, (double) 0, h);
 
513
        prolooks_add_color_stop (background_gradient, (double) 0, &background_gradient_start, 1.0);
 
514
        prolooks_add_color_stop (background_gradient, (double) 1, &background_gradient_stop, 1.0);
 
515
        cairo_set_source (cr, background_gradient);
 
516
        cairo_fill (cr);
 
517
        _cairo_pattern_destroy0 (background_gradient);
 
518
}
 
519
 
 
520
 
 
521
double prolooks_modula (double number, double divisor) {
 
522
        double result = 0.0;
 
523
        result = (((gint) number) % ((gint) divisor)) + (number - ((gint) number));
 
524
        return result;
 
525
}
 
526
 
 
527
 
 
528
char* prolooks_hsl_to_string (ProlooksHSL* self) {
 
529
        char* result = NULL;
 
530
        g_return_val_if_fail (self != NULL, NULL);
 
531
        result = g_strdup_printf ("HSL (%f, %f, %f)", self->priv->_hue, self->priv->_saturation, self->priv->_lightness);
 
532
        return result;
 
533
}
 
534
 
 
535
 
 
536
CairoColor* prolooks_hsl_to_cairo_color (ProlooksHSL* self) {
 
537
        CairoColor* result = NULL;
 
538
        gint i = 0;
 
539
        double* _tmp0_;
 
540
        double* hue_shift;
 
541
        double* _tmp1_;
 
542
        double* color_shift;
 
543
        double m1 = 0.0;
 
544
        double m2 = 0.0;
 
545
        double m3 = 0.0;
 
546
        gint _tmp2_ = 0;
 
547
        CairoColor* color;
 
548
        g_return_val_if_fail (self != NULL, NULL);
 
549
        hue_shift = (_tmp0_ = g_new0 (double, 3), _tmp0_);
 
550
        color_shift = (_tmp1_ = g_new0 (double, 3), _tmp1_);
 
551
        if (self->priv->_lightness <= 0.5) {
 
552
                m2 = self->priv->_lightness * (1 + self->priv->_saturation);
 
553
        } else {
 
554
                m2 = (self->priv->_lightness + self->priv->_saturation) - (self->priv->_lightness * self->priv->_saturation);
 
555
        }
 
556
        m1 = (2 * self->priv->_lightness) - m2;
 
557
        hue_shift[0] = self->priv->_hue + 120;
 
558
        hue_shift[1] = self->priv->_hue;
 
559
        hue_shift[2] = self->priv->_hue - 120;
 
560
        color_shift[0] = color_shift[1] = color_shift[2] = self->priv->_lightness;
 
561
        if (self->priv->_saturation == 0) {
 
562
                _tmp2_ = 3;
 
563
        } else {
 
564
                _tmp2_ = 0;
 
565
        }
 
566
        i = _tmp2_;
 
567
        {
 
568
                gboolean _tmp3_;
 
569
                _tmp3_ = TRUE;
 
570
                while (TRUE) {
 
571
                        if (!_tmp3_) {
 
572
                                i++;
 
573
                        }
 
574
                        _tmp3_ = FALSE;
 
575
                        if (!(i < 3)) {
 
576
                                break;
 
577
                        }
 
578
                        m3 = hue_shift[i];
 
579
                        if (m3 > 360) {
 
580
                                m3 = prolooks_modula (m3, (double) 360);
 
581
                        } else {
 
582
                                if (m3 < 0) {
 
583
                                        m3 = 360 - prolooks_modula (fabs (m3), (double) 360);
 
584
                                }
 
585
                        }
 
586
                        if (m3 < 60) {
 
587
                                color_shift[i] = m1 + (((m2 - m1) * m3) / 60.0);
 
588
                        } else {
 
589
                                if (m3 < 180) {
 
590
                                        color_shift[i] = m2;
 
591
                                } else {
 
592
                                        if (m3 < 240) {
 
593
                                                color_shift[i] = m1 + (((m2 - m1) * (240 - m3)) / 60.0);
 
594
                                        } else {
 
595
                                                color_shift[i] = m1;
 
596
                                        }
 
597
                                }
 
598
                        }
 
599
                }
 
600
        }
 
601
        color = cairo_color_new (color_shift[0], color_shift[1], color_shift[2], 1.0);
 
602
        result = color;
 
603
        hue_shift = (g_free (hue_shift), NULL);
 
604
        color_shift = (g_free (color_shift), NULL);
 
605
        return result;
 
606
}
 
607
 
 
608
 
 
609
void prolooks_hsl_to_gdk_color (ProlooksHSL* self, GdkColor* result) {
 
610
        GdkColor _tmp1_ = {0,0,0,0};
 
611
        CairoColor* _tmp0_;
 
612
        GdkColor _tmp2_;
 
613
        g_return_if_fail (self != NULL);
 
614
        *result = (_tmp2_ = (prolooks_cairo_color_to_gdk (_tmp0_ = prolooks_hsl_to_cairo_color (self), &_tmp1_), _tmp1_), _cairo_color_unref0 (_tmp0_), _tmp2_);
 
615
        return;
 
616
}
 
617
 
 
618
 
 
619
void prolooks_hsl_from_gdk_color (ProlooksHSL* self, const GdkColor* color) {
 
620
        CairoColor* _tmp0_;
 
621
        g_return_if_fail (self != NULL);
 
622
        prolooks_hsl_from_cairo_color (self, _tmp0_ = prolooks_gdk_color_to_cairo (color));
 
623
        _cairo_color_unref0 (_tmp0_);
 
624
}
 
625
 
 
626
 
 
627
void prolooks_hsl_from_cairo_color (ProlooksHSL* self, CairoColor* color) {
 
628
        double min = 0.0;
 
629
        double max = 0.0;
 
630
        double delta = 0.0;
 
631
        double red;
 
632
        double green;
 
633
        double blue;
 
634
        g_return_if_fail (self != NULL);
 
635
        g_return_if_fail (color != NULL);
 
636
        red = cairo_color_get_red (color);
 
637
        green = cairo_color_get_green (color);
 
638
        blue = cairo_color_get_blue (color);
 
639
        if (red > green) {
 
640
                if (red > blue) {
 
641
                        max = red;
 
642
                } else {
 
643
                        max = blue;
 
644
                }
 
645
                if (green < blue) {
 
646
                        min = green;
 
647
                } else {
 
648
                        min = blue;
 
649
                }
 
650
        } else {
 
651
                if (green > blue) {
 
652
                        max = green;
 
653
                } else {
 
654
                        max = blue;
 
655
                }
 
656
                if (red < blue) {
 
657
                        min = red;
 
658
                } else {
 
659
                        min = blue;
 
660
                }
 
661
        }
 
662
        prolooks_hsl_set_lightness (self, (max + min) / 2.0);
 
663
        if (fabs (max - min) < 0.0001) {
 
664
                prolooks_hsl_set_hue (self, 0.0);
 
665
                prolooks_hsl_set_saturation (self, 0.0);
 
666
        } else {
 
667
                if (self->priv->_lightness <= 0.5) {
 
668
                        prolooks_hsl_set_saturation (self, (max - min) / (max + min));
 
669
                } else {
 
670
                        prolooks_hsl_set_saturation (self, (max - min) / ((2.0 - max) - min));
 
671
                }
 
672
                delta = max - min;
 
673
                if (red == max) {
 
674
                        prolooks_hsl_set_hue (self, (green - blue) / delta);
 
675
                } else {
 
676
                        if (green == max) {
 
677
                                prolooks_hsl_set_hue (self, 2.0 + ((blue - red) / delta));
 
678
                        } else {
 
679
                                if (blue == max) {
 
680
                                        prolooks_hsl_set_hue (self, 4.0 + ((red - green) / delta));
 
681
                                }
 
682
                        }
 
683
                }
 
684
                prolooks_hsl_set_hue (self, self->priv->_hue * 60.0);
 
685
                if (self->priv->_hue < 0.0) {
 
686
                        prolooks_hsl_set_hue (self, self->priv->_hue + 360.0);
 
687
                }
 
688
        }
 
689
}
 
690
 
 
691
 
 
692
ProlooksHSL* prolooks_hsl_construct (GType object_type) {
 
693
        ProlooksHSL* self;
 
694
        self = (ProlooksHSL*) g_type_create_instance (object_type);
 
695
        return self;
 
696
}
 
697
 
 
698
 
 
699
ProlooksHSL* prolooks_hsl_new (void) {
 
700
        return prolooks_hsl_construct (PROLOOKS_TYPE_HSL);
 
701
}
 
702
 
 
703
 
 
704
double prolooks_hsl_get_hue (ProlooksHSL* self) {
 
705
        double result;
 
706
        g_return_val_if_fail (self != NULL, 0.0);
 
707
        result = self->priv->_hue;
 
708
        return result;
 
709
}
 
710
 
 
711
 
 
712
void prolooks_hsl_set_hue (ProlooksHSL* self, double value) {
 
713
        g_return_if_fail (self != NULL);
 
714
        self->priv->_hue = value;
 
715
}
 
716
 
 
717
 
 
718
double prolooks_hsl_get_saturation (ProlooksHSL* self) {
 
719
        double result;
 
720
        g_return_val_if_fail (self != NULL, 0.0);
 
721
        result = self->priv->_saturation;
 
722
        return result;
 
723
}
 
724
 
 
725
 
 
726
void prolooks_hsl_set_saturation (ProlooksHSL* self, double value) {
 
727
        g_return_if_fail (self != NULL);
 
728
        self->priv->_saturation = value;
 
729
}
 
730
 
 
731
 
 
732
double prolooks_hsl_get_lightness (ProlooksHSL* self) {
 
733
        double result;
 
734
        g_return_val_if_fail (self != NULL, 0.0);
 
735
        result = self->priv->_lightness;
 
736
        return result;
 
737
}
 
738
 
 
739
 
 
740
void prolooks_hsl_set_lightness (ProlooksHSL* self, double value) {
 
741
        g_return_if_fail (self != NULL);
 
742
        self->priv->_lightness = value;
 
743
}
 
744
 
 
745
 
 
746
static void prolooks_value_hsl_init (GValue* value) {
 
747
        value->data[0].v_pointer = NULL;
 
748
}
 
749
 
 
750
 
 
751
static void prolooks_value_hsl_free_value (GValue* value) {
 
752
        if (value->data[0].v_pointer) {
 
753
                prolooks_hsl_unref (value->data[0].v_pointer);
 
754
        }
 
755
}
 
756
 
 
757
 
 
758
static void prolooks_value_hsl_copy_value (const GValue* src_value, GValue* dest_value) {
 
759
        if (src_value->data[0].v_pointer) {
 
760
                dest_value->data[0].v_pointer = prolooks_hsl_ref (src_value->data[0].v_pointer);
 
761
        } else {
 
762
                dest_value->data[0].v_pointer = NULL;
 
763
        }
 
764
}
 
765
 
 
766
 
 
767
static gpointer prolooks_value_hsl_peek_pointer (const GValue* value) {
 
768
        return value->data[0].v_pointer;
 
769
}
 
770
 
 
771
 
 
772
static gchar* prolooks_value_hsl_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 
773
        (void) n_collect_values;
 
774
        (void) collect_flags;
 
775
        if (collect_values[0].v_pointer) {
 
776
                ProlooksHSL* object;
 
777
                object = collect_values[0].v_pointer;
 
778
                if (object->parent_instance.g_class == NULL) {
 
779
                        return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 
780
                } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
 
781
                        return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 
782
                }
 
783
                value->data[0].v_pointer = prolooks_hsl_ref (object);
 
784
        } else {
 
785
                value->data[0].v_pointer = NULL;
 
786
        }
 
787
        return NULL;
 
788
}
 
789
 
 
790
 
 
791
static gchar* prolooks_value_hsl_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 
792
        ProlooksHSL** object_p;
 
793
        (void) n_collect_values;
 
794
        object_p = collect_values[0].v_pointer;
 
795
        if (!object_p) {
 
796
                return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME ((GValue*)value));
 
797
        }
 
798
        if (!value->data[0].v_pointer) {
 
799
                *object_p = NULL;
 
800
        } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
 
801
                *object_p = value->data[0].v_pointer;
 
802
        } else {
 
803
                *object_p = prolooks_hsl_ref (value->data[0].v_pointer);
 
804
        }
 
805
        return NULL;
 
806
}
 
807
 
 
808
 
 
809
GParamSpec* prolooks_param_spec_hsl (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
 
810
        ProlooksParamSpecHSL* spec;
 
811
        g_return_val_if_fail (g_type_is_a (object_type, PROLOOKS_TYPE_HSL), NULL);
 
812
        spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
 
813
        G_PARAM_SPEC (spec)->value_type = object_type;
 
814
        return G_PARAM_SPEC (spec);
 
815
}
 
816
 
 
817
 
 
818
gpointer prolooks_value_get_hsl (const GValue* value) {
 
819
        g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE ((GValue*)value, PROLOOKS_TYPE_HSL), NULL);
 
820
        return value->data[0].v_pointer;
 
821
}
 
822
 
 
823
 
 
824
void prolooks_value_set_hsl (GValue* value, gpointer v_object) {
 
825
        ProlooksHSL* old;
 
826
        g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSL));
 
827
        old = value->data[0].v_pointer;
 
828
        if (v_object) {
 
829
                g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, PROLOOKS_TYPE_HSL));
 
830
                g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 
831
                value->data[0].v_pointer = v_object;
 
832
                prolooks_hsl_ref (value->data[0].v_pointer);
 
833
        } else {
 
834
                value->data[0].v_pointer = NULL;
 
835
        }
 
836
        if (old) {
 
837
                prolooks_hsl_unref (old);
 
838
        }
 
839
}
 
840
 
 
841
 
 
842
void prolooks_value_take_hsl (GValue* value, gpointer v_object) {
 
843
        ProlooksHSL* old;
 
844
        g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSL));
 
845
        old = value->data[0].v_pointer;
 
846
        if (v_object) {
 
847
                g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, PROLOOKS_TYPE_HSL));
 
848
                g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 
849
                value->data[0].v_pointer = v_object;
 
850
        } else {
 
851
                value->data[0].v_pointer = NULL;
 
852
        }
 
853
        if (old) {
 
854
                prolooks_hsl_unref (old);
 
855
        }
 
856
}
 
857
 
 
858
static void prolooks_hsl_finalize (ProlooksHSL* obj) {
 
859
        ProlooksHSL * self;
 
860
        self = PROLOOKS_HSL (obj);
 
861
}
 
862
 
 
863
static void prolooks_hsl_class_init (ProlooksHSLClass * klass) {
 
864
        prolooks_hsl_parent_class = g_type_class_peek_parent (klass);
 
865
        PROLOOKS_HSL_CLASS (klass)->finalize = prolooks_hsl_finalize;
 
866
        g_type_class_add_private (klass, sizeof (ProlooksHSLPrivate));
 
867
}
 
868
 
 
869
 
 
870
static void prolooks_hsl_instance_init (ProlooksHSL * self) {
 
871
        self->priv = PROLOOKS_HSL_GET_PRIVATE (self);
 
872
        self->ref_count = 1;
 
873
}
 
874
 
 
875
 
 
876
 
 
877
GType prolooks_hsl_get_type (void) {
 
878
        static volatile gsize prolooks_hsl_type_id__volatile = 0;
 
879
        if (g_once_init_enter (&prolooks_hsl_type_id__volatile)) {
 
880
                static const GTypeValueTable g_define_type_value_table = { prolooks_value_hsl_init, prolooks_value_hsl_free_value, prolooks_value_hsl_copy_value, prolooks_value_hsl_peek_pointer, "p", prolooks_value_hsl_collect_value, "p", prolooks_value_hsl_lcopy_value };
 
881
                static const GTypeInfo g_define_type_info = { sizeof (ProlooksHSLClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) prolooks_hsl_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProlooksHSL), 0, (GInstanceInitFunc) prolooks_hsl_instance_init, &g_define_type_value_table };
 
882
                static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
 
883
                GType prolooks_hsl_type_id;
 
884
                prolooks_hsl_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ProlooksHSL", &g_define_type_info, &g_define_type_fundamental_info, 0);
 
885
                g_once_init_leave (&prolooks_hsl_type_id__volatile, prolooks_hsl_type_id);
 
886
        }
 
887
        return prolooks_hsl_type_id__volatile;
 
888
}
 
889
 
 
890
 
 
891
gpointer prolooks_hsl_ref (gpointer instance) {
 
892
        ProlooksHSL* self;
 
893
        self = instance;
 
894
        g_atomic_int_inc (&self->ref_count);
 
895
        return instance;
 
896
}
 
897
 
 
898
 
 
899
void prolooks_hsl_unref (gpointer instance) {
 
900
        ProlooksHSL* self;
 
901
        self = instance;
 
902
        if (g_atomic_int_dec_and_test (&self->ref_count)) {
 
903
                PROLOOKS_HSL_GET_CLASS (self)->finalize (self);
 
904
                g_type_free_instance ((GTypeInstance *) self);
 
905
        }
 
906
}
 
907
 
 
908
 
 
909
char* prolooks_hsv_to_string (ProlooksHSV* self) {
 
910
        char* result = NULL;
 
911
        g_return_val_if_fail (self != NULL, NULL);
 
912
        result = g_strdup_printf ("HSV (%f, %f, %f)", self->priv->_hue, self->priv->_saturation, self->priv->_value);
 
913
        return result;
 
914
}
 
915
 
 
916
 
 
917
ProlooksHSV* prolooks_hsv_construct_for_gdk_color (GType object_type, const GdkColor* color) {
 
918
        ProlooksHSV* self;
 
919
        self = (ProlooksHSV*) g_type_create_instance (object_type);
 
920
        prolooks_hsv_from_gdk_color (self, color);
 
921
        return self;
 
922
}
 
923
 
 
924
 
 
925
ProlooksHSV* prolooks_hsv_new_for_gdk_color (const GdkColor* color) {
 
926
        return prolooks_hsv_construct_for_gdk_color (PROLOOKS_TYPE_HSV, color);
 
927
}
 
928
 
 
929
 
 
930
ProlooksHSV* prolooks_hsv_construct_for_cairo_color (GType object_type, CairoColor* color) {
 
931
        ProlooksHSV* self;
 
932
        g_return_val_if_fail (color != NULL, NULL);
 
933
        self = (ProlooksHSV*) g_type_create_instance (object_type);
 
934
        prolooks_hsv_from_cairo_color (self, color);
 
935
        return self;
 
936
}
 
937
 
 
938
 
 
939
ProlooksHSV* prolooks_hsv_new_for_cairo_color (CairoColor* color) {
 
940
        return prolooks_hsv_construct_for_cairo_color (PROLOOKS_TYPE_HSV, color);
 
941
}
 
942
 
 
943
 
 
944
CairoColor* prolooks_hsv_to_cairo_color (ProlooksHSV* self) {
 
945
        CairoColor* result = NULL;
 
946
        double r;
 
947
        double g;
 
948
        double b;
 
949
        gint hi = 0;
 
950
        double f = 0.0;
 
951
        double p = 0.0;
 
952
        double q = 0.0;
 
953
        double t = 0.0;
 
954
        CairoColor* color;
 
955
        g_return_val_if_fail (self != NULL, NULL);
 
956
        r = 0.0;
 
957
        g = 0.0;
 
958
        b = 0.0;
 
959
        hi = (gint) prolooks_modula (floor (self->priv->_hue / 60.0), (double) 6);
 
960
        f = (self->priv->_hue / 60.0) - floor (self->priv->_hue / 60.0);
 
961
        p = self->priv->_value * (1.0 - self->priv->_saturation);
 
962
        q = self->priv->_value * (1.0 - (f * self->priv->_saturation));
 
963
        t = self->priv->_value * (1.0 - ((1.0 - f) * self->priv->_saturation));
 
964
        switch (hi) {
 
965
                case 0:
 
966
                {
 
967
                        r = self->priv->_value;
 
968
                        g = t;
 
969
                        b = p;
 
970
                        break;
 
971
                }
 
972
                case 1:
 
973
                {
 
974
                        r = q;
 
975
                        g = self->priv->_value;
 
976
                        b = p;
 
977
                        break;
 
978
                }
 
979
                case 2:
 
980
                {
 
981
                        r = p;
 
982
                        g = self->priv->_value;
 
983
                        b = t;
 
984
                        break;
 
985
                }
 
986
                case 3:
 
987
                {
 
988
                        r = p;
 
989
                        g = q;
 
990
                        b = self->priv->_value;
 
991
                        break;
 
992
                }
 
993
                case 4:
 
994
                {
 
995
                        r = t;
 
996
                        g = p;
 
997
                        b = self->priv->_value;
 
998
                        break;
 
999
                }
 
1000
                case 5:
 
1001
                {
 
1002
                        r = self->priv->_value;
 
1003
                        g = p;
 
1004
                        b = q;
 
1005
                        break;
 
1006
                }
 
1007
                default:
 
1008
                {
 
1009
                        break;
 
1010
                }
 
1011
        }
 
1012
        color = cairo_color_new (r, g, b, 1.0);
 
1013
        result = color;
 
1014
        return result;
 
1015
}
 
1016
 
 
1017
 
 
1018
void prolooks_hsv_to_gdk_color (ProlooksHSV* self, GdkColor* result) {
 
1019
        GdkColor _tmp1_ = {0,0,0,0};
 
1020
        CairoColor* _tmp0_;
 
1021
        GdkColor _tmp2_;
 
1022
        g_return_if_fail (self != NULL);
 
1023
        *result = (_tmp2_ = (prolooks_cairo_color_to_gdk (_tmp0_ = prolooks_hsv_to_cairo_color (self), &_tmp1_), _tmp1_), _cairo_color_unref0 (_tmp0_), _tmp2_);
 
1024
        return;
 
1025
}
 
1026
 
 
1027
 
 
1028
void prolooks_hsv_from_gdk_color (ProlooksHSV* self, const GdkColor* color) {
 
1029
        CairoColor* _tmp0_;
 
1030
        g_return_if_fail (self != NULL);
 
1031
        prolooks_hsv_from_cairo_color (self, _tmp0_ = prolooks_gdk_color_to_cairo (color));
 
1032
        _cairo_color_unref0 (_tmp0_);
 
1033
}
 
1034
 
 
1035
 
 
1036
void prolooks_hsv_from_cairo_color (ProlooksHSV* self, CairoColor* color) {
 
1037
        double min = 0.0;
 
1038
        double max = 0.0;
 
1039
        double delta = 0.0;
 
1040
        double red;
 
1041
        double green;
 
1042
        double blue;
 
1043
        g_return_if_fail (self != NULL);
 
1044
        g_return_if_fail (color != NULL);
 
1045
        red = cairo_color_get_red (color);
 
1046
        green = cairo_color_get_green (color);
 
1047
        blue = cairo_color_get_blue (color);
 
1048
        if (red > green) {
 
1049
                if (red > blue) {
 
1050
                        max = red;
 
1051
                } else {
 
1052
                        max = blue;
 
1053
                }
 
1054
                if (green < blue) {
 
1055
                        min = green;
 
1056
                } else {
 
1057
                        min = blue;
 
1058
                }
 
1059
        } else {
 
1060
                if (green > blue) {
 
1061
                        max = green;
 
1062
                } else {
 
1063
                        max = blue;
 
1064
                }
 
1065
                if (red < blue) {
 
1066
                        min = red;
 
1067
                } else {
 
1068
                        min = blue;
 
1069
                }
 
1070
        }
 
1071
        prolooks_hsv_set_value (self, max);
 
1072
        if (fabs (max - min) < 0.0001) {
 
1073
                prolooks_hsv_set_hue (self, 0.0);
 
1074
                prolooks_hsv_set_saturation (self, 0.0);
 
1075
        } else {
 
1076
                if (max < 0.0001) {
 
1077
                        prolooks_hsv_set_saturation (self, (double) 0);
 
1078
                } else {
 
1079
                        prolooks_hsv_set_saturation (self, (max - min) / max);
 
1080
                }
 
1081
                delta = max - min;
 
1082
                if (red == max) {
 
1083
                        prolooks_hsv_set_hue (self, (green - blue) / delta);
 
1084
                } else {
 
1085
                        if (green == max) {
 
1086
                                prolooks_hsv_set_hue (self, 2.0 + ((blue - red) / delta));
 
1087
                        } else {
 
1088
                                if (blue == max) {
 
1089
                                        prolooks_hsv_set_hue (self, 4.0 + ((red - green) / delta));
 
1090
                                }
 
1091
                        }
 
1092
                }
 
1093
                prolooks_hsv_set_hue (self, self->priv->_hue * 60.0);
 
1094
                if (self->priv->_hue < 0.0) {
 
1095
                        prolooks_hsv_set_hue (self, self->priv->_hue + 360.0);
 
1096
                }
 
1097
        }
 
1098
}
 
1099
 
 
1100
 
 
1101
ProlooksHSV* prolooks_hsv_construct (GType object_type) {
 
1102
        ProlooksHSV* self;
 
1103
        self = (ProlooksHSV*) g_type_create_instance (object_type);
 
1104
        return self;
 
1105
}
 
1106
 
 
1107
 
 
1108
ProlooksHSV* prolooks_hsv_new (void) {
 
1109
        return prolooks_hsv_construct (PROLOOKS_TYPE_HSV);
 
1110
}
 
1111
 
 
1112
 
 
1113
double prolooks_hsv_get_hue (ProlooksHSV* self) {
 
1114
        double result;
 
1115
        g_return_val_if_fail (self != NULL, 0.0);
 
1116
        result = self->priv->_hue;
 
1117
        return result;
 
1118
}
 
1119
 
 
1120
 
 
1121
void prolooks_hsv_set_hue (ProlooksHSV* self, double value) {
 
1122
        g_return_if_fail (self != NULL);
 
1123
        self->priv->_hue = value;
 
1124
}
 
1125
 
 
1126
 
 
1127
double prolooks_hsv_get_saturation (ProlooksHSV* self) {
 
1128
        double result;
 
1129
        g_return_val_if_fail (self != NULL, 0.0);
 
1130
        result = self->priv->_saturation;
 
1131
        return result;
 
1132
}
 
1133
 
 
1134
 
 
1135
void prolooks_hsv_set_saturation (ProlooksHSV* self, double value) {
 
1136
        g_return_if_fail (self != NULL);
 
1137
        self->priv->_saturation = value;
 
1138
}
 
1139
 
 
1140
 
 
1141
double prolooks_hsv_get_value (ProlooksHSV* self) {
 
1142
        double result;
 
1143
        g_return_val_if_fail (self != NULL, 0.0);
 
1144
        result = self->priv->_value;
 
1145
        return result;
 
1146
}
 
1147
 
 
1148
 
 
1149
void prolooks_hsv_set_value (ProlooksHSV* self, double value) {
 
1150
        g_return_if_fail (self != NULL);
 
1151
        self->priv->_value = value;
 
1152
}
 
1153
 
 
1154
 
 
1155
static void prolooks_value_hsv_init (GValue* value) {
 
1156
        value->data[0].v_pointer = NULL;
 
1157
}
 
1158
 
 
1159
 
 
1160
static void prolooks_value_hsv_free_value (GValue* value) {
 
1161
        if (value->data[0].v_pointer) {
 
1162
                prolooks_hsv_unref (value->data[0].v_pointer);
 
1163
        }
 
1164
}
 
1165
 
 
1166
 
 
1167
static void prolooks_value_hsv_copy_value (const GValue* src_value, GValue* dest_value) {
 
1168
        if (src_value->data[0].v_pointer) {
 
1169
                dest_value->data[0].v_pointer = prolooks_hsv_ref (src_value->data[0].v_pointer);
 
1170
        } else {
 
1171
                dest_value->data[0].v_pointer = NULL;
 
1172
        }
 
1173
}
 
1174
 
 
1175
 
 
1176
static gpointer prolooks_value_hsv_peek_pointer (const GValue* value) {
 
1177
        return value->data[0].v_pointer;
 
1178
}
 
1179
 
 
1180
 
 
1181
static gchar* prolooks_value_hsv_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 
1182
        (void) collect_flags;
 
1183
        (void) n_collect_values;
 
1184
        if (collect_values[0].v_pointer) {
 
1185
                ProlooksHSV* object;
 
1186
                object = collect_values[0].v_pointer;
 
1187
                if (object->parent_instance.g_class == NULL) {
 
1188
                        return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 
1189
                } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
 
1190
                        return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 
1191
                }
 
1192
                value->data[0].v_pointer = prolooks_hsv_ref (object);
 
1193
        } else {
 
1194
                value->data[0].v_pointer = NULL;
 
1195
        }
 
1196
        return NULL;
 
1197
}
 
1198
 
 
1199
 
 
1200
static gchar* prolooks_value_hsv_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 
1201
        ProlooksHSV** object_p;
 
1202
        (void) n_collect_values;
 
1203
        object_p = collect_values[0].v_pointer;
 
1204
        if (!object_p) {
 
1205
                return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME ((GValue*)value));
 
1206
        }
 
1207
        if (!value->data[0].v_pointer) {
 
1208
                *object_p = NULL;
 
1209
        } else if (collect_flags & G_VALUE_NOCOPY_CONTENTS) {
 
1210
                *object_p = value->data[0].v_pointer;
 
1211
        } else {
 
1212
                *object_p = prolooks_hsv_ref (value->data[0].v_pointer);
 
1213
        }
 
1214
        return NULL;
 
1215
}
 
1216
 
 
1217
 
 
1218
GParamSpec* prolooks_param_spec_hsv (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
 
1219
        ProlooksParamSpecHSV* spec;
 
1220
        g_return_val_if_fail (g_type_is_a (object_type, PROLOOKS_TYPE_HSV), NULL);
 
1221
        spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
 
1222
        G_PARAM_SPEC (spec)->value_type = object_type;
 
1223
        return G_PARAM_SPEC (spec);
 
1224
}
 
1225
 
 
1226
 
 
1227
gpointer prolooks_value_get_hsv (const GValue* value) {
 
1228
        g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE ((GValue*) value, PROLOOKS_TYPE_HSV), NULL);
 
1229
        return value->data[0].v_pointer;
 
1230
}
 
1231
 
 
1232
 
 
1233
void prolooks_value_set_hsv (GValue* value, gpointer v_object) {
 
1234
        ProlooksHSV* old;
 
1235
        g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSV));
 
1236
        old = value->data[0].v_pointer;
 
1237
        if (v_object) {
 
1238
                g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, PROLOOKS_TYPE_HSV));
 
1239
                g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 
1240
                value->data[0].v_pointer = v_object;
 
1241
                prolooks_hsv_ref (value->data[0].v_pointer);
 
1242
        } else {
 
1243
                value->data[0].v_pointer = NULL;
 
1244
        }
 
1245
        if (old) {
 
1246
                prolooks_hsv_unref (old);
 
1247
        }
 
1248
}
 
1249
 
 
1250
 
 
1251
void prolooks_value_take_hsv (GValue* value, gpointer v_object) {
 
1252
        ProlooksHSV* old;
 
1253
        g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSV));
 
1254
        old = value->data[0].v_pointer;
 
1255
        if (v_object) {
 
1256
                g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, PROLOOKS_TYPE_HSV));
 
1257
                g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 
1258
                value->data[0].v_pointer = v_object;
 
1259
        } else {
 
1260
                value->data[0].v_pointer = NULL;
 
1261
        }
 
1262
        if (old) {
 
1263
                prolooks_hsv_unref (old);
 
1264
        }
 
1265
}
 
1266
 
 
1267
static void prolooks_hsv_finalize (ProlooksHSV* obj) {
 
1268
        ProlooksHSV * self;
 
1269
        self = PROLOOKS_HSV (obj);
 
1270
}
 
1271
 
 
1272
static void prolooks_hsv_class_init (ProlooksHSVClass * klass) {
 
1273
        prolooks_hsv_parent_class = g_type_class_peek_parent (klass);
 
1274
        PROLOOKS_HSV_CLASS (klass)->finalize = prolooks_hsv_finalize;
 
1275
        g_type_class_add_private (klass, sizeof (ProlooksHSVPrivate));
 
1276
}
 
1277
 
 
1278
 
 
1279
static void prolooks_hsv_instance_init (ProlooksHSV * self) {
 
1280
        self->priv = PROLOOKS_HSV_GET_PRIVATE (self);
 
1281
        self->ref_count = 1;
 
1282
}
 
1283
 
 
1284
GType prolooks_hsv_get_type (void) {
 
1285
        static volatile gsize prolooks_hsv_type_id__volatile = 0;
 
1286
        if (g_once_init_enter (&prolooks_hsv_type_id__volatile)) {
 
1287
                static const GTypeValueTable g_define_type_value_table = { prolooks_value_hsv_init, prolooks_value_hsv_free_value, prolooks_value_hsv_copy_value, prolooks_value_hsv_peek_pointer, "p", prolooks_value_hsv_collect_value, "p", prolooks_value_hsv_lcopy_value };
 
1288
                static const GTypeInfo g_define_type_info = { sizeof (ProlooksHSVClass), (GBaseInitFunc) NULL, (GBaseFinalizeFunc) NULL, (GClassInitFunc) prolooks_hsv_class_init, (GClassFinalizeFunc) NULL, NULL, sizeof (ProlooksHSV), 0, (GInstanceInitFunc) prolooks_hsv_instance_init, &g_define_type_value_table };
 
1289
                static const GTypeFundamentalInfo g_define_type_fundamental_info = { (G_TYPE_FLAG_CLASSED | G_TYPE_FLAG_INSTANTIATABLE | G_TYPE_FLAG_DERIVABLE | G_TYPE_FLAG_DEEP_DERIVABLE) };
 
1290
                GType prolooks_hsv_type_id;
 
1291
                prolooks_hsv_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ProlooksHSV", &g_define_type_info, &g_define_type_fundamental_info, 0);
 
1292
                g_once_init_leave (&prolooks_hsv_type_id__volatile, prolooks_hsv_type_id);
 
1293
        }
 
1294
        return prolooks_hsv_type_id__volatile;
 
1295
}
 
1296
 
 
1297
 
 
1298
gpointer prolooks_hsv_ref (gpointer instance) {
 
1299
        ProlooksHSV* self;
 
1300
        self = instance;
 
1301
        g_atomic_int_inc (&self->ref_count);
 
1302
        return instance;
 
1303
}
 
1304
 
 
1305
 
 
1306
void prolooks_hsv_unref (gpointer instance) {
 
1307
        ProlooksHSV* self;
 
1308
        self = instance;
 
1309
        if (g_atomic_int_dec_and_test (&self->ref_count)) {
 
1310
                PROLOOKS_HSV_GET_CLASS (self)->finalize (self);
 
1311
                g_type_free_instance ((GTypeInstance *) self);
 
1312
        }
 
1313
}
 
1314
 
 
1315
 
 
1316
void prolooks_shade_color (const GdkColor* orig, double shade_ratio, GdkColor* result) {
 
1317
        ProlooksHSL* HSL;
 
1318
        GdkColor _tmp0_ = {0,0,0,0};
 
1319
        GdkColor _result_;
 
1320
        HSL = prolooks_hsl_new ();
 
1321
        prolooks_hsl_from_gdk_color (HSL, orig);
 
1322
        prolooks_hsl_set_lightness (HSL, fmin (prolooks_hsl_get_lightness (HSL) * shade_ratio, 1.0));
 
1323
        prolooks_hsl_set_lightness (HSL, fmax (prolooks_hsl_get_lightness (HSL), 0.0));
 
1324
        prolooks_hsl_set_saturation (HSL, fmin (prolooks_hsl_get_saturation (HSL) * shade_ratio, 1.0));
 
1325
        prolooks_hsl_set_saturation (HSL, fmax (prolooks_hsl_get_saturation (HSL), 0.0));
 
1326
        _result_ = (prolooks_hsl_to_gdk_color (HSL, &_tmp0_), _tmp0_);
 
1327
        *result = _result_;
 
1328
        _prolooks_hsl_unref0 (HSL);
 
1329
        return;
 
1330
}
 
1331
 
 
1332
 
 
1333
GdkPixbuf* prolooks_cairo_image_surface_to_pixbuf (cairo_surface_t* surface) {
 
1334
        GdkPixbuf* result = NULL;
 
1335
        guchar* _tmp0_;
 
1336
        guchar* knob_data;
 
1337
        g_return_val_if_fail (surface != NULL, NULL);
 
1338
        if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32) {
 
1339
                result = NULL;
 
1340
                return result;
 
1341
        }
 
1342
        knob_data = (_tmp0_ = cairo_image_surface_get_data (surface), _tmp0_);
 
1343
        {
 
1344
                gint i;
 
1345
                i = 0;
 
1346
                {
 
1347
                        gboolean _tmp1_;
 
1348
                        _tmp1_ = TRUE;
 
1349
                        while (TRUE) {
 
1350
                                guchar r;
 
1351
                                guchar g;
 
1352
                                guchar b;
 
1353
                                guchar a;
 
1354
                                if (!_tmp1_) {
 
1355
                                        i = i + 4;
 
1356
                                }
 
1357
                                _tmp1_ = FALSE;
 
1358
                                if (!(i < (cairo_image_surface_get_height (surface) * cairo_image_surface_get_stride (surface)))) {
 
1359
                                        break;
 
1360
                                }
 
1361
                                r = knob_data[i + 0];
 
1362
                                g = knob_data[i + 1];
 
1363
                                b = knob_data[i + 2];
 
1364
                                a = knob_data[i + 3];
 
1365
                                knob_data[i + 0] = b;
 
1366
                                knob_data[i + 1] = g;
 
1367
                                knob_data[i + 2] = r;
 
1368
                                knob_data[i + 3] = a;
 
1369
                        }
 
1370
                }
 
1371
        }
 
1372
        result = gdk_pixbuf_new_from_data (knob_data, GDK_COLORSPACE_RGB, TRUE, 8, cairo_image_surface_get_width (surface), cairo_image_surface_get_height (surface), cairo_image_surface_get_stride (surface), NULL, NULL);
 
1373
        return result;
 
1374
}
 
1375
 
 
1376
 
 
1377
 
 
1378