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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2010 Carlos Garnacho <carlosg@gnome.org>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "config.h"
  19
  20 #include "gtkstylepropertyprivate.h"
  21
  22 #include <gobject/gvaluecollector.h>
  23 #include <gdk-pixbuf/gdk-pixbuf.h>
  24 #include <cairo-gobject.h>
  25 #include <math.h>
  26
  27 #include "gtkcssparserprivate.h"
  28 #include "gtkcssstylefuncsprivate.h"
  29 #include "gtkcssstylepropertyprivate.h"
  30 #include "gtkcsstypesprivate.h"
  31 #include "gtkintl.h"
  32 #include "gtkprivatetypebuiltins.h"
  33 #include "gtkstylepropertiesprivate.h"
  34
  35 /* this is in case round() is not provided by the compiler,
  36  * such as in the case of C89 compilers, like MSVC
  37  */
  38 #include "fallback-c89.c"
  39
  40 /* the actual parsers we have */
  41 #include "gtkbindings.h"
  42 #include "gtkcssarrayvalueprivate.h"
  43 #include "gtkcssbgsizevalueprivate.h"
  44 #include "gtkcssbordervalueprivate.h"
  45 #include "gtkcsscornervalueprivate.h"
  46 #include "gtkcsseasevalueprivate.h"
  47 #include "gtkcssenginevalueprivate.h"
  48 #include "gtkcssimagegradientprivate.h"
  49 #include "gtkcssimageprivate.h"
  50 #include "gtkcssimagevalueprivate.h"
  51 #include "gtkcssenumvalueprivate.h"
  52 #include "gtkcssnumbervalueprivate.h"
  53 #include "gtkcsspositionvalueprivate.h"
  54 #include "gtkcssrepeatvalueprivate.h"
  55 #include "gtkcssrgbavalueprivate.h"
  56 #include "gtkcssshadowsvalueprivate.h"
  57 #include "gtkcssstringvalueprivate.h"
  58 #include "gtksymboliccolorprivate.h"
  59 #include "gtkthemingengine.h"
  60 #include "gtktypebuiltins.h"
  61 #include "gtkwin32themeprivate.h"
  62
  63 /*** REGISTRATION ***/
  64
  65 typedef enum {
  66   GTK_STYLE_PROPERTY_INHERIT = (1 << 0),
  67   GTK_STYLE_PROPERTY_ANIMATED = (1 << 1)
  68 } GtkStylePropertyFlags;
  69
  70 static void
  71 gtk_css_style_property_register (const char *                   name,
  72                                  guint                          expected_id,
  73                                  GType                          value_type,
  74                                  GtkStylePropertyFlags          flags,
  75                                  GtkCssStylePropertyParseFunc   parse_value,
  76                                  GtkCssStylePropertyPrintFunc   print_value,
  77                                  GtkCssStylePropertyComputeFunc compute_value,
  78                                  GtkCssStylePropertyQueryFunc   query_value,
  79                                  GtkCssStylePropertyAssignFunc  assign_value,
  80                                  GtkCssValue *                  initial_value)
  81 {
  82   GtkCssStyleProperty *node;
  83
  84   g_assert (initial_value != NULL);
  85   g_assert (parse_value != NULL);
  86   g_assert (value_type == G_TYPE_NONE || query_value != NULL);
  87   g_assert (value_type == G_TYPE_NONE || assign_value != NULL);
  88
  89   node = g_object_new (GTK_TYPE_CSS_STYLE_PROPERTY,
  90                        "value-type", value_type,
  91                        "animated", (flags & GTK_STYLE_PROPERTY_ANIMATED) ? TRUE : FALSE,
  92                        "inherit", (flags & GTK_STYLE_PROPERTY_INHERIT) ? TRUE : FALSE,
  93                        "initial-value", initial_value,
  94                        "name", name,
  95                        NULL);
  96
  97   node->parse_value = parse_value;
  98   if (print_value)
  99     node->print_value = print_value;
 100   if (compute_value)
 101     node->compute_value = compute_value;
 102   node->query_value = query_value;
 103   node->assign_value = assign_value;
 104
 105   _gtk_css_value_unref (initial_value);
 106
 107   g_assert (_gtk_css_style_property_get_id (node) == expected_id);
 108 }
 109
 110 /*** IMPLEMENTATIONS ***/
 111
 112 static void
 113 query_length_as_int (GtkCssStyleProperty *property,
 114                      const GtkCssValue   *css_value,
 115                      GValue              *value)
 116 {
 117   g_value_init (value, G_TYPE_INT);
 118   g_value_set_int (value, round (_gtk_css_number_value_get (css_value, 100)));
 119 }
 120
 121 static GtkCssValue *
 122 assign_length_from_int (GtkCssStyleProperty *property,
 123                         const GValue        *value)
 124 {
 125   return _gtk_css_number_value_new (g_value_get_int (value), GTK_CSS_PX);
 126 }
 127
 128 static void
 129 query_length_as_double (GtkCssStyleProperty *property,
 130                         const GtkCssValue   *css_value,
 131                         GValue              *value)
 132 {
 133   g_value_init (value, G_TYPE_DOUBLE);
 134   g_value_set_double (value, _gtk_css_number_value_get (css_value, 100));
 135 }
 136
 137 static GtkCssValue *
 138 assign_length_from_double (GtkCssStyleProperty *property,
 139                            const GValue        *value)
 140 {
 141   return _gtk_css_number_value_new (g_value_get_double (value), GTK_CSS_PX);
 142 }
 143
 144 static void
 145 query_border (GtkCssStyleProperty *property,
 146               const GtkCssValue   *css_value,
 147               GValue              *value)
 148 {
 149   GtkBorder border;
 150
 151   g_value_init (value, GTK_TYPE_BORDER);
 152
 153   border.top = round (_gtk_css_number_value_get (_gtk_css_border_value_get_top (css_value), 100));
 154   border.right = round (_gtk_css_number_value_get (_gtk_css_border_value_get_right (css_value), 100));
 155   border.bottom = round (_gtk_css_number_value_get (_gtk_css_border_value_get_bottom (css_value), 100));
 156   border.left = round (_gtk_css_number_value_get (_gtk_css_border_value_get_left (css_value), 100));
 157
 158   g_value_set_boxed (value, &border);
 159 }
 160
 161 static GtkCssValue *
 162 assign_border (GtkCssStyleProperty *property,
 163                const GValue        *value)
 164 {
 165   const GtkBorder *border = g_value_get_boxed (value);
 166
 167   if (border == NULL)
 168     return _gtk_css_value_ref (_gtk_css_style_property_get_initial_value (property));
 169   else
 170     return _gtk_css_border_value_new (_gtk_css_number_value_new (border->top, GTK_CSS_PX),
 171                                       _gtk_css_number_value_new (border->right, GTK_CSS_PX),
 172                                       _gtk_css_number_value_new (border->bottom, GTK_CSS_PX),
 173                                       _gtk_css_number_value_new (border->left, GTK_CSS_PX));
 174 }
 175
 176 static GtkCssValue *
 177 color_parse (GtkCssStyleProperty *property,
 178              GtkCssParser        *parser)
 179 {
 180   return _gtk_css_symbolic_value_new (parser);
 181 }
 182
 183 static void
 184 color_query (GtkCssStyleProperty *property,
 185              const GtkCssValue   *css_value,
 186              GValue              *value)
 187 {
 188   g_value_init (value, GDK_TYPE_RGBA);
 189   g_value_set_boxed (value, _gtk_css_rgba_value_get_rgba (css_value));
 190 }
 191
 192 static GtkCssValue *
 193 color_assign (GtkCssStyleProperty *property,
 194               const GValue        *value)
 195 {
 196   return _gtk_css_rgba_value_new_from_rgba (g_value_get_boxed (value));
 197 }
 198
 199 static GtkCssValue *
 200 font_family_parse_one (GtkCssParser *parser)
 201 {
 202   char *name;
 203
 204   name = _gtk_css_parser_try_ident (parser, TRUE);
 205   if (name)
 206     {
 207       GString *string = g_string_new (name);
 208       g_free (name);
 209       while ((name = _gtk_css_parser_try_ident (parser, TRUE)))
 210         {
 211           g_string_append_c (string, ' ');
 212           g_string_append (string, name);
 213           g_free (name);
 214         }
 215       name = g_string_free (string, FALSE);
 216     }
 217   else
 218     {
 219       name = _gtk_css_parser_read_string (parser);
 220       if (name == NULL)
 221         return NULL;
 222     }
 223
 224   return _gtk_css_string_value_new_take (name);
 225 }
 226
 227 static GtkCssValue *
 228 font_family_parse (GtkCssStyleProperty *property,
 229                    GtkCssParser        *parser)
 230 {
 231   return _gtk_css_array_value_parse (parser, font_family_parse_one, FALSE);
 232 }
 233
 234 static void
 235 font_family_query (GtkCssStyleProperty *property,
 236                    const GtkCssValue   *css_value,
 237                    GValue              *value)
 238 {
 239   GPtrArray *array;
 240   guint i;
 241
 242   array = g_ptr_array_new ();
 243
 244   for (i = 0; i < _gtk_css_array_value_get_n_values (css_value); i++)
 245     {
 246       g_ptr_array_add (array, g_strdup (_gtk_css_string_value_get (_gtk_css_array_value_get_nth (css_value, i))));
 247     }
 248
 249   /* NULL-terminate */
 250   g_ptr_array_add (array, NULL);
 251
 252   g_value_init (value, G_TYPE_STRV);
 253   g_value_set_boxed (value, g_ptr_array_free (array, FALSE));
 254 }
 255
 256 static GtkCssValue *
 257 font_family_assign (GtkCssStyleProperty *property,
 258                     const GValue        *value)
 259 {
 260   const char **names = g_value_get_boxed (value);
 261   GtkCssValue *result;
 262   GPtrArray *array;
 263
 264   array = g_ptr_array_new ();
 265
 266   for (names = g_value_get_boxed (value); *names; names++)
 267     {
 268       g_ptr_array_add (array, _gtk_css_string_value_new (*names));
 269     }
 270
 271   result = _gtk_css_array_value_new_from_array ((GtkCssValue **) array->pdata, array->len);
 272   g_ptr_array_free (array, TRUE);
 273   return result;
 274 }
 275
 276 static GtkCssValue *
 277 parse_pango_style (GtkCssStyleProperty *property,
 278                    GtkCssParser        *parser)
 279 {
 280   GtkCssValue *value = _gtk_css_font_style_value_try_parse (parser);
 281
 282   if (value == NULL)
 283     _gtk_css_parser_error (parser, "unknown value for property");
 284
 285   return value;
 286 }
 287
 288 static void
 289 query_pango_style (GtkCssStyleProperty *property,
 290                     const GtkCssValue   *css_value,
 291                     GValue              *value)
 292 {
 293   g_value_init (value, PANGO_TYPE_STYLE);
 294   g_value_set_enum (value, _gtk_css_font_style_value_get (css_value));
 295 }
 296
 297 static GtkCssValue *
 298 assign_pango_style (GtkCssStyleProperty *property,
 299                     const GValue        *value)
 300 {
 301   return _gtk_css_font_style_value_new (g_value_get_enum (value));
 302 }
 303
 304 static GtkCssValue *
 305 parse_pango_weight (GtkCssStyleProperty *property,
 306                     GtkCssParser        *parser)
 307 {
 308   GtkCssValue *value = _gtk_css_font_weight_value_try_parse (parser);
 309
 310   if (value == NULL)
 311     _gtk_css_parser_error (parser, "unknown value for property");
 312
 313   return value;
 314 }
 315
 316 static void
 317 query_pango_weight (GtkCssStyleProperty *property,
 318                     const GtkCssValue   *css_value,
 319                     GValue              *value)
 320 {
 321   g_value_init (value, PANGO_TYPE_WEIGHT);
 322   g_value_set_enum (value, _gtk_css_font_weight_value_get (css_value));
 323 }
 324
 325 static GtkCssValue *
 326 assign_pango_weight (GtkCssStyleProperty *property,
 327                      const GValue        *value)
 328 {
 329   return _gtk_css_font_weight_value_new (g_value_get_enum (value));
 330 }
 331
 332 static GtkCssValue *
 333 parse_pango_variant (GtkCssStyleProperty *property,
 334                      GtkCssParser        *parser)
 335 {
 336   GtkCssValue *value = _gtk_css_font_variant_value_try_parse (parser);
 337
 338   if (value == NULL)
 339     _gtk_css_parser_error (parser, "unknown value for property");
 340
 341   return value;
 342 }
 343
 344 static void
 345 query_pango_variant (GtkCssStyleProperty *property,
 346                      const GtkCssValue   *css_value,
 347                      GValue              *value)
 348 {
 349   g_value_init (value, PANGO_TYPE_VARIANT);
 350   g_value_set_enum (value, _gtk_css_font_variant_value_get (css_value));
 351 }
 352
 353 static GtkCssValue *
 354 assign_pango_variant (GtkCssStyleProperty *property,
 355                       const GValue        *value)
 356 {
 357   return _gtk_css_font_variant_value_new (g_value_get_enum (value));
 358 }
 359
 360 static GtkCssValue *
 361 parse_border_style (GtkCssStyleProperty *property,
 362                     GtkCssParser        *parser)
 363 {
 364   GtkCssValue *value = _gtk_css_border_style_value_try_parse (parser);
 365
 366   if (value == NULL)
 367     _gtk_css_parser_error (parser, "unknown value for property");
 368
 369   return value;
 370 }
 371
 372 static void
 373 query_border_style (GtkCssStyleProperty *property,
 374                     const GtkCssValue   *css_value,
 375                     GValue              *value)
 376 {
 377   g_value_init (value, GTK_TYPE_BORDER_STYLE);
 378   g_value_set_enum (value, _gtk_css_border_style_value_get (css_value));
 379 }
 380
 381 static GtkCssValue *
 382 assign_border_style (GtkCssStyleProperty *property,
 383                      const GValue        *value)
 384 {
 385   return _gtk_css_border_style_value_new (g_value_get_enum (value));
 386 }
 387
 388 static GtkCssValue *
 389 parse_css_area_one (GtkCssParser *parser)
 390 {
 391   GtkCssValue *value = _gtk_css_area_value_try_parse (parser);
 392
 393   if (value == NULL)
 394     _gtk_css_parser_error (parser, "unknown value for property");
 395
 396   return value;
 397 }
 398
 399 static GtkCssValue *
 400 parse_css_area (GtkCssStyleProperty *property,
 401                 GtkCssParser        *parser)
 402 {
 403   return _gtk_css_array_value_parse (parser, parse_css_area_one, FALSE);
 404 }
 405
 406 static GtkCssValue *
 407 bindings_value_parse_one (GtkCssParser *parser)
 408 {
 409   char *name;
 410
 411   name = _gtk_css_parser_try_ident (parser, TRUE);
 412   if (name == NULL)
 413     {
 414       _gtk_css_parser_error (parser, "Not a valid binding name");
 415       return NULL;
 416     }
 417
 418
 419   if (!gtk_binding_set_find (name))
 420     {
 421       _gtk_css_parser_error (parser, "No binding set named '%s'", name);
 422       g_free (name);
 423       return NULL;
 424     }
 425
 426   return _gtk_css_string_value_new_take (name);
 427 }
 428
 429 static GtkCssValue *
 430 bindings_value_parse (GtkCssStyleProperty *property,
 431                       GtkCssParser        *parser)
 432 {
 433   return _gtk_css_array_value_parse (parser, bindings_value_parse_one, TRUE);
 434 }
 435
 436 static void
 437 bindings_value_query (GtkCssStyleProperty *property,
 438                       const GtkCssValue   *css_value,
 439                       GValue              *value)
 440 {
 441   GPtrArray *array;
 442   guint i;
 443
 444   g_value_init (value, G_TYPE_PTR_ARRAY);
 445
 446   if (_gtk_css_array_value_get_n_values (css_value) == 0)
 447     return;
 448
 449   array = g_ptr_array_new ();
 450
 451   for (i = 0; i < _gtk_css_array_value_get_n_values (css_value); i++)
 452     {
 453       GtkBindingSet *binding_set = gtk_binding_set_find (_gtk_css_string_value_get (_gtk_css_array_value_get_nth (css_value, i)));
 454
 455       g_ptr_array_add (array, binding_set);
 456     }
 457
 458   g_value_take_boxed (value, array);
 459 }
 460
 461 static GtkCssValue *
 462 bindings_value_assign (GtkCssStyleProperty *property,
 463                        const GValue        *value)
 464 {
 465   GPtrArray *binding_sets = g_value_get_boxed (value);
 466   GtkCssValue **values, *result;
 467   guint i;
 468
 469   if (binding_sets == NULL || binding_sets->len == 0)
 470     return _gtk_css_array_value_new (NULL);
 471
 472   values = g_new (GtkCssValue *, binding_sets->len);
 473
 474   for (i = 0; i < binding_sets->len; i++)
 475     {
 476       GtkBindingSet *binding_set = g_ptr_array_index (binding_sets, i);
 477       values[i] = _gtk_css_string_value_new (binding_set->set_name);
 478     }
 479
 480   result = _gtk_css_array_value_new_from_array (values, binding_sets->len);
 481   g_free (values);
 482   return result;
 483 }
 484
 485 static GtkCssValue *
 486 shadow_value_parse (GtkCssStyleProperty *property,
 487                     GtkCssParser        *parser)
 488 {
 489   return _gtk_css_shadows_value_parse (parser);
 490 }
 491
 492 static GtkCssValue *
 493 border_corner_radius_value_parse (GtkCssStyleProperty *property,
 494                                   GtkCssParser        *parser)
 495 {
 496   return _gtk_css_corner_value_parse (parser);
 497 }
 498
 499 static GtkCssValue *
 500 css_image_value_parse (GtkCssStyleProperty *property,
 501                        GtkCssParser        *parser)
 502 {
 503   GtkCssImage *image;
 504
 505   if (_gtk_css_parser_try (parser, "none", TRUE))
 506     image = NULL;
 507   else
 508     {
 509       image = _gtk_css_image_new_parse (parser);
 510       if (image == NULL)
 511         return FALSE;
 512     }
 513
 514   return _gtk_css_image_value_new (image);
 515 }
 516
 517 static void
 518 css_image_value_query (GtkCssStyleProperty *property,
 519                        const GtkCssValue   *css_value,
 520                        GValue              *value)
 521 {
 522   GtkCssImage *image = _gtk_css_image_value_get_image (css_value);
 523   cairo_pattern_t *pattern;
 524   cairo_surface_t *surface;
 525   cairo_matrix_t matrix;
 526
 527   g_value_init (value, CAIRO_GOBJECT_TYPE_PATTERN);
 528
 529   if (GTK_IS_CSS_IMAGE_GRADIENT (image))
 530     g_value_set_boxed (value, GTK_CSS_IMAGE_GRADIENT (image)->pattern);
 531   else if (image != NULL)
 532     {
 533       double width, height;
 534
 535       /* the 100, 100 is rather random */
 536       _gtk_css_image_get_concrete_size (image, 0, 0, 100, 100, &width, &height);
 537       surface = _gtk_css_image_get_surface (image, NULL, width, height);
 538       pattern = cairo_pattern_create_for_surface (surface);
 539       cairo_matrix_init_scale (&matrix, width, height);
 540       cairo_pattern_set_matrix (pattern, &matrix);
 541       cairo_surface_destroy (surface);
 542       g_value_take_boxed (value, pattern);
 543     }
 544 }
 545
 546 static GtkCssValue *
 547 css_image_value_assign (GtkCssStyleProperty *property,
 548                         const GValue        *value)
 549 {
 550   g_warning ("FIXME: assigning images is not implemented");
 551   return _gtk_css_image_value_new (NULL);
 552 }
 553
 554 static GtkCssValue *
 555 background_image_value_parse_one (GtkCssParser *parser)
 556 {
 557   return css_image_value_parse (NULL, parser);
 558 }
 559
 560 static GtkCssValue *
 561 background_image_value_parse (GtkCssStyleProperty *property,
 562                               GtkCssParser        *parser)
 563 {
 564   return _gtk_css_array_value_parse (parser, background_image_value_parse_one, FALSE);
 565 }
 566
 567 static void
 568 background_image_value_query (GtkCssStyleProperty *property,
 569                               const GtkCssValue   *css_value,
 570                               GValue              *value)
 571 {
 572   css_image_value_query (property, _gtk_css_array_value_get_nth (css_value, 0), value);
 573 }
 574
 575 static GtkCssValue *
 576 background_image_value_assign (GtkCssStyleProperty *property,
 577                                const GValue        *value)
 578 {
 579   return _gtk_css_array_value_new (css_image_value_assign (property, value));
 580 }
 581
 582 static GtkCssValue *
 583 font_size_parse (GtkCssStyleProperty *property,
 584                  GtkCssParser        *parser)
 585 {
 586   gdouble d;
 587
 588   if (!_gtk_css_parser_try_double (parser, &d))
 589     {
 590       _gtk_css_parser_error (parser, "Expected a number");
 591       return NULL;
 592     }
 593
 594   return _gtk_css_number_value_new (d, GTK_CSS_PX);
 595 }
 596
 597 static GtkCssValue *
 598 outline_parse (GtkCssStyleProperty *property,
 599                GtkCssParser        *parser)
 600 {
 601   return _gtk_css_number_value_parse (parser,
 602                                       GTK_CSS_NUMBER_AS_PIXELS
 603                                       | GTK_CSS_PARSE_LENGTH);
 604 }
 605
 606 static GtkCssValue *
 607 border_image_repeat_parse (GtkCssStyleProperty *property,
 608                            GtkCssParser        *parser)
 609 {
 610   GtkCssValue *value = _gtk_css_border_repeat_value_try_parse (parser);
 611
 612   if (value == NULL)
 613     {
 614       _gtk_css_parser_error (parser, "Not a valid value");
 615       return NULL;
 616     }
 617
 618   return value;
 619 }
 620
 621 static GtkCssValue *
 622 border_image_slice_parse (GtkCssStyleProperty *property,
 623                           GtkCssParser        *parser)
 624 {
 625   return _gtk_css_border_value_parse (parser,
 626                                       GTK_CSS_PARSE_PERCENT
 627                                       | GTK_CSS_PARSE_NUMBER
 628                                       | GTK_CSS_POSITIVE_ONLY,
 629                                       FALSE,
 630                                       TRUE);
 631 }
 632
 633 static GtkCssValue *
 634 border_image_width_parse (GtkCssStyleProperty *property,
 635                           GtkCssParser        *parser)
 636 {
 637   return _gtk_css_border_value_parse (parser,
 638                                       GTK_CSS_PARSE_PERCENT
 639                                       | GTK_CSS_PARSE_LENGTH
 640                                       | GTK_CSS_PARSE_NUMBER
 641                                       | GTK_CSS_POSITIVE_ONLY,
 642                                       TRUE,
 643                                       FALSE);
 644 }
 645
 646 static GtkCssValue *
 647 transition_property_parse_one (GtkCssParser *parser)
 648 {
 649   GtkCssValue *value;
 650
 651   value = _gtk_css_ident_value_try_parse (parser);
 652
 653   if (value == NULL)
 654     {
 655       _gtk_css_parser_error (parser, "Expected an identifier");
 656       return NULL;
 657     }
 658
 659   return value;
 660 }
 661
 662 static GtkCssValue *
 663 transition_property_parse (GtkCssStyleProperty *property,
 664                            GtkCssParser        *parser)
 665 {
 666   return _gtk_css_array_value_parse (parser, transition_property_parse_one, FALSE);
 667 }
 668
 669 static GtkCssValue *
 670 transition_time_parse_one (GtkCssParser *parser)
 671 {
 672   return _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_TIME);
 673 }
 674
 675 static GtkCssValue *
 676 transition_time_parse (GtkCssStyleProperty *property,
 677                        GtkCssParser        *parser)
 678 {
 679   return _gtk_css_array_value_parse (parser, transition_time_parse_one, FALSE);
 680 }
 681
 682 static GtkCssValue *
 683 transition_timing_function_parse (GtkCssStyleProperty *property,
 684                                   GtkCssParser        *parser)
 685 {
 686   return _gtk_css_array_value_parse (parser, _gtk_css_ease_value_parse, FALSE);
 687 }
 688
 689 static GtkCssValue *
 690 engine_parse (GtkCssStyleProperty *property,
 691               GtkCssParser        *parser)
 692 {
 693   return _gtk_css_engine_value_parse (parser);
 694 }
 695
 696 static void
 697 engine_query (GtkCssStyleProperty *property,
 698               const GtkCssValue   *css_value,
 699               GValue              *value)
 700 {
 701   g_value_init (value, GTK_TYPE_THEMING_ENGINE);
 702   g_value_set_object (value, _gtk_css_engine_value_get_engine (css_value));
 703 }
 704
 705 static GtkCssValue *
 706 engine_assign (GtkCssStyleProperty *property,
 707                const GValue        *value)
 708 {
 709   return _gtk_css_engine_value_new (g_value_get_object (value));
 710 }
 711
 712 static GtkCssValue *
 713 parse_margin (GtkCssStyleProperty *property,
 714               GtkCssParser        *parser)
 715 {
 716   return _gtk_css_number_value_parse (parser,
 717                                       GTK_CSS_NUMBER_AS_PIXELS
 718                                       | GTK_CSS_PARSE_LENGTH);
 719 }
 720
 721 static GtkCssValue *
 722 parse_padding (GtkCssStyleProperty *property,
 723                GtkCssParser        *parser)
 724 {
 725   return _gtk_css_number_value_parse (parser,
 726                                       GTK_CSS_POSITIVE_ONLY
 727                                       | GTK_CSS_NUMBER_AS_PIXELS
 728                                       | GTK_CSS_PARSE_LENGTH);
 729 }
 730
 731 static GtkCssValue *
 732 parse_border_width (GtkCssStyleProperty *property,
 733                     GtkCssParser        *parser)
 734 {
 735   return _gtk_css_number_value_parse (parser,
 736                                       GTK_CSS_POSITIVE_ONLY
 737                                       | GTK_CSS_NUMBER_AS_PIXELS
 738                                       | GTK_CSS_PARSE_LENGTH);
 739 }
 740
 741 static GtkCssValue *
 742 background_repeat_value_parse_one (GtkCssParser *parser)
 743 {
 744   GtkCssValue *value = _gtk_css_background_repeat_value_try_parse (parser);
 745
 746   if (value == NULL)
 747     {
 748       _gtk_css_parser_error (parser, "Not a valid value");
 749       return NULL;
 750     }
 751
 752   return value;
 753 }
 754
 755 static GtkCssValue *
 756 background_repeat_value_parse (GtkCssStyleProperty *property,
 757                                GtkCssParser        *parser)
 758 {
 759   return _gtk_css_array_value_parse (parser, background_repeat_value_parse_one, FALSE);
 760 }
 761
 762 static GtkCssValue *
 763 background_size_parse (GtkCssStyleProperty *property,
 764                        GtkCssParser        *parser)
 765 {
 766   return _gtk_css_array_value_parse (parser, _gtk_css_bg_size_value_parse, FALSE);
 767 }
 768
 769 static GtkCssValue *
 770 background_position_parse (GtkCssStyleProperty *property,
 771                            GtkCssParser        *parser)
 772 {
 773   return _gtk_css_array_value_parse (parser, _gtk_css_position_value_parse, FALSE);
 774 }
 775
 776 /*** REGISTRATION ***/
 777
 778 static GtkSymbolicColor *
 779 gtk_symbolic_color_new_rgba (double red,
 780                              double green,
 781                              double blue,
 782                              double alpha)
 783 {
 784   GdkRGBA rgba = { red, green, blue, alpha };
 785
 786   return gtk_symbolic_color_new_literal (&rgba);
 787 }
 788
 789 void
 790 _gtk_css_style_property_init_properties (void)
 791 {
 792   /* Initialize "color" and "font-size" first,
 793    * so that when computing values later they are
 794    * done first. That way, 'currentColor' and font
 795    * sizes in em can be looked up properly */
 796   gtk_css_style_property_register        ("color",
 797                                           GTK_CSS_PROPERTY_COLOR,
 798                                           GDK_TYPE_RGBA,
 799                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
 800                                           color_parse,
 801                                           NULL,
 802                                           NULL,
 803                                           color_query,
 804                                           color_assign,
 805                                           _gtk_css_symbolic_value_new_take_symbolic_color (
 806                                             gtk_symbolic_color_new_rgba (1, 1, 1, 1)));
 807   gtk_css_style_property_register        ("font-size",
 808                                           GTK_CSS_PROPERTY_FONT_SIZE,
 809                                           G_TYPE_DOUBLE,
 810                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
 811                                           font_size_parse,
 812                                           NULL,
 813                                           NULL,
 814                                           query_length_as_double,
 815                                           assign_length_from_double,
 816                                           /* XXX: This should be 'normal' */
 817                                           _gtk_css_number_value_new (10.0, GTK_CSS_PX));
 818
 819   /* properties that aren't referenced when computing values
 820    * start here */
 821   gtk_css_style_property_register        ("background-color",
 822                                           GTK_CSS_PROPERTY_BACKGROUND_COLOR,
 823                                           GDK_TYPE_RGBA,
 824                                           GTK_STYLE_PROPERTY_ANIMATED,
 825                                           color_parse,
 826                                           NULL,
 827                                           NULL,
 828                                           color_query,
 829                                           color_assign,
 830                                           _gtk_css_symbolic_value_new_take_symbolic_color (
 831                                             gtk_symbolic_color_new_rgba (0, 0, 0, 0)));
 832
 833   gtk_css_style_property_register        ("font-family",
 834                                           GTK_CSS_PROPERTY_FONT_FAMILY,
 835                                           G_TYPE_STRV,
 836                                           GTK_STYLE_PROPERTY_INHERIT,
 837                                           font_family_parse,
 838                                           NULL,
 839                                           NULL,
 840                                           font_family_query,
 841                                           font_family_assign,
 842                                           _gtk_css_array_value_new (_gtk_css_string_value_new ("Sans")));
 843   gtk_css_style_property_register        ("font-style",
 844                                           GTK_CSS_PROPERTY_FONT_STYLE,
 845                                           PANGO_TYPE_STYLE,
 846                                           GTK_STYLE_PROPERTY_INHERIT,
 847                                           parse_pango_style,
 848                                           NULL,
 849                                           NULL,
 850                                           query_pango_style,
 851                                           assign_pango_style,
 852                                           _gtk_css_font_style_value_new (PANGO_STYLE_NORMAL));
 853   gtk_css_style_property_register        ("font-variant",
 854                                           GTK_CSS_PROPERTY_FONT_VARIANT,
 855                                           PANGO_TYPE_VARIANT,
 856                                           GTK_STYLE_PROPERTY_INHERIT,
 857                                           parse_pango_variant,
 858                                           NULL,
 859                                           NULL,
 860                                           query_pango_variant,
 861                                           assign_pango_variant,
 862                                           _gtk_css_font_variant_value_new (PANGO_VARIANT_NORMAL));
 863   gtk_css_style_property_register        ("font-weight",
 864                                           GTK_CSS_PROPERTY_FONT_WEIGHT,
 865                                           PANGO_TYPE_WEIGHT,
 866                                           GTK_STYLE_PROPERTY_INHERIT,
 867                                           parse_pango_weight,
 868                                           NULL,
 869                                           NULL,
 870                                           query_pango_weight,
 871                                           assign_pango_weight,
 872                                           _gtk_css_font_weight_value_new (PANGO_WEIGHT_NORMAL));
 873
 874   gtk_css_style_property_register        ("text-shadow",
 875                                           GTK_CSS_PROPERTY_TEXT_SHADOW,
 876                                           G_TYPE_NONE,
 877                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
 878                                           shadow_value_parse,
 879                                           NULL,
 880                                           NULL,
 881                                           NULL,
 882                                           NULL,
 883                                           _gtk_css_shadows_value_new_none ());
 884
 885   gtk_css_style_property_register        ("icon-shadow",
 886                                           GTK_CSS_PROPERTY_ICON_SHADOW,
 887                                           G_TYPE_NONE,
 888                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
 889                                           shadow_value_parse,
 890                                           NULL,
 891                                           NULL,
 892                                           NULL,
 893                                           NULL,
 894                                           _gtk_css_shadows_value_new_none ());
 895
 896   gtk_css_style_property_register        ("box-shadow",
 897                                           GTK_CSS_PROPERTY_BOX_SHADOW,
 898                                           G_TYPE_NONE,
 899                                           GTK_STYLE_PROPERTY_ANIMATED,
 900                                           shadow_value_parse,
 901                                           NULL,
 902                                           NULL,
 903                                           NULL,
 904                                           NULL,
 905                                           _gtk_css_shadows_value_new_none ());
 906
 907   gtk_css_style_property_register        ("margin-top",
 908                                           GTK_CSS_PROPERTY_MARGIN_TOP,
 909                                           G_TYPE_INT,
 910                                           GTK_STYLE_PROPERTY_ANIMATED,
 911                                           parse_margin,
 912                                           NULL,
 913                                           NULL,
 914                                           query_length_as_int,
 915                                           assign_length_from_int,
 916                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
 917   gtk_css_style_property_register        ("margin-left",
 918                                           GTK_CSS_PROPERTY_MARGIN_LEFT,
 919                                           G_TYPE_INT,
 920                                           GTK_STYLE_PROPERTY_ANIMATED,
 921                                           parse_margin,
 922                                           NULL,
 923                                           NULL,
 924                                           query_length_as_int,
 925                                           assign_length_from_int,
 926                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
 927   gtk_css_style_property_register        ("margin-bottom",
 928                                           GTK_CSS_PROPERTY_MARGIN_BOTTOM,
 929                                           G_TYPE_INT,
 930                                           GTK_STYLE_PROPERTY_ANIMATED,
 931                                           parse_margin,
 932                                           NULL,
 933                                           NULL,
 934                                           query_length_as_int,
 935                                           assign_length_from_int,
 936                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
 937   gtk_css_style_property_register        ("margin-right",
 938                                           GTK_CSS_PROPERTY_MARGIN_RIGHT,
 939                                           G_TYPE_INT,
 940                                           GTK_STYLE_PROPERTY_ANIMATED,
 941                                           parse_margin,
 942                                           NULL,
 943                                           NULL,
 944                                           query_length_as_int,
 945                                           assign_length_from_int,
 946                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
 947   gtk_css_style_property_register        ("padding-top",
 948                                           GTK_CSS_PROPERTY_PADDING_TOP,
 949                                           G_TYPE_INT,
 950                                           GTK_STYLE_PROPERTY_ANIMATED,
 951                                           parse_padding,
 952                                           NULL,
 953                                           NULL,
 954                                           query_length_as_int,
 955                                           assign_length_from_int,
 956                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
 957   gtk_css_style_property_register        ("padding-left",
 958                                           GTK_CSS_PROPERTY_PADDING_LEFT,
 959                                           G_TYPE_INT,
 960                                           GTK_STYLE_PROPERTY_ANIMATED,
 961                                           parse_padding,
 962                                           NULL,
 963                                           NULL,
 964                                           query_length_as_int,
 965                                           assign_length_from_int,
 966                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
 967   gtk_css_style_property_register        ("padding-bottom",
 968                                           GTK_CSS_PROPERTY_PADDING_BOTTOM,
 969                                           G_TYPE_INT,
 970                                           GTK_STYLE_PROPERTY_ANIMATED,
 971                                           parse_padding,
 972                                           NULL,
 973                                           NULL,
 974                                           query_length_as_int,
 975                                           assign_length_from_int,
 976                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
 977   gtk_css_style_property_register        ("padding-right",
 978                                           GTK_CSS_PROPERTY_PADDING_RIGHT,
 979                                           G_TYPE_INT,
 980                                           GTK_STYLE_PROPERTY_ANIMATED,
 981                                           parse_padding,
 982                                           NULL,
 983                                           NULL,
 984                                           query_length_as_int,
 985                                           assign_length_from_int,
 986                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
 987   /* IMPORTANT: the border-width properties must come after border-style properties,
 988    * they depend on them for their value computation.
 989    */
 990   gtk_css_style_property_register        ("border-top-style",
 991                                           GTK_CSS_PROPERTY_BORDER_TOP_STYLE,
 992                                           GTK_TYPE_BORDER_STYLE,
 993                                           0,
 994                                           parse_border_style,
 995                                           NULL,
 996                                           NULL,
 997                                           query_border_style,
 998                                           assign_border_style,
 999                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1000   gtk_css_style_property_register        ("border-top-width",
1001                                           GTK_CSS_PROPERTY_BORDER_TOP_WIDTH,
1002                                           G_TYPE_INT,
1003                                           GTK_STYLE_PROPERTY_ANIMATED,
1004                                           parse_border_width,
1005                                           NULL,
1006                                           NULL,
1007                                           query_length_as_int,
1008                                           assign_length_from_int,
1009                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1010   gtk_css_style_property_register        ("border-left-style",
1011                                           GTK_CSS_PROPERTY_BORDER_LEFT_STYLE,
1012                                           GTK_TYPE_BORDER_STYLE,
1013                                           0,
1014                                           parse_border_style,
1015                                           NULL,
1016                                           NULL,
1017                                           query_border_style,
1018                                           assign_border_style,
1019                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1020   gtk_css_style_property_register        ("border-left-width",
1021                                           GTK_CSS_PROPERTY_BORDER_LEFT_WIDTH,
1022                                           G_TYPE_INT,
1023                                           GTK_STYLE_PROPERTY_ANIMATED,
1024                                           parse_border_width,
1025                                           NULL,
1026                                           NULL,
1027                                           query_length_as_int,
1028                                           assign_length_from_int,
1029                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1030   gtk_css_style_property_register        ("border-bottom-style",
1031                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_STYLE,
1032                                           GTK_TYPE_BORDER_STYLE,
1033                                           0,
1034                                           parse_border_style,
1035                                           NULL,
1036                                           NULL,
1037                                           query_border_style,
1038                                           assign_border_style,
1039                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1040   gtk_css_style_property_register        ("border-bottom-width",
1041                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_WIDTH,
1042                                           G_TYPE_INT,
1043                                           GTK_STYLE_PROPERTY_ANIMATED,
1044                                           parse_border_width,
1045                                           NULL,
1046                                           NULL,
1047                                           query_length_as_int,
1048                                           assign_length_from_int,
1049                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1050   gtk_css_style_property_register        ("border-right-style",
1051                                           GTK_CSS_PROPERTY_BORDER_RIGHT_STYLE,
1052                                           GTK_TYPE_BORDER_STYLE,
1053                                           0,
1054                                           parse_border_style,
1055                                           NULL,
1056                                           NULL,
1057                                           query_border_style,
1058                                           assign_border_style,
1059                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1060   gtk_css_style_property_register        ("border-right-width",
1061                                           GTK_CSS_PROPERTY_BORDER_RIGHT_WIDTH,
1062                                           G_TYPE_INT,
1063                                           GTK_STYLE_PROPERTY_ANIMATED,
1064                                           parse_border_width,
1065                                           NULL,
1066                                           NULL,
1067                                           query_length_as_int,
1068                                           assign_length_from_int,
1069                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1070
1071   gtk_css_style_property_register        ("border-top-left-radius",
1072                                           GTK_CSS_PROPERTY_BORDER_TOP_LEFT_RADIUS,
1073                                           G_TYPE_NONE,
1074                                           GTK_STYLE_PROPERTY_ANIMATED,
1075                                           border_corner_radius_value_parse,
1076                                           NULL,
1077                                           NULL,
1078                                           NULL,
1079                                           NULL,
1080                                           _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
1081                                                                      _gtk_css_number_value_new (0, GTK_CSS_PX)));
1082   gtk_css_style_property_register        ("border-top-right-radius",
1083                                           GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS,
1084                                           G_TYPE_NONE,
1085                                           GTK_STYLE_PROPERTY_ANIMATED,
1086                                           border_corner_radius_value_parse,
1087                                           NULL,
1088                                           NULL,
1089                                           NULL,
1090                                           NULL,
1091                                           _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
1092                                                                      _gtk_css_number_value_new (0, GTK_CSS_PX)));
1093   gtk_css_style_property_register        ("border-bottom-right-radius",
1094                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS,
1095                                           G_TYPE_NONE,
1096                                           GTK_STYLE_PROPERTY_ANIMATED,
1097                                           border_corner_radius_value_parse,
1098                                           NULL,
1099                                           NULL,
1100                                           NULL,
1101                                           NULL,
1102                                           _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
1103                                                                      _gtk_css_number_value_new (0, GTK_CSS_PX)));
1104   gtk_css_style_property_register        ("border-bottom-left-radius",
1105                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS,
1106                                           G_TYPE_NONE,
1107                                           GTK_STYLE_PROPERTY_ANIMATED,
1108                                           border_corner_radius_value_parse,
1109                                           NULL,
1110                                           NULL,
1111                                           NULL,
1112                                           NULL,
1113                                           _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
1114                                                                      _gtk_css_number_value_new (0, GTK_CSS_PX)));
1115
1116   gtk_css_style_property_register        ("outline-style",
1117                                           GTK_CSS_PROPERTY_OUTLINE_STYLE,
1118                                           GTK_TYPE_BORDER_STYLE,
1119                                           0,
1120                                           parse_border_style,
1121                                           NULL,
1122                                           NULL,
1123                                           query_border_style,
1124                                           assign_border_style,
1125                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1126   gtk_css_style_property_register        ("outline-width",
1127                                           GTK_CSS_PROPERTY_OUTLINE_WIDTH,
1128                                           G_TYPE_INT,
1129                                           GTK_STYLE_PROPERTY_ANIMATED,
1130                                           parse_border_width,
1131                                           NULL,
1132                                           NULL,
1133                                           query_length_as_int,
1134                                           assign_length_from_int,
1135                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1136   gtk_css_style_property_register        ("outline-offset",
1137                                           GTK_CSS_PROPERTY_OUTLINE_OFFSET,
1138                                           G_TYPE_INT,
1139                                           0,
1140                                           outline_parse,
1141                                           NULL,
1142                                           NULL,
1143                                           query_length_as_int,
1144                                           assign_length_from_int,
1145                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1146
1147   gtk_css_style_property_register        ("background-clip",
1148                                           GTK_CSS_PROPERTY_BACKGROUND_CLIP,
1149                                           G_TYPE_NONE,
1150                                           0,
1151                                           parse_css_area,
1152                                           NULL,
1153                                           NULL,
1154                                           NULL,
1155                                           NULL,
1156                                           _gtk_css_array_value_new (_gtk_css_area_value_new (GTK_CSS_AREA_BORDER_BOX)));
1157   gtk_css_style_property_register        ("background-origin",
1158                                           GTK_CSS_PROPERTY_BACKGROUND_ORIGIN,
1159                                           G_TYPE_NONE,
1160                                           0,
1161                                           parse_css_area,
1162                                           NULL,
1163                                           NULL,
1164                                           NULL,
1165                                           NULL,
1166                                           _gtk_css_array_value_new (_gtk_css_area_value_new (GTK_CSS_AREA_PADDING_BOX)));
1167   gtk_css_style_property_register        ("background-size",
1168                                           GTK_CSS_PROPERTY_BACKGROUND_SIZE,
1169                                           G_TYPE_NONE,
1170                                           0,
1171                                           background_size_parse,
1172                                           NULL,
1173                                           NULL,
1174                                           NULL,
1175                                           NULL,
1176                                           _gtk_css_array_value_new (_gtk_css_bg_size_value_new (NULL, NULL)));
1177   gtk_css_style_property_register        ("background-position",
1178                                           GTK_CSS_PROPERTY_BACKGROUND_POSITION,
1179                                           G_TYPE_NONE,
1180                                           GTK_STYLE_PROPERTY_ANIMATED,
1181                                           background_position_parse,
1182                                           NULL,
1183                                           NULL,
1184                                           NULL,
1185                                           NULL,
1186                                           _gtk_css_array_value_new (_gtk_css_position_value_new (_gtk_css_number_value_new (0, GTK_CSS_PERCENT),
1187                                                                                                  _gtk_css_number_value_new (0, GTK_CSS_PERCENT))));
1188
1189   gtk_css_style_property_register        ("border-top-color",
1190                                           GTK_CSS_PROPERTY_BORDER_TOP_COLOR,
1191                                           GDK_TYPE_RGBA,
1192                                           GTK_STYLE_PROPERTY_ANIMATED,
1193                                           color_parse,
1194                                           NULL,
1195                                           NULL,
1196                                           color_query,
1197                                           color_assign,
1198                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1199                                             gtk_symbolic_color_ref (
1200                                               _gtk_symbolic_color_get_current_color ())));
1201   gtk_css_style_property_register        ("border-right-color",
1202                                           GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR,
1203                                           GDK_TYPE_RGBA,
1204                                           GTK_STYLE_PROPERTY_ANIMATED,
1205                                           color_parse,
1206                                           NULL,
1207                                           NULL,
1208                                           color_query,
1209                                           color_assign,
1210                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1211                                             gtk_symbolic_color_ref (
1212                                               _gtk_symbolic_color_get_current_color ())));
1213   gtk_css_style_property_register        ("border-bottom-color",
1214                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR,
1215                                           GDK_TYPE_RGBA,
1216                                           GTK_STYLE_PROPERTY_ANIMATED,
1217                                           color_parse,
1218                                           NULL,
1219                                           NULL,
1220                                           color_query,
1221                                           color_assign,
1222                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1223                                             gtk_symbolic_color_ref (
1224                                               _gtk_symbolic_color_get_current_color ())));
1225   gtk_css_style_property_register        ("border-left-color",
1226                                           GTK_CSS_PROPERTY_BORDER_LEFT_COLOR,
1227                                           GDK_TYPE_RGBA,
1228                                           GTK_STYLE_PROPERTY_ANIMATED,
1229                                           color_parse,
1230                                           NULL,
1231                                           NULL,
1232                                           color_query,
1233                                           color_assign,
1234                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1235                                             gtk_symbolic_color_ref (
1236                                               _gtk_symbolic_color_get_current_color ())));
1237   gtk_css_style_property_register        ("outline-color",
1238                                           GTK_CSS_PROPERTY_OUTLINE_COLOR,
1239                                           GDK_TYPE_RGBA,
1240                                           GTK_STYLE_PROPERTY_ANIMATED,
1241                                           color_parse,
1242                                           NULL,
1243                                           NULL,
1244                                           color_query,
1245                                           color_assign,
1246                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1247                                             gtk_symbolic_color_ref (
1248                                               _gtk_symbolic_color_get_current_color ())));
1249
1250   gtk_css_style_property_register        ("background-repeat",
1251                                           GTK_CSS_PROPERTY_BACKGROUND_REPEAT,
1252                                           G_TYPE_NONE,
1253                                           0,
1254                                           background_repeat_value_parse,
1255                                           NULL,
1256                                           NULL,
1257                                           NULL,
1258                                           NULL,
1259                                           _gtk_css_array_value_new (_gtk_css_background_repeat_value_new (GTK_CSS_REPEAT_STYLE_REPEAT,
1260                                                                                                           GTK_CSS_REPEAT_STYLE_REPEAT)));
1261   gtk_css_style_property_register        ("background-image",
1262                                           GTK_CSS_PROPERTY_BACKGROUND_IMAGE,
1263                                           CAIRO_GOBJECT_TYPE_PATTERN,
1264                                           GTK_STYLE_PROPERTY_ANIMATED,
1265                                           background_image_value_parse,
1266                                           NULL,
1267                                           NULL,
1268                                           background_image_value_query,
1269                                           background_image_value_assign,
1270                                           _gtk_css_array_value_new (_gtk_css_image_value_new (NULL)));
1271
1272   gtk_css_style_property_register        ("border-image-source",
1273                                           GTK_CSS_PROPERTY_BORDER_IMAGE_SOURCE,
1274                                           CAIRO_GOBJECT_TYPE_PATTERN,
1275                                           GTK_STYLE_PROPERTY_ANIMATED,
1276                                           css_image_value_parse,
1277                                           NULL,
1278                                           NULL,
1279                                           css_image_value_query,
1280                                           css_image_value_assign,
1281                                           _gtk_css_image_value_new (NULL));
1282   gtk_css_style_property_register        ("border-image-repeat",
1283                                           GTK_CSS_PROPERTY_BORDER_IMAGE_REPEAT,
1284                                           G_TYPE_NONE,
1285                                           0,
1286                                           border_image_repeat_parse,
1287                                           NULL,
1288                                           NULL,
1289                                           NULL,
1290                                           NULL,
1291                                           _gtk_css_border_repeat_value_new (GTK_CSS_REPEAT_STYLE_STRETCH,
1292                                                                             GTK_CSS_REPEAT_STYLE_STRETCH));
1293
1294   gtk_css_style_property_register        ("border-image-slice",
1295                                           GTK_CSS_PROPERTY_BORDER_IMAGE_SLICE,
1296                                           GTK_TYPE_BORDER,
1297                                           0,
1298                                           border_image_slice_parse,
1299                                           NULL,
1300                                           NULL,
1301                                           query_border,
1302                                           assign_border,
1303                                           _gtk_css_border_value_new (_gtk_css_number_value_new (100, GTK_CSS_PERCENT),
1304                                                                      _gtk_css_number_value_new (100, GTK_CSS_PERCENT),
1305                                                                      _gtk_css_number_value_new (100, GTK_CSS_PERCENT),
1306                                                                      _gtk_css_number_value_new (100, GTK_CSS_PERCENT)));
1307   gtk_css_style_property_register        ("border-image-width",
1308                                           GTK_CSS_PROPERTY_BORDER_IMAGE_WIDTH,
1309                                           GTK_TYPE_BORDER,
1310                                           0,
1311                                           border_image_width_parse,
1312                                           NULL,
1313                                           NULL,
1314                                           query_border,
1315                                           assign_border,
1316                                           _gtk_css_border_value_new (_gtk_css_number_value_new (1, GTK_CSS_NUMBER),
1317                                                                      _gtk_css_number_value_new (1, GTK_CSS_NUMBER),
1318                                                                      _gtk_css_number_value_new (1, GTK_CSS_NUMBER),
1319                                                                      _gtk_css_number_value_new (1, GTK_CSS_NUMBER)));
1320
1321   gtk_css_style_property_register        ("transition-property",
1322                                           GTK_CSS_PROPERTY_TRANSITION_PROPERTY,
1323                                           G_TYPE_NONE,
1324                                           0,
1325                                           transition_property_parse,
1326                                           NULL,
1327                                           NULL,
1328                                           NULL,
1329                                           NULL,
1330                                           _gtk_css_array_value_new (_gtk_css_ident_value_new ("all")));
1331   gtk_css_style_property_register        ("transition-duration",
1332                                           GTK_CSS_PROPERTY_TRANSITION_DURATION,
1333                                           G_TYPE_NONE,
1334                                           0,
1335                                           transition_time_parse,
1336                                           NULL,
1337                                           NULL,
1338                                           NULL,
1339                                           NULL,
1340                                           _gtk_css_array_value_new (_gtk_css_number_value_new (0, GTK_CSS_S)));
1341   gtk_css_style_property_register        ("transition-timing-function",
1342                                           GTK_CSS_PROPERTY_TRANSITION_TIMING_FUNCTION,
1343                                           G_TYPE_NONE,
1344                                           0,
1345                                           transition_timing_function_parse,
1346                                           NULL,
1347                                           NULL,
1348                                           NULL,
1349                                           NULL,
1350                                           _gtk_css_array_value_new (
1351                                             _gtk_css_ease_value_new_cubic_bezier (0.25, 0.1, 0.25, 1.0)));
1352   gtk_css_style_property_register        ("transition-delay",
1353                                           GTK_CSS_PROPERTY_TRANSITION_DELAY,
1354                                           G_TYPE_NONE,
1355                                           0,
1356                                           transition_time_parse,
1357                                           NULL,
1358                                           NULL,
1359                                           NULL,
1360                                           NULL,
1361                                           _gtk_css_array_value_new (_gtk_css_number_value_new (0, GTK_CSS_S)));
1362
1363   gtk_css_style_property_register        ("engine",
1364                                           GTK_CSS_PROPERTY_ENGINE,
1365                                           GTK_TYPE_THEMING_ENGINE,
1366                                           0,
1367                                           engine_parse,
1368                                           NULL,
1369                                           NULL,
1370                                           engine_query,
1371                                           engine_assign,
1372                                           _gtk_css_engine_value_new (gtk_theming_engine_load (NULL)));
1373
1374   /* Private property holding the binding sets */
1375   gtk_css_style_property_register        ("gtk-key-bindings",
1376                                           GTK_CSS_PROPERTY_GTK_KEY_BINDINGS,
1377                                           G_TYPE_PTR_ARRAY,
1378                                           0,
1379                                           bindings_value_parse,
1380                                           NULL,
1381                                           NULL,
1382                                           bindings_value_query,
1383                                           bindings_value_assign,
1384                                           _gtk_css_array_value_new (NULL));
1385 }
1386