← Back to branch summary

~ubuntu-branches/ubuntu/quantal/ibus/quantal

« back to all changes in this revision

Viewing changes to src/ibusserializable.c

  • Committer: Bazaar Package Importer
  • Author(s): Barry Warsaw
  • Date: 2011-08-11 17:00:57 UTC
  • mfrom: (6.2.14 sid)
  • Revision ID: james.westby@ubuntu.com-20110811170057-6dmbfs4s3cchzl7x
Tags: 1.3.99.20110419-1ubuntu1
https://launchpad.net/bugs/457632
* Merge with Debian unstable.  Remaining Ubuntu changes:
  - Indicator support:
    + Add 05_appindicator.patch: Use an indicator rather than a notification
      icon.
    + debian/control: Recommend python-appindicator.
  - debian/control: Install im-switch instead of im-config by default.
  - debian/README.source: Removed, it was outdated and no longer correct
  - debian/patches/01_ubuntu_desktop: Fix "Desktop entry needs the
    X-Ubuntu-Gettext-Domain key"  (LP: #457632)
  - debian/patches/02_title_update.patch: Rename "IBus Preferences" to
    "Keyboard Input Methods"
  - debian/patches/06_locale_parser.patch: Cherry-picked from upstream.

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/ibusserializable.c
19
19
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20
20
 * Boston, MA 02111-1307, USA.
21
21
 */
22
 
#include <dbus/dbus.h>
23
22
#include "ibusinternal.h"
24
23
#include "ibusserializable.h"
25
24
 
30
29
    LAST_SIGNAL,
31
30
};
32
31
 
33
 
typedef struct _IBusSerializablePrivate IBusSerializablePrivate;
34
32
struct _IBusSerializablePrivate {
35
33
    GData   *attachments;
36
34
};
38
36
// static guint    object_signals[LAST_SIGNAL] = { 0 };
39
37
 
40
38
/* functions prototype */
41
 
static void      ibus_serializable_base_init        (IBusSerializableClass  *klass);
42
 
static void      ibus_serializable_base_fini        (IBusSerializableClass  *klass);
43
 
static void      ibus_serializable_class_init       (IBusSerializableClass  *klass);
 
39
static void      ibus_serializable_base_init        (IBusSerializableClass  *class);
 
40
static void      ibus_serializable_base_fini        (IBusSerializableClass  *class);
 
41
static void      ibus_serializable_class_init       (IBusSerializableClass  *class);
44
42
static void      ibus_serializable_init             (IBusSerializable       *object);
45
43
static void      ibus_serializable_destroy          (IBusSerializable       *object);
46
44
static gboolean  ibus_serializable_real_serialize   (IBusSerializable       *object,
47
 
                                                     IBusMessageIter        *iter);
48
 
static gboolean  ibus_serializable_real_deserialize (IBusSerializable       *object,
49
 
                                                     IBusMessageIter        *iter);
 
45
                                                     GVariantBuilder        *builder);
 
46
static gint      ibus_serializable_real_deserialize (IBusSerializable       *object,
 
47
                                                     GVariant               *variant);
50
48
static gboolean  ibus_serializable_real_copy        (IBusSerializable       *dest,
51
49
                                                     const IBusSerializable *src);
52
50
 
86
84
}
87
85
 
88
86
static void
89
 
ibus_serializable_base_init     (IBusSerializableClass *klass)
90
 
{
91
 
    /* init signature */
92
 
    klass->signature = g_string_new ("a{sv}");
93
 
}
94
 
 
95
 
static void
96
 
ibus_serializable_base_fini     (IBusSerializableClass *klass)
97
 
{
98
 
    /* init signature */
99
 
    g_string_free (klass->signature, TRUE);
100
 
    klass->signature = NULL;
101
 
}
102
 
 
103
 
static void
104
 
ibus_serializable_class_init     (IBusSerializableClass *klass)
105
 
