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         gint _hue_shift_size_;
 538         gint hue_shift_length1;
 539         double* hue_shift;
 540         double* _tmp1_;
 541         gint _color_shift_size_;
 542         gint color_shift_length1;
 543         double* color_shift;
 544         double m1 = 0.0;
 545         double m2 = 0.0;
 546         double m3 = 0.0;
 547         gint _tmp2_ = 0;
 548         CairoColor* color;
 549         g_return_val_if_fail (self != NULL, NULL);
 550         hue_shift = (_tmp0_ = g_new0 (double, 3), hue_shift_length1 = 3, _hue_shift_size_ = hue_shift_length1, _tmp0_);
 551         color_shift = (_tmp1_ = g_new0 (double, 3), color_shift_length1 = 3, _color_shift_size_ = color_shift_length1, _tmp1_);
 552         if (self->priv->_lightness <= 0.5) {
 553                 m2 = self->priv->_lightness * (1 + self->priv->_saturation);
 554         } else {
 555                 m2 = (self->priv->_lightness + self->priv->_saturation) - (self->priv->_lightness * self->priv->_saturation);
 556         }
 557         m1 = (2 * self->priv->_lightness) - m2;
 558         hue_shift[0] = self->priv->_hue + 120;
 559         hue_shift[1] = self->priv->_hue;
 560         hue_shift[2] = self->priv->_hue - 120;
 561         color_shift[0] = color_shift[1] = color_shift[2] = self->priv->_lightness;
 562         if (self->priv->_saturation == 0) {
 563                 _tmp2_ = 3;
 564         } else {
 565                 _tmp2_ = 0;
 566         }
 567         i = _tmp2_;
 568         {
 569                 gboolean _tmp3_;
 570                 _tmp3_ = TRUE;
 571                 while (TRUE) {
 572                         if (!_tmp3_) {
 573                                 i++;
 574                         }
 575                         _tmp3_ = FALSE;
 576                         if (!(i < 3)) {
 577                                 break;
 578                         }
 579                         m3 = hue_shift[i];
 580                         if (m3 > 360) {
 581                                 m3 = prolooks_modula (m3, (double) 360);
 582                         } else {
 583                                 if (m3 < 0) {
 584                                         m3 = 360 - prolooks_modula (fabs (m3), (double) 360);
 585                                 }
 586                         }
 587                         if (m3 < 60) {
 588                                 color_shift[i] = m1 + (((m2 - m1) * m3) / 60.0);
 589                         } else {
 590                                 if (m3 < 180) {
 591                                         color_shift[i] = m2;
 592                                 } else {
 593                                         if (m3 < 240) {
 594                                                 color_shift[i] = m1 + (((m2 - m1) * (240 - m3)) / 60.0);
 595                                         } else {
 596                                                 color_shift[i] = m1;
 597                                         }
 598                                 }
 599                         }
 600                 }
 601         }
 602         color = cairo_color_new (color_shift[0], color_shift[1], color_shift[2], 1.0);
 603         result = color;
 604         hue_shift = (g_free (hue_shift), NULL);
 605         color_shift = (g_free (color_shift), NULL);
 606         return result;
 607 }
 608
 609
 610 void prolooks_hsl_to_gdk_color (ProlooksHSL* self, GdkColor* result) {
 611         GdkColor _tmp1_ = {0,0,0,0};
 612         CairoColor* _tmp0_;
 613         GdkColor _tmp2_;
 614         g_return_if_fail (self != NULL);
 615         *result = (_tmp2_ = (prolooks_cairo_color_to_gdk (_tmp0_ = prolooks_hsl_to_cairo_color (self), &_tmp1_), _tmp1_), _cairo_color_unref0 (_tmp0_), _tmp2_);
 616         return;
 617 }
 618
 619
 620 void prolooks_hsl_from_gdk_color (ProlooksHSL* self, const GdkColor* color) {
 621         CairoColor* _tmp0_;
 622         g_return_if_fail (self != NULL);
 623         prolooks_hsl_from_cairo_color (self, _tmp0_ = prolooks_gdk_color_to_cairo (color));
 624         _cairo_color_unref0 (_tmp0_);
 625 }
 626
 627
 628 void prolooks_hsl_from_cairo_color (ProlooksHSL* self, CairoColor* color) {
 629         double min = 0.0;
 630         double max = 0.0;
 631         double delta = 0.0;
 632         double red;
 633         double green;
 634         double blue;
 635         g_return_if_fail (self != NULL);
 636         g_return_if_fail (color != NULL);
 637         red = cairo_color_get_red (color);
 638         green = cairo_color_get_green (color);
 639         blue = cairo_color_get_blue (color);
 640         if (red > green) {
 641                 if (red > blue) {
 642                         max = red;
 643                 } else {
 644                         max = blue;
 645                 }
 646                 if (green < blue) {
 647                         min = green;
 648                 } else {
 649                         min = blue;
 650                 }
 651         } else {
 652                 if (green > blue) {
 653                         max = green;
 654                 } else {
 655                         max = blue;
 656                 }
 657                 if (red < blue) {
 658                         min = red;
 659                 } else {
 660                         min = blue;
 661                 }
 662         }
 663         prolooks_hsl_set_lightness (self, (max + min) / 2.0);
 664         if (fabs (max - min) < 0.0001) {
 665                 prolooks_hsl_set_hue (self, 0.0);
 666                 prolooks_hsl_set_saturation (self, 0.0);
 667         } else {
 668                 if (self->priv->_lightness <= 0.5) {
 669                         prolooks_hsl_set_saturation (self, (max - min) / (max + min));
 670                 } else {
 671                         prolooks_hsl_set_saturation (self, (max - min) / ((2.0 - max) - min));
 672                 }
 673                 delta = max - min;
 674                 if (red == max) {
 675                         prolooks_hsl_set_hue (self, (green - blue) / delta);
 676                 } else {
 677                         if (green == max) {
 678                                 prolooks_hsl_set_hue (self, 2.0 + ((blue - red) / delta));
 679                         } else {
 680                                 if (blue == max) {
 681                                         prolooks_hsl_set_hue (self, 4.0 + ((red - green) / delta));
 682                                 }
 683                         }
 684                 }
 685                 prolooks_hsl_set_hue (self, self->priv->_hue * 60.0);
 686                 if (self->priv->_hue < 0.0) {
 687                         prolooks_hsl_set_hue (self, self->priv->_hue + 360.0);
 688                 }
 689         }
 690 }
 691
 692
 693 ProlooksHSL* prolooks_hsl_construct (GType object_type) {
 694         ProlooksHSL* self;
 695         self = (ProlooksHSL*) g_type_create_instance (object_type);
 696         return self;
 697 }
 698
 699
 700 ProlooksHSL* prolooks_hsl_new (void) {
 701         return prolooks_hsl_construct (PROLOOKS_TYPE_HSL);
 702 }
 703
 704
 705 double prolooks_hsl_get_hue (ProlooksHSL* self) {
 706         double result;
 707         g_return_val_if_fail (self != NULL, 0.0);
 708         result = self->priv->_hue;
 709         return result;
 710 }
 711
 712
 713 void prolooks_hsl_set_hue (ProlooksHSL* self, double value) {
 714         g_return_if_fail (self != NULL);
 715         self->priv->_hue = value;
 716 }
 717
 718
 719 double prolooks_hsl_get_saturation (ProlooksHSL* self) {
 720         double result;
 721         g_return_val_if_fail (self != NULL, 0.0);
 722         result = self->priv->_saturation;
 723         return result;
 724 }
 725
 726
 727 void prolooks_hsl_set_saturation (ProlooksHSL* self, double value) {
 728         g_return_if_fail (self != NULL);
 729         self->priv->_saturation = value;
 730 }
 731
 732
 733 double prolooks_hsl_get_lightness (ProlooksHSL* self) {
 734         double result;
 735         g_return_val_if_fail (self != NULL, 0.0);
 736         result = self->priv->_lightness;
 737         return result;
 738 }
 739
 740
 741 void prolooks_hsl_set_lightness (ProlooksHSL* self, double value) {
 742         g_return_if_fail (self != NULL);
 743         self->priv->_lightness = value;
 744 }
 745
 746
 747 static void prolooks_value_hsl_init (GValue* value) {
 748         value->data[0].v_pointer = NULL;
 749 }
 750
 751
 752 static void prolooks_value_hsl_free_value (GValue* value) {
 753         if (value->data[0].v_pointer) {
 754                 prolooks_hsl_unref (value->data[0].v_pointer);
 755         }
 756 }
 757
 758
 759 static void prolooks_value_hsl_copy_value (const GValue* src_value, GValue* dest_value) {
 760         if (src_value->data[0].v_pointer) {
 761                 dest_value->data[0].v_pointer = prolooks_hsl_ref (src_value->data[0].v_pointer);
 762         } else {
 763                 dest_value->data[0].v_pointer = NULL;
 764         }
 765 }
 766
 767
 768 static gpointer prolooks_value_hsl_peek_pointer (const GValue* value) {
 769         return value->data[0].v_pointer;
 770 }
 771
 772
 773 static gchar* prolooks_value_hsl_collect_value (GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 774         if (collect_values[0].v_pointer) {
 775                 ProlooksHSL* object;
 776                 object = collect_values[0].v_pointer;
 777                 if (object->parent_instance.g_class == NULL) {
 778                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 779                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
 780                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
 781                 }
 782                 value->data[0].v_pointer = prolooks_hsl_ref (object);
 783         } else {
 784                 value->data[0].v_pointer = NULL;
 785         }
 786         return NULL;
 787 }
 788
 789
 790 static gchar* prolooks_value_hsl_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
 791         ProlooksHSL** object_p;
 792         object_p = collect_values[0].v_pointer;
 793         if (!object_p) {
 794                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
 795         }
 796         if (!value->data[0].v_pointer) {
 797                 *object_p = NULL;
 798         } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
 799                 *object_p = value->data[0].v_pointer;
 800         } else {
 801                 *object_p = prolooks_hsl_ref (value->data[0].v_pointer);
 802         }
 803         return NULL;
 804 }
 805
 806
 807 GParamSpec* prolooks_param_spec_hsl (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
 808         ProlooksParamSpecHSL* spec;
 809         g_return_val_if_fail (g_type_is_a (object_type, PROLOOKS_TYPE_HSL), NULL);
 810         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
 811         G_PARAM_SPEC (spec)->value_type = object_type;
 812         return G_PARAM_SPEC (spec);
 813 }
 814
 815
 816 gpointer prolooks_value_get_hsl (const GValue* value) {
 817         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSL), NULL);
 818         return value->data[0].v_pointer;
 819 }
 820
 821
 822 void prolooks_value_set_hsl (GValue* value, gpointer v_object) {
 823         ProlooksHSL* old;
 824         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSL));
 825         old = value->data[0].v_pointer;
 826         if (v_object) {
 827                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, PROLOOKS_TYPE_HSL));
 828                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 829                 value->data[0].v_pointer = v_object;
 830                 prolooks_hsl_ref (value->data[0].v_pointer);
 831         } else {
 832                 value->data[0].v_pointer = NULL;
 833         }
 834         if (old) {
 835                 prolooks_hsl_unref (old);
 836         }
 837 }
 838
 839
 840 void prolooks_value_take_hsl (GValue* value, gpointer v_object) {
 841         ProlooksHSL* old;
 842         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSL));
 843         old = value->data[0].v_pointer;
 844         if (v_object) {
 845                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, PROLOOKS_TYPE_HSL));
 846                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
 847                 value->data[0].v_pointer = v_object;
 848         } else {
 849                 value->data[0].v_pointer = NULL;
 850         }
 851         if (old) {
 852                 prolooks_hsl_unref (old);
 853         }
 854 }
 855
 856 static void prolooks_hsl_finalize (ProlooksHSL* obj) {
 857         ProlooksHSL * self;
 858         self = PROLOOKS_HSL (obj);
 859 }
 860
 861 static void prolooks_hsl_class_init (ProlooksHSLClass * klass) {
 862         prolooks_hsl_parent_class = g_type_class_peek_parent (klass);
 863         PROLOOKS_HSL_CLASS (klass)->finalize = prolooks_hsl_finalize;
 864         g_type_class_add_private (klass, sizeof (ProlooksHSLPrivate));
 865 }
 866
 867
 868 static void prolooks_hsl_instance_init (ProlooksHSL * self) {
 869         self->priv = PROLOOKS_HSL_GET_PRIVATE (self);
 870         self->ref_count = 1;
 871 }
 872
 873
 874
 875 GType prolooks_hsl_get_type (void) {
 876         static volatile gsize prolooks_hsl_type_id__volatile = 0;
 877         if (g_once_init_enter (&prolooks_hsl_type_id__volatile)) {
 878                 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 };
 879                 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 };
 880                 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) };
 881                 GType prolooks_hsl_type_id;
 882                 prolooks_hsl_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ProlooksHSL", &g_define_type_info, &g_define_type_fundamental_info, 0);
 883                 g_once_init_leave (&prolooks_hsl_type_id__volatile, prolooks_hsl_type_id);
 884         }
 885         return prolooks_hsl_type_id__volatile;
 886 }
 887
 888
 889 gpointer prolooks_hsl_ref (gpointer instance) {
 890         ProlooksHSL* self;
 891         self = instance;
 892         g_atomic_int_inc (&self->ref_count);
 893         return instance;
 894 }
 895
 896
 897 void prolooks_hsl_unref (gpointer instance) {
 898         ProlooksHSL* self;
 899         self = instance;
 900         if (g_atomic_int_dec_and_test (&self->ref_count)) {
 901                 PROLOOKS_HSL_GET_CLASS (self)->finalize (self);
 902                 g_type_free_instance ((GTypeInstance *) self);
 903         }
 904 }
 905
 906
 907 char* prolooks_hsv_to_string (ProlooksHSV* self) {
 908         char* result = NULL;
 909         g_return_val_if_fail (self != NULL, NULL);
 910         result = g_strdup_printf ("HSV (%f, %f, %f)", self->priv->_hue, self->priv->_saturation, self->priv->_value);
 911         return result;
 912 }
 913
 914
 915 ProlooksHSV* prolooks_hsv_construct_for_gdk_color (GType object_type, const GdkColor* color) {
 916         ProlooksHSV* self;
 917         self = (ProlooksHSV*) g_type_create_instance (object_type);
 918         prolooks_hsv_from_gdk_color (self, color);
 919         return self;
 920 }
 921
 922
 923 ProlooksHSV* prolooks_hsv_new_for_gdk_color (const GdkColor* color) {
 924         return prolooks_hsv_construct_for_gdk_color (PROLOOKS_TYPE_HSV, color);
 925 }
 926
 927
 928 ProlooksHSV* prolooks_hsv_construct_for_cairo_color (GType object_type, CairoColor* color) {
 929         ProlooksHSV* self;
 930         g_return_val_if_fail (color != NULL, NULL);
 931         self = (ProlooksHSV*) g_type_create_instance (object_type);
 932         prolooks_hsv_from_cairo_color (self, color);
 933         return self;
 934 }
 935
 936
 937 ProlooksHSV* prolooks_hsv_new_for_cairo_color (CairoColor* color) {
 938         return prolooks_hsv_construct_for_cairo_color (PROLOOKS_TYPE_HSV, color);
 939 }
 940
 941
 942 CairoColor* prolooks_hsv_to_cairo_color (ProlooksHSV* self) {
 943         CairoColor* result = NULL;
 944         double r;
 945         double g;
 946         double b;
 947         double v;
 948         gint hi = 0;
 949         double f = 0.0;
 950         double p = 0.0;
 951         double q = 0.0;
 952         double t = 0.0;
 953         CairoColor* color;
 954         g_return_val_if_fail (self != NULL, NULL);
 955         r = 0.0;
 956         g = 0.0;
 957         b = 0.0;
 958         v = self->priv->_value;
 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         if (collect_values[0].v_pointer) {
1183                 ProlooksHSV* object;
1184                 object = collect_values[0].v_pointer;
1185                 if (object->parent_instance.g_class == NULL) {
1186                         return g_strconcat ("invalid unclassed object pointer for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1187                 } else if (!g_value_type_compatible (G_TYPE_FROM_INSTANCE (object), G_VALUE_TYPE (value))) {
1188                         return g_strconcat ("invalid object type `", g_type_name (G_TYPE_FROM_INSTANCE (object)), "' for value type `", G_VALUE_TYPE_NAME (value), "'", NULL);
1189                 }
1190                 value->data[0].v_pointer = prolooks_hsv_ref (object);
1191         } else {
1192                 value->data[0].v_pointer = NULL;
1193         }
1194         return NULL;
1195 }
1196
1197
1198 static gchar* prolooks_value_hsv_lcopy_value (const GValue* value, guint n_collect_values, GTypeCValue* collect_values, guint collect_flags) {
1199         ProlooksHSV** object_p;
1200         object_p = collect_values[0].v_pointer;
1201         if (!object_p) {
1202                 return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value));
1203         }
1204         if (!value->data[0].v_pointer) {
1205                 *object_p = NULL;
1206         } else if (collect_flags && G_VALUE_NOCOPY_CONTENTS) {
1207                 *object_p = value->data[0].v_pointer;
1208         } else {
1209                 *object_p = prolooks_hsv_ref (value->data[0].v_pointer);
1210         }
1211         return NULL;
1212 }
1213
1214
1215 GParamSpec* prolooks_param_spec_hsv (const gchar* name, const gchar* nick, const gchar* blurb, GType object_type, GParamFlags flags) {
1216         ProlooksParamSpecHSV* spec;
1217         g_return_val_if_fail (g_type_is_a (object_type, PROLOOKS_TYPE_HSV), NULL);
1218         spec = g_param_spec_internal (G_TYPE_PARAM_OBJECT, name, nick, blurb, flags);
1219         G_PARAM_SPEC (spec)->value_type = object_type;
1220         return G_PARAM_SPEC (spec);
1221 }
1222
1223
1224 gpointer prolooks_value_get_hsv (const GValue* value) {
1225         g_return_val_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSV), NULL);
1226         return value->data[0].v_pointer;
1227 }
1228
1229
1230 void prolooks_value_set_hsv (GValue* value, gpointer v_object) {
1231         ProlooksHSV* old;
1232         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSV));
1233         old = value->data[0].v_pointer;
1234         if (v_object) {
1235                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, PROLOOKS_TYPE_HSV));
1236                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1237                 value->data[0].v_pointer = v_object;
1238                 prolooks_hsv_ref (value->data[0].v_pointer);
1239         } else {
1240                 value->data[0].v_pointer = NULL;
1241         }
1242         if (old) {
1243                 prolooks_hsv_unref (old);
1244         }
1245 }
1246
1247
1248 void prolooks_value_take_hsv (GValue* value, gpointer v_object) {
1249         ProlooksHSV* old;
1250         g_return_if_fail (G_TYPE_CHECK_VALUE_TYPE (value, PROLOOKS_TYPE_HSV));
1251         old = value->data[0].v_pointer;
1252         if (v_object) {
1253                 g_return_if_fail (G_TYPE_CHECK_INSTANCE_TYPE (v_object, PROLOOKS_TYPE_HSV));
1254                 g_return_if_fail (g_value_type_compatible (G_TYPE_FROM_INSTANCE (v_object), G_VALUE_TYPE (value)));
1255                 value->data[0].v_pointer = v_object;
1256         } else {
1257                 value->data[0].v_pointer = NULL;
1258         }
1259         if (old) {
1260                 prolooks_hsv_unref (old);
1261         }
1262 }
1263
1264 static void prolooks_hsv_finalize (ProlooksHSV* obj) {
1265         ProlooksHSV * self;
1266         self = PROLOOKS_HSV (obj);
1267 }
1268
1269 static void prolooks_hsv_class_init (ProlooksHSVClass * klass) {
1270         prolooks_hsv_parent_class = g_type_class_peek_parent (klass);
1271         PROLOOKS_HSV_CLASS (klass)->finalize = prolooks_hsv_finalize;
1272         g_type_class_add_private (klass, sizeof (ProlooksHSVPrivate));
1273 }
1274
1275
1276 static void prolooks_hsv_instance_init (ProlooksHSV * self) {
1277         self->priv = PROLOOKS_HSV_GET_PRIVATE (self);
1278         self->ref_count = 1;
1279 }
1280
1281 GType prolooks_hsv_get_type (void) {
1282         static volatile gsize prolooks_hsv_type_id__volatile = 0;
1283         if (g_once_init_enter (&prolooks_hsv_type_id__volatile)) {
1284                 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 };
1285                 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 };
1286                 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) };
1287                 GType prolooks_hsv_type_id;
1288                 prolooks_hsv_type_id = g_type_register_fundamental (g_type_fundamental_next (), "ProlooksHSV", &g_define_type_info, &g_define_type_fundamental_info, 0);
1289                 g_once_init_leave (&prolooks_hsv_type_id__volatile, prolooks_hsv_type_id);
1290         }
1291         return prolooks_hsv_type_id__volatile;
1292 }
1293
1294
1295 gpointer prolooks_hsv_ref (gpointer instance) {
1296         ProlooksHSV* self;
1297         self = instance;
1298         g_atomic_int_inc (&self->ref_count);
1299         return instance;
1300 }
1301
1302
1303 void prolooks_hsv_unref (gpointer instance) {
1304         ProlooksHSV* self;
1305         self = instance;
1306         if (g_atomic_int_dec_and_test (&self->ref_count)) {
1307                 PROLOOKS_HSV_GET_CLASS (self)->finalize (self);
1308                 g_type_free_instance ((GTypeInstance *) self);
1309         }
1310 }
1311
1312
1313 void prolooks_shade_color (const GdkColor* orig, double shade_ratio, GdkColor* result) {
1314         ProlooksHSL* HSL;
1315         GdkColor _tmp0_ = {0,0,0,0};
1316         GdkColor _result_;
1317         HSL = prolooks_hsl_new ();
1318         prolooks_hsl_from_gdk_color (HSL, orig);
1319         prolooks_hsl_set_lightness (HSL, fmin (prolooks_hsl_get_lightness (HSL) * shade_ratio, 1.0));
1320         prolooks_hsl_set_lightness (HSL, fmax (prolooks_hsl_get_lightness (HSL), 0.0));
1321         prolooks_hsl_set_saturation (HSL, fmin (prolooks_hsl_get_saturation (HSL) * shade_ratio, 1.0));
1322         prolooks_hsl_set_saturation (HSL, fmax (prolooks_hsl_get_saturation (HSL), 0.0));
1323         _result_ = (prolooks_hsl_to_gdk_color (HSL, &_tmp0_), _tmp0_);
1324         *result = _result_;
1325         _prolooks_hsl_unref0 (HSL);
1326         return;
1327 }
1328
1329
1330 GdkPixbuf* prolooks_cairo_image_surface_to_pixbuf (cairo_surface_t* surface) {
1331         GdkPixbuf* result = NULL;
1332         guchar* _tmp0_;
1333         gint _knob_data_size_;
1334         gint knob_data_length1;
1335         guchar* knob_data;
1336         g_return_val_if_fail (surface != NULL, NULL);
1337         if (cairo_image_surface_get_format (surface) != CAIRO_FORMAT_ARGB32) {
1338                 result = NULL;
1339                 return result;
1340         }
1341         knob_data = (_tmp0_ = cairo_image_surface_get_data (surface), knob_data_length1 = -1, _knob_data_size_ = knob_data_length1, _tmp0_);
1342         {
1343                 gint i;
1344                 i = 0;
1345                 {
1346                         gboolean _tmp1_;
1347                         _tmp1_ = TRUE;
1348                         while (TRUE) {
1349                                 guchar r;
1350                                 guchar g;
1351                                 guchar b;
1352                                 guchar a;
1353                                 if (!_tmp1_) {
1354                                         i = i + 4;
1355                                 }
1356                                 _tmp1_ = FALSE;
1357                                 if (!(i < (cairo_image_surface_get_height (surface) * cairo_image_surface_get_stride (surface)))) {
1358                                         break;
1359                                 }
1360                                 r = knob_data[i + 0];
1361                                 g = knob_data[i + 1];
1362                                 b = knob_data[i + 2];
1363                                 a = knob_data[i + 3];
1364                                 knob_data[i + 0] = b;
1365                                 knob_data[i + 1] = g;
1366                                 knob_data[i + 2] = r;
1367                                 knob_data[i + 3] = a;
1368                         }
1369                 }
1370         }
1371         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);
1372         return result;
1373 }
1374
1375
1376
1377