← Back to branch summary

~ubuntu-branches/ubuntu/quantal/d-conf/quantal-updates

« back to all changes in this revision

Viewing changes to client/dconf-client.c

  • Committer: Bazaar Package Importer
  • Author(s): Robert Ancell
  • Date: 2011-03-23 14:59:53 UTC
  • mfrom: (1.1.9 upstream)
  • Revision ID: james.westby@ubuntu.com-20110323145953-clxdx551vtyy6i8k
Tags: 0.7.3-0ubuntu1
* New upstream release
* debian/patches/integer-no-schema.patch:
* debian/patches/fix_settings_model_get_path.patch:
  - Applied upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
client/dconf-client.c
1
 
/* dconf-client.c generated by valac 0.11.5.5-1aa1b, the Vala compiler
 
1
/* dconf-client.c generated by valac 0.11.7, the Vala compiler
2
2
 * generated from dconf-client.vala, do not modify */
3
3
 
4
4
 
66
66
        GDBusConnection* _tmp3_;
67
67
        GDBusConnection* _tmp4_;
68
68
        GDBusConnection* _tmp5_;
69
 
        GDBusConnection* _tmp6_;
70
 
        GDBusConnection* _tmp7_;
71
 
        GDBusConnection* _tmp8_;
72
 
        GDBusConnection* _tmp9_;
73
69
        GVariant** message_collection;
74
70
        int message_collection_length1;
75
71
        int message_it;
76
 
        GVariant* _tmp10_;
 
72
        GVariant* _tmp6_;
77
73
        GVariant* message;
78
 
        GVariant* _tmp11_;
 
74
        GVariant* _tmp7_;
79
75
        GVariant* reply;
80
76
        GError * _inner_error_;
81
77
};
219
215
        GError * _inner_error_ = NULL;
220
216
        g_return_if_fail (self != NULL);
221
217
        if ((*dcem).bus_types[0] == 'e') {
222
 
                GDBusConnection* _tmp3_;
223
 
                GDBusConnection* _tmp4_;
 
218
                GDBusConnection* _tmp2_;
224
219
                if (self->priv->session == NULL) {
225
220
                        GDBusConnection* _tmp0_ = NULL;
226
221
                        GDBusConnection* _tmp1_;
227
 
                        GDBusConnection* _tmp2_;
228
222
                        _tmp0_ = g_bus_get_sync (G_BUS_TYPE_SESSION, cancellable, &_inner_error_);
229
223
                        _tmp1_ = _tmp0_;
230
224
                        if (_inner_error_ != NULL) {
232
226
                                _g_object_unref0 (connection);
233
227
                                return;
234
228
                        }
235
 
                        _tmp2_ = _tmp1_;
236
229
                        _g_object_unref0 (self->priv->session);
237
 
                        self->priv->session = _tmp2_;
 
230
                        self->priv->session = _tmp1_;
238
231
                }
239
 
                _tmp3_ = _g_object_ref0 (self->priv->session);
240
 
                _tmp4_ = _tmp3_;
 
232
                _tmp2_ = _g_object_ref0 (self->priv->session);
241
233
                _g_object_unref0 (connection);
242
 
                connection = _tmp4_;
 
234
                connection = _tmp2_;
243
235
        } else {
244
 
                GDBusConnection* _tmp8_;
245
 
                GDBusConnection* _tmp9_;
 
236
                GDBusConnection* _tmp5_;
246
237
                g_assert ((*dcem).bus_types[0] == 'y');
247
238
                if (self->priv->system == NULL) {
248
 
                        GDBusConnection* _tmp5_ = NULL;
249
 
                        GDBusConnection* _tmp6_;
250
 
                        GDBusConnection* _tmp7_;
251
 
                        _tmp5_ = g_bus_get_sync (G_BUS_TYPE_SYSTEM, cancellable, &_inner_error_);
252
 
                        _tmp6_ = _tmp5_;
 
239
                        GDBusConnection* _tmp3_ = NULL;
 
240
                        GDBusConnection* _tmp4_;
 
241
                        _tmp3_ = g_bus_get_sync (G_BUS_TYPE_SYSTEM, cancellable, &_inner_error_);
 
242
                        _tmp4_ = _tmp3_;
253
243
                        if (_inner_error_ != NULL) {
254
244
                                g_propagate_error (error, _inner_error_);
255
245
                                _g_object_unref0 (connection);
256
246
                                return;
257
247
                        }
258
 
                        _tmp7_ = _tmp6_;
259
248
                        _g_object_unref0 (self->priv->system);
260
 
                        self->priv->system = _tmp7_;
 
249
                        self->priv->system = _tmp4_;
261
250
                }
262
 
                _tmp8_ = _g_object_ref0 (self->priv->system);
263
 
                _tmp9_ = _tmp8_;
 
251
                _tmp5_ = _g_object_ref0 (self->priv->system);
264
252
                _g_object_unref0 (connection);
265
 
                connection = _tmp9_;
 
253
                connection = _tmp5_;
266
254
        }
