← Back to branch summary

~ubuntu-branches/ubuntu/precise/libdbusmenu/precise

« back to all changes in this revision

Viewing changes to libdbusmenu-glib/server.c

  • Committer: Bazaar Package Importer
  • Author(s): Ken VanDine
  • Date: 2011-06-24 14:55:59 UTC
  • mto: (8.1.77 oneiric)
  • mto: This revision was merged to the branch mainline in revision 17.
  • Revision ID: james.westby@ubuntu.com-20110624145559-f56h41ljy8yc1vaz
Tags: upstream-0.4.90
Import upstream version 0.4.90

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdbusmenu-glib/server.c
455
455
                                g_return_if_fail(priv->bus_lookup != NULL);
456
456
                        }
457
457
 
 
458
                        g_object_ref(obj);
458
459
                        g_bus_get(G_BUS_TYPE_SESSION, priv->bus_lookup, bus_got_cb, obj);
459
460
                } else {
460
461
                        register_object(DBUSMENU_SERVER(obj));
694
695
        if (error != NULL) {
695
696
                g_warning("Unable to get session bus: %s", error->message);
696
697
                g_error_free(error);
 
698
                g_object_unref(G_OBJECT(user_data));
697
699
                return;
698
700
        }
699
701
 
706
708
 
707
709
        register_object(DBUSMENU_SERVER(user_data));
708
710
 
 
711
        g_object_unref(G_OBJECT(user_data));
709
712
        return;
710
713
}
711
714
 
949
952
                }
950
953
        }
951
954
 
 
955
        /* these are going to be standard references in all code paths and must be unrefed */
952
956
        GVariant * megadata[2];
953
957
        gboolean gotsomething = FALSE;
954
958
 
955
959
        if (item_init) {
956
960
                megadata[0] = g_variant_builder_end(&itembuilder);
 
961
                g_variant_ref_sink(megadata[0]);
957
962
                gotsomething = TRUE;
958
963
        } else {
959
964
                GError * error = NULL;
967
972
 
968
973
        if (removeitem_init) {
969
974
                megadata[1] = g_variant_builder_end(&removeitembuilder);
 
975
                g_variant_ref_sink(megadata[1]);
970
976
                gotsomething = TRUE;
971
977
        } else {
972
978
                GError * error = NULL;
983
989
                                              NULL,
984
990
                                              priv->dbusobject,
985
991
                                              DBUSMENU_INTERFACE,
986
 
                                              "ItemPropertiesUpdated",
 
992
                                              "ItemsPropertiesUpdated",
987
993
                                              g_variant_new_tuple(megadata, 2),
988
994
                                              NULL);
989
 
        } else {
990
 
                g_variant_unref(megadata[0]);
991
 
                g_variant_unref(megadata[1]);
992
995
        }
993
996
 
 
997
        g_variant_unref(megadata[0]);
 
998
        g_variant_unref(megadata[1]);
 
999
 
994
1000
        /* Clean everything up */
995
1001
        prop_array_teardown(priv->prop_array);
996
1002
        priv->prop_array = NULL;
1191
1197
        DbusmenuServerPrivate * priv = DBUSMENU_SERVER_GET_PRIVATE(server);
1192
1198
 
1193
1199
        /* Input */
1194
 
        gint parent = g_variant_get_int32(g_variant_get_child_value(params, 0));
1195
 
        gint recurse = g_variant_get_int32(g_variant_get_child_value(params, 1));
1196
 
        const gchar ** props = g_variant_get_strv(g_variant_get_child_value(params, 2), NULL);
 
1200
        gint32 parent;
 
1201
        gint32 recurse;
 
1202
        const gchar ** props;
 
1203
 
 
1204
        g_variant_get(params, "(ii^a&s)", &parent, &recurse, &props);
1197
1205
 
1198
1206
        /* Output */
1199
1207
        guint revision = priv->layout_revision;
1206
1214
                        items = dbusmenu_menuitem_build_variant(mi, props, recurse);
1207
1215
                }
1208
1216
        }
 
1217
        g_free(props);
1209
1218
 
1210
1219
        /* What happens if we don't have anything? */
1211
1220
        if (items == NULL) {
1252
1261
                                    "There currently isn't a layout in this server");
1253
1262
                return;
1254
1263
        }
1255
 
        
1256
 
        gint id = g_variant_get_int32(g_variant_get_child_value(params, 0));
1257
 
        const gchar * property = g_variant_get_string(g_variant_get_child_value(params, 1), NULL);
 
1264
 
 
1265
        gint32 id;
 
1266
        const gchar * property;
 
1267
 
 
1268
        g_variant_get(params, "(i&s)", &id, &property);
1258
1269
 
1259
1270
        DbusmenuMenuitem * mi = dbusmenu_menuitem_find_id(priv->root, id);
1260
1271
 
1296
1307
                return;
1297
1308
        }
1298
1309
 
