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, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include "config.h"
  21 #include "gtksymboliccolor.h"
  22 #include "gtkstyleproperties.h"
  23 #include "gtkintl.h"
  24
  25 G_DEFINE_BOXED_TYPE (GtkSymbolicColor, gtk_symbolic_color,
  26                      gtk_symbolic_color_ref, gtk_symbolic_color_unref)
  27 G_DEFINE_BOXED_TYPE (GtkGradient, gtk_gradient,
  28                      gtk_gradient_ref, gtk_gradient_unref)
  29
  30 /* Symbolic colors */
  31 typedef enum {
  32   COLOR_TYPE_LITERAL,
  33   COLOR_TYPE_NAME,
  34   COLOR_TYPE_SHADE,
  35   COLOR_TYPE_ALPHA,
  36   COLOR_TYPE_MIX
  37 } ColorType;
  38
  39 struct _GtkSymbolicColor
  40 {
  41   ColorType type;
  42   guint ref_count;
  43
  44   union
  45   {
  46     GdkRGBA color;
  47     gchar *name;
  48
  49     struct
  50     {
  51       GtkSymbolicColor *color;
  52       gdouble factor;
  53     } shade, alpha;
  54
  55     struct
  56     {
  57       GtkSymbolicColor *color1;
  58       GtkSymbolicColor *color2;
  59       gdouble factor;
  60     } mix;
  61   };
  62 };
  63
  64 typedef struct ColorStop ColorStop;
  65
  66 struct ColorStop
  67 {
  68   gdouble offset;
  69   GtkSymbolicColor *color;
  70 };
  71
  72 struct _GtkGradient
  73 {
  74   gdouble x0;
  75   gdouble y0;
  76   gdouble x1;
  77   gdouble y1;
  78   gdouble radius0;
  79   gdouble radius1;
  80
  81   GArray *stops;
  82
  83   guint ref_count;
  84 };
  85
  86 /**
  87  * gtk_symbolic_color_new_literal:
  88  * @color: a #GdkRGBA
  89  *
  90  * Creates a symbolic color pointing to a literal color.
  91  *
  92  * Returns: a newly created #GtkSymbolicColor
  93  *
  94  * Since: 3.0
  95  **/
  96 GtkSymbolicColor *
  97 gtk_symbolic_color_new_literal (const GdkRGBA *color)
  98 {
  99   GtkSymbolicColor *symbolic_color;
 100
 101   g_return_val_if_fail (color != NULL, NULL);
 102
 103   symbolic_color = g_slice_new0 (GtkSymbolicColor);
 104   symbolic_color->type = COLOR_TYPE_LITERAL;
 105   symbolic_color->color = *color;
 106   symbolic_color->ref_count = 1;
 107
 108   return symbolic_color;
 109 }
 110
 111 /**
 112  * gtk_symbolic_color_new_name:
 113  * @name: color name
 114  *
 115  * Creates a symbolic color pointing to an unresolved named
 116  * color. See gtk_style_context_lookup_color() and
 117  * gtk_style_properties_lookup_color().
 118  *
 119  * Returns: a newly created #GtkSymbolicColor
 120  *
 121  * Since: 3.0
 122  **/
 123 GtkSymbolicColor *
 124 gtk_symbolic_color_new_name (const gchar *name)
 125 {
 126   GtkSymbolicColor *symbolic_color;
 127
 128   g_return_val_if_fail (name != NULL, NULL);
 129
 130   symbolic_color = g_slice_new0 (GtkSymbolicColor);
 131   symbolic_color->type = COLOR_TYPE_NAME;
 132   symbolic_color->name = g_strdup (name);
 133   symbolic_color->ref_count = 1;
 134
 135   return symbolic_color;
 136 }
 137
 138 /**
 139  * gtk_symbolic_color_new_shade:
 140  * @color: another #GtkSymbolicColor
 141  * @factor: shading factor to apply to @color
 142  *
 143  * Creates a symbolic color defined as a shade of
 144  * another color. A factor > 1.0 would resolve to
 145  * a brighter color, while < 1.0 would resolve to
 146  * a darker color.
 147  *
 148  * Returns: A newly created #GtkSymbolicColor
 149  *
 150  * Since: 3.0
 151  **/
 152 GtkSymbolicColor *
 153 gtk_symbolic_color_new_shade (GtkSymbolicColor *color,
 154                               gdouble           factor)
 155 {
 156   GtkSymbolicColor *symbolic_color;
 157
 158   g_return_val_if_fail (color != NULL, NULL);
 159
 160   symbolic_color = g_slice_new0 (GtkSymbolicColor);
 161   symbolic_color->type = COLOR_TYPE_SHADE;
 162   symbolic_color->shade.color = gtk_symbolic_color_ref (color);
 163   symbolic_color->shade.factor = factor;
 164   symbolic_color->ref_count = 1;
 165
 166   return symbolic_color;
 167 }
 168
 169 /**
 170  * gtk_symbolic_color_new_alpha:
 171  * @color: another #GtkSymbolicColor
 172  * @factor: factor to apply to @color alpha
 173  *
 174  * Creates a symbolic color by modifying the relative alpha
 175  * value of @color. A factor < 1.0 would resolve to a more
 176  * transparent color, while > 1.0 would resolve to a more
 177  * opaque color.
 178  *
 179  * Returns: A newly created #GtkSymbolicColor
 180  *
 181  * Since: 3.0
 182  **/
 183 GtkSymbolicColor *
 184 gtk_symbolic_color_new_alpha (GtkSymbolicColor *color,
 185                               gdouble           factor)
 186 {
 187   GtkSymbolicColor *symbolic_color;
 188
 189   g_return_val_if_fail (color != NULL, NULL);
 190
 191   symbolic_color = g_slice_new0 (GtkSymbolicColor);
 192   symbolic_color->type = COLOR_TYPE_ALPHA;
 193   symbolic_color->alpha.color = gtk_symbolic_color_ref (color);
 194   symbolic_color->alpha.factor = factor;
 195   symbolic_color->ref_count = 1;
 196
 197   return symbolic_color;
 198 }
 199
 200 /**
 201  * gtk_symbolic_color_new_mix:
 202  * @color1: color to mix
 203  * @color2: another color to mix
 204  * @factor: mix factor
 205  *
 206  * Creates a symbolic color defined as a mix of another
 207  * two colors. a mix factor of 0 would resolve to @color1,
 208  * while a factor of 1 would resolve to @color2.
 209  *
 210  * Returns: A newly created #GtkSymbolicColor
 211  *
 212  * Since: 3.0
 213  **/
 214 GtkSymbolicColor *
 215 gtk_symbolic_color_new_mix (GtkSymbolicColor *color1,
 216                             GtkSymbolicColor *color2,
 217                             gdouble           factor)
 218 {
 219   GtkSymbolicColor *symbolic_color;
 220
 221   g_return_val_if_fail (color1 != NULL, NULL);
 222   g_return_val_if_fail (color1 != NULL, NULL);
 223
 224   symbolic_color = g_slice_new0 (GtkSymbolicColor);
 225   symbolic_color->type = COLOR_TYPE_MIX;
 226   symbolic_color->mix.color1 = gtk_symbolic_color_ref (color1);
 227   symbolic_color->mix.color2 = gtk_symbolic_color_ref (color2);
 228   symbolic_color->mix.factor = factor;
 229   symbolic_color->ref_count = 1;
 230
 231   return symbolic_color;
 232 }
 233
 234 /**
 235  * gtk_symbolic_color_ref:
 236  * @color: a #GtkSymbolicColor
 237  *
 238  * Increases the reference count of @color
 239  *
 240  * Returns: the same @color
 241  *
 242  * Since: 3.0
 243  **/
 244 GtkSymbolicColor *
 245 gtk_symbolic_color_ref (GtkSymbolicColor *color)
 246 {
 247   g_return_val_if_fail (color != NULL, NULL);
 248
 249   color->ref_count++;
 250
 251   return color;
 252 }
 253
 254 /**
 255  * gtk_symbolic_color_unref:
 256  * @color: a #GtkSymbolicColor
 257  *
 258  * Decreases the reference count of @color, freeing its memory if the
 259  * reference count reaches 0.
 260  *
 261  * Since: 3.0
 262  **/
 263 void
 264 gtk_symbolic_color_unref (GtkSymbolicColor *color)
 265 {
 266   g_return_if_fail (color != NULL);
 267
 268   color->ref_count--;
 269
 270   if (color->ref_count == 0)
 271     {
 272       switch (color->type)
 273         {
 274         case COLOR_TYPE_NAME:
 275           g_free (color->name);
 276           break;
 277         case COLOR_TYPE_SHADE:
 278           gtk_symbolic_color_unref (color->shade.color);
 279           break;
 280         case COLOR_TYPE_ALPHA:
 281           gtk_symbolic_color_unref (color->alpha.color);
 282           break;
 283         case COLOR_TYPE_MIX:
 284           gtk_symbolic_color_unref (color->mix.color1);
 285           gtk_symbolic_color_unref (color->mix.color2);
 286           break;
 287         default:
 288           break;
 289         }
 290
 291       g_slice_free (GtkSymbolicColor, color);
 292     }
 293 }
 294
 295 static void
 296 rgb_to_hls (gdouble *r,
 297             gdouble *g,
 298             gdouble *b)
 299 {
 300   gdouble min;
 301   gdouble max;
 302   gdouble red;
 303   gdouble green;
 304   gdouble blue;
 305   gdouble h, l, s;
 306   gdouble delta;
 307
 308   red = *r;
 309   green = *g;
 310   blue = *b;
 311
 312   if (red > green)
 313     {
 314       if (red > blue)
 315         max = red;
 316       else
 317         max = blue;
 318
 319       if (green < blue)
 320         min = green;
 321       else
 322         min = blue;
 323     }
 324   else
 325     {
 326       if (green > blue)
 327         max = green;
 328       else
 329         max = blue;
 330
 331       if (red < blue)
 332         min = red;
 333       else
 334         min = blue;
 335     }
 336
 337   l = (max + min) / 2;
 338   s = 0;
 339   h = 0;
 340
 341   if (max != min)
 342     {
 343       if (l <= 0.5)
 344         s = (max - min) / (max + min);
 345       else
 346         s = (max - min) / (2 - max - min);
 347
 348       delta = max -min;
 349       if (red == max)
 350         h = (green - blue) / delta;
 351       else if (green == max)
 352         h = 2 + (blue - red) / delta;
 353       else if (blue == max)
 354         h = 4 + (red - green) / delta;
 355
 356       h *= 60;
 357       if (h < 0.0)
 358         h += 360;
 359     }
 360
 361   *r = h;
 362   *g = l;
 363   *b = s;
 364 }
 365
 366 static void
 367 hls_to_rgb (gdouble *h,
 368             gdouble *l,
 369             gdouble *s)
 370 {
 371   gdouble hue;
 372   gdouble lightness;
 373   gdouble saturation;
 374   gdouble m1, m2;
 375   gdouble r, g, b;
 376
 377   lightness = *l;
 378   saturation = *s;
 379
 380   if (lightness <= 0.5)
 381     m2 = lightness * (1 + saturation);
 382   else
 383     m2 = lightness + saturation - lightness * saturation;
 384   m1 = 2 * lightness - m2;
 385
 386   if (saturation == 0)
 387     {
 388       *h = lightness;
 389       *l = lightness;
 390       *s = lightness;
 391     }
 392   else
 393     {
 394       hue = *h + 120;
 395       while (hue > 360)
 396         hue -= 360;
 397       while (hue < 0)
 398         hue += 360;
 399
 400       if (hue < 60)
 401         r = m1 + (m2 - m1) * hue / 60;
 402       else if (hue < 180)
 403         r = m2;
 404       else if (hue < 240)
 405         r = m1 + (m2 - m1) * (240 - hue) / 60;
 406       else
 407         r = m1;
 408
 409       hue = *h;
 410       while (hue > 360)
 411         hue -= 360;
 412       while (hue < 0)
 413         hue += 360;
 414
 415       if (hue < 60)
 416         g = m1 + (m2 - m1) * hue / 60;
 417       else if (hue < 180)
 418         g = m2;
 419       else if (hue < 240)
 420         g = m1 + (m2 - m1) * (240 - hue) / 60;
 421       else
 422         g = m1;
 423
 424       hue = *h - 120;
 425       while (hue > 360)
 426         hue -= 360;
 427       while (hue < 0)
 428         hue += 360;
 429
 430       if (hue < 60)
 431         b = m1 + (m2 - m1) * hue / 60;
 432       else if (hue < 180)
 433         b = m2;
 434       else if (hue < 240)
 435         b = m1 + (m2 - m1) * (240 - hue) / 60;
 436       else
 437         b = m1;
 438
 439       *h = r;
 440       *l = g;
 441       *s = b;
 442     }
 443 }
 444
 445 static void
 446 _shade_color (GdkRGBA *color,
 447               gdouble  factor)
 448 {
 449   GdkRGBA temp;
 450
 451   temp = *color;
 452   rgb_to_hls (&temp.red, &temp.green, &temp.blue);
 453
 454   temp.green *= factor;
 455   if (temp.green > 1.0)
 456     temp.green = 1.0;
 457   else if (temp.green < 0.0)
 458     temp.green = 0.0;
 459
 460   temp.blue *= factor;
 461   if (temp.blue > 1.0)
 462     temp.blue = 1.0;
 463   else if (temp.blue < 0.0)
 464     temp.blue = 0.0;
 465
 466   hls_to_rgb (&temp.red, &temp.green, &temp.blue);
 467   *color = temp;
 468 }
 469
 470 /**
 471  * gtk_symbolic_color_resolve:
 472  * @color: a #GtkSymbolicColor
 473  * @props: #GtkStyleProperties to use when resolving named colors
 474  * @resolved_color: (out): return location for the resolved color
 475  *
 476  * If @color is resolvable, @resolved_color will be filled in
 477  * with the resolved color, and %TRUE will be returned. Generally,
 478  * if @color can't be resolved, it is due to it being defined on
 479  * top of a named color that doesn't exist in @props.
 480  *
 481  * Returns: %TRUE if the color has been resolved
 482  *
 483  * Since: 3.0
 484  **/
 485 gboolean
 486 gtk_symbolic_color_resolve (GtkSymbolicColor   *color,
 487                             GtkStyleProperties *props,
 488                             GdkRGBA            *resolved_color)
 489 {
 490   g_return_val_if_fail (color != NULL, FALSE);
 491   g_return_val_if_fail (resolved_color != NULL, FALSE);
 492
 493   switch (color->type)
 494     {
 495     case COLOR_TYPE_LITERAL:
 496       *resolved_color = color->color;
 497       return TRUE;
 498     case COLOR_TYPE_NAME:
 499       {
 500         GtkSymbolicColor *named_color;
 501
 502         g_return_val_if_fail (GTK_IS_STYLE_PROPERTIES (props), FALSE);
 503
 504         named_color = gtk_style_properties_lookup_color (props, color->name);
 505
 506         if (!named_color)
 507           return FALSE;
 508
 509         return gtk_symbolic_color_resolve (named_color, props, resolved_color);
 510       }
 511
 512       break;
 513     case COLOR_TYPE_SHADE:
 514       {
 515         GdkRGBA shade;
 516
 517         if (!gtk_symbolic_color_resolve (color->shade.color, props, &shade))
 518           return FALSE;
 519
 520         _shade_color (&shade, color->shade.factor);
 521         *resolved_color = shade;
 522
 523         return TRUE;
 524       }
 525
 526       break;
 527     case COLOR_TYPE_ALPHA:
 528       {
 529         GdkRGBA alpha;
 530
 531         if (!gtk_symbolic_color_resolve (color->alpha.color, props, &alpha))
 532           return FALSE;
 533
 534         *resolved_color = alpha;
 535         resolved_color->alpha = CLAMP (alpha.alpha * color->alpha.factor, 0, 1);
 536
 537         return TRUE;
 538       }
 539     case COLOR_TYPE_MIX:
 540       {
 541         GdkRGBA color1, color2;
 542
 543         if (!gtk_symbolic_color_resolve (color->mix.color1, props, &color1))
 544           return FALSE;
 545
 546         if (!gtk_symbolic_color_resolve (color->mix.color2, props, &color2))
 547           return FALSE;
 548
 549         resolved_color->red = CLAMP (color1.red + ((color2.red - color1.red) * color->mix.factor), 0, 1);
 550         resolved_color->green = CLAMP (color1.green + ((color2.green - color1.green) * color->mix.factor), 0, 1);
 551         resolved_color->blue = CLAMP (color1.blue + ((color2.blue - color1.blue) * color->mix.factor), 0, 1);
 552         resolved_color->alpha = CLAMP (color1.alpha + ((color2.alpha - color1.alpha) * color->mix.factor), 0, 1);
 553
 554         return TRUE;
 555       }
 556
 557       break;
 558     default:
 559       g_assert_not_reached ();
 560     }
 561
 562   return FALSE;
 563 }
 564
 565 /* GtkGradient */
 566 /**
 567  * gtk_gradient_new_linear:
 568  * @x0: X coordinate of the starting point
 569  * @y0: Y coordinate of the starting point
 570  * @x1: X coordinate of the end point
 571  * @y1: Y coordinate of the end point
 572  *
 573  * Creates a new linear gradient along the line defined by (x0, y0) and (x1, y1). Before using the gradient
 574  * a number of stop colors must be added through gtk_gradient_add_color_stop().
 575  *
 576  * Returns: A newly created #GtkGradient
 577  *
 578  * Since: 3.0
 579  **/
 580 GtkGradient *
 581 gtk_gradient_new_linear (gdouble x0,
 582                          gdouble y0,
 583                          gdouble x1,
 584                          gdouble y1)
 585 {
 586   GtkGradient *gradient;
 587
 588   gradient = g_slice_new (GtkGradient);
 589   gradient->stops = g_array_new (FALSE, FALSE, sizeof (ColorStop));
 590
 591   gradient->x0 = x0;
 592   gradient->y0 = y0;
 593   gradient->x1 = x1;
 594   gradient->y1 = y1;
 595   gradient->radius0 = 0;
 596   gradient->radius1 = 0;
 597
 598   gradient->ref_count = 1;
 599
 600   return gradient;
 601 }
 602
 603 /**
 604  * gtk_gradient_new_radial:
 605  * @x0: X coordinate of the start circle
 606  * @y0: Y coordinate of the start circle
 607  * @radius0: radius of the start circle
 608  * @x1: X coordinate of the end circle
 609  * @y1: Y coordinate of the end circle
 610  * @radius1: radius of the end circle
 611  *
 612  * Creates a new radial gradient along the two circles defined by (x0, y0, radius0) and
 613  * (x1, y1, radius1). Before using the gradient a number of stop colors must be added
 614  * through gtk_gradient_add_color_stop().
 615  *
 616  * Returns: A newly created #GtkGradient
 617  *
 618  * Since: 3.0
 619  **/
 620 GtkGradient *
 621 gtk_gradient_new_radial (gdouble x0,
 622                          gdouble y0,
 623                          gdouble radius0,
 624                          gdouble x1,
 625                          gdouble y1,
 626                          gdouble radius1)
 627 {
 628   GtkGradient *gradient;
 629
 630   gradient = g_slice_new (GtkGradient);
 631   gradient->stops = g_array_new (FALSE, FALSE, sizeof (ColorStop));
 632
 633   gradient->x0 = x0;
 634   gradient->y0 = y0;
 635   gradient->x1 = x1;
 636   gradient->y1 = y1;
 637   gradient->radius0 = radius0;
 638   gradient->radius1 = radius1;
 639
 640   gradient->ref_count = 1;
 641
 642   return gradient;
 643 }
 644
 645 /**
 646  * gtk_gradient_add_color_stop:
 647  * @gradient: a #GtkGradient
 648  * @offset: offset for the color stop
 649  * @color: color to use
 650  *
 651  * Adds a stop color to @gradient.
 652  *
 653  * Since: 3.0
 654  **/
 655 void
 656 gtk_gradient_add_color_stop (GtkGradient      *gradient,
 657                              gdouble           offset,
 658                              GtkSymbolicColor *color)
 659 {
 660   ColorStop stop;
 661
 662   g_return_if_fail (gradient != NULL);
 663
 664   stop.offset = offset;
 665   stop.color = gtk_symbolic_color_ref (color);
 666
 667   g_array_append_val (gradient->stops, stop);
 668 }
 669
 670 /**
 671  * gtk_gradient_ref:
 672  * @gradient: a #GtkGradient
 673  *
 674  * Increases the reference count of @gradient.
 675  *
 676  * Returns: The same @gradient
 677  *
 678  * Since: 3.0
 679  **/
 680 GtkGradient *
 681 gtk_gradient_ref (GtkGradient *gradient)
 682 {
 683   g_return_val_if_fail (gradient != NULL, NULL);
 684
 685   gradient->ref_count++;
 686
 687   return gradient;
 688 }
 689
 690 /**
 691  * gtk_gradient_unref:
 692  * @gradient: a #GtkGradient
 693  *
 694  * Decreases the reference count of @gradient, freeing its memory
 695  * if the reference count reaches 0.
 696  *
 697  * Since: 3.0
 698  **/
 699 void
 700 gtk_gradient_unref (GtkGradient *gradient)
 701 {
 702   g_return_if_fail (gradient != NULL);
 703
 704   gradient->ref_count--;
 705
 706   if (gradient->ref_count == 0)
 707     {
 708       guint i;
 709
 710       for (i = 0; i < gradient->stops->len; i++)
 711         {
 712           ColorStop *stop;
 713
 714           stop = &g_array_index (gradient->stops, ColorStop, i);
 715           gtk_symbolic_color_unref (stop->color);
 716         }
 717
 718       g_array_free (gradient->stops, TRUE);
 719       g_slice_free (GtkGradient, gradient);
 720     }
 721 }
 722
 723 /**
 724  * gtk_gradient_resolve:
 725  * @gradient: a #GtkGradient
 726  * @props: #GtkStyleProperties to use when resolving named colors
 727  * @resolved_gradient: (out): return location for the resolved pattern
 728  *
 729  * If @gradient is resolvable, @resolved_gradient will be filled in
 730  * with the resolved gradient as a cairo_pattern_t, and %TRUE will
 731  * be returned. Generally, if @gradient can't be resolved, it is
 732  * due to it being defined on top of a named color that doesn't
 733  * exist in @props.
 734  *
 735  * Returns: %TRUE if the gradient has been resolved
 736  *
 737  * Since: 3.0
 738  **/
 739 gboolean
 740 gtk_gradient_resolve (GtkGradient         *gradient,
 741                       GtkStyleProperties  *props,
 742                       cairo_pattern_t    **resolved_gradient)
 743 {
 744   cairo_pattern_t *pattern;
 745   guint i;
 746
 747   g_return_val_if_fail (gradient != NULL, FALSE);
 748   g_return_val_if_fail (GTK_IS_STYLE_PROPERTIES (props), FALSE);
 749   g_return_val_if_fail (resolved_gradient != NULL, FALSE);
 750
 751   if (gradient->radius0 == 0 && gradient->radius1 == 0)
 752     pattern = cairo_pattern_create_linear (gradient->x0, gradient->y0,
 753                                            gradient->x1, gradient->y1);
 754   else
 755     pattern = cairo_pattern_create_radial (gradient->x0, gradient->y0,
 756                                            gradient->radius0,
 757                                            gradient->x1, gradient->y1,
 758                                            gradient->radius1);
 759
 760   for (i = 0; i < gradient->stops->len; i++)
 761     {
 762       ColorStop *stop;
 763       GdkRGBA color;
 764
 765       stop = &g_array_index (gradient->stops, ColorStop, i);
 766
 767       if (!gtk_symbolic_color_resolve (stop->color, props, &color))
 768         {
 769           cairo_pattern_destroy (pattern);
 770           return FALSE;
 771         }
 772
 773       cairo_pattern_add_color_stop_rgba (pattern, stop->offset,
 774                                          color.red, color.green,
 775                                          color.blue, color.alpha);
 776     }
 777
 778   *resolved_gradient = pattern;
 779   return TRUE;
 780 }