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