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 GtkCssValue *
 184 color_compute (GtkCssStyleProperty    *property,
 185                GtkStyleContext        *context,
 186                GtkCssValue            *specified)
 187 {
 188   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 189 }
 190
 191 static GtkCssValue *
 192 color_property_compute (GtkCssStyleProperty    *property,
 193                         GtkStyleContext        *context,
 194                         GtkCssValue            *specified)
 195 {
 196   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 197 }
 198
 199 static void
 200 color_query (GtkCssStyleProperty *property,
 201              const GtkCssValue   *css_value,
 202              GValue              *value)
 203 {
 204   g_value_init (value, GDK_TYPE_RGBA);
 205   g_value_set_boxed (value, _gtk_css_rgba_value_get_rgba (css_value));
 206 }
 207
 208 static GtkCssValue *
 209 color_assign (GtkCssStyleProperty *property,
 210               const GValue        *value)
 211 {
 212   return _gtk_css_rgba_value_new_from_rgba (g_value_get_boxed (value));
 213 }
 214
 215 static GtkCssValue *
 216 font_family_parse_one (GtkCssParser *parser)
 217 {
 218   char *name;
 219
 220   name = _gtk_css_parser_try_ident (parser, TRUE);
 221   if (name)
 222     {
 223       GString *string = g_string_new (name);
 224       g_free (name);
 225       while ((name = _gtk_css_parser_try_ident (parser, TRUE)))
 226         {
 227           g_string_append_c (string, ' ');
 228           g_string_append (string, name);
 229           g_free (name);
 230         }
 231       name = g_string_free (string, FALSE);
 232     }
 233   else
 234     {
 235       name = _gtk_css_parser_read_string (parser);
 236       if (name == NULL)
 237         return NULL;
 238     }
 239
 240   return _gtk_css_string_value_new_take (name);
 241 }
 242
 243 static GtkCssValue *
 244 font_family_parse (GtkCssStyleProperty *property,
 245                    GtkCssParser        *parser)
 246 {
 247   return _gtk_css_array_value_parse (parser, font_family_parse_one, FALSE);
 248 }
 249
 250 static void
 251 font_family_query (GtkCssStyleProperty *property,
 252                    const GtkCssValue   *css_value,
 253                    GValue              *value)
 254 {
 255   GPtrArray *array;
 256   guint i;
 257
 258   array = g_ptr_array_new ();
 259
 260   for (i = 0; i < _gtk_css_array_value_get_n_values (css_value); i++)
 261     {
 262       g_ptr_array_add (array, g_strdup (_gtk_css_string_value_get (_gtk_css_array_value_get_nth (css_value, i))));
 263     }
 264
 265   /* NULL-terminate */
 266   g_ptr_array_add (array, NULL);
 267
 268   g_value_init (value, G_TYPE_STRV);
 269   g_value_set_boxed (value, g_ptr_array_free (array, FALSE));
 270 }
 271
 272 static GtkCssValue *
 273 font_family_assign (GtkCssStyleProperty *property,
 274                     const GValue        *value)
 275 {
 276   const char **names = g_value_get_boxed (value);
 277   GtkCssValue *result;
 278   GPtrArray *array;
 279
 280   array = g_ptr_array_new ();
 281
 282   for (names = g_value_get_boxed (value); *names; names++)
 283     {
 284       g_ptr_array_add (array, _gtk_css_string_value_new (*names));
 285     }
 286
 287   result = _gtk_css_array_value_new_from_array ((GtkCssValue **) array->pdata, array->len);
 288   g_ptr_array_free (array, TRUE);
 289   return result;
 290 }
 291
 292 static GtkCssValue *
 293 parse_pango_style (GtkCssStyleProperty *property,
 294                    GtkCssParser        *parser)
 295 {
 296   GtkCssValue *value = _gtk_css_font_style_value_try_parse (parser);
 297
 298   if (value == NULL)
 299     _gtk_css_parser_error (parser, "unknown value for property");
 300
 301   return value;
 302 }
 303
 304 static void
 305 query_pango_style (GtkCssStyleProperty *property,
 306                     const GtkCssValue   *css_value,
 307                     GValue              *value)
 308 {
 309   g_value_init (value, PANGO_TYPE_STYLE);
 310   g_value_set_enum (value, _gtk_css_font_style_value_get (css_value));
 311 }
 312
 313 static GtkCssValue *
 314 assign_pango_style (GtkCssStyleProperty *property,
 315                     const GValue        *value)
 316 {
 317   return _gtk_css_font_style_value_new (g_value_get_enum (value));
 318 }
 319
 320 static GtkCssValue *
 321 parse_pango_weight (GtkCssStyleProperty *property,
 322                     GtkCssParser        *parser)
 323 {
 324   GtkCssValue *value = _gtk_css_font_weight_value_try_parse (parser);
 325
 326   if (value == NULL)
 327     _gtk_css_parser_error (parser, "unknown value for property");
 328
 329   return value;
 330 }
 331
 332 static void
 333 query_pango_weight (GtkCssStyleProperty *property,
 334                     const GtkCssValue   *css_value,
 335                     GValue              *value)
 336 {
 337   g_value_init (value, PANGO_TYPE_WEIGHT);
 338   g_value_set_enum (value, _gtk_css_font_weight_value_get (css_value));
 339 }
 340
 341 static GtkCssValue *
 342 assign_pango_weight (GtkCssStyleProperty *property,
 343                      const GValue        *value)
 344 {
 345   return _gtk_css_font_weight_value_new (g_value_get_enum (value));
 346 }
 347
 348 static GtkCssValue *
 349 parse_pango_variant (GtkCssStyleProperty *property,
 350                      GtkCssParser        *parser)
 351 {
 352   GtkCssValue *value = _gtk_css_font_variant_value_try_parse (parser);
 353
 354   if (value == NULL)
 355     _gtk_css_parser_error (parser, "unknown value for property");
 356
 357   return value;
 358 }
 359
 360 static void
 361 query_pango_variant (GtkCssStyleProperty *property,
 362                      const GtkCssValue   *css_value,
 363                      GValue              *value)
 364 {
 365   g_value_init (value, PANGO_TYPE_VARIANT);
 366   g_value_set_enum (value, _gtk_css_font_variant_value_get (css_value));
 367 }
 368
 369 static GtkCssValue *
 370 assign_pango_variant (GtkCssStyleProperty *property,
 371                       const GValue        *value)
 372 {
 373   return _gtk_css_font_variant_value_new (g_value_get_enum (value));
 374 }
 375
 376 static GtkCssValue *
 377 parse_border_style (GtkCssStyleProperty *property,
 378                     GtkCssParser        *parser)
 379 {
 380   GtkCssValue *value = _gtk_css_border_style_value_try_parse (parser);
 381
 382   if (value == NULL)
 383     _gtk_css_parser_error (parser, "unknown value for property");
 384
 385   return value;
 386 }
 387
 388 static void
 389 query_border_style (GtkCssStyleProperty *property,
 390                     const GtkCssValue   *css_value,
 391                     GValue              *value)
 392 {
 393   g_value_init (value, GTK_TYPE_BORDER_STYLE);
 394   g_value_set_enum (value, _gtk_css_border_style_value_get (css_value));
 395 }
 396
 397 static GtkCssValue *
 398 assign_border_style (GtkCssStyleProperty *property,
 399                      const GValue        *value)
 400 {
 401   return _gtk_css_border_style_value_new (g_value_get_enum (value));
 402 }
 403
 404 static GtkCssValue *
 405 parse_css_area_one (GtkCssParser *parser)
 406 {
 407   GtkCssValue *value = _gtk_css_area_value_try_parse (parser);
 408
 409   if (value == NULL)
 410     _gtk_css_parser_error (parser, "unknown value for property");
 411
 412   return value;
 413 }
 414
 415 static GtkCssValue *
 416 parse_css_area (GtkCssStyleProperty *property,
 417                 GtkCssParser        *parser)
 418 {
 419   return _gtk_css_array_value_parse (parser, parse_css_area_one, FALSE);
 420 }
 421
 422 static GtkCssValue *
 423 bindings_value_parse_one (GtkCssParser *parser)
 424 {
 425   char *name;
 426
 427   name = _gtk_css_parser_try_ident (parser, TRUE);
 428   if (name == NULL)
 429     {
 430       _gtk_css_parser_error (parser, "Not a valid binding name");
 431       return NULL;
 432     }
 433
 434
 435   if (!gtk_binding_set_find (name))
 436     {
 437       _gtk_css_parser_error (parser, "No binding set named '%s'", name);
 438       g_free (name);
 439       return NULL;
 440     }
 441
 442   return _gtk_css_string_value_new_take (name);
 443 }
 444
 445 static GtkCssValue *
 446 bindings_value_parse (GtkCssStyleProperty *property,
 447                       GtkCssParser        *parser)
 448 {
 449   return _gtk_css_array_value_parse (parser, bindings_value_parse_one, TRUE);
 450 }
 451
 452 static void
 453 bindings_value_query (GtkCssStyleProperty *property,
 454                       const GtkCssValue   *css_value,
 455                       GValue              *value)
 456 {
 457   GPtrArray *array;
 458   guint i;
 459
 460   g_value_init (value, G_TYPE_PTR_ARRAY);
 461
 462   if (_gtk_css_array_value_get_n_values (css_value) == 0)
 463     return;
 464
 465   array = g_ptr_array_new ();
 466
 467   for (i = 0; i < _gtk_css_array_value_get_n_values (css_value); i++)
 468     {
 469       GtkBindingSet *binding_set = gtk_binding_set_find (_gtk_css_string_value_get (_gtk_css_array_value_get_nth (css_value, i)));
 470
 471       g_ptr_array_add (array, binding_set);
 472     }
 473
 474   g_value_take_boxed (value, array);
 475 }
 476
 477 static GtkCssValue *
 478 bindings_value_assign (GtkCssStyleProperty *property,
 479                        const GValue        *value)
 480 {
 481   GPtrArray *binding_sets = g_value_get_boxed (value);
 482   GtkCssValue **values, *result;
 483   guint i;
 484
 485   if (binding_sets == NULL || binding_sets->len == 0)
 486     return _gtk_css_array_value_new (NULL);
 487
 488   values = g_new (GtkCssValue *, binding_sets->len);
 489
 490   for (i = 0; i < binding_sets->len; i++)
 491     {
 492       GtkBindingSet *binding_set = g_ptr_array_index (binding_sets, i);
 493       values[i] = _gtk_css_string_value_new (binding_set->set_name);
 494     }
 495
 496   result = _gtk_css_array_value_new_from_array (values, binding_sets->len);
 497   g_free (values);
 498   return result;
 499 }
 500
 501 static GtkCssValue *
 502 shadow_value_parse (GtkCssStyleProperty *property,
 503                     GtkCssParser        *parser)
 504 {
 505   return _gtk_css_shadows_value_parse (parser);
 506 }
 507
 508 static GtkCssValue *
 509 shadow_value_compute (GtkCssStyleProperty *property,
 510                       GtkStyleContext     *context,
 511                       GtkCssValue         *specified)
 512 {
 513   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 514 }
 515
 516 static GtkCssValue *
 517 border_corner_radius_value_parse (GtkCssStyleProperty *property,
 518                                   GtkCssParser        *parser)
 519 {
 520   return _gtk_css_corner_value_parse (parser);
 521 }
 522
 523 static GtkCssValue *
 524 border_corner_radius_value_compute (GtkCssStyleProperty *property,
 525                                     GtkStyleContext     *context,
 526                                     GtkCssValue         *specified)
 527 {
 528   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 529 }
 530
 531 static GtkCssValue *
 532 css_image_value_parse (GtkCssStyleProperty *property,
 533                        GtkCssParser        *parser)
 534 {
 535   GtkCssImage *image;
 536
 537   if (_gtk_css_parser_try (parser, "none", TRUE))
 538     image = NULL;
 539   else
 540     {
 541       image = _gtk_css_image_new_parse (parser);
 542       if (image == NULL)
 543         return FALSE;
 544     }
 545
 546   return _gtk_css_image_value_new (image);
 547 }
 548
 549 static GtkCssValue *
 550 css_image_value_compute (GtkCssStyleProperty    *property,
 551                          GtkStyleContext        *context,
 552                          GtkCssValue            *specified)
 553 {
 554   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 555 }
 556
 557 static void
 558 css_image_value_query (GtkCssStyleProperty *property,
 559                        const GtkCssValue   *css_value,
 560                        GValue              *value)
 561 {
 562   GtkCssImage *image = _gtk_css_image_value_get_image (css_value);
 563   cairo_pattern_t *pattern;
 564   cairo_surface_t *surface;
 565   cairo_matrix_t matrix;
 566
 567   g_value_init (value, CAIRO_GOBJECT_TYPE_PATTERN);
 568
 569   if (GTK_IS_CSS_IMAGE_GRADIENT (image))
 570     g_value_set_boxed (value, GTK_CSS_IMAGE_GRADIENT (image)->pattern);
 571   else if (image != NULL)
 572     {
 573       double width, height;
 574
 575       /* the 100, 100 is rather random */
 576       _gtk_css_image_get_concrete_size (image, 0, 0, 100, 100, &width, &height);
 577       surface = _gtk_css_image_get_surface (image, NULL, width, height);
 578       pattern = cairo_pattern_create_for_surface (surface);
 579       cairo_matrix_init_scale (&matrix, width, height);
 580       cairo_pattern_set_matrix (pattern, &matrix);
 581       cairo_surface_destroy (surface);
 582       g_value_take_boxed (value, pattern);
 583     }
 584 }
 585
 586 static GtkCssValue *
 587 css_image_value_assign (GtkCssStyleProperty *property,
 588                         const GValue        *value)
 589 {
 590   g_warning ("FIXME: assigning images is not implemented");
 591   return _gtk_css_image_value_new (NULL);
 592 }
 593
 594 static GtkCssValue *
 595 background_image_value_parse_one (GtkCssParser *parser)
 596 {
 597   return css_image_value_parse (NULL, parser);
 598 }
 599
 600 static GtkCssValue *
 601 background_image_value_parse (GtkCssStyleProperty *property,
 602                               GtkCssParser        *parser)
 603 {
 604   return _gtk_css_array_value_parse (parser, background_image_value_parse_one, FALSE);
 605 }
 606
 607 static GtkCssValue *
 608 background_image_value_compute (GtkCssStyleProperty    *property,
 609                                 GtkStyleContext        *context,
 610                                 GtkCssValue            *specified)
 611 {
 612   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 613 }
 614
 615 static void
 616 background_image_value_query (GtkCssStyleProperty *property,
 617                               const GtkCssValue   *css_value,
 618                               GValue              *value)
 619 {
 620   css_image_value_query (property, _gtk_css_array_value_get_nth (css_value, 0), value);
 621 }
 622
 623 static GtkCssValue *
 624 background_image_value_assign (GtkCssStyleProperty *property,
 625                                const GValue        *value)
 626 {
 627   return _gtk_css_array_value_new (css_image_value_assign (property, value));
 628 }
 629
 630 static GtkCssValue *
 631 font_size_parse (GtkCssStyleProperty *property,
 632                  GtkCssParser        *parser)
 633 {
 634   gdouble d;
 635
 636   if (!_gtk_css_parser_try_double (parser, &d))
 637     {
 638       _gtk_css_parser_error (parser, "Expected a number");
 639       return NULL;
 640     }
 641
 642   return _gtk_css_number_value_new (d, GTK_CSS_PX);
 643 }
 644
 645 static GtkCssValue *
 646 font_size_compute (GtkCssStyleProperty *property,
 647                    GtkStyleContext     *context,
 648                    GtkCssValue         *specified)
 649 {
 650   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 651 }
 652
 653 static GtkCssValue *
 654 outline_parse (GtkCssStyleProperty *property,
 655                GtkCssParser        *parser)
 656 {
 657   return _gtk_css_number_value_parse (parser,
 658                                       GTK_CSS_NUMBER_AS_PIXELS
 659                                       | GTK_CSS_PARSE_LENGTH);
 660 }
 661
 662 static GtkCssValue *
 663 outline_compute (GtkCssStyleProperty *property,
 664                  GtkStyleContext     *context,
 665                  GtkCssValue         *specified)
 666 {
 667   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 668 }
 669
 670 static GtkCssValue *
 671 border_image_repeat_parse (GtkCssStyleProperty *property,
 672                            GtkCssParser        *parser)
 673 {
 674   GtkCssValue *value = _gtk_css_border_repeat_value_try_parse (parser);
 675
 676   if (value == NULL)
 677     {
 678       _gtk_css_parser_error (parser, "Not a valid value");
 679       return NULL;
 680     }
 681
 682   return value;
 683 }
 684
 685 static GtkCssValue *
 686 border_image_slice_parse (GtkCssStyleProperty *property,
 687                           GtkCssParser        *parser)
 688 {
 689   return _gtk_css_border_value_parse (parser,
 690                                       GTK_CSS_PARSE_PERCENT
 691                                       | GTK_CSS_PARSE_NUMBER
 692                                       | GTK_CSS_POSITIVE_ONLY,
 693                                       FALSE,
 694                                       TRUE);
 695 }
 696
 697 static GtkCssValue *
 698 border_image_width_parse (GtkCssStyleProperty *property,
 699                           GtkCssParser        *parser)
 700 {
 701   return _gtk_css_border_value_parse (parser,
 702                                       GTK_CSS_PARSE_PERCENT
 703                                       | GTK_CSS_PARSE_LENGTH
 704                                       | GTK_CSS_PARSE_NUMBER
 705                                       | GTK_CSS_POSITIVE_ONLY,
 706                                       TRUE,
 707                                       FALSE);
 708 }
 709
 710 static GtkCssValue *
 711 compute_border (GtkCssStyleProperty *property,
 712                 GtkStyleContext     *context,
 713                 GtkCssValue         *specified)
 714 {
 715   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 716 }
 717
 718 static GtkCssValue *
 719 transition_property_parse_one (GtkCssParser *parser)
 720 {
 721   GtkCssValue *value;
 722
 723   value = _gtk_css_ident_value_try_parse (parser);
 724
 725   if (value == NULL)
 726     {
 727       _gtk_css_parser_error (parser, "Expected an identifier");
 728       return NULL;
 729     }
 730
 731   return value;
 732 }
 733
 734 static GtkCssValue *
 735 transition_property_parse (GtkCssStyleProperty *property,
 736                            GtkCssParser        *parser)
 737 {
 738   return _gtk_css_array_value_parse (parser, transition_property_parse_one, FALSE);
 739 }
 740
 741 static GtkCssValue *
 742 transition_time_parse_one (GtkCssParser *parser)
 743 {
 744   return _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_TIME);
 745 }
 746
 747 static GtkCssValue *
 748 transition_time_parse (GtkCssStyleProperty *property,
 749                        GtkCssParser        *parser)
 750 {
 751   return _gtk_css_array_value_parse (parser, transition_time_parse_one, FALSE);
 752 }
 753
 754 static GtkCssValue *
 755 transition_timing_function_parse (GtkCssStyleProperty *property,
 756                                   GtkCssParser        *parser)
 757 {
 758   return _gtk_css_array_value_parse (parser, _gtk_css_ease_value_parse, FALSE);
 759 }
 760
 761 static GtkCssValue *
 762 engine_parse (GtkCssStyleProperty *property,
 763               GtkCssParser        *parser)
 764 {
 765   return _gtk_css_engine_value_parse (parser);
 766 }
 767
 768 static void
 769 engine_query (GtkCssStyleProperty *property,
 770               const GtkCssValue   *css_value,
 771               GValue              *value)
 772 {
 773   g_value_init (value, GTK_TYPE_THEMING_ENGINE);
 774   g_value_set_object (value, _gtk_css_engine_value_get_engine (css_value));
 775 }
 776
 777 static GtkCssValue *
 778 engine_assign (GtkCssStyleProperty *property,
 779                const GValue        *value)
 780 {
 781   return _gtk_css_engine_value_new (g_value_get_object (value));
 782 }
 783
 784 static GtkCssValue *
 785 parse_margin (GtkCssStyleProperty *property,
 786               GtkCssParser        *parser)
 787 {
 788   return _gtk_css_number_value_parse (parser,
 789                                       GTK_CSS_NUMBER_AS_PIXELS
 790                                       | GTK_CSS_PARSE_LENGTH);
 791 }
 792
 793 static GtkCssValue *
 794 compute_margin (GtkCssStyleProperty *property,
 795                 GtkStyleContext     *context,
 796                 GtkCssValue         *specified)
 797 {
 798   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 799 }
 800
 801 static GtkCssValue *
 802 parse_padding (GtkCssStyleProperty *property,
 803                GtkCssParser        *parser)
 804 {
 805   return _gtk_css_number_value_parse (parser,
 806                                       GTK_CSS_POSITIVE_ONLY
 807                                       | GTK_CSS_NUMBER_AS_PIXELS
 808                                       | GTK_CSS_PARSE_LENGTH);
 809 }
 810
 811 static GtkCssValue *
 812 compute_padding (GtkCssStyleProperty *property,
 813                  GtkStyleContext     *context,
 814                  GtkCssValue         *specified)
 815 {
 816   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 817 }
 818
 819 static GtkCssValue *
 820 parse_border_width (GtkCssStyleProperty *property,
 821                     GtkCssParser        *parser)
 822 {
 823   return _gtk_css_number_value_parse (parser,
 824                                       GTK_CSS_POSITIVE_ONLY
 825                                       | GTK_CSS_NUMBER_AS_PIXELS
 826                                       | GTK_CSS_PARSE_LENGTH);
 827 }
 828
 829 static GtkCssValue *
 830 compute_border_width (GtkCssStyleProperty    *property,
 831                       GtkStyleContext        *context,
 832                       GtkCssValue            *specified)
 833 {
 834   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 835 }
 836
 837 static GtkCssValue *
 838 background_repeat_value_parse_one (GtkCssParser *parser)
 839 {
 840   GtkCssValue *value = _gtk_css_background_repeat_value_try_parse (parser);
 841
 842   if (value == NULL)
 843     {
 844       _gtk_css_parser_error (parser, "Not a valid value");
 845       return NULL;
 846     }
 847
 848   return value;
 849 }
 850
 851 static GtkCssValue *
 852 background_repeat_value_parse (GtkCssStyleProperty *property,
 853                                GtkCssParser        *parser)
 854 {
 855   return _gtk_css_array_value_parse (parser, background_repeat_value_parse_one, FALSE);
 856 }
 857
 858 static GtkCssValue *
 859 background_size_parse (GtkCssStyleProperty *property,
 860                        GtkCssParser        *parser)
 861 {
 862   return _gtk_css_array_value_parse (parser, _gtk_css_bg_size_value_parse, FALSE);
 863 }
 864
 865 static GtkCssValue *
 866 background_size_compute (GtkCssStyleProperty    *property,
 867                          GtkStyleContext        *context,
 868                          GtkCssValue            *specified)
 869 {
 870   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 871 }
 872
 873 static GtkCssValue *
 874 background_position_parse (GtkCssStyleProperty *property,
 875                            GtkCssParser        *parser)
 876 {
 877   return _gtk_css_array_value_parse (parser, _gtk_css_position_value_parse, FALSE);
 878 }
 879
 880 static GtkCssValue *
 881 background_position_compute (GtkCssStyleProperty    *property,
 882                              GtkStyleContext        *context,
 883                              GtkCssValue            *specified)
 884 {
 885   return _gtk_css_value_compute (specified, _gtk_css_style_property_get_id (property), context);
 886 }
 887
 888 /*** REGISTRATION ***/
 889
 890 static GtkSymbolicColor *
 891 gtk_symbolic_color_new_rgba (double red,
 892                              double green,
 893                              double blue,
 894                              double alpha)
 895 {
 896   GdkRGBA rgba = { red, green, blue, alpha };
 897
 898   return gtk_symbolic_color_new_literal (&rgba);
 899 }
 900
 901 void
 902 _gtk_css_style_property_init_properties (void)
 903 {
 904   /* Initialize "color" and "font-size" first,
 905    * so that when computing values later they are
 906    * done first. That way, 'currentColor' and font
 907    * sizes in em can be looked up properly */
 908   gtk_css_style_property_register        ("color",
 909                                           GTK_CSS_PROPERTY_COLOR,
 910                                           GDK_TYPE_RGBA,
 911                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
 912                                           color_parse,
 913                                           NULL,
 914                                           color_property_compute,
 915                                           color_query,
 916                                           color_assign,
 917                                           _gtk_css_symbolic_value_new_take_symbolic_color (
 918                                             gtk_symbolic_color_new_rgba (1, 1, 1, 1)));
 919   gtk_css_style_property_register        ("font-size",
 920                                           GTK_CSS_PROPERTY_FONT_SIZE,
 921                                           G_TYPE_DOUBLE,
 922                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
 923                                           font_size_parse,
 924                                           NULL,
 925                                           font_size_compute,
 926                                           query_length_as_double,
 927                                           assign_length_from_double,
 928                                           /* XXX: This should be 'normal' */
 929                                           _gtk_css_number_value_new (10.0, GTK_CSS_PX));
 930
 931   /* properties that aren't referenced when computing values
 932    * start here */
 933   gtk_css_style_property_register        ("background-color",
 934                                           GTK_CSS_PROPERTY_BACKGROUND_COLOR,
 935                                           GDK_TYPE_RGBA,
 936                                           GTK_STYLE_PROPERTY_ANIMATED,
 937                                           color_parse,
 938                                           NULL,
 939                                           color_compute,
 940                                           color_query,
 941                                           color_assign,
 942                                           _gtk_css_symbolic_value_new_take_symbolic_color (
 943                                             gtk_symbolic_color_new_rgba (0, 0, 0, 0)));
 944
 945   gtk_css_style_property_register        ("font-family",
 946                                           GTK_CSS_PROPERTY_FONT_FAMILY,
 947                                           G_TYPE_STRV,
 948                                           GTK_STYLE_PROPERTY_INHERIT,
 949                                           font_family_parse,
 950                                           NULL,
 951                                           NULL,
 952                                           font_family_query,
 953                                           font_family_assign,
 954                                           _gtk_css_array_value_new (_gtk_css_string_value_new ("Sans")));
 955   gtk_css_style_property_register        ("font-style",
 956                                           GTK_CSS_PROPERTY_FONT_STYLE,
 957                                           PANGO_TYPE_STYLE,
 958                                           GTK_STYLE_PROPERTY_INHERIT,
 959                                           parse_pango_style,
 960                                           NULL,
 961                                           NULL,
 962                                           query_pango_style,
 963                                           assign_pango_style,
 964                                           _gtk_css_font_style_value_new (PANGO_STYLE_NORMAL));
 965   gtk_css_style_property_register        ("font-variant",
 966                                           GTK_CSS_PROPERTY_FONT_VARIANT,
 967                                           PANGO_TYPE_VARIANT,
 968                                           GTK_STYLE_PROPERTY_INHERIT,
 969                                           parse_pango_variant,
 970                                           NULL,
 971                                           NULL,
 972                                           query_pango_variant,
 973                                           assign_pango_variant,
 974                                           _gtk_css_font_variant_value_new (PANGO_VARIANT_NORMAL));
 975   gtk_css_style_property_register        ("font-weight",
 976                                           GTK_CSS_PROPERTY_FONT_WEIGHT,
 977                                           PANGO_TYPE_WEIGHT,
 978                                           GTK_STYLE_PROPERTY_INHERIT,
 979                                           parse_pango_weight,
 980                                           NULL,
 981                                           NULL,
 982                                           query_pango_weight,
 983                                           assign_pango_weight,
 984                                           _gtk_css_font_weight_value_new (PANGO_WEIGHT_NORMAL));
 985
 986   gtk_css_style_property_register        ("text-shadow",
 987                                           GTK_CSS_PROPERTY_TEXT_SHADOW,
 988                                           G_TYPE_NONE,
 989                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
 990                                           shadow_value_parse,
 991                                           NULL,
 992                                           shadow_value_compute,
 993                                           NULL,
 994                                           NULL,
 995                                           _gtk_css_shadows_value_new_none ());
 996
 997   gtk_css_style_property_register        ("icon-shadow",
 998                                           GTK_CSS_PROPERTY_ICON_SHADOW,
 999                                           G_TYPE_NONE,
1000                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
1001                                           shadow_value_parse,
1002                                           NULL,
1003                                           shadow_value_compute,
1004                                           NULL,
1005                                           NULL,
1006                                           _gtk_css_shadows_value_new_none ());
1007
1008   gtk_css_style_property_register        ("box-shadow",
1009                                           GTK_CSS_PROPERTY_BOX_SHADOW,
1010                                           G_TYPE_NONE,
1011                                           GTK_STYLE_PROPERTY_ANIMATED,
1012                                           shadow_value_parse,
1013                                           NULL,
1014                                           shadow_value_compute,
1015                                           NULL,
1016                                           NULL,
1017                                           _gtk_css_shadows_value_new_none ());
1018
1019   gtk_css_style_property_register        ("margin-top",
1020                                           GTK_CSS_PROPERTY_MARGIN_TOP,
1021                                           G_TYPE_INT,
1022                                           GTK_STYLE_PROPERTY_ANIMATED,
1023                                           parse_margin,
1024                                           NULL,
1025                                           compute_margin,
1026                                           query_length_as_int,
1027                                           assign_length_from_int,
1028                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1029   gtk_css_style_property_register        ("margin-left",
1030                                           GTK_CSS_PROPERTY_MARGIN_LEFT,
1031                                           G_TYPE_INT,
1032                                           GTK_STYLE_PROPERTY_ANIMATED,
1033                                           parse_margin,
1034                                           NULL,
1035                                           compute_margin,
1036                                           query_length_as_int,
1037                                           assign_length_from_int,
1038                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1039   gtk_css_style_property_register        ("margin-bottom",
1040                                           GTK_CSS_PROPERTY_MARGIN_BOTTOM,
1041                                           G_TYPE_INT,
1042                                           GTK_STYLE_PROPERTY_ANIMATED,
1043                                           parse_margin,
1044                                           NULL,
1045                                           compute_margin,
1046                                           query_length_as_int,
1047                                           assign_length_from_int,
1048                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1049   gtk_css_style_property_register        ("margin-right",
1050                                           GTK_CSS_PROPERTY_MARGIN_RIGHT,
1051                                           G_TYPE_INT,
1052                                           GTK_STYLE_PROPERTY_ANIMATED,
1053                                           parse_margin,
1054                                           NULL,
1055                                           compute_margin,
1056                                           query_length_as_int,
1057                                           assign_length_from_int,
1058                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1059   gtk_css_style_property_register        ("padding-top",
1060                                           GTK_CSS_PROPERTY_PADDING_TOP,
1061                                           G_TYPE_INT,
1062                                           GTK_STYLE_PROPERTY_ANIMATED,
1063                                           parse_padding,
1064                                           NULL,
1065                                           compute_padding,
1066                                           query_length_as_int,
1067                                           assign_length_from_int,
1068                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1069   gtk_css_style_property_register        ("padding-left",
1070                                           GTK_CSS_PROPERTY_PADDING_LEFT,
1071                                           G_TYPE_INT,
1072                                           GTK_STYLE_PROPERTY_ANIMATED,
1073                                           parse_padding,
1074                                           NULL,
1075                                           compute_padding,
1076                                           query_length_as_int,
1077                                           assign_length_from_int,
1078                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1079   gtk_css_style_property_register        ("padding-bottom",
1080                                           GTK_CSS_PROPERTY_PADDING_BOTTOM,
1081                                           G_TYPE_INT,
1082                                           GTK_STYLE_PROPERTY_ANIMATED,
1083                                           parse_padding,
1084                                           NULL,
1085                                           compute_padding,
1086                                           query_length_as_int,
1087                                           assign_length_from_int,
1088                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1089   gtk_css_style_property_register        ("padding-right",
1090                                           GTK_CSS_PROPERTY_PADDING_RIGHT,
1091                                           G_TYPE_INT,
1092                                           GTK_STYLE_PROPERTY_ANIMATED,
1093                                           parse_padding,
1094                                           NULL,
1095                                           compute_padding,
1096                                           query_length_as_int,
1097                                           assign_length_from_int,
1098                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1099   /* IMPORTANT: the border-width properties must come after border-style properties,
1100    * they depend on them for their value computation.
1101    */
1102   gtk_css_style_property_register        ("border-top-style",
1103                                           GTK_CSS_PROPERTY_BORDER_TOP_STYLE,
1104                                           GTK_TYPE_BORDER_STYLE,
1105                                           0,
1106                                           parse_border_style,
1107                                           NULL,
1108                                           NULL,
1109                                           query_border_style,
1110                                           assign_border_style,
1111                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1112   gtk_css_style_property_register        ("border-top-width",
1113                                           GTK_CSS_PROPERTY_BORDER_TOP_WIDTH,
1114                                           G_TYPE_INT,
1115                                           GTK_STYLE_PROPERTY_ANIMATED,
1116                                           parse_border_width,
1117                                           NULL,
1118                                           compute_border_width,
1119                                           query_length_as_int,
1120                                           assign_length_from_int,
1121                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1122   gtk_css_style_property_register        ("border-left-style",
1123                                           GTK_CSS_PROPERTY_BORDER_LEFT_STYLE,
1124                                           GTK_TYPE_BORDER_STYLE,
1125                                           0,
1126                                           parse_border_style,
1127                                           NULL,
1128                                           NULL,
1129                                           query_border_style,
1130                                           assign_border_style,
1131                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1132   gtk_css_style_property_register        ("border-left-width",
1133                                           GTK_CSS_PROPERTY_BORDER_LEFT_WIDTH,
1134                                           G_TYPE_INT,
1135                                           GTK_STYLE_PROPERTY_ANIMATED,
1136                                           parse_border_width,
1137                                           NULL,
1138                                           compute_border_width,
1139                                           query_length_as_int,
1140                                           assign_length_from_int,
1141                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1142   gtk_css_style_property_register        ("border-bottom-style",
1143                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_STYLE,
1144                                           GTK_TYPE_BORDER_STYLE,
1145                                           0,
1146                                           parse_border_style,
1147                                           NULL,
1148                                           NULL,
1149                                           query_border_style,
1150                                           assign_border_style,
1151                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1152   gtk_css_style_property_register        ("border-bottom-width",
1153                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_WIDTH,
1154                                           G_TYPE_INT,
1155                                           GTK_STYLE_PROPERTY_ANIMATED,
1156                                           parse_border_width,
1157                                           NULL,
1158                                           compute_border_width,
1159                                           query_length_as_int,
1160                                           assign_length_from_int,
1161                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1162   gtk_css_style_property_register        ("border-right-style",
1163                                           GTK_CSS_PROPERTY_BORDER_RIGHT_STYLE,
1164                                           GTK_TYPE_BORDER_STYLE,
1165                                           0,
1166                                           parse_border_style,
1167                                           NULL,
1168                                           NULL,
1169                                           query_border_style,
1170                                           assign_border_style,
1171                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1172   gtk_css_style_property_register        ("border-right-width",
1173                                           GTK_CSS_PROPERTY_BORDER_RIGHT_WIDTH,
1174                                           G_TYPE_INT,
1175                                           GTK_STYLE_PROPERTY_ANIMATED,
1176                                           parse_border_width,
1177                                           NULL,
1178                                           compute_border_width,
1179                                           query_length_as_int,
1180                                           assign_length_from_int,
1181                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1182
1183   gtk_css_style_property_register        ("border-top-left-radius",
1184                                           GTK_CSS_PROPERTY_BORDER_TOP_LEFT_RADIUS,
1185                                           G_TYPE_NONE,
1186                                           GTK_STYLE_PROPERTY_ANIMATED,
1187                                           border_corner_radius_value_parse,
1188                                           NULL,
1189                                           border_corner_radius_value_compute,
1190                                           NULL,
1191                                           NULL,
1192                                           _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
1193                                                                      _gtk_css_number_value_new (0, GTK_CSS_PX)));
1194   gtk_css_style_property_register        ("border-top-right-radius",
1195                                           GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS,
1196                                           G_TYPE_NONE,
1197                                           GTK_STYLE_PROPERTY_ANIMATED,
1198                                           border_corner_radius_value_parse,
1199                                           NULL,
1200                                           border_corner_radius_value_compute,
1201                                           NULL,
1202                                           NULL,
1203                                           _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
1204                                                                      _gtk_css_number_value_new (0, GTK_CSS_PX)));
1205   gtk_css_style_property_register        ("border-bottom-right-radius",
1206                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS,
1207                                           G_TYPE_NONE,
1208                                           GTK_STYLE_PROPERTY_ANIMATED,
1209                                           border_corner_radius_value_parse,
1210                                           NULL,
1211                                           border_corner_radius_value_compute,
1212                                           NULL,
1213                                           NULL,
1214                                           _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
1215                                                                      _gtk_css_number_value_new (0, GTK_CSS_PX)));
1216   gtk_css_style_property_register        ("border-bottom-left-radius",
1217                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS,
1218                                           G_TYPE_NONE,
1219                                           GTK_STYLE_PROPERTY_ANIMATED,
1220                                           border_corner_radius_value_parse,
1221                                           NULL,
1222                                           border_corner_radius_value_compute,
1223                                           NULL,
1224                                           NULL,
1225                                           _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
1226                                                                      _gtk_css_number_value_new (0, GTK_CSS_PX)));
1227
1228   gtk_css_style_property_register        ("outline-style",
1229                                           GTK_CSS_PROPERTY_OUTLINE_STYLE,
1230                                           GTK_TYPE_BORDER_STYLE,
1231                                           0,
1232                                           parse_border_style,
1233                                           NULL,
1234                                           NULL,
1235                                           query_border_style,
1236                                           assign_border_style,
1237                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1238   gtk_css_style_property_register        ("outline-width",
1239                                           GTK_CSS_PROPERTY_OUTLINE_WIDTH,
1240                                           G_TYPE_INT,
1241                                           GTK_STYLE_PROPERTY_ANIMATED,
1242                                           parse_border_width,
1243                                           NULL,
1244                                           compute_border_width,
1245                                           query_length_as_int,
1246                                           assign_length_from_int,
1247                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1248   gtk_css_style_property_register        ("outline-offset",
1249                                           GTK_CSS_PROPERTY_OUTLINE_OFFSET,
1250                                           G_TYPE_INT,
1251                                           0,
1252                                           outline_parse,
1253                                           NULL,
1254                                           outline_compute,
1255                                           query_length_as_int,
1256                                           assign_length_from_int,
1257                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1258
1259   gtk_css_style_property_register        ("background-clip",
1260                                           GTK_CSS_PROPERTY_BACKGROUND_CLIP,
1261                                           G_TYPE_NONE,
1262                                           0,
1263                                           parse_css_area,
1264                                           NULL,
1265                                           NULL,
1266                                           NULL,
1267                                           NULL,
1268                                           _gtk_css_array_value_new (_gtk_css_area_value_new (GTK_CSS_AREA_BORDER_BOX)));
1269   gtk_css_style_property_register        ("background-origin",
1270                                           GTK_CSS_PROPERTY_BACKGROUND_ORIGIN,
1271                                           G_TYPE_NONE,
1272                                           0,
1273                                           parse_css_area,
1274                                           NULL,
1275                                           NULL,
1276                                           NULL,
1277                                           NULL,
1278                                           _gtk_css_array_value_new (_gtk_css_area_value_new (GTK_CSS_AREA_PADDING_BOX)));
1279   gtk_css_style_property_register        ("background-size",
1280                                           GTK_CSS_PROPERTY_BACKGROUND_SIZE,
1281                                           G_TYPE_NONE,
1282                                           0,
1283                                           background_size_parse,
1284                                           NULL,
1285                                           background_size_compute,
1286                                           NULL,
1287                                           NULL,
1288                                           _gtk_css_array_value_new (_gtk_css_bg_size_value_new (NULL, NULL)));
1289   gtk_css_style_property_register        ("background-position",
1290                                           GTK_CSS_PROPERTY_BACKGROUND_POSITION,
1291                                           G_TYPE_NONE,
1292                                           GTK_STYLE_PROPERTY_ANIMATED,
1293                                           background_position_parse,
1294                                           NULL,
1295                                           background_position_compute,
1296                                           NULL,
1297                                           NULL,
1298                                           _gtk_css_array_value_new (_gtk_css_position_value_new (_gtk_css_number_value_new (0, GTK_CSS_PERCENT),
1299                                                                                                  _gtk_css_number_value_new (0, GTK_CSS_PERCENT))));
1300
1301   gtk_css_style_property_register        ("border-top-color",
1302                                           GTK_CSS_PROPERTY_BORDER_TOP_COLOR,
1303                                           GDK_TYPE_RGBA,
1304                                           GTK_STYLE_PROPERTY_ANIMATED,
1305                                           color_parse,
1306                                           NULL,
1307                                           color_compute,
1308                                           color_query,
1309                                           color_assign,
1310                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1311                                             gtk_symbolic_color_ref (
1312                                               _gtk_symbolic_color_get_current_color ())));
1313   gtk_css_style_property_register        ("border-right-color",
1314                                           GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR,
1315                                           GDK_TYPE_RGBA,
1316                                           GTK_STYLE_PROPERTY_ANIMATED,
1317                                           color_parse,
1318                                           NULL,
1319                                           color_compute,
1320                                           color_query,
1321                                           color_assign,
1322                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1323                                             gtk_symbolic_color_ref (
1324                                               _gtk_symbolic_color_get_current_color ())));
1325   gtk_css_style_property_register        ("border-bottom-color",
1326                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR,
1327                                           GDK_TYPE_RGBA,
1328                                           GTK_STYLE_PROPERTY_ANIMATED,
1329                                           color_parse,
1330                                           NULL,
1331                                           color_compute,
1332                                           color_query,
1333                                           color_assign,
1334                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1335                                             gtk_symbolic_color_ref (
1336                                               _gtk_symbolic_color_get_current_color ())));
1337   gtk_css_style_property_register        ("border-left-color",
1338                                           GTK_CSS_PROPERTY_BORDER_LEFT_COLOR,
1339                                           GDK_TYPE_RGBA,
1340                                           GTK_STYLE_PROPERTY_ANIMATED,
1341                                           color_parse,
1342                                           NULL,
1343                                           color_compute,
1344                                           color_query,
1345                                           color_assign,
1346                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1347                                             gtk_symbolic_color_ref (
1348                                               _gtk_symbolic_color_get_current_color ())));
1349   gtk_css_style_property_register        ("outline-color",
1350                                           GTK_CSS_PROPERTY_OUTLINE_COLOR,
1351                                           GDK_TYPE_RGBA,
1352                                           GTK_STYLE_PROPERTY_ANIMATED,
1353                                           color_parse,
1354                                           NULL,
1355                                           color_compute,
1356                                           color_query,
1357                                           color_assign,
1358                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1359                                             gtk_symbolic_color_ref (
1360                                               _gtk_symbolic_color_get_current_color ())));
1361
1362   gtk_css_style_property_register        ("background-repeat",
1363                                           GTK_CSS_PROPERTY_BACKGROUND_REPEAT,
1364                                           G_TYPE_NONE,
1365                                           0,
1366                                           background_repeat_value_parse,
1367                                           NULL,
1368                                           NULL,
1369                                           NULL,
1370                                           NULL,
1371                                           _gtk_css_array_value_new (_gtk_css_background_repeat_value_new (GTK_CSS_REPEAT_STYLE_REPEAT,
1372                                                                                                           GTK_CSS_REPEAT_STYLE_REPEAT)));
1373   gtk_css_style_property_register        ("background-image",
1374                                           GTK_CSS_PROPERTY_BACKGROUND_IMAGE,
1375                                           CAIRO_GOBJECT_TYPE_PATTERN,
1376                                           GTK_STYLE_PROPERTY_ANIMATED,
1377                                           background_image_value_parse,
1378                                           NULL,
1379                                           background_image_value_compute,
1380                                           background_image_value_query,
1381                                           background_image_value_assign,
1382                                           _gtk_css_array_value_new (_gtk_css_image_value_new (NULL)));
1383
1384   gtk_css_style_property_register        ("border-image-source",
1385                                           GTK_CSS_PROPERTY_BORDER_IMAGE_SOURCE,
1386                                           CAIRO_GOBJECT_TYPE_PATTERN,
1387                                           GTK_STYLE_PROPERTY_ANIMATED,
1388                                           css_image_value_parse,
1389                                           NULL,
1390                                           css_image_value_compute,
1391                                           css_image_value_query,
1392                                           css_image_value_assign,
1393                                           _gtk_css_image_value_new (NULL));
1394   gtk_css_style_property_register        ("border-image-repeat",
1395                                           GTK_CSS_PROPERTY_BORDER_IMAGE_REPEAT,
1396                                           G_TYPE_NONE,
1397                                           0,
1398                                           border_image_repeat_parse,
1399                                           NULL,
1400                                           NULL,
1401                                           NULL,
1402                                           NULL,
1403                                           _gtk_css_border_repeat_value_new (GTK_CSS_REPEAT_STYLE_STRETCH,
1404                                                                             GTK_CSS_REPEAT_STYLE_STRETCH));
1405
1406   gtk_css_style_property_register        ("border-image-slice",
1407                                           GTK_CSS_PROPERTY_BORDER_IMAGE_SLICE,
1408                                           GTK_TYPE_BORDER,
1409                                           0,
1410                                           border_image_slice_parse,
1411                                           NULL,
1412                                           compute_border,
1413                                           query_border,
1414                                           assign_border,
1415                                           _gtk_css_border_value_new (_gtk_css_number_value_new (100, GTK_CSS_PERCENT),
1416                                                                      _gtk_css_number_value_new (100, GTK_CSS_PERCENT),
1417                                                                      _gtk_css_number_value_new (100, GTK_CSS_PERCENT),
1418                                                                      _gtk_css_number_value_new (100, GTK_CSS_PERCENT)));
1419   gtk_css_style_property_register        ("border-image-width",
1420                                           GTK_CSS_PROPERTY_BORDER_IMAGE_WIDTH,
1421                                           GTK_TYPE_BORDER,
1422                                           0,
1423                                           border_image_width_parse,
1424                                           NULL,
1425                                           compute_border,
1426                                           query_border,
1427                                           assign_border,
1428                                           _gtk_css_border_value_new (_gtk_css_number_value_new (1, GTK_CSS_NUMBER),
1429                                                                      _gtk_css_number_value_new (1, GTK_CSS_NUMBER),
1430                                                                      _gtk_css_number_value_new (1, GTK_CSS_NUMBER),
1431                                                                      _gtk_css_number_value_new (1, GTK_CSS_NUMBER)));
1432
1433   gtk_css_style_property_register        ("transition-property",
1434                                           GTK_CSS_PROPERTY_TRANSITION_PROPERTY,
1435                                           G_TYPE_NONE,
1436                                           0,
1437                                           transition_property_parse,
1438                                           NULL,
1439                                           NULL,
1440                                           NULL,
1441                                           NULL,
1442                                           _gtk_css_array_value_new (_gtk_css_ident_value_new ("all")));
1443   gtk_css_style_property_register        ("transition-duration",
1444                                           GTK_CSS_PROPERTY_TRANSITION_DURATION,
1445                                           G_TYPE_NONE,
1446                                           0,
1447                                           transition_time_parse,
1448                                           NULL,
1449                                           NULL,
1450                                           NULL,
1451                                           NULL,
1452                                           _gtk_css_array_value_new (_gtk_css_number_value_new (0, GTK_CSS_S)));
1453   gtk_css_style_property_register        ("transition-timing-function",
1454                                           GTK_CSS_PROPERTY_TRANSITION_TIMING_FUNCTION,
1455                                           G_TYPE_NONE,
1456                                           0,
1457                                           transition_timing_function_parse,
1458                                           NULL,
1459                                           NULL,
1460                                           NULL,
1461                                           NULL,
1462                                           _gtk_css_array_value_new (
1463                                             _gtk_css_ease_value_new_cubic_bezier (0.25, 0.1, 0.25, 1.0)));
1464   gtk_css_style_property_register        ("transition-delay",
1465                                           GTK_CSS_PROPERTY_TRANSITION_DELAY,
1466                                           G_TYPE_NONE,
1467                                           0,
1468                                           transition_time_parse,
1469                                           NULL,
1470                                           NULL,
1471                                           NULL,
1472                                           NULL,
1473                                           _gtk_css_array_value_new (_gtk_css_number_value_new (0, GTK_CSS_S)));
1474
1475   gtk_css_style_property_register        ("engine",
1476                                           GTK_CSS_PROPERTY_ENGINE,
1477                                           GTK_TYPE_THEMING_ENGINE,
1478                                           0,
1479                                           engine_parse,
1480                                           NULL,
1481                                           NULL,
1482                                           engine_query,
1483                                           engine_assign,
1484                                           _gtk_css_engine_value_new (gtk_theming_engine_load (NULL)));
1485
1486   /* Private property holding the binding sets */
1487   gtk_css_style_property_register        ("gtk-key-bindings",
1488                                           GTK_CSS_PROPERTY_GTK_KEY_BINDINGS,
1489                                           G_TYPE_PTR_ARRAY,
1490                                           0,
1491                                           bindings_value_parse,
1492                                           NULL,
1493                                           NULL,
1494                                           bindings_value_query,
1495                                           bindings_value_assign,
1496                                           _gtk_css_array_value_new (NULL));
1497 }
1498