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