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 gboolean
  83 gtk_css_value_default_equal (const GtkCssValue *value1,
  84                              const GtkCssValue *value2)
  85 {
  86   return FALSE;
  87 }
  88
  89 static void
  90 gtk_css_value_default_print (const GtkCssValue *value,
  91                              GString           *string)
  92 {
  93   GValue g_value = G_VALUE_INIT;
  94
  95   _gtk_css_value_init_gvalue (value, &g_value);
  96   _gtk_css_style_print_value (&g_value, string);
  97   g_value_unset (&g_value);
  98 }
  99
 100 static const GtkCssValueClass GTK_CSS_VALUE_DEFAULT = {
 101   gtk_css_value_default_free,
 102   gtk_css_value_default_equal,
 103   gtk_css_value_default_print
 104 };
 105
 106 G_DEFINE_BOXED_TYPE (GtkCssValue, _gtk_css_value, _gtk_css_value_ref, _gtk_css_value_unref)
 107
 108 static GtkCssValue *
 109 gtk_css_value_new (GType type)
 110 {
 111   GtkCssValue *value;
 112
 113   value = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_DEFAULT);
 114
 115   value->type = type;
 116
 117   return value;
 118 }
 119
 120 GtkCssValue *
 121 _gtk_css_value_new_from_gvalue (const GValue *g_value)
 122 {
 123   GtkCssValue *value;
 124   GType type;
 125
 126   g_return_val_if_fail (g_value != NULL, NULL);
 127
 128   type = G_VALUE_TYPE (g_value);
 129
 130   /* Make sure we reuse the int/number singletons */
 131   if (type == G_TYPE_INT)
 132     value = _gtk_css_value_new_from_int (g_value_get_int (g_value));
 133   else if (type == GTK_TYPE_CSS_NUMBER)
 134     value = _gtk_css_value_new_from_number (g_value_get_boxed (g_value));
 135   else
 136     {
 137       value = gtk_css_value_new (type);
 138
 139       if (g_type_is_a (type, G_TYPE_OBJECT))
 140         value->u.ptr = g_value_dup_object (g_value);
 141       else if (g_type_is_a (type, G_TYPE_BOXED))
 142         value->u.ptr = g_value_dup_boxed (g_value);
 143       else if (g_type_is_a (type, G_TYPE_INT))
 144         value->u.gint = g_value_get_int (g_value);
 145       else if (g_type_is_a (type, G_TYPE_UINT))
 146         value->u.guint = g_value_get_uint (g_value);
 147       else if (g_type_is_a (type, G_TYPE_BOOLEAN))
 148         value->u.gint = g_value_get_boolean (g_value);
 149       else if (g_type_is_a (type, G_TYPE_ENUM))
 150         value->u.gint = g_value_get_enum (g_value);
 151       else if (g_type_is_a (type, G_TYPE_FLAGS))
 152         value->u.guint = g_value_get_flags (g_value);
 153       else if (g_type_is_a (type, G_TYPE_STRING))
 154         value->u.ptr = g_value_dup_string (g_value);
 155       else if (g_type_is_a (type, G_TYPE_DOUBLE))
 156         value->u.dbl = g_value_get_double (g_value);
 157       else if (g_type_is_a (type, G_TYPE_FLOAT))
 158         value->u.flt = g_value_get_float (g_value);
 159       else
 160         {
 161           value->u.ptr = g_slice_new0 (GValue);
 162           g_value_init (value->u.ptr, G_VALUE_TYPE (g_value));
 163           g_value_copy (g_value, value->u.ptr);
 164         }
 165     }
 166
 167   return value;
 168 }
 169
 170 GtkCssValue *
 171 _gtk_css_value_new_from_int (gint val)
 172 {
 173   GtkCssValue *value;
 174   static GtkCssValue *singletons[4] = {NULL};
 175
 176   if (val >= 0 && val < G_N_ELEMENTS (singletons))
 177     {
 178       if (singletons[val] == NULL)
 179         {
 180           value = gtk_css_value_new (G_TYPE_INT);
 181           value->u.gint = val;
 182           singletons[val] = value;
 183         }
 184       return _gtk_css_value_ref (singletons[val]);
 185     }
 186
 187   value = gtk_css_value_new (G_TYPE_INT);
 188   value->u.gint = val;
 189
 190   return value;
 191 }
 192
 193 GtkCssValue *
 194 _gtk_css_value_new_from_enum (GType type,
 195                               gint  val)
 196 {
 197   GtkCssValue *value;
 198
 199   g_return_val_if_fail (g_type_is_a (type, G_TYPE_ENUM), NULL);
 200
 201   value = gtk_css_value_new (type);
 202   value->u.gint = val;
 203
 204   return value;
 205 }
 206
 207 GtkCssValue *
 208 _gtk_css_value_new_from_double (double d)
 209 {
 210   GtkCssValue *value;
 211
 212   value = gtk_css_value_new (G_TYPE_DOUBLE);
 213   value->u.dbl = d;
 214
 215   return value;
 216 }
 217
 218 GtkCssValue *
 219 _gtk_css_value_new_take_string (char *string)
 220 {
 221   GtkCssValue *value;
 222
 223   value = gtk_css_value_new (G_TYPE_STRING);
 224   value->u.ptr = string;
 225
 226   return value;
 227 }
 228
 229 GtkCssValue *
 230 _gtk_css_value_new_take_strv (char **strv)
 231 {
 232   GtkCssValue *value;
 233
 234   value = gtk_css_value_new (G_TYPE_STRV);
 235   value->u.ptr = strv;
 236
 237   return value;
 238 }
 239
 240 static gpointer
 241 g_boxed_copy0 (GType         boxed_type,
 242                gconstpointer src_boxed)
 243 {
 244   if (src_boxed == NULL)
 245     return NULL;
 246   return g_boxed_copy (boxed_type, src_boxed);
 247 }
 248
 249 GtkCssValue *
 250 _gtk_css_value_new_take_pattern (cairo_pattern_t *v)
 251 {
 252   GtkCssValue *value;
 253
 254   value = gtk_css_value_new (CAIRO_GOBJECT_TYPE_PATTERN);
 255   value->u.ptr = v;
 256
 257   return value;
 258 }
 259
 260 GtkCssValue *
 261 _gtk_css_value_new_take_shadow (GtkShadow *v)
 262 {
 263   GtkCssValue *value;
 264
 265   value = gtk_css_value_new (GTK_TYPE_SHADOW);
 266   value->u.ptr = v;
 267
 268   return value;
 269 }
 270
 271 GtkCssValue *
 272 _gtk_css_value_new_take_image (GtkCssImage *v)
 273 {
 274   GtkCssValue *value;
 275
 276   value = gtk_css_value_new (GTK_TYPE_CSS_IMAGE);
 277   value->u.ptr = v;
 278
 279   return value;
 280 }
 281
 282 GtkCssValue *
 283 _gtk_css_value_new_take_binding_sets (GPtrArray *array)
 284 {
 285   GtkCssValue *value;
 286
 287   value = gtk_css_value_new (G_TYPE_PTR_ARRAY);
 288   value->u.ptr = array;
 289
 290   return value;
 291 }
 292
 293 GtkCssValue *
 294 _gtk_css_value_new_from_number (const GtkCssNumber *v)
 295 {
 296   GtkCssValue *value;
 297   static GtkCssValue *zero_singleton = NULL;
 298   static GtkCssValue *px_singletons[5] = {NULL};
 299
 300   if (v->unit == GTK_CSS_NUMBER &&
 301       v->value == 0)
 302     {
 303       if (zero_singleton == NULL)
 304         {
 305           value = gtk_css_value_new (GTK_TYPE_CSS_NUMBER);
 306           value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_NUMBER, v);
 307           zero_singleton = value;
 308         }
 309       return _gtk_css_value_ref (zero_singleton);
 310     }
 311
 312   if (v->unit == GTK_CSS_PX &&
 313       (v->value == 0 ||
 314        v->value == 1 ||
 315        v->value == 2 ||
 316        v->value == 3 ||
 317        v->value == 4))
 318     {
 319       int i = round (v->value);
 320       if (px_singletons[i] == NULL)
 321         {
 322           value = gtk_css_value_new (GTK_TYPE_CSS_NUMBER);
 323           value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_NUMBER, v);
 324           px_singletons[i] = value;
 325         }
 326
 327       return _gtk_css_value_ref (px_singletons[i]);
 328     }
 329
 330   value = gtk_css_value_new (GTK_TYPE_CSS_NUMBER);
 331   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_NUMBER, v);
 332
 333   return value;
 334 }
 335
 336 GtkCssValue *
 337 _gtk_css_value_new_from_rgba (const GdkRGBA *v)
 338 {
 339   GtkCssValue *value;
 340
 341   value = gtk_css_value_new (GDK_TYPE_RGBA);
 342   value->u.ptr = g_boxed_copy0 (GDK_TYPE_RGBA, v);
 343
 344   return value;
 345 }
 346
 347 GtkCssValue *
 348 _gtk_css_value_new_from_color (const GdkColor *v)
 349 {
 350   GtkCssValue *value;
 351
 352   value = gtk_css_value_new (GDK_TYPE_COLOR);
 353   value->u.ptr = g_boxed_copy0 (GDK_TYPE_COLOR, v);
 354
 355   return value;
 356 }
 357
 358 GtkCssValue *
 359 _gtk_css_value_new_from_background_size (const GtkCssBackgroundSize *v)
 360 {
 361   GtkCssValue *value;
 362
 363   value = gtk_css_value_new (GTK_TYPE_CSS_BACKGROUND_SIZE);
 364   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BACKGROUND_SIZE, v);
 365
 366   return value;
 367 }
 368
 369 GtkCssValue *
 370 _gtk_css_value_new_from_background_position (const GtkCssBackgroundPosition *v)
 371 {
 372   GtkCssValue *value;
 373
 374   value = gtk_css_value_new (GTK_TYPE_CSS_BACKGROUND_POSITION);
 375   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BACKGROUND_POSITION, v);
 376
 377   return value;
 378 }
 379
 380 GtkCssValue *
 381 _gtk_css_value_new_from_border_corner_radius (const GtkCssBorderCornerRadius *v)
 382 {
 383   GtkCssValue *value;
 384
 385   value = gtk_css_value_new (GTK_TYPE_CSS_BORDER_CORNER_RADIUS);
 386   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BORDER_CORNER_RADIUS, v);
 387
 388   return value;
 389 }
 390
 391 GtkCssValue *
 392 _gtk_css_value_new_from_border_style (GtkBorderStyle style)
 393 {
 394   GtkCssValue *value;
 395
 396   value = gtk_css_value_new (GTK_TYPE_BORDER_STYLE);
 397   value->u.gint = style;
 398
 399   return value;
 400 }
 401
 402 GtkCssValue *
 403 _gtk_css_value_new_take_symbolic_color (GtkSymbolicColor *v)
 404 {
 405   GtkCssValue *value;
 406
 407   value = gtk_css_value_new (GTK_TYPE_SYMBOLIC_COLOR);
 408   value->u.ptr = v;
 409
 410   return value;
 411 }
 412
 413 GtkCssValue *
 414 _gtk_css_value_alloc (const GtkCssValueClass *klass,
 415                       gsize                   size)
 416 {
 417   GtkCssValue *value;
 418
 419   value = g_slice_alloc0 (size);
 420
 421   value->class = klass;
 422   value->ref_count = 1;
 423
 424   return value;
 425 }
 426
 427 GtkCssValue *
 428 _gtk_css_value_ref (GtkCssValue *value)
 429 {
 430   g_return_val_if_fail (value != NULL, NULL);
 431
 432   g_atomic_int_add (&value->ref_count, 1);
 433
 434   return value;
 435 }
 436
 437 void
 438 _gtk_css_value_unref (GtkCssValue *value)
 439 {
 440   if (value == NULL)
 441     return;
 442
 443   if (!g_atomic_int_dec_and_test (&value->ref_count))
 444     return;
 445
 446   value->class->free (value);
 447 }
 448
 449 gboolean
 450 _gtk_css_value_equal (const GtkCssValue *value1,
 451                       const GtkCssValue *value2)
 452 {
 453   g_return_val_if_fail (value1 != NULL, FALSE);
 454   g_return_val_if_fail (value2 != NULL, FALSE);
 455
 456   if (value1->class != value2->class)
 457     return FALSE;
 458
 459   return value1->class->equal (value1, value2);
 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 const GtkCssNumber *
 528 _gtk_css_value_get_number (const GtkCssValue *value)
 529 {
 530   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_NUMBER), NULL);
 531   return value->u.ptr;
 532 }
 533
 534 GtkSymbolicColor *
 535 _gtk_css_value_get_symbolic_color (const GtkCssValue *value)
 536 {
 537   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_SYMBOLIC_COLOR), NULL);
 538   return value->u.ptr;
 539 }
 540
 541 int
 542 _gtk_css_value_get_int (const GtkCssValue *value)
 543 {
 544   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_INT), 0);
 545   return value->u.gint;
 546 }
 547
 548 int
 549 _gtk_css_value_get_enum (const GtkCssValue *value)
 550 {
 551   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_ENUM), 0);
 552   return value->u.gint;
 553 }
 554
 555 double
 556 _gtk_css_value_get_double (const GtkCssValue *value)
 557 {
 558   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_DOUBLE), 0);
 559   return value->u.dbl;
 560 }
 561
 562 const char *
 563 _gtk_css_value_get_string (const GtkCssValue *value)
 564 {
 565   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_STRING), 0);
 566   return value->u.ptr;
 567 }
 568
 569 gpointer
 570 _gtk_css_value_dup_object (const GtkCssValue *value)
 571 {
 572   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_OBJECT), NULL);
 573   if (value->u.ptr)
 574     return g_object_ref (value->u.ptr);
 575   return NULL;
 576 }
 577
 578 gpointer
 579 _gtk_css_value_get_object (const GtkCssValue *value)
 580 {
 581   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_OBJECT), NULL);
 582   return value->u.ptr;
 583 }
 584
 585 gpointer
 586 _gtk_css_value_get_boxed (const GtkCssValue *value)
 587 {
 588   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_BOXED), NULL);
 589   return value->u.ptr;
 590 }
 591
 592 const char **
 593 _gtk_css_value_get_strv (const GtkCssValue *value)
 594 {
 595   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_STRV), NULL);
 596   return value->u.ptr;
 597 }
 598
 599 GtkCssImage *
 600 _gtk_css_value_get_image (const GtkCssValue *value)
 601 {
 602   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_IMAGE), NULL);
 603   return value->u.ptr;
 604 }
 605
 606 GtkBorderStyle
 607 _gtk_css_value_get_border_style (const GtkCssValue *value)
 608 {
 609   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_BORDER_STYLE), 0);
 610   return value->u.gint;
 611 }
 612
 613 const GtkCssBackgroundSize *
 614 _gtk_css_value_get_background_size (const GtkCssValue *value)
 615 {
 616   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BACKGROUND_SIZE), NULL);
 617   return value->u.ptr;
 618 }
 619
 620 const GtkCssBackgroundPosition *
 621 _gtk_css_value_get_background_position (const GtkCssValue *value)
 622 {
 623   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BACKGROUND_POSITION), NULL);
 624   return value->u.ptr;
 625 }
 626
 627 const GtkCssBorderImageRepeat *
 628 _gtk_css_value_get_border_image_repeat (const GtkCssValue *value)
 629 {
 630   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BORDER_IMAGE_REPEAT), NULL);
 631   return value->u.ptr;
 632 }
 633
 634 const GtkCssBorderCornerRadius *
 635 _gtk_css_value_get_border_corner_radius (const GtkCssValue *value)
 636 {
 637   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BORDER_CORNER_RADIUS), NULL);
 638   return value->u.ptr;
 639 }
 640
 641 PangoStyle
 642 _gtk_css_value_get_pango_style (const GtkCssValue *value)
 643 {
 644   g_return_val_if_fail (_gtk_css_value_holds (value, PANGO_TYPE_STYLE), 0);
 645   return value->u.gint;
 646 }
 647
 648 PangoVariant
 649 _gtk_css_value_get_pango_variant (const GtkCssValue *value)
 650 {
 651   g_return_val_if_fail (_gtk_css_value_holds (value, PANGO_TYPE_VARIANT), 0);
 652   return value->u.gint;
 653 }
 654
 655 PangoWeight
 656 _gtk_css_value_get_pango_weight (const GtkCssValue *value)
 657 {
 658   g_return_val_if_fail (_gtk_css_value_holds (value, PANGO_TYPE_WEIGHT), 0);
 659   return value->u.gint;
 660 }
 661
 662 const GdkRGBA *
 663 _gtk_css_value_get_rgba (const GtkCssValue *value)
 664 {
 665   g_return_val_if_fail (_gtk_css_value_holds (value, GDK_TYPE_RGBA), NULL);
 666   return value->u.ptr;
 667 }
 668
 669 cairo_pattern_t *
 670 _gtk_css_value_get_pattern (const GtkCssValue *value)
 671 {
 672   g_return_val_if_fail (_gtk_css_value_holds (value, CAIRO_GOBJECT_TYPE_PATTERN), NULL);
 673   return value->u.ptr;
 674 }
 675
 676 GtkGradient *
 677 _gtk_css_value_get_gradient (const GtkCssValue *value)
 678 {
 679   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_GRADIENT), NULL);
 680   return value->u.ptr;
 681 }
 682
 683 GtkShadow *
 684 _gtk_css_value_get_shadow (const GtkCssValue *value)
 685 {
 686   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_SHADOW), NULL);
 687   return value->u.ptr;
 688 }