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

   1 /*
   2  * Copyright © 2012 Red Hat Inc.
   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.1 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  * Authors: Benjamin Otte <otte@gnome.org>
  18  */
  19
  20 #include "config.h"
  21
  22 #include "gtkcssimagelinearprivate.h"
  23
  24 #include <math.h>
  25
  26 #include "gtkcssnumbervalueprivate.h"
  27 #include "gtkcssrgbavalueprivate.h"
  28 #include "gtkcssprovider.h"
  29 #include "gtksymboliccolorprivate.h"
  30
  31 G_DEFINE_TYPE (GtkCssImageLinear, _gtk_css_image_linear, GTK_TYPE_CSS_IMAGE)
  32
  33 static void
  34 gtk_css_image_linear_get_start_end (GtkCssImageLinear *linear,
  35                                     double             length,
  36                                     double            *start,
  37                                     double            *end)
  38 {
  39   GtkCssImageLinearColorStop *stop;
  40   double pos;
  41   guint i;
  42
  43   stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, 0);
  44   if (stop->offset == NULL)
  45     *start = 0;
  46   else
  47     *start = _gtk_css_number_value_get (stop->offset, length) / length;
  48
  49   *end = *start;
  50
  51   for (i = 0; i < linear->stops->len; i++)
  52     {
  53       stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, i);
  54
  55       if (stop->offset == NULL)
  56         continue;
  57
  58       pos = _gtk_css_number_value_get (stop->offset, length) / length;
  59
  60       *end = MAX (pos, *end);
  61     }
  62
  63   if (stop->offset == NULL)
  64     *end = MAX (*end, 1.0);
  65 }
  66
  67 static void
  68 gtk_css_image_linear_compute_start_point (double angle_in_degrees,
  69                                           double width,
  70                                           double height,
  71                                           double *x,
  72                                           double *y)
  73 {
  74   double angle, c, slope, perpendicular;
  75
  76   angle = fmod (angle_in_degrees, 360);
  77   if (angle < 0)
  78     angle += 360;
  79
  80   if (angle == 0)
  81     {
  82       *x = 0;
  83       *y = -height;
  84       return;
  85     }
  86   else if (angle == 90)
  87     {
  88       *x = width;
  89       *y = 0;
  90       return;
  91     }
  92   else if (angle == 180)
  93     {
  94       *x = 0;
  95       *y = height;
  96       return;
  97     }
  98   else if (angle == 270)
  99     {
 100       *x = -width;
 101       *y = 0;
 102       return;
 103     }
 104
 105   /* The tan() is confusing because the angle is clockwise
 106    * from 'to top' */
 107   perpendicular = tan (angle * G_PI / 180);
 108   slope = -1 / perpendicular;
 109
 110   if (angle > 180)
 111     width = - width;
 112   if (angle < 90 || angle > 270)
 113     height = - height;
 114
 115   /* Compute c (of y = mx + c) of perpendicular */
 116   c = height - perpendicular * width;
 117
 118   *x = c / (slope - perpendicular);
 119   *y = perpendicular * *x + c;
 120 }
 121
 122 static void
 123 gtk_css_image_linear_draw (GtkCssImage        *image,
 124                            cairo_t            *cr,
 125                            double              width,
 126                            double              height)
 127 {
 128   GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
 129   cairo_pattern_t *pattern;
 130   double x, y; /* coordinates of start point */
 131   double length; /* distance in pixels for 100% */
 132   double start, end; /* position of first/last point on gradient line - with gradient line being [0, 1] */
 133   double offset;
 134   int i, last;
 135
 136   if (_gtk_css_number_value_get_unit (linear->angle) == GTK_CSS_NUMBER)
 137     {
 138       guint side = _gtk_css_number_value_get (linear->angle, 100);
 139
 140       if (side & (1 << GTK_CSS_RIGHT))
 141         x = width;
 142       else if (side & (1 << GTK_CSS_LEFT))
 143         x = -width;
 144       else
 145         x = 0;
 146
 147       if (side & (1 << GTK_CSS_TOP))
 148         y = -height;
 149       else if (side & (1 << GTK_CSS_BOTTOM))
 150         y = height;
 151       else
 152         y = 0;
 153     }
 154   else
 155     {
 156       gtk_css_image_linear_compute_start_point (_gtk_css_number_value_get (linear->angle, 100),
 157                                                 width, height,
 158                                                 &x, &y);
 159     }
 160
 161   length = sqrt (x * x + y * y);
 162   gtk_css_image_linear_get_start_end (linear, length, &start, &end);
 163   pattern = cairo_pattern_create_linear (x * (start - 0.5), y * (start - 0.5),
 164                                          x * (end - 0.5),   y * (end - 0.5));
 165   if (linear->repeating)
 166     cairo_pattern_set_extend (pattern, CAIRO_EXTEND_REPEAT);
 167   else
 168     cairo_pattern_set_extend (pattern, CAIRO_EXTEND_PAD);
 169
 170   offset = start;
 171   last = -1;
 172   for (i = 0; i < linear->stops->len; i++)
 173     {
 174       GtkCssImageLinearColorStop *stop;
 175       double pos, step;
 176
 177       stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, i);
 178
 179       if (stop->offset == NULL)
 180         {
 181           if (i == 0)
 182             pos = 0.0;
 183           else if (i + 1 == linear->stops->len)
 184             pos = 1.0;
 185           else
 186             continue;
 187         }
 188       else
 189         pos = _gtk_css_number_value_get (stop->offset, length) / length;
 190
 191       pos = MAX (pos, offset);
 192       step = (pos - offset) / (i - last);
 193       for (last = last + 1; last <= i; last++)
 194         {
 195           const GdkRGBA *rgba;
 196
 197           stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, last);
 198
 199           rgba = _gtk_css_rgba_value_get_rgba (stop->color);
 200           offset += step;
 201
 202           cairo_pattern_add_color_stop_rgba (pattern,
 203                                              (offset - start) / (end - start),
 204                                              rgba->red,
 205                                              rgba->green,
 206                                              rgba->blue,
 207                                              rgba->alpha);
 208         }
 209
 210       offset = pos;
 211       last = i;
 212     }
 213
 214   cairo_rectangle (cr, 0, 0, width, height);
 215   cairo_translate (cr, width / 2, height / 2);
 216   cairo_set_source (cr, pattern);
 217   cairo_fill (cr);
 218
 219   cairo_pattern_destroy (pattern);
 220 }
 221
 222
 223 static gboolean
 224 gtk_css_image_linear_parse (GtkCssImage  *image,
 225                             GtkCssParser *parser)
 226 {
 227   GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
 228   guint i;
 229
 230   if (_gtk_css_parser_try (parser, "repeating-linear-gradient(", TRUE))
 231     linear->repeating = TRUE;
 232   else if (_gtk_css_parser_try (parser, "linear-gradient(", TRUE))
 233     linear->repeating = FALSE;
 234   else
 235     {
 236       _gtk_css_parser_error (parser, "Not a linear gradient");
 237       return FALSE;
 238     }
 239
 240   if (_gtk_css_parser_try (parser, "to", TRUE))
 241     {
 242       guint side = 0;
 243
 244       for (i = 0; i < 2; i++)
 245         {
 246           if (_gtk_css_parser_try (parser, "left", TRUE))
 247             {
 248               if (side & ((1 << GTK_CSS_LEFT) | (1 << GTK_CSS_RIGHT)))
 249                 {
 250                   _gtk_css_parser_error (parser, "Expected `top', `bottom' or comma");
 251                   return FALSE;
 252                 }
 253               side |= (1 << GTK_CSS_LEFT);
 254             }
 255           else if (_gtk_css_parser_try (parser, "right", TRUE))
 256             {
 257               if (side & ((1 << GTK_CSS_LEFT) | (1 << GTK_CSS_RIGHT)))
 258                 {
 259                   _gtk_css_parser_error (parser, "Expected `top', `bottom' or comma");
 260                   return FALSE;
 261                 }
 262               side |= (1 << GTK_CSS_RIGHT);
 263             }
 264           else if (_gtk_css_parser_try (parser, "top", TRUE))
 265             {
 266               if (side & ((1 << GTK_CSS_TOP) | (1 << GTK_CSS_BOTTOM)))
 267                 {
 268                   _gtk_css_parser_error (parser, "Expected `left', `right' or comma");
 269                   return FALSE;
 270                 }
 271               side |= (1 << GTK_CSS_TOP);
 272             }
 273           else if (_gtk_css_parser_try (parser, "bottom", TRUE))
 274             {
 275               if (side & ((1 << GTK_CSS_TOP) | (1 << GTK_CSS_BOTTOM)))
 276                 {
 277                   _gtk_css_parser_error (parser, "Expected `left', `right' or comma");
 278                   return FALSE;
 279                 }
 280               side |= (1 << GTK_CSS_BOTTOM);
 281             }
 282           else
 283             break;
 284         }
 285
 286       if (side == 0)
 287         {
 288           _gtk_css_parser_error (parser, "Expected side that gradient should go to");
 289           return FALSE;
 290         }
 291
 292       linear->angle = _gtk_css_number_value_new (side, GTK_CSS_NUMBER);
 293
 294       if (!_gtk_css_parser_try (parser, ",", TRUE))
 295         {
 296           _gtk_css_parser_error (parser, "Expected a comma");
 297           return FALSE;
 298         }
 299     }
 300   else if (_gtk_css_parser_has_number (parser))
 301     {
 302       linear->angle = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE);
 303       if (linear->angle == NULL)
 304         return FALSE;
 305
 306       if (!_gtk_css_parser_try (parser, ",", TRUE))
 307         {
 308           _gtk_css_parser_error (parser, "Expected a comma");
 309           return FALSE;
 310         }
 311     }
 312   else
 313     linear->angle = _gtk_css_number_value_new (1 << GTK_CSS_BOTTOM, GTK_CSS_NUMBER);
 314
 315   do {
 316     GtkCssImageLinearColorStop stop;
 317
 318     stop.color = _gtk_css_symbolic_value_new (parser);
 319     if (stop.color == NULL)
 320       return FALSE;
 321
 322     if (_gtk_css_parser_has_number (parser))
 323       {
 324         stop.offset = _gtk_css_number_value_parse (parser,
 325                                                    GTK_CSS_PARSE_PERCENT
 326                                                    | GTK_CSS_PARSE_LENGTH);
 327         if (stop.offset == NULL)
 328           {
 329             _gtk_css_value_unref (stop.color);
 330             return FALSE;
 331           }
 332       }
 333     else
 334       {
 335         stop.offset = NULL;
 336       }
 337
 338     g_array_append_val (linear->stops, stop);
 339
 340   } while (_gtk_css_parser_try (parser, ",", TRUE));
 341
 342   if (!_gtk_css_parser_try (parser, ")", TRUE))
 343     {
 344       _gtk_css_parser_error (parser, "Missing closing bracket at end of linear gradient");
 345       return FALSE;
 346     }
 347
 348   return TRUE;
 349 }
 350
 351 static void
 352 gtk_css_image_linear_print (GtkCssImage *image,
 353                             GString     *string)
 354 {
 355   GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
 356   guint i;
 357
 358   if (linear->repeating)
 359     g_string_append (string, "repeating-linear-gradient(");
 360   else
 361     g_string_append (string, "linear-gradient(");
 362
 363   if (_gtk_css_number_value_get_unit (linear->angle) == GTK_CSS_NUMBER)
 364     {
 365       guint side = _gtk_css_number_value_get (linear->angle, 100);
 366
 367       if (side != (1 << GTK_CSS_BOTTOM))
 368         {
 369           g_string_append (string, "to");
 370
 371           if (side & (1 << GTK_CSS_TOP))
 372             g_string_append (string, " top");
 373           else if (side & (1 << GTK_CSS_BOTTOM))
 374             g_string_append (string, " bottom");
 375
 376           if (side & (1 << GTK_CSS_LEFT))
 377             g_string_append (string, " left");
 378           else if (side & (1 << GTK_CSS_RIGHT))
 379             g_string_append (string, " right");
 380
 381           g_string_append (string, ", ");
 382         }
 383     }
 384   else
 385     {
 386       _gtk_css_value_print (linear->angle, string);
 387       g_string_append (string, ", ");
 388     }
 389
 390   for (i = 0; i < linear->stops->len; i++)
 391     {
 392       GtkCssImageLinearColorStop *stop;
 393
 394       if (i > 0)
 395         g_string_append (string, ", ");
 396
 397       stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, i);
 398
 399       _gtk_css_value_print (stop->color, string);
 400
 401       if (stop->offset)
 402         {
 403           g_string_append (string, " ");
 404           _gtk_css_value_print (stop->offset, string);
 405         }
 406     }
 407
 408   g_string_append (string, ")");
 409 }
 410
 411 static GtkCssImage *
 412 gtk_css_image_linear_compute (GtkCssImage     *image,
 413                               GtkStyleContext *context)
 414 {
 415   static const GdkRGBA transparent = { 0, 0, 0, 0 };
 416   GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
 417   GtkCssImageLinear *copy;
 418   GtkCssValue *fallback;
 419   guint i;
 420
 421   copy = g_object_new (GTK_TYPE_CSS_IMAGE_LINEAR, NULL);
 422   copy->repeating = linear->repeating;
 423
 424   copy->angle = _gtk_css_number_value_compute (linear->angle, context);
 425
 426   fallback = _gtk_css_symbolic_value_new_take_symbolic_color (gtk_symbolic_color_new_literal (&transparent));
 427   g_array_set_size (copy->stops, linear->stops->len);
 428   for (i = 0; i < linear->stops->len; i++)
 429     {
 430       GtkCssImageLinearColorStop *stop, *scopy;
 431
 432       stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, i);
 433       scopy = &g_array_index (copy->stops, GtkCssImageLinearColorStop, i);
 434
 435       scopy->color = _gtk_css_rgba_value_compute_from_symbolic (stop->color,
 436                                                                 fallback,
 437                                                                 context,
 438                                                                 FALSE);
 439
 440       if (stop->offset)
 441         scopy->offset = _gtk_css_number_value_compute (stop->offset, context);
 442       else
 443         scopy->offset = NULL;
 444     }
 445
 446   _gtk_css_value_unref (fallback);
 447
 448   return GTK_CSS_IMAGE (copy);
 449 }
 450
 451 static void
 452 gtk_css_image_linear_dispose (GObject *object)
 453 {
 454   GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (object);
 455
 456   if (linear->stops)
 457     {
 458       g_array_free (linear->stops, TRUE);
 459       linear->stops = NULL;
 460     }
 461
 462   if (linear->angle)
 463     {
 464       _gtk_css_value_unref (linear->angle);
 465       linear->angle = NULL;
 466     }
 467
 468   G_OBJECT_CLASS (_gtk_css_image_linear_parent_class)->dispose (object);
 469 }
 470
 471 static void
 472 _gtk_css_image_linear_class_init (GtkCssImageLinearClass *klass)
 473 {
 474   GtkCssImageClass *image_class = GTK_CSS_IMAGE_CLASS (klass);
 475   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 476
 477   image_class->draw = gtk_css_image_linear_draw;
 478   image_class->parse = gtk_css_image_linear_parse;
 479   image_class->print = gtk_css_image_linear_print;
 480   image_class->compute = gtk_css_image_linear_compute;
 481
 482   object_class->dispose = gtk_css_image_linear_dispose;
 483 }
 484
 485 static void
 486 gtk_css_image_clear_color_stop (gpointer color_stop)
 487 {
 488   GtkCssImageLinearColorStop *stop = color_stop;
 489
 490   _gtk_css_value_unref (stop->color);
 491   if (stop->offset)
 492     _gtk_css_value_unref (stop->offset);
 493 }
 494
 495 static void
 496 _gtk_css_image_linear_init (GtkCssImageLinear *linear)
 497 {
 498   linear->stops = g_array_new (FALSE, FALSE, sizeof (GtkCssImageLinearColorStop));
 499   g_array_set_clear_func (linear->stops, gtk_css_image_clear_color_stop);
 500 }
 501