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

   1 /* GTK - The GIMP Toolkit
   2  * Copyright (C) 2011 Red Hat, Inc.
   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 "gtkcssenumvalueprivate.h"
  21
  22 #include "gtkcsscomputedvaluesprivate.h"
  23 #include "gtkcssnumbervalueprivate.h"
  24 #include "gtkstyleproviderprivate.h"
  25
  26 /* repeated API */
  27
  28 struct _GtkCssValue {
  29   GTK_CSS_VALUE_BASE
  30   int value;
  31   const char *name;
  32 };
  33
  34 static void
  35 gtk_css_value_enum_free (GtkCssValue *value)
  36 {
  37   g_slice_free (GtkCssValue, value);
  38 }
  39
  40 static GtkCssValue *
  41 gtk_css_value_enum_compute (GtkCssValue             *value,
  42                             guint                    property_id,
  43                             GtkStyleProviderPrivate *provider,
  44                             GtkCssComputedValues    *values,
  45                             GtkCssComputedValues    *parent_values,
  46                             GtkCssDependencies      *dependencies)
  47 {
  48   return _gtk_css_value_ref (value);
  49 }
  50
  51 static gboolean
  52 gtk_css_value_enum_equal (const GtkCssValue *enum1,
  53                           const GtkCssValue *enum2)
  54 {
  55   return enum1 == enum2;
  56 }
  57
  58 static GtkCssValue *
  59 gtk_css_value_enum_transition (GtkCssValue *start,
  60                                GtkCssValue *end,
  61                                guint        property_id,
  62                                double       progress)
  63 {
  64   return NULL;
  65 }
  66
  67 static void
  68 gtk_css_value_enum_print (const GtkCssValue *value,
  69                           GString           *string)
  70 {
  71   g_string_append (string, value->name);
  72 }
  73
  74 /* GtkBorderStyle */
  75
  76 static const GtkCssValueClass GTK_CSS_VALUE_BORDER_STYLE = {
  77   gtk_css_value_enum_free,
  78   gtk_css_value_enum_compute,
  79   gtk_css_value_enum_equal,
  80   gtk_css_value_enum_transition,
  81   gtk_css_value_enum_print
  82 };
  83
  84 static GtkCssValue border_style_values[] = {
  85   { &GTK_CSS_VALUE_BORDER_STYLE, 1, GTK_BORDER_STYLE_NONE, "none" },
  86   { &GTK_CSS_VALUE_BORDER_STYLE, 1, GTK_BORDER_STYLE_SOLID, "solid" },
  87   { &GTK_CSS_VALUE_BORDER_STYLE, 1, GTK_BORDER_STYLE_INSET, "inset" },
  88   { &GTK_CSS_VALUE_BORDER_STYLE, 1, GTK_BORDER_STYLE_OUTSET, "outset" },
  89   { &GTK_CSS_VALUE_BORDER_STYLE, 1, GTK_BORDER_STYLE_HIDDEN, "hidden" },
  90   { &GTK_CSS_VALUE_BORDER_STYLE, 1, GTK_BORDER_STYLE_DOTTED, "dotted" },
  91   { &GTK_CSS_VALUE_BORDER_STYLE, 1, GTK_BORDER_STYLE_DASHED, "dashed" },
  92   { &GTK_CSS_VALUE_BORDER_STYLE, 1, GTK_BORDER_STYLE_DOUBLE, "double" },
  93   { &GTK_CSS_VALUE_BORDER_STYLE, 1, GTK_BORDER_STYLE_GROOVE, "groove" },
  94   { &GTK_CSS_VALUE_BORDER_STYLE, 1, GTK_BORDER_STYLE_RIDGE, "ridge" }
  95 };
  96
  97 GtkCssValue *
  98 _gtk_css_border_style_value_new (GtkBorderStyle border_style)
  99 {
 100   g_return_val_if_fail (border_style < G_N_ELEMENTS (border_style_values), NULL);
 101
 102   return _gtk_css_value_ref (&border_style_values[border_style]);
 103 }
 104
 105 GtkCssValue *
 106 _gtk_css_border_style_value_try_parse (GtkCssParser *parser)
 107 {
 108   guint i;
 109
 110   g_return_val_if_fail (parser != NULL, NULL);
 111
 112   for (i = 0; i < G_N_ELEMENTS (border_style_values); i++)
 113     {
 114       if (_gtk_css_parser_try (parser, border_style_values[i].name, TRUE))
 115         return _gtk_css_value_ref (&border_style_values[i]);
 116     }
 117
 118   return NULL;
 119 }
 120
 121 GtkBorderStyle
 122 _gtk_css_border_style_value_get (const GtkCssValue *value)
 123 {
 124   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_BORDER_STYLE, GTK_BORDER_STYLE_NONE);
 125
 126   return value->value;
 127 }
 128
 129 /* GtkCssFontSize */
 130
 131 /* XXX: Kinda bad to have that machinery here, nobody expects vital font
 132  * size code to appear in gtkcssvalueenum.c.
 133  */
 134 #define DEFAULT_FONT_SIZE 10
 135
 136 double
 137 _gtk_css_font_size_get_default (GtkStyleProviderPrivate *provider)
 138 {
 139   GtkSettings *settings;
 140   PangoFontDescription *description;
 141   char *font_name;
 142   double font_size;
 143
 144   settings = _gtk_style_provider_private_get_settings (provider);
 145   if (settings == NULL)
 146     return DEFAULT_FONT_SIZE;
 147
 148   g_object_get (settings, "gtk-font-name", &font_name, NULL);
 149   description = pango_font_description_from_string (font_name);
 150   g_free (font_name);
 151   if (description == NULL)
 152     return DEFAULT_FONT_SIZE;
 153
 154   if (pango_font_description_get_set_fields (description) & PANGO_FONT_MASK_SIZE)
 155     font_size = (double) pango_font_description_get_size (description) / PANGO_SCALE;
 156   else
 157     font_size = DEFAULT_FONT_SIZE;
 158
 159   pango_font_description_free (description);
 160   return font_size;
 161 }
 162
 163 static GtkCssValue *
 164 gtk_css_value_font_size_compute (GtkCssValue             *value,
 165                                  guint                    property_id,
 166                                  GtkStyleProviderPrivate *provider,
 167                                  GtkCssComputedValues    *values,
 168                                  GtkCssComputedValues    *parent_values,
 169                                  GtkCssDependencies      *dependencies)
 170 {
 171   double font_size;
 172
 173   switch (value->value)
 174     {
 175     case GTK_CSS_FONT_SIZE_XX_SMALL:
 176       font_size = _gtk_css_font_size_get_default (provider) * 3. / 5;
 177       break;
 178     case GTK_CSS_FONT_SIZE_X_SMALL:
 179       font_size = _gtk_css_font_size_get_default (provider) * 3. / 4;
 180       break;
 181     case GTK_CSS_FONT_SIZE_SMALL:
 182       font_size = _gtk_css_font_size_get_default (provider) * 8. / 9;
 183       break;
 184     default:
 185       g_assert_not_reached ();
 186       /* fall thru */
 187     case GTK_CSS_FONT_SIZE_MEDIUM:
 188       font_size = _gtk_css_font_size_get_default (provider);
 189       break;
 190     case GTK_CSS_FONT_SIZE_LARGE:
 191       font_size = _gtk_css_font_size_get_default (provider) * 6. / 5;
 192       break;
 193     case GTK_CSS_FONT_SIZE_X_LARGE:
 194       font_size = _gtk_css_font_size_get_default (provider) * 3. / 2;
 195       break;
 196     case GTK_CSS_FONT_SIZE_XX_LARGE:
 197       font_size = _gtk_css_font_size_get_default (provider) * 2;
 198       break;
 199     case GTK_CSS_FONT_SIZE_SMALLER:
 200       *dependencies = GTK_CSS_DEPENDS_ON_PARENT;
 201       if (parent_values)
 202         font_size = _gtk_css_number_value_get (_gtk_css_computed_values_get_value (parent_values, GTK_CSS_PROPERTY_FONT_SIZE), 100);
 203       else
 204         font_size = _gtk_css_font_size_get_default (provider);
 205       /* XXX: This is what WebKit does... */
 206       font_size /= 1.2;
 207       break;
 208     case GTK_CSS_FONT_SIZE_LARGER:
 209       *dependencies = GTK_CSS_DEPENDS_ON_PARENT;
 210       if (parent_values)
 211         font_size = _gtk_css_number_value_get (_gtk_css_computed_values_get_value (parent_values, GTK_CSS_PROPERTY_FONT_SIZE), 100);
 212       else
 213         font_size = _gtk_css_font_size_get_default (provider);
 214       /* XXX: This is what WebKit does... */
 215       font_size *= 1.2;
 216       break;
 217   }
 218
 219   return _gtk_css_number_value_new (font_size, GTK_CSS_PX);
 220 }
 221
 222 static const GtkCssValueClass GTK_CSS_VALUE_FONT_SIZE = {
 223   gtk_css_value_enum_free,
 224   gtk_css_value_font_size_compute,
 225   gtk_css_value_enum_equal,
 226   gtk_css_value_enum_transition,
 227   gtk_css_value_enum_print
 228 };
 229
 230 static GtkCssValue font_size_values[] = {
 231   { &GTK_CSS_VALUE_FONT_SIZE, 1, GTK_CSS_FONT_SIZE_SMALLER, "smaller" },
 232   { &GTK_CSS_VALUE_FONT_SIZE, 1, GTK_CSS_FONT_SIZE_LARGER, "larger" },
 233   { &GTK_CSS_VALUE_FONT_SIZE, 1, GTK_CSS_FONT_SIZE_XX_SMALL, "xx-small" },
 234   { &GTK_CSS_VALUE_FONT_SIZE, 1, GTK_CSS_FONT_SIZE_X_SMALL, "x-small" },
 235   { &GTK_CSS_VALUE_FONT_SIZE, 1, GTK_CSS_FONT_SIZE_SMALL, "small" },
 236   { &GTK_CSS_VALUE_FONT_SIZE, 1, GTK_CSS_FONT_SIZE_MEDIUM, "medium" },
 237   { &GTK_CSS_VALUE_FONT_SIZE, 1, GTK_CSS_FONT_SIZE_LARGE, "large" },
 238   { &GTK_CSS_VALUE_FONT_SIZE, 1, GTK_CSS_FONT_SIZE_X_LARGE, "x-large" },
 239   { &GTK_CSS_VALUE_FONT_SIZE, 1, GTK_CSS_FONT_SIZE_XX_LARGE, "xx-large" }
 240 };
 241
 242 GtkCssValue *
 243 _gtk_css_font_size_value_new (GtkCssFontSize font_size)
 244 {
 245   g_return_val_if_fail (font_size < G_N_ELEMENTS (font_size_values), NULL);
 246
 247   return _gtk_css_value_ref (&font_size_values[font_size]);
 248 }
 249
 250 GtkCssValue *
 251 _gtk_css_font_size_value_try_parse (GtkCssParser *parser)
 252 {
 253   guint i;
 254
 255   g_return_val_if_fail (parser != NULL, NULL);
 256
 257   for (i = 0; i < G_N_ELEMENTS (font_size_values); i++)
 258     {
 259       if (_gtk_css_parser_try (parser, font_size_values[i].name, TRUE))
 260         return _gtk_css_value_ref (&font_size_values[i]);
 261     }
 262
 263   return NULL;
 264 }
 265
 266 GtkCssFontSize
 267 _gtk_css_font_size_value_get (const GtkCssValue *value)
 268 {
 269   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_FONT_SIZE, GTK_CSS_FONT_SIZE_MEDIUM);
 270
 271   return value->value;
 272 }
 273
 274 /* PangoStyle */
 275
 276 static const GtkCssValueClass GTK_CSS_VALUE_FONT_STYLE = {
 277   gtk_css_value_enum_free,
 278   gtk_css_value_enum_compute,
 279   gtk_css_value_enum_equal,
 280   gtk_css_value_enum_transition,
 281   gtk_css_value_enum_print
 282 };
 283
 284 static GtkCssValue font_style_values[] = {
 285   { &GTK_CSS_VALUE_FONT_STYLE, 1, PANGO_STYLE_NORMAL, "normal" },
 286   { &GTK_CSS_VALUE_FONT_STYLE, 1, PANGO_STYLE_OBLIQUE, "oblique" },
 287   { &GTK_CSS_VALUE_FONT_STYLE, 1, PANGO_STYLE_ITALIC, "italic" }
 288 };
 289
 290 GtkCssValue *
 291 _gtk_css_font_style_value_new (PangoStyle font_style)
 292 {
 293   g_return_val_if_fail (font_style < G_N_ELEMENTS (font_style_values), NULL);
 294
 295   return _gtk_css_value_ref (&font_style_values[font_style]);
 296 }
 297
 298 GtkCssValue *
 299 _gtk_css_font_style_value_try_parse (GtkCssParser *parser)
 300 {
 301   guint i;
 302
 303   g_return_val_if_fail (parser != NULL, NULL);
 304
 305   for (i = 0; i < G_N_ELEMENTS (font_style_values); i++)
 306     {
 307       if (_gtk_css_parser_try (parser, font_style_values[i].name, TRUE))
 308         return _gtk_css_value_ref (&font_style_values[i]);
 309     }
 310
 311   return NULL;
 312 }
 313
 314 PangoStyle
 315 _gtk_css_font_style_value_get (const GtkCssValue *value)
 316 {
 317   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_FONT_STYLE, PANGO_STYLE_NORMAL);
 318
 319   return value->value;
 320 }
 321
 322 /* PangoVariant */
 323
 324 static const GtkCssValueClass GTK_CSS_VALUE_FONT_VARIANT = {
 325   gtk_css_value_enum_free,
 326   gtk_css_value_enum_compute,
 327   gtk_css_value_enum_equal,
 328   gtk_css_value_enum_transition,
 329   gtk_css_value_enum_print
 330 };
 331
 332 static GtkCssValue font_variant_values[] = {
 333   { &GTK_CSS_VALUE_FONT_VARIANT, 1, PANGO_VARIANT_NORMAL, "normal" },
 334   { &GTK_CSS_VALUE_FONT_VARIANT, 1, PANGO_VARIANT_SMALL_CAPS, "small-caps" }
 335 };
 336
 337 GtkCssValue *
 338 _gtk_css_font_variant_value_new (PangoVariant font_variant)
 339 {
 340   g_return_val_if_fail (font_variant < G_N_ELEMENTS (font_variant_values), NULL);
 341
 342   return _gtk_css_value_ref (&font_variant_values[font_variant]);
 343 }
 344
 345 GtkCssValue *
 346 _gtk_css_font_variant_value_try_parse (GtkCssParser *parser)
 347 {
 348   guint i;
 349
 350   g_return_val_if_fail (parser != NULL, NULL);
 351
 352   for (i = 0; i < G_N_ELEMENTS (font_variant_values); i++)
 353     {
 354       if (_gtk_css_parser_try (parser, font_variant_values[i].name, TRUE))
 355         return _gtk_css_value_ref (&font_variant_values[i]);
 356     }
 357
 358   return NULL;
 359 }
 360
 361 PangoVariant
 362 _gtk_css_font_variant_value_get (const GtkCssValue *value)
 363 {
 364   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_FONT_VARIANT, PANGO_VARIANT_NORMAL);
 365
 366   return value->value;
 367 }
 368
 369 /* PangoWeight */
 370
 371 static const GtkCssValueClass GTK_CSS_VALUE_FONT_WEIGHT = {
 372   gtk_css_value_enum_free,
 373   gtk_css_value_enum_compute,
 374   gtk_css_value_enum_equal,
 375   gtk_css_value_enum_transition,
 376   gtk_css_value_enum_print
 377 };
 378
 379 static GtkCssValue font_weight_values[] = {
 380   { &GTK_CSS_VALUE_FONT_WEIGHT, 1, PANGO_WEIGHT_THIN, "100" },
 381   { &GTK_CSS_VALUE_FONT_WEIGHT, 1, PANGO_WEIGHT_ULTRALIGHT, "200" },
 382   { &GTK_CSS_VALUE_FONT_WEIGHT, 1, PANGO_WEIGHT_LIGHT, "300" },
 383   { &GTK_CSS_VALUE_FONT_WEIGHT, 1, PANGO_WEIGHT_NORMAL, "normal" },
 384   { &GTK_CSS_VALUE_FONT_WEIGHT, 1, PANGO_WEIGHT_MEDIUM, "500" },
 385   { &GTK_CSS_VALUE_FONT_WEIGHT, 1, PANGO_WEIGHT_SEMIBOLD, "600" },
 386   { &GTK_CSS_VALUE_FONT_WEIGHT, 1, PANGO_WEIGHT_BOLD, "bold" },
 387   { &GTK_CSS_VALUE_FONT_WEIGHT, 1, PANGO_WEIGHT_ULTRABOLD, "800" },
 388   { &GTK_CSS_VALUE_FONT_WEIGHT, 1, PANGO_WEIGHT_HEAVY, "900" }
 389 };
 390
 391 GtkCssValue *
 392 _gtk_css_font_weight_value_new (PangoWeight font_weight)
 393 {
 394   guint i;
 395   gint w;
 396
 397   w = ((font_weight + 50) / 100) * 100;
 398
 399   for (i = 0; i < G_N_ELEMENTS (font_weight_values); i++)
 400     {
 401       if (font_weight_values[i].value == w)
 402         return _gtk_css_value_ref (&font_weight_values[i]);
 403     }
 404
 405   g_return_val_if_reached (NULL);
 406 }
 407
 408 GtkCssValue *
 409 _gtk_css_font_weight_value_try_parse (GtkCssParser *parser)
 410 {
 411   guint i;
 412
 413   g_return_val_if_fail (parser != NULL, NULL);
 414
 415   for (i = 0; i < G_N_ELEMENTS (font_weight_values); i++)
 416     {
 417       if (_gtk_css_parser_try (parser, font_weight_values[i].name, TRUE))
 418         return _gtk_css_value_ref (&font_weight_values[i]);
 419     }
 420   /* special cases go here */
 421   if (_gtk_css_parser_try (parser, "400", TRUE))
 422     return _gtk_css_value_ref (&font_weight_values[3]);
 423   if (_gtk_css_parser_try (parser, "700", TRUE))
 424     return _gtk_css_value_ref (&font_weight_values[6]);
 425
 426   return NULL;
 427 }
 428
 429 PangoWeight
 430 _gtk_css_font_weight_value_get (const GtkCssValue *value)
 431 {
 432   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_FONT_WEIGHT, PANGO_WEIGHT_NORMAL);
 433
 434   return value->value;
 435 }
 436
 437 /* GtkCssArea */
 438
 439 static const GtkCssValueClass GTK_CSS_VALUE_AREA = {
 440   gtk_css_value_enum_free,
 441   gtk_css_value_enum_compute,
 442   gtk_css_value_enum_equal,
 443   gtk_css_value_enum_transition,
 444   gtk_css_value_enum_print
 445 };
 446
 447 static GtkCssValue area_values[] = {
 448   { &GTK_CSS_VALUE_AREA, 1, GTK_CSS_AREA_BORDER_BOX, "border-box" },
 449   { &GTK_CSS_VALUE_AREA, 1, GTK_CSS_AREA_PADDING_BOX, "padding-box" },
 450   { &GTK_CSS_VALUE_AREA, 1, GTK_CSS_AREA_CONTENT_BOX, "content-box" }
 451 };
 452
 453 GtkCssValue *
 454 _gtk_css_area_value_new (GtkCssArea area)
 455 {
 456   guint i;
 457
 458   for (i = 0; i < G_N_ELEMENTS (area_values); i++)
 459     {
 460       if (area_values[i].value == area)
 461         return _gtk_css_value_ref (&area_values[i]);
 462     }
 463
 464   g_return_val_if_reached (NULL);
 465 }
 466
 467 GtkCssValue *
 468 _gtk_css_area_value_try_parse (GtkCssParser *parser)
 469 {
 470   guint i;
 471
 472   g_return_val_if_fail (parser != NULL, NULL);
 473
 474   for (i = 0; i < G_N_ELEMENTS (area_values); i++)
 475     {
 476       if (_gtk_css_parser_try (parser, area_values[i].name, TRUE))
 477         return _gtk_css_value_ref (&area_values[i]);
 478     }
 479
 480   return NULL;
 481 }
 482
 483 GtkCssArea
 484 _gtk_css_area_value_get (const GtkCssValue *value)
 485 {
 486   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_AREA, GTK_CSS_AREA_BORDER_BOX);
 487
 488   return value->value;
 489 }
 490
 491 /* GtkCssDirection */
 492
 493 static const GtkCssValueClass GTK_CSS_VALUE_DIRECTION = {
 494   gtk_css_value_enum_free,
 495   gtk_css_value_enum_compute,
 496   gtk_css_value_enum_equal,
 497   gtk_css_value_enum_transition,
 498   gtk_css_value_enum_print
 499 };
 500
 501 static GtkCssValue direction_values[] = {
 502   { &GTK_CSS_VALUE_DIRECTION, 1, GTK_CSS_DIRECTION_NORMAL, "normal" },
 503   { &GTK_CSS_VALUE_DIRECTION, 1, GTK_CSS_DIRECTION_REVERSE, "reverse" },
 504   { &GTK_CSS_VALUE_DIRECTION, 1, GTK_CSS_DIRECTION_ALTERNATE, "alternate" },
 505   { &GTK_CSS_VALUE_DIRECTION, 1, GTK_CSS_DIRECTION_ALTERNATE_REVERSE, "alternate-reverse" }
 506 };
 507
 508 GtkCssValue *
 509 _gtk_css_direction_value_new (GtkCssDirection direction)
 510 {
 511   guint i;
 512
 513   for (i = 0; i < G_N_ELEMENTS (direction_values); i++)
 514     {
 515       if (direction_values[i].value == direction)
 516         return _gtk_css_value_ref (&direction_values[i]);
 517     }
 518
 519   g_return_val_if_reached (NULL);
 520 }
 521
 522 GtkCssValue *
 523 _gtk_css_direction_value_try_parse (GtkCssParser *parser)
 524 {
 525   guint i;
 526
 527   g_return_val_if_fail (parser != NULL, NULL);
 528
 529   for (i = 0; i < G_N_ELEMENTS (direction_values); i++)
 530     {
 531       if (_gtk_css_parser_try (parser, direction_values[i].name, TRUE))
 532         return _gtk_css_value_ref (&direction_values[i]);
 533     }
 534
 535   return NULL;
 536 }
 537
 538 GtkCssDirection
 539 _gtk_css_direction_value_get (const GtkCssValue *value)
 540 {
 541   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_DIRECTION, GTK_CSS_DIRECTION_NORMAL);
 542
 543   return value->value;
 544 }
 545
 546 /* GtkCssPlayState */
 547
 548 static const GtkCssValueClass GTK_CSS_VALUE_PLAY_STATE = {
 549   gtk_css_value_enum_free,
 550   gtk_css_value_enum_compute,
 551   gtk_css_value_enum_equal,
 552   gtk_css_value_enum_transition,
 553   gtk_css_value_enum_print
 554 };
 555
 556 static GtkCssValue play_state_values[] = {
 557   { &GTK_CSS_VALUE_PLAY_STATE, 1, GTK_CSS_PLAY_STATE_RUNNING, "running" },
 558   { &GTK_CSS_VALUE_PLAY_STATE, 1, GTK_CSS_PLAY_STATE_PAUSED, "paused" }
 559 };
 560
 561 GtkCssValue *
 562 _gtk_css_play_state_value_new (GtkCssPlayState play_state)
 563 {
 564   guint i;
 565
 566   for (i = 0; i < G_N_ELEMENTS (play_state_values); i++)
 567     {
 568       if (play_state_values[i].value == play_state)
 569         return _gtk_css_value_ref (&play_state_values[i]);
 570     }
 571
 572   g_return_val_if_reached (NULL);
 573 }
 574
 575 GtkCssValue *
 576 _gtk_css_play_state_value_try_parse (GtkCssParser *parser)
 577 {
 578   guint i;
 579
 580   g_return_val_if_fail (parser != NULL, NULL);
 581
 582   for (i = 0; i < G_N_ELEMENTS (play_state_values); i++)
 583     {
 584       if (_gtk_css_parser_try (parser, play_state_values[i].name, TRUE))
 585         return _gtk_css_value_ref (&play_state_values[i]);
 586     }
 587
 588   return NULL;
 589 }
 590
 591 GtkCssPlayState
 592 _gtk_css_play_state_value_get (const GtkCssValue *value)
 593 {
 594   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_PLAY_STATE, GTK_CSS_PLAY_STATE_RUNNING);
 595
 596   return value->value;
 597 }
 598
 599 /* GtkCssFillMode */
 600
 601 static const GtkCssValueClass GTK_CSS_VALUE_FILL_MODE = {
 602   gtk_css_value_enum_free,
 603   gtk_css_value_enum_compute,
 604   gtk_css_value_enum_equal,
 605   gtk_css_value_enum_transition,
 606   gtk_css_value_enum_print
 607 };
 608
 609 static GtkCssValue fill_mode_values[] = {
 610   { &GTK_CSS_VALUE_FILL_MODE, 1, GTK_CSS_FILL_NONE, "none" },
 611   { &GTK_CSS_VALUE_FILL_MODE, 1, GTK_CSS_FILL_FORWARDS, "forwards" },
 612   { &GTK_CSS_VALUE_FILL_MODE, 1, GTK_CSS_FILL_BACKWARDS, "backwards" },
 613   { &GTK_CSS_VALUE_FILL_MODE, 1, GTK_CSS_FILL_BOTH, "both" }
 614 };
 615
 616 GtkCssValue *
 617 _gtk_css_fill_mode_value_new (GtkCssFillMode fill_mode)
 618 {
 619   guint i;
 620
 621   for (i = 0; i < G_N_ELEMENTS (fill_mode_values); i++)
 622     {
 623       if (fill_mode_values[i].value == fill_mode)
 624         return _gtk_css_value_ref (&fill_mode_values[i]);
 625     }
 626
 627   g_return_val_if_reached (NULL);
 628 }
 629
 630 GtkCssValue *
 631 _gtk_css_fill_mode_value_try_parse (GtkCssParser *parser)
 632 {
 633   guint i;
 634
 635   g_return_val_if_fail (parser != NULL, NULL);
 636
 637   for (i = 0; i < G_N_ELEMENTS (fill_mode_values); i++)
 638     {
 639       if (_gtk_css_parser_try (parser, fill_mode_values[i].name, TRUE))
 640         return _gtk_css_value_ref (&fill_mode_values[i]);
 641     }
 642
 643   return NULL;
 644 }
 645
 646 GtkCssFillMode
 647 _gtk_css_fill_mode_value_get (const GtkCssValue *value)
 648 {
 649   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_FILL_MODE, GTK_CSS_FILL_NONE);
 650
 651   return value->value;
 652 }
 653