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