Pileus Git - ~andy/gtk/blob - gtk/gtkcssstylepropertyimpl.c

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2010 Carlos Garnacho <carlosg@gnome.org>
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #include "config.h"
  19
  20 #include "gtkstylepropertyprivate.h"
  21
  22 #include <gobject/gvaluecollector.h>
  23 #include <gdk-pixbuf/gdk-pixbuf.h>
  24 #include <cairo-gobject.h>
  25 #include <math.h>
  26
  27 #include "gtkcssparserprivate.h"
  28 #include "gtkcssstylefuncsprivate.h"
  29 #include "gtkcssstylepropertyprivate.h"
  30 #include "gtkcsstypesprivate.h"
  31 #include "gtkintl.h"
  32 #include "gtkprivatetypebuiltins.h"
  33 #include "gtkstylepropertiesprivate.h"
  34
  35 /* this is in case round() is not provided by the compiler,
  36  * such as in the case of C89 compilers, like MSVC
  37  */
  38 #include "fallback-c89.c"
  39
  40 /* the actual parsers we have */
  41 #include "gtkbindings.h"
  42 #include "gtkcssarrayvalueprivate.h"
  43 #include "gtkcssbgsizevalueprivate.h"
  44 #include "gtkcssbordervalueprivate.h"
  45 #include "gtkcsscornervalueprivate.h"
  46 #include "gtkcsseasevalueprivate.h"
  47 #include "gtkcssenginevalueprivate.h"
  48 #include "gtkcssimagegradientprivate.h"
  49 #include "gtkcssimageprivate.h"
  50 #include "gtkcssimagevalueprivate.h"
  51 #include "gtkcssenumvalueprivate.h"
  52 #include "gtkcssnumbervalueprivate.h"
  53 #include "gtkcsspositionvalueprivate.h"
  54 #include "gtkcssrepeatvalueprivate.h"
  55 #include "gtkcssrgbavalueprivate.h"
  56 #include "gtkcssshadowsvalueprivate.h"
  57 #include "gtkcssstringvalueprivate.h"
  58 #include "gtksymboliccolorprivate.h"
  59 #include "gtkthemingengine.h"
  60 #include "gtktypebuiltins.h"
  61 #include "gtkwin32themeprivate.h"
  62
  63 /*** REGISTRATION ***/
  64
  65 typedef enum {
  66   GTK_STYLE_PROPERTY_INHERIT = (1 << 0),
  67   GTK_STYLE_PROPERTY_ANIMATED = (1 << 1)
  68 } GtkStylePropertyFlags;
  69
  70 static void
  71 gtk_css_style_property_register (const char *                   name,
  72                                  guint                          expected_id,
  73                                  GType                          value_type,
  74                                  GtkStylePropertyFlags          flags,
  75                                  GtkCssStylePropertyParseFunc   parse_value,
  76                                  GtkCssStylePropertyPrintFunc   print_value,
  77                                  GtkCssStylePropertyComputeFunc compute_value,
  78                                  GtkCssStylePropertyQueryFunc   query_value,
  79                                  GtkCssStylePropertyAssignFunc  assign_value,
  80                                  GtkCssValue *                  initial_value)
  81 {
  82   GtkCssStyleProperty *node;
  83
  84   g_assert (initial_value != NULL);
  85   g_assert (parse_value != NULL);
  86   g_assert (value_type == G_TYPE_NONE || query_value != NULL);
  87   g_assert (value_type == G_TYPE_NONE || assign_value != NULL);
  88
  89   node = g_object_new (GTK_TYPE_CSS_STYLE_PROPERTY,
  90                        "value-type", value_type,
  91                        "animated", (flags & GTK_STYLE_PROPERTY_ANIMATED) ? TRUE : FALSE,
  92                        "inherit", (flags & GTK_STYLE_PROPERTY_INHERIT) ? TRUE : FALSE,
  93                        "initial-value", initial_value,
  94                        "name", name,
  95                        NULL);
  96
  97   node->parse_value = parse_value;
  98   if (print_value)
  99     node->print_value = print_value;
 100   if (compute_value)
 101     node->compute_value = compute_value;
 102   node->query_value = query_value;
 103   node->assign_value = assign_value;
 104
 105   _gtk_css_value_unref (initial_value);
 106
 107   g_assert (_gtk_css_style_property_get_id (node) == expected_id);
 108 }
 109
 110 /*** IMPLEMENTATIONS ***/
 111
 112 static void
 113 query_length_as_int (GtkCssStyleProperty *property,
 114                      const GtkCssValue   *css_value,
 115                      GValue              *value)
 116 {
 117   g_value_init (value, G_TYPE_INT);
 118   g_value_set_int (value, round (_gtk_css_number_value_get (css_value, 100)));
 119 }
 120
 121 static GtkCssValue *
 122 assign_length_from_int (GtkCssStyleProperty *property,
 123                         const GValue        *value)
 124 {
 125   return _gtk_css_number_value_new (g_value_get_int (value), GTK_CSS_PX);
 126 }
 127
 128 static void
 129 query_length_as_double (GtkCssStyleProperty *property,
 130                         const GtkCssValue   *css_value,
 131                         GValue              *value)
 132 {
 133   g_value_init (value, G_TYPE_DOUBLE);
 134   g_value_set_double (value, _gtk_css_number_value_get (css_value, 100));
 135 }
 136
 137 static GtkCssValue *
 138 assign_length_from_double (GtkCssStyleProperty *property,
 139                            const GValue        *value)
 140 {
 141   return _gtk_css_number_value_new (g_value_get_double (value), GTK_CSS_PX);
 142 }
 143
 144 static void
 145 query_border (GtkCssStyleProperty *property,
 146               const GtkCssValue   *css_value,
 147               GValue              *value)
 148 {
 149   GtkBorder border;
 150
 151   g_value_init (value, GTK_TYPE_BORDER);
 152
 153   border.top = round (_gtk_css_number_value_get (_gtk_css_border_value_get_top (css_value), 100));
 154   border.right = round (_gtk_css_number_value_get (_gtk_css_border_value_get_right (css_value), 100));
 155   border.bottom = round (_gtk_css_number_value_get (_gtk_css_border_value_get_bottom (css_value), 100));
 156   border.left = round (_gtk_css_number_value_get (_gtk_css_border_value_get_left (css_value), 100));
 157
 158   g_value_set_boxed (value, &border);
 159 }
 160
 161 static GtkCssValue *
 162 assign_border (GtkCssStyleProperty *property,
 163                const GValue        *value)
 164 {
 165   const GtkBorder *border = g_value_get_boxed (value);
 166
 167   if (border == NULL)
 168     return _gtk_css_value_ref (_gtk_css_style_property_get_initial_value (property));
 169   else
 170     return _gtk_css_border_value_new (_gtk_css_number_value_new (border->top, GTK_CSS_PX),
 171                                       _gtk_css_number_value_new (border->right, GTK_CSS_PX),
 172                                       _gtk_css_number_value_new (border->bottom, GTK_CSS_PX),
 173                                       _gtk_css_number_value_new (border->left, GTK_CSS_PX));
 174 }
 175
 176 static GtkCssValue *
 177 color_parse (GtkCssStyleProperty *property,
 178              GtkCssParser        *parser)
 179 {
 180   return _gtk_css_symbolic_value_new (parser);
 181 }
 182
 183 static GtkCssValue *
 184 color_compute (GtkCssStyleProperty    *property,
 185                GtkStyleContext        *context,
 186                GtkCssValue            *specified)
 187 {
 188   return _gtk_css_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 {
 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 {
 306   GtkCssValue *value = _gtk_css_font_style_value_try_parse (parser);
 307
 308   if (value == NULL)
 309     _gtk_css_parser_error (parser, "unknown value for property");
 310
 311   return value;
 312 }
 313
 314 static void
 315 query_pango_style (GtkCssStyleProperty *property,
 316                     const GtkCssValue   *css_value,
 317                     GValue              *value)
 318 {
 319   g_value_init (value, PANGO_TYPE_STYLE);
 320   g_value_set_enum (value, _gtk_css_font_style_value_get (css_value));
 321 }
 322
 323 static GtkCssValue *
 324 assign_pango_style (GtkCssStyleProperty *property,
 325                     const GValue        *value)
 326 {
 327   return _gtk_css_font_style_value_new (g_value_get_enum (value));
 328 }
 329
 330 static GtkCssValue *
 331 parse_pango_weight (GtkCssStyleProperty *property,
 332                     GtkCssParser        *parser)
 333 {
 334   GtkCssValue *value = _gtk_css_font_weight_value_try_parse (parser);
 335
 336   if (value == NULL)
 337     _gtk_css_parser_error (parser, "unknown value for property");
 338
 339   return value;
 340 }
 341
 342 static void
 343 query_pango_weight (GtkCssStyleProperty *property,
 344                     const GtkCssValue   *css_value,
 345                     GValue              *value)
 346 {
 347   g_value_init (value, PANGO_TYPE_WEIGHT);
 348   g_value_set_enum (value, _gtk_css_font_weight_value_get (css_value));
 349 }
 350
 351 static GtkCssValue *
 352 assign_pango_weight (GtkCssStyleProperty *property,
 353                      const GValue        *value)
 354 {
 355   return _gtk_css_font_weight_value_new (g_value_get_enum (value));
 356 }
 357
 358 static GtkCssValue *
 359 parse_pango_variant (GtkCssStyleProperty *property,
 360                      GtkCssParser        *parser)
 361 {
 362   GtkCssValue *value = _gtk_css_font_variant_value_try_parse (parser);
 363
 364   if (value == NULL)
 365     _gtk_css_parser_error (parser, "unknown value for property");
 366
 367   return value;
 368 }
 369
 370 static void
 371 query_pango_variant (GtkCssStyleProperty *property,
 372                      const GtkCssValue   *css_value,
 373                      GValue              *value)
 374 {
 375   g_value_init (value, PANGO_TYPE_VARIANT);
 376   g_value_set_enum (value, _gtk_css_font_variant_value_get (css_value));
 377 }
 378
 379 static GtkCssValue *
 380 assign_pango_variant (GtkCssStyleProperty *property,
 381                       const GValue        *value)
 382 {
 383   return _gtk_css_font_variant_value_new (g_value_get_enum (value));
 384 }
 385
 386 static GtkCssValue *
 387 parse_border_style (GtkCssStyleProperty *property,
 388                     GtkCssParser        *parser)
 389 {
 390   GtkCssValue *value = _gtk_css_border_style_value_try_parse (parser);
 391
 392   if (value == NULL)
 393     _gtk_css_parser_error (parser, "unknown value for property");
 394
 395   return value;
 396 }
 397
 398 static void
 399 query_border_style (GtkCssStyleProperty *property,
 400                     const GtkCssValue   *css_value,
 401                     GValue              *value)
 402 {
 403   g_value_init (value, GTK_TYPE_BORDER_STYLE);
 404   g_value_set_enum (value, _gtk_css_border_style_value_get (css_value));
 405 }
 406
 407 static GtkCssValue *
 408 assign_border_style (GtkCssStyleProperty *property,
 409                      const GValue        *value)
 410 {
 411   return _gtk_css_border_style_value_new (g_value_get_enum (value));
 412 }
 413
 414 static GtkCssValue *
 415 parse_css_area_one (GtkCssParser *parser)
 416 {
 417   GtkCssValue *value = _gtk_css_area_value_try_parse (parser);
 418
 419   if (value == NULL)
 420     _gtk_css_parser_error (parser, "unknown value for property");
 421
 422   return value;
 423 }
 424
 425 static GtkCssValue *
 426 parse_css_area (GtkCssStyleProperty *property,
 427                 GtkCssParser        *parser)
 428 {
 429   return _gtk_css_array_value_parse (parser, parse_css_area_one, FALSE);
 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 {
 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 {
 515   return _gtk_css_shadows_value_parse (parser);
 516 }
 517
 518 static GtkCssValue *
 519 shadow_value_compute (GtkCssStyleProperty *property,
 520                       GtkStyleContext     *context,
 521                       GtkCssValue         *specified)
 522 {
 523   return _gtk_css_shadows_value_compute (specified, context);
 524 }
 525
 526 static GtkCssValue *
 527 border_corner_radius_value_parse (GtkCssStyleProperty *property,
 528                                   GtkCssParser        *parser)
 529 {
 530   return _gtk_css_corner_value_parse (parser);
 531 }
 532
 533 static GtkCssValue *
 534 border_corner_radius_value_compute (GtkCssStyleProperty *property,
 535                                     GtkStyleContext     *context,
 536                                     GtkCssValue         *specified)
 537 {
 538   return _gtk_css_corner_value_compute (specified, context);
 539 }
 540
 541 static GtkCssValue *
 542 css_image_value_parse (GtkCssStyleProperty *property,
 543                        GtkCssParser        *parser)
 544 {
 545   GtkCssImage *image;
 546
 547   if (_gtk_css_parser_try (parser, "none", TRUE))
 548     image = NULL;
 549   else
 550     {
 551       image = _gtk_css_image_new_parse (parser);
 552       if (image == NULL)
 553         return FALSE;
 554     }
 555
 556   return _gtk_css_image_value_new (image);
 557 }
 558
 559 static GtkCssValue *
 560 css_image_value_compute (GtkCssStyleProperty    *property,
 561                          GtkStyleContext        *context,
 562                          GtkCssValue            *specified)
 563 {
 564   GtkCssImage *image, *computed;
 565
 566   image = _gtk_css_image_value_get_image (specified);
 567
 568   if (image == NULL)
 569     return _gtk_css_value_ref (specified);
 570
 571   computed = _gtk_css_image_compute (image, context);
 572
 573   if (computed == image)
 574     {
 575       g_object_unref (computed);
 576       return _gtk_css_value_ref (specified);
 577     }
 578
 579   return _gtk_css_image_value_new (computed);
 580 }
 581
 582 static void
 583 css_image_value_query (GtkCssStyleProperty *property,
 584                        const GtkCssValue   *css_value,
 585                        GValue              *value)
 586 {
 587   GtkCssImage *image = _gtk_css_image_value_get_image (css_value);
 588   cairo_pattern_t *pattern;
 589   cairo_surface_t *surface;
 590   cairo_matrix_t matrix;
 591
 592   g_value_init (value, CAIRO_GOBJECT_TYPE_PATTERN);
 593
 594   if (GTK_IS_CSS_IMAGE_GRADIENT (image))
 595     g_value_set_boxed (value, GTK_CSS_IMAGE_GRADIENT (image)->pattern);
 596   else if (image != NULL)
 597     {
 598       double width, height;
 599
 600       /* the 100, 100 is rather random */
 601       _gtk_css_image_get_concrete_size (image, 0, 0, 100, 100, &width, &height);
 602       surface = _gtk_css_image_get_surface (image, NULL, width, height);
 603       pattern = cairo_pattern_create_for_surface (surface);
 604       cairo_matrix_init_scale (&matrix, width, height);
 605       cairo_pattern_set_matrix (pattern, &matrix);
 606       cairo_surface_destroy (surface);
 607       g_value_take_boxed (value, pattern);
 608     }
 609 }
 610
 611 static GtkCssValue *
 612 css_image_value_assign (GtkCssStyleProperty *property,
 613                         const GValue        *value)
 614 {
 615   g_warning ("FIXME: assigning images is not implemented");
 616   return _gtk_css_image_value_new (NULL);
 617 }
 618
 619 static GtkCssValue *
 620 background_image_value_parse_one (GtkCssParser *parser)
 621 {
 622   return css_image_value_parse (NULL, parser);
 623 }
 624
 625 static GtkCssValue *
 626 background_image_value_parse (GtkCssStyleProperty *property,
 627                               GtkCssParser        *parser)
 628 {
 629   return _gtk_css_array_value_parse (parser, background_image_value_parse_one, FALSE);
 630 }
 631
 632 static GtkCssValue *
 633 background_image_value_compute_one (GtkCssValue     *value,
 634                                     GtkStyleContext *context)
 635 {
 636   return css_image_value_compute (NULL, context, value);
 637 }
 638
 639 static GtkCssValue *
 640 background_image_value_compute (GtkCssStyleProperty    *property,
 641                                 GtkStyleContext        *context,
 642                                 GtkCssValue            *specified)
 643 {
 644   return _gtk_css_array_value_compute (specified, background_image_value_compute_one, context);
 645 }
 646
 647 static void
 648 background_image_value_query (GtkCssStyleProperty *property,
 649                               const GtkCssValue   *css_value,
 650                               GValue              *value)
 651 {
 652   css_image_value_query (property, _gtk_css_array_value_get_nth (css_value, 0), value);
 653 }
 654
 655 static GtkCssValue *
 656 background_image_value_assign (GtkCssStyleProperty *property,
 657                                const GValue        *value)
 658 {
 659   return _gtk_css_array_value_new (css_image_value_assign (property, value));
 660 }
 661
 662 static GtkCssValue *
 663 font_size_parse (GtkCssStyleProperty *property,
 664                  GtkCssParser        *parser)
 665 {
 666   gdouble d;
 667
 668   if (!_gtk_css_parser_try_double (parser, &d))
 669     {
 670       _gtk_css_parser_error (parser, "Expected a number");
 671       return NULL;
 672     }
 673
 674   return _gtk_css_number_value_new (d, GTK_CSS_PX);
 675 }
 676
 677 static GtkCssValue *
 678 font_size_compute (GtkCssStyleProperty *property,
 679                    GtkStyleContext     *context,
 680                    GtkCssValue         *specified)
 681 {
 682   return _gtk_css_number_value_compute (specified, context);
 683 }
 684
 685 static GtkCssValue *
 686 outline_parse (GtkCssStyleProperty *property,
 687                GtkCssParser        *parser)
 688 {
 689   return _gtk_css_number_value_parse (parser,
 690                                       GTK_CSS_NUMBER_AS_PIXELS
 691                                       | GTK_CSS_PARSE_LENGTH);
 692 }
 693
 694 static GtkCssValue *
 695 outline_compute (GtkCssStyleProperty *property,
 696                  GtkStyleContext     *context,
 697                  GtkCssValue         *specified)
 698 {
 699   return _gtk_css_number_value_compute (specified, context);
 700 }
 701
 702 static GtkCssValue *
 703 border_image_repeat_parse (GtkCssStyleProperty *property,
 704                            GtkCssParser        *parser)
 705 {
 706   GtkCssValue *value = _gtk_css_border_repeat_value_try_parse (parser);
 707
 708   if (value == NULL)
 709     {
 710       _gtk_css_parser_error (parser, "Not a valid value");
 711       return NULL;
 712     }
 713
 714   return value;
 715 }
 716
 717 static GtkCssValue *
 718 border_image_slice_parse (GtkCssStyleProperty *property,
 719                           GtkCssParser        *parser)
 720 {
 721   return _gtk_css_border_value_parse (parser,
 722                                       GTK_CSS_PARSE_PERCENT
 723                                       | GTK_CSS_PARSE_NUMBER
 724                                       | GTK_CSS_POSITIVE_ONLY,
 725                                       FALSE,
 726                                       TRUE);
 727 }
 728
 729 static GtkCssValue *
 730 border_image_width_parse (GtkCssStyleProperty *property,
 731                           GtkCssParser        *parser)
 732 {
 733   return _gtk_css_border_value_parse (parser,
 734                                       GTK_CSS_PARSE_PERCENT
 735                                       | GTK_CSS_PARSE_LENGTH
 736                                       | GTK_CSS_PARSE_NUMBER
 737                                       | GTK_CSS_POSITIVE_ONLY,
 738                                       TRUE,
 739                                       FALSE);
 740 }
 741
 742 static GtkCssValue *
 743 compute_border (GtkCssStyleProperty *property,
 744                 GtkStyleContext     *context,
 745                 GtkCssValue         *specified)
 746 {
 747   return _gtk_css_border_value_compute (specified, context);
 748 }
 749
 750 static GtkCssValue *
 751 transition_property_parse_one (GtkCssParser *parser)
 752 {
 753   GtkCssValue *value;
 754
 755   value = _gtk_css_ident_value_try_parse (parser);
 756
 757   if (value == NULL)
 758     {
 759       _gtk_css_parser_error (parser, "Expected an identifier");
 760       return NULL;
 761     }
 762
 763   return value;
 764 }
 765
 766 static GtkCssValue *
 767 transition_property_parse (GtkCssStyleProperty *property,
 768                            GtkCssParser        *parser)
 769 {
 770   return _gtk_css_array_value_parse (parser, transition_property_parse_one, FALSE);
 771 }
 772
 773 static GtkCssValue *
 774 transition_time_parse_one (GtkCssParser *parser)
 775 {
 776   return _gtk_css_number_value_parse (parser, GTK_CSS_PARSE_TIME);
 777 }
 778
 779 static GtkCssValue *
 780 transition_time_parse (GtkCssStyleProperty *property,
 781                        GtkCssParser        *parser)
 782 {
 783   return _gtk_css_array_value_parse (parser, transition_time_parse_one, FALSE);
 784 }
 785
 786 static GtkCssValue *
 787 transition_timing_function_parse (GtkCssStyleProperty *property,
 788                                   GtkCssParser        *parser)
 789 {
 790   return _gtk_css_array_value_parse (parser, _gtk_css_ease_value_parse, FALSE);
 791 }
 792
 793 static GtkCssValue *
 794 engine_parse (GtkCssStyleProperty *property,
 795               GtkCssParser        *parser)
 796 {
 797   return _gtk_css_engine_value_parse (parser);
 798 }
 799
 800 static void
 801 engine_query (GtkCssStyleProperty *property,
 802               const GtkCssValue   *css_value,
 803               GValue              *value)
 804 {
 805   g_value_init (value, GTK_TYPE_THEMING_ENGINE);
 806   g_value_set_object (value, _gtk_css_engine_value_get_engine (css_value));
 807 }
 808
 809 static GtkCssValue *
 810 engine_assign (GtkCssStyleProperty *property,
 811                const GValue        *value)
 812 {
 813   return _gtk_css_engine_value_new (g_value_get_object (value));
 814 }
 815
 816 static GtkCssValue *
 817 parse_margin (GtkCssStyleProperty *property,
 818               GtkCssParser        *parser)
 819 {
 820   return _gtk_css_number_value_parse (parser,
 821                                       GTK_CSS_NUMBER_AS_PIXELS
 822                                       | GTK_CSS_PARSE_LENGTH);
 823 }
 824
 825 static GtkCssValue *
 826 compute_margin (GtkCssStyleProperty *property,
 827                 GtkStyleContext     *context,
 828                 GtkCssValue         *specified)
 829 {
 830   return _gtk_css_number_value_compute (specified, context);
 831 }
 832
 833 static GtkCssValue *
 834 parse_padding (GtkCssStyleProperty *property,
 835                GtkCssParser        *parser)
 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 {
 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_one (GtkCssParser *parser)
 882 {
 883   GtkCssValue *value = _gtk_css_background_repeat_value_try_parse (parser);
 884
 885   if (value == NULL)
 886     {
 887       _gtk_css_parser_error (parser, "Not a valid value");
 888       return NULL;
 889     }
 890
 891   return value;
 892 }
 893
 894 static GtkCssValue *
 895 background_repeat_value_parse (GtkCssStyleProperty *property,
 896                                GtkCssParser        *parser)
 897 {
 898   return _gtk_css_array_value_parse (parser, background_repeat_value_parse_one, FALSE);
 899 }
 900
 901 static GtkCssValue *
 902 background_size_parse (GtkCssStyleProperty *property,
 903                        GtkCssParser        *parser)
 904 {
 905   return _gtk_css_array_value_parse (parser, _gtk_css_bg_size_value_parse, FALSE);
 906 }
 907
 908 static GtkCssValue *
 909 background_size_compute (GtkCssStyleProperty    *property,
 910                          GtkStyleContext        *context,
 911                          GtkCssValue            *specified)
 912 {
 913   return _gtk_css_array_value_compute (specified, _gtk_css_bg_size_value_compute, context);
 914 }
 915
 916 static GtkCssValue *
 917 background_position_parse (GtkCssStyleProperty *property,
 918                            GtkCssParser        *parser)
 919 {
 920   return _gtk_css_array_value_parse (parser, _gtk_css_position_value_parse, FALSE);
 921 }
 922
 923 static GtkCssValue *
 924 background_position_compute (GtkCssStyleProperty    *property,
 925                              GtkStyleContext        *context,
 926                              GtkCssValue            *specified)
 927 {
 928   return _gtk_css_array_value_compute (specified, _gtk_css_position_value_compute, context);
 929 }
 930
 931 /*** REGISTRATION ***/
 932
 933 static GtkSymbolicColor *
 934 gtk_symbolic_color_new_rgba (double red,
 935                              double green,
 936                              double blue,
 937                              double alpha)
 938 {
 939   GdkRGBA rgba = { red, green, blue, alpha };
 940
 941   return gtk_symbolic_color_new_literal (&rgba);
 942 }
 943
 944 void
 945 _gtk_css_style_property_init_properties (void)
 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                                           _gtk_css_symbolic_value_new_take_symbolic_color (
 961                                             gtk_symbolic_color_new_rgba (1, 1, 1, 1)));
 962   gtk_css_style_property_register        ("font-size",
 963                                           GTK_CSS_PROPERTY_FONT_SIZE,
 964                                           G_TYPE_DOUBLE,
 965                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
 966                                           font_size_parse,
 967                                           NULL,
 968                                           font_size_compute,
 969                                           query_length_as_double,
 970                                           assign_length_from_double,
 971                                           /* XXX: This should be 'normal' */
 972                                           _gtk_css_number_value_new (10.0, GTK_CSS_PX));
 973
 974   /* properties that aren't referenced when computing values
 975    * start here */
 976   gtk_css_style_property_register        ("background-color",
 977                                           GTK_CSS_PROPERTY_BACKGROUND_COLOR,
 978                                           GDK_TYPE_RGBA,
 979                                           GTK_STYLE_PROPERTY_ANIMATED,
 980                                           color_parse,
 981                                           NULL,
 982                                           color_compute,
 983                                           color_query,
 984                                           color_assign,
 985                                           _gtk_css_symbolic_value_new_take_symbolic_color (
 986                                             gtk_symbolic_color_new_rgba (0, 0, 0, 0)));
 987
 988   gtk_css_style_property_register        ("font-family",
 989                                           GTK_CSS_PROPERTY_FONT_FAMILY,
 990                                           G_TYPE_STRV,
 991                                           GTK_STYLE_PROPERTY_INHERIT,
 992                                           font_family_parse,
 993                                           NULL,
 994                                           NULL,
 995                                           font_family_query,
 996                                           font_family_assign,
 997                                           _gtk_css_array_value_new (_gtk_css_string_value_new ("Sans")));
 998   gtk_css_style_property_register        ("font-style",
 999                                           GTK_CSS_PROPERTY_FONT_STYLE,
1000                                           PANGO_TYPE_STYLE,
1001                                           GTK_STYLE_PROPERTY_INHERIT,
1002                                           parse_pango_style,
1003                                           NULL,
1004                                           NULL,
1005                                           query_pango_style,
1006                                           assign_pango_style,
1007                                           _gtk_css_font_style_value_new (PANGO_STYLE_NORMAL));
1008   gtk_css_style_property_register        ("font-variant",
1009                                           GTK_CSS_PROPERTY_FONT_VARIANT,
1010                                           PANGO_TYPE_VARIANT,
1011                                           GTK_STYLE_PROPERTY_INHERIT,
1012                                           parse_pango_variant,
1013                                           NULL,
1014                                           NULL,
1015                                           query_pango_variant,
1016                                           assign_pango_variant,
1017                                           _gtk_css_font_variant_value_new (PANGO_VARIANT_NORMAL));
1018   gtk_css_style_property_register        ("font-weight",
1019                                           GTK_CSS_PROPERTY_FONT_WEIGHT,
1020                                           PANGO_TYPE_WEIGHT,
1021                                           GTK_STYLE_PROPERTY_INHERIT,
1022                                           parse_pango_weight,
1023                                           NULL,
1024                                           NULL,
1025                                           query_pango_weight,
1026                                           assign_pango_weight,
1027                                           _gtk_css_font_weight_value_new (PANGO_WEIGHT_NORMAL));
1028
1029   gtk_css_style_property_register        ("text-shadow",
1030                                           GTK_CSS_PROPERTY_TEXT_SHADOW,
1031                                           G_TYPE_NONE,
1032                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
1033                                           shadow_value_parse,
1034                                           NULL,
1035                                           shadow_value_compute,
1036                                           NULL,
1037                                           NULL,
1038                                           _gtk_css_shadows_value_new_none ());
1039
1040   gtk_css_style_property_register        ("icon-shadow",
1041                                           GTK_CSS_PROPERTY_ICON_SHADOW,
1042                                           G_TYPE_NONE,
1043                                           GTK_STYLE_PROPERTY_INHERIT | GTK_STYLE_PROPERTY_ANIMATED,
1044                                           shadow_value_parse,
1045                                           NULL,
1046                                           shadow_value_compute,
1047                                           NULL,
1048                                           NULL,
1049                                           _gtk_css_shadows_value_new_none ());
1050
1051   gtk_css_style_property_register        ("box-shadow",
1052                                           GTK_CSS_PROPERTY_BOX_SHADOW,
1053                                           G_TYPE_NONE,
1054                                           GTK_STYLE_PROPERTY_ANIMATED,
1055                                           shadow_value_parse,
1056                                           NULL,
1057                                           shadow_value_compute,
1058                                           NULL,
1059                                           NULL,
1060                                           _gtk_css_shadows_value_new_none ());
1061
1062   gtk_css_style_property_register        ("margin-top",
1063                                           GTK_CSS_PROPERTY_MARGIN_TOP,
1064                                           G_TYPE_INT,
1065                                           GTK_STYLE_PROPERTY_ANIMATED,
1066                                           parse_margin,
1067                                           NULL,
1068                                           compute_margin,
1069                                           query_length_as_int,
1070                                           assign_length_from_int,
1071                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1072   gtk_css_style_property_register        ("margin-left",
1073                                           GTK_CSS_PROPERTY_MARGIN_LEFT,
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                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1082   gtk_css_style_property_register        ("margin-bottom",
1083                                           GTK_CSS_PROPERTY_MARGIN_BOTTOM,
1084                                           G_TYPE_INT,
1085                                           GTK_STYLE_PROPERTY_ANIMATED,
1086                                           parse_margin,
1087                                           NULL,
1088                                           compute_margin,
1089                                           query_length_as_int,
1090                                           assign_length_from_int,
1091                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1092   gtk_css_style_property_register        ("margin-right",
1093                                           GTK_CSS_PROPERTY_MARGIN_RIGHT,
1094                                           G_TYPE_INT,
1095                                           GTK_STYLE_PROPERTY_ANIMATED,
1096                                           parse_margin,
1097                                           NULL,
1098                                           compute_margin,
1099                                           query_length_as_int,
1100                                           assign_length_from_int,
1101                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1102   gtk_css_style_property_register        ("padding-top",
1103                                           GTK_CSS_PROPERTY_PADDING_TOP,
1104                                           G_TYPE_INT,
1105                                           GTK_STYLE_PROPERTY_ANIMATED,
1106                                           parse_padding,
1107                                           NULL,
1108                                           compute_padding,
1109                                           query_length_as_int,
1110                                           assign_length_from_int,
1111                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1112   gtk_css_style_property_register        ("padding-left",
1113                                           GTK_CSS_PROPERTY_PADDING_LEFT,
1114                                           G_TYPE_INT,
1115                                           GTK_STYLE_PROPERTY_ANIMATED,
1116                                           parse_padding,
1117                                           NULL,
1118                                           compute_padding,
1119                                           query_length_as_int,
1120                                           assign_length_from_int,
1121                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1122   gtk_css_style_property_register        ("padding-bottom",
1123                                           GTK_CSS_PROPERTY_PADDING_BOTTOM,
1124                                           G_TYPE_INT,
1125                                           GTK_STYLE_PROPERTY_ANIMATED,
1126                                           parse_padding,
1127                                           NULL,
1128                                           compute_padding,
1129                                           query_length_as_int,
1130                                           assign_length_from_int,
1131                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1132   gtk_css_style_property_register        ("padding-right",
1133                                           GTK_CSS_PROPERTY_PADDING_RIGHT,
1134                                           G_TYPE_INT,
1135                                           GTK_STYLE_PROPERTY_ANIMATED,
1136                                           parse_padding,
1137                                           NULL,
1138                                           compute_padding,
1139                                           query_length_as_int,
1140                                           assign_length_from_int,
1141                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1142   /* IMPORTANT: compute_border_width() requires that the border-width
1143    * properties be immeditaly followed by the border-style properties
1144    */
1145   gtk_css_style_property_register        ("border-top-style",
1146                                           GTK_CSS_PROPERTY_BORDER_TOP_STYLE,
1147                                           GTK_TYPE_BORDER_STYLE,
1148                                           0,
1149                                           parse_border_style,
1150                                           NULL,
1151                                           NULL,
1152                                           query_border_style,
1153                                           assign_border_style,
1154                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1155   gtk_css_style_property_register        ("border-top-width",
1156                                           GTK_CSS_PROPERTY_BORDER_TOP_WIDTH,
1157                                           G_TYPE_INT,
1158                                           GTK_STYLE_PROPERTY_ANIMATED,
1159                                           parse_border_width,
1160                                           NULL,
1161                                           compute_border_width,
1162                                           query_length_as_int,
1163                                           assign_length_from_int,
1164                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1165   gtk_css_style_property_register        ("border-left-style",
1166                                           GTK_CSS_PROPERTY_BORDER_LEFT_STYLE,
1167                                           GTK_TYPE_BORDER_STYLE,
1168                                           0,
1169                                           parse_border_style,
1170                                           NULL,
1171                                           NULL,
1172                                           query_border_style,
1173                                           assign_border_style,
1174                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1175   gtk_css_style_property_register        ("border-left-width",
1176                                           GTK_CSS_PROPERTY_BORDER_LEFT_WIDTH,
1177                                           G_TYPE_INT,
1178                                           GTK_STYLE_PROPERTY_ANIMATED,
1179                                           parse_border_width,
1180                                           NULL,
1181                                           compute_border_width,
1182                                           query_length_as_int,
1183                                           assign_length_from_int,
1184                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1185   gtk_css_style_property_register        ("border-bottom-style",
1186                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_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                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1195   gtk_css_style_property_register        ("border-bottom-width",
1196                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_WIDTH,
1197                                           G_TYPE_INT,
1198                                           GTK_STYLE_PROPERTY_ANIMATED,
1199                                           parse_border_width,
1200                                           NULL,
1201                                           compute_border_width,
1202                                           query_length_as_int,
1203                                           assign_length_from_int,
1204                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1205   gtk_css_style_property_register        ("border-right-style",
1206                                           GTK_CSS_PROPERTY_BORDER_RIGHT_STYLE,
1207                                           GTK_TYPE_BORDER_STYLE,
1208                                           0,
1209                                           parse_border_style,
1210                                           NULL,
1211                                           NULL,
1212                                           query_border_style,
1213                                           assign_border_style,
1214                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1215   gtk_css_style_property_register        ("border-right-width",
1216                                           GTK_CSS_PROPERTY_BORDER_RIGHT_WIDTH,
1217                                           G_TYPE_INT,
1218                                           GTK_STYLE_PROPERTY_ANIMATED,
1219                                           parse_border_width,
1220                                           NULL,
1221                                           compute_border_width,
1222                                           query_length_as_int,
1223                                           assign_length_from_int,
1224                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1225
1226   gtk_css_style_property_register        ("border-top-left-radius",
1227                                           GTK_CSS_PROPERTY_BORDER_TOP_LEFT_RADIUS,
1228                                           G_TYPE_NONE,
1229                                           GTK_STYLE_PROPERTY_ANIMATED,
1230                                           border_corner_radius_value_parse,
1231                                           NULL,
1232                                           border_corner_radius_value_compute,
1233                                           NULL,
1234                                           NULL,
1235                                           _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
1236                                                                      _gtk_css_number_value_new (0, GTK_CSS_PX)));
1237   gtk_css_style_property_register        ("border-top-right-radius",
1238                                           GTK_CSS_PROPERTY_BORDER_TOP_RIGHT_RADIUS,
1239                                           G_TYPE_NONE,
1240                                           GTK_STYLE_PROPERTY_ANIMATED,
1241                                           border_corner_radius_value_parse,
1242                                           NULL,
1243                                           border_corner_radius_value_compute,
1244                                           NULL,
1245                                           NULL,
1246                                           _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
1247                                                                      _gtk_css_number_value_new (0, GTK_CSS_PX)));
1248   gtk_css_style_property_register        ("border-bottom-right-radius",
1249                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_RIGHT_RADIUS,
1250                                           G_TYPE_NONE,
1251                                           GTK_STYLE_PROPERTY_ANIMATED,
1252                                           border_corner_radius_value_parse,
1253                                           NULL,
1254                                           border_corner_radius_value_compute,
1255                                           NULL,
1256                                           NULL,
1257                                           _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
1258                                                                      _gtk_css_number_value_new (0, GTK_CSS_PX)));
1259   gtk_css_style_property_register        ("border-bottom-left-radius",
1260                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_LEFT_RADIUS,
1261                                           G_TYPE_NONE,
1262                                           GTK_STYLE_PROPERTY_ANIMATED,
1263                                           border_corner_radius_value_parse,
1264                                           NULL,
1265                                           border_corner_radius_value_compute,
1266                                           NULL,
1267                                           NULL,
1268                                           _gtk_css_corner_value_new (_gtk_css_number_value_new (0, GTK_CSS_PX),
1269                                                                      _gtk_css_number_value_new (0, GTK_CSS_PX)));
1270
1271   gtk_css_style_property_register        ("outline-style",
1272                                           GTK_CSS_PROPERTY_OUTLINE_STYLE,
1273                                           GTK_TYPE_BORDER_STYLE,
1274                                           0,
1275                                           parse_border_style,
1276                                           NULL,
1277                                           NULL,
1278                                           query_border_style,
1279                                           assign_border_style,
1280                                           _gtk_css_border_style_value_new (GTK_BORDER_STYLE_NONE));
1281   gtk_css_style_property_register        ("outline-width",
1282                                           GTK_CSS_PROPERTY_OUTLINE_WIDTH,
1283                                           G_TYPE_INT,
1284                                           GTK_STYLE_PROPERTY_ANIMATED,
1285                                           parse_border_width,
1286                                           NULL,
1287                                           compute_border_width,
1288                                           query_length_as_int,
1289                                           assign_length_from_int,
1290                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1291   gtk_css_style_property_register        ("outline-offset",
1292                                           GTK_CSS_PROPERTY_OUTLINE_OFFSET,
1293                                           G_TYPE_INT,
1294                                           0,
1295                                           outline_parse,
1296                                           NULL,
1297                                           outline_compute,
1298                                           query_length_as_int,
1299                                           assign_length_from_int,
1300                                           _gtk_css_number_value_new (0.0, GTK_CSS_PX));
1301
1302   gtk_css_style_property_register        ("background-clip",
1303                                           GTK_CSS_PROPERTY_BACKGROUND_CLIP,
1304                                           G_TYPE_NONE,
1305                                           0,
1306                                           parse_css_area,
1307                                           NULL,
1308                                           NULL,
1309                                           NULL,
1310                                           NULL,
1311                                           _gtk_css_array_value_new (_gtk_css_area_value_new (GTK_CSS_AREA_BORDER_BOX)));
1312   gtk_css_style_property_register        ("background-origin",
1313                                           GTK_CSS_PROPERTY_BACKGROUND_ORIGIN,
1314                                           G_TYPE_NONE,
1315                                           0,
1316                                           parse_css_area,
1317                                           NULL,
1318                                           NULL,
1319                                           NULL,
1320                                           NULL,
1321                                           _gtk_css_array_value_new (_gtk_css_area_value_new (GTK_CSS_AREA_PADDING_BOX)));
1322   gtk_css_style_property_register        ("background-size",
1323                                           GTK_CSS_PROPERTY_BACKGROUND_SIZE,
1324                                           G_TYPE_NONE,
1325                                           0,
1326                                           background_size_parse,
1327                                           NULL,
1328                                           background_size_compute,
1329                                           NULL,
1330                                           NULL,
1331                                           _gtk_css_array_value_new (_gtk_css_bg_size_value_new (NULL, NULL)));
1332   gtk_css_style_property_register        ("background-position",
1333                                           GTK_CSS_PROPERTY_BACKGROUND_POSITION,
1334                                           G_TYPE_NONE,
1335                                           GTK_STYLE_PROPERTY_ANIMATED,
1336                                           background_position_parse,
1337                                           NULL,
1338                                           background_position_compute,
1339                                           NULL,
1340                                           NULL,
1341                                           _gtk_css_array_value_new (_gtk_css_position_value_new (_gtk_css_number_value_new (0, GTK_CSS_PERCENT),
1342                                                                                                  _gtk_css_number_value_new (0, GTK_CSS_PERCENT))));
1343
1344   gtk_css_style_property_register        ("border-top-color",
1345                                           GTK_CSS_PROPERTY_BORDER_TOP_COLOR,
1346                                           GDK_TYPE_RGBA,
1347                                           GTK_STYLE_PROPERTY_ANIMATED,
1348                                           color_parse,
1349                                           NULL,
1350                                           color_compute,
1351                                           color_query,
1352                                           color_assign,
1353                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1354                                             gtk_symbolic_color_ref (
1355                                               _gtk_symbolic_color_get_current_color ())));
1356   gtk_css_style_property_register        ("border-right-color",
1357                                           GTK_CSS_PROPERTY_BORDER_RIGHT_COLOR,
1358                                           GDK_TYPE_RGBA,
1359                                           GTK_STYLE_PROPERTY_ANIMATED,
1360                                           color_parse,
1361                                           NULL,
1362                                           color_compute,
1363                                           color_query,
1364                                           color_assign,
1365                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1366                                             gtk_symbolic_color_ref (
1367                                               _gtk_symbolic_color_get_current_color ())));
1368   gtk_css_style_property_register        ("border-bottom-color",
1369                                           GTK_CSS_PROPERTY_BORDER_BOTTOM_COLOR,
1370                                           GDK_TYPE_RGBA,
1371                                           GTK_STYLE_PROPERTY_ANIMATED,
1372                                           color_parse,
1373                                           NULL,
1374                                           color_compute,
1375                                           color_query,
1376                                           color_assign,
1377                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1378                                             gtk_symbolic_color_ref (
1379                                               _gtk_symbolic_color_get_current_color ())));
1380   gtk_css_style_property_register        ("border-left-color",
1381                                           GTK_CSS_PROPERTY_BORDER_LEFT_COLOR,
1382                                           GDK_TYPE_RGBA,
1383                                           GTK_STYLE_PROPERTY_ANIMATED,
1384                                           color_parse,
1385                                           NULL,
1386                                           color_compute,
1387                                           color_query,
1388                                           color_assign,
1389                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1390                                             gtk_symbolic_color_ref (
1391                                               _gtk_symbolic_color_get_current_color ())));
1392   gtk_css_style_property_register        ("outline-color",
1393                                           GTK_CSS_PROPERTY_OUTLINE_COLOR,
1394                                           GDK_TYPE_RGBA,
1395                                           GTK_STYLE_PROPERTY_ANIMATED,
1396                                           color_parse,
1397                                           NULL,
1398                                           color_compute,
1399                                           color_query,
1400                                           color_assign,
1401                                           _gtk_css_symbolic_value_new_take_symbolic_color (
1402                                             gtk_symbolic_color_ref (
1403                                               _gtk_symbolic_color_get_current_color ())));
1404
1405   gtk_css_style_property_register        ("background-repeat",
1406                                           GTK_CSS_PROPERTY_BACKGROUND_REPEAT,
1407                                           G_TYPE_NONE,
1408                                           0,
1409                                           background_repeat_value_parse,
1410                                           NULL,
1411                                           NULL,
1412                                           NULL,
1413                                           NULL,
1414                                           _gtk_css_array_value_new (_gtk_css_background_repeat_value_new (GTK_CSS_REPEAT_STYLE_REPEAT,
1415                                                                                                           GTK_CSS_REPEAT_STYLE_REPEAT)));
1416   gtk_css_style_property_register        ("background-image",
1417                                           GTK_CSS_PROPERTY_BACKGROUND_IMAGE,
1418                                           CAIRO_GOBJECT_TYPE_PATTERN,
1419                                           GTK_STYLE_PROPERTY_ANIMATED,
1420                                           background_image_value_parse,
1421                                           NULL,
1422                                           background_image_value_compute,
1423                                           background_image_value_query,
1424                                           background_image_value_assign,
1425                                           _gtk_css_array_value_new (_gtk_css_image_value_new (NULL)));
1426
1427   gtk_css_style_property_register        ("border-image-source",
1428                                           GTK_CSS_PROPERTY_BORDER_IMAGE_SOURCE,
1429                                           CAIRO_GOBJECT_TYPE_PATTERN,
1430                                           GTK_STYLE_PROPERTY_ANIMATED,
1431                                           css_image_value_parse,
1432                                           NULL,
1433                                           css_image_value_compute,
1434                                           css_image_value_query,
1435                                           css_image_value_assign,
1436                                           _gtk_css_image_value_new (NULL));
1437   gtk_css_style_property_register        ("border-image-repeat",
1438                                           GTK_CSS_PROPERTY_BORDER_IMAGE_REPEAT,
1439                                           G_TYPE_NONE,
1440                                           0,
1441                                           border_image_repeat_parse,
1442                                           NULL,
1443                                           NULL,
1444                                           NULL,
1445                                           NULL,
1446                                           _gtk_css_border_repeat_value_new (GTK_CSS_REPEAT_STYLE_STRETCH,
1447                                                                             GTK_CSS_REPEAT_STYLE_STRETCH));
1448
1449   gtk_css_style_property_register        ("border-image-slice",
1450                                           GTK_CSS_PROPERTY_BORDER_IMAGE_SLICE,
1451                                           GTK_TYPE_BORDER,
1452                                           0,
1453                                           border_image_slice_parse,
1454                                           NULL,
1455                                           compute_border,
1456                                           query_border,
1457                                           assign_border,
1458                                           _gtk_css_border_value_new (_gtk_css_number_value_new (100, GTK_CSS_PERCENT),
1459                                                                      _gtk_css_number_value_new (100, GTK_CSS_PERCENT),
1460                                                                      _gtk_css_number_value_new (100, GTK_CSS_PERCENT),
1461                                                                      _gtk_css_number_value_new (100, GTK_CSS_PERCENT)));
1462   gtk_css_style_property_register        ("border-image-width",
1463                                           GTK_CSS_PROPERTY_BORDER_IMAGE_WIDTH,
1464                                           GTK_TYPE_BORDER,
1465                                           0,
1466                                           border_image_width_parse,
1467                                           NULL,
1468                                           compute_border,
1469                                           query_border,
1470                                           assign_border,
1471                                           _gtk_css_border_value_new (_gtk_css_number_value_new (1, GTK_CSS_NUMBER),
1472                                                                      _gtk_css_number_value_new (1, GTK_CSS_NUMBER),
1473                                                                      _gtk_css_number_value_new (1, GTK_CSS_NUMBER),
1474                                                                      _gtk_css_number_value_new (1, GTK_CSS_NUMBER)));
1475
1476   gtk_css_style_property_register        ("transition-property",
1477                                           GTK_CSS_PROPERTY_TRANSITION_PROPERTY,
1478                                           G_TYPE_NONE,
1479                                           0,
1480                                           transition_property_parse,
1481                                           NULL,
1482                                           NULL,
1483                                           NULL,
1484                                           NULL,
1485                                           _gtk_css_array_value_new (_gtk_css_ident_value_new ("all")));
1486   gtk_css_style_property_register        ("transition-duration",
1487                                           GTK_CSS_PROPERTY_TRANSITION_DURATION,
1488                                           G_TYPE_NONE,
1489                                           0,
1490                                           transition_time_parse,
1491                                           NULL,
1492                                           NULL,
1493                                           NULL,
1494                                           NULL,
1495                                           _gtk_css_array_value_new (_gtk_css_number_value_new (0, GTK_CSS_S)));
1496   gtk_css_style_property_register        ("transition-timing-function",
1497                                           GTK_CSS_PROPERTY_TRANSITION_TIMING_FUNCTION,
1498                                           G_TYPE_NONE,
1499                                           0,
1500                                           transition_timing_function_parse,
1501                                           NULL,
1502                                           NULL,
1503                                           NULL,
1504                                           NULL,
1505                                           _gtk_css_array_value_new (
1506                                             _gtk_css_ease_value_new_cubic_bezier (0.25, 0.1, 0.25, 1.0)));
1507   gtk_css_style_property_register        ("transition-delay",
1508                                           GTK_CSS_PROPERTY_TRANSITION_DELAY,
1509                                           G_TYPE_NONE,
1510                                           0,
1511                                           transition_time_parse,
1512                                           NULL,
1513                                           NULL,
1514                                           NULL,
1515                                           NULL,
1516                                           _gtk_css_array_value_new (_gtk_css_number_value_new (0, GTK_CSS_S)));
1517
1518   gtk_css_style_property_register        ("engine",
1519                                           GTK_CSS_PROPERTY_ENGINE,
1520                                           GTK_TYPE_THEMING_ENGINE,
1521                                           0,
1522                                           engine_parse,
1523                                           NULL,
1524                                           NULL,
1525                                           engine_query,
1526                                           engine_assign,
1527                                           _gtk_css_engine_value_new (gtk_theming_engine_load (NULL)));
1528
1529   /* Private property holding the binding sets */
1530   gtk_css_style_property_register        ("gtk-key-bindings",
1531                                           GTK_CSS_PROPERTY_GTK_KEY_BINDINGS,
1532                                           G_TYPE_PTR_ARRAY,
1533                                           0,
1534                                           bindings_value_parse,
1535                                           NULL,
1536                                           NULL,
1537                                           bindings_value_query,
1538                                           bindings_value_assign,
1539                                           _gtk_css_array_value_new (NULL));
1540 }
1541