267
255
        {
268
256
                GVariant** message_collection;
271
259
                message_collection = (*dcem).parameters;
272
260
                message_collection_length1 = (*dcem).n_messages;
273
261
                for (message_it = 0; message_it < (*dcem).n_messages; message_it = message_it + 1) {
274
 
                        GVariant* _tmp10_;
 
262
                        GVariant* _tmp6_;
275
263
                        GVariant* message;
276
 
                        _tmp10_ = _g_variant_ref0 (message_collection[message_it]);
277
 
                        message = _tmp10_;
 
264
                        _tmp6_ = _g_variant_ref0 (message_collection[message_it]);
 
265
                        message = _tmp6_;
278
266
                        {
279
 
                                GVariant* _tmp11_ = NULL;
 
267
                                GVariant* _tmp7_ = NULL;
280
268
                                GVariant* reply;
281
 
                                _tmp11_ = g_dbus_connection_call_sync (connection, (*dcem).bus_name, (*dcem).object_path, (*dcem).interface_name, (*dcem).method_name, message, (*dcem).reply_type, G_DBUS_CALL_FLAGS_NONE, -1, cancellable, &_inner_error_);
282
 
                                reply = _tmp11_;
 
269
                                _tmp7_ = g_dbus_connection_call_sync (connection, (*dcem).bus_name, (*dcem).object_path, (*dcem).interface_name, (*dcem).method_name, message, (*dcem).reply_type, G_DBUS_CALL_FLAGS_NONE, -1, cancellable, &_inner_error_);
 
270
                                reply = _tmp7_;
283
271
                                if (_inner_error_ != NULL) {
284
272
                                        g_propagate_error (error, _inner_error_);
285
273
                                        _g_variant_unref0 (message);
320
308
        _data_->_async_result = g_simple_async_result_new (G_OBJECT (self), _callback_, _user_data_, dconf_client_call_async);
321
309
        g_simple_async_result_set_op_res_gpointer (_data_->_async_result, _data_, dconf_client_call_async_data_free);
322
310
        _data_->self = _g_object_ref0 (self);
323
 
        _data_->dcem = (dconf_engine_message_copy (dcem, &_tmp0_), _tmp0_);
 
311
        dconf_engine_message_copy (dcem, &_tmp0_);
 
312
        _data_->dcem = _tmp0_;
324
313
        _data_->cancellable = _g_object_ref0 (cancellable);
325
314
        dconf_client_call_async_co (_data_);
326
315
}
381
370
                                g_object_unref (data->_async_result);
382
371
                                return FALSE;
383
372
                        }
384
 
                        data->_tmp2_ = data->_tmp1_;
385
373
                        _g_object_unref0 (data->self->priv->session);
386
 
                        data->self->priv->session = data->_tmp2_;
 
374
                        data->self->priv->session = data->_tmp1_;
387
375
                }
388
 
                data->_tmp3_ = _g_object_ref0 (data->self->priv->session);
389
 
                data->_tmp4_ = data->_tmp3_;
 
376
                data->_tmp2_ = _g_object_ref0 (data->self->priv->session);
390
377
                _g_object_unref0 (data->connection);
391
 
                data->connection = data->_tmp4_;
 
378
                data->connection = data->_tmp2_;
392
379
        } else {
393
380
                g_assert (data->dcem.bus_types[0] == 'y');
394
381
                if (data->self->priv->system == NULL) {
396
383
                        g_bus_get (G_BUS_TYPE_SYSTEM, data->cancellable, dconf_client_call_async_ready, data);
397
384
                        return FALSE;
398
385
                        _state_2:
399
 
                        data->_tmp5_ = NULL;
400
 
                        data->_tmp5_ = g_bus_get_finish (data->_res_, &data->_inner_error_);
401
 
                        data->_tmp6_ = data->_tmp5_;
 
386
                        data->_tmp3_ = NULL;
 
387
                        data->_tmp3_ = g_bus_get_finish (data->_res_, &data->_inner_error_);
 
388
                        data->_tmp4_ = data->_tmp3_;
402
389
                        if (data->_inner_error_ != NULL) {
403
390
                                g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
404
391
                                g_error_free (data->_inner_error_);
411
398
                                g_object_unref (data->_async_result);
412
399
                                return FALSE;
413
400
                        }
414
 
                        data->_tmp7_ = data->_tmp6_;
415
401
                        _g_object_unref0 (data->self->priv->system);
416
 
                        data->self->priv->system = data->_tmp7_;
 
402
                        data->self->priv->system = data->_tmp4_;
417
403
                }
418
 
                data->_tmp8_ = _g_object_ref0 (data->self->priv->system);
419
 
                data->_tmp9_ = data->_tmp8_;
 
404
                data->_tmp5_ = _g_object_ref0 (data->self->priv->system);
420
405
                _g_object_unref0 (data->connection);
421
 
                data->connection = data->_tmp9_;
 
406
                data->connection = data->_tmp5_;
422
407
        }
