src/adg/adg-color-style.c

   1 /* ADG - Automatic Drawing Generation
   2  * Copyright (C) 2007,2008,2009,2010,2011,2012  Nicola Fontana <ntd at entidi.it>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  17  * Boston, MA  02110-1301, USA.
  18  */
  19
  20
  21 /**
  22  * SECTION:adg-color-style
  23  * @short_description: RGBA color information
  24  *
  25  * A style containing a single color expressed in RGB format.
  26  * #AdgColorStyle also supports the alpha compositing that should be
  27  * expressed with a double value between %0 and %1, where %0 is the
  28  * "completely transparent" value while %1 is "fully opaque".
  29  *
  30  * Since: 1.0
  31  **/
  32
  33 /**
  34  * AdgColorStyle:
  35  *
  36  * All fields are private and should not be used directly.
  37  * Use its public methods instead.
  38  *
  39  * Since: 1.0
  40  **/
  41
  42
  43 #include "adg-internal.h"
  44 #include "adg-style.h"
  45 #include "adg-color-style.h"
  46
  47 #include "adg-color-style.h"
  48 #include "adg-color-style-private.h"
  49
  50
  51 G_DEFINE_TYPE(AdgColorStyle, adg_color_style, ADG_TYPE_STYLE)
  52
  53 enum {
  54     PROP_0,
  55     PROP_RED,
  56     PROP_GREEN,
  57     PROP_BLUE,
  58     PROP_ALPHA
  59 };
  60
  61
  62 static void             _adg_get_property       (GObject        *object,
  63                                                  guint           prop_id,
  64                                                  GValue         *value,
  65                                                  GParamSpec     *pspec);
  66 static void             _adg_set_property       (GObject        *object,
  67                                                  guint           prop_id,
  68                                                  const GValue   *value,
  69                                                  GParamSpec     *pspec);
  70 static void             _adg_apply              (AdgStyle       *style,
  71                                                  AdgEntity      *entity,
  72                                                  cairo_t        *cr);
  73
  74
  75 static void
  76 adg_color_style_class_init(AdgColorStyleClass *klass)
  77 {
  78     GObjectClass *gobject_class;
  79     AdgStyleClass *style_class;
  80     GParamSpec *param;
  81
  82     gobject_class = (GObjectClass *) klass;
  83     style_class = (AdgStyleClass *) klass;
  84
  85     g_type_class_add_private(klass, sizeof(AdgColorStylePrivate));
  86
  87     gobject_class->get_property = _adg_get_property;
  88     gobject_class->set_property = _adg_set_property;
  89
  90     style_class->apply = _adg_apply;
  91
  92     param = g_param_spec_double("red",
  93                                 P_("Red Channel"),
  94                                 P_("The red value, where 0 means no red and 1 is full red"),
  95                                 0, 1, 0,
  96                                 G_PARAM_READWRITE);
  97     g_object_class_install_property(gobject_class, PROP_RED, param);
  98
  99     param = g_param_spec_double("green",
 100                                 P_("Green Channel"),
 101                                 P_("The green value, where 0 means no green and 1 is full green"),
 102                                 0, 1, 0,
 103                                 G_PARAM_READWRITE);
 104     g_object_class_install_property(gobject_class, PROP_GREEN, param);
 105
 106     param = g_param_spec_double("blue",
 107                                 P_("Blue Channel"),
 108                                 P_("The blue value, where 0 means no blue and 1 is full blue"),
 109                                 0, 1, 0,
 110                                 G_PARAM_READWRITE);
 111     g_object_class_install_property(gobject_class, PROP_BLUE, param);
 112
 113     param = g_param_spec_double("alpha",
 114                                 P_("Alpha Channel"),
 115                                 P_("The alpha value, where 0 means completely transparent and 1 is fully opaque"),
 116                                 0, 1, 1,
 117                                 G_PARAM_READWRITE);
 118     g_object_class_install_property(gobject_class, PROP_ALPHA, param);
 119 }
 120
 121 static void
 122 adg_color_style_init(AdgColorStyle *color_style)
 123 {
 124     AdgColorStylePrivate *data = G_TYPE_INSTANCE_GET_PRIVATE(color_style,
 125                                                             ADG_TYPE_COLOR_STYLE,
 126                                                             AdgColorStylePrivate);
 127
 128     data->red = 0;
 129     data->green = 0;
 130     data->blue = 0;
 131     data->alpha = 1;
 132
 133     color_style->data = data;
 134 }
 135
 136 static void
 137 _adg_get_property(GObject *object, guint prop_id,
 138                   GValue *value, GParamSpec *pspec)
 139 {
 140     AdgColorStylePrivate *data = ((AdgColorStyle *) object)->data;
 141
 142     switch (prop_id) {
 143     case PROP_RED:
 144         g_value_set_double(value, data->red);
 145         break;
 146     case PROP_GREEN:
 147         g_value_set_double(value, data->green);
 148         break;
 149     case PROP_BLUE:
 150         g_value_set_double(value, data->blue);
 151         break;
 152     case PROP_ALPHA:
 153         g_value_set_double(value, data->alpha);
 154         break;
 155     default:
 156         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 157         break;
 158     }
 159 }
 160
 161 static void
 162 _adg_set_property(GObject *object, guint prop_id,
 163                   const GValue *value, GParamSpec *pspec)
 164 {
 165     AdgColorStylePrivate *data = ((AdgColorStyle *) object)->data;
 166
 167     switch (prop_id) {
 168     case PROP_RED:
 169         data->red = g_value_get_double(value);
 170         break;
 171     case PROP_GREEN:
 172         data->green = g_value_get_double(value);
 173         break;
 174     case PROP_BLUE:
 175         data->blue = g_value_get_double(value);
 176         break;
 177     case PROP_ALPHA:
 178         data->alpha = g_value_get_double(value);
 179         break;
 180     default:
 181         G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
 182         break;
 183     }
 184 }
 185
 186
 187 /**
 188  * adg_color_style_new:
 189  *
 190  * Constructs a new color initialized to opaque black.
 191  *
 192  * Returns: a new color style
 193  *
 194  * Since: 1.0
 195  **/
 196 AdgColorStyle *
 197 adg_color_style_new(void)
 198 {
 199     return g_object_new(ADG_TYPE_COLOR_STYLE, NULL);
 200 }
 201
 202 /**
 203  * adg_color_style_set_red:
 204  * @color_style: an #AdgColorStyle
 205  * @red: the new value
 206  *
 207  * Sets a new value for the red channel, where %0 means no red and
 208  * %1 is full red.
 209  *
 210  * Since: 1.0
 211  **/
 212 void
 213 adg_color_style_set_red(AdgColorStyle *color_style, gdouble red)
 214 {
 215     g_return_if_fail(ADG_IS_COLOR_STYLE(color_style));
 216     g_object_set(color_style, "red", red, NULL);
 217 }
 218
 219 /**
 220  * adg_color_style_get_red:
 221  * @color_style: an #AdgColorStyle
 222  *
 223  * Gets the current value of the red channel, where %0 means no red and
 224  * %1 is full red.
 225  *
 226  * Returns: the requested red value
 227  *
 228  * Since: 1.0
 229  **/
 230 gdouble
 231 adg_color_style_get_red(AdgColorStyle *color_style)
 232 {
 233     AdgColorStylePrivate *data;
 234
 235     g_return_val_if_fail(ADG_IS_COLOR_STYLE(color_style), 0.);
 236
 237     data = color_style->data;
 238
 239     return data->red;
 240 }
 241
 242 /**
 243  * adg_color_style_set_green:
 244  * @color_style: an #AdgColorStyle
 245  * @green: the new value
 246  *
 247  * Sets a new value for the green channel, where %0 means no green and
 248  * %1 is full green.
 249  *
 250  * Since: 1.0
 251  **/
 252 void
 253 adg_color_style_set_green(AdgColorStyle *color_style, gdouble green)
 254 {
 255     g_return_if_fail(ADG_IS_COLOR_STYLE(color_style));
 256     g_object_set(color_style, "green", green, NULL);
 257 }
 258
 259 /**
 260  * adg_color_style_get_green:
 261  * @color_style: an #AdgColorStyle
 262  *
 263  * Gets the current value of the green channel, where %0 means no green and
 264  * %1 is full green.
 265  *
 266  * Returns: the requested green value
 267  *
 268  * Since: 1.0
 269  **/
 270 gdouble
 271 adg_color_style_get_green(AdgColorStyle *color_style)
 272 {
 273     AdgColorStylePrivate *data;
 274
 275     g_return_val_if_fail(ADG_IS_COLOR_STYLE(color_style), 0.);
 276
 277     data = color_style->data;
 278
 279     return data->green;
 280 }
 281
 282 /**
 283  * adg_color_style_set_blue:
 284  * @color_style: an #AdgColorStyle
 285  * @blue: the new value
 286  *
 287  * Sets a new value for the blue channel, where %0 means no blue and
 288  * %1 is full blue.
 289  *
 290  * Since: 1.0
 291  **/
 292 void
 293 adg_color_style_set_blue(AdgColorStyle *color_style, gdouble blue)
 294 {
 295     g_return_if_fail(ADG_IS_COLOR_STYLE(color_style));
 296     g_object_set(color_style, "blue", blue, NULL);
 297 }
 298
 299 /**
 300  * adg_color_style_get_blue:
 301  * @color_style: an #AdgColorStyle
 302  *
 303  * Gets the current value of the blue channel, where %0 means no blue and
 304  * %1 is full blue.
 305  *
 306  * Returns: the requested blue value
 307  *
 308  * Since: 1.0
 309  **/
 310 gdouble
 311 adg_color_style_get_blue(AdgColorStyle *color_style)
 312 {
 313     AdgColorStylePrivate *data;
 314
 315     g_return_val_if_fail(ADG_IS_COLOR_STYLE(color_style), 0.);
 316
 317     data = color_style->data;
 318
 319     return data->blue;
 320 }
 321
 322 /**
 323  * adg_color_style_set_rgb:
 324  * @color_style: an #AdgColorStyle
 325  * @red: the red channel value
 326  * @green: the green channel value
 327  * @blue: the blue channel value
 328  *
 329  * Sets the RGB channels at once.
 330  *
 331  * Since: 1.0
 332  **/
 333 void
 334 adg_color_style_set_rgb(AdgColorStyle *color_style,
 335                         gdouble red, gdouble green, gdouble blue)
 336 {
 337     g_return_if_fail(ADG_IS_COLOR_STYLE(color_style));
 338     g_object_set(color_style, "red", red, "green", green, "blue", blue, NULL);
 339 }
 340
 341 /**
 342  * adg_color_style_put_rgb:
 343  * @color_style: an #AdgColorStyle
 344  * @red: where to store the red channel value
 345  * @green: where to store the green channel value
 346  * @blue: where to store the blue channel value
 347  *
 348  * Gets the values of the red, green and blue channels of @color_style.
 349  * Any of the pointer can be %NULL, in which case the value is not returned.
 350  *
 351  * Since: 1.0
 352  **/
 353 void
 354 adg_color_style_put_rgb(AdgColorStyle *color_style,
 355                         gdouble *red, gdouble *green, gdouble *blue)
 356 {
 357     AdgColorStylePrivate *data;
 358
 359     g_return_if_fail(ADG_IS_COLOR_STYLE(color_style));
 360
 361     data = color_style->data;
 362
 363     if (red != NULL)
 364         *red = data->red;
 365
 366     if (green != NULL)
 367         *green = data->green;
 368
 369     if (blue != NULL)
 370         *blue = data->blue;
 371 }
 372
 373 /**
 374  * adg_color_style_set_alpha:
 375  * @color_style: an #AdgColorStyle
 376  * @alpha: the new alpha
 377  *
 378  * Sets a new color alpha value, where %0 means completely transparent
 379  * and %1 is fully opaque.
 380  *
 381  * Since: 1.0
 382  **/
 383 void
 384 adg_color_style_set_alpha(AdgColorStyle *color_style, gdouble alpha)
 385 {
 386     g_return_if_fail(ADG_IS_COLOR_STYLE(color_style));
 387     g_object_set(color_style, "alpha", alpha, NULL);
 388 }
 389
 390 /**
 391  * adg_color_style_get_alpha:
 392  * @color_style: an #AdgColorStyle
 393  *
 394  * Gets the alpha channel value, where %0 means completely transparent
 395  * and %1 is fully opaque.
 396  *
 397  * Returns: the requested alpha value
 398  *
 399  * Since: 1.0
 400  **/
 401 gdouble
 402 adg_color_style_get_alpha(AdgColorStyle *color_style)
 403 {
 404     AdgColorStylePrivate *data;
 405
 406     g_return_val_if_fail(ADG_IS_COLOR_STYLE(color_style), 0.);
 407
 408     data = color_style->data;
 409
 410     return data->alpha;
 411 }
 412
 413
 414 static void
 415 _adg_apply(AdgStyle *style, AdgEntity *entity, cairo_t *cr)
 416 {
 417     AdgColorStylePrivate *data = ((AdgColorStyle *) style)->data;
 418
 419     if (data->alpha == 1.)
 420         cairo_set_source_rgb(cr, data->red, data->green, data->blue);
 421     else
 422         cairo_set_source_rgba(cr, data->red, data->green, data->blue,
 423                               data->alpha);
 424 }