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