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