{
106
 
    IBusObjectClass *object_class = IBUS_OBJECT_CLASS (klass);
107
 
 
108
 
    parent_class = (IBusObjectClass *) g_type_class_peek_parent (klass);
109
 
 
110
 
    g_type_class_add_private (klass, sizeof (IBusSerializablePrivate));
 
87
ibus_serializable_base_init     (IBusSerializableClass *class)
 
88
{
 
89
}
 
90
 
 
91
static void
 
92
ibus_serializable_base_fini     (IBusSerializableClass *class)
 
93
{
 
94
}
 
95
 
 
96
static void
 
97
ibus_serializable_class_init     (IBusSerializableClass *class)
 
98
{
 
99
    IBusObjectClass *object_class = IBUS_OBJECT_CLASS (class);
 
100
 
 
101
    parent_class = (IBusObjectClass *) g_type_class_peek_parent (class);
 
102
 
 
103
    g_type_class_add_private (class, sizeof (IBusSerializablePrivate));
111
104
 
112
105
    object_class->destroy = (IBusObjectDestroyFunc) ibus_serializable_destroy;
113
106
 
114
 
    klass->serialize = ibus_serializable_real_serialize;
115
 
    klass->deserialize = ibus_serializable_real_deserialize;
116
 
    klass->copy = ibus_serializable_real_copy;
117
 
}
118
 
 
119
 
static void
120
 
ibus_serializable_init (IBusSerializable *object)
121
 
{
122
 
    IBusSerializablePrivate *priv;
123
 
    priv = IBUS_SERIALIZABLE_GET_PRIVATE (object);
124
 
 
125
 
    priv->attachments = NULL;
126
 
    g_datalist_init (&priv->attachments);
127
 
}
128
 
 
129
 
static void
130
 
ibus_serializable_destroy (IBusSerializable *object)
131
 
{
132
 
    IBusSerializablePrivate *priv;
133
 
    priv = IBUS_SERIALIZABLE_GET_PRIVATE (object);
134
 
 
135
 
    g_datalist_clear (&priv->attachments);
136
 
 
137
 
    parent_class->destroy (IBUS_OBJECT (object));
 
107
    class->serialize = ibus_serializable_real_serialize;
 
108
    class->deserialize = ibus_serializable_real_deserialize;
 
109
    class->copy = ibus_serializable_real_copy;
 
110
}
 
111
 
 
112
static void
 
113
ibus_serializable_init (IBusSerializable *serializable)
 
114
{
 
115
    serializable->priv = IBUS_SERIALIZABLE_GET_PRIVATE (serializable);
 
116
    serializable->priv->attachments = NULL;
 
117
    g_datalist_init (&serializable->priv->attachments);
 
118
}
 
119
 
 
120
static void
 
121
ibus_serializable_destroy (IBusSerializable *serializable)
 
122
{
 
123
    g_datalist_clear (&serializable->priv->attachments);
 
124
    parent_class->destroy (IBUS_OBJECT (serializable));
138
125
}
139
126
 
140
127
static GValue *
156
143
    g_slice_free (GValue, value);
157
144
}
158
145
 
159
 
static gboolean
160
 
_g_value_serialize (GValue          *value,
161
 
                    IBusMessageIter *iter)
 
146
static GVariant *
 
