815 lines
20 KiB
C
815 lines
20 KiB
C
/* LIBPIKA - The PIKA Library
|
|
* Copyright (C) 1995-1997 Peter Mattis and Spencer Kimball
|
|
*
|
|
* 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 3 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
|
|
* Library 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, see
|
|
* <https://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "config.h"
|
|
|
|
#include <babl/babl.h>
|
|
#include <glib-object.h>
|
|
|
|
#include "libpikamath/pikamath.h"
|
|
|
|
#include "pikacolortypes.h"
|
|
#include "pikargb.h"
|
|
|
|
|
|
/**
|
|
* SECTION: pikargb
|
|
* @title: PikaRGB
|
|
* @short_description: Definitions and Functions relating to RGB colors.
|
|
*
|
|
* Definitions and Functions relating to RGB colors.
|
|
**/
|
|
|
|
|
|
/*
|
|
* PIKA_TYPE_RGB
|
|
*/
|
|
|
|
static PikaRGB * pika_rgb_copy (const PikaRGB *rgb);
|
|
|
|
|
|
G_DEFINE_BOXED_TYPE (PikaRGB, pika_rgb, pika_rgb_copy, g_free)
|
|
|
|
void
|
|
pika_value_get_rgb (const GValue *value,
|
|
PikaRGB *rgb)
|
|
{
|
|
g_return_if_fail (PIKA_VALUE_HOLDS_RGB (value));
|
|
g_return_if_fail (rgb != NULL);
|
|
|
|
if (value->data[0].v_pointer)
|
|
*rgb = *((PikaRGB *) value->data[0].v_pointer);
|
|
else
|
|
pika_rgba_set (rgb, 0.0, 0.0, 0.0, 1.0);
|
|
}
|
|
|
|
void
|
|
pika_value_set_rgb (GValue *value,
|
|
const PikaRGB *rgb)
|
|
{
|
|
g_return_if_fail (PIKA_VALUE_HOLDS_RGB (value));
|
|
g_return_if_fail (rgb != NULL);
|
|
|
|
g_value_set_boxed (value, rgb);
|
|
}
|
|
|
|
static PikaRGB *
|
|
pika_rgb_copy (const PikaRGB *rgb)
|
|
{
|
|
return g_memdup2 (rgb, sizeof (PikaRGB));
|
|
}
|
|
|
|
|
|
/* RGB functions */
|
|
|
|
/**
|
|
* pika_rgb_set:
|
|
* @rgb: a #PikaRGB struct
|
|
* @red: the red component
|
|
* @green: the green component
|
|
* @blue: the blue component
|
|
*
|
|
* Sets the red, green and blue components of @rgb and leaves the
|
|
* alpha component unchanged. The color values should be between 0.0
|
|
* and 1.0 but there is no check to enforce this and the values are
|
|
* set exactly as they are passed in.
|
|
**/
|
|
void
|
|
pika_rgb_set (PikaRGB *rgb,
|
|
gdouble r,
|
|
gdouble g,
|
|
gdouble b)
|
|
{
|
|
g_return_if_fail (rgb != NULL);
|
|
|
|
rgb->r = r;
|
|
rgb->g = g;
|
|
rgb->b = b;
|
|
}
|
|
|
|
/**
|
|
* pika_rgb_set_alpha:
|
|
* @rgb: a #PikaRGB struct
|
|
* @alpha: the alpha component
|
|
*
|
|
* Sets the alpha component of @rgb and leaves the RGB components unchanged.
|
|
**/
|
|
void
|
|
pika_rgb_set_alpha (PikaRGB *rgb,
|
|
gdouble a)
|
|
{
|
|
g_return_if_fail (rgb != NULL);
|
|
|
|
rgb->a = a;
|
|
}
|
|
|
|
/**
|
|
* pika_rgb_set_pixel:
|
|
* @rgb: a #PikaRGB struct
|
|
* @format: a Babl format
|
|
* @pixel: pointer to the source pixel
|
|
*
|
|
* Sets the red, green and blue components of @rgb from the color
|
|
* stored in @pixel. The pixel format of @pixel is determined by
|
|
* @format.
|
|
*
|
|
* Since: 2.10
|
|
**/
|
|
void
|
|
pika_rgb_set_pixel (PikaRGB *rgb,
|
|
const Babl *format,
|
|
gconstpointer pixel)
|
|
{
|
|
g_return_if_fail (rgb != NULL);
|
|
g_return_if_fail (format != NULL);
|
|
g_return_if_fail (pixel != NULL);
|
|
|
|
babl_process (babl_fish (format,
|
|
babl_format ("R'G'B' double")),
|
|
pixel, rgb, 1);
|
|
}
|
|
|
|
/**
|
|
* pika_rgb_get_pixel:
|
|
* @rgb: a #PikaRGB struct
|
|
* @format: a Babl format
|
|
* @pixel: (out caller-allocates): pointer to the destination pixel
|
|
*
|
|
* Writes the red, green, blue and alpha components of @rgb to the
|
|
* color stored in @pixel. The pixel format of @pixel is determined by
|
|
* @format.
|
|
*
|
|
* Since: 2.10
|
|
**/
|
|
void
|
|
pika_rgb_get_pixel (const PikaRGB *rgb,
|
|
const Babl *format,
|
|
gpointer pixel)
|
|
{
|
|
g_return_if_fail (rgb != NULL);
|
|
g_return_if_fail (format != NULL);
|
|
g_return_if_fail (pixel != NULL);
|
|
|
|
babl_process (babl_fish (babl_format ("R'G'B' double"),
|
|
format),
|
|
rgb, pixel, 1);
|
|
}
|
|
|
|
/**
|
|
* pika_rgb_set_uchar:
|
|
* @rgb: a #PikaRGB struct
|
|
* @red: the red component
|
|
* @green: the green component
|
|
* @blue: the blue component
|
|
*
|
|
* Sets the red, green and blue components of @rgb from 8bit values
|
|
* (0 to 255) and leaves the alpha component unchanged.
|
|
**/
|
|
void
|
|
pika_rgb_set_uchar (PikaRGB *rgb,
|
|
guchar r,
|
|
guchar g,
|
|
guchar b)
|
|
{
|
|
g_return_if_fail (rgb != NULL);
|
|
|
|
rgb->r = (gdouble) r / 255.0;
|
|
rgb->g = (gdouble) g / 255.0;
|
|
rgb->b = (gdouble) b / 255.0;
|
|
}
|
|
|
|
/**
|
|
* pika_rgb_get_uchar:
|
|
* @rgb: a #PikaRGB struct
|
|
* @red: (out) (optional): Location for red component, or %NULL
|
|
* @green: (out) (optional): Location for green component, or %NULL
|
|
* @blue: (out) (optional): Location for blue component, or %NULL
|
|
*
|
|
* Writes the red, green, blue and alpha components of @rgb to the
|
|
* color components @red, @green and @blue.
|
|
*/
|
|
void
|
|
pika_rgb_get_uchar (const PikaRGB *rgb,
|
|
guchar *red,
|
|
guchar *green,
|
|
guchar *blue)
|
|
{
|
|
g_return_if_fail (rgb != NULL);
|
|
|
|
if (red) *red = ROUND (CLAMP (rgb->r, 0.0, 1.0) * 255.0);
|
|
if (green) *green = ROUND (CLAMP (rgb->g, 0.0, 1.0) * 255.0);
|
|
if (blue) *blue = ROUND (CLAMP (rgb->b, 0.0, 1.0) * 255.0);
|
|
}
|
|
|
|
void
|
|
pika_rgb_add (PikaRGB *rgb1,
|
|
const PikaRGB *rgb2)
|
|
{
|
|
g_return_if_fail (rgb1 != NULL);
|
|
g_return_if_fail (rgb2 != NULL);
|
|
|
|
rgb1->r += rgb2->r;
|
|
rgb1->g += rgb2->g;
|
|
rgb1->b += rgb2->b;
|
|
}
|
|
|
|
void
|
|
pika_rgb_subtract (PikaRGB *rgb1,
|
|
const PikaRGB *rgb2)
|
|
{
|
|
g_return_if_fail (rgb1 != NULL);
|
|
g_return_if_fail (rgb2 != NULL);
|
|
|
|
rgb1->r -= rgb2->r;
|
|
rgb1->g -= rgb2->g;
|
|
rgb1->b -= rgb2->b;
|
|
}
|
|
|
|
void
|
|
pika_rgb_multiply (PikaRGB *rgb,
|
|
gdouble factor)
|
|
{
|
|
g_return_if_fail (rgb != NULL);
|
|
|
|
rgb->r *= factor;
|
|
rgb->g *= factor;
|
|
rgb->b *= factor;
|
|
}
|
|
|
|
gdouble
|
|
pika_rgb_distance (const PikaRGB *rgb1,
|
|
const PikaRGB *rgb2)
|
|
{
|
|
g_return_val_if_fail (rgb1 != NULL, 0.0);
|
|
g_return_val_if_fail (rgb2 != NULL, 0.0);
|
|
|
|
return (fabs (rgb1->r - rgb2->r) +
|
|
fabs (rgb1->g - rgb2->g) +
|
|
fabs (rgb1->b - rgb2->b));
|
|
}
|
|
|
|
gdouble
|
|
pika_rgb_max (const PikaRGB *rgb)
|
|
{
|
|
g_return_val_if_fail (rgb != NULL, 0.0);
|
|
|
|
if (rgb->r > rgb->g)
|
|
return (rgb->r > rgb->b) ? rgb->r : rgb->b;
|
|
else
|
|
return (rgb->g > rgb->b) ? rgb->g : rgb->b;
|
|
}
|
|
|
|
gdouble
|
|
pika_rgb_min (const PikaRGB *rgb)
|
|
{
|
|
g_return_val_if_fail (rgb != NULL, 0.0);
|
|
|
|
if (rgb->r < rgb->g)
|
|
return (rgb->r < rgb->b) ? rgb->r : rgb->b;
|
|
else
|
|
return (rgb->g < rgb->b) ? rgb->g : rgb->b;
|
|
}
|
|
|
|
void
|
|
pika_rgb_clamp (PikaRGB *rgb)
|
|
{
|
|
g_return_if_fail (rgb != NULL);
|
|
|
|
rgb->r = CLAMP (rgb->r, 0.0, 1.0);
|
|
rgb->g = CLAMP (rgb->g, 0.0, 1.0);
|
|
rgb->b = CLAMP (rgb->b, 0.0, 1.0);
|
|
rgb->a = CLAMP (rgb->a, 0.0, 1.0);
|
|
}
|
|
|
|
void
|
|
pika_rgb_gamma (PikaRGB *rgb,
|
|
gdouble gamma)
|
|
{
|
|
gdouble ig;
|
|
|
|
g_return_if_fail (rgb != NULL);
|
|
|
|
if (gamma != 0.0)
|
|
ig = 1.0 / gamma;
|
|
else
|
|
ig = 0.0;
|
|
|
|
rgb->r = pow (rgb->r, ig);
|
|
rgb->g = pow (rgb->g, ig);
|
|
rgb->b = pow (rgb->b, ig);
|
|
}
|
|
|
|
/**
|
|
* pika_rgb_luminance:
|
|
* @rgb: a #PikaRGB struct
|
|
*
|
|
* Returns: the luminous intensity of the range from 0.0 to 1.0.
|
|
*
|
|
* Since: 2.4
|
|
**/
|
|
gdouble
|
|
pika_rgb_luminance (const PikaRGB *rgb)
|
|
{
|
|
gdouble luminance;
|
|
|
|
g_return_val_if_fail (rgb != NULL, 0.0);
|
|
|
|
luminance = PIKA_RGB_LUMINANCE (rgb->r, rgb->g, rgb->b);
|
|
|
|
return CLAMP (luminance, 0.0, 1.0);
|
|
}
|
|
|
|
/**
|
|
* pika_rgb_luminance_uchar:
|
|
* @rgb: a #PikaRGB struct
|
|
*
|
|
* Returns: the luminous intensity in the range from 0 to 255.
|
|
*
|
|
* Since: 2.4
|
|
**/
|
|
guchar
|
|
pika_rgb_luminance_uchar (const PikaRGB *rgb)
|
|
{
|
|
g_return_val_if_fail (rgb != NULL, 0);
|
|
|
|
return ROUND (pika_rgb_luminance (rgb) * 255.0);
|
|
}
|
|
|
|
void
|
|
pika_rgb_composite (PikaRGB *color1,
|
|
const PikaRGB *color2,
|
|
PikaRGBCompositeMode mode)
|
|
{
|
|
g_return_if_fail (color1 != NULL);
|
|
g_return_if_fail (color2 != NULL);
|
|
|
|
switch (mode)
|
|
{
|
|
case PIKA_RGB_COMPOSITE_NONE:
|
|
break;
|
|
|
|
case PIKA_RGB_COMPOSITE_NORMAL:
|
|
/* put color2 on top of color1 */
|
|
if (color2->a == 1.0)
|
|
{
|
|
*color1 = *color2;
|
|
}
|
|
else
|
|
{
|
|
gdouble factor = color1->a * (1.0 - color2->a);
|
|
|
|
color1->r = color1->r * factor + color2->r * color2->a;
|
|
color1->g = color1->g * factor + color2->g * color2->a;
|
|
color1->b = color1->b * factor + color2->b * color2->a;
|
|
color1->a = factor + color2->a;
|
|
}
|
|
break;
|
|
|
|
case PIKA_RGB_COMPOSITE_BEHIND:
|
|
/* put color2 below color1 */
|
|
if (color1->a < 1.0)
|
|
{
|
|
gdouble factor = color2->a * (1.0 - color1->a);
|
|
|
|
color1->r = color2->r * factor + color1->r * color1->a;
|
|
color1->g = color2->g * factor + color1->g * color1->a;
|
|
color1->b = color2->b * factor + color1->b * color1->a;
|
|
color1->a = factor + color1->a;
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* RGBA functions */
|
|
|
|
/**
|
|
* pika_rgba_set_pixel:
|
|
* @rgba: a #PikaRGB struct
|
|
* @format: a Babl format
|
|
* @pixel: pointer to the source pixel
|
|
*
|
|
* Sets the red, green, blue and alpha components of @rgba from the
|
|
* color stored in @pixel. The pixel format of @pixel is determined
|
|
* by @format.
|
|
*
|
|
* Since: 2.10
|
|
**/
|
|
void
|
|
pika_rgba_set_pixel (PikaRGB *rgba,
|
|
const Babl *format,
|
|
gconstpointer pixel)
|
|
{
|
|
g_return_if_fail (rgba != NULL);
|
|
g_return_if_fail (format != NULL);
|
|
g_return_if_fail (pixel != NULL);
|
|
|
|
babl_process (babl_fish (format,
|
|
babl_format ("R'G'B'A double")),
|
|
pixel, rgba, 1);
|
|
}
|
|
|
|
/**
|
|
* pika_rgba_get_pixel:
|
|
* @rgba: a #PikaRGB struct
|
|
* @format: a Babl format
|
|
* @pixel: (out caller-allocates): pointer to the destination pixel
|
|
*
|
|
* Writes the red, green, blue and alpha components of @rgba to the
|
|
* color stored in @pixel. The pixel format of @pixel is determined by
|
|
* @format.
|
|
*
|
|
* Since: 2.10
|
|
**/
|
|
void
|
|
pika_rgba_get_pixel (const PikaRGB *rgba,
|
|
const Babl *format,
|
|
gpointer pixel)
|
|
{
|
|
g_return_if_fail (rgba != NULL);
|
|
g_return_if_fail (format != NULL);
|
|
g_return_if_fail (pixel != NULL);
|
|
|
|
babl_process (babl_fish (babl_format ("R'G'B'A double"),
|
|
format),
|
|
rgba, pixel, 1);
|
|
}
|
|
|
|
/**
|
|
* pika_rgba_set:
|
|
* @rgba: a #PikaRGB struct
|
|
* @red: the red component
|
|
* @green: the green component
|
|
* @blue: the blue component
|
|
* @alpha: the alpha component
|
|
*
|
|
* Sets the red, green, blue and alpha components of @rgb. The values
|
|
* should be between 0.0 and 1.0 but there is no check to enforce this
|
|
* and the values are set exactly as they are passed in.
|
|
**/
|
|
void
|
|
pika_rgba_set (PikaRGB *rgba,
|
|
gdouble r,
|
|
gdouble g,
|
|
gdouble b,
|
|
gdouble a)
|
|
{
|
|
g_return_if_fail (rgba != NULL);
|
|
|
|
rgba->r = r;
|
|
rgba->g = g;
|
|
rgba->b = b;
|
|
rgba->a = a;
|
|
}
|
|
|
|
/**
|
|
* pika_rgba_set_uchar:
|
|
* @rgba: a #PikaRGB struct
|
|
* @red: the red component
|
|
* @green: the green component
|
|
* @blue: the blue component
|
|
* @alpha: the alpha component
|
|
*
|
|
* Sets the red, green, blue and alpha components of @rgba from 8bit
|
|
* values (0 to 255).
|
|
**/
|
|
void
|
|
pika_rgba_set_uchar (PikaRGB *rgba,
|
|
guchar r,
|
|
guchar g,
|
|
guchar b,
|
|
guchar a)
|
|
{
|
|
g_return_if_fail (rgba != NULL);
|
|
|
|
rgba->r = (gdouble) r / 255.0;
|
|
rgba->g = (gdouble) g / 255.0;
|
|
rgba->b = (gdouble) b / 255.0;
|
|
rgba->a = (gdouble) a / 255.0;
|
|
}
|
|
|
|
/**
|
|
* pika_rgba_get_uchar:
|
|
* @rgba: a #PikaRGB struct
|
|
* @red: (out) (optional): Location for the red component
|
|
* @green: (out) (optional): Location for the green component
|
|
* @blue: (out) (optional): Location for the blue component
|
|
* @alpha: (out) (optional): Location for the alpha component
|
|
*
|
|
* Gets the 8bit red, green, blue and alpha components of @rgba.
|
|
**/
|
|
void
|
|
pika_rgba_get_uchar (const PikaRGB *rgba,
|
|
guchar *r,
|
|
guchar *g,
|
|
guchar *b,
|
|
guchar *a)
|
|
{
|
|
g_return_if_fail (rgba != NULL);
|
|
|
|
if (r) *r = ROUND (CLAMP (rgba->r, 0.0, 1.0) * 255.0);
|
|
if (g) *g = ROUND (CLAMP (rgba->g, 0.0, 1.0) * 255.0);
|
|
if (b) *b = ROUND (CLAMP (rgba->b, 0.0, 1.0) * 255.0);
|
|
if (a) *a = ROUND (CLAMP (rgba->a, 0.0, 1.0) * 255.0);
|
|
}
|
|
|
|
void
|
|
pika_rgba_add (PikaRGB *rgba1,
|
|
const PikaRGB *rgba2)
|
|
{
|
|
g_return_if_fail (rgba1 != NULL);
|
|
g_return_if_fail (rgba2 != NULL);
|
|
|
|
rgba1->r += rgba2->r;
|
|
rgba1->g += rgba2->g;
|
|
rgba1->b += rgba2->b;
|
|
rgba1->a += rgba2->a;
|
|
}
|
|
|
|
void
|
|
pika_rgba_subtract (PikaRGB *rgba1,
|
|
const PikaRGB *rgba2)
|
|
{
|
|
g_return_if_fail (rgba1 != NULL);
|
|
g_return_if_fail (rgba2 != NULL);
|
|
|
|
rgba1->r -= rgba2->r;
|
|
rgba1->g -= rgba2->g;
|
|
rgba1->b -= rgba2->b;
|
|
rgba1->a -= rgba2->a;
|
|
}
|
|
|
|
void
|
|
pika_rgba_multiply (PikaRGB *rgba,
|
|
gdouble factor)
|
|
{
|
|
g_return_if_fail (rgba != NULL);
|
|
|
|
rgba->r *= factor;
|
|
rgba->g *= factor;
|
|
rgba->b *= factor;
|
|
rgba->a *= factor;
|
|
}
|
|
|
|
gdouble
|
|
pika_rgba_distance (const PikaRGB *rgba1,
|
|
const PikaRGB *rgba2)
|
|
{
|
|
g_return_val_if_fail (rgba1 != NULL, 0.0);
|
|
g_return_val_if_fail (rgba2 != NULL, 0.0);
|
|
|
|
return (fabs (rgba1->r - rgba2->r) +
|
|
fabs (rgba1->g - rgba2->g) +
|
|
fabs (rgba1->b - rgba2->b) +
|
|
fabs (rgba1->a - rgba2->a));
|
|
}
|
|
|
|
|
|
/*
|
|
* PIKA_TYPE_PARAM_RGB
|
|
*/
|
|
|
|
#define PIKA_PARAM_SPEC_RGB(pspec) (G_TYPE_CHECK_INSTANCE_CAST ((pspec), PIKA_TYPE_PARAM_RGB, PikaParamSpecRGB))
|
|
|
|
struct _PikaParamSpecRGB
|
|
{
|
|
GParamSpecBoxed parent_instance;
|
|
|
|
gboolean has_alpha;
|
|
gboolean validate; /* change this to enable [0.0...1.0] */
|
|
PikaRGB default_value;
|
|
};
|
|
|
|
static void pika_param_rgb_class_init (GParamSpecClass *class);
|
|
static void pika_param_rgb_init (GParamSpec *pspec);
|
|
static void pika_param_rgb_set_default (GParamSpec *pspec,
|
|
GValue *value);
|
|
static gboolean pika_param_rgb_validate (GParamSpec *pspec,
|
|
GValue *value);
|
|
static gint pika_param_rgb_values_cmp (GParamSpec *pspec,
|
|
const GValue *value1,
|
|
const GValue *value2);
|
|
|
|
/**
|
|
* pika_param_rgb_get_type:
|
|
*
|
|
* Reveals the object type
|
|
*
|
|
* Returns: the #GType for a PikaParamRGB object
|
|
*
|
|
* Since: 2.4
|
|
**/
|
|
GType
|
|
pika_param_rgb_get_type (void)
|
|
{
|
|
static GType spec_type = 0;
|
|
|
|
if (! spec_type)
|
|
{
|
|
const GTypeInfo type_info =
|
|
{
|
|
sizeof (GParamSpecClass),
|
|
NULL, NULL,
|
|
(GClassInitFunc) pika_param_rgb_class_init,
|
|
NULL, NULL,
|
|
sizeof (PikaParamSpecRGB),
|
|
0,
|
|
(GInstanceInitFunc) pika_param_rgb_init
|
|
};
|
|
|
|
spec_type = g_type_register_static (G_TYPE_PARAM_BOXED,
|
|
"PikaParamRGB",
|
|
&type_info, 0);
|
|
}
|
|
|
|
return spec_type;
|
|
}
|
|
|
|
static void
|
|
pika_param_rgb_class_init (GParamSpecClass *class)
|
|
{
|
|
class->value_type = PIKA_TYPE_RGB;
|
|
class->value_set_default = pika_param_rgb_set_default;
|
|
class->value_validate = pika_param_rgb_validate;
|
|
class->values_cmp = pika_param_rgb_values_cmp;
|
|
}
|
|
|
|
static void
|
|
pika_param_rgb_init (GParamSpec *pspec)
|
|
{
|
|
PikaParamSpecRGB *cspec = PIKA_PARAM_SPEC_RGB (pspec);
|
|
|
|
pika_rgba_set (&cspec->default_value, 0.0, 0.0, 0.0, 1.0);
|
|
}
|
|
|
|
static void
|
|
pika_param_rgb_set_default (GParamSpec *pspec,
|
|
GValue *value)
|
|
{
|
|
PikaParamSpecRGB *cspec = PIKA_PARAM_SPEC_RGB (pspec);
|
|
|
|
g_value_set_static_boxed (value, &cspec->default_value);
|
|
}
|
|
|
|
static gboolean
|
|
pika_param_rgb_validate (GParamSpec *pspec,
|
|
GValue *value)
|
|
{
|
|
PikaParamSpecRGB *rgb_spec = PIKA_PARAM_SPEC_RGB (pspec);
|
|
PikaRGB *rgb = value->data[0].v_pointer;
|
|
|
|
if (rgb_spec->validate && rgb)
|
|
{
|
|
PikaRGB oval = *rgb;
|
|
|
|
pika_rgb_clamp (rgb);
|
|
|
|
return (oval.r != rgb->r ||
|
|
oval.g != rgb->g ||
|
|
oval.b != rgb->b ||
|
|
(rgb_spec->has_alpha && oval.a != rgb->a));
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
static gint
|
|
pika_param_rgb_values_cmp (GParamSpec *pspec,
|
|
const GValue *value1,
|
|
const GValue *value2)
|
|
{
|
|
PikaRGB *rgb1 = value1->data[0].v_pointer;
|
|
PikaRGB *rgb2 = value2->data[0].v_pointer;
|
|
|
|
/* try to return at least *something*, it's useless anyway... */
|
|
|
|
if (! rgb1)
|
|
{
|
|
return rgb2 != NULL ? -1 : 0;
|
|
}
|
|
else if (! rgb2)
|
|
{
|
|
return rgb1 != NULL;
|
|
}
|
|
else
|
|
{
|
|
guint32 int1 = 0;
|
|
guint32 int2 = 0;
|
|
|
|
if (PIKA_PARAM_SPEC_RGB (pspec)->has_alpha)
|
|
{
|
|
pika_rgba_get_uchar (rgb1,
|
|
((guchar *) &int1) + 0,
|
|
((guchar *) &int1) + 1,
|
|
((guchar *) &int1) + 2,
|
|
((guchar *) &int1) + 3);
|
|
pika_rgba_get_uchar (rgb2,
|
|
((guchar *) &int2) + 0,
|
|
((guchar *) &int2) + 1,
|
|
((guchar *) &int2) + 2,
|
|
((guchar *) &int2) + 3);
|
|
}
|
|
else
|
|
{
|
|
pika_rgb_get_uchar (rgb1,
|
|
((guchar *) &int1) + 0,
|
|
((guchar *) &int1) + 1,
|
|
((guchar *) &int1) + 2);
|
|
pika_rgb_get_uchar (rgb2,
|
|
((guchar *) &int2) + 0,
|
|
((guchar *) &int2) + 1,
|
|
((guchar *) &int2) + 2);
|
|
}
|
|
|
|
return int1 - int2;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* pika_param_spec_rgb:
|
|
* @name: Canonical name of the param
|
|
* @nick: Nickname of the param
|
|
* @blurb: Brief description of param.
|
|
* @has_alpha: %TRUE if the alpha channel has relevance.
|
|
* @default_value: Value to use if none is assigned.
|
|
* @flags: a combination of #GParamFlags
|
|
*
|
|
* Creates a param spec to hold an #PikaRGB value.
|
|
* See g_param_spec_internal() for more information.
|
|
*
|
|
* Returns: (transfer full): a newly allocated #GParamSpec instance
|
|
*
|
|
* Since: 2.4
|
|
**/
|
|
GParamSpec *
|
|
pika_param_spec_rgb (const gchar *name,
|
|
const gchar *nick,
|
|
const gchar *blurb,
|
|
gboolean has_alpha,
|
|
const PikaRGB *default_value,
|
|
GParamFlags flags)
|
|
{
|
|
PikaParamSpecRGB *cspec;
|
|
|
|
cspec = g_param_spec_internal (PIKA_TYPE_PARAM_RGB,
|
|
name, nick, blurb, flags);
|
|
|
|
cspec->has_alpha = has_alpha;
|
|
|
|
if (default_value)
|
|
cspec->default_value = *default_value;
|
|
else
|
|
pika_rgba_set (&cspec->default_value, 0.0, 0.0, 0.0, 1.0);
|
|
|
|
return G_PARAM_SPEC (cspec);
|
|
}
|
|
|
|
/**
|
|
* pika_param_spec_rgb_get_default:
|
|
* @pspec: a #PikaParamSpecRGB.
|
|
* @default_value: return location for @pspec's default value
|
|
*
|
|
* Returns the @pspec's default color value.
|
|
*
|
|
* Since: 2.10.14
|
|
**/
|
|
void
|
|
pika_param_spec_rgb_get_default (GParamSpec *pspec,
|
|
PikaRGB *default_value)
|
|
{
|
|
g_return_if_fail (PIKA_IS_PARAM_SPEC_RGB (pspec));
|
|
g_return_if_fail (default_value != NULL);
|
|
|
|
*default_value = PIKA_PARAM_SPEC_RGB (pspec)->default_value;
|
|
}
|
|
|
|
/**
|
|
* pika_param_spec_rgb_has_alpha:
|
|
* @pspec: a #GParamSpec to hold an #PikaRGB value.
|
|
*
|
|
* Returns: %TRUE if the alpha channel is relevant.
|
|
*
|
|
* Since: 2.4
|
|
**/
|
|
gboolean
|
|
pika_param_spec_rgb_has_alpha (GParamSpec *pspec)
|
|
{
|
|
g_return_val_if_fail (PIKA_IS_PARAM_SPEC_RGB (pspec), FALSE);
|
|
|
|
return PIKA_PARAM_SPEC_RGB (pspec)->has_alpha;
|
|
}
|
