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_image_repeat (const GtkCssBorderImageRepeat *v)
 316 {
 317   GtkCssValue *value;
 318
 319   value = gtk_css_value_new (GTK_TYPE_CSS_BORDER_IMAGE_REPEAT);
 320   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BORDER_IMAGE_REPEAT, v);
 321
 322   return value;
 323 }
 324
 325 GtkCssValue *
 326 _gtk_css_value_new_from_border_style (GtkBorderStyle style)
 327 {
 328   GtkCssValue *value;
 329
 330   value = gtk_css_value_new (GTK_TYPE_BORDER_STYLE);
 331   value->u.gint = style;
 332
 333   return value;
 334 }
 335
 336 GtkCssValue *
 337 _gtk_css_value_new_take_symbolic_color (GtkSymbolicColor *v)
 338 {
 339   GtkCssValue *value;
 340
 341   value = gtk_css_value_new (GTK_TYPE_SYMBOLIC_COLOR);
 342   value->u.ptr = v;
 343
 344   return value;
 345 }
 346
 347 GtkCssValue *
 348 _gtk_css_value_alloc (const GtkCssValueClass *klass,
 349                       gsize                   size)
 350 {
 351   GtkCssValue *value;
 352
 353   value = g_slice_alloc0 (size);
 354
 355   value->class = klass;
 356   value->ref_count = 1;
 357
 358   return value;
 359 }
 360
 361 GtkCssValue *
 362 _gtk_css_value_ref (GtkCssValue *value)
 363 {
 364   g_return_val_if_fail (value != NULL, NULL);
 365
 366   g_atomic_int_add (&value->ref_count, 1);
 367
 368   return value;
 369 }
 370
 371 void
 372 _gtk_css_value_unref (GtkCssValue *value)
 373 {
 374   if (value == NULL)
 375     return;
 376
 377   if (!g_atomic_int_dec_and_test (&value->ref_count))
 378     return;
 379
 380   value->class->free (value);
 381 }
 382
 383 gboolean
 384 _gtk_css_value_equal (const GtkCssValue *value1,
 385                       const GtkCssValue *value2)
 386 {
 387   g_return_val_if_fail (value1 != NULL, FALSE);
 388   g_return_val_if_fail (value2 != NULL, FALSE);
 389
 390   if (value1->class != value2->class)
 391     return FALSE;
 392
 393   return value1->class->equal (value1, value2);
 394 }
 395
 396 GtkCssValue *
 397 _gtk_css_value_transition (GtkCssValue *start,
 398                            GtkCssValue *end,
 399                            double       progress)
 400 {
 401   g_return_val_if_fail (start != NULL, FALSE);
 402   g_return_val_if_fail (end != NULL, FALSE);
 403
 404   if (start->class != end->class)
 405     return NULL;
 406
 407   return start->class->transition (start, end, progress);
 408 }
 409
 410 char *
 411 _gtk_css_value_to_string (const GtkCssValue *value)
 412 {
 413   GString *string;
 414
 415   g_return_val_if_fail (value != NULL, NULL);
 416
 417   string = g_string_new (NULL);
 418   _gtk_css_value_print (value, string);
 419   return g_string_free (string, FALSE);
 420 }
 421
 422 void
 423 _gtk_css_value_print (const GtkCssValue *value,
 424                       GString           *string)
 425 {
 426   g_return_if_fail (value != NULL);
 427   g_return_if_fail (string != NULL);
 428
 429   value->class->print (value, string);
 430 }
 431
 432 GType
 433 _gtk_css_value_get_content_type (const GtkCssValue *value)
 434 {
 435   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_DEFAULT, G_TYPE_NONE);
 436
 437   return value->type;
 438 }
 439
 440 gboolean
 441 _gtk_css_value_holds (const GtkCssValue *value, GType type)
 442 {
 443   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_DEFAULT, FALSE);
 444
 445   return g_type_is_a (value->type, type);
 446 }
 447
 448 static void
 449 fill_gvalue (const GtkCssValue *value,
 450              GValue            *g_value)
 451 {
 452   GType type;
 453
 454   type = value->type;
 455
 456   if (g_type_is_a (type, G_TYPE_OBJECT))
 457     g_value_set_object (g_value, value->u.ptr);
 458   else if (g_type_is_a (type, G_TYPE_BOXED))
 459     g_value_set_boxed (g_value, value->u.ptr);
 460   else if (g_type_is_a (type, G_TYPE_INT))
 461     g_value_set_int (g_value, value->u.gint);
 462   else if (g_type_is_a (type, G_TYPE_UINT))
 463     g_value_set_uint (g_value, value->u.guint);
 464   else if (g_type_is_a (type, G_TYPE_BOOLEAN))
 465     g_value_set_boolean (g_value, value->u.gint);
 466   else if (g_type_is_a (type, G_TYPE_ENUM))
 467     g_value_set_enum (g_value, value->u.gint);
 468   else if (g_type_is_a (type, G_TYPE_FLAGS))
 469     g_value_set_flags (g_value, value->u.guint);
 470   else if (g_type_is_a (type, G_TYPE_STRING))
 471     g_value_set_string (g_value, value->u.ptr);
 472   else if (g_type_is_a (type, G_TYPE_DOUBLE))
 473     g_value_set_double (g_value, value->u.dbl);
 474   else if (g_type_is_a (type, G_TYPE_FLOAT))
 475     g_value_set_float (g_value, value->u.flt);
 476   else
 477     g_value_copy (value->u.ptr, g_value);
 478 }
 479
 480 void
 481 _gtk_css_value_init_gvalue (const GtkCssValue *value,
 482                             GValue            *g_value)
 483 {
 484   if (value != NULL)
 485     {
 486       g_return_if_fail (value->class == &GTK_CSS_VALUE_DEFAULT);
 487       g_value_init (g_value, value->type);
 488       fill_gvalue (value, g_value);
 489     }
 490 }
 491
 492 GtkSymbolicColor *
 493 _gtk_css_value_get_symbolic_color (const GtkCssValue *value)
 494 {
 495   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_SYMBOLIC_COLOR), NULL);
 496   return value->u.ptr;
 497 }
 498
 499 int
 500 _gtk_css_value_get_int (const GtkCssValue *value)
 501 {
 502   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_INT), 0);
 503   return value->u.gint;
 504 }
 505
 506 int
 507 _gtk_css_value_get_enum (const GtkCssValue *value)
 508 {
 509   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_ENUM), 0);
 510   return value->u.gint;
 511 }
 512
 513 gpointer
 514 _gtk_css_value_dup_object (const GtkCssValue *value)
 515 {
 516   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_OBJECT), NULL);
 517   if (value->u.ptr)
 518     return g_object_ref (value->u.ptr);
 519   return NULL;
 520 }
 521
 522 gpointer
 523 _gtk_css_value_get_object (const GtkCssValue *value)
 524 {
 525   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_OBJECT), NULL);
 526   return value->u.ptr;
 527 }
 528
 529 gpointer
 530 _gtk_css_value_get_boxed (const GtkCssValue *value)
 531 {
 532   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_BOXED), NULL);
 533   return value->u.ptr;
 534 }
 535
 536 const char **
 537 _gtk_css_value_get_strv (const GtkCssValue *value)
 538 {
 539   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_STRV), NULL);
 540   return value->u.ptr;
 541 }
 542
 543 GtkBorderStyle
 544 _gtk_css_value_get_border_style (const GtkCssValue *value)
 545 {
 546   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_BORDER_STYLE), 0);
 547   return value->u.gint;
 548 }
 549
 550 const GtkCssBackgroundSize *
 551 _gtk_css_value_get_background_size (const GtkCssValue *value)
 552 {
 553   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BACKGROUND_SIZE), NULL);
 554   return value->u.ptr;
 555 }
 556
 557 const GtkCssBackgroundPosition *
 558 _gtk_css_value_get_background_position (const GtkCssValue *value)
 559 {
 560   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BACKGROUND_POSITION), NULL);
 561   return value->u.ptr;
 562 }
 563
 564 const GtkCssBorderImageRepeat *
 565 _gtk_css_value_get_border_image_repeat (const GtkCssValue *value)
 566 {
 567   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BORDER_IMAGE_REPEAT), NULL);
 568   return value->u.ptr;
 569 }
 570
 571 GtkGradient *
 572 _gtk_css_value_get_gradient (const GtkCssValue *value)
 573 {
 574   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_GRADIENT), NULL);
 575   return value->u.ptr;
 576 }
 577