Branch data Line data Source code
1 : : /*
2 : : * Copyright © 2010 Novell, Inc.
3 : : *
4 : : * SPDX-License-Identifier: LGPL-2.1-or-later
5 : : *
6 : : * This library is free software; you can redistribute it and/or
7 : : * modify it under the terms of the GNU Lesser General Public
8 : : * License as published by the Free Software Foundation; either
9 : : * version 2.1 of the License, or (at your option) any later version.
10 : : *
11 : : * This library is distributed in the hope that it will be useful,
12 : : * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 : : * Lesser General Public License for more details.
15 : : *
16 : : * You should have received a copy of the GNU Lesser General Public
17 : : * License along with this library; if not, see <http://www.gnu.org/licenses/>.
18 : : *
19 : : * Author: Vincent Untz <vuntz@gnome.org>
20 : : */
21 : :
22 : : #include "config.h"
23 : :
24 : : #include "gsettings-mapping.h"
25 : :
26 : : static GVariant *
27 : 6 : g_settings_set_mapping_int (const GValue *value,
28 : : const GVariantType *expected_type)
29 : : {
30 : 6 : GVariant *variant = NULL;
31 : : gint64 l;
32 : :
33 [ - + + + : 6 : if (G_VALUE_HOLDS_INT (value))
+ + ]
34 : 5 : l = g_value_get_int (value);
35 [ - + + - : 1 : else if (G_VALUE_HOLDS_INT64 (value))
+ - ]
36 : 1 : l = g_value_get_int64 (value);
37 : : else
38 : 0 : return NULL;
39 : :
40 [ + + ]: 6 : if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
41 : : {
42 [ + - + - ]: 1 : if (G_MININT16 <= l && l <= G_MAXINT16)
43 : 1 : variant = g_variant_new_int16 ((gint16) l);
44 : : }
45 [ - + ]: 5 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
46 : : {
47 [ # # # # ]: 0 : if (0 <= l && l <= G_MAXUINT16)
48 : 0 : variant = g_variant_new_uint16 ((guint16) l);
49 : : }
50 [ + + ]: 5 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
51 : : {
52 [ + - + - ]: 4 : if (G_MININT32 <= l && l <= G_MAXINT32)
53 : 4 : variant = g_variant_new_int32 ((gint) l);
54 : : }
55 [ - + ]: 1 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
56 : : {
57 [ # # # # ]: 0 : if (0 <= l && l <= G_MAXUINT32)
58 : 0 : variant = g_variant_new_uint32 ((guint) l);
59 : : }
60 [ + - ]: 1 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
61 : : {
62 : : if (G_MININT64 <= l && l <= G_MAXINT64)
63 : 1 : variant = g_variant_new_int64 ((gint64) l);
64 : : }
65 [ # # ]: 0 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
66 : : {
67 [ # # ]: 0 : if (0 <= l && (guint64) l <= G_MAXUINT64)
68 : 0 : variant = g_variant_new_uint64 ((guint64) l);
69 : : }
70 [ # # ]: 0 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
71 : : {
72 [ # # # # ]: 0 : if (0 <= l && l <= G_MAXUINT32)
73 : 0 : variant = g_variant_new_handle ((guint) l);
74 : : }
75 [ # # ]: 0 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
76 : 0 : variant = g_variant_new_double ((gdouble) l);
77 : :
78 : 6 : return variant;
79 : : }
80 : :
81 : : static GVariant *
82 : 2 : g_settings_set_mapping_float (const GValue *value,
83 : : const GVariantType *expected_type)
84 : : {
85 : 2 : GVariant *variant = NULL;
86 : : gdouble d;
87 : : gint64 l;
88 : :
89 [ - + + - : 2 : if (G_VALUE_HOLDS_DOUBLE (value))
+ - ]
90 : 2 : d = g_value_get_double (value);
91 : : else
92 : 0 : return NULL;
93 : :
94 : 2 : l = (gint64) d;
95 [ - + ]: 2 : if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
96 : : {
97 [ # # # # ]: 0 : if (G_MININT16 <= l && l <= G_MAXINT16)
98 : 0 : variant = g_variant_new_int16 ((gint16) l);
99 : : }
100 [ - + ]: 2 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
101 : : {
102 [ # # # # ]: 0 : if (0 <= l && l <= G_MAXUINT16)
103 : 0 : variant = g_variant_new_uint16 ((guint16) l);
104 : : }
105 [ - + ]: 2 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
106 : : {
107 [ # # # # ]: 0 : if (G_MININT32 <= l && l <= G_MAXINT32)
108 : 0 : variant = g_variant_new_int32 ((gint) l);
109 : : }
110 [ - + ]: 2 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
111 : : {
112 [ # # # # ]: 0 : if (0 <= l && l <= G_MAXUINT32)
113 : 0 : variant = g_variant_new_uint32 ((guint) l);
114 : : }
115 [ - + ]: 2 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
116 : : {
117 : : if (G_MININT64 <= l && l <= G_MAXINT64)
118 : 0 : variant = g_variant_new_int64 ((gint64) l);
119 : : }
120 [ - + ]: 2 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
121 : : {
122 [ # # ]: 0 : if (0 <= l && (guint64) l <= G_MAXUINT64)
123 : 0 : variant = g_variant_new_uint64 ((guint64) l);
124 : : }
125 [ - + ]: 2 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
126 : : {
127 [ # # # # ]: 0 : if (0 <= l && l <= G_MAXUINT32)
128 : 0 : variant = g_variant_new_handle ((guint) l);
129 : : }
130 [ + - ]: 2 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
131 : 2 : variant = g_variant_new_double ((gdouble) d);
132 : :
133 : 2 : return variant;
134 : : }
135 : : static GVariant *
136 : 18 : g_settings_set_mapping_unsigned_int (const GValue *value,
137 : : const GVariantType *expected_type)
138 : : {
139 : 18 : GVariant *variant = NULL;
140 : : guint64 u;
141 : :
142 [ - + + + : 18 : if (G_VALUE_HOLDS_UINT (value))
+ + ]
143 : 15 : u = g_value_get_uint (value);
144 [ - + + - : 3 : else if (G_VALUE_HOLDS_UINT64 (value))
+ - ]
145 : 3 : u = g_value_get_uint64 (value);
146 : : else
147 : 0 : return NULL;
148 : :
149 [ - + ]: 18 : if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT16))
150 : : {
151 [ # # ]: 0 : if (u <= G_MAXINT16)
152 : 0 : variant = g_variant_new_int16 ((gint16) u);
153 : : }
154 [ + + ]: 18 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT16))
155 : : {
156 [ + - ]: 1 : if (u <= G_MAXUINT16)
157 : 1 : variant = g_variant_new_uint16 ((guint16) u);
158 : : }
159 [ - + ]: 17 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT32))
160 : : {
161 [ # # ]: 0 : if (u <= G_MAXINT32)
162 : 0 : variant = g_variant_new_int32 ((gint) u);
163 : : }
164 [ + + ]: 17 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT32))
165 : : {
166 [ + - ]: 14 : if (u <= G_MAXUINT32)
167 : 14 : variant = g_variant_new_uint32 ((guint) u);
168 : : }
169 [ - + ]: 3 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_INT64))
170 : : {
171 [ # # ]: 0 : if (u <= G_MAXINT64)
172 : 0 : variant = g_variant_new_int64 ((gint64) u);
173 : : }
174 [ + - ]: 3 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_UINT64))
175 : : {
176 : : if (u <= G_MAXUINT64)
177 : 3 : variant = g_variant_new_uint64 ((guint64) u);
178 : : }
179 [ # # ]: 0 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_HANDLE))
180 : : {
181 [ # # ]: 0 : if (u <= G_MAXUINT32)
182 : 0 : variant = g_variant_new_handle ((guint) u);
183 : : }
184 [ # # ]: 0 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_DOUBLE))
185 : 0 : variant = g_variant_new_double ((gdouble) u);
186 : :
187 : 18 : return variant;
188 : : }
189 : :
190 : : static gboolean
191 : 7 : g_settings_get_mapping_int (GValue *value,
192 : : GVariant *variant)
193 : : {
194 : : const GVariantType *type;
195 : : gint64 l;
196 : :
197 : 7 : type = g_variant_get_type (variant);
198 : :
199 [ + + ]: 7 : if (g_variant_type_equal (type, G_VARIANT_TYPE_INT16))
200 : 2 : l = g_variant_get_int16 (variant);
201 [ + + ]: 5 : else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT32))
202 : 3 : l = g_variant_get_int32 (variant);
203 [ + - ]: 2 : else if (g_variant_type_equal (type, G_VARIANT_TYPE_INT64))
204 : 2 : l = g_variant_get_int64 (variant);
205 [ # # ]: 0 : else if (g_variant_type_equal (type, G_VARIANT_TYPE_HANDLE))
206 : 0 : l = g_variant_get_handle (variant);
207 : : else
208 : 0 : return FALSE;
209 : :
210 [ - + + + : 7 : if (G_VALUE_HOLDS_INT (value))
+ + ]
211 : : {
212 : 5 : g_value_set_int (value, l);
213 [ + - + - ]: 5 : return (G_MININT32 <= l && l <= G_MAXINT32);
214 : : }
215 [ - + - + : 2 : else if (G_VALUE_HOLDS_UINT (value))
- + ]
216 : : {
217 : 0 : g_value_set_uint (value, l);
218 [ # # # # ]: 0 : return (0 <= l && l <= G_MAXUINT32);
219 : : }
220 [ - + + - : 2 : else if (G_VALUE_HOLDS_INT64 (value))
+ - ]
221 : : {
222 : 2 : g_value_set_int64 (value, l);
223 : 2 : return (G_MININT64 <= l && l <= G_MAXINT64);
224 : : }
225 [ # # # # : 0 : else if (G_VALUE_HOLDS_UINT64 (value))
# # ]
226 : : {
227 : 0 : g_value_set_uint64 (value, l);
228 : 0 : return (0 <= l && (guint64) l <= G_MAXUINT64);
229 : : }
230 [ # # # # : 0 : else if (G_VALUE_HOLDS_DOUBLE (value))
# # ]
231 : : {
232 : 0 : g_value_set_double (value, l);
233 : 0 : return TRUE;
234 : : }
235 : :
236 : 0 : return FALSE;
237 : : }
238 : :
239 : : static gboolean
240 : 3 : g_settings_get_mapping_float (GValue *value,
241 : : GVariant *variant)
242 : : {
243 : : const GVariantType *type;
244 : : gdouble d;
245 : : gint64 l;
246 : :
247 : 3 : type = g_variant_get_type (variant);
248 : :
249 [ + - ]: 3 : if (g_variant_type_equal (type, G_VARIANT_TYPE_DOUBLE))
250 : 3 : d = g_variant_get_double (variant);
251 : : else
252 : 0 : return FALSE;
253 : :
254 : 3 : l = (gint64)d;
255 [ - + - + : 3 : if (G_VALUE_HOLDS_INT (value))
- + ]
256 : : {
257 : 0 : g_value_set_int (value, l);
258 [ # # # # ]: 0 : return (G_MININT32 <= l && l <= G_MAXINT32);
259 : : }
260 [ - + - + : 3 : else if (G_VALUE_HOLDS_UINT (value))
- + ]
261 : : {
262 : 0 : g_value_set_uint (value, l);
263 [ # # # # ]: 0 : return (0 <= l && l <= G_MAXUINT32);
264 : : }
265 [ - + - + : 3 : else if (G_VALUE_HOLDS_INT64 (value))
- + ]
266 : : {
267 : 0 : g_value_set_int64 (value, l);
268 : 0 : return (G_MININT64 <= l && l <= G_MAXINT64);
269 : : }
270 [ - + - + : 3 : else if (G_VALUE_HOLDS_UINT64 (value))
- + ]
271 : : {
272 : 0 : g_value_set_uint64 (value, l);
273 : 0 : return (0 <= l && (guint64) l <= G_MAXUINT64);
274 : : }
275 [ - + + - : 3 : else if (G_VALUE_HOLDS_DOUBLE (value))
+ - ]
276 : : {
277 : 3 : g_value_set_double (value, d);
278 : 3 : return TRUE;
279 : : }
280 : :
281 : 0 : return FALSE;
282 : : }
283 : : static gboolean
284 : 13 : g_settings_get_mapping_unsigned_int (GValue *value,
285 : : GVariant *variant)
286 : : {
287 : : const GVariantType *type;
288 : : guint64 u;
289 : :
290 : 13 : type = g_variant_get_type (variant);
291 : :
292 [ + + ]: 13 : if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT16))
293 : 2 : u = g_variant_get_uint16 (variant);
294 [ + + ]: 11 : else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT32))
295 : 7 : u = g_variant_get_uint32 (variant);
296 [ + - ]: 4 : else if (g_variant_type_equal (type, G_VARIANT_TYPE_UINT64))
297 : 4 : u = g_variant_get_uint64 (variant);
298 : : else
299 : 0 : return FALSE;
300 : :
301 [ - + - + : 13 : if (G_VALUE_HOLDS_INT (value))
- + ]
302 : : {
303 : 0 : g_value_set_int (value, u);
304 : 0 : return (u <= G_MAXINT32);
305 : : }
306 [ - + + + : 13 : else if (G_VALUE_HOLDS_UINT (value))
+ + ]
307 : : {
308 : 9 : g_value_set_uint (value, u);
309 : 9 : return (u <= G_MAXUINT32);
310 : : }
311 [ - + - + : 4 : else if (G_VALUE_HOLDS_INT64 (value))
- + ]
312 : : {
313 : 0 : g_value_set_int64 (value, u);
314 : 0 : return (u <= G_MAXINT64);
315 : : }
316 [ - + + - : 4 : else if (G_VALUE_HOLDS_UINT64 (value))
+ - ]
317 : : {
318 : 4 : g_value_set_uint64 (value, u);
319 : 4 : return (u <= G_MAXUINT64);
320 : : }
321 [ # # # # : 0 : else if (G_VALUE_HOLDS_DOUBLE (value))
# # ]
322 : : {
323 : 0 : g_value_set_double (value, u);
324 : 0 : return TRUE;
325 : : }
326 : :
327 : 0 : return FALSE;
328 : : }
329 : :
330 : : GVariant *
331 : 68 : g_settings_set_mapping (const GValue *value,
332 : : const GVariantType *expected_type,
333 : : gpointer user_data)
334 : : {
335 : : gchar *type_string;
336 : :
337 [ - + + + : 68 : if (G_VALUE_HOLDS_BOOLEAN (value))
+ + ]
338 : : {
339 [ + - ]: 20 : if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BOOLEAN))
340 : 20 : return g_variant_new_boolean (g_value_get_boolean (value));
341 : : }
342 : :
343 [ - + + + : 48 : else if (G_VALUE_HOLDS_CHAR (value) ||
+ + ]
344 [ - + - + : 47 : G_VALUE_HOLDS_UCHAR (value))
- + ]
345 : : {
346 [ + - ]: 1 : if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTE))
347 : : {
348 [ - + + - : 1 : if (G_VALUE_HOLDS_CHAR (value))
+ - ]
349 : 1 : return g_variant_new_byte (g_value_get_schar (value));
350 : : else
351 : 0 : return g_variant_new_byte (g_value_get_uchar (value));
352 : : }
353 : : }
354 : :
355 [ - + + + : 47 : else if (G_VALUE_HOLDS_INT (value) ||
+ + ]
356 [ - + + + : 42 : G_VALUE_HOLDS_INT64 (value))
+ + ]
357 : 6 : return g_settings_set_mapping_int (value, expected_type);
358 : :
359 [ - + + + : 41 : else if (G_VALUE_HOLDS_DOUBLE (value))
+ + ]
360 : 2 : return g_settings_set_mapping_float (value, expected_type);
361 : :
362 [ - + + + : 39 : else if (G_VALUE_HOLDS_UINT (value) ||
+ + ]
363 [ - + + + : 24 : G_VALUE_HOLDS_UINT64 (value))
+ + ]
364 : 18 : return g_settings_set_mapping_unsigned_int (value, expected_type);
365 : :
366 [ - + + + : 21 : else if (G_VALUE_HOLDS_STRING (value))
+ + ]
367 : : {
368 [ + + ]: 11 : if (g_value_get_string (value) == NULL)
369 : 1 : return NULL;
370 [ + + ]: 10 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_STRING))
371 : 9 : return g_variant_new_string (g_value_get_string (value));
372 [ + - ]: 1 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_BYTESTRING))
373 : 1 : return g_variant_new_bytestring (g_value_get_string (value));
374 [ # # ]: 0 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_OBJECT_PATH))
375 : 0 : return g_variant_new_object_path (g_value_get_string (value));
376 [ # # ]: 0 : else if (g_variant_type_equal (expected_type, G_VARIANT_TYPE_SIGNATURE))
377 : 0 : return g_variant_new_signature (g_value_get_string (value));
378 : : }
379 : :
380 [ - + + + : 10 : else if (G_VALUE_HOLDS (value, G_TYPE_STRV))
+ + ]
381 : : {
382 [ - + ]: 1 : if (g_value_get_boxed (value) == NULL)
383 : 0 : return NULL;
384 : 1 : return g_variant_new_strv ((const gchar **) g_value_get_boxed (value),
385 : : -1);
386 : : }
387 : :
388 [ - + - + : 9 : else if (G_VALUE_HOLDS_ENUM (value))
+ + ]
389 : : {
390 : : GEnumValue *enumval;
391 : : GEnumClass *eclass;
392 : :
393 : : /* GParamSpecEnum holds a ref on the class so we just peek... */
394 : 8 : eclass = g_type_class_peek (G_VALUE_TYPE (value));
395 : 8 : enumval = g_enum_get_value (eclass, g_value_get_enum (value));
396 : :
397 [ + - ]: 8 : if (enumval)
398 : 8 : return g_variant_new_string (enumval->value_nick);
399 : : else
400 : 0 : return NULL;
401 : : }
402 : :
403 [ - + - + : 1 : else if (G_VALUE_HOLDS_FLAGS (value))
+ - ]
404 : : {
405 : : GVariantBuilder builder;
406 : : GFlagsValue *flagsval;
407 : : GFlagsClass *fclass;
408 : : guint flags;
409 : :
410 : 1 : fclass = g_type_class_peek (G_VALUE_TYPE (value));
411 : 1 : flags = g_value_get_flags (value);
412 : :
413 : 1 : g_variant_builder_init (&builder, G_VARIANT_TYPE ("as"));
414 [ + + ]: 2 : while (flags)
415 : : {
416 : 1 : flagsval = g_flags_get_first_value (fclass, flags);
417 : :
418 [ - + ]: 1 : if (flagsval == NULL)
419 : : {
420 : 0 : g_variant_builder_clear (&builder);
421 : 0 : return NULL;
422 : : }
423 : :
424 : 1 : g_variant_builder_add (&builder, "s", flagsval->value_nick);
425 : 1 : flags &= ~flagsval->value;
426 : : }
427 : :
428 : 1 : return g_variant_builder_end (&builder);
429 : : }
430 : :
431 : 0 : type_string = g_variant_type_dup_string (expected_type);
432 : 0 : g_critical ("No GSettings bind handler for type \"%s\".", type_string);
433 : 0 : g_free (type_string);
434 : :
435 : 0 : return NULL;
436 : : }
437 : :
438 : : gboolean
439 : 50 : g_settings_get_mapping (GValue *value,
440 : : GVariant *variant,
441 : : gpointer user_data)
442 : : {
443 [ + + ]: 50 : if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BOOLEAN))
444 : : {
445 [ - + + - : 7 : if (!G_VALUE_HOLDS_BOOLEAN (value))
- + ]
446 : 0 : return FALSE;
447 : 7 : g_value_set_boolean (value, g_variant_get_boolean (variant));
448 : 7 : return TRUE;
449 : : }
450 : :
451 [ + + ]: 43 : else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTE))
452 : : {
453 [ - + - + : 2 : if (G_VALUE_HOLDS_UCHAR (value))
- + ]
454 : 0 : g_value_set_uchar (value, g_variant_get_byte (variant));
455 [ - + + - : 2 : else if (G_VALUE_HOLDS_CHAR (value))
+ - ]
456 : 2 : g_value_set_schar (value, (gint8)g_variant_get_byte (variant));
457 : : else
458 : 0 : return FALSE;
459 : 2 : return TRUE;
460 : : }
461 : :
462 [ + + + + ]: 80 : else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_INT16) ||
463 [ + + ]: 75 : g_variant_is_of_type (variant, G_VARIANT_TYPE_INT32) ||
464 [ - + ]: 70 : g_variant_is_of_type (variant, G_VARIANT_TYPE_INT64) ||
465 : 34 : g_variant_is_of_type (variant, G_VARIANT_TYPE_HANDLE))
466 : 7 : return g_settings_get_mapping_int (value, variant);
467 : :
468 [ + + ]: 34 : else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_DOUBLE))
469 : 3 : return g_settings_get_mapping_float (value, variant);
470 : :
471 [ + + + + ]: 60 : else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT16) ||
472 [ + + ]: 51 : g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT32) ||
473 : 22 : g_variant_is_of_type (variant, G_VARIANT_TYPE_UINT64))
474 : 13 : return g_settings_get_mapping_unsigned_int (value, variant);
475 : :
476 [ + + + - ]: 24 : else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_STRING) ||
477 [ - + ]: 12 : g_variant_is_of_type (variant, G_VARIANT_TYPE_OBJECT_PATH) ||
478 : 6 : g_variant_is_of_type (variant, G_VARIANT_TYPE_SIGNATURE))
479 : : {
480 [ - + + + : 12 : if (G_VALUE_HOLDS_STRING (value))
+ + ]
481 : : {
482 : 7 : g_value_set_string (value, g_variant_get_string (variant, NULL));
483 : 7 : return TRUE;
484 : : }
485 : :
486 [ - + - + : 5 : else if (G_VALUE_HOLDS_ENUM (value))
+ - ]
487 : : {
488 : : GEnumClass *eclass;
489 : : GEnumValue *evalue;
490 : : const gchar *nick;
491 : :
492 : : /* GParamSpecEnum holds a ref on the class so we just peek... */
493 : 5 : eclass = g_type_class_peek (G_VALUE_TYPE (value));
494 : 5 : nick = g_variant_get_string (variant, NULL);
495 : 5 : evalue = g_enum_get_value_by_nick (eclass, nick);
496 : :
497 [ + - ]: 5 : if (evalue)
498 : : {
499 : 5 : g_value_set_enum (value, evalue->value);
500 : 5 : return TRUE;
501 : : }
502 : :
503 : 0 : g_warning ("Unable to look up enum nick ‘%s’ via GType", nick);
504 : 0 : return FALSE;
505 : : }
506 : : }
507 [ + + ]: 6 : else if (g_variant_is_of_type (variant, G_VARIANT_TYPE ("as")))
508 : : {
509 [ - + + + : 5 : if (G_VALUE_HOLDS (value, G_TYPE_STRV))
+ + ]
510 : : {
511 : 3 : g_value_take_boxed (value, g_variant_dup_strv (variant, NULL));
512 : 3 : return TRUE;
513 : : }
514 : :
515 [ - + - + : 2 : else if (G_VALUE_HOLDS_FLAGS (value))
+ - ]
516 : : {
517 : : GFlagsClass *fclass;
518 : : GFlagsValue *fvalue;
519 : : const gchar *nick;
520 : : GVariantIter iter;
521 : 2 : guint flags = 0;
522 : :
523 : 2 : fclass = g_type_class_peek (G_VALUE_TYPE (value));
524 : :
525 : 2 : g_variant_iter_init (&iter, variant);
526 [ + + ]: 6 : while (g_variant_iter_next (&iter, "&s", &nick))
527 : : {
528 : 4 : fvalue = g_flags_get_value_by_nick (fclass, nick);
529 : :
530 [ + - ]: 4 : if (fvalue)
531 : 4 : flags |= fvalue->value;
532 : :
533 : : else
534 : : {
535 : 0 : g_warning ("Unable to lookup flags nick '%s' via GType",
536 : : nick);
537 : 0 : return FALSE;
538 : : }
539 : : }
540 : :
541 : 2 : g_value_set_flags (value, flags);
542 : 2 : return TRUE;
543 : : }
544 : : }
545 [ + - ]: 1 : else if (g_variant_is_of_type (variant, G_VARIANT_TYPE_BYTESTRING))
546 : : {
547 : 1 : g_value_set_string (value, g_variant_get_bytestring (variant));
548 : 1 : return TRUE;
549 : : }
550 : :
551 : 0 : g_critical ("No GSettings bind handler for type \"%s\".",
552 : : g_variant_get_type_string (variant));
553 : :
554 : 0 : return FALSE;
555 : : }
556 : :
557 : : gboolean
558 : 25 : g_settings_mapping_is_compatible (GType gvalue_type,
559 : : const GVariantType *variant_type)
560 : : {
561 : 25 : gboolean ok = FALSE;
562 : :
563 [ + + ]: 25 : if (gvalue_type == G_TYPE_BOOLEAN)
564 : 3 : ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE_BOOLEAN);
565 [ + + - + ]: 22 : else if (gvalue_type == G_TYPE_CHAR ||
566 : : gvalue_type == G_TYPE_UCHAR)
567 : 1 : ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE_BYTE);
568 [ + + + + ]: 21 : else if (gvalue_type == G_TYPE_INT ||
569 [ + + ]: 13 : gvalue_type == G_TYPE_UINT ||
570 [ + + ]: 12 : gvalue_type == G_TYPE_INT64 ||
571 [ + + ]: 10 : gvalue_type == G_TYPE_UINT64 ||
572 : : gvalue_type == G_TYPE_DOUBLE)
573 [ + + ]: 35 : ok = (g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT16) ||
574 [ + + ]: 21 : g_variant_type_equal (variant_type, G_VARIANT_TYPE_UINT16) ||
575 [ + + ]: 17 : g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT32) ||
576 [ + + ]: 11 : g_variant_type_equal (variant_type, G_VARIANT_TYPE_UINT32) ||
577 [ + + ]: 7 : g_variant_type_equal (variant_type, G_VARIANT_TYPE_INT64) ||
578 [ + - ]: 4 : g_variant_type_equal (variant_type, G_VARIANT_TYPE_UINT64) ||
579 [ + + + - ]: 24 : g_variant_type_equal (variant_type, G_VARIANT_TYPE_HANDLE) ||
580 : 1 : g_variant_type_equal (variant_type, G_VARIANT_TYPE_DOUBLE));
581 [ + + ]: 9 : else if (gvalue_type == G_TYPE_STRING)
582 [ - + ]: 13 : ok = (g_variant_type_equal (variant_type, G_VARIANT_TYPE_STRING) ||
583 [ - - ]: 1 : g_variant_type_equal (variant_type, G_VARIANT_TYPE ("ay")) ||
584 [ + + - - ]: 7 : g_variant_type_equal (variant_type, G_VARIANT_TYPE_OBJECT_PATH) ||
585 : 0 : g_variant_type_equal (variant_type, G_VARIANT_TYPE_SIGNATURE));
586 [ + + ]: 3 : else if (gvalue_type == G_TYPE_STRV)
587 : 1 : ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE ("as"));
588 [ + + ]: 2 : else if (G_TYPE_IS_ENUM (gvalue_type))
589 : 1 : ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE_STRING);
590 [ + - ]: 1 : else if (G_TYPE_IS_FLAGS (gvalue_type))
591 : 1 : ok = g_variant_type_equal (variant_type, G_VARIANT_TYPE ("as"));
592 : :
593 : 25 : return ok;
594 : : }
|
