Pileus Git - ~andy/gtk/blob - gtk/gtkcssvalue.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 "gtkcssvalueprivate.h"
  21 #include "gtkcssstylefuncsprivate.h"
  22 #include "gtktypebuiltins.h"
  23 #include "gtkgradient.h"
  24 #include <cairo-gobject.h>
  25 #include "gtkprivatetypebuiltins.h"
  26
  27 #include "fallback-c89.c"
  28
  29 struct _GtkCssValue
  30 {
  31   GTK_CSS_VALUE_BASE
  32   GType type;
  33   union {
  34     gpointer ptr;
  35     gint gint;
  36     guint guint;
  37     double dbl;
  38     float flt;
  39   } u;
  40 };
  41
  42 static void
  43 gtk_css_value_default_free (GtkCssValue *value)
  44 {
  45   GType type = value->type;
  46
  47   if (g_type_is_a (type, G_TYPE_OBJECT))
  48     {
  49       if (value->u.ptr != NULL)
  50         g_object_unref (value->u.ptr);
  51     }
  52   else if (g_type_is_a (type, G_TYPE_BOXED))
  53     {
  54       if (value->u.ptr != NULL)
  55         g_boxed_free (type, value->u.ptr);
  56     }
  57   else if (g_type_is_a (type, G_TYPE_STRING))
  58     g_free (value->u.ptr);
  59   else if (g_type_is_a (type, G_TYPE_INT))
  60     {}
  61   else if (g_type_is_a (type, G_TYPE_UINT))
  62     {}
  63   else if (g_type_is_a (type, G_TYPE_BOOLEAN))
  64     {}
  65   else if (g_type_is_a (type, G_TYPE_ENUM))
  66     {}
  67   else if (g_type_is_a (type, G_TYPE_FLAGS))
  68     {}
  69   else if (g_type_is_a (type, G_TYPE_DOUBLE))
  70     {}
  71   else if (g_type_is_a (type, G_TYPE_FLOAT))
  72     {}
  73   else
  74     {
  75       g_value_unset (value->u.ptr);
  76       g_slice_free (GValue, value->u.ptr);
  77     }
  78
  79   g_slice_free (GtkCssValue, value);
  80 }
  81
  82 static void
  83 gtk_css_value_default_print (const GtkCssValue *value,
  84                              GString           *string)
  85 {
  86   GValue g_value = G_VALUE_INIT;
  87
  88   _gtk_css_value_init_gvalue (value, &g_value);
  89   _gtk_css_style_print_value (&g_value, string);
  90   g_value_unset (&g_value);
  91 }
  92
  93 static const GtkCssValueClass GTK_CSS_VALUE_DEFAULT = {
  94   gtk_css_value_default_free,
  95   gtk_css_value_default_print
  96 };
  97
  98 G_DEFINE_BOXED_TYPE (GtkCssValue, _gtk_css_value, _gtk_css_value_ref, _gtk_css_value_unref)
  99
 100 static GtkCssValue *
 101 gtk_css_value_new (GType type)
 102 {
 103   GtkCssValue *value;
 104
 105   value = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_DEFAULT);
 106
 107   value->type = type;
 108
 109   return value;
 110 }
 111
 112 GtkCssValue *
 113 _gtk_css_value_new_from_gvalue (const GValue *g_value)
 114 {
 115   GtkCssValue *value;
 116   GType type;
 117
 118   g_return_val_if_fail (g_value != NULL, NULL);
 119
 120   type = G_VALUE_TYPE (g_value);
 121
 122   /* Make sure we reuse the int/number singletons */
 123   if (type == G_TYPE_INT)
 124     value = _gtk_css_value_new_from_int (g_value_get_int (g_value));
 125   else if (type == GTK_TYPE_CSS_NUMBER)
 126     value = _gtk_css_value_new_from_number (g_value_get_boxed (g_value));
 127   else
 128     {
 129       value = gtk_css_value_new (type);
 130
 131       if (g_type_is_a (type, G_TYPE_OBJECT))
 132         value->u.ptr = g_value_dup_object (g_value);
 133       else if (g_type_is_a (type, G_TYPE_BOXED))
 134         value->u.ptr = g_value_dup_boxed (g_value);
 135       else if (g_type_is_a (type, G_TYPE_INT))
 136         value->u.gint = g_value_get_int (g_value);
 137       else if (g_type_is_a (type, G_TYPE_UINT))
 138         value->u.guint = g_value_get_uint (g_value);
 139       else if (g_type_is_a (type, G_TYPE_BOOLEAN))
 140         value->u.gint = g_value_get_boolean (g_value);
 141       else if (g_type_is_a (type, G_TYPE_ENUM))
 142         value->u.gint = g_value_get_enum (g_value);
 143       else if (g_type_is_a (type, G_TYPE_FLAGS))
 144         value->u.guint = g_value_get_flags (g_value);
 145       else if (g_type_is_a (type, G_TYPE_STRING))
 146         value->u.ptr = g_value_dup_string (g_value);
 147       else if (g_type_is_a (type, G_TYPE_DOUBLE))
 148         value->u.dbl = g_value_get_double (g_value);
 149       else if (g_type_is_a (type, G_TYPE_FLOAT))
 150         value->u.flt = g_value_get_float (g_value);
 151       else
 152         {
 153           value->u.ptr = g_slice_new0 (GValue);
 154           g_value_init (value->u.ptr, G_VALUE_TYPE (g_value));
 155           g_value_copy (g_value, value->u.ptr);
 156         }
 157     }
 158
 159   return value;
 160 }
 161
 162 GtkCssValue *
 163 _gtk_css_value_new_take_gvalue (GValue *g_value)
 164 {
 165   GtkCssValue *value;
 166   GType type;
 167
 168   g_return_val_if_fail (g_value != NULL, NULL);
 169
 170   type = G_VALUE_TYPE (g_value);
 171
 172   /* Make sure we reuse the int/number singletons */
 173   if (type == G_TYPE_INT)
 174     {
 175       value = _gtk_css_value_new_from_int (g_value_get_int (g_value));
 176       g_value_unset (g_value);
 177     }
 178   else if (type == GTK_TYPE_CSS_NUMBER)
 179     {
 180       value = _gtk_css_value_new_from_number (g_value_get_boxed (g_value));
 181       g_value_unset (g_value);
 182     }
 183   else
 184     {
 185       value = gtk_css_value_new (type);
 186
 187       if (g_type_is_a (type, G_TYPE_OBJECT))
 188         value->u.ptr = g_value_get_object (g_value);
 189       else if (g_type_is_a (type, G_TYPE_BOXED))
 190         value->u.ptr = g_value_get_boxed (g_value);
 191       else if (g_type_is_a (type, G_TYPE_INT))
 192         value->u.gint = g_value_get_int (g_value);
 193       else if (g_type_is_a (type, G_TYPE_UINT))
 194         value->u.guint = g_value_get_uint (g_value);
 195       else if (g_type_is_a (type, G_TYPE_BOOLEAN))
 196         value->u.gint = g_value_get_boolean (g_value);
 197       else if (g_type_is_a (type, G_TYPE_ENUM))
 198         value->u.gint = g_value_get_enum (g_value);
 199       else if (g_type_is_a (type, G_TYPE_FLAGS))
 200         value->u.guint = g_value_get_flags (g_value);
 201       else if (g_type_is_a (type, G_TYPE_STRING))
 202         value->u.ptr = g_value_dup_string (g_value);
 203       else if (g_type_is_a (type, G_TYPE_DOUBLE))
 204         value->u.dbl = g_value_get_double (g_value);
 205       else if (g_type_is_a (type, G_TYPE_FLOAT))
 206         value->u.flt = g_value_get_float (g_value);
 207       else
 208         {
 209           value->u.ptr = g_slice_new0 (GValue);
 210           g_value_init (value->u.ptr, G_VALUE_TYPE (g_value));
 211           g_value_copy (g_value, value->u.ptr);
 212           g_value_unset (g_value);
 213         }
 214     }
 215
 216   return value;
 217 }
 218
 219 GtkCssValue *
 220 _gtk_css_value_new_from_int (gint val)
 221 {
 222   GtkCssValue *value;
 223   static GtkCssValue *singletons[4] = {NULL};
 224
 225   if (val >= 0 && val < G_N_ELEMENTS (singletons))
 226     {
 227       if (singletons[val] == NULL)
 228         {
 229           value = gtk_css_value_new (G_TYPE_INT);
 230           value->u.gint = val;
 231           singletons[val] = value;
 232         }
 233       return _gtk_css_value_ref (singletons[val]);
 234     }
 235
 236   value = gtk_css_value_new (G_TYPE_INT);
 237   value->u.gint = val;
 238
 239   return value;
 240 }
 241
 242 GtkCssValue *
 243 _gtk_css_value_new_take_string (char *string)
 244 {
 245   GtkCssValue *value;
 246
 247   value = gtk_css_value_new (G_TYPE_STRING);
 248   value->u.ptr = string;
 249
 250   return value;
 251 }
 252
 253 static gpointer
 254 g_boxed_copy0 (GType         boxed_type,
 255                gconstpointer src_boxed)
 256 {
 257   if (src_boxed == NULL)
 258     return NULL;
 259   return g_boxed_copy (boxed_type, src_boxed);
 260 }
 261
 262 GtkCssValue *
 263 _gtk_css_value_new_from_border (const GtkBorder *border)
 264 {
 265   GtkCssValue *value;
 266
 267   value = gtk_css_value_new (GTK_TYPE_BORDER);
 268   value->u.ptr = g_boxed_copy0 (GTK_TYPE_BORDER, border);
 269
 270   return value;
 271 }
 272
 273 GtkCssValue *
 274 _gtk_css_value_new_take_pattern (cairo_pattern_t *v)
 275 {
 276   GtkCssValue *value;
 277
 278   value = gtk_css_value_new (CAIRO_GOBJECT_TYPE_PATTERN);
 279   value->u.ptr = v;
 280
 281   return value;
 282 }
 283
 284 GtkCssValue *
 285 _gtk_css_value_new_from_pattern (const cairo_pattern_t *v)
 286 {
 287   GtkCssValue *value;
 288
 289   value = gtk_css_value_new (CAIRO_GOBJECT_TYPE_PATTERN);
 290   value->u.ptr = g_boxed_copy0 (CAIRO_GOBJECT_TYPE_PATTERN, v);
 291
 292   return value;
 293 }
 294
 295 GtkCssValue *
 296 _gtk_css_value_new_take_shadow (GtkShadow *v)
 297 {
 298   GtkCssValue *value;
 299
 300   value = gtk_css_value_new (GTK_TYPE_SHADOW);
 301   value->u.ptr = v;
 302
 303   return value;
 304 }
 305
 306 GtkCssValue *
 307 _gtk_css_value_new_take_font_description (PangoFontDescription *v)
 308 {
 309   GtkCssValue *value;
 310
 311   value = gtk_css_value_new (PANGO_TYPE_FONT_DESCRIPTION);
 312   value->u.ptr = v;
 313
 314   return value;
 315 }
 316
 317 GtkCssValue *
 318 _gtk_css_value_new_take_image (GtkCssImage *v)
 319 {
 320   GtkCssValue *value;
 321
 322   value = gtk_css_value_new (GTK_TYPE_CSS_IMAGE);
 323   value->u.ptr = v;
 324
 325   return value;
 326 }
 327
 328 GtkCssValue *
 329 _gtk_css_value_new_from_number (const GtkCssNumber *v)
 330 {
 331   GtkCssValue *value;
 332   static GtkCssValue *zero_singleton = NULL;
 333   static GtkCssValue *px_singletons[5] = {NULL};
 334
 335   if (v->unit == GTK_CSS_NUMBER &&
 336       v->value == 0)
 337     {
 338       if (zero_singleton == NULL)
 339         {
 340           value = gtk_css_value_new (GTK_TYPE_CSS_NUMBER);
 341           value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_NUMBER, v);
 342           zero_singleton = value;
 343         }
 344       return _gtk_css_value_ref (zero_singleton);
 345     }
 346
 347   if (v->unit == GTK_CSS_PX &&
 348       (v->value == 0 ||
 349        v->value == 1 ||
 350        v->value == 2 ||
 351        v->value == 3 ||
 352        v->value == 4))
 353     {
 354       int i = round (v->value);
 355       if (px_singletons[i] == NULL)
 356         {
 357           value = gtk_css_value_new (GTK_TYPE_CSS_NUMBER);
 358           value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_NUMBER, v);
 359           px_singletons[i] = value;
 360         }
 361
 362       return _gtk_css_value_ref (px_singletons[i]);
 363     }
 364
 365   value = gtk_css_value_new (GTK_TYPE_CSS_NUMBER);
 366   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_NUMBER, v);
 367
 368   return value;
 369 }
 370
 371 GtkCssValue *
 372 _gtk_css_value_new_from_rgba (const GdkRGBA *v)
 373 {
 374   GtkCssValue *value;
 375
 376   value = gtk_css_value_new (GDK_TYPE_RGBA);
 377   value->u.ptr = g_boxed_copy0 (GDK_TYPE_RGBA, v);
 378
 379   return value;
 380 }
 381
 382 GtkCssValue *
 383 _gtk_css_value_new_from_color (const GdkColor *v)
 384 {
 385   GtkCssValue *value;
 386
 387   value = gtk_css_value_new (GDK_TYPE_COLOR);
 388   value->u.ptr = g_boxed_copy0 (GDK_TYPE_COLOR, v);
 389
 390   return value;
 391 }
 392
 393 GtkCssValue *
 394 _gtk_css_value_new_from_background_size (const GtkCssBackgroundSize *v)
 395 {
 396   GtkCssValue *value;
 397
 398   value = gtk_css_value_new (GTK_TYPE_CSS_BACKGROUND_SIZE);
 399   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BACKGROUND_SIZE, v);
 400
 401   return value;
 402 }
 403
 404 GtkCssValue *
 405 _gtk_css_value_new_from_background_position (const GtkCssBackgroundPosition *v)
 406 {
 407   GtkCssValue *value;
 408
 409   value = gtk_css_value_new (GTK_TYPE_CSS_BACKGROUND_POSITION);
 410   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BACKGROUND_POSITION, v);
 411
 412   return value;
 413 }
 414
 415 GtkCssValue *
 416 _gtk_css_value_new_take_symbolic_color (GtkSymbolicColor *v)
 417 {
 418   GtkCssValue *value;
 419
 420   value = gtk_css_value_new (GTK_TYPE_SYMBOLIC_COLOR);
 421   value->u.ptr = v;
 422
 423   return value;
 424 }
 425
 426 GtkCssValue *
 427 _gtk_css_value_alloc (const GtkCssValueClass *klass,
 428                       gsize                   size)
 429 {
 430   GtkCssValue *value;
 431
 432   value = g_slice_alloc0 (size);
 433
 434   value->class = klass;
 435   value->ref_count = 1;
 436
 437   return value;
 438 }
 439
 440 GtkCssValue *
 441 _gtk_css_value_ref (GtkCssValue *value)
 442 {
 443   g_return_val_if_fail (value != NULL, NULL);
 444
 445   g_atomic_int_add (&value->ref_count, 1);
 446
 447   return value;
 448 }
 449
 450 void
 451 _gtk_css_value_unref (GtkCssValue *value)
 452 {
 453   if (value == NULL)
 454     return;
 455
 456   if (!g_atomic_int_dec_and_test (&value->ref_count))
 457     return;
 458
 459   value->class->free (value);
 460 }
 461
 462 void
 463 _gtk_css_value_print (const GtkCssValue *value,
 464                       GString           *string)
 465 {
 466   g_return_if_fail (value != NULL);
 467   g_return_if_fail (string != NULL);
 468
 469   value->class->print (value, string);
 470 }
 471
 472 GType
 473 _gtk_css_value_get_content_type (const GtkCssValue *value)
 474 {
 475   return value->type;
 476 }
 477
 478 gboolean
 479 _gtk_css_value_holds (const GtkCssValue *value, GType type)
 480 {
 481   return g_type_is_a (value->type, type);
 482 }
 483
 484 static void
 485 fill_gvalue (const GtkCssValue *value,
 486              GValue            *g_value)
 487 {
 488   GType type;
 489
 490   type = value->type;
 491
 492   if (g_type_is_a (type, G_TYPE_OBJECT))
 493     g_value_set_object (g_value, value->u.ptr);
 494   else if (g_type_is_a (type, G_TYPE_BOXED))
 495     g_value_set_boxed (g_value, value->u.ptr);
 496   else if (g_type_is_a (type, G_TYPE_INT))
 497     g_value_set_int (g_value, value->u.gint);
 498   else if (g_type_is_a (type, G_TYPE_UINT))
 499     g_value_set_uint (g_value, value->u.guint);
 500   else if (g_type_is_a (type, G_TYPE_BOOLEAN))
 501     g_value_set_boolean (g_value, value->u.gint);
 502   else if (g_type_is_a (type, G_TYPE_ENUM))
 503     g_value_set_enum (g_value, value->u.gint);
 504   else if (g_type_is_a (type, G_TYPE_FLAGS))
 505     g_value_set_flags (g_value, value->u.guint);
 506   else if (g_type_is_a (type, G_TYPE_STRING))
 507     g_value_set_string (g_value, value->u.ptr);
 508   else if (g_type_is_a (type, G_TYPE_DOUBLE))
 509     g_value_set_double (g_value, value->u.dbl);
 510   else if (g_type_is_a (type, G_TYPE_FLOAT))
 511     g_value_set_float (g_value, value->u.flt);
 512   else
 513     g_value_copy (value->u.ptr, g_value);
 514 }
 515
 516 void
 517 _gtk_css_value_init_gvalue (const GtkCssValue *value,
 518                             GValue            *g_value)
 519 {
 520   if (value != NULL)
 521     {
 522       g_value_init (g_value, value->type);
 523       fill_gvalue (value, g_value);
 524     }
 525 }
 526
 527 gboolean
 528 _gtk_css_value_is_special (const GtkCssValue *value)
 529 {
 530   return _gtk_css_value_holds (value, GTK_TYPE_CSS_SPECIAL_VALUE);
 531 }
 532
 533 GtkCssSpecialValue
 534 _gtk_css_value_get_special_kind (const GtkCssValue *value)
 535 {
 536   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_SPECIAL_VALUE), 0);
 537   return value->u.gint;
 538 }
 539
 540 const GtkCssNumber *
 541 _gtk_css_value_get_number (const GtkCssValue *value)
 542 {
 543   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_NUMBER), NULL);
 544   return value->u.ptr;
 545 }
 546
 547 GtkSymbolicColor *
 548 _gtk_css_value_get_symbolic_color (const GtkCssValue *value)
 549 {
 550   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_SYMBOLIC_COLOR), NULL);
 551   return value->u.ptr;
 552 }
 553
 554 int
 555 _gtk_css_value_get_int (const GtkCssValue *value)
 556 {
 557   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_INT), 0);
 558   return value->u.gint;
 559 }
 560
 561 int
 562 _gtk_css_value_get_enum (const GtkCssValue *value)
 563 {
 564   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_ENUM), 0);
 565   return value->u.gint;
 566 }
 567
 568 double
 569 _gtk_css_value_get_double (const GtkCssValue *value)
 570 {
 571   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_DOUBLE), 0);
 572   return value->u.dbl;
 573 }
 574
 575 const char *
 576 _gtk_css_value_get_string (const GtkCssValue *value)
 577 {
 578   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_STRING), 0);
 579   return value->u.ptr;
 580 }
 581
 582 gpointer
 583 _gtk_css_value_dup_object (const GtkCssValue *value)
 584 {
 585   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_OBJECT), NULL);
 586   if (value->u.ptr)
 587     return g_object_ref (value->u.ptr);
 588   return NULL;
 589 }
 590
 591 gpointer
 592 _gtk_css_value_get_object (const GtkCssValue *value)
 593 {
 594   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_OBJECT), NULL);
 595   return value->u.ptr;
 596 }
 597
 598 gpointer
 599 _gtk_css_value_get_boxed (const GtkCssValue *value)
 600 {
 601   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_BOXED), NULL);
 602   return value->u.ptr;
 603 }
 604
 605 const char **
 606 _gtk_css_value_get_strv (const GtkCssValue *value)
 607 {
 608   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_STRV), NULL);
 609   return value->u.ptr;
 610 }
 611
 612 GtkCssImage *
 613 _gtk_css_value_get_image (const GtkCssValue *value)
 614 {
 615   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_IMAGE), NULL);
 616   return value->u.ptr;
 617 }
 618
 619 GtkBorderStyle
 620 _gtk_css_value_get_border_style (const GtkCssValue *value)
 621 {
 622   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_BORDER_STYLE), 0);
 623   return value->u.gint;
 624 }
 625
 626 const GtkCssBackgroundSize *
 627 _gtk_css_value_get_background_size (const GtkCssValue *value)
 628 {
 629   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BACKGROUND_SIZE), NULL);
 630   return value->u.ptr;
 631 }
 632
 633 const GtkCssBackgroundPosition *
 634 _gtk_css_value_get_background_position (const GtkCssValue *value)
 635 {
 636   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BACKGROUND_POSITION), NULL);
 637   return value->u.ptr;
 638 }
 639
 640 const GtkCssBorderImageRepeat *
 641 _gtk_css_value_get_border_image_repeat (const GtkCssValue *value)
 642 {
 643   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BORDER_IMAGE_REPEAT), NULL);
 644   return value->u.ptr;
 645 }
 646
 647 const GtkCssBorderCornerRadius *
 648 _gtk_css_value_get_border_corner_radius (const GtkCssValue *value)
 649 {
 650   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BORDER_CORNER_RADIUS), NULL);
 651   return value->u.ptr;
 652 }
 653
 654 PangoFontDescription *
 655 _gtk_css_value_get_font_description (const GtkCssValue *value)
 656 {
 657   g_return_val_if_fail (_gtk_css_value_holds (value, PANGO_TYPE_FONT_DESCRIPTION), 0);
 658   return value->u.ptr;
 659 }
 660
 661 PangoStyle
 662 _gtk_css_value_get_pango_style (const GtkCssValue *value)
 663 {
 664   g_return_val_if_fail (_gtk_css_value_holds (value, PANGO_TYPE_STYLE), 0);
 665   return value->u.gint;
 666 }
 667
 668 PangoVariant
 669 _gtk_css_value_get_pango_variant (const GtkCssValue *value)
 670 {
 671   g_return_val_if_fail (_gtk_css_value_holds (value, PANGO_TYPE_VARIANT), 0);
 672   return value->u.gint;
 673 }
 674
 675 PangoWeight
 676 _gtk_css_value_get_pango_weight (const GtkCssValue *value)
 677 {
 678   g_return_val_if_fail (_gtk_css_value_holds (value, PANGO_TYPE_WEIGHT), 0);
 679   return value->u.gint;
 680 }
 681
 682 const GdkRGBA *
 683 _gtk_css_value_get_rgba (const GtkCssValue *value)
 684 {
 685   g_return_val_if_fail (_gtk_css_value_holds (value, GDK_TYPE_RGBA), NULL);
 686   return value->u.ptr;
 687 }
 688
 689 cairo_pattern_t *
 690 _gtk_css_value_get_pattern (const GtkCssValue *value)
 691 {
 692   g_return_val_if_fail (_gtk_css_value_holds (value, CAIRO_GOBJECT_TYPE_PATTERN), NULL);
 693   return value->u.ptr;
 694 }
 695
 696 GtkGradient *
 697 _gtk_css_value_get_gradient (const GtkCssValue *value)
 698 {
 699   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_GRADIENT), NULL);
 700   return value->u.ptr;
 701 }
 702
 703 GtkShadow *
 704 _gtk_css_value_get_shadow (const GtkCssValue *value)
 705 {
 706   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_SHADOW), NULL);
 707   return value->u.ptr;
 708 }