Pileus Git - ~andy/gtk/blob - gtk/gtksymboliccolor.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2010 Carlos Garnacho <carlosg@gnome.org>
   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, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "config.h"
  19 #include "gtkcssrgbavalueprivate.h"
  20 #include "gtkcssstylepropertyprivate.h"
  21 #include "gtkhslaprivate.h"
  22 #include "gtkstylepropertyprivate.h"
  23 #include "gtksymboliccolorprivate.h"
  24 #include "gtkstyleproperties.h"
  25 #include "gtkintl.h"
  26 #include "gtkwin32themeprivate.h"
  27
  28 /**
  29  * SECTION:gtksymboliccolor
  30  * @Short_description: Symbolic colors
  31  * @Title: GtkSymbolicColor
  32  *
  33  * GtkSymbolicColor is a boxed type that represents a symbolic color.
  34  * It is the result of parsing a
  35  * <link linkend="gtkcssprovider-symbolic-colors">color expression</link>.
  36  * To obtain the color represented by a GtkSymbolicColor, it has to
  37  * be resolved with gtk_symbolic_color_resolve(), which replaces all
  38  * symbolic color references by the colors they refer to (in a given
  39  * context) and evaluates mix, shade and other expressions, resulting
  40  * in a #GdkRGBA value.
  41  *
  42  * It is not normally necessary to deal directly with #GtkSymbolicColors,
  43  * since they are mostly used behind the scenes by #GtkStyleContext and
  44  * #GtkCssProvider.
  45  */
  46
  47 G_DEFINE_BOXED_TYPE (GtkSymbolicColor, gtk_symbolic_color,
  48                      gtk_symbolic_color_ref, gtk_symbolic_color_unref)
  49
  50 /* Symbolic colors */
  51 typedef enum {
  52   COLOR_TYPE_LITERAL,
  53   COLOR_TYPE_NAME,
  54   COLOR_TYPE_SHADE,
  55   COLOR_TYPE_ALPHA,
  56   COLOR_TYPE_MIX,
  57   COLOR_TYPE_WIN32,
  58   COLOR_TYPE_CURRENT_COLOR
  59 } ColorType;
  60
  61 struct _GtkSymbolicColor
  62 {
  63   GTK_CSS_VALUE_BASE
  64   ColorType type;
  65   GtkCssValue *last_value;
  66
  67   union
  68   {
  69     gchar *name;
  70
  71     struct
  72     {
  73       GtkSymbolicColor *color;
  74       gdouble factor;
  75     } shade, alpha;
  76
  77     struct
  78     {
  79       GtkSymbolicColor *color1;
  80       GtkSymbolicColor *color2;
  81       gdouble factor;
  82     } mix;
  83
  84     struct
  85     {
  86       gchar *theme_class;
  87       gint id;
  88     } win32;
  89   } sym_col;
  90 };
  91
  92 static void
  93 gtk_css_value_symbolic_free (GtkCssValue *value)
  94 {
  95   GtkSymbolicColor *color = (GtkSymbolicColor *) value;
  96
  97   _gtk_css_value_unref (color->last_value);
  98   switch (color->type)
  99     {
 100     case COLOR_TYPE_NAME:
 101       g_free (color->sym_col.name);
 102       break;
 103     case COLOR_TYPE_SHADE:
 104       gtk_symbolic_color_unref (color->sym_col.shade.color);
 105       break;
 106     case COLOR_TYPE_ALPHA:
 107       gtk_symbolic_color_unref (color->sym_col.alpha.color);
 108       break;
 109     case COLOR_TYPE_MIX:
 110       gtk_symbolic_color_unref (color->sym_col.mix.color1);
 111       gtk_symbolic_color_unref (color->sym_col.mix.color2);
 112       break;
 113     case COLOR_TYPE_WIN32:
 114       g_free (color->sym_col.win32.theme_class);
 115       break;
 116     default:
 117       break;
 118     }
 119
 120   g_slice_free (GtkSymbolicColor, color);
 121 }
 122
 123 static GtkCssValue *
 124 gtk_css_value_symbolic_get_fallback (guint                    property_id,
 125                                      GtkStyleProviderPrivate *provider,
 126                                      GtkCssComputedValues    *values,
 127                                      GtkCssComputedValues    *parent_values)
 128 {
 129   static const GdkRGBA transparent = { 0, 0, 0, 0 };
 130
 131   switch (property_id)
 132     {
 133       case GTK_CSS_PROPERTY_BACKGROUND_IMAGE:
 134       case GTK_CSS_PROPERTY_BORDER_IMAGE_SOURCE:
 135       case GTK_CSS_PROPERTY_TEXT_SHADOW:
 136       case GTK_CSS_PROPERTY_ICON_SHADOW:
 137       case GTK_CSS_PROPERTY_BOX_SHADOW:
 138         return _gtk_css_rgba_value_new_from_rgba (&transparent);
 139       case GTK_CSS_PROPERTY_COLOR:
 140       case GTK_CSS_PROPERTY_BACKGROUND_COLOR:
 141       case GTK_CSS_PROPERTY_BORDER_TOP_COLOR:
 142       case GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR:
 143       case GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR:
 144       case GTK_CSS_PROPERTY_BORDER_LEFT_COLOR:
 145       case GTK_CSS_PROPERTY_OUTLINE_COLOR:
 146         return _gtk_css_value_compute (_gtk_css_style_property_get_initial_value (_gtk_css_style_property_lookup_by_id (property_id)),
 147                                        property_id,
 148                                        provider,
 149                                        values,
 150                                        parent_values,
 151                                        NULL);
 152       default:
 153         if (property_id < GTK_CSS_PROPERTY_N_PROPERTIES)
 154           g_warning ("No fallback color defined for property '%s'",
 155                      _gtk_style_property_get_name (GTK_STYLE_PROPERTY (_gtk_css_style_property_lookup_by_id (property_id))));
 156         return _gtk_css_rgba_value_new_from_rgba (&transparent);
 157     }
 158 }
 159
 160 static GtkCssValue *
 161 gtk_css_value_symbolic_compute (GtkCssValue             *value,
 162                                 guint                    property_id,
 163                                 GtkStyleProviderPrivate *provider,
 164                                 GtkCssComputedValues    *values,
 165                                 GtkCssComputedValues    *parent_values,
 166                                 GtkCssDependencies      *dependencies)
 167 {
 168   GtkCssValue *resolved, *current;
 169   GtkCssDependencies current_deps;
 170
 171   /* The computed value of the ‘currentColor’ keyword is the computed
 172    * value of the ‘color’ property. If the ‘currentColor’ keyword is
 173    * set on the ‘color’ property itself, it is treated as ‘color: inherit’.
 174    */
 175   if (property_id == GTK_CSS_PROPERTY_COLOR)
 176     {
 177       if (parent_values)
 178         {
 179           current = _gtk_css_computed_values_get_value (parent_values, GTK_CSS_PROPERTY_COLOR);
 180           current_deps = GTK_CSS_EQUALS_PARENT;
 181         }
 182       else
 183         {
 184           current = _gtk_css_style_property_get_initial_value (_gtk_css_style_property_lookup_by_id (GTK_CSS_PROPERTY_COLOR));
 185           current_deps = 0;
 186         }
 187     }
 188   else
 189     {
 190       current = _gtk_css_computed_values_get_value (values, GTK_CSS_PROPERTY_COLOR);
 191       current_deps = GTK_CSS_DEPENDS_ON_COLOR;
 192     }
 193
 194   resolved = _gtk_symbolic_color_resolve_full ((GtkSymbolicColor *) value,
 195                                                provider,
 196                                                current,
 197                                                current_deps,
 198                                                dependencies);
 199
 200   if (resolved == NULL)
 201     return gtk_css_value_symbolic_get_fallback (property_id, provider, values, parent_values);
 202
 203   return resolved;
 204 }
 205
 206 static gboolean
 207 gtk_css_value_symbolic_equal (const GtkCssValue *value1,
 208                               const GtkCssValue *value2)
 209 {
 210   GtkSymbolicColor *color1 = (GtkSymbolicColor *) value1;
 211   GtkSymbolicColor *color2 = (GtkSymbolicColor *) value2;
 212
 213   if (color1->type != color2->type)
 214     return FALSE;
 215
 216   switch (color1->type)
 217     {
 218     case COLOR_TYPE_LITERAL:
 219       return _gtk_css_value_equal (color1->last_value, color2->last_value);
 220     case COLOR_TYPE_NAME:
 221       return g_str_equal (color1->sym_col.name, color2->sym_col.name);
 222     case COLOR_TYPE_SHADE:
 223       return color1->sym_col.shade.factor == color2->sym_col.shade.factor &&
 224              _gtk_css_value_equal ((GtkCssValue *) color1->sym_col.shade.color,
 225                                    (GtkCssValue *) color2->sym_col.shade.color);
 226     case COLOR_TYPE_ALPHA:
 227       return color1->sym_col.alpha.factor == color2->sym_col.alpha.factor &&
 228              _gtk_css_value_equal ((GtkCssValue *) color1->sym_col.alpha.color,
 229                                    (GtkCssValue *) color2->sym_col.alpha.color);
 230     case COLOR_TYPE_MIX:
 231       return color1->sym_col.mix.factor == color2->sym_col.mix.factor &&
 232              _gtk_css_value_equal ((GtkCssValue *) color1->sym_col.mix.color1,
 233                                    (GtkCssValue *) color2->sym_col.mix.color1) &&
 234              _gtk_css_value_equal ((GtkCssValue *) color1->sym_col.mix.color2,
 235                                    (GtkCssValue *) color2->sym_col.mix.color2);
 236     case COLOR_TYPE_WIN32:
 237       return g_str_equal (color1->sym_col.win32.theme_class, color2->sym_col.win32.theme_class) &&
 238              color1->sym_col.win32.id == color2->sym_col.win32.id;
 239     case COLOR_TYPE_CURRENT_COLOR:
 240       return TRUE;
 241     default:
 242       g_assert_not_reached ();
 243       return FALSE;
 244     }
 245 }
 246
 247 static GtkCssValue *
 248 gtk_css_value_symbolic_transition (GtkCssValue *start,
 249                                    GtkCssValue *end,
 250                                    guint        property_id,
 251                                    double       progress)
 252 {
 253   return (GtkCssValue *) gtk_symbolic_color_new_mix ((GtkSymbolicColor *) start,
 254                                                      (GtkSymbolicColor *) end,
 255                                                      progress);
 256 }
 257
 258 static void
 259 gtk_css_value_symbolic_print (const GtkCssValue *value,
 260                               GString           *string)
 261 {
 262   GtkSymbolicColor *color = (GtkSymbolicColor *) value;
 263   char *s;
 264
 265   s = gtk_symbolic_color_to_string (color);
 266   g_string_append (string, s);
 267   g_free (s);
 268 }
 269
 270 static const GtkCssValueClass GTK_CSS_VALUE_SYMBOLIC = {
 271   gtk_css_value_symbolic_free,
 272   gtk_css_value_symbolic_compute,
 273   gtk_css_value_symbolic_equal,
 274   gtk_css_value_symbolic_transition,
 275   gtk_css_value_symbolic_print
 276 };
 277
 278 /**
 279  * gtk_symbolic_color_new_literal:
 280  * @color: a #GdkRGBA
 281  *
 282  * Creates a symbolic color pointing to a literal color.
 283  *
 284  * Returns: a newly created #GtkSymbolicColor
 285  *
 286  * Since: 3.0
 287  **/
 288 GtkSymbolicColor *
 289 gtk_symbolic_color_new_literal (const GdkRGBA *color)
 290 {
 291   GtkSymbolicColor *symbolic_color;
 292
 293   g_return_val_if_fail (color != NULL, NULL);
 294
 295   symbolic_color = _gtk_css_value_new (GtkSymbolicColor, &GTK_CSS_VALUE_SYMBOLIC);
 296   symbolic_color->type = COLOR_TYPE_LITERAL;
 297   symbolic_color->last_value = _gtk_css_rgba_value_new_from_rgba (color);
 298
 299   return symbolic_color;
 300 }
 301
 302 /**
 303  * gtk_symbolic_color_new_name:
 304  * @name: color name
 305  *
 306  * Creates a symbolic color pointing to an unresolved named
 307  * color. See gtk_style_context_lookup_color() and
 308  * gtk_style_properties_lookup_color().
 309  *
 310  * Returns: a newly created #GtkSymbolicColor
 311  *
 312  * Since: 3.0
 313  **/
 314 GtkSymbolicColor *
 315 gtk_symbolic_color_new_name (const gchar *name)
 316 {
 317   GtkSymbolicColor *symbolic_color;
 318
 319   g_return_val_if_fail (name != NULL, NULL);
 320
 321   symbolic_color = _gtk_css_value_new (GtkSymbolicColor, &GTK_CSS_VALUE_SYMBOLIC);
 322   symbolic_color->type = COLOR_TYPE_NAME;
 323   symbolic_color->sym_col.name = g_strdup (name);
 324
 325   return symbolic_color;
 326 }
 327
 328 /**
 329  * gtk_symbolic_color_new_shade: (constructor)
 330  * @color: another #GtkSymbolicColor
 331  * @factor: shading factor to apply to @color
 332  *
 333  * Creates a symbolic color defined as a shade of
 334  * another color. A factor > 1.0 would resolve to
 335  * a brighter color, while < 1.0 would resolve to
 336  * a darker color.
 337  *
 338  * Returns: A newly created #GtkSymbolicColor
 339  *
 340  * Since: 3.0
 341  **/
 342 GtkSymbolicColor *
 343 gtk_symbolic_color_new_shade (GtkSymbolicColor *color,
 344                               gdouble           factor)
 345 {
 346   GtkSymbolicColor *symbolic_color;
 347
 348   g_return_val_if_fail (color != NULL, NULL);
 349
 350   symbolic_color = _gtk_css_value_new (GtkSymbolicColor, &GTK_CSS_VALUE_SYMBOLIC);
 351   symbolic_color->type = COLOR_TYPE_SHADE;
 352   symbolic_color->sym_col.shade.color = gtk_symbolic_color_ref (color);
 353   symbolic_color->sym_col.shade.factor = factor;
 354
 355   return symbolic_color;
 356 }
 357
 358 /**
 359  * gtk_symbolic_color_new_alpha: (constructor)
 360  * @color: another #GtkSymbolicColor
 361  * @factor: factor to apply to @color alpha
 362  *
 363  * Creates a symbolic color by modifying the relative alpha
 364  * value of @color. A factor < 1.0 would resolve to a more
 365  * transparent color, while > 1.0 would resolve to a more
 366  * opaque color.
 367  *
 368  * Returns: A newly created #GtkSymbolicColor
 369  *
 370  * Since: 3.0
 371  **/
 372 GtkSymbolicColor *
 373 gtk_symbolic_color_new_alpha (GtkSymbolicColor *color,
 374                               gdouble           factor)
 375 {
 376   GtkSymbolicColor *symbolic_color;
 377
 378   g_return_val_if_fail (color != NULL, NULL);
 379
 380   symbolic_color = _gtk_css_value_new (GtkSymbolicColor, &GTK_CSS_VALUE_SYMBOLIC);
 381   symbolic_color->type = COLOR_TYPE_ALPHA;
 382   symbolic_color->sym_col.alpha.color = gtk_symbolic_color_ref (color);
 383   symbolic_color->sym_col.alpha.factor = factor;
 384
 385   return symbolic_color;
 386 }
 387
 388 /**
 389  * gtk_symbolic_color_new_mix: (constructor)
 390  * @color1: color to mix
 391  * @color2: another color to mix
 392  * @factor: mix factor
 393  *
 394  * Creates a symbolic color defined as a mix of another
 395  * two colors. a mix factor of 0 would resolve to @color1,
 396  * while a factor of 1 would resolve to @color2.
 397  *
 398  * Returns: A newly created #GtkSymbolicColor
 399  *
 400  * Since: 3.0
 401  **/
 402 GtkSymbolicColor *
 403 gtk_symbolic_color_new_mix (GtkSymbolicColor *color1,
 404                             GtkSymbolicColor *color2,
 405                             gdouble           factor)
 406 {
 407   GtkSymbolicColor *symbolic_color;
 408
 409   g_return_val_if_fail (color1 != NULL, NULL);
 410   g_return_val_if_fail (color1 != NULL, NULL);
 411
 412   symbolic_color = _gtk_css_value_new (GtkSymbolicColor, &GTK_CSS_VALUE_SYMBOLIC);
 413   symbolic_color->type = COLOR_TYPE_MIX;
 414   symbolic_color->sym_col.mix.color1 = gtk_symbolic_color_ref (color1);
 415   symbolic_color->sym_col.mix.color2 = gtk_symbolic_color_ref (color2);
 416   symbolic_color->sym_col.mix.factor = factor;
 417
 418   return symbolic_color;
 419 }
 420
 421 /**
 422  * gtk_symbolic_color_new_win32: (constructor)
 423  * @theme_class: The theme class to pull color from
 424  * @id: The color id
 425  *
 426  * Creates a symbolic color based on the current win32
 427  * theme.
 428  *
 429  * Note that while this call is available on all platforms
 430  * the actual value returned is not reliable on non-win32
 431  * platforms.
 432  *
 433  * Returns: A newly created #GtkSymbolicColor
 434  *
 435  * Since: 3.4
 436  */
 437 GtkSymbolicColor *
 438 gtk_symbolic_color_new_win32 (const gchar *theme_class,
 439                               gint         id)
 440 {
 441   GtkSymbolicColor *symbolic_color;
 442
 443   g_return_val_if_fail (theme_class != NULL, NULL);
 444
 445   symbolic_color = _gtk_css_value_new (GtkSymbolicColor, &GTK_CSS_VALUE_SYMBOLIC);
 446   symbolic_color->type = COLOR_TYPE_WIN32;
 447   symbolic_color->sym_col.win32.theme_class = g_strdup (theme_class);
 448   symbolic_color->sym_col.win32.id = id;
 449
 450   return symbolic_color;
 451 }
 452
 453 /**
 454  * _gtk_symbolic_color_get_current_color:
 455  *
 456  * Gets the color representing the CSS 'currentColor' keyword.
 457  * This color will resolve to the color set for the color property.
 458  *
 459  * Returns: (transfer none): The singleton representing the
 460  *     'currentColor' keyword
 461  **/
 462 GtkSymbolicColor *
 463 _gtk_symbolic_color_get_current_color (void)
 464 {
 465   static GtkSymbolicColor *current_color = NULL;
 466
 467   if (G_UNLIKELY (current_color == NULL))
 468     {
 469       current_color = _gtk_css_value_new (GtkSymbolicColor, &GTK_CSS_VALUE_SYMBOLIC);
 470       current_color->type = COLOR_TYPE_CURRENT_COLOR;
 471     }
 472
 473   return current_color;
 474 }
 475
 476 /**
 477  * gtk_symbolic_color_ref:
 478  * @color: a #GtkSymbolicColor
 479  *
 480  * Increases the reference count of @color
 481  *
 482  * Returns: the same @color
 483  *
 484  * Since: 3.0
 485  **/
 486 GtkSymbolicColor *
 487 gtk_symbolic_color_ref (GtkSymbolicColor *color)
 488 {
 489   g_return_val_if_fail (color != NULL, NULL);
 490
 491   _gtk_css_value_ref ((GtkCssValue *) color);
 492
 493   return color;
 494 }
 495
 496 /**
 497  * gtk_symbolic_color_unref:
 498  * @color: a #GtkSymbolicColor
 499  *
 500  * Decreases the reference count of @color, freeing its memory if the
 501  * reference count reaches 0.
 502  *
 503  * Since: 3.0
 504  **/
 505 void
 506 gtk_symbolic_color_unref (GtkSymbolicColor *color)
 507 {
 508   g_return_if_fail (color != NULL);
 509
 510   _gtk_css_value_unref ((GtkCssValue *) color);
 511 }
 512
 513 static void
 514 _shade_color (GdkRGBA *color,
 515               gdouble  factor)
 516 {
 517   GtkHSLA hsla;
 518
 519   _gtk_hsla_init_from_rgba (&hsla, color);
 520
 521   hsla.lightness *= factor;
 522   hsla.lightness = CLAMP (hsla.lightness, 0.0, 1.0);
 523
 524   hsla.saturation *= factor;
 525   hsla.saturation = CLAMP (hsla.saturation, 0.0, 1.0);
 526
 527   _gdk_rgba_init_from_hsla (color, &hsla);
 528 }
 529
 530 /**
 531  * gtk_symbolic_color_resolve:
 532  * @color: a #GtkSymbolicColor
 533  * @props: (allow-none): #GtkStyleProperties to use when resolving
 534  *    named colors, or %NULL
 535  * @resolved_color: (out): return location for the resolved color
 536  *
 537  * If @color is resolvable, @resolved_color will be filled in
 538  * with the resolved color, and %TRUE will be returned. Generally,
 539  * if @color can't be resolved, it is due to it being defined on
 540  * top of a named color that doesn't exist in @props.
 541  *
 542  * When @props is %NULL, resolving of named colors will fail, so if
 543  * your @color is or references such a color, this function will
 544  * return %FALSE.
 545  *
 546  * Returns: %TRUE if the color has been resolved
 547  *
 548  * Since: 3.0
 549  **/
 550 gboolean
 551 gtk_symbolic_color_resolve (GtkSymbolicColor   *color,
 552                             GtkStyleProperties *props,
 553                             GdkRGBA            *resolved_color)
 554 {
 555   GdkRGBA pink = { 1.0, 0.5, 0.5, 1.0 };
 556   GtkCssValue *v, *current;
 557
 558   g_return_val_if_fail (color != NULL, FALSE);
 559   g_return_val_if_fail (resolved_color != NULL, FALSE);
 560   g_return_val_if_fail (props == NULL || GTK_IS_STYLE_PROPERTIES (props), FALSE);
 561
 562   current = _gtk_css_rgba_value_new_from_rgba (&pink);
 563   v =_gtk_symbolic_color_resolve_full (color,
 564                                        GTK_STYLE_PROVIDER_PRIVATE (props),
 565                                        current,
 566                                        0,
 567                                        NULL);
 568   _gtk_css_value_unref (current);
 569   if (v == NULL)
 570     return FALSE;
 571
 572   *resolved_color = *_gtk_css_rgba_value_get_rgba (v);
 573   _gtk_css_value_unref (v);
 574   return TRUE;
 575 }
 576
 577 GtkCssValue *
 578 _gtk_symbolic_color_resolve_full (GtkSymbolicColor        *color,
 579                                   GtkStyleProviderPrivate *provider,
 580                                   GtkCssValue             *current,
 581                                   GtkCssDependencies       current_deps,
 582                                   GtkCssDependencies      *dependencies)
 583 {
 584   GtkCssDependencies unused;
 585   GtkCssValue *value;
 586
 587   g_return_val_if_fail (color != NULL, FALSE);
 588   g_return_val_if_fail (provider == NULL || GTK_IS_STYLE_PROVIDER_PRIVATE (provider), FALSE);
 589   g_return_val_if_fail (current != NULL, FALSE);
 590
 591   if (dependencies == NULL)
 592     dependencies = &unused;
 593   *dependencies = 0;
 594
 595   value = NULL;
 596   switch (color->type)
 597     {
 598     case COLOR_TYPE_LITERAL:
 599       return _gtk_css_value_ref (color->last_value);
 600     case COLOR_TYPE_NAME:
 601       {
 602         GtkSymbolicColor *named_color;
 603
 604         named_color = _gtk_style_provider_private_get_color (provider, color->sym_col.name);
 605
 606         if (!named_color)
 607           return NULL;
 608
 609         return _gtk_symbolic_color_resolve_full (named_color, provider, current, current_deps, dependencies);
 610       }
 611
 612       break;
 613     case COLOR_TYPE_SHADE:
 614       {
 615         GtkCssValue *val;
 616         GdkRGBA shade;
 617
 618         val = _gtk_symbolic_color_resolve_full (color->sym_col.shade.color, provider, current, current_deps, dependencies);
 619         if (val == NULL)
 620           return NULL;
 621
 622         *dependencies = _gtk_css_dependencies_union (*dependencies, 0);
 623         shade = *_gtk_css_rgba_value_get_rgba (val);
 624         _shade_color (&shade, color->sym_col.shade.factor);
 625
 626         _gtk_css_value_unref (val);
 627
 628         value = _gtk_css_rgba_value_new_from_rgba (&shade);
 629       }
 630
 631       break;
 632     case COLOR_TYPE_ALPHA:
 633       {
 634         GtkCssValue *val;
 635         GdkRGBA alpha;
 636
 637         val = _gtk_symbolic_color_resolve_full (color->sym_col.alpha.color, provider, current, current_deps, dependencies);
 638         if (val == NULL)
 639           return NULL;
 640
 641         *dependencies = _gtk_css_dependencies_union (*dependencies, 0);
 642         alpha = *_gtk_css_rgba_value_get_rgba (val);
 643         alpha.alpha = CLAMP (alpha.alpha * color->sym_col.alpha.factor, 0, 1);
 644
 645         _gtk_css_value_unref (val);
 646
 647         value = _gtk_css_rgba_value_new_from_rgba (&alpha);
 648       }
 649       break;
 650
 651     case COLOR_TYPE_MIX:
 652       {
 653         GtkCssValue *val;
 654         GdkRGBA color1, color2, res;
 655         GtkCssDependencies dep1, dep2;
 656
 657         val = _gtk_symbolic_color_resolve_full (color->sym_col.mix.color1, provider, current, current_deps, &dep1);
 658         if (val == NULL)
 659           return NULL;
 660         color1 = *_gtk_css_rgba_value_get_rgba (val);
 661         _gtk_css_value_unref (val);
 662
 663         val = _gtk_symbolic_color_resolve_full (color->sym_col.mix.color2, provider, current, current_deps, &dep2);
 664         if (val == NULL)
 665           return NULL;
 666         color2 = *_gtk_css_rgba_value_get_rgba (val);
 667         _gtk_css_value_unref (val);
 668
 669         *dependencies = _gtk_css_dependencies_union (dep1, dep2);
 670         res.red = CLAMP (color1.red + ((color2.red - color1.red) * color->sym_col.mix.factor), 0, 1);
 671         res.green = CLAMP (color1.green + ((color2.green - color1.green) * color->sym_col.mix.factor), 0, 1);
 672         res.blue = CLAMP (color1.blue + ((color2.blue - color1.blue) * color->sym_col.mix.factor), 0, 1);
 673         res.alpha = CLAMP (color1.alpha + ((color2.alpha - color1.alpha) * color->sym_col.mix.factor), 0, 1);
 674
 675         value =_gtk_css_rgba_value_new_from_rgba (&res);
 676       }
 677
 678       break;
 679     case COLOR_TYPE_WIN32:
 680       {
 681         GdkRGBA res;
 682
 683         if (!_gtk_win32_theme_color_resolve (color->sym_col.win32.theme_class,
 684                                              color->sym_col.win32.id,
 685                                              &res))
 686           return NULL;
 687
 688         value = _gtk_css_rgba_value_new_from_rgba (&res);
 689       }
 690
 691       break;
 692     case COLOR_TYPE_CURRENT_COLOR:
 693       if (current)
 694         {
 695           *dependencies = current_deps;
 696           return _gtk_css_value_ref (current);
 697         }
 698       else
 699         {
 700           return NULL;
 701         }
 702       break;
 703     default:
 704       g_assert_not_reached ();
 705     }
 706
 707   if (value != NULL)
 708     {
 709       if (color->last_value != NULL &&
 710           _gtk_css_value_equal (color->last_value, value))
 711         {
 712           _gtk_css_value_unref (value);
 713           value = _gtk_css_value_ref (color->last_value);
 714         }
 715       else
 716         {
 717           if (color->last_value != NULL)
 718             _gtk_css_value_unref (color->last_value);
 719           color->last_value = _gtk_css_value_ref (value);
 720         }
 721     }
 722
 723   _gtk_css_rgba_value_get_rgba (value);
 724   return value;
 725 }
 726
 727 /**
 728  * gtk_symbolic_color_to_string:
 729  * @color: color to convert to a string
 730  *
 731  * Converts the given @color to a string representation. This is useful
 732  * both for debugging and for serialization of strings. The format of
 733  * the string may change between different versions of GTK, but it is
 734  * guaranteed that the GTK css parser is able to read the string and
 735  * create the same symbolic color from it.
 736  *
 737  * Returns: a new string representing @color
 738  **/
 739 char *
 740 gtk_symbolic_color_to_string (GtkSymbolicColor *color)
 741 {
 742   char *s;
 743
 744   g_return_val_if_fail (color != NULL, NULL);
 745
 746   switch (color->type)
 747     {
 748     case COLOR_TYPE_LITERAL:
 749       s = gdk_rgba_to_string (_gtk_css_rgba_value_get_rgba (color->last_value));
 750       break;
 751     case COLOR_TYPE_NAME:
 752       s = g_strconcat ("@", color->sym_col.name, NULL);
 753       break;
 754     case COLOR_TYPE_SHADE:
 755       {
 756         char *color_string = gtk_symbolic_color_to_string (color->sym_col.shade.color);
 757         char factor[G_ASCII_DTOSTR_BUF_SIZE];
 758
 759         g_ascii_dtostr (factor, sizeof (factor), color->sym_col.shade.factor);
 760         s = g_strdup_printf ("shade(%s, %s)", color_string, factor);
 761         g_free (color_string);
 762       }
 763       break;
 764     case COLOR_TYPE_ALPHA:
 765       {
 766         char *color_string = gtk_symbolic_color_to_string (color->sym_col.shade.color);
 767         char factor[G_ASCII_DTOSTR_BUF_SIZE];
 768
 769         g_ascii_dtostr (factor, sizeof (factor), color->sym_col.alpha.factor);
 770         s = g_strdup_printf ("alpha(%s, %s)", color_string, factor);
 771         g_free (color_string);
 772       }
 773       break;
 774     case COLOR_TYPE_MIX:
 775       {
 776         char *color_string1 = gtk_symbolic_color_to_string (color->sym_col.mix.color1);
 777         char *color_string2 = gtk_symbolic_color_to_string (color->sym_col.mix.color2);
 778         char factor[G_ASCII_DTOSTR_BUF_SIZE];
 779
 780         g_ascii_dtostr (factor, sizeof (factor), color->sym_col.mix.factor);
 781         s = g_strdup_printf ("mix(%s, %s, %s)", color_string1, color_string2, factor);
 782         g_free (color_string1);
 783         g_free (color_string2);
 784       }
 785       break;
 786     case COLOR_TYPE_WIN32:
 787       {
 788         s = g_strdup_printf (GTK_WIN32_THEME_SYMBOLIC_COLOR_NAME"(%s, %d)",
 789                              color->sym_col.win32.theme_class, color->sym_col.win32.id);
 790       }
 791       break;
 792     case COLOR_TYPE_CURRENT_COLOR:
 793       s = g_strdup ("currentColor");
 794       break;
 795     default:
 796       g_assert_not_reached ();
 797     }
 798
 799   return s;
 800 }
 801
 802 typedef enum {
 803   COLOR_RGBA,
 804   COLOR_RGB,
 805   COLOR_LIGHTER,
 806   COLOR_DARKER,
 807   COLOR_SHADE,
 808   COLOR_ALPHA,
 809   COLOR_MIX,
 810   COLOR_WIN32
 811 } ColorParseType;
 812
 813 static GtkSymbolicColor * gtk_css_parser_read_symbolic_color (GtkCssParser *parser);
 814
 815 static GtkSymbolicColor *
 816 gtk_css_parser_read_symbolic_color_function (GtkCssParser   *parser,
 817                                              ColorParseType  color)
 818 {
 819   GtkSymbolicColor *symbolic;
 820   GtkSymbolicColor *child1, *child2;
 821   double value;
 822
 823   if (!_gtk_css_parser_try (parser, "(", TRUE))
 824     {
 825       _gtk_css_parser_error (parser, "Missing opening bracket in color definition");
 826       return NULL;
 827     }
 828
 829   if (color == COLOR_RGB || color == COLOR_RGBA)
 830     {
 831       GdkRGBA rgba;
 832       double tmp;
 833       guint i;
 834
 835       for (i = 0; i < 3; i++)
 836         {
 837           if (i > 0 && !_gtk_css_parser_try (parser, ",", TRUE))
 838             {
 839               _gtk_css_parser_error (parser, "Expected ',' in color definition");
 840               return NULL;
 841             }
 842
 843           if (!_gtk_css_parser_try_double (parser, &tmp))
 844             {
 845               _gtk_css_parser_error (parser, "Invalid number for color value");
 846               return NULL;
 847             }
 848           if (_gtk_css_parser_try (parser, "%", TRUE))
 849             tmp /= 100.0;
 850           else
 851             tmp /= 255.0;
 852           if (i == 0)
 853             rgba.red = tmp;
 854           else if (i == 1)
 855             rgba.green = tmp;
 856           else if (i == 2)
 857             rgba.blue = tmp;
 858           else
 859             g_assert_not_reached ();
 860         }
 861
 862       if (color == COLOR_RGBA)
 863         {
 864           if (i > 0 && !_gtk_css_parser_try (parser, ",", TRUE))
 865             {
 866               _gtk_css_parser_error (parser, "Expected ',' in color definition");
 867               return NULL;
 868             }
 869
 870           if (!_gtk_css_parser_try_double (parser, &rgba.alpha))
 871             {
 872               _gtk_css_parser_error (parser, "Invalid number for alpha value");
 873               return NULL;
 874             }
 875         }
 876       else
 877         rgba.alpha = 1.0;
 878
 879       symbolic = gtk_symbolic_color_new_literal (&rgba);
 880     }
 881   else if (color == COLOR_WIN32)
 882     {
 883       symbolic = _gtk_win32_theme_color_parse (parser);
 884       if (symbolic == NULL)
 885         return NULL;
 886     }
 887   else
 888     {
 889       child1 = gtk_css_parser_read_symbolic_color (parser);
 890       if (child1 == NULL)
 891         return NULL;
 892
 893       if (color == COLOR_MIX)
 894         {
 895           if (!_gtk_css_parser_try (parser, ",", TRUE))
 896             {
 897               _gtk_css_parser_error (parser, "Expected ',' in color definition");
 898               gtk_symbolic_color_unref (child1);
 899               return NULL;
 900             }
 901
 902           child2 = gtk_css_parser_read_symbolic_color (parser);
 903           if (child2 == NULL)
 904             {
 905               gtk_symbolic_color_unref (child1);
 906               return NULL;
 907             }
 908         }
 909       else
 910         child2 = NULL;
 911
 912       if (color == COLOR_LIGHTER)
 913         value = 1.3;
 914       else if (color == COLOR_DARKER)
 915         value = 0.7;
 916       else
 917         {
 918           if (!_gtk_css_parser_try (parser, ",", TRUE))
 919             {
 920               _gtk_css_parser_error (parser, "Expected ',' in color definition");
 921               gtk_symbolic_color_unref (child1);
 922               if (child2)
 923                 gtk_symbolic_color_unref (child2);
 924               return NULL;
 925             }
 926
 927           if (!_gtk_css_parser_try_double (parser, &value))
 928             {
 929               _gtk_css_parser_error (parser, "Expected number in color definition");
 930               gtk_symbolic_color_unref (child1);
 931               if (child2)
 932                 gtk_symbolic_color_unref (child2);
 933               return NULL;
 934             }
 935         }
 936
 937       switch (color)
 938         {
 939         case COLOR_LIGHTER:
 940         case COLOR_DARKER:
 941         case COLOR_SHADE:
 942           symbolic = gtk_symbolic_color_new_shade (child1, value);
 943           break;
 944         case COLOR_ALPHA:
 945           symbolic = gtk_symbolic_color_new_alpha (child1, value);
 946           break;
 947         case COLOR_MIX:
 948           symbolic = gtk_symbolic_color_new_mix (child1, child2, value);
 949           break;
 950         default:
 951           g_assert_not_reached ();
 952           symbolic = NULL;
 953         }
 954
 955       gtk_symbolic_color_unref (child1);
 956       if (child2)
 957         gtk_symbolic_color_unref (child2);
 958     }
 959
 960   if (!_gtk_css_parser_try (parser, ")", TRUE))
 961     {
 962       _gtk_css_parser_error (parser, "Expected ')' in color definition");
 963       gtk_symbolic_color_unref (symbolic);
 964       return NULL;
 965     }
 966
 967   return symbolic;
 968 }
 969
 970 static GtkSymbolicColor *
 971 gtk_css_parser_read_symbolic_color (GtkCssParser *parser)
 972 {
 973   GtkSymbolicColor *symbolic;
 974   GdkRGBA rgba;
 975   guint color;
 976   const char *names[] = {"rgba", "rgb",  "lighter", "darker", "shade", "alpha", "mix",
 977                          GTK_WIN32_THEME_SYMBOLIC_COLOR_NAME};
 978   char *name;
 979
 980   if (_gtk_css_parser_try (parser, "currentColor", TRUE))
 981     return gtk_symbolic_color_ref (_gtk_symbolic_color_get_current_color ());
 982
 983   if (_gtk_css_parser_try (parser, "transparent", TRUE))
 984     {
 985       GdkRGBA transparent = { 0, 0, 0, 0 };
 986
 987       return gtk_symbolic_color_new_literal (&transparent);
 988     }
 989
 990   if (_gtk_css_parser_try (parser, "@", FALSE))
 991     {
 992       name = _gtk_css_parser_try_name (parser, TRUE);
 993
 994       if (name)
 995         {
 996           symbolic = gtk_symbolic_color_new_name (name);
 997         }
 998       else
 999         {
1000           _gtk_css_parser_error (parser, "'%s' is not a valid symbolic color name", name);
1001           symbolic = NULL;
1002         }
1003
1004       g_free (name);
1005       return symbolic;
1006     }
1007
1008   for (color = 0; color < G_N_ELEMENTS (names); color++)
1009     {
1010       if (_gtk_css_parser_try (parser, names[color], TRUE))
1011         break;
1012     }
1013
1014   if (color < G_N_ELEMENTS (names))
1015     return gtk_css_parser_read_symbolic_color_function (parser, color);
1016
1017   if (_gtk_css_parser_try_hash_color (parser, &rgba))
1018     return gtk_symbolic_color_new_literal (&rgba);
1019
1020   name = _gtk_css_parser_try_name (parser, TRUE);
1021   if (name)
1022     {
1023       if (gdk_rgba_parse (&rgba, name))
1024         {
1025           symbolic = gtk_symbolic_color_new_literal (&rgba);
1026         }
1027       else
1028         {
1029           _gtk_css_parser_error (parser, "'%s' is not a valid color name", name);
1030           symbolic = NULL;
1031         }
1032       g_free (name);
1033       return symbolic;
1034     }
1035
1036   _gtk_css_parser_error (parser, "Not a color definition");
1037   return NULL;
1038 }
1039
1040 GtkCssValue *
1041 _gtk_css_symbolic_value_new (GtkCssParser *parser)
1042 {
1043   g_return_val_if_fail (parser != NULL, NULL);
1044
1045   return _gtk_css_symbolic_value_new_take_symbolic_color (gtk_css_parser_read_symbolic_color (parser));
1046 }
1047