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_from_int (gint val)
 164 {
 165   GtkCssValue *value;
 166   static GtkCssValue *singletons[4] = {NULL};
 167
 168   if (val >= 0 && val < G_N_ELEMENTS (singletons))
 169     {
 170       if (singletons[val] == NULL)
 171         {
 172           value = gtk_css_value_new (G_TYPE_INT);
 173           value->u.gint = val;
 174           singletons[val] = value;
 175         }
 176       return _gtk_css_value_ref (singletons[val]);
 177     }
 178
 179   value = gtk_css_value_new (G_TYPE_INT);
 180   value->u.gint = val;
 181
 182   return value;
 183 }
 184
 185 GtkCssValue *
 186 _gtk_css_value_new_from_enum (GType type,
 187                               gint  val)
 188 {
 189   GtkCssValue *value;
 190
 191   g_return_val_if_fail (g_type_is_a (type, G_TYPE_ENUM), NULL);
 192
 193   value = gtk_css_value_new (type);
 194   value->u.gint = val;
 195
 196   return value;
 197 }
 198
 199 GtkCssValue *
 200 _gtk_css_value_new_from_double (double d)
 201 {
 202   GtkCssValue *value;
 203
 204   value = gtk_css_value_new (G_TYPE_DOUBLE);
 205   value->u.dbl = d;
 206
 207   return value;
 208 }
 209
 210 GtkCssValue *
 211 _gtk_css_value_new_take_string (char *string)
 212 {
 213   GtkCssValue *value;
 214
 215   value = gtk_css_value_new (G_TYPE_STRING);
 216   value->u.ptr = string;
 217
 218   return value;
 219 }
 220
 221 GtkCssValue *
 222 _gtk_css_value_new_take_strv (char **strv)
 223 {
 224   GtkCssValue *value;
 225
 226   value = gtk_css_value_new (G_TYPE_STRV);
 227   value->u.ptr = strv;
 228
 229   return value;
 230 }
 231
 232 static gpointer
 233 g_boxed_copy0 (GType         boxed_type,
 234                gconstpointer src_boxed)
 235 {
 236   if (src_boxed == NULL)
 237     return NULL;
 238   return g_boxed_copy (boxed_type, src_boxed);
 239 }
 240
 241 GtkCssValue *
 242 _gtk_css_value_new_take_pattern (cairo_pattern_t *v)
 243 {
 244   GtkCssValue *value;
 245
 246   value = gtk_css_value_new (CAIRO_GOBJECT_TYPE_PATTERN);
 247   value->u.ptr = v;
 248
 249   return value;
 250 }
 251
 252 GtkCssValue *
 253 _gtk_css_value_new_take_shadow (GtkShadow *v)
 254 {
 255   GtkCssValue *value;
 256
 257   value = gtk_css_value_new (GTK_TYPE_SHADOW);
 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_take_binding_sets (GPtrArray *array)
 276 {
 277   GtkCssValue *value;
 278
 279   value = gtk_css_value_new (G_TYPE_PTR_ARRAY);
 280   value->u.ptr = array;
 281
 282   return value;
 283 }
 284
 285 GtkCssValue *
 286 _gtk_css_value_new_from_number (const GtkCssNumber *v)
 287 {
 288   GtkCssValue *value;
 289   static GtkCssValue *zero_singleton = NULL;
 290   static GtkCssValue *px_singletons[5] = {NULL};
 291
 292   if (v->unit == GTK_CSS_NUMBER &&
 293       v->value == 0)
 294     {
 295       if (zero_singleton == NULL)
 296         {
 297           value = gtk_css_value_new (GTK_TYPE_CSS_NUMBER);
 298           value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_NUMBER, v);
 299           zero_singleton = value;
 300         }
 301       return _gtk_css_value_ref (zero_singleton);
 302     }
 303
 304   if (v->unit == GTK_CSS_PX &&
 305       (v->value == 0 ||
 306        v->value == 1 ||
 307        v->value == 2 ||
 308        v->value == 3 ||
 309        v->value == 4))
 310     {
 311       int i = round (v->value);
 312       if (px_singletons[i] == NULL)
 313         {
 314           value = gtk_css_value_new (GTK_TYPE_CSS_NUMBER);
 315           value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_NUMBER, v);
 316           px_singletons[i] = value;
 317         }
 318
 319       return _gtk_css_value_ref (px_singletons[i]);
 320     }
 321
 322   value = gtk_css_value_new (GTK_TYPE_CSS_NUMBER);
 323   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_NUMBER, v);
 324
 325   return value;
 326 }
 327
 328 GtkCssValue *
 329 _gtk_css_value_new_from_rgba (const GdkRGBA *v)
 330 {
 331   GtkCssValue *value;
 332
 333   value = gtk_css_value_new (GDK_TYPE_RGBA);
 334   value->u.ptr = g_boxed_copy0 (GDK_TYPE_RGBA, v);
 335
 336   return value;
 337 }
 338
 339 GtkCssValue *
 340 _gtk_css_value_new_from_color (const GdkColor *v)
 341 {
 342   GtkCssValue *value;
 343
 344   value = gtk_css_value_new (GDK_TYPE_COLOR);
 345   value->u.ptr = g_boxed_copy0 (GDK_TYPE_COLOR, v);
 346
 347   return value;
 348 }
 349
 350 GtkCssValue *
 351 _gtk_css_value_new_from_background_size (const GtkCssBackgroundSize *v)
 352 {
 353   GtkCssValue *value;
 354
 355   value = gtk_css_value_new (GTK_TYPE_CSS_BACKGROUND_SIZE);
 356   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BACKGROUND_SIZE, v);
 357
 358   return value;
 359 }
 360
 361 GtkCssValue *
 362 _gtk_css_value_new_from_background_position (const GtkCssBackgroundPosition *v)
 363 {
 364   GtkCssValue *value;
 365
 366   value = gtk_css_value_new (GTK_TYPE_CSS_BACKGROUND_POSITION);
 367   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BACKGROUND_POSITION, v);
 368
 369   return value;
 370 }
 371
 372 GtkCssValue *
 373 _gtk_css_value_new_from_border_corner_radius (const GtkCssBorderCornerRadius *v)
 374 {
 375   GtkCssValue *value;
 376
 377   value = gtk_css_value_new (GTK_TYPE_CSS_BORDER_CORNER_RADIUS);
 378   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BORDER_CORNER_RADIUS, v);
 379
 380   return value;
 381 }
 382
 383 GtkCssValue *
 384 _gtk_css_value_new_from_border_style (GtkBorderStyle style)
 385 {
 386   GtkCssValue *value;
 387
 388   value = gtk_css_value_new (GTK_TYPE_BORDER_STYLE);
 389   value->u.gint = style;
 390
 391   return value;
 392 }
 393
 394 GtkCssValue *
 395 _gtk_css_value_new_take_symbolic_color (GtkSymbolicColor *v)
 396 {
 397   GtkCssValue *value;
 398
 399   value = gtk_css_value_new (GTK_TYPE_SYMBOLIC_COLOR);
 400   value->u.ptr = v;
 401
 402   return value;
 403 }
 404
 405 GtkCssValue *
 406 _gtk_css_value_alloc (const GtkCssValueClass *klass,
 407                       gsize                   size)
 408 {
 409   GtkCssValue *value;
 410
 411   value = g_slice_alloc0 (size);
 412
 413   value->class = klass;
 414   value->ref_count = 1;
 415
 416   return value;
 417 }
 418
 419 GtkCssValue *
 420 _gtk_css_value_ref (GtkCssValue *value)
 421 {
 422   g_return_val_if_fail (value != NULL, NULL);
 423
 424   g_atomic_int_add (&value->ref_count, 1);
 425
 426   return value;
 427 }
 428
 429 void
 430 _gtk_css_value_unref (GtkCssValue *value)
 431 {
 432   if (value == NULL)
 433     return;
 434
 435   if (!g_atomic_int_dec_and_test (&value->ref_count))
 436     return;
 437
 438   value->class->free (value);
 439 }
 440
 441 void
 442 _gtk_css_value_print (const GtkCssValue *value,
 443                       GString           *string)
 444 {
 445   g_return_if_fail (value != NULL);
 446   g_return_if_fail (string != NULL);
 447
 448   value->class->print (value, string);
 449 }
 450
 451 GType
 452 _gtk_css_value_get_content_type (const GtkCssValue *value)
 453 {
 454   return value->type;
 455 }
 456
 457 gboolean
 458 _gtk_css_value_holds (const GtkCssValue *value, GType type)
 459 {
 460   return g_type_is_a (value->type, type);
 461 }
 462
 463 static void
 464 fill_gvalue (const GtkCssValue *value,
 465              GValue            *g_value)
 466 {
 467   GType type;
 468
 469   type = value->type;
 470
 471   if (g_type_is_a (type, G_TYPE_OBJECT))
 472     g_value_set_object (g_value, value->u.ptr);
 473   else if (g_type_is_a (type, G_TYPE_BOXED))
 474     g_value_set_boxed (g_value, value->u.ptr);
 475   else if (g_type_is_a (type, G_TYPE_INT))
 476     g_value_set_int (g_value, value->u.gint);
 477   else if (g_type_is_a (type, G_TYPE_UINT))
 478     g_value_set_uint (g_value, value->u.guint);
 479   else if (g_type_is_a (type, G_TYPE_BOOLEAN))
 480     g_value_set_boolean (g_value, value->u.gint);
 481   else if (g_type_is_a (type, G_TYPE_ENUM))
 482     g_value_set_enum (g_value, value->u.gint);
 483   else if (g_type_is_a (type, G_TYPE_FLAGS))
 484     g_value_set_flags (g_value, value->u.guint);
 485   else if (g_type_is_a (type, G_TYPE_STRING))
 486     g_value_set_string (g_value, value->u.ptr);
 487   else if (g_type_is_a (type, G_TYPE_DOUBLE))
 488     g_value_set_double (g_value, value->u.dbl);
 489   else if (g_type_is_a (type, G_TYPE_FLOAT))
 490     g_value_set_float (g_value, value->u.flt);
 491   else
 492     g_value_copy (value->u.ptr, g_value);
 493 }
 494
 495 void
 496 _gtk_css_value_init_gvalue (const GtkCssValue *value,
 497                             GValue            *g_value)
 498 {
 499   if (value != NULL)
 500     {
 501       g_value_init (g_value, value->type);
 502       fill_gvalue (value, g_value);
 503     }
 504 }
 505
 506 const GtkCssNumber *
 507 _gtk_css_value_get_number (const GtkCssValue *value)
 508 {
 509   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_NUMBER), NULL);
 510   return value->u.ptr;
 511 }
 512
 513 GtkSymbolicColor *
 514 _gtk_css_value_get_symbolic_color (const GtkCssValue *value)
 515 {
 516   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_SYMBOLIC_COLOR), NULL);
 517   return value->u.ptr;
 518 }
 519
 520 int
 521 _gtk_css_value_get_int (const GtkCssValue *value)
 522 {
 523   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_INT), 0);
 524   return value->u.gint;
 525 }
 526
 527 int
 528 _gtk_css_value_get_enum (const GtkCssValue *value)
 529 {
 530   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_ENUM), 0);
 531   return value->u.gint;
 532 }
 533
 534 double
 535 _gtk_css_value_get_double (const GtkCssValue *value)
 536 {
 537   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_DOUBLE), 0);
 538   return value->u.dbl;
 539 }
 540
 541 const char *
 542 _gtk_css_value_get_string (const GtkCssValue *value)
 543 {
 544   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_STRING), 0);
 545   return value->u.ptr;
 546 }
 547
 548 gpointer
 549 _gtk_css_value_dup_object (const GtkCssValue *value)
 550 {
 551   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_OBJECT), NULL);
 552   if (value->u.ptr)
 553     return g_object_ref (value->u.ptr);
 554   return NULL;
 555 }
 556
 557 gpointer
 558 _gtk_css_value_get_object (const GtkCssValue *value)
 559 {
 560   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_OBJECT), NULL);
 561   return value->u.ptr;
 562 }
 563
 564 gpointer
 565 _gtk_css_value_get_boxed (const GtkCssValue *value)
 566 {
 567   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_BOXED), NULL);
 568   return value->u.ptr;
 569 }
 570
 571 const char **
 572 _gtk_css_value_get_strv (const GtkCssValue *value)
 573 {
 574   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_STRV), NULL);
 575   return value->u.ptr;
 576 }
 577
 578 GtkCssImage *
 579 _gtk_css_value_get_image (const GtkCssValue *value)
 580 {
 581   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_IMAGE), NULL);
 582   return value->u.ptr;
 583 }
 584
 585 GtkBorderStyle
 586 _gtk_css_value_get_border_style (const GtkCssValue *value)
 587 {
 588   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_BORDER_STYLE), 0);
 589   return value->u.gint;
 590 }
 591
 592 const GtkCssBackgroundSize *
 593 _gtk_css_value_get_background_size (const GtkCssValue *value)
 594 {
 595   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BACKGROUND_SIZE), NULL);
 596   return value->u.ptr;
 597 }
 598
 599 const GtkCssBackgroundPosition *
 600 _gtk_css_value_get_background_position (const GtkCssValue *value)
 601 {
 602   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BACKGROUND_POSITION), NULL);
 603   return value->u.ptr;
 604 }
 605
 606 const GtkCssBorderImageRepeat *
 607 _gtk_css_value_get_border_image_repeat (const GtkCssValue *value)
 608 {
 609   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BORDER_IMAGE_REPEAT), NULL);
 610   return value->u.ptr;
 611 }
 612
 613 const GtkCssBorderCornerRadius *
 614 _gtk_css_value_get_border_corner_radius (const GtkCssValue *value)
 615 {
 616   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BORDER_CORNER_RADIUS), NULL);
 617   return value->u.ptr;
 618 }
 619
 620 PangoStyle
 621 _gtk_css_value_get_pango_style (const GtkCssValue *value)
 622 {
 623   g_return_val_if_fail (_gtk_css_value_holds (value, PANGO_TYPE_STYLE), 0);
 624   return value->u.gint;
 625 }
 626
 627 PangoVariant
 628 _gtk_css_value_get_pango_variant (const GtkCssValue *value)
 629 {
 630   g_return_val_if_fail (_gtk_css_value_holds (value, PANGO_TYPE_VARIANT), 0);
 631   return value->u.gint;
 632 }
 633
 634 PangoWeight
 635 _gtk_css_value_get_pango_weight (const GtkCssValue *value)
 636 {
 637   g_return_val_if_fail (_gtk_css_value_holds (value, PANGO_TYPE_WEIGHT), 0);
 638   return value->u.gint;
 639 }
 640
 641 const GdkRGBA *
 642 _gtk_css_value_get_rgba (const GtkCssValue *value)
 643 {
 644   g_return_val_if_fail (_gtk_css_value_holds (value, GDK_TYPE_RGBA), NULL);
 645   return value->u.ptr;
 646 }
 647
 648 cairo_pattern_t *
 649 _gtk_css_value_get_pattern (const GtkCssValue *value)
 650 {
 651   g_return_val_if_fail (_gtk_css_value_holds (value, CAIRO_GOBJECT_TYPE_PATTERN), NULL);
 652   return value->u.ptr;
 653 }
 654
 655 GtkGradient *
 656 _gtk_css_value_get_gradient (const GtkCssValue *value)
 657 {
 658   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_GRADIENT), NULL);
 659   return value->u.ptr;
 660 }
 661
 662 GtkShadow *
 663 _gtk_css_value_get_shadow (const GtkCssValue *value)
 664 {
 665   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_SHADOW), NULL);
 666   return value->u.ptr;
 667 }