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