1299
 
        gint id = g_variant_get_int32(g_variant_get_child_value(params, 0));
 
1310
        gint32 id;
 
1311
        g_variant_get(params, "(i)", &id);
1300
1312
 
1301
1313
        DbusmenuMenuitem * mi = dbusmenu_menuitem_find_id(priv->root, id);
1302
1314
 
1324
1336
        DbusmenuServerPrivate * priv = DBUSMENU_SERVER_GET_PRIVATE(server);
1325
1337
 
1326
1338
        if (priv->root == NULL) {
 
1339
                /* Allow a request for just id 0 when root is null. Return no properties.
 
1340
                   So that a request always returns a valid structure no matter the
 
1341
                   state of the structure in the server.
 
1342
                */
1327
1343
                GVariant * idlist = g_variant_get_child_value(params, 0);
1328
 
                if (g_variant_n_children(idlist) == 1 && g_variant_get_int32(g_variant_get_child_value(idlist, 0)) == 0) {
1329
 
                        GVariant * final = g_variant_parse(g_variant_type_new("(a(ia{sv}))"), "([(0, {})],)", NULL, NULL, NULL);
1330
 
                        g_dbus_method_invocation_return_value(invocation, final);
1331
 
                        return;
 
1344
                if (g_variant_n_children(idlist) == 1) {
 
1345
 
 
1346
                        GVariant *id_v = g_variant_get_child_value(idlist, 0);
 
1347
                        gint32 id = g_variant_get_int32(id_v);
 
1348
                        g_variant_unref(id_v);
 
1349
 
 
1350
                        if (id == 0) {
 
1351
 
 
1352
                                GVariant * final = g_variant_parse(G_VARIANT_TYPE("(a(ia{sv}))"), "([(0, {})],)", NULL, NULL, NULL);
 
1353
                                g_dbus_method_invocation_return_value(invocation, final);
 
1354
                                g_variant_unref(final);
 
1355
                        }
 
1356
                } else {
 
1357
 
 
1358
                        g_dbus_method_invocation_return_error(invocation,
 
1359
                                                  error_quark(),
 
1360
                                                  NO_VALID_LAYOUT,
 
1361
                                                  "There currently isn't a layout in this server");
1332
1362
                }
1333
 
 
1334
 
                g_dbus_method_invocation_return_error(invocation,
1335
 
                                    error_quark(),
1336
 
                                    NO_VALID_LAYOUT,
1337
 
                                    "There currently isn't a layout in this server");
 
1363
                g_variant_unref(idlist);
1338
1364
                return;
1339
1365
        }
1340
1366
 
1341
 
        GVariantIter ids;
1342
 
        g_variant_iter_init(&ids, g_variant_get_child_value(params, 0));
 
1367
        GVariantIter *ids;
 
1368
        g_variant_get(params, "(aias)", &ids, NULL);
 
1369
        /* TODO: implementation ignores propertyNames declared in XML */
1343
1370
 
1344
1371
        GVariantBuilder builder;
1345
1372
        gboolean builder_init = FALSE;
1346
1373
 
1347
 
        gint id;
1348
 
        while (g_variant_iter_next(&ids, "i", &id)) {
 
1374
        gint32 id;
 
1375
        while (g_variant_iter_loop(ids, "i", &id)) {
1349
1376
                DbusmenuMenuitem * mi = dbusmenu_menuitem_find_id(priv->root, id);
1350
1377
                if (mi == NULL) continue;
1351
1378
 
1361
1388
 
1362
1389
                if (props == NULL) {
1363
1390
                        GError * error = NULL;
1364
 
                        props = g_variant_parse(g_variant_type_new("a{sv}"), "{}", NULL, NULL, &error);
 
1391
                        props = g_variant_parse(G_VARIANT_TYPE("a{sv}"), "{}", NULL, NULL, &error);
1365
1392
                        if (error != NULL) {
1366
1393
                                g_warning("Unable to parse '{}' as a 'a{sv}': %s", error->message);
1367
1394
                                g_error_free(error);
1374
1401
 
1375
1402
                g_variant_builder_add_value(&builder, mi_data);
1376
1403
        }
 
1404
        g_variant_iter_free(ids);
1377
1405
 
 
1406
        /* a standard reference that must be unrefed */
1378
1407
        GVariant * ret = NULL;
1379
1408
        
1380
1409
        if (builder_init) {
1381
1410
                ret = g_variant_builder_end(&builder);
 
1411
                g_variant_ref_sink(ret);
1382
1412
        } else {
1383
1413
                GError * error = NULL;
1384
 
                ret = g_variant_parse(g_variant_type_new("a(ia{sv})"), "[]", NULL, NULL, NULL);
 
1414
                ret = g_variant_parse(G_VARIANT_TYPE("a(ia{sv})"), "[]", NULL, NULL, &error);
1385
1415
                if (error != NULL) {
1386
1416
                        g_warning("Unable to parse '[]' as a 'a(ia{sv})': %s", error->message);
1387
1417
                        g_error_free(error);
1388
 
                        ret = NULL;
1389
1418
                }
1390
1419
        }
1391
1420
 
1393
1422
        if (ret != NULL) {
1394
1423
                g_variant_builder_init(&builder, G_VARIANT_TYPE_TUPLE);
1395
1424
                g_variant_builder_add_value(&builder, ret);
 
1425
                g_variant_unref(ret);
1396
1426
                final = g_variant_builder_end(&builder);
1397
1427
        } else {
1398
1428
                g_warning("Error building property list, final variant is NULL");
1431
1461
bus_get_children (DbusmenuServer * server, GVariant * params, GDBusMethodInvocation * invocation)
1432
1462
{
1433
1463
        DbusmenuServerPrivate * priv = DBUSMENU_SERVER_GET_PRIVATE(server);
1434
 
        gint id = g_variant_get_int32(g_variant_get_child_value(params, 0));
 
1464
        gint32 id;
 
1465
        g_variant_get(params, "(i)", &id);
1435
1466
 
1436
1467
        if (priv->root == NULL) {
1437
1468
                g_dbus_method_invocation_return_error(invocation,
1465
1496
                ret = g_variant_new_tuple(&end, 1);
1466
1497
        } else {
1467
1498
                GError * error = NULL;
1468
 
                ret = g_variant_parse(g_variant_type_new("(a(ia{sv}))"), "([(0, {})],)", NULL, NULL, &error);
 
1499
                ret = g_variant_parse(G_VARIANT_TYPE("(a(ia{sv}))"), "([(0, {})],)", NULL, NULL, &error);
1469
1500
                if (error != NULL) {
1470
1501
                        g_warning("Unable to parse '([(0, {})],)' as a '(a(ia{sv}))': %s", error->message);
1471
1502
                        g_error_free(error);
1517
1548
                return;
1518
1549
        }
1519
1550
 
1520
 
        gint id = g_variant_get_int32(g_variant_get_child_value(params, 0));
 
1551
        gint32 id;
 
1552
        gchar *etype;
 
1553
        GVariant *data;
 
1554
        guint32 ts;
 
1555
 
 
1556
        g_variant_get(params, "(isvu)", &id, &etype, &data, &ts);
 
1557
 
1521
1558
        DbusmenuMenuitem * mi = dbusmenu_menuitem_find_id(priv->root, id);
1522
1559
 
1523
1560
        if (mi == NULL) {
 
1561
 
1524
1562
                g_dbus_method_invocation_return_error(invocation,
1525
1563
                                                          error_quark(),
1526
1564
                                                          INVALID_MENUITEM_ID,
1527
1565
                                                          "The ID supplied %d does not refer to a menu item we have",
1528
1566
                                                          id);
1529
 
                return;
1530
 
        }
1531
 
 
1532
 
        idle_event_t * event_data = g_new0(idle_event_t, 1);
1533
 
        event_data->mi = mi;
1534
 
        g_object_ref(event_data->mi);
1535
 
        event_data->eventid = g_strdup(g_variant_get_string(g_variant_get_child_value(params, 1), NULL));
1536
 
        event_data->timestamp = g_variant_get_uint32(g_variant_get_child_value(params, 3));
1537
 
        event_data->variant = g_variant_get_child_value(params, 2);
1538
 
 
1539
 
        if (g_variant_is_of_type(event_data->variant, G_VARIANT_TYPE_VARIANT)) {
1540
 
                event_data->variant = g_variant_get_variant(event_data->variant);
1541
 
        }
1542
 
 
1543
 
        g_variant_ref_sink(event_data->variant);
1544
 
 
1545
 
        g_timeout_add(0, event_local_handler, event_data);
 
1567
                g_free(etype);
 
1568
                g_variant_unref(data);
 
1569
 
 
1570
        } else {
 
1571
 
 
1572
                idle_event_t * event_data = g_new0(idle_event_t, 1);
 
1573
                event_data->mi = g_object_ref(mi);
 
1574
                event_data->eventid = etype;
 
1575
                event_data->timestamp = ts;
 
1576
                event_data->variant = data; /* give away our reference */
 
1577
 
 
1578
                g_timeout_add(0, event_local_handler, event_data);
 
1579
        }
1546
1580
 
1547
1581
        g_dbus_method_invocation_return_value(invocation, NULL);
1548
1582
        return;
1562
1596
                return;
1563
1597
        }
1564
1598
 
1565
 
        gint id = g_variant_get_int32(g_variant_get_child_value(params, 0));
 
1599
        gint32 id;
 
1600
        g_variant_get(params, "(i)", &id);
1566
1601
        DbusmenuMenuitem * mi = dbusmenu_menuitem_find_id(priv->root, id);
1567
1602
 
1568
1603
        if (mi == NULL) {