/* * Clutter. * * An OpenGL based 'interactive canvas' library. * * Authored By Matthew Allum * * Copyright (C) 2006 OpenedHand * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General Public * License along with this library; if not, write to the * Free Software Foundation, Inc., 59 Temple Place - Suite 330, * Boston, MA 02111-1307, USA. */ /** * SECTION:clutter-color * @short_description: Color management and manipulation. * * #ClutterColor is a simple type for representing colors in Clutter. * * A #ClutterColor is expressed as a 4-tuple of values ranging from * zero to 255, one for each color channel plus one for the alpha. */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include #include #include "clutter-main.h" #include "clutter-color.h" #include "clutter-private.h" #include "clutter-debug.h" /** * clutter_color_add: * @a: a #ClutterColor * @b: a #ClutterColor * @result: (out): return location for the result * * Adds @a to @b and saves the resulting color inside @result. * * The alpha channel of @result is set as as the maximum value * between the alpha channels of @a and @b. */ void clutter_color_add (const ClutterColor *a, const ClutterColor *b, ClutterColor *result) { g_return_if_fail (a != NULL); g_return_if_fail (b != NULL); g_return_if_fail (result != NULL); result->red = CLAMP (a->red + b->red, 0, 255); result->green = CLAMP (a->green + b->green, 0, 255); result->blue = CLAMP (a->blue + b->blue, 0, 255); result->alpha = MAX (a->alpha, b->alpha); } /** * clutter_color_subtract: * @a: a #ClutterColor * @b: a #ClutterColor * @result: (out): return location for the result * * Subtracts @b from @a and saves the resulting color inside @result. * * This function assumes that the components of @a are greater than the * components of @b; the result is, otherwise, undefined. * * The alpha channel of @result is set as the minimum value * between the alpha channels of @a and @b. */ void clutter_color_subtract (const ClutterColor *a, const ClutterColor *b, ClutterColor *result) { g_return_if_fail (a != NULL); g_return_if_fail (b != NULL); g_return_if_fail (result != NULL); result->red = CLAMP (a->red - b->red, 0, 255); result->green = CLAMP (a->green - b->green, 0, 255); result->blue = CLAMP (a->blue - b->blue, 0, 255); result->alpha = MIN (a->alpha, b->alpha); } /** * clutter_color_lighten: * @color: a #ClutterColor * @result: (out): return location for the lighter color * * Lightens @color by a fixed amount, and saves the changed color * in @result. */ void clutter_color_lighten (const ClutterColor *color, ClutterColor *result) { clutter_color_shade (color, 1.3, result); } /** * clutter_color_darken: * @color: a #ClutterColor * @result: (out): return location for the darker color * * Darkens @color by a fixed amount, and saves the changed color * in @result. */ void clutter_color_darken (const ClutterColor *color, ClutterColor *result) { clutter_color_shade (color, 0.7, result); } /* * clutter_color_to_hlsx: * @color: a #ClutterColor * @hue: return location for the hue value or %NULL * @luminance: return location for the luminance value or %NULL * @saturation: return location for the saturation value or %NULL * * Converts @color to the HLS format. Returned hue is in degrees (0 .. 360), * luminance and saturation from interval <0 .. 1>. * * The implementation is in fixed point because we don't particularly * care about precision. It can be moved to floating point at any later * date. */ static void clutter_color_to_hlsx (const ClutterColor *color, CoglFixed *hue, CoglFixed *luminance, CoglFixed *saturation) { CoglFixed red, green, blue; CoglFixed min, max, delta; CoglFixed h, l, s; g_return_if_fail (color != NULL); red = COGL_FIXED_FAST_DIV (color->red, COGL_FIXED_255); green = COGL_FIXED_FAST_DIV (color->green, COGL_FIXED_255); blue = COGL_FIXED_FAST_DIV (color->blue, COGL_FIXED_255); if (red > green) { if (red > blue) max = red; else max = blue; if (green < blue) min = green; else min = blue; } else { if (green > blue) max = green; else max = blue; if (red < blue) min = red; else min = blue; } l = (max + min) / 2; s = 0; h = 0; if (max != min) { if (l <= COGL_FIXED_0_5) s = COGL_FIXED_DIV ((max - min), (max + min)); else s = COGL_FIXED_DIV ((max - min), (COGL_FIXED_FROM_INT (2) - max - min)); delta = max - min; if (red == max) h = COGL_FIXED_DIV ((green - blue), delta); else if (green == max) h = COGL_FIXED_FROM_INT (2) + COGL_FIXED_DIV ((blue - red), delta); else if (blue == max) h = COGL_FIXED_FROM_INT (4) + COGL_FIXED_DIV ((red - green), delta); h *= 60; if (h < 0) h += COGL_FIXED_360; } if (hue) *hue = h; if (luminance) *luminance = l; if (saturation) *saturation = s; } /* * clutter_color_from_hlsx: * @dest: (out): return location for a #ClutterColor * @hue: hue value (0 .. 360) * @luminance: luminance value (0 .. 1) * @saturation: saturation value (0 .. 1) * * Converts a color expressed in HLS (hue, luminance and saturation) * values into a #ClutterColor. */ void clutter_color_from_hlsx (ClutterColor *color, CoglFixed hue, CoglFixed luminance, CoglFixed saturation) { CoglFixed h, l, s; CoglFixed m1, m2; g_return_if_fail (color != NULL); l = luminance; s = saturation; if (l <= COGL_FIXED_0_5) m2 = COGL_FIXED_MUL (l, (COGL_FIXED_1 + s)); else m2 = l + s - COGL_FIXED_MUL (l, s); m1 = 2 * l - m2; if (s == 0) { color->red = (guint8) (COGL_FIXED_TO_FLOAT (l) * 255); color->green = (guint8) (COGL_FIXED_TO_FLOAT (l) * 255); color->blue = (guint8) (COGL_FIXED_TO_FLOAT (l) * 255); } else { h = hue + COGL_FIXED_120; while (h > COGL_FIXED_360) h -= COGL_FIXED_360; while (h < 0) h += COGL_FIXED_360; if (h < COGL_FIXED_60) { CoglFixed tmp; tmp = (m1 + COGL_FIXED_MUL_DIV ((m2 - m1), h, COGL_FIXED_60)); color->red = (guint8) (COGL_FIXED_TO_FLOAT (tmp) * 255); } else if (h < COGL_FIXED_180) color->red = (guint8) (COGL_FIXED_TO_FLOAT (m2) * 255); else if (h < COGL_FIXED_240) { CoglFixed tmp; tmp = (m1 + COGL_FIXED_MUL_DIV ((m2 - m1), (COGL_FIXED_240 - h), COGL_FIXED_60)); color->red = (guint8) (COGL_FIXED_TO_FLOAT (tmp) * 255); } else color->red = (guint8) (COGL_FIXED_TO_FLOAT (m1) * 255); h = hue; while (h > COGL_FIXED_360) h -= COGL_FIXED_360; while (h < 0) h += COGL_FIXED_360; if (h < COGL_FIXED_60) { CoglFixed tmp; tmp = (m1 + COGL_FIXED_MUL_DIV ((m2 - m1), h, COGL_FIXED_60)); color->green = (guint8) (COGL_FIXED_TO_FLOAT (tmp) * 255); } else if (h < COGL_FIXED_180) color->green = (guint8) (COGL_FIXED_TO_FLOAT (m2) * 255); else if (h < COGL_FIXED_240) { CoglFixed tmp; tmp = (m1 + COGL_FIXED_MUL_DIV ((m2 - m1), (COGL_FIXED_240 - h), COGL_FIXED_60)); color->green = (guint8) (COGL_FIXED_TO_FLOAT (tmp) * 255); } else color->green = (guint8) (COGL_FIXED_TO_FLOAT (m1) * 255); h = hue - COGL_FIXED_120; while (h > COGL_FIXED_360) h -= COGL_FIXED_360; while (h < 0) h += COGL_FIXED_360; if (h < COGL_FIXED_60) { CoglFixed tmp; tmp = (m1 + COGL_FIXED_MUL_DIV ((m2 - m1), h, COGL_FIXED_60)); color->blue = (guint8) (COGL_FIXED_TO_FLOAT (tmp) * 255); } else if (h < COGL_FIXED_180) color->blue = (guint8) (COGL_FIXED_TO_FLOAT (m2) * 255); else if (h < COGL_FIXED_240) { CoglFixed tmp; tmp = (m1 + COGL_FIXED_MUL_DIV ((m2 - m1), (COGL_FIXED_240 - h), COGL_FIXED_60)); color->blue = (guint8) (COGL_FIXED_TO_FLOAT (tmp) * 255); } else color->blue = (guint8) (COGL_FIXED_TO_FLOAT (m1) * 255); } } /** * clutter_color_to_hls: * @color: a #ClutterColor * @hue: return location for the hue value or %NULL * @luminance: return location for the luminance value or %NULL * @saturation: return location for the saturation value or %NULL * * Converts @color to the HLS format. * * The @hue value is in the 0 .. 360 range. The @luminance and * @saturation values are in the 0 .. 1 range. */ void clutter_color_to_hls (const ClutterColor *color, gfloat *hue, gfloat *luminance, gfloat *saturation) { CoglFixed h, l, s; clutter_color_to_hlsx (color, &h, &l, &s); if (hue) *hue = COGL_FIXED_TO_FLOAT (h); if (luminance) *luminance = COGL_FIXED_TO_FLOAT (l); if (saturation) *saturation = COGL_FIXED_TO_FLOAT (s); } /** * clutter_color_from_hls: * @color: (out): return location for a #ClutterColor * @hue: hue value, in the 0 .. 360 range * @luminance: luminance value, in the 0 .. 1 range * @saturation: saturation value, in the 0 .. 1 range * * Converts a color expressed in HLS (hue, luminance and saturation) * values into a #ClutterColor. */ void clutter_color_from_hls (ClutterColor *color, gfloat hue, gfloat luminance, gfloat saturation) { CoglFixed h, l, s; h = COGL_FIXED_FROM_FLOAT (hue); l = COGL_FIXED_FROM_FLOAT (luminance); s = COGL_FIXED_FROM_FLOAT (saturation); clutter_color_from_hlsx (color, h, l, s); } /* * clutter_color_shadex: * @color: a #ClutterColor * @factor: the shade factor to apply, as a fixed point value * @result: (out): return location for the shaded color * * Shades @color by @factor and saves the modified color into @result. */ static void clutter_color_shadex (const ClutterColor *color, CoglFixed factor, ClutterColor *result) { CoglFixed h, l, s; g_return_if_fail (color != NULL); g_return_if_fail (result != NULL); clutter_color_to_hlsx (color, &h, &l, &s); l = COGL_FIXED_MUL (l, factor); if (l > COGL_FIXED_1) l = COGL_FIXED_1; else if (l < 0) l = 0; s = COGL_FIXED_MUL (s, factor); if (s > COGL_FIXED_1) s = COGL_FIXED_1; else if (s < 0) s = 0; clutter_color_from_hlsx (result, h, l, s); result->alpha = color->alpha; } /** * clutter_color_shade: * @color: a #ClutterColor * @factor: the shade factor to apply * @result: (out): return location for the shaded color * * Shades @color by @factor and saves the modified color into @result. */ void clutter_color_shade (const ClutterColor *color, gdouble factor, ClutterColor *result) { clutter_color_shadex (color, COGL_FIXED_FROM_FLOAT (factor), result); } /** * clutter_color_to_pixel: * @color: a #ClutterColor * * Converts @color into a packed 32 bit integer, containing * all the four 8 bit channels used by #ClutterColor. * * Return value: a packed color */ guint32 clutter_color_to_pixel (const ClutterColor *color) { g_return_val_if_fail (color != NULL, 0); return (color->alpha | color->blue << 8 | color->green << 16 | color->red << 24); } /** * clutter_color_from_pixel: * @color: (out): return location for a #ClutterColor * @pixel: a 32 bit packed integer containing a color * * Converts @pixel from the packed representation of a four 8 bit channel * color to a #ClutterColor. */ void clutter_color_from_pixel (ClutterColor *color, guint32 pixel) { g_return_if_fail (color != NULL); color->red = pixel >> 24; color->green = (pixel >> 16) & 0xff; color->blue = (pixel >> 8) & 0xff; color->alpha = pixel & 0xff; } /** * clutter_color_from_string: * @color: (out): return location for a #ClutterColor * @str: a string specifiying a color (named color or #RRGGBBAA) * * Parses a string definition of a color, filling the * red, green, * blue and alpha * channels of @color. If alpha is not specified it will be set full opaque. * * The @color is not allocated. * * The color may be defined by any of the formats understood by * pango_color_from_string(); these include literal color names, like * Red or DarkSlateGray, or * hexadecimal specifications like #3050b2 or * #333. * * Return value: %TRUE if parsing succeeded. * * Since: 1.0 */ gboolean clutter_color_from_string (ClutterColor *color, const gchar *str) { PangoColor pango_color = { 0, }; g_return_val_if_fail (color != NULL, FALSE); g_return_val_if_fail (str != NULL, FALSE); /* if the string contains a color encoded using the hexadecimal * notations (#rrggbbaa or #rrggbb) we attempt a rough pass at * parsing the color ourselves, as we need the alpha channel that * Pango can't retrieve. */ if (str[0] == '#') { gint32 result; if (sscanf (str + 1, "%x", &result)) { if (strlen (str) == 9) { /* #rrggbbaa */ color->red = (result >> 24) & 0xff; color->green = (result >> 16) & 0xff; color->blue = (result >> 8) & 0xff; color->alpha = result & 0xff; return TRUE; } else if (strlen (str) == 7) { /* #rrggbb */ color->red = (result >> 16) & 0xff; color->green = (result >> 8) & 0xff; color->blue = result & 0xff; color->alpha = 0xff; return TRUE; } } /* XXX - should we return FALSE here? it's not like * Pango is endowed with mystical parsing powers and * will be able to do better than the code above. * still, it doesn't hurt */ } /* Fall back to pango for named colors */ if (pango_color_parse (&pango_color, str)) { color->red = pango_color.red; color->green = pango_color.green; color->blue = pango_color.blue; color->alpha = 0xff; return TRUE; } return FALSE; } /** * clutter_color_to_string: * @color: a #ClutterColor * * Returns a textual specification of @color in the hexadecimal form * #rrggbbaa, where r, * g, b and a are * hex digits representing the red, green, blue and alpha components * respectively. * * Return value: a newly-allocated text string * * Since: 0.2 */ gchar * clutter_color_to_string (const ClutterColor *color) { g_return_val_if_fail (color != NULL, NULL); return g_strdup_printf ("#%02x%02x%02x%02x", color->red, color->green, color->blue, color->alpha); } /** * clutter_color_equal: * @v1: a #ClutterColor * @v2: a #ClutterColor * * Compares two #ClutterColors and checks if they are the same. * * This function can be passed to g_hash_table_new() as the @key_equal_func * parameter, when using #ClutterColors as keys in a #GHashTable. * * Return value: %TRUE if the two colors are the same. * * Since: 0.2 */ gboolean clutter_color_equal (gconstpointer v1, gconstpointer v2) { const ClutterColor *a, *b; g_return_val_if_fail (v1 != NULL, FALSE); g_return_val_if_fail (v2 != NULL, FALSE); if (v1 == v2) return TRUE; a = v1; b = v2; return (a->red == b->red && a->green == b->green && a->blue == b->blue && a->alpha == b->alpha); } /** * clutter_color_hash: * @v: a #ClutterColor * * Converts a #ClutterColor to a hash value. * * This function can be passed to g_hash_table_new() as the @hash_func * parameter, when using #ClutterColors as keys in a #GHashTable. * * Return value: a hash value corresponding to the color * * Since: 1.0 */ guint clutter_color_hash (gconstpointer v) { return clutter_color_to_pixel ((const ClutterColor *) v); } /** * clutter_color_copy: * @color: a #ClutterColor * * Makes a copy of the color structure. The result must be * freed using clutter_color_free(). * * Return value: an allocated copy of @color. * * Since: 0.2 */ ClutterColor * clutter_color_copy (const ClutterColor *color) { if (G_LIKELY (color != NULL)) return g_slice_dup (ClutterColor, color); return NULL; } /** * clutter_color_free: * @color: a #ClutterColor * * Frees a color structure created with clutter_color_copy(). * * Since: 0.2 */ void clutter_color_free (ClutterColor *color) { if (G_LIKELY (color != NULL)) g_slice_free (ClutterColor, color); } /** * clutter_color_new: * @red: red component of the color, between 0 and 255 * @green: green component of the color, between 0 and 255 * @blue: blue component of the color, between 0 and 255 * @alpha: alpha component of the color, between 0 and 255 * * Creates a new #ClutterColor with the given values. * * Return value: the newly allocated color. Use clutter_color_free() * when done * * Since: 0.8.4 */ ClutterColor * clutter_color_new (guint8 red, guint8 green, guint8 blue, guint8 alpha) { ClutterColor *color; color = g_slice_new (ClutterColor); color->red = red; color->green = green; color->blue = blue; color->alpha = alpha; return color; } static void clutter_value_transform_color_string (const GValue *src, GValue *dest) { gchar *string = clutter_color_to_string (src->data[0].v_pointer); g_value_take_string (dest, string); } static void clutter_value_transform_string_color (const GValue *src, GValue *dest) { ClutterColor color = { 0, }; clutter_color_from_string (&color, g_value_get_string (src)); clutter_value_set_color (dest, &color); } GType clutter_color_get_type (void) { static GType _clutter_color_type = 0; if (G_UNLIKELY (_clutter_color_type == 0)) { _clutter_color_type = g_boxed_type_register_static (I_("ClutterColor"), (GBoxedCopyFunc) clutter_color_copy, (GBoxedFreeFunc) clutter_color_free); g_value_register_transform_func (_clutter_color_type, G_TYPE_STRING, clutter_value_transform_color_string); g_value_register_transform_func (G_TYPE_STRING, _clutter_color_type, clutter_value_transform_string_color); } return _clutter_color_type; } static void clutter_value_init_color (GValue *value) { value->data[0].v_pointer = NULL; } static void clutter_value_free_color (GValue *value) { if (!(value->data[1].v_uint & G_VALUE_NOCOPY_CONTENTS)) clutter_color_free (value->data[0].v_pointer); } static void clutter_value_copy_color (const GValue *src, GValue *dest) { dest->data[0].v_pointer = clutter_color_copy (src->data[0].v_pointer); } static gpointer clutter_value_peek_color (const GValue *value) { return value->data[0].v_pointer; } static gchar * clutter_value_collect_color (GValue *value, guint n_collect_values, GTypeCValue *collect_values, guint collect_flags) { if (!collect_values[0].v_pointer) value->data[0].v_pointer = NULL; else { if (collect_flags & G_VALUE_NOCOPY_CONTENTS) { value->data[0].v_pointer = collect_values[0].v_pointer; value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS; } else { value->data[0].v_pointer = clutter_color_copy (collect_values[0].v_pointer); } } return NULL; } static gchar * clutter_value_lcopy_color (const GValue *value, guint n_collect_values, GTypeCValue *collect_values, guint collect_flags) { ClutterColor **color_p = collect_values[0].v_pointer; if (!color_p) return g_strdup_printf ("value location for `%s' passed as NULL", G_VALUE_TYPE_NAME (value)); if (!value->data[0].v_pointer) *color_p = NULL; else { if (collect_flags & G_VALUE_NOCOPY_CONTENTS) *color_p = value->data[0].v_pointer; else *color_p = clutter_color_copy (value->data[0].v_pointer); } return NULL; } /** * clutter_value_set_color: * @value: a #GValue initialized to #CLUTTER_TYPE_COLOR * @color: the color to set * * Sets @value to @color. * * Since: 0.8.4 */ void clutter_value_set_color (GValue *value, const ClutterColor *color) { g_return_if_fail (CLUTTER_VALUE_HOLDS_COLOR (value)); value->data[0].v_pointer = clutter_color_copy (color); } /** * clutter_value_get_color: * @value: a #GValue initialized to #CLUTTER_TYPE_COLOR * * Gets the #ClutterColor contained in @value. * * Return value: the colors inside the passed #GValue * * Since: 0.8.4 */ G_CONST_RETURN ClutterColor * clutter_value_get_color (const GValue *value) { g_return_val_if_fail (CLUTTER_VALUE_HOLDS_COLOR (value), NULL); return value->data[0].v_pointer; } static void param_color_init (GParamSpec *pspec) { ClutterParamSpecColor *cspec = CLUTTER_PARAM_SPEC_COLOR (pspec); cspec->default_value = NULL; } static void param_color_finalize (GParamSpec *pspec) { ClutterParamSpecColor *cspec = CLUTTER_PARAM_SPEC_COLOR (pspec); clutter_color_free (cspec->default_value); } static void param_color_set_default (GParamSpec *pspec, GValue *value) { value->data[0].v_pointer = CLUTTER_PARAM_SPEC_COLOR (pspec)->default_value; value->data[1].v_uint = G_VALUE_NOCOPY_CONTENTS; } static gint param_color_values_cmp (GParamSpec *pspec, const GValue *value1, const GValue *value2) { guint32 color1, color2; color1 = clutter_color_to_pixel (value1->data[0].v_pointer); color2 = clutter_color_to_pixel (value2->data[0].v_pointer); if (color1 < color2) return -1; else if (color1 == color2) return 0; else return 1; } static const GTypeValueTable _clutter_color_value_table = { clutter_value_init_color, clutter_value_free_color, clutter_value_copy_color, clutter_value_peek_color, "p", clutter_value_collect_color, "p", clutter_value_lcopy_color }; GType clutter_param_color_get_type (void) { static GType pspec_type = 0; if (G_UNLIKELY (pspec_type == 0)) { const GParamSpecTypeInfo pspec_info = { sizeof (ClutterParamSpecColor), 16, param_color_init, CLUTTER_TYPE_COLOR, param_color_finalize, param_color_set_default, NULL, param_color_values_cmp, }; pspec_type = g_param_type_register_static (I_("ClutterParamSpecColor"), &pspec_info); } return pspec_type; } /** * clutter_param_spec_color: * @name: name of the property * @nick: short name * @blurb: description (can be translatable) * @default_value: default value * @flags: flags for the param spec * * Creates a #GParamSpec for properties using #ClutterColor. * * Return value: the newly created #GParamSpec * * Since: 0.8.4 */ GParamSpec * clutter_param_spec_color (const gchar *name, const gchar *nick, const gchar *blurb, const ClutterColor *default_value, GParamFlags flags) { ClutterParamSpecColor *cspec; cspec = g_param_spec_internal (CLUTTER_TYPE_PARAM_COLOR, name, nick, blurb, flags); cspec->default_value = clutter_color_copy (default_value); return G_PARAM_SPEC (cspec); }