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