Pileus Git - ~andy/gtk/blob - gtk/gtkstyleproperty.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
  22 #include "gtkstylepropertyprivate.h"
  23
  24 #include <errno.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 #include <gdk-pixbuf/gdk-pixbuf.h>
  29 #include <cairo-gobject.h>
  30
  31 #include "gtkcssprovider.h"
  32 #include "gtkcssparserprivate.h"
  33
  34 /* the actual parsers we have */
  35 #include "gtkanimationdescription.h"
  36 #include "gtkbindings.h"
  37 #include "gtk9slice.h"
  38 #include "gtkgradient.h"
  39 #include "gtkshadowprivate.h"
  40 #include "gtkthemingengine.h"
  41
  42 typedef gboolean (* ParseFunc)        (GtkCssParser  *parser,
  43                                        GFile         *base,
  44                                        GValue        *value);
  45 typedef char *   (* ToStringFunc)     (const GValue  *value);
  46
  47 static GHashTable *parse_funcs = NULL;
  48 static GHashTable *to_string_funcs = NULL;
  49
  50 static void
  51 register_conversion_function (GType          type,
  52                               ParseFunc      parse,
  53                               ToStringFunc   to_string)
  54 {
  55   if (parse)
  56     g_hash_table_insert (parse_funcs, GSIZE_TO_POINTER (type), parse);
  57   if (to_string)
  58     g_hash_table_insert (to_string_funcs, GSIZE_TO_POINTER (type), to_string);
  59 }
  60
  61 /*** IMPLEMENTATIONS ***/
  62
  63 static gboolean
  64 rgba_value_parse (GtkCssParser *parser,
  65                   GFile        *base,
  66                   GValue       *value)
  67 {
  68   GtkSymbolicColor *symbolic;
  69   GdkRGBA rgba;
  70
  71   symbolic = _gtk_css_parser_read_symbolic_color (parser);
  72   if (symbolic == NULL)
  73     return FALSE;
  74
  75   if (gtk_symbolic_color_resolve (symbolic, NULL, &rgba))
  76     {
  77       g_value_set_boxed (value, &rgba);
  78     }
  79   else
  80     {
  81       g_value_unset (value);
  82       g_value_init (value, GTK_TYPE_SYMBOLIC_COLOR);
  83       g_value_take_boxed (value, symbolic);
  84     }
  85
  86   return TRUE;
  87 }
  88
  89 static char *
  90 rgba_value_to_string (const GValue *value)
  91 {
  92   const GdkRGBA *rgba = g_value_get_boxed (value);
  93
  94   if (rgba == NULL)
  95     return g_strdup ("none");
  96
  97   return gdk_rgba_to_string (rgba);
  98 }
  99
 100 static gboolean
 101 color_value_parse (GtkCssParser *parser,
 102                    GFile        *base,
 103                    GValue       *value)
 104 {
 105   GtkSymbolicColor *symbolic;
 106   GdkRGBA rgba;
 107
 108   symbolic = _gtk_css_parser_read_symbolic_color (parser);
 109   if (symbolic == NULL)
 110     return FALSE;
 111
 112   if (gtk_symbolic_color_resolve (symbolic, NULL, &rgba))
 113     {
 114       GdkColor color;
 115
 116       color.red = rgba.red * 65535. + 0.5;
 117       color.green = rgba.green * 65535. + 0.5;
 118       color.blue = rgba.blue * 65535. + 0.5;
 119
 120       g_value_set_boxed (value, &color);
 121     }
 122   else
 123     {
 124       g_value_unset (value);
 125       g_value_init (value, GTK_TYPE_SYMBOLIC_COLOR);
 126       g_value_take_boxed (value, symbolic);
 127     }
 128
 129   return TRUE;
 130 }
 131
 132 static char *
 133 color_value_to_string (const GValue *value)
 134 {
 135   const GdkColor *color = g_value_get_boxed (value);
 136
 137   if (color == NULL)
 138     return g_strdup ("none");
 139
 140   return gdk_color_to_string (color);
 141 }
 142
 143 static gboolean
 144 symbolic_color_value_parse (GtkCssParser *parser,
 145                             GFile        *base,
 146                             GValue       *value)
 147 {
 148   GtkSymbolicColor *symbolic;
 149
 150   symbolic = _gtk_css_parser_read_symbolic_color (parser);
 151   if (symbolic == NULL)
 152     return FALSE;
 153
 154   g_value_take_boxed (value, symbolic);
 155   return TRUE;
 156 }
 157
 158 static char *
 159 symbolic_color_value_to_string (const GValue *value)
 160 {
 161   GtkSymbolicColor *symbolic = g_value_get_boxed (value);
 162
 163   if (symbolic == NULL)
 164     return g_strdup ("none");
 165
 166   return gtk_symbolic_color_to_string (symbolic);
 167 }
 168
 169 static gboolean
 170 font_description_value_parse (GtkCssParser *parser,
 171                               GFile        *base,
 172                               GValue       *value)
 173 {
 174   PangoFontDescription *font_desc;
 175   char *str;
 176
 177   str = _gtk_css_parser_read_value (parser);
 178   if (str == NULL)
 179     return FALSE;
 180
 181   font_desc = pango_font_description_from_string (str);
 182   g_free (str);
 183   g_value_take_boxed (value, font_desc);
 184   return TRUE;
 185 }
 186
 187 static char *
 188 font_description_value_to_string (const GValue *value)
 189 {
 190   const PangoFontDescription *desc = g_value_get_boxed (value);
 191
 192   if (desc == NULL)
 193     return g_strdup ("none");
 194
 195   return pango_font_description_to_string (desc);
 196 }
 197
 198 static gboolean
 199 boolean_value_parse (GtkCssParser *parser,
 200                      GFile        *base,
 201                      GValue       *value)
 202 {
 203   if (_gtk_css_parser_try (parser, "true", TRUE) ||
 204       _gtk_css_parser_try (parser, "1", TRUE))
 205     {
 206       g_value_set_boolean (value, TRUE);
 207       return TRUE;
 208     }
 209   else if (_gtk_css_parser_try (parser, "false", TRUE) ||
 210            _gtk_css_parser_try (parser, "0", TRUE))
 211     {
 212       g_value_set_boolean (value, FALSE);
 213       return TRUE;
 214     }
 215   else
 216     {
 217       _gtk_css_parser_error (parser, "Expected a boolean value");
 218       return FALSE;
 219     }
 220 }
 221
 222 static char *
 223 boolean_value_to_string (const GValue *value)
 224 {
 225   if (g_value_get_boolean (value))
 226     return g_strdup ("true");
 227   else
 228     return g_strdup ("false");
 229 }
 230
 231 static gboolean
 232 int_value_parse (GtkCssParser *parser,
 233                  GFile        *base,
 234                  GValue       *value)
 235 {
 236   gint i;
 237
 238   if (!_gtk_css_parser_try_int (parser, &i))
 239     {
 240       _gtk_css_parser_error (parser, "Expected a valid integer value");
 241       return FALSE;
 242     }
 243
 244   g_value_set_int (value, i);
 245   return TRUE;
 246 }
 247
 248 static char *
 249 int_value_to_string (const GValue *value)
 250 {
 251   return g_strdup_printf ("%d", g_value_get_int (value));
 252 }
 253
 254 static gboolean
 255 uint_value_parse (GtkCssParser *parser,
 256                   GFile        *base,
 257                   GValue       *value)
 258 {
 259   guint u;
 260
 261   if (!_gtk_css_parser_try_uint (parser, &u))
 262     {
 263       _gtk_css_parser_error (parser, "Expected a valid unsigned value");
 264       return FALSE;
 265     }
 266
 267   g_value_set_uint (value, u);
 268   return TRUE;
 269 }
 270
 271 static char *
 272 uint_value_to_string (const GValue *value)
 273 {
 274   return g_strdup_printf ("%u", g_value_get_uint (value));
 275 }
 276
 277 static gboolean
 278 double_value_parse (GtkCssParser *parser,
 279                     GFile        *base,
 280                     GValue       *value)
 281 {
 282   gdouble d;
 283
 284   if (!_gtk_css_parser_try_double (parser, &d))
 285     {
 286       _gtk_css_parser_error (parser, "Expected a number");
 287       return FALSE;
 288     }
 289
 290   g_value_set_double (value, d);
 291   return TRUE;
 292 }
 293
 294 static char *
 295 double_value_to_string (const GValue *value)
 296 {
 297   char buf[G_ASCII_DTOSTR_BUF_SIZE];
 298
 299   g_ascii_dtostr (buf, sizeof (buf), g_value_get_double (value));
 300
 301   return g_strdup (buf);
 302 }
 303
 304 static gboolean
 305 float_value_parse (GtkCssParser *parser,
 306                    GFile        *base,
 307                    GValue       *value)
 308 {
 309   gdouble d;
 310
 311   if (!_gtk_css_parser_try_double (parser, &d))
 312     {
 313       _gtk_css_parser_error (parser, "Expected a number");
 314       return FALSE;
 315     }
 316
 317   g_value_set_float (value, d);
 318   return TRUE;
 319 }
 320
 321 static char *
 322 float_value_to_string (const GValue *value)
 323 {
 324   char buf[G_ASCII_DTOSTR_BUF_SIZE];
 325
 326   g_ascii_dtostr (buf, sizeof (buf), g_value_get_float (value));
 327
 328   return g_strdup (buf);
 329 }
 330
 331 static gboolean
 332 string_value_parse (GtkCssParser *parser,
 333                     GFile        *base,
 334                     GValue       *value)
 335 {
 336   char *str = _gtk_css_parser_read_string (parser);
 337
 338   if (str == NULL)
 339     return FALSE;
 340
 341   g_value_take_string (value, str);
 342   return TRUE;
 343 }
 344
 345 static char *
 346 string_value_to_string (const GValue *value)
 347 {
 348   const char *string;
 349   gsize len;
 350   GString *str;
 351
 352   string = g_value_get_string (value);
 353   str = g_string_new ("\"");
 354
 355   do {
 356     len = strcspn (string, "\"\n\r\f");
 357     g_string_append (str, string);
 358     string += len;
 359     switch (*string)
 360       {
 361       case '\0':
 362         break;
 363       case '\n':
 364         g_string_append (str, "\\A ");
 365         break;
 366       case '\r':
 367         g_string_append (str, "\\D ");
 368         break;
 369       case '\f':
 370         g_string_append (str, "\\C ");
 371         break;
 372       case '\"':
 373         g_string_append (str, "\\\"");
 374         break;
 375       default:
 376         g_assert_not_reached ();
 377         break;
 378       }
 379   } while (*string);
 380
 381   g_string_append_c (str, '"');
 382   return g_string_free (str, FALSE);
 383 }
 384
 385 static gboolean
 386 theming_engine_value_parse (GtkCssParser *parser,
 387                             GFile        *base,
 388                             GValue       *value)
 389 {
 390   GtkThemingEngine *engine;
 391   char *str;
 392
 393   str = _gtk_css_parser_try_ident (parser, TRUE);
 394   if (str == NULL)
 395     {
 396       _gtk_css_parser_error (parser, "Expected a valid theme name");
 397       return FALSE;
 398     }
 399
 400   engine = gtk_theming_engine_load (str);
 401   if (engine == NULL)
 402     {
 403       _gtk_css_parser_error (parser, "Themeing engine '%s' not found", str);
 404       g_free (str);
 405       return FALSE;
 406     }
 407
 408   g_value_set_object (value, engine);
 409   g_free (str);
 410   return TRUE;
 411 }
 412
 413 static char *
 414 theming_engine_value_to_string (const GValue *value)
 415 {
 416   GtkThemingEngine *engine;
 417   char *name;
 418
 419   engine = g_value_get_object (value);
 420   if (engine == NULL)
 421     return g_strdup ("none");
 422
 423   /* XXX: gtk_theming_engine_get_name()? */
 424   g_object_get (engine, "name", &name, NULL);
 425
 426   return name;
 427 }
 428
 429 static gboolean
 430 animation_description_value_parse (GtkCssParser *parser,
 431                                    GFile        *base,
 432                                    GValue       *value)
 433 {
 434   GtkAnimationDescription *desc;
 435   char *str;
 436
 437   str = _gtk_css_parser_read_value (parser);
 438   if (str == NULL)
 439     return FALSE;
 440
 441   desc = _gtk_animation_description_from_string (str);
 442   g_free (str);
 443
 444   if (desc == NULL)
 445     {
 446       _gtk_css_parser_error (parser, "Invalid animation description");
 447       return FALSE;
 448     }
 449
 450   g_value_take_boxed (value, desc);
 451   return TRUE;
 452 }
 453
 454 static char *
 455 animation_description_value_to_string (const GValue *value)
 456 {
 457   GtkAnimationDescription *desc = g_value_get_boxed (value);
 458
 459   if (desc == NULL)
 460     return g_strdup ("none");
 461
 462   return _gtk_animation_description_to_string (desc);
 463 }
 464
 465 static gboolean
 466 border_value_parse (GtkCssParser *parser,
 467                     GFile        *base,
 468                     GValue       *value)
 469 {
 470   GtkBorder border = { 0, };
 471   guint i, numbers[4];
 472
 473   for (i = 0; i < G_N_ELEMENTS (numbers); i++)
 474     {
 475       if (!_gtk_css_parser_try_uint (parser, &numbers[i]))
 476         break;
 477
 478       /* XXX: shouldn't allow spaces here? */
 479       _gtk_css_parser_try (parser, "px", TRUE);
 480     }
 481
 482   if (i == 0)
 483     {
 484       _gtk_css_parser_error (parser, "Expected valid border");
 485       return FALSE;
 486     }
 487
 488   border.top = numbers[0];
 489   if (i > 1)
 490     border.right = numbers[1];
 491   else
 492     border.right = border.top;
 493   if (i > 2)
 494     border.bottom = numbers[2];
 495   else
 496     border.bottom = border.top;
 497   if (i > 3)
 498     border.left = numbers[3];
 499   else
 500     border.left = border.right;
 501
 502   g_value_set_boxed (value, &border);
 503   return TRUE;
 504 }
 505
 506 static char *
 507 border_value_to_string (const GValue *value)
 508 {
 509   const GtkBorder *border = g_value_get_boxed (value);
 510
 511   if (border == NULL)
 512     return g_strdup ("none");
 513   else if (border->left != border->right)
 514     return g_strdup_printf ("%d %d %d %d", border->top, border->right, border->bottom, border->left);
 515   else if (border->top != border->bottom)
 516     return g_strdup_printf ("%d %d %d", border->top, border->right, border->bottom);
 517   else if (border->top != border->left)
 518     return g_strdup_printf ("%d %d", border->top, border->right);
 519   else
 520     return g_strdup_printf ("%d", border->top);
 521 }
 522
 523 static gboolean
 524 gradient_value_parse (GtkCssParser *parser,
 525                       GFile        *base,
 526                       GValue       *value)
 527 {
 528   GtkGradient *gradient;
 529   cairo_pattern_type_t type;
 530   gdouble coords[6];
 531   guint i;
 532
 533   if (!_gtk_css_parser_try (parser, "-gtk-gradient", TRUE))
 534     {
 535       _gtk_css_parser_error (parser,
 536                              "Expected '-gtk-gradient'");
 537       return FALSE;
 538     }
 539
 540   if (!_gtk_css_parser_try (parser, "(", TRUE))
 541     {
 542       _gtk_css_parser_error (parser,
 543                              "Expected '(' after '-gtk-gradient'");
 544       return FALSE;
 545     }
 546
 547   /* Parse gradient type */
 548   if (_gtk_css_parser_try (parser, "linear", TRUE))
 549     type = CAIRO_PATTERN_TYPE_LINEAR;
 550   else if (_gtk_css_parser_try (parser, "radial", TRUE))
 551     type = CAIRO_PATTERN_TYPE_RADIAL;
 552   else
 553     {
 554       _gtk_css_parser_error (parser,
 555                              "Gradient type must be 'radial' or 'linear'");
 556       return FALSE;
 557     }
 558
 559   /* Parse start/stop position parameters */
 560   for (i = 0; i < 2; i++)
 561     {
 562       if (! _gtk_css_parser_try (parser, ",", TRUE))
 563         {
 564           _gtk_css_parser_error (parser,
 565                                  "Expected ','");
 566           return FALSE;
 567         }
 568
 569       if (_gtk_css_parser_try (parser, "left", TRUE))
 570         coords[i * 3] = 0;
 571       else if (_gtk_css_parser_try (parser, "right", TRUE))
 572         coords[i * 3] = 1;
 573       else if (_gtk_css_parser_try (parser, "center", TRUE))
 574         coords[i * 3] = 0.5;
 575       else if (!_gtk_css_parser_try_double (parser, &coords[i * 3]))
 576         {
 577           _gtk_css_parser_error (parser,
 578                                  "Expected a valid X coordinate");
 579           return FALSE;
 580         }
 581
 582       if (_gtk_css_parser_try (parser, "top", TRUE))
 583         coords[i * 3 + 1] = 0;
 584       else if (_gtk_css_parser_try (parser, "bottom", TRUE))
 585         coords[i * 3 + 1] = 1;
 586       else if (_gtk_css_parser_try (parser, "center", TRUE))
 587         coords[i * 3 + 1] = 0.5;
 588       else if (!_gtk_css_parser_try_double (parser, &coords[i * 3 + 1]))
 589         {
 590           _gtk_css_parser_error (parser,
 591                                  "Expected a valid Y coordinate");
 592           return FALSE;
 593         }
 594
 595       if (type == CAIRO_PATTERN_TYPE_RADIAL)
 596         {
 597           /* Parse radius */
 598           if (! _gtk_css_parser_try (parser, ",", TRUE))
 599             {
 600               _gtk_css_parser_error (parser,
 601                                      "Expected ','");
 602               return FALSE;
 603             }
 604
 605           if (! _gtk_css_parser_try_double (parser, &coords[(i * 3) + 2]))
 606             {
 607               _gtk_css_parser_error (parser,
 608                                      "Expected a numer for the radius");
 609               return FALSE;
 610             }
 611         }
 612     }
 613
 614   if (type == CAIRO_PATTERN_TYPE_LINEAR)
 615     gradient = gtk_gradient_new_linear (coords[0], coords[1], coords[3], coords[4]);
 616   else
 617     gradient = gtk_gradient_new_radial (coords[0], coords[1], coords[2],
 618                                         coords[3], coords[4], coords[5]);
 619
 620   while (_gtk_css_parser_try (parser, ",", TRUE))
 621     {
 622       GtkSymbolicColor *color;
 623       gdouble position;
 624
 625       if (_gtk_css_parser_try (parser, "from", TRUE))
 626         {
 627           position = 0;
 628
 629           if (!_gtk_css_parser_try (parser, "(", TRUE))
 630             {
 631               gtk_gradient_unref (gradient);
 632               _gtk_css_parser_error (parser,
 633                                      "Expected '('");
 634               return FALSE;
 635             }
 636
 637         }
 638       else if (_gtk_css_parser_try (parser, "to", TRUE))
 639         {
 640           position = 1;
 641
 642           if (!_gtk_css_parser_try (parser, "(", TRUE))
 643             {
 644               gtk_gradient_unref (gradient);
 645               _gtk_css_parser_error (parser,
 646                                      "Expected '('");
 647               return FALSE;
 648             }
 649
 650         }
 651       else if (_gtk_css_parser_try (parser, "color-stop", TRUE))
 652         {
 653           if (!_gtk_css_parser_try (parser, "(", TRUE))
 654             {
 655               gtk_gradient_unref (gradient);
 656               _gtk_css_parser_error (parser,
 657                                      "Expected '('");
 658               return FALSE;
 659             }
 660
 661           if (!_gtk_css_parser_try_double (parser, &position))
 662             {
 663               gtk_gradient_unref (gradient);
 664               _gtk_css_parser_error (parser,
 665                                      "Expected a valid number");
 666               return FALSE;
 667             }
 668
 669           if (!_gtk_css_parser_try (parser, ",", TRUE))
 670             {
 671               gtk_gradient_unref (gradient);
 672               _gtk_css_parser_error (parser,
 673                                      "Expected a comma");
 674               return FALSE;
 675             }
 676         }
 677       else
 678         {
 679           gtk_gradient_unref (gradient);
 680           _gtk_css_parser_error (parser,
 681                                  "Not a valid color-stop definition");
 682           return FALSE;
 683         }
 684
 685       color = _gtk_css_parser_read_symbolic_color (parser);
 686       if (color == NULL)
 687         {
 688           gtk_gradient_unref (gradient);
 689           return FALSE;
 690         }
 691
 692       gtk_gradient_add_color_stop (gradient, position, color);
 693       gtk_symbolic_color_unref (color);
 694
 695       if (!_gtk_css_parser_try (parser, ")", TRUE))
 696         {
 697           gtk_gradient_unref (gradient);
 698           _gtk_css_parser_error (parser,
 699                                  "Expected ')'");
 700           return FALSE;
 701         }
 702     }
 703
 704   if (!_gtk_css_parser_try (parser, ")", TRUE))
 705     {
 706       gtk_gradient_unref (gradient);
 707       _gtk_css_parser_error (parser,
 708                              "Expected ')'");
 709       return FALSE;
 710     }
 711
 712   g_value_set_boxed (value, gradient);
 713   return TRUE;
 714 }
 715
 716 static char *
 717 gradient_value_to_string (const GValue *value)
 718 {
 719   GtkGradient *gradient = g_value_get_boxed (value);
 720
 721   if (gradient == NULL)
 722     return g_strdup ("none");
 723
 724   return gtk_gradient_to_string (gradient);
 725 }
 726
 727 static GFile *
 728 gtk_css_parse_url (GtkCssParser *parser,
 729                    GFile        *base)
 730 {
 731   gchar *path;
 732   GFile *file;
 733
 734   if (_gtk_css_parser_try (parser, "url", FALSE))
 735     {
 736       if (!_gtk_css_parser_try (parser, "(", TRUE))
 737         {
 738           _gtk_css_parser_skip_whitespace (parser);
 739           if (_gtk_css_parser_try (parser, "(", TRUE))
 740             {
 741               GError *error;
 742
 743               error = g_error_new_literal (GTK_CSS_PROVIDER_ERROR,
 744                                            GTK_CSS_PROVIDER_ERROR_DEPRECATED,
 745                                            "Whitespace between 'url' and '(' is not allowed");
 746
 747               _gtk_css_parser_take_error (parser, error);
 748             }
 749           else
 750             {
 751               _gtk_css_parser_error (parser, "Expected '(' after 'url'");
 752               return NULL;
 753             }
 754         }
 755
 756       path = _gtk_css_parser_read_string (parser);
 757       if (path == NULL)
 758         return NULL;
 759
 760       if (!_gtk_css_parser_try (parser, ")", TRUE))
 761         {
 762           _gtk_css_parser_error (parser, "No closing ')' found for 'url'");
 763           g_free (path);
 764           return NULL;
 765         }
 766     }
 767   else
 768     {
 769       path = _gtk_css_parser_try_name (parser, TRUE);
 770       if (path == NULL)
 771         {
 772           _gtk_css_parser_error (parser, "Not a valid url");
 773           return NULL;
 774         }
 775     }
 776
 777   file = g_file_resolve_relative_path (base, path);
 778   g_free (path);
 779
 780   return file;
 781 }
 782
 783 static gboolean
 784 pattern_value_parse (GtkCssParser *parser,
 785                      GFile        *base,
 786                      GValue       *value)
 787 {
 788   if (_gtk_css_parser_begins_with (parser, '-'))
 789     {
 790       g_value_unset (value);
 791       g_value_init (value, GTK_TYPE_GRADIENT);
 792       return gradient_value_parse (parser, base, value);
 793     }
 794   else
 795     {
 796       GError *error = NULL;
 797       gchar *path;
 798       GdkPixbuf *pixbuf;
 799       GFile *file;
 800       cairo_surface_t *surface;
 801       cairo_pattern_t *pattern;
 802       cairo_t *cr;
 803       cairo_matrix_t matrix;
 804
 805       file = gtk_css_parse_url (parser, base);
 806       if (file == NULL)
 807         return FALSE;
 808
 809       path = g_file_get_path (file);
 810       g_object_unref (file);
 811
 812       pixbuf = gdk_pixbuf_new_from_file (path, &error);
 813       g_free (path);
 814       if (pixbuf == NULL)
 815         {
 816           _gtk_css_parser_take_error (parser, error);
 817           return FALSE;
 818         }
 819
 820       surface = cairo_image_surface_create (CAIRO_FORMAT_ARGB32,
 821                                             gdk_pixbuf_get_width (pixbuf),
 822                                             gdk_pixbuf_get_height (pixbuf));
 823       cr = cairo_create (surface);
 824       gdk_cairo_set_source_pixbuf (cr, pixbuf, 0, 0);
 825       cairo_paint (cr);
 826       pattern = cairo_pattern_create_for_surface (surface);
 827
 828       cairo_matrix_init_scale (&matrix,
 829                                gdk_pixbuf_get_width (pixbuf),
 830                                gdk_pixbuf_get_height (pixbuf));
 831       cairo_pattern_set_matrix (pattern, &matrix);
 832
 833       cairo_surface_destroy (surface);
 834       cairo_destroy (cr);
 835       g_object_unref (pixbuf);
 836
 837       g_value_take_boxed (value, pattern);
 838     }
 839
 840   return TRUE;
 841 }
 842
 843 static gboolean
 844 shadow_value_parse (GtkCssParser *parser,
 845                     GFile *base,
 846                     GValue *value)
 847 {
 848   gboolean inset;
 849   gdouble hoffset, voffset, blur, spread;
 850   GtkSymbolicColor *color;
 851   GtkShadow *shadow;
 852
 853   shadow = _gtk_shadow_new ();
 854
 855   do
 856     {
 857       inset = _gtk_css_parser_try (parser, "inset", TRUE);
 858
 859       if (!_gtk_css_parser_try_double (parser, &hoffset) ||
 860           !_gtk_css_parser_try_double (parser, &voffset))
 861         {
 862           _gtk_css_parser_error (parser, "Horizontal and vertical offsets are required");
 863           _gtk_shadow_unref (shadow);
 864           return FALSE;
 865         }
 866
 867       if (!_gtk_css_parser_try_double (parser, &blur))
 868         blur = 0;
 869
 870       if (!_gtk_css_parser_try_double (parser, &spread))
 871         spread = 0;
 872
 873       /* XXX: the color is optional and UA-defined if it's missing,
 874        * but it doesn't really make sense for us...
 875        */
 876       color = _gtk_css_parser_read_symbolic_color (parser);
 877
 878       if (color == NULL)
 879         {
 880           _gtk_shadow_unref (shadow);
 881           return FALSE;
 882         }
 883
 884       _gtk_shadow_append (shadow,
 885                           hoffset, voffset,
 886                           blur, spread,
 887                           inset, color);
 888
 889       gtk_symbolic_color_unref (color);
 890
 891     }
 892   while (_gtk_css_parser_try (parser, ",", TRUE));
 893
 894   g_value_take_boxed (value, shadow);
 895   return TRUE;
 896 }
 897
 898 static gchar *
 899 shadow_value_to_string (const GValue *value)
 900 {
 901   GtkShadow *shadow;
 902
 903   shadow = g_value_get_boxed (value);
 904
 905   if (shadow == NULL)
 906     return g_strdup ("none");
 907
 908   return _gtk_shadow_to_string (shadow);
 909 }
 910
 911 static gboolean
 912 slice_value_parse (GtkCssParser *parser,
 913                    GFile        *base,
 914                    GValue       *value)
 915 {
 916   gdouble distance_top, distance_bottom;
 917   gdouble distance_left, distance_right;
 918   GtkSliceSideModifier mods[2];
 919   GdkPixbuf *pixbuf;
 920   Gtk9Slice *slice;
 921   GFile *file;
 922   GError *error = NULL;
 923   gint i;
 924   char *path;
 925
 926   /* Parse image url */
 927   file = gtk_css_parse_url (parser, base);
 928   if (!file)
 929       return FALSE;
 930
 931   if (!_gtk_css_parser_try_double (parser, &distance_top) ||
 932       !_gtk_css_parser_try_double (parser, &distance_right) ||
 933       !_gtk_css_parser_try_double (parser, &distance_bottom) ||
 934       !_gtk_css_parser_try_double (parser, &distance_left))
 935     {
 936       _gtk_css_parser_error (parser, "Expected a number");
 937       g_object_unref (file);
 938       return FALSE;
 939     }
 940
 941   for (i = 0; i < 2; i++)
 942     {
 943       if (_gtk_css_parser_try (parser, "stretch", TRUE))
 944         mods[i] = GTK_SLICE_STRETCH;
 945       else if (_gtk_css_parser_try (parser, "repeat", TRUE))
 946         mods[i] = GTK_SLICE_REPEAT;
 947       else if (i == 0)
 948         {
 949           mods[1] = mods[0] = GTK_SLICE_STRETCH;
 950           break;
 951         }
 952       else
 953         mods[i] = mods[0];
 954     }
 955
 956   path = g_file_get_path (file);
 957   g_object_unref (file);
 958   pixbuf = gdk_pixbuf_new_from_file (path, &error);
 959   g_free (path);
 960   if (!pixbuf)
 961     {
 962       _gtk_css_parser_take_error (parser, error);
 963       return FALSE;
 964     }
 965
 966   slice = _gtk_9slice_new (pixbuf,
 967                            distance_top, distance_bottom,
 968                            distance_left, distance_right,
 969                            mods[0], mods[1]);
 970   g_object_unref (pixbuf);
 971
 972   g_value_take_boxed (value, slice);
 973   return TRUE;
 974 }
 975
 976 static gboolean
 977 enum_value_parse (GtkCssParser *parser,
 978                   GFile        *base,
 979                   GValue       *value)
 980 {
 981   GEnumClass *enum_class;
 982   GEnumValue *enum_value;
 983   char *str;
 984
 985   str = _gtk_css_parser_try_ident (parser, TRUE);
 986   if (str == NULL)
 987     {
 988       _gtk_css_parser_error (parser, "Expected an identifier");
 989       return FALSE;
 990     }
 991
 992   enum_class = g_type_class_ref (G_VALUE_TYPE (value));
 993   enum_value = g_enum_get_value_by_nick (enum_class, str);
 994
 995   if (enum_value)
 996     g_value_set_enum (value, enum_value->value);
 997   else
 998     _gtk_css_parser_error (parser,
 999                            "Unknown value '%s' for enum type '%s'",
1000                            str, g_type_name (G_VALUE_TYPE (value)));
1001
1002   g_type_class_unref (enum_class);
1003   g_free (str);
1004
1005   return enum_value != NULL;
1006 }
1007
1008 static char *
1009 enum_value_to_string (const GValue *value)
1010 {
1011   GEnumClass *enum_class;
1012   GEnumValue *enum_value;
1013   char *s;
1014
1015   enum_class = g_type_class_ref (G_VALUE_TYPE (value));
1016   enum_value = g_enum_get_value (enum_class, g_value_get_enum (value));
1017
1018   s = g_strdup (enum_value->value_nick);
1019
1020   g_type_class_unref (enum_class);
1021
1022   return s;
1023 }
1024
1025 static gboolean
1026 flags_value_parse (GtkCssParser *parser,
1027                    GFile        *base,
1028                    GValue       *value)
1029 {
1030   GFlagsClass *flags_class;
1031   GFlagsValue *flag_value;
1032   guint flags = 0;
1033   char *str;
1034
1035   flags_class = g_type_class_ref (G_VALUE_TYPE (value));
1036
1037   do {
1038     str = _gtk_css_parser_try_ident (parser, TRUE);
1039     if (str == NULL)
1040       {
1041         _gtk_css_parser_error (parser, "Expected an identifier");
1042         g_type_class_unref (flags_class);
1043         return FALSE;
1044       }
1045
1046       flag_value = g_flags_get_value_by_nick (flags_class, str);
1047       if (!flag_value)
1048         {
1049           _gtk_css_parser_error (parser,
1050                                  "Unknown flag value '%s' for type '%s'",
1051                                  str, g_type_name (G_VALUE_TYPE (value)));
1052           /* XXX Do we want to return FALSE here? We can get
1053            * forward-compatibility for new values this way
1054            */
1055           g_free (str);
1056           g_type_class_unref (flags_class);
1057           return FALSE;
1058         }
1059
1060       g_free (str);
1061     }
1062   while (_gtk_css_parser_try (parser, ",", FALSE));
1063
1064   g_type_class_unref (flags_class);
1065
1066   g_value_set_enum (value, flags);
1067
1068   return TRUE;
1069 }
1070
1071 static char *
1072 flags_value_to_string (const GValue *value)
1073 {
1074   GFlagsClass *flags_class;
1075   GString *string;
1076   guint i, flags;
1077
1078   flags_class = g_type_class_ref (G_VALUE_TYPE (value));
1079   flags = g_value_get_flags (value);
1080   string = g_string_new (NULL);
1081
1082   for (i = 0; i < flags_class->n_values; i++)
1083     {
1084       GFlagsValue *flags_value = &flags_class->values[i];
1085
1086       if (flags & flags_value->value)
1087         {
1088           if (string->len != 0)
1089             g_string_append (string, ", ");
1090
1091           g_string_append (string, flags_value->value_nick);
1092         }
1093     }
1094
1095   g_type_class_unref (flags_class);
1096
1097   return g_string_free (string, FALSE);
1098 }
1099
1100 static gboolean
1101 bindings_value_parse (GtkCssParser *parser,
1102                       GFile        *base,
1103                       GValue       *value)
1104 {
1105   GPtrArray *array;
1106   GtkBindingSet *binding_set;
1107   char *name;
1108
1109   array = g_ptr_array_new ();
1110
1111   do {
1112       name = _gtk_css_parser_try_ident (parser, TRUE);
1113       if (name == NULL)
1114         {
1115           _gtk_css_parser_error (parser, "Not a valid binding name");
1116           g_ptr_array_free (array, TRUE);
1117           return FALSE;
1118         }
1119
1120       binding_set = gtk_binding_set_find (name);
1121
1122       if (!binding_set)
1123         {
1124           _gtk_css_parser_error (parser, "No binding set named '%s'", name);
1125           g_free (name);
1126           continue;
1127         }
1128
1129       g_ptr_array_add (array, binding_set);
1130       g_free (name);
1131     }
1132   while (_gtk_css_parser_try (parser, ",", TRUE));
1133
1134   g_value_take_boxed (value, array);
1135
1136   return TRUE;
1137 }
1138
1139 static char *
1140 bindings_value_to_string (const GValue *value)
1141 {
1142   GPtrArray *array;
1143   GString *str;
1144   guint i;
1145
1146   array = g_value_get_boxed (value);
1147   str = g_string_new (NULL);
1148
1149   for (i = 0; i < array->len; i++)
1150     {
1151       GtkBindingSet *binding_set = g_ptr_array_index (array, i);
1152
1153       if (i > 0)
1154         g_string_append (str, ", ");
1155       g_string_append (str, binding_set->set_name);
1156     }
1157
1158   return g_string_free (str, FALSE);
1159 }
1160
1161 /*** API ***/
1162
1163 static void
1164 css_string_funcs_init (void)
1165 {
1166   if (G_LIKELY (parse_funcs != NULL))
1167     return;
1168
1169   parse_funcs = g_hash_table_new (NULL, NULL);
1170   to_string_funcs = g_hash_table_new (NULL, NULL);
1171
1172   register_conversion_function (GDK_TYPE_RGBA,
1173                                 rgba_value_parse,
1174                                 rgba_value_to_string);
1175   register_conversion_function (GDK_TYPE_COLOR,
1176                                 color_value_parse,
1177                                 color_value_to_string);
1178   register_conversion_function (GTK_TYPE_SYMBOLIC_COLOR,
1179                                 symbolic_color_value_parse,
1180                                 symbolic_color_value_to_string);
1181   register_conversion_function (PANGO_TYPE_FONT_DESCRIPTION,
1182                                 font_description_value_parse,
1183                                 font_description_value_to_string);
1184   register_conversion_function (G_TYPE_BOOLEAN,
1185                                 boolean_value_parse,
1186                                 boolean_value_to_string);
1187   register_conversion_function (G_TYPE_INT,
1188                                 int_value_parse,
1189                                 int_value_to_string);
1190   register_conversion_function (G_TYPE_UINT,
1191                                 uint_value_parse,
1192                                 uint_value_to_string);
1193   register_conversion_function (G_TYPE_DOUBLE,
1194                                 double_value_parse,
1195                                 double_value_to_string);
1196   register_conversion_function (G_TYPE_FLOAT,
1197                                 float_value_parse,
1198                                 float_value_to_string);
1199   register_conversion_function (G_TYPE_STRING,
1200                                 string_value_parse,
1201                                 string_value_to_string);
1202   register_conversion_function (GTK_TYPE_THEMING_ENGINE,
1203                                 theming_engine_value_parse,
1204                                 theming_engine_value_to_string);
1205   register_conversion_function (GTK_TYPE_ANIMATION_DESCRIPTION,
1206                                 animation_description_value_parse,
1207                                 animation_description_value_to_string);
1208   register_conversion_function (GTK_TYPE_BORDER,
1209                                 border_value_parse,
1210                                 border_value_to_string);
1211   register_conversion_function (GTK_TYPE_GRADIENT,
1212                                 gradient_value_parse,
1213                                 gradient_value_to_string);
1214   register_conversion_function (CAIRO_GOBJECT_TYPE_PATTERN,
1215                                 pattern_value_parse,
1216                                 NULL);
1217   register_conversion_function (GTK_TYPE_9SLICE,
1218                                 slice_value_parse,
1219                                 NULL);
1220   register_conversion_function (GTK_TYPE_SHADOW,
1221                                 shadow_value_parse,
1222                                 shadow_value_to_string);
1223   register_conversion_function (G_TYPE_ENUM,
1224                                 enum_value_parse,
1225                                 enum_value_to_string);
1226   register_conversion_function (G_TYPE_FLAGS,
1227                                 flags_value_parse,
1228                                 flags_value_to_string);
1229   register_conversion_function (G_TYPE_PTR_ARRAY,
1230                                 bindings_value_parse,
1231                                 bindings_value_to_string);
1232 }
1233
1234 gboolean
1235 _gtk_css_value_parse (GValue       *value,
1236                       GtkCssParser *parser,
1237                       GFile        *base)
1238 {
1239   ParseFunc func;
1240
1241   g_return_val_if_fail (value != NULL, FALSE);
1242   g_return_val_if_fail (parser != NULL, FALSE);
1243
1244   css_string_funcs_init ();
1245
1246   func = g_hash_table_lookup (parse_funcs,
1247                               GSIZE_TO_POINTER (G_VALUE_TYPE (value)));
1248   if (func == NULL)
1249     func = g_hash_table_lookup (parse_funcs,
1250                                 GSIZE_TO_POINTER (g_type_fundamental (G_VALUE_TYPE (value))));
1251
1252   if (func == NULL)
1253     {
1254       _gtk_css_parser_error (parser,
1255                              "Cannot convert to type '%s'",
1256                              g_type_name (G_VALUE_TYPE (value)));
1257       return FALSE;
1258     }
1259
1260   return (*func) (parser, base, value);
1261 }
1262
1263 char *
1264 _gtk_css_value_to_string (const GValue *value)
1265 {
1266   ToStringFunc func;
1267
1268   css_string_funcs_init ();
1269
1270   func = g_hash_table_lookup (to_string_funcs,
1271                               GSIZE_TO_POINTER (G_VALUE_TYPE (value)));
1272   if (func == NULL)
1273     func = g_hash_table_lookup (to_string_funcs,
1274                                 GSIZE_TO_POINTER (g_type_fundamental (G_VALUE_TYPE (value))));
1275
1276   if (func)
1277     return func (value);
1278
1279   return g_strdup_value_contents (value);
1280 }