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