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                             GFile        *base)
 227 {
 228   GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
 229   guint i;
 230
 231   if (_gtk_css_parser_try (parser, "repeating-linear-gradient(", TRUE))
 232     linear->repeating = TRUE;
 233   else if (_gtk_css_parser_try (parser, "linear-gradient(", TRUE))
 234     linear->repeating = FALSE;
 235   else
 236     {
 237       _gtk_css_parser_error (parser, "Not a linear gradient");
 238       return FALSE;
 239     }
 240
 241   if (_gtk_css_parser_try (parser, "to", TRUE))
 242     {
 243       guint side = 0;
 244
 245       for (i = 0; i < 2; i++)
 246         {
 247           if (_gtk_css_parser_try (parser, "left", TRUE))
 248             {
 249               if (side & ((1 << GTK_CSS_LEFT) | (1 << GTK_CSS_RIGHT)))
 250                 {
 251                   _gtk_css_parser_error (parser, "Expected `top', `bottom' or comma");
 252                   return FALSE;
 253                 }
 254               side |= (1 << GTK_CSS_LEFT);
 255             }
 256           else if (_gtk_css_parser_try (parser, "right", TRUE))
 257             {
 258               if (side & ((1 << GTK_CSS_LEFT) | (1 << GTK_CSS_RIGHT)))
 259                 {
 260                   _gtk_css_parser_error (parser, "Expected `top', `bottom' or comma");
 261                   return FALSE;
 262                 }
 263               side |= (1 << GTK_CSS_RIGHT);
 264             }
 265           else if (_gtk_css_parser_try (parser, "top", TRUE))
 266             {
 267               if (side & ((1 << GTK_CSS_TOP) | (1 << GTK_CSS_BOTTOM)))
 268                 {
 269                   _gtk_css_parser_error (parser, "Expected `left', `right' or comma");
 270                   return FALSE;
 271                 }
 272               side |= (1 << GTK_CSS_TOP);
 273             }
 274           else if (_gtk_css_parser_try (parser, "bottom", TRUE))
 275             {
 276               if (side & ((1 << GTK_CSS_TOP) | (1 << GTK_CSS_BOTTOM)))
 277                 {
 278                   _gtk_css_parser_error (parser, "Expected `left', `right' or comma");
 279                   return FALSE;
 280                 }
 281               side |= (1 << GTK_CSS_BOTTOM);
 282             }
 283           else
 284             break;
 285         }
 286
 287       if (side == 0)
 288         {
 289           _gtk_css_parser_error (parser, "Expected side that gradient should go to");
 290           return FALSE;
 291         }
 292
 293       linear->angle = _gtk_css_number_value_new (side, GTK_CSS_NUMBER);
 294
 295       if (!_gtk_css_parser_try (parser, ",", TRUE))
 296         {
 297           _gtk_css_parser_error (parser, "Expected a comma");
 298           return FALSE;
 299         }
 300     }
 301   else if (_gtk_css_parser_has_number (parser))
 302     {
 303       linear->angle = _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_ANGLE);
 304       if (linear->angle == NULL)
 305         return FALSE;
 306
 307       if (!_gtk_css_parser_try (parser, ",", TRUE))
 308         {
 309           _gtk_css_parser_error (parser, "Expected a comma");
 310           return FALSE;
 311         }
 312     }
 313   else
 314     linear->angle = _gtk_css_number_value_new (1 << GTK_CSS_BOTTOM, GTK_CSS_NUMBER);
 315
 316   do {
 317     GtkCssImageLinearColorStop stop;
 318
 319     stop.color = _gtk_css_symbolic_value_new (parser);
 320     if (stop.color == NULL)
 321       return FALSE;
 322
 323     if (_gtk_css_parser_has_number (parser))
 324       {
 325         stop.offset = _gtk_css_number_value_parse (parser,
 326                                                    GTK_CSS_PARSE_PERCENT
 327                                                    | GTK_CSS_PARSE_LENGTH);
 328         if (stop.offset == NULL)
 329           {
 330             _gtk_css_value_unref (stop.color);
 331             return FALSE;
 332           }
 333       }
 334     else
 335       {
 336         stop.offset = NULL;
 337       }
 338
 339     g_array_append_val (linear->stops, stop);
 340
 341   } while (_gtk_css_parser_try (parser, ",", TRUE));
 342
 343   if (!_gtk_css_parser_try (parser, ")", TRUE))
 344     {
 345       _gtk_css_parser_error (parser, "Missing closing bracket at end of linear gradient");
 346       return FALSE;
 347     }
 348
 349   return TRUE;
 350 }
 351
 352 static void
 353 gtk_css_image_linear_print (GtkCssImage *image,
 354                             GString     *string)
 355 {
 356   GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
 357   guint i;
 358
 359   if (linear->repeating)
 360     g_string_append (string, "repeating-linear-gradient(");
 361   else
 362     g_string_append (string, "linear-gradient(");
 363
 364   if (_gtk_css_number_value_get_unit (linear->angle) == GTK_CSS_NUMBER)
 365     {
 366       guint side = _gtk_css_number_value_get (linear->angle, 100);
 367
 368       if (side != (1 << GTK_CSS_BOTTOM))
 369         {
 370           g_string_append (string, "to");
 371
 372           if (side & (1 << GTK_CSS_TOP))
 373             g_string_append (string, " top");
 374           else if (side & (1 << GTK_CSS_BOTTOM))
 375             g_string_append (string, " bottom");
 376
 377           if (side & (1 << GTK_CSS_LEFT))
 378             g_string_append (string, " left");
 379           else if (side & (1 << GTK_CSS_RIGHT))
 380             g_string_append (string, " right");
 381
 382           g_string_append (string, ", ");
 383         }
 384     }
 385   else
 386     {
 387       _gtk_css_value_print (linear->angle, string);
 388       g_string_append (string, ", ");
 389     }
 390
 391   for (i = 0; i < linear->stops->len; i++)
 392     {
 393       GtkCssImageLinearColorStop *stop;
 394
 395       if (i > 0)
 396         g_string_append (string, ", ");
 397
 398       stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, i);
 399
 400       _gtk_css_value_print (stop->color, string);
 401
 402       if (stop->offset)
 403         {
 404           g_string_append (string, " ");
 405           _gtk_css_value_print (stop->offset, string);
 406         }
 407     }
 408
 409   g_string_append (string, ")");
 410 }
 411
 412 static GtkCssImage *
 413 gtk_css_image_linear_compute (GtkCssImage     *image,
 414                               GtkStyleContext *context)
 415 {
 416   static const GdkRGBA transparent = { 0, 0, 0, 0 };
 417   GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (image);
 418   GtkCssImageLinear *copy;
 419   GtkCssValue *fallback;
 420   guint i;
 421
 422   copy = g_object_new (GTK_TYPE_CSS_IMAGE_LINEAR, NULL);
 423   copy->repeating = linear->repeating;
 424
 425   copy->angle = _gtk_css_number_value_compute (linear->angle, context);
 426
 427   fallback = _gtk_css_symbolic_value_new_take_symbolic_color (gtk_symbolic_color_new_literal (&transparent));
 428   g_array_set_size (copy->stops, linear->stops->len);
 429   for (i = 0; i < linear->stops->len; i++)
 430     {
 431       GtkCssImageLinearColorStop *stop, *scopy;
 432
 433       stop = &g_array_index (linear->stops, GtkCssImageLinearColorStop, i);
 434       scopy = &g_array_index (copy->stops, GtkCssImageLinearColorStop, i);
 435
 436       scopy->color = _gtk_css_rgba_value_compute_from_symbolic (stop->color,
 437                                                                 fallback,
 438                                                                 context,
 439                                                                 FALSE);
 440
 441       if (stop->offset)
 442         scopy->offset = _gtk_css_number_value_compute (stop->offset, context);
 443       else
 444         scopy->offset = NULL;
 445     }
 446
 447   _gtk_css_value_unref (fallback);
 448
 449   return GTK_CSS_IMAGE (copy);
 450 }
 451
 452 static void
 453 gtk_css_image_linear_dispose (GObject *object)
 454 {
 455   GtkCssImageLinear *linear = GTK_CSS_IMAGE_LINEAR (object);
 456
 457   if (linear->stops)
 458     {
 459       g_array_free (linear->stops, TRUE);
 460       linear->stops = NULL;
 461     }
 462
 463   if (linear->angle)
 464     {
 465       _gtk_css_value_unref (linear->angle);
 466       linear->angle = NULL;
 467     }
 468
 469   G_OBJECT_CLASS (_gtk_css_image_linear_parent_class)->dispose (object);
 470 }
 471
 472 static void
 473 _gtk_css_image_linear_class_init (GtkCssImageLinearClass *klass)
 474 {
 475   GtkCssImageClass *image_class = GTK_CSS_IMAGE_CLASS (klass);
 476   GObjectClass *object_class = G_OBJECT_CLASS (klass);
 477
 478   image_class->draw = gtk_css_image_linear_draw;
 479   image_class->parse = gtk_css_image_linear_parse;
 480   image_class->print = gtk_css_image_linear_print;
 481   image_class->compute = gtk_css_image_linear_compute;
 482
 483   object_class->dispose = gtk_css_image_linear_dispose;
 484 }
 485
 486 static void
 487 gtk_css_image_clear_color_stop (gpointer color_stop)
 488 {
 489   GtkCssImageLinearColorStop *stop = color_stop;
 490
 491   _gtk_css_value_unref (stop->color);
 492   if (stop->offset)
 493     _gtk_css_value_unref (stop->offset);
 494 }
 495
 496 static void
 497 _gtk_css_image_linear_init (GtkCssImageLinear *linear)
 498 {
 499   linear->stops = g_array_new (FALSE, FALSE, sizeof (GtkCssImageLinearColorStop));
 500   g_array_set_clear_func (linear->stops, gtk_css_image_clear_color_stop);
 501 }
 502