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_static (&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 : : }
|
