libs/gtkmm2ext/prolooks_helpers.c

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