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_take_binding_sets (GPtrArray *array)
 261 {
 262   GtkCssValue *value;
 263
 264   value = gtk_css_value_new (G_TYPE_PTR_ARRAY);
 265   value->u.ptr = array;
 266
 267   return value;
 268 }
 269
 270 GtkCssValue *
 271 _gtk_css_value_new_from_color (const GdkColor *v)
 272 {
 273   GtkCssValue *value;
 274
 275   value = gtk_css_value_new (GDK_TYPE_COLOR);
 276   value->u.ptr = g_boxed_copy0 (GDK_TYPE_COLOR, v);
 277
 278   return value;
 279 }
 280
 281 GtkCssValue *
 282 _gtk_css_value_new_from_background_size (const GtkCssBackgroundSize *v)
 283 {
 284   GtkCssValue *value;
 285
 286   value = gtk_css_value_new (GTK_TYPE_CSS_BACKGROUND_SIZE);
 287   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BACKGROUND_SIZE, v);
 288
 289   return value;
 290 }
 291
 292 GtkCssValue *
 293 _gtk_css_value_new_from_border_image_repeat (const GtkCssBorderImageRepeat *v)
 294 {
 295   GtkCssValue *value;
 296
 297   value = gtk_css_value_new (GTK_TYPE_CSS_BORDER_IMAGE_REPEAT);
 298   value->u.ptr = g_boxed_copy0 (GTK_TYPE_CSS_BORDER_IMAGE_REPEAT, v);
 299
 300   return value;
 301 }
 302
 303 GtkCssValue *
 304 _gtk_css_value_new_from_border_style (GtkBorderStyle style)
 305 {
 306   GtkCssValue *value;
 307
 308   value = gtk_css_value_new (GTK_TYPE_BORDER_STYLE);
 309   value->u.gint = style;
 310
 311   return value;
 312 }
 313
 314 GtkCssValue *
 315 _gtk_css_value_new_take_symbolic_color (GtkSymbolicColor *v)
 316 {
 317   GtkCssValue *value;
 318
 319   value = gtk_css_value_new (GTK_TYPE_SYMBOLIC_COLOR);
 320   value->u.ptr = v;
 321
 322   return value;
 323 }
 324
 325 GtkCssValue *
 326 _gtk_css_value_alloc (const GtkCssValueClass *klass,
 327                       gsize                   size)
 328 {
 329   GtkCssValue *value;
 330
 331   value = g_slice_alloc0 (size);
 332
 333   value->class = klass;
 334   value->ref_count = 1;
 335
 336   return value;
 337 }
 338
 339 GtkCssValue *
 340 _gtk_css_value_ref (GtkCssValue *value)
 341 {
 342   g_return_val_if_fail (value != NULL, NULL);
 343
 344   g_atomic_int_add (&value->ref_count, 1);
 345
 346   return value;
 347 }
 348
 349 void
 350 _gtk_css_value_unref (GtkCssValue *value)
 351 {
 352   if (value == NULL)
 353     return;
 354
 355   if (!g_atomic_int_dec_and_test (&value->ref_count))
 356     return;
 357
 358   value->class->free (value);
 359 }
 360
 361 gboolean
 362 _gtk_css_value_equal (const GtkCssValue *value1,
 363                       const GtkCssValue *value2)
 364 {
 365   g_return_val_if_fail (value1 != NULL, FALSE);
 366   g_return_val_if_fail (value2 != NULL, FALSE);
 367
 368   if (value1->class != value2->class)
 369     return FALSE;
 370
 371   return value1->class->equal (value1, value2);
 372 }
 373
 374 GtkCssValue *
 375 _gtk_css_value_transition (GtkCssValue *start,
 376                            GtkCssValue *end,
 377                            double       progress)
 378 {
 379   g_return_val_if_fail (start != NULL, FALSE);
 380   g_return_val_if_fail (end != NULL, FALSE);
 381
 382   if (start->class != end->class)
 383     return NULL;
 384
 385   return start->class->transition (start, end, progress);
 386 }
 387
 388 char *
 389 _gtk_css_value_to_string (const GtkCssValue *value)
 390 {
 391   GString *string;
 392
 393   g_return_val_if_fail (value != NULL, NULL);
 394
 395   string = g_string_new (NULL);
 396   _gtk_css_value_print (value, string);
 397   return g_string_free (string, FALSE);
 398 }
 399
 400 void
 401 _gtk_css_value_print (const GtkCssValue *value,
 402                       GString           *string)
 403 {
 404   g_return_if_fail (value != NULL);
 405   g_return_if_fail (string != NULL);
 406
 407   value->class->print (value, string);
 408 }
 409
 410 GType
 411 _gtk_css_value_get_content_type (const GtkCssValue *value)
 412 {
 413   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_DEFAULT, G_TYPE_NONE);
 414
 415   return value->type;
 416 }
 417
 418 gboolean
 419 _gtk_css_value_holds (const GtkCssValue *value, GType type)
 420 {
 421   g_return_val_if_fail (value->class == &GTK_CSS_VALUE_DEFAULT, FALSE);
 422
 423   return g_type_is_a (value->type, type);
 424 }
 425
 426 static void
 427 fill_gvalue (const GtkCssValue *value,
 428              GValue            *g_value)
 429 {
 430   GType type;
 431
 432   type = value->type;
 433
 434   if (g_type_is_a (type, G_TYPE_OBJECT))
 435     g_value_set_object (g_value, value->u.ptr);
 436   else if (g_type_is_a (type, G_TYPE_BOXED))
 437     g_value_set_boxed (g_value, value->u.ptr);
 438   else if (g_type_is_a (type, G_TYPE_INT))
 439     g_value_set_int (g_value, value->u.gint);
 440   else if (g_type_is_a (type, G_TYPE_UINT))
 441     g_value_set_uint (g_value, value->u.guint);
 442   else if (g_type_is_a (type, G_TYPE_BOOLEAN))
 443     g_value_set_boolean (g_value, value->u.gint);
 444   else if (g_type_is_a (type, G_TYPE_ENUM))
 445     g_value_set_enum (g_value, value->u.gint);
 446   else if (g_type_is_a (type, G_TYPE_FLAGS))
 447     g_value_set_flags (g_value, value->u.guint);
 448   else if (g_type_is_a (type, G_TYPE_STRING))
 449     g_value_set_string (g_value, value->u.ptr);
 450   else if (g_type_is_a (type, G_TYPE_DOUBLE))
 451     g_value_set_double (g_value, value->u.dbl);
 452   else if (g_type_is_a (type, G_TYPE_FLOAT))
 453     g_value_set_float (g_value, value->u.flt);
 454   else
 455     g_value_copy (value->u.ptr, g_value);
 456 }
 457
 458 void
 459 _gtk_css_value_init_gvalue (const GtkCssValue *value,
 460                             GValue            *g_value)
 461 {
 462   if (value != NULL)
 463     {
 464       g_return_if_fail (value->class == &GTK_CSS_VALUE_DEFAULT);
 465       g_value_init (g_value, value->type);
 466       fill_gvalue (value, g_value);
 467     }
 468 }
 469
 470 GtkSymbolicColor *
 471 _gtk_css_value_get_symbolic_color (const GtkCssValue *value)
 472 {
 473   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_SYMBOLIC_COLOR), NULL);
 474   return value->u.ptr;
 475 }
 476
 477 int
 478 _gtk_css_value_get_int (const GtkCssValue *value)
 479 {
 480   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_INT), 0);
 481   return value->u.gint;
 482 }
 483
 484 int
 485 _gtk_css_value_get_enum (const GtkCssValue *value)
 486 {
 487   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_ENUM), 0);
 488   return value->u.gint;
 489 }
 490
 491 gpointer
 492 _gtk_css_value_dup_object (const GtkCssValue *value)
 493 {
 494   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_OBJECT), NULL);
 495   if (value->u.ptr)
 496     return g_object_ref (value->u.ptr);
 497   return NULL;
 498 }
 499
 500 gpointer
 501 _gtk_css_value_get_object (const GtkCssValue *value)
 502 {
 503   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_OBJECT), NULL);
 504   return value->u.ptr;
 505 }
 506
 507 gpointer
 508 _gtk_css_value_get_boxed (const GtkCssValue *value)
 509 {
 510   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_BOXED), NULL);
 511   return value->u.ptr;
 512 }
 513
 514 const char **
 515 _gtk_css_value_get_strv (const GtkCssValue *value)
 516 {
 517   g_return_val_if_fail (_gtk_css_value_holds (value, G_TYPE_STRV), NULL);
 518   return value->u.ptr;
 519 }
 520
 521 GtkBorderStyle
 522 _gtk_css_value_get_border_style (const GtkCssValue *value)
 523 {
 524   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_BORDER_STYLE), 0);
 525   return value->u.gint;
 526 }
 527
 528 const GtkCssBackgroundSize *
 529 _gtk_css_value_get_background_size (const GtkCssValue *value)
 530 {
 531   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BACKGROUND_SIZE), NULL);
 532   return value->u.ptr;
 533 }
 534
 535 const GtkCssBorderImageRepeat *
 536 _gtk_css_value_get_border_image_repeat (const GtkCssValue *value)
 537 {
 538   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_CSS_BORDER_IMAGE_REPEAT), NULL);
 539   return value->u.ptr;
 540 }
 541
 542 GtkGradient *
 543 _gtk_css_value_get_gradient (const GtkCssValue *value)
 544 {
 545   g_return_val_if_fail (_gtk_css_value_holds (value, GTK_TYPE_GRADIENT), NULL);
 546   return value->u.ptr;
 547 }
 548