147
_g_value_serialize (GValue          *value)
162
148
{
163
 
    gboolean retval;
164
149
    GType type;
165
150
 
166
151
    type = G_VALUE_TYPE (value);
167
152
    g_return_val_if_fail (type != G_TYPE_INVALID, FALSE);
168
153
 
169
 
 
170
154
    if (g_type_is_a (type, IBUS_TYPE_SERIALIZABLE)) {
171
155
        IBusSerializable *object;
172
156
        object = IBUS_SERIALIZABLE (g_value_get_object (value));
173
 
        retval = ibus_message_iter_append (iter,
174
 
                                           type,
175
 
                                           &object);
176
 
        g_return_val_if_fail (retval, FALSE);
177
 
        return TRUE;
 
157
        return ibus_serializable_serialize (object);
178
158
    }
179
159
 
180
160
    typedef const gchar *gstring;
181
161
    switch (type) {
182
 
#define CASE_ENTRY(TYPE, _type, signature)                                          \
183
 
    case G_TYPE_##TYPE:                                                             \
184
 
        {                                                                           \
185
 
            g##_type v;                                                             \
186
 
            IBusMessageIter variant_iter;                                           \
187
 
                                                                                    \
188
 
            retval = ibus_message_iter_open_container (iter,                        \
189
 
                                                       IBUS_TYPE_VARIANT,           \
190
 
                                                       signature,                   \
191
 
                                                       &variant_iter);              \
192
 
            g_return_val_if_fail (retval, FALSE);                                   \
193
 
                                                                                    \
194
 
            v = g_value_get_##_type (value);                                        \
195
 
            retval = ibus_message_iter_append (&variant_iter,                       \
196
 
                                                G_TYPE_##TYPE,                      \
197
 
                                                &v);                                \
198
 
            g_return_val_if_fail (retval, FALSE);                                   \
199
 
                                                                                    \
200
 
            retval = ibus_message_iter_close_container (iter, &variant_iter);       \
201
 
            g_return_val_if_fail (retval, FALSE);                                   \
202
 
                                                                                    \
203
 
            return TRUE;                                                            \
 
162
#define CASE_ENTRY(TYPE, _type, signature)                              \
 
163
    case G_TYPE_##TYPE:                                                 \
 
164
        {                                                               \
 
165
            g##_type v;                                                 \
 
166
            v = g_value_get_##_type (value);                            \
 
167
            return g_variant_new ("v", g_variant_new (signature, v));   \
204
168
        }
205
169
    CASE_ENTRY(CHAR, char, "y");
206
170
    CASE_ENTRY(BOOLEAN, boolean, "b");
214
178
#undef CASE_ENTRY
215
179
    }
216
180
 
217
 
    g_return_val_if_reached (FALSE);
 
181
    g_assert_not_reached ();
218
182
}
219
183
 
220
184
static GValue *
221
 
_g_value_deserialize (IBusMessageIter *iter)
 
185
_g_value_deserialize (GVariant *variant)
222
186
{
223
 
    IBusMessageIter variant_iter;
224
 
    gboolean retval;
225
187
    GValue *value = NULL;
226
 
    GType type;
227
 
 
228
 
    retval = ibus_message_iter_recurse (iter, IBUS_TYPE_VARIANT, &variant_iter);
229
 
    g_return_val_if_fail (retval, NULL);
230
 
 
231
 
    type = ibus_message_iter_get_arg_type (&variant_iter);
232
 
 
233
 
    if (type == IBUS_TYPE_STRUCT) {
 
188
    const GVariantType *type;
 
189
 
 
190
    type = g_variant_get_type (variant);
 
191
    if (type == G_VARIANT_TYPE_TUPLE) {
234
192
        IBusSerializable *object;
235
 
        retval = ibus_message_iter_get (iter, IBUS_TYPE_SERIALIZABLE, &object);
236
 
        g_return_val_if_fail (retval, NULL);
237
 
        ibus_message_iter_next (iter);
238
 
 
 
193
        object = ibus_serializable_deserialize (variant);
239
194
        value = g_slice_new0 (GValue);
240
195
        g_value_init (value, G_OBJECT_TYPE (object));
241
196
        g_value_take_object (value, object);
243
198
    }
244
199
 
245
200
    typedef gchar *gstring;
246
 
    switch (type) {
247
 
#define CASE_ENTRY(TYPE, _type)                                 \
248
 
    case G_TYPE_##TYPE:                                         \
249
 
        {                                                       \
250
 
            g##_type v;                                         \
251
 
            ibus_message_iter_get_basic (&variant_iter, &v);    \
252
 
            ibus_message_iter_next (&variant_iter);             \
253
 
            value = g_slice_new0 (GValue);                      \
254
 
            g_value_init (value, G_TYPE_##TYPE);                \
255
 
            g_value_set_##_type (value, v);                     \
256
 
            ibus_message_iter_next (iter);                      \
257
 
            return value;                                       \
258
 
        }
259
 
    CASE_ENTRY(CHAR, char);
260
 
    CASE_ENTRY(BOOLEAN, boolean);
261
 
    CASE_ENTRY(INT, int);
262
 
    CASE_ENTRY(UINT, uint);
263
 
    CASE_ENTRY(INT64, int64);
264
 
    CASE_ENTRY(UINT64, uint64);
265
 
    CASE_ENTRY(FLOAT, float);
266
 
    CASE_ENTRY(DOUBLE, double);
267
 
    CASE_ENTRY(STRING, string);
 
201
#define IF_ENTRY(TYPE, _type, signature)                    \
 
202
    if (type ==  G_VARIANT_TYPE_##TYPE) {                   \
 
203
        g##_type v;                                         \
 
204
        g_variant_get (variant, signature, &v);             \
 
205
        value = g_slice_new0 (GValue);                      \
 
206
        g_value_init (value, G_TYPE_##TYPE);                \
 
207
        g_value_set_##_type (value, v);                     \
 
208
        return value;                                       \
268
209
    }
 
210
#define G_VARIANT_TYPE_CHAR G_VARIANT_TYPE_BYTE
 
211
    IF_ENTRY(CHAR, char, "y");
 
212
#undef G_VARIANT_TYPE_CHAR
 
213
    IF_ENTRY(BOOLEAN, boolean, "b");
 
214
#define G_VARIANT_TYPE_INT G_VARIANT_TYPE_INT32
 
215
#define G_VARIANT_TYPE_UINT G_VARIANT_TYPE_UINT32
 
216
    IF_ENTRY(INT, int, "i");
 
217
    IF_ENTRY(UINT, uint, "u");
 
218
#undef G_VARIANT_TYPE_INT
 
219
#undef G_VARIANT_TYPE_UINT
 
220
    IF_ENTRY(INT64, int64, "x");
 
221
    IF_ENTRY(UINT64, uint64, "t");
 
222
    IF_ENTRY(DOUBLE, double, "d");
 
223
    IF_ENTRY(STRING, string, "s");
 
224
 
269
225
    g_return_val_if_reached (NULL);
270
226
}
271
227
 
272
228
static void
273
229
_serialize_cb (GQuark           key,
274
230
               GValue          *value,
275
 
               IBusMessageIter *iter)
 
231
               GVariantBuilder *array)
276
232
{
277
 
    IBusMessageIter dict_entry;
278
 
    gboolean retval;
279
 
    const gchar *name;
280
 
 
281
 
    retval = ibus_message_iter_open_container (iter,
282
 
                                               IBUS_TYPE_DICT_ENTRY,
283
 
                                               NULL,
284
 
                                               &dict_entry);
285
 
    g_return_if_fail (retval);
286
 
    name = g_quark_to_string (key);
287
 
    retval = ibus_message_iter_append (&dict_entry,
288
 
                                       G_TYPE_STRING,
289
 
                                       &name);
290
 
    g_return_if_fail (retval);
291
 
 
292
 
    retval = _g_value_serialize (value, &dict_entry);
293
 
    g_return_if_fail (retval);
294
 
 
295
 
    retval = ibus_message_iter_close_container (iter, &dict_entry);
296
 
    g_return_if_fail (retval);
 
233
    g_variant_builder_add (array, "{sv}",
 
234
                g_quark_to_string (key), _g_value_serialize (value));
297
235
}
298
236
 
299
237
static gboolean
300
 
ibus_serializable_real_serialize (IBusSerializable *object,
301
 
                                  IBusMessageIter  *iter)
 
238
ibus_serializable_real_serialize (IBusSerializable *serializable,
 
239
                                  GVariantBuilder  *builder)
302
240
{
303
 
    IBusSerializablePrivate *priv;
304
 
    IBusMessageIter array_iter;
305
 
    gboolean retval;
306
 
 
307
 
    priv = IBUS_SERIALIZABLE_GET_PRIVATE (object);
308
 
 
309
 
    retval = ibus_message_iter_open_container (iter,
310
 
                                               IBUS_TYPE_ARRAY,
311
 
                                               "{sv}",
312
 
                                               &array_iter);
313
 
    g_return_val_if_fail (retval, FALSE);
314
 
 
315
 
    g_datalist_foreach (&priv->attachments,
 
241
    GVariantBuilder array;
 
242
    g_variant_builder_init (&array, G_VARIANT_TYPE ("a{sv}"));
 
243
 
 
244
    g_datalist_foreach (&serializable->priv->attachments,
316
245
                        (GDataForeachFunc) _serialize_cb,
317
 
                        &array_iter);
318
 
 
319
 
    retval = ibus_message_iter_close_container (iter, &array_iter);
320
 
    g_return_val_if_fail (retval, FALSE);
321
 
 
 
246
                        &array);
 
247
    g_variant_builder_add (builder, "a{sv}", &array);
322
248
    return TRUE;
323
249
}
324
250
 
325
 
static gboolean
 
251
static gint
326
252
ibus_serializable_real_deserialize (IBusSerializable *object,
327
 
                                    IBusMessageIter  *iter)
 
253
                                    GVariant         *variant)
328
254
{
329
 
    IBusMessageIter array_iter;
330
 
    gboolean retval;
331
 
 
332
 
    retval = ibus_message_iter_recurse (iter,
333
 
                                        IBUS_TYPE_ARRAY,
334
 
                                        &array_iter);
335
 
    g_return_val_if_fail (retval, FALSE);
336
 
 
337
 
    while (ibus_message_iter_get_arg_type (&array_iter) != G_TYPE_INVALID) {
338
 
        gchar *name;
339
 
        GValue *value;
340
 
        IBusMessageIter dict_entry;
341
 
 
342
 
        retval = ibus_message_iter_recurse (&array_iter,
343
 
                                            IBUS_TYPE_DICT_ENTRY,
344
 
                                            &dict_entry);
345
 
        g_return_val_if_fail (retval, FALSE);
346
 
 
347
 
        retval = ibus_message_iter_get (&dict_entry,
348
 
                                        G_TYPE_STRING,
349
 
                                        &name);
350
 
        g_return_val_if_fail (retval, FALSE);
351
 
        ibus_message_iter_next (&dict_entry);
352
 
 
353
 
        value = _g_value_deserialize (&dict_entry);
354
 
        g_return_val_if_fail (value != NULL, FALSE);
355
 
 
356
 
        ibus_serializable_set_attachment (object, name, value);
357
 
 
358
 
        ibus_message_iter_next (&array_iter);
 
255
    const gchar *key;
 
256
    GVariant *value;
 
257
    GVariantIter *iter = NULL;
 
258
    g_variant_get_child (variant, 1, "a{sv}", &iter);
 
259
    while (g_variant_iter_loop (iter, "{&sv}", &key, &value)) {
 
260
        ibus_serializable_set_attachment (object, key, _g_value_deserialize (value));
359
261
    }
360
 
 
361
 
    ibus_message_iter_next (iter);
362
 
 
363
 
    return TRUE;
 
262
    g_variant_iter_free (iter);
 
263
    return 2;
364
264
}
365
265
 
366
266
static void
433
333
}
434
334
 
435
335
const GValue *
436
 
ibus_serializable_get_qattachment (IBusSerializable *object,
 
336
ibus_serializable_get_qattachment (IBusSerializable *serializable,
437
337
                                   GQuark            key)
438
338
{
439
339
 
440
 
    g_return_val_if_fail (IBUS_IS_SERIALIZABLE (object), NULL);
 
340
    g_return_val_if_fail (IBUS_IS_SERIALIZABLE (serializable), NULL);
441
341
    g_return_val_if_fail (key != 0, NULL);
442
342
 
443
 
    IBusSerializablePrivate *priv;
444
 
    priv = IBUS_SERIALIZABLE_GET_PRIVATE (object);
445
 
 
446
 
    return (const GValue *) g_datalist_id_get_data (&priv->attachments, key);
 
343
    return (const GValue *) g_datalist_id_get_data (&serializable->priv->attachments, key);
447
344
}
448
345
 
449
346
void
450
 
ibus_serializable_remove_qattachment (IBusSerializable *object,
 
347
ibus_serializable_remove_qattachment (IBusSerializable *serializable,
451
348
                                      GQuark            key)
452
349
{
453
350
 
454
 
    g_return_if_fail (IBUS_IS_SERIALIZABLE (object));
 
351
    g_return_if_fail (IBUS_IS_SERIALIZABLE (serializable));
455
352
    g_return_if_fail (key != 0);
456
353
 
457
 
    IBusSerializablePrivate *priv;
458
 
    priv = IBUS_SERIALIZABLE_GET_PRIVATE (object);
459
 
 
460
 
    g_datalist_id_remove_no_notify (&priv->attachments, key);
 
354
    g_datalist_id_remove_no_notify (&serializable->priv->attachments, key);
461
355
}
462
356
 
463
357
IBusSerializable *
481
375
    g_return_val_if_reached (NULL);
482
376
}
483
377
 
484
 
gboolean
485
 
ibus_serializable_serialize (IBusSerializable *object,
486
 
                             IBusMessageIter  *iter)
 
378
GVariant *
 
379
ibus_serializable_serialize (IBusSerializable *object)
487
380
{
488
381
    g_return_val_if_fail (IBUS_IS_SERIALIZABLE (object), FALSE);
489
 
    g_return_val_if_fail (iter != NULL, FALSE);
490
 
 
491
 
    IBusMessageIter variant_iter;
492
 
    IBusMessageIter sub_iter;
493
382
    gboolean retval;
494
383
 
495
 
    gchar *signature;
496
 
 
497
 
    signature = g_strdup_printf ("(s%s)", IBUS_SERIALIZABLE_GET_CLASS (object)->signature->str);
498
 
    retval = ibus_message_iter_open_container (iter,
499
 
                                               IBUS_TYPE_VARIANT,
500
 
                                               signature,
501
 
                                               &variant_iter);
502
 
    g_free (signature);
503
 
    g_return_val_if_fail (retval, FALSE);
504
 
 
505
 
    retval = ibus_message_iter_open_container (&variant_iter,
506
 
                                               IBUS_TYPE_STRUCT,
507
 
                                               NULL,
508
 
                                               &sub_iter);
509
 
    g_return_val_if_fail (retval, FALSE);
510
 
 
511
 
    const gchar *type_name = g_type_name (G_OBJECT_TYPE (object));
512
 
    g_return_val_if_fail (type_name != NULL, FALSE);
513
 
 
514
 
    retval = ibus_message_iter_append (&sub_iter,
515
 
                                       G_TYPE_STRING,
516
 
                                       &type_name);
517
 
    g_return_val_if_fail (retval, FALSE);
518
 
 
519
 
    retval = IBUS_SERIALIZABLE_GET_CLASS (object)->serialize (object, &sub_iter);
520
 
    g_return_val_if_fail (retval, FALSE);
521
 
 
522
 
    retval = ibus_message_iter_close_container (&variant_iter, &sub_iter);
523
 
    g_return_val_if_fail (retval, FALSE);
524
 
 
525
 
    retval = ibus_message_iter_close_container (iter, &variant_iter);
526
 
    g_return_val_if_fail (retval, FALSE);
527
 
 
528
 
    return TRUE;
 
384
    GVariantBuilder builder;
 
385
    g_variant_builder_init (&builder, G_VARIANT_TYPE_TUPLE);
 
386
 
 
387
    g_variant_builder_add (&builder, "s", g_type_name (G_OBJECT_TYPE (object)));
 
388
    retval = IBUS_SERIALIZABLE_GET_CLASS (object)->serialize (object, &builder);
 
389
    g_assert (retval);
 
390
 
 
391
    return g_variant_builder_end (&builder);
529
392
}
530
393
 
531
394
IBusSerializable *
532
 
ibus_serializable_deserialize (IBusMessageIter *iter)
 
395
ibus_serializable_deserialize (GVariant *variant)
533
396
{
534
 
    g_return_val_if_fail (iter != NULL, NULL);
535
 
 
536
 
    gboolean retval;
537
 
    IBusMessageIter variant_iter;
538
 
    IBusMessageIter sub_iter;
539
 
    gchar *type_name;
540
 
    GType type;
541
 
    IBusSerializable *object;
542
 
 
543
 
    type = ibus_message_iter_get_arg_type (iter);
544
 
 
545
 
    if (type == IBUS_TYPE_VARIANT) {
546
 
        retval = ibus_message_iter_recurse (iter, IBUS_TYPE_VARIANT, &variant_iter);
547
 
        g_return_val_if_fail (retval, NULL);
548
 
 
549
 
        retval = ibus_message_iter_recurse (&variant_iter, IBUS_TYPE_STRUCT, &sub_iter);
550
 
        g_return_val_if_fail (retval, NULL);
551
 
    }
552
 
    else if (type == IBUS_TYPE_STRUCT) {
553
 
        retval = ibus_message_iter_recurse (iter, IBUS_TYPE_STRUCT, &sub_iter);
554
 
        g_return_val_if_fail (retval, NULL);
555
 
    }
556
 
    else
 
397
    g_return_val_if_fail (variant != NULL, NULL);
 
398
 
 
399
    GVariant *var = NULL;
 
400
    switch (g_variant_classify (variant)) {
 
401
    case G_VARIANT_CLASS_VARIANT:
 
402
        var = g_variant_get_variant (variant);
 
403
        break;
 
404
    case G_VARIANT_CLASS_TUPLE:
 
405
        var = g_variant_ref (variant);
 
406
        break;
 
407
    default:
557
408
        g_return_val_if_reached (NULL);
558
 
 
559
 
    retval = ibus_message_iter_get (&sub_iter, G_TYPE_STRING, &type_name);
560
 
    g_return_val_if_fail (retval, NULL);
561
 
    ibus_message_iter_next (&sub_iter);
562
 
 
563
 
    type = g_type_from_name (type_name);
 
409
    }
 
410
 
 
411
    gchar *type_name = NULL;
 
412
    g_variant_get_child (var, 0, "&s", &type_name);
 
413
    GType type = g_type_from_name (type_name);
564
414
 
565
415
    g_return_val_if_fail (g_type_is_a (type, IBUS_TYPE_SERIALIZABLE), NULL);
566
416
 
567
 
    object = g_object_new (type, NULL);
 
417
    IBusSerializable *object = g_object_new (type, NULL);
568
418
 
569
 
    retval = IBUS_SERIALIZABLE_GET_CLASS (object)->deserialize (object, &sub_iter);
 
419
    gint retval = IBUS_SERIALIZABLE_GET_CLASS (object)->deserialize (object, var);
 
420
    g_variant_unref (var);
570
421
    if (retval)
571
422
        return object;
572
423