423
408
        {
424
409
                data->message_collection = data->dcem.parameters;
425
410
                data->message_collection_length1 = data->dcem.n_messages;
426
411
                for (data->message_it = 0; data->message_it < data->dcem.n_messages; data->message_it = data->message_it + 1) {
427
 
                        data->_tmp10_ = _g_variant_ref0 (data->message_collection[data->message_it]);
428
 
                        data->message = data->_tmp10_;
 
412
                        data->_tmp6_ = _g_variant_ref0 (data->message_collection[data->message_it]);
 
413
                        data->message = data->_tmp6_;
429
414
                        {
430
415
                                data->_state_ = 3;
431
416
                                g_dbus_connection_call (data->connection, data->dcem.bus_name, data->dcem.object_path, data->dcem.interface_name, data->dcem.method_name, data->message, data->dcem.reply_type, G_DBUS_CALL_FLAGS_NONE, -1, data->cancellable, dconf_client_call_async_ready, data);
432
417
                                return FALSE;
433
418
                                _state_3:
434
 
                                data->_tmp11_ = NULL;
435
 
                                data->_tmp11_ = g_dbus_connection_call_finish (data->connection, data->_res_, &data->_inner_error_);
436
 
                                data->reply = data->_tmp11_;
 
419
                                data->_tmp7_ = NULL;
 
420
                                data->_tmp7_ = g_dbus_connection_call_finish (data->connection, data->_res_, &data->_inner_error_);
 
421
                                data->reply = data->_tmp7_;
437
422
                                if (data->_inner_error_ != NULL) {
438
423
                                        g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
439
424
                                        g_error_free (data->_inner_error_);
520
505
                DConfEngineMessage _tmp2_;
521
506
                DConfEngineMessage _tmp3_;
522
507
                gchar* _tmp4_ = NULL;
523
 
                _tmp1_ = (dconf_engine_write (self->priv->engine, key, value, &_tmp0_, &_inner_error_), _tmp0_);
 
508
                dconf_engine_write (self->priv->engine, key, value, &_tmp0_, &_inner_error_);
 
509
                _tmp1_ = _tmp0_;
524
510
                _tmp2_ = _tmp1_;
525
511
                if (_inner_error_ != NULL) {
526
512
                        g_propagate_error (error, _inner_error_);
544
530
                DConfEngineMessage _tmp7_;
545
531
                DConfEngineMessage _tmp8_;
546
532
                gchar* _tmp9_ = NULL;
547
 
                _tmp6_ = (dconf_engine_write (self->priv->engine, key, value, &_tmp5_, &_inner_error_), _tmp5_);
 
533
                dconf_engine_write (self->priv->engine, key, value, &_tmp5_, &_inner_error_);
 
534
                _tmp6_ = _tmp5_;
548
535
                _tmp7_ = _tmp6_;
549
536
                if (_inner_error_ != NULL) {
550
537
                        g_propagate_error (error, _inner_error_);
642
629
        }
643
630
        _state_0:
644
631
        memset (&data->_tmp0_, 0, sizeof (DConfEngineMessage));
 
632
        dconf_engine_write (data->self->priv->engine, data->key, data->value, &data->_tmp0_, &data->_inner_error_);
645
633
        memset (&data->_tmp1_, 0, sizeof (DConfEngineMessage));
646
 
        data->_tmp1_ = (dconf_engine_write (data->self->priv->engine, data->key, data->value, &data->_tmp0_, &data->_inner_error_), data->_tmp0_);
 
634
        data->_tmp1_ = data->_tmp0_;
647
635
        data->_tmp2_ = data->_tmp1_;
648
636
        if (data->_inner_error_ != NULL) {
649
637
                g_simple_async_result_set_from_error (data->_async_result, data->_inner_error_);
729
717
                DConfEngineMessage _tmp2_;
730
718
                DConfEngineMessage _tmp3_;
731
719
                gchar* _tmp4_ = NULL;
732
 
                _tmp1_ = (dconf_engine_write_many (self->priv->engine, dir, (const gchar * const *) rels, values, &_tmp0_, &_inner_error_), _tmp0_);
 
720
                dconf_engine_write_many (self->priv->engine, dir, (const gchar * const *) rels, values, &_tmp0_, &_inner_error_);
 
721
                _tmp1_ = _tmp0_;
733
722
                _tmp2_ = _tmp1_;
734
723
                if (_inner_error_ != NULL) {
735
724
                        g_propagate_error (error, _inner_error_);
753
742
                DConfEngineMessage _tmp7_;
754
743
                DConfEngineMessage _tmp8_;
755
744
                gchar* _tmp9_ = NULL;
756
 
                _tmp6_ = (dconf_engine_write_many (self->priv->engine, dir, (const gchar * const *) rels, values, &_tmp5_, &_inner_error_), _tmp5_);
 
745
                dconf_engine_write_many (self->priv->engine, dir, (const gchar * const *) rels, values, &_tmp5_, &_inner_error_);
 
746
                _tmp6_ = _tmp5_;
757
747
                _tmp7_ = _tmp6_;
758
748
                if (_inner_error_ != NULL) {
759
749
                        g_propagate_error (error, _inner_error_);
805
795
        GError * _inner_error_ = NULL;
806
796
        g_return_val_if_fail (self != NULL, FALSE);
807
797
        g_return_val_if_fail (path != NULL, FALSE);
808
 
        _tmp1_ = (dconf_engine_set_locked (self->priv->engine, path, locked, &_tmp0_), _tmp0_);
 
798
        dconf_engine_set_locked (self->priv->engine, path, locked, &_tmp0_);
 
799
        _tmp1_ = _tmp0_;
809
800
        _tmp2_ = _tmp1_;
810
801
        dconf_client_call_sync (self, &_tmp2_, NULL, cancellable, &_inner_error_);
811
802
        dconf_engine_message_destroy (&_tmp2_);
887
878
        }
888
879
        _state_0:
889
880
        memset (&data->_tmp0_, 0, sizeof (DConfEngineMessage));
 
881
        dconf_engine_set_locked (data->self->priv->engine, data->key, data->locked, &data->_tmp0_);
890
882
        memset (&data->_tmp1_, 0, sizeof (DConfEngineMessage));
891
 
        data->_tmp1_ = (dconf_engine_set_locked (data->self->priv->engine, data->key, data->locked, &data->_tmp0_), data->_tmp0_);
 
883
        data->_tmp1_ = data->_tmp0_;
892
884
        data->_tmp2_ = data->_tmp1_;
893
885
        data->_state_ = 1;
894
886
        dconf_client_call_async (data->self, &data->_tmp2_, data->cancellable, dconf_client_set_locked_async_ready, data);
1040
1032
        GError * _inner_error_ = NULL;
1041
1033
        g_return_val_if_fail (self != NULL, FALSE);
1042
1034
        g_return_val_if_fail (path != NULL, FALSE);
1043
 
        _tmp1_ = (dconf_engine_watch (self->priv->engine, path, &_tmp0_), _tmp0_);
 
1035
        dconf_engine_watch (self->priv->engine, path, &_tmp0_);
 
1036
        _tmp1_ = _tmp0_;
1044
1037
        _tmp2_ = _tmp1_;
1045
1038
        dconf_client_call_sync (self, &_tmp2_, NULL, cancellable, &_inner_error_);
1046
1039
        dconf_engine_message_destroy (&_tmp2_);
1120
1113
        }
1121
1114
        _state_0:
1122
1115
        memset (&data->_tmp0_, 0, sizeof (DConfEngineMessage));
 
1116
        dconf_engine_watch (data->self->priv->engine, data->name, &data->_tmp0_);
1123
1117
        memset (&data->_tmp1_, 0, sizeof (DConfEngineMessage));
1124
 
        data->_tmp1_ = (dconf_engine_watch (data->self->priv->engine, data->name, &data->_tmp0_), data->_tmp0_);
 
1118
        data->_tmp1_ = data->_tmp0_;
1125
1119
        data->_tmp2_ = data->_tmp1_;
1126
1120
        data->_state_ = 1;
1127
1121
        dconf_client_call_async (data->self, &data->_tmp2_, data->cancellable, dconf_client_watch_async_ready, data);
1183
1177
        GError * _inner_error_ = NULL;
1184
1178
        g_return_val_if_fail (self != NULL, FALSE);
1185
1179
        g_return_val_if_fail (name != NULL, FALSE);
1186
 
        _tmp1_ = (dconf_engine_unwatch (self->priv->engine, name, &_tmp0_), _tmp0_);
 
1180
        dconf_engine_unwatch (self->priv->engine, name, &_tmp0_);
 
1181
        _tmp1_ = _tmp0_;
1187
1182
        _tmp2_ = _tmp1_;
1188
1183
        dconf_client_call_sync (self, &_tmp2_, NULL, cancellable, &_inner_error_);
1189
1184
        dconf_engine_message_destroy (&_tmp2_);
1264
1259
        }
1265
1260
        _state_0:
1266
1261
        memset (&data->_tmp0_, 0, sizeof (DConfEngineMessage));
 
1262
        dconf_engine_unwatch (data->self->priv->engine, data->name, &data->_tmp0_);
1267
1263
        memset (&data->_tmp1_, 0, sizeof (DConfEngineMessage));
1268
 
        data->_tmp1_ = (dconf_engine_unwatch (data->self->priv->engine, data->name, &data->_tmp0_), data->_tmp0_);
 
1264
        data->_tmp1_ = data->_tmp0_;
1269
1265
        data->_tmp2_ = data->_tmp1_;
1270
1266
        data->_state_ = 1;
1271
1267
        dconf_client_call_async (data->self, &data->_tmp2_, data->cancellable, dconf_client_unwatch_async_ready, data);
1365
1361
DConfClient* dconf_client_construct (GType object_type, const gchar* profile, DConfWatchFunc watch_func, void* watch_func_target, GDestroyNotify watch_func_target_destroy_notify) {
1366
1362
        DConfClient * self = NULL;
1367
1363
        DConfEngine* _tmp0_ = NULL;
1368
 
        DConfEngine* _tmp1_;
1369
 
        DConfWatchFunc _tmp2_;
1370
 
        DConfWatchFunc _tmp3_;
 
1364
        DConfWatchFunc _tmp1_;
1371
1365
        self = (DConfClient*) g_object_new (object_type, NULL);
1372
1366
        dconf_engine_set_service_func (_dconf_client_service_func_dconf_service_func);
1373
1367
        _tmp0_ = dconf_engine_new (profile);
1374
 
        _tmp1_ = _tmp0_;
1375
1368
        _dconf_engine_free0 (self->priv->engine);
1376
 
        self->priv->engine = _tmp1_;
1377
 
        _tmp2_ = watch_func;
1378
 
        _tmp3_ = _tmp2_;
 
1369
        self->priv->engine = _tmp0_;
 
1370
        _tmp1_ = watch_func;
1379
1371
        (self->priv->watch_func_target_destroy_notify == NULL) ? NULL : (self->priv->watch_func_target_destroy_notify (self->priv->watch_func_target), NULL);
1380
1372
        self->priv->watch_func = NULL;
1381
1373
        self->priv->watch_func_target = NULL;
1382
1374
        self->priv->watch_func_target_destroy_notify = NULL;
 
1375
        self->priv->watch_func = _tmp1_;
1383
1376
        self->priv->watch_func_target = watch_func_target;
1384
1377
        self->priv->watch_func_target_destroy_notify = NULL;
1385
 
        self->priv->watch_func = _tmp3_;
1386
1378
        (watch_func_target_destroy_notify == NULL) ? NULL : (watch_func_target_destroy_notify (watch_func_target), NULL);
1387
1379
        watch_func = NULL;
1388
1380
        watch_func_target = NULL;