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