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