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 GtkCssValue *
  90 gtk_css_value_default_transition (GtkCssValue *start,
  91                                   GtkCssValue *end,
  92                                   double       progress)
  93 {
  94   return NULL;
  95 }
  96
  97 static void
  98 gtk_css_value_default_print (const GtkCssValue *value,
  99                              GString           *string)
 100 {
 101   GValue g_value = G_VALUE_INIT;
 102
 103   _gtk_css_value_init_gvalue (value, &g_value);
 104   _gtk_css_style_print_value (&g_value, string);
 105   g_value_unset (&g_value);
 106 }
 107
 108 static const GtkCssValueClass GTK_CSS_VALUE_DEFAULT = {
 109   gtk_css_value_default_free,
 110   gtk_css_value_default_equal,
 111   gtk_css_value_default_transition,
 112   gtk_css_value_default_print
 113 };
 114
 115 G_DEFINE_BOXED_TYPE (GtkCssValue, _gtk_css_value, _gtk_css_value_ref, _gtk_css_value_unref)
 116
 117 static GtkCssValue *
 118 gtk_css_value_new (GType type)
 119 {
 120   GtkCssValue *value;
 121
 122   value = _gtk_css_value_new (GtkCssValue, &GTK_CSS_VALUE_DEFAULT);
 123
 124   value->type = type;
 125
 126   return value;
 127 }
 128
 129 GtkCssValue *
 130 _gtk_css_value_new_from_gvalue (const GValue *g_value)
 131 {
 132   GtkCssValue *value;
 133   GType type;
 134
 135   g_return_val_if_fail (g_value != NULL, NULL);
 136
 137   type = G_VALUE_TYPE (g_value);
 138
 139   /* Make sure we reuse the int/number singletons */
 140   if (type == G_TYPE_INT)
 141     value = _gtk_css_value_new_from_int (g_value_get_int (g_value));
 142   else
 143     {
 144       value = gtk_css_value_new (type);
 145
 146       if (g_type_is_a (type, G_TYPE_OBJECT))
 147         value->u.ptr = g_value_dup_object (g_value);
 148       else if (g_type_is_a (type, G_TYPE_BOXED))
 149         value->u.ptr = g_value_dup_boxed (g_value);
 150       else if (g_type_is_a (type, G_TYPE_INT))
 151         value->u.gint = g_value_get_int (g_value);
 152       else if (g_type_is_a (type, G_TYPE_UINT))
 153         value->u.guint = g_value_get_uint (g_value);
 154       else if (g_type_is_a (type, G_TYPE_BOOLEAN))
 155         value->u.gint = g_value_get_boolean (g_value);
 156       else if (g_type_is_a (type, G_TYPE_ENUM))
 157         value->u.gint = g_value_get_enum (g_value);
 158       else if (g_type_is_a (type, G_TYPE_FLAGS))
 159         value->u.guint = g_value_get_flags (g_value);
 160       else if (g_type_is_a (type, G_TYPE_STRING))
 161         value->u.ptr = g_value_dup_string (g_value);
 162       else if (g_type_is_a (type, G_TYPE_DOUBLE))
 163         value->u.dbl = g_value_get_double (g_value);
 164       else if (g_type_is_a (type, G_TYPE_FLOAT))
 165         value->u.flt = g_value_get_float (g_value);
 166       else
 167         {
 168           value->u.ptr = g_slice_new0 (GValue);
 169           g_value_init (value->u.ptr, G_VALUE_TYPE (g_value));
 170           g_value_copy (g_value, value->u.ptr);
 171         }
 172     }
 173
 174   return value;
 175 }
 176
 177 GtkCssValue *
 178 _gtk_css_value_new_from_int (gint val)
 179 {
 180   GtkCssValue *value;
 181   static GtkCssValue *singletons[4] = {NULL};
 182
 183   if (val >= 0 && val < G_N_ELEMENTS (singletons))
 184     {
 185       if (singletons[val] == NULL)
 186         {
 187           value = gtk_css_value_new (G_TYPE_INT);
 188           value->u.gint = val;
 189           singletons[val] = value;
 190         }
 191       return _gtk_css_value_ref (singletons[val]);
 192     }
 193
 194   value = gtk_css_value_new (G_TYPE_INT);
 195   value->u.gint = val;
 196
 197   return value;
 198 }
 199
 200 GtkCssValue *
 201 _gtk_css_value_new_from_enum (GType type,
 202                               gint  val)
 203 {
 204   GtkCssValue *value;
 205
 206   g_return_val_if_fail (g_type_is_a (type, G_TYPE_ENUM), NULL);
 207
 208   value = gtk_css_value_new (type);
 209   value->u.gint = val;
 210
 211   return value;
 212 }
 213
 214 GtkCssValue *
 215 _gtk_css_value_new_take_strv (char **strv)
 216 {
 217   GtkCssValue *value;
 218
 219   value = gtk_css_value_new (G_TYPE_STRV);
 220   value->u.ptr = strv;
 221
 222   return value;
 223 }
 224
 225 static gpointer
 226 g_boxed_copy0 (GType         boxed_type,
 227                gconstpointer src_boxed)
 228 {
 229   if (src_boxed == NULL)
 230     return NULL;
 231   return g_boxed_copy (boxed_type, src_boxed);
 232 }
 233
 234 GtkCssValue *
 235 _gtk_css_value_new_from_boxed (GType    type,
 236                                gpointer boxed)
 237 {
 238   GtkCssValue *value;
 239
 240   g_return_val_if_fail (g_type_is_a (type, G_TYPE_BOXED), NULL);
 241
 242   value = gtk_css_value_new (type);
 243   value->u.ptr = g_boxed_copy0 (type, boxed);
 244
 245   return value;
 246 }
 247
 248 GtkCssValue *
 249 _gtk_css_value_new_take_pattern (cairo_pattern_t *v)
 250 {
 251   GtkCssValue *value;
 252
 253   value = gtk_css_value_new (CAIRO_GOBJECT_TYPE_PATTERN);
 254   value->u.ptr = v;
 255
 256   return value;
 257 }
 258
 259 GtkCssValue *
 260 _gtk_css_value_new_from_theming_engine (GtkThemingEngine *v)
 261 {
 262   GtkCssValue *value;
 263
 264   value = gtk_css_value_new (GTK_TYPE_THEMING_ENGINE);
 265   value->u.ptr = g_object_ref (v);
 266
 267   return value;
 268 }
 269
 270 GtkCssValue *
 271 _gtk_css_value_new_take_binding_sets (GPtrArray *array)
 272 {
 273   GtkCssValue *value;
 274
 275   value = gtk_css_value_new (G_TYPE_PTR_ARRAY);
 276   value->u.ptr = array;
 277
 278   return value;
 279 }
 280
 281 GtkCssValue *
 282 _gtk_css_value_new_from_color (const GdkColor *v)
 283 {
 284   GtkCssValue *value;
 285
 286   value = gtk_css_value_new (GDK_TYPE_COLOR);
 287   value->u.ptr = g_boxed_copy0 (GDK_TYPE_COLOR, v);
 288
 289   return value;
 290 }
 291
 292 GtkCssValue *
 293 _gtk_css_value_new_from_background_size (const GtkCssBackgroundSize *v)
 294 {
 295   GtkCssValue *value;
 296
 297   value = gtk_css_value_new (GTK_TYPE_CSS_BACKGROUND_SIZE);
 298   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BACKGROUND_SIZE, v);
 299
 300   return value;
 301 }
 302
 303 GtkCssValue *
 304 _gtk_css_value_new_from_background_position (const GtkCssBackgroundPosition *v)
 305 {
 306   GtkCssValue *value;
 307
 308   value = gtk_css_value_new (GTK_TYPE_CSS_BACKGROUND_POSITION);
 309   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BACKGROUND_POSITION, v);
 310
 311   return value;
 312 }
 313
 314 GtkCssValue *
 315 _gtk_css_value_new_from_border_corner_radius (const GtkCssBorderCornerRadius *v)
 316 {
 317   GtkCssValue *value;
 318
 319   value = gtk_css_value_new (GTK_TYPE_CSS_BORDER_CORNER_RADIUS);
 320   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BORDER_CORNER_RADIUS, v);
 321
 322   return value;
 323 }
 324
 325 GtkCssValue *
 326 _gtk_css_value_new_from_border_image_repeat (const GtkCssBorderImageRepeat *v)
 327 {
 328   GtkCssValue *value;
 329
 330   value = gtk_css_value_new (GTK_TYPE_CSS_BORDER_IMAGE_REPEAT);
 331   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BORDER_IMAGE_REPEAT, v);
 332
 333   return value;
 334 }
 335
 336 GtkCssValue *
 337 _gtk_css_value_new_from_border_style (GtkBorderStyle style)
 338 {
 339   GtkCssValue *value;
 340
 341   value = gtk_css_value_new (GTK_TYPE_BORDER_STYLE);
 342   value->u.gint = style;
 343
 344   return value;
 345 }
 346
 347 GtkCssValue *
 348 _gtk_css_value_new_take_symbolic_color (GtkSymbolicColor *v)
 349 {
 350   GtkCssValue *value;
 351
 352   value = gtk_css_value_new (GTK_TYPE_SYMBOLIC_COLOR);
 353   value->u.ptr = v;
 354
 355   return value;
 356 }
 357
 358 GtkCssValue *
 359 _gtk_css_value_alloc (const GtkCssValueClass *klass,
 360                       gsize                   size)
 361 {
 362   GtkCssValue *value;
 363
 364   value = g_slice_alloc0 (size);
 365
 366   value->class = klass;
 367   value->ref_count = 1;
 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   if (value == NULL)
 386     return;
 387
 388   if (!g_atomic_int_dec_and_test (&value->ref_count))
 389     return;
 390
 391   value->class->free (value);
 392 }
 393
 394 gboolean
 395 _gtk_css_value_equal (const GtkCssValue *value1,
 396                       const GtkCssValue *value2)
 397 {
 398   g_return_val_if_fail (value1 != NULL, FALSE);
 399   g_return_val_if_fail (value2 != NULL, FALSE);
 400
 401   if (value1->class != value2->class)
 402     return FALSE;
 403
 404   return value1->class->equal (value1, value2);
 405 }
 406
 407 GtkCssValue *
 408 _gtk_css_value_transition (GtkCssValue *start,
 409                            GtkCssValue *end,
 410                            double       progress)
 411 {
 412   g_return_val_if_fail (start != NULL, FALSE);
 413   g_return_val_if_fail (end != NULL, FALSE);
 414
 415   if (start->class != end->class)
 416     return NULL;
 417
 418   return start->class->transition (start, end, progress);
 419 }
 420
 421 void
 422 _gtk_css_value_print (const GtkCssValue *value,
 423                       GString           *string)
 424 {
 425   g_return_if_fail (value != NULL);
 426   g_return_if_fail (string != NULL);
 427
 428   value->class->print (value, string);
 429 }
 430
 431 GType
 432 _gtk_css_value_get_content_type (const GtkCssValue *value)
 433 {
 434   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_DEFAULT, G_TYPE_NONE);
 435
 436   return value->type;
 437 }
 438
 439 gboolean
 440 _gtk_css_value_holds (const GtkCssValue *value, GType type)
 441 {
 442   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_DEFAULT, FALSE);
 443
 444   return g_type_is_a (value->type, type);
 445 }
 446
 447 static void
 448 fill_gvalue (const GtkCssValue *value,
 449              GValue            *g_value)
 450 {
 451   GType type;
 452
 453   type = value->type;
 454
 455   if (g_type_is_a (type, G_TYPE_OBJECT))
 456     g_value_set_object (g_value, value->u.ptr);
 457   else if (g_type_is_a (type, G_TYPE_BOXED))
 458     g_value_set_boxed (g_value, value->u.ptr);
 459   else if (g_type_is_a (type, G_TYPE_INT))
 460     g_value_set_int (g_value, value->u.gint);
 461   else if (g_type_is_a (type, G_TYPE_UINT))
 462     g_value_set_uint (g_value, value->u.guint);
 463   else if (g_type_is_a (type, G_TYPE_BOOLEAN))
 464     g_value_set_boolean (g_value, value->u.gint);
 465   else if (g_type_is_a (type, G_TYPE_ENUM))
 466     g_value_set_enum (g_value, value->u.gint);
 467   else if (g_type_is_a (type, G_TYPE_FLAGS))
 468     g_value_set_flags (g_value, value->u.guint);
 469   else if (g_type_is_a (type, G_TYPE_STRING))
 470     g_value_set_string (g_value, value->u.ptr);
 471   else if (g_type_is_a (type, G_TYPE_DOUBLE))
 472     g_value_set_double (g_value, value->u.dbl);
 473   else if (g_type_is_a (type, G_TYPE_FLOAT))
 474     g_value_set_float (g_value, value->u.flt);
 475   else
 476     g_value_copy (value->u.ptr, g_value);
 477 }
 478
 479 void
 480 _gtk_css_value_init_gvalue (const GtkCssValue *value,
 481                             GValue            *g_value)
 482 {
 483   if (value != NULL)
 484     {
 485       g_return_if_fail (value->class == &GTK_CSS_VALUE_DEFAULT);
 486       g_value_init (g_value, value->type);
 487       fill_gvalue (value, g_value);
 488     }
 489 }
 490
 491 GtkSymbolicColor *
 492 _gtk_css_value_get_symbolic_color (const GtkCssValue *value)
 493 {
 494   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_SYMBOLIC_COLOR), NULL);
 495   return value->u.ptr;
 496 }
 497
 498 int
 499 _gtk_css_value_get_int (const GtkCssValue *value)
 500 {
 501   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_INT), 0);
 502   return value->u.gint;
 503 }
 504
 505 int
 506 _gtk_css_value_get_enum (const GtkCssValue *value)
 507 {
 508   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_ENUM), 0);
 509   return value->u.gint;
 510 }
 511
 512 gpointer
 513 _gtk_css_value_dup_object (const GtkCssValue *value)
 514 {
 515   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_OBJECT), NULL);
 516   if (value->u.ptr)
 517     return g_object_ref (value->u.ptr);
 518   return NULL;
 519 }
 520
 521 gpointer
 522 _gtk_css_value_get_object (const GtkCssValue *value)
 523 {
 524   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_OBJECT), NULL);
 525   return value->u.ptr;
 526 }
 527
 528 gpointer
 529 _gtk_css_value_get_boxed (const GtkCssValue *value)
 530 {
 531   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_BOXED), NULL);
 532   return value->u.ptr;
 533 }
 534
 535 const char **
 536 _gtk_css_value_get_strv (const GtkCssValue *value)
 537 {
 538   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_STRV), NULL);
 539   return value->u.ptr;
 540 }
 541
 542 GtkBorderStyle
 543 _gtk_css_value_get_border_style (const GtkCssValue *value)
 544 {
 545   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_BORDER_STYLE), 0);
 546   return value->u.gint;
 547 }
 548
 549 const GtkCssBackgroundSize *
 550 _gtk_css_value_get_background_size (const GtkCssValue *value)
 551 {
 552   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BACKGROUND_SIZE), NULL);
 553   return value->u.ptr;
 554 }
 555
 556 const GtkCssBackgroundPosition *
 557 _gtk_css_value_get_background_position (const GtkCssValue *value)
 558 {
 559   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BACKGROUND_POSITION), NULL);
 560   return value->u.ptr;
 561 }
 562
 563 const GtkCssBorderImageRepeat *
 564 _gtk_css_value_get_border_image_repeat (const GtkCssValue *value)
 565 {
 566   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BORDER_IMAGE_REPEAT), NULL);
 567   return value->u.ptr;
 568 }
 569
 570 const GtkCssBorderCornerRadius *
 571 _gtk_css_value_get_border_corner_radius (const GtkCssValue *value)
 572 {
 573   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BORDER_CORNER_RADIUS), NULL);
 574   return value->u.ptr;
 575 }
 576
 577 GtkGradient *
 578 _gtk_css_value_get_gradient (const GtkCssValue *value)
 579 {
 580   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_GRADIENT), NULL);
 581   return value->u.ptr;
 582 }
 583