nexmon – Blame information for rev 1

Subversion Repositories:
Rev:
Rev Author Line No. Line
1 office 1 /*
2 * Copyright © 2011 Canonical Ltd.
3 *
4 * This library is free software; you can redistribute it and/or modify
5 * it under the terms of the GNU Lesser General Public License as
6 * published by the Free Software Foundation; either version 2 of the
7 * licence, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful, but
10 * WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, see <http://www.gnu.org/licenses/>.
16 *
17 * Author: Ryan Lortie <desrt@desrt.ca>
18 */
19  
20 #include "config.h"
21  
22 #include "gmenuexporter.h"
23  
24 #include "gdbusmethodinvocation.h"
25 #include "gdbusintrospection.h"
26 #include "gdbusnamewatching.h"
27 #include "gdbuserror.h"
28  
29 /**
30 * SECTION:gmenuexporter
31 * @title: GMenuModel exporter
32 * @short_description: Export GMenuModels on D-Bus
33 * @include: gio/gio.h
34 * @see_also: #GMenuModel, #GDBusMenuModel
35 *
36 * These functions support exporting a #GMenuModel on D-Bus.
37 * The D-Bus interface that is used is a private implementation
38 * detail.
39 *
40 * To access an exported #GMenuModel remotely, use
41 * g_dbus_menu_model_get() to obtain a #GDBusMenuModel.
42 */
43  
44 /* {{{1 D-Bus Interface description */
45  
46 /* For documentation of this interface, see
47 * https://wiki.gnome.org/Projects/GLib/GApplication/DBusAPI
48 */
49  
50 static GDBusInterfaceInfo *
51 org_gtk_Menus_get_interface (void)
52 {
53 static GDBusInterfaceInfo *interface_info;
54  
55 if (interface_info == NULL)
56 {
57 GError *error = NULL;
58 GDBusNodeInfo *info;
59  
60 info = g_dbus_node_info_new_for_xml ("<node>"
61 " <interface name='org.gtk.Menus'>"
62 " <method name='Start'>"
63 " <arg type='au' name='groups' direction='in'/>"
64 " <arg type='a(uuaa{sv})' name='content' direction='out'/>"
65 " </method>"
66 " <method name='End'>"
67 " <arg type='au' name='groups' direction='in'/>"
68 " </method>"
69 " <signal name='Changed'>"
70 " arg type='a(uuuuaa{sv})' name='changes'/>"
71 " </signal>"
72 " </interface>"
73 "</node>", &error);
74 if (info == NULL)
75 g_error ("%s\n", error->message);
76 interface_info = g_dbus_node_info_lookup_interface (info, "org.gtk.Menus");
77 g_assert (interface_info != NULL);
78 g_dbus_interface_info_ref (interface_info);
79 g_dbus_node_info_unref (info);
80 }
81  
82 return interface_info;
83 }
84  
85 /* {{{1 Forward declarations */
86 typedef struct _GMenuExporterMenu GMenuExporterMenu;
87 typedef struct _GMenuExporterLink GMenuExporterLink;
88 typedef struct _GMenuExporterGroup GMenuExporterGroup;
89 typedef struct _GMenuExporterRemote GMenuExporterRemote;
90 typedef struct _GMenuExporterWatch GMenuExporterWatch;
91 typedef struct _GMenuExporter GMenuExporter;
92  
93 static gboolean g_menu_exporter_group_is_subscribed (GMenuExporterGroup *group);
94 static guint g_menu_exporter_group_get_id (GMenuExporterGroup *group);
95 static GMenuExporter * g_menu_exporter_group_get_exporter (GMenuExporterGroup *group);
96 static GMenuExporterMenu * g_menu_exporter_group_add_menu (GMenuExporterGroup *group,
97 GMenuModel *model);
98 static void g_menu_exporter_group_remove_menu (GMenuExporterGroup *group,
99 guint id);
100  
101 static GMenuExporterGroup * g_menu_exporter_create_group (GMenuExporter *exporter);
102 static GMenuExporterGroup * g_menu_exporter_lookup_group (GMenuExporter *exporter,
103 guint group_id);
104 static void g_menu_exporter_report (GMenuExporter *exporter,
105 GVariant *report);
106 static void g_menu_exporter_remove_group (GMenuExporter *exporter,
107 guint id);
108  
109 /* {{{1 GMenuExporterLink, GMenuExporterMenu */
110  
111 struct _GMenuExporterMenu
112 {
113 GMenuExporterGroup *group;
114 guint id;
115  
116 GMenuModel *model;
117 gulong handler_id;
118 GSequence *item_links;
119 };
120  
121 struct _GMenuExporterLink
122 {
123 gchar *name;
124 GMenuExporterMenu *menu;
125 GMenuExporterLink *next;
126 };
127  
128 static void
129 g_menu_exporter_menu_free (GMenuExporterMenu *menu)
130 {
131 g_menu_exporter_group_remove_menu (menu->group, menu->id);
132  
133 if (menu->handler_id != 0)
134 g_signal_handler_disconnect (menu->model, menu->handler_id);
135  
136 if (menu->item_links != NULL)
137 g_sequence_free (menu->item_links);
138  
139 g_object_unref (menu->model);
140  
141 g_slice_free (GMenuExporterMenu, menu);
142 }
143  
144 static void
145 g_menu_exporter_link_free (gpointer data)
146 {
147 GMenuExporterLink *link = data;
148  
149 while (link != NULL)
150 {
151 GMenuExporterLink *tmp = link;
152 link = tmp->next;
153  
154 g_menu_exporter_menu_free (tmp->menu);
155 g_free (tmp->name);
156  
157 g_slice_free (GMenuExporterLink, tmp);
158 }
159 }
160  
161 static GMenuExporterLink *
162 g_menu_exporter_menu_create_links (GMenuExporterMenu *menu,
163 gint position)
164 {
165 GMenuExporterLink *list = NULL;
166 GMenuLinkIter *iter;
167 const char *name;
168 GMenuModel *model;
169  
170 iter = g_menu_model_iterate_item_links (menu->model, position);
171  
172 while (g_menu_link_iter_get_next (iter, &name, &model))
173 {
174 GMenuExporterGroup *group;
175 GMenuExporterLink *tmp;
176  
177 /* keep sections in the same group, but create new groups
178 * otherwise
179 */
180 if (!g_str_equal (name, "section"))
181 group = g_menu_exporter_create_group (g_menu_exporter_group_get_exporter (menu->group));
182 else
183 group = menu->group;
184  
185 tmp = g_slice_new (GMenuExporterLink);
186 tmp->name = g_strconcat (":", name, NULL);
187 tmp->menu = g_menu_exporter_group_add_menu (group, model);
188 tmp->next = list;
189 list = tmp;
190  
191 g_object_unref (model);
192 }
193  
194 g_object_unref (iter);
195  
196 return list;
197 }
198  
199 static GVariant *
200 g_menu_exporter_menu_describe_item (GMenuExporterMenu *menu,
201 gint position)
202 {
203 GMenuAttributeIter *attr_iter;
204 GVariantBuilder builder;
205 GSequenceIter *iter;
206 GMenuExporterLink *link;
207 const char *name;
208 GVariant *value;
209  
210 g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
211  
212 attr_iter = g_menu_model_iterate_item_attributes (menu->model, position);
213 while (g_menu_attribute_iter_get_next (attr_iter, &name, &value))
214 {
215 g_variant_builder_add (&builder, "{sv}", name, value);
216 g_variant_unref (value);
217 }
218 g_object_unref (attr_iter);
219  
220 iter = g_sequence_get_iter_at_pos (menu->item_links, position);
221 for (link = g_sequence_get (iter); link; link = link->next)
222 g_variant_builder_add (&builder, "{sv}", link->name,
223 g_variant_new ("(uu)", g_menu_exporter_group_get_id (link->menu->group), link->menu->id));
224  
225 return g_variant_builder_end (&builder);
226 }
227  
228 static GVariant *
229 g_menu_exporter_menu_list (GMenuExporterMenu *menu)
230 {
231 GVariantBuilder builder;
232 gint i, n;
233  
234 g_variant_builder_init (&builder, G_VARIANT_TYPE ("aa{sv}"));
235  
236 n = g_sequence_get_length (menu->item_links);
237 for (i = 0; i < n; i++)
238 g_variant_builder_add_value (&builder, g_menu_exporter_menu_describe_item (menu, i));
239  
240 return g_variant_builder_end (&builder);
241 }
242  
243 static void
244 g_menu_exporter_menu_items_changed (GMenuModel *model,
245 gint position,
246 gint removed,
247 gint added,
248 gpointer user_data)
249 {
250 GMenuExporterMenu *menu = user_data;
251 GSequenceIter *point;
252 gint i;
253  
254 g_assert (menu->model == model);
255 g_assert (menu->item_links != NULL);
256 g_assert (position + removed <= g_sequence_get_length (menu->item_links));
257  
258 point = g_sequence_get_iter_at_pos (menu->item_links, position + removed);
259 g_sequence_remove_range (g_sequence_get_iter_at_pos (menu->item_links, position), point);
260  
261 for (i = position; i < position + added; i++)
262 g_sequence_insert_before (point, g_menu_exporter_menu_create_links (menu, i));
263  
264 if (g_menu_exporter_group_is_subscribed (menu->group))
265 {
266 GVariantBuilder builder;
267  
268 g_variant_builder_init (&builder, G_VARIANT_TYPE ("(uuuuaa{sv})"));
269 g_variant_builder_add (&builder, "u", g_menu_exporter_group_get_id (menu->group));
270 g_variant_builder_add (&builder, "u", menu->id);
271 g_variant_builder_add (&builder, "u", position);
272 g_variant_builder_add (&builder, "u", removed);
273  
274 g_variant_builder_open (&builder, G_VARIANT_TYPE ("aa{sv}"));
275 for (i = position; i < position + added; i++)
276 g_variant_builder_add_value (&builder, g_menu_exporter_menu_describe_item (menu, i));
277 g_variant_builder_close (&builder);
278  
279 g_menu_exporter_report (g_menu_exporter_group_get_exporter (menu->group), g_variant_builder_end (&builder));
280 }
281 }
282  
283 static void
284 g_menu_exporter_menu_prepare (GMenuExporterMenu *menu)
285 {
286 gint n_items;
287  
288 g_assert (menu->item_links == NULL);
289  
290 if (g_menu_model_is_mutable (menu->model))
291 menu->handler_id = g_signal_connect (menu->model, "items-changed",
292 G_CALLBACK (g_menu_exporter_menu_items_changed), menu);
293  
294 menu->item_links = g_sequence_new (g_menu_exporter_link_free);
295  
296 n_items = g_menu_model_get_n_items (menu->model);
297 if (n_items)
298 g_menu_exporter_menu_items_changed (menu->model, 0, 0, n_items, menu);
299 }
300  
301 static GMenuExporterMenu *
302 g_menu_exporter_menu_new (GMenuExporterGroup *group,
303 guint id,
304 GMenuModel *model)
305 {
306 GMenuExporterMenu *menu;
307  
308 menu = g_slice_new0 (GMenuExporterMenu);
309 menu->group = group;
310 menu->id = id;
311 menu->model = g_object_ref (model);
312  
313 return menu;
314 }
315  
316 /* {{{1 GMenuExporterGroup */
317  
318 struct _GMenuExporterGroup
319 {
320 GMenuExporter *exporter;
321 guint id;
322  
323 GHashTable *menus;
324 guint next_menu_id;
325 gboolean prepared;
326  
327 gint subscribed;
328 };
329  
330 static void
331 g_menu_exporter_group_check_if_useless (GMenuExporterGroup *group)
332 {
333 if (g_hash_table_size (group->menus) == 0 && group->subscribed == 0)
334 {
335 g_menu_exporter_remove_group (group->exporter, group->id);
336  
337 g_hash_table_unref (group->menus);
338  
339 g_slice_free (GMenuExporterGroup, group);
340 }
341 }
342  
343 static void
344 g_menu_exporter_group_subscribe (GMenuExporterGroup *group,
345 GVariantBuilder *builder)
346 {
347 GHashTableIter iter;
348 gpointer key, val;
349  
350 if (!group->prepared)
351 {
352 GMenuExporterMenu *menu;
353  
354 /* set this first, so that any menus created during the
355 * preparation of the first menu also end up in the prepared
356 * state.
357 * */
358 group->prepared = TRUE;
359  
360 menu = g_hash_table_lookup (group->menus, 0);
361  
362 /* If the group was created by a subscription and does not yet
363 * exist, it won't have a root menu...
364 *
365 * That menu will be prepared if it is ever added (due to
366 * group->prepared == TRUE).
367 */
368 if (menu)
369 g_menu_exporter_menu_prepare (menu);
370 }
371  
372 group->subscribed++;
373  
374 g_hash_table_iter_init (&iter, group->menus);
375 while (g_hash_table_iter_next (&iter, &key, &val))
376 {
377 guint id = GPOINTER_TO_INT (key);
378 GMenuExporterMenu *menu = val;
379  
380 if (!g_sequence_is_empty (menu->item_links))
381 {
382 g_variant_builder_open (builder, G_VARIANT_TYPE ("(uuaa{sv})"));
383 g_variant_builder_add (builder, "u", group->id);
384 g_variant_builder_add (builder, "u", id);
385 g_variant_builder_add_value (builder, g_menu_exporter_menu_list (menu));
386 g_variant_builder_close (builder);
387 }
388 }
389 }
390  
391 static void
392 g_menu_exporter_group_unsubscribe (GMenuExporterGroup *group,
393 gint count)
394 {
395 g_assert (group->subscribed >= count);
396  
397 group->subscribed -= count;
398  
399 g_menu_exporter_group_check_if_useless (group);
400 }
401  
402 static GMenuExporter *
403 g_menu_exporter_group_get_exporter (GMenuExporterGroup *group)
404 {
405 return group->exporter;
406 }
407  
408 static gboolean
409 g_menu_exporter_group_is_subscribed (GMenuExporterGroup *group)
410 {
411 return group->subscribed > 0;
412 }
413  
414 static guint
415 g_menu_exporter_group_get_id (GMenuExporterGroup *group)
416 {
417 return group->id;
418 }
419  
420 static void
421 g_menu_exporter_group_remove_menu (GMenuExporterGroup *group,
422 guint id)
423 {
424 g_hash_table_remove (group->menus, GINT_TO_POINTER (id));
425  
426 g_menu_exporter_group_check_if_useless (group);
427 }
428  
429 static GMenuExporterMenu *
430 g_menu_exporter_group_add_menu (GMenuExporterGroup *group,
431 GMenuModel *model)
432 {
433 GMenuExporterMenu *menu;
434 guint id;
435  
436 id = group->next_menu_id++;
437 menu = g_menu_exporter_menu_new (group, id, model);
438 g_hash_table_insert (group->menus, GINT_TO_POINTER (id), menu);
439  
440 if (group->prepared)
441 g_menu_exporter_menu_prepare (menu);
442  
443 return menu;
444 }
445  
446 static GMenuExporterGroup *
447 g_menu_exporter_group_new (GMenuExporter *exporter,
448 guint id)
449 {
450 GMenuExporterGroup *group;
451  
452 group = g_slice_new0 (GMenuExporterGroup);
453 group->menus = g_hash_table_new (NULL, NULL);
454 group->exporter = exporter;
455 group->id = id;
456  
457 return group;
458 }
459  
460 /* {{{1 GMenuExporterRemote */
461  
462 struct _GMenuExporterRemote
463 {
464 GMenuExporter *exporter;
465 GHashTable *watches;
466 guint watch_id;
467 };
468  
469 static void
470 g_menu_exporter_remote_subscribe (GMenuExporterRemote *remote,
471 guint group_id,
472 GVariantBuilder *builder)
473 {
474 GMenuExporterGroup *group;
475 guint count;
476  
477 count = (gsize) g_hash_table_lookup (remote->watches, GINT_TO_POINTER (group_id));
478 g_hash_table_insert (remote->watches, GINT_TO_POINTER (group_id), GINT_TO_POINTER (count + 1));
479  
480 /* Group will be created (as empty/unsubscribed if it does not exist) */
481 group = g_menu_exporter_lookup_group (remote->exporter, group_id);
482 g_menu_exporter_group_subscribe (group, builder);
483 }
484  
485 static void
486 g_menu_exporter_remote_unsubscribe (GMenuExporterRemote *remote,
487 guint group_id)
488 {
489 GMenuExporterGroup *group;
490 guint count;
491  
492 count = (gsize) g_hash_table_lookup (remote->watches, GINT_TO_POINTER (group_id));
493  
494 if (count == 0)
495 return;
496  
497 if (count != 1)
498 g_hash_table_insert (remote->watches, GINT_TO_POINTER (group_id), GINT_TO_POINTER (count - 1));
499 else
500 g_hash_table_remove (remote->watches, GINT_TO_POINTER (group_id));
501  
502 group = g_menu_exporter_lookup_group (remote->exporter, group_id);
503 g_menu_exporter_group_unsubscribe (group, 1);
504 }
505  
506 static gboolean
507 g_menu_exporter_remote_has_subscriptions (GMenuExporterRemote *remote)
508 {
509 return g_hash_table_size (remote->watches) != 0;
510 }
511  
512 static void
513 g_menu_exporter_remote_free (gpointer data)
514 {
515 GMenuExporterRemote *remote = data;
516 GHashTableIter iter;
517 gpointer key, val;
518  
519 g_hash_table_iter_init (&iter, remote->watches);
520 while (g_hash_table_iter_next (&iter, &key, &val))
521 {
522 GMenuExporterGroup *group;
523  
524 group = g_menu_exporter_lookup_group (remote->exporter, GPOINTER_TO_INT (key));
525 g_menu_exporter_group_unsubscribe (group, GPOINTER_TO_INT (val));
526 }
527  
528 g_bus_unwatch_name (remote->watch_id);
529 g_hash_table_unref (remote->watches);
530  
531 g_slice_free (GMenuExporterRemote, remote);
532 }
533  
534 static GMenuExporterRemote *
535 g_menu_exporter_remote_new (GMenuExporter *exporter,
536 guint watch_id)
537 {
538 GMenuExporterRemote *remote;
539  
540 remote = g_slice_new0 (GMenuExporterRemote);
541 remote->exporter = exporter;
542 remote->watches = g_hash_table_new (NULL, NULL);
543 remote->watch_id = watch_id;
544  
545 return remote;
546 }
547  
548 /* {{{1 GMenuExporter */
549  
550 struct _GMenuExporter
551 {
552 GDBusConnection *connection;
553 gchar *object_path;
554 guint registration_id;
555 GHashTable *groups;
556 guint next_group_id;
557  
558 GMenuExporterMenu *root;
559 GHashTable *remotes;
560 };
561  
562 static void
563 g_menu_exporter_name_vanished (GDBusConnection *connection,
564 const gchar *name,
565 gpointer user_data)
566 {
567 GMenuExporter *exporter = user_data;
568  
569 /* connection == NULL when we get called because the connection closed */
570 g_assert (exporter->connection == connection || connection == NULL);
571  
572 g_hash_table_remove (exporter->remotes, name);
573 }
574  
575 static GVariant *
576 g_menu_exporter_subscribe (GMenuExporter *exporter,
577 const gchar *sender,
578 GVariant *group_ids)
579 {
580 GMenuExporterRemote *remote;
581 GVariantBuilder builder;
582 GVariantIter iter;
583 guint32 id;
584  
585 remote = g_hash_table_lookup (exporter->remotes, sender);
586  
587 if (remote == NULL)
588 {
589 guint watch_id;
590  
591 watch_id = g_bus_watch_name_on_connection (exporter->connection, sender, G_BUS_NAME_WATCHER_FLAGS_NONE,
592 NULL, g_menu_exporter_name_vanished, exporter, NULL);
593 remote = g_menu_exporter_remote_new (exporter, watch_id);
594 g_hash_table_insert (exporter->remotes, g_strdup (sender), remote);
595 }
596  
597 g_variant_builder_init (&builder, G_VARIANT_TYPE ("(a(uuaa{sv}))"));
598  
599 g_variant_builder_open (&builder, G_VARIANT_TYPE ("a(uuaa{sv})"));
600  
601 g_variant_iter_init (&iter, group_ids);
602 while (g_variant_iter_next (&iter, "u", &id))
603 g_menu_exporter_remote_subscribe (remote, id, &builder);
604  
605 g_variant_builder_close (&builder);
606  
607 return g_variant_builder_end (&builder);
608 }
609  
610 static void
611 g_menu_exporter_unsubscribe (GMenuExporter *exporter,
612 const gchar *sender,
613 GVariant *group_ids)
614 {
615 GMenuExporterRemote *remote;
616 GVariantIter iter;
617 guint32 id;
618  
619 remote = g_hash_table_lookup (exporter->remotes, sender);
620  
621 if (remote == NULL)
622 return;
623  
624 g_variant_iter_init (&iter, group_ids);
625 while (g_variant_iter_next (&iter, "u", &id))
626 g_menu_exporter_remote_unsubscribe (remote, id);
627  
628 if (!g_menu_exporter_remote_has_subscriptions (remote))
629 g_hash_table_remove (exporter->remotes, sender);
630 }
631  
632 static void
633 g_menu_exporter_report (GMenuExporter *exporter,
634 GVariant *report)
635 {
636 GVariantBuilder builder;
637  
638 g_variant_builder_init (&builder, G_VARIANT_TYPE_TUPLE);
639 g_variant_builder_open (&builder, G_VARIANT_TYPE_ARRAY);
640 g_variant_builder_add_value (&builder, report);
641 g_variant_builder_close (&builder);
642  
643 g_dbus_connection_emit_signal (exporter->connection,
644 NULL,
645 exporter->object_path,
646 "org.gtk.Menus", "Changed",
647 g_variant_builder_end (&builder),
648 NULL);
649 }
650  
651 static void
652 g_menu_exporter_remove_group (GMenuExporter *exporter,
653 guint id)
654 {
655 g_hash_table_remove (exporter->groups, GINT_TO_POINTER (id));
656 }
657  
658 static GMenuExporterGroup *
659 g_menu_exporter_lookup_group (GMenuExporter *exporter,
660 guint group_id)
661 {
662 GMenuExporterGroup *group;
663  
664 group = g_hash_table_lookup (exporter->groups, GINT_TO_POINTER (group_id));
665  
666 if (group == NULL)
667 {
668 group = g_menu_exporter_group_new (exporter, group_id);
669 g_hash_table_insert (exporter->groups, GINT_TO_POINTER (group_id), group);
670 }
671  
672 return group;
673 }
674  
675 static GMenuExporterGroup *
676 g_menu_exporter_create_group (GMenuExporter *exporter)
677 {
678 GMenuExporterGroup *group;
679 guint id;
680  
681 id = exporter->next_group_id++;
682 group = g_menu_exporter_group_new (exporter, id);
683 g_hash_table_insert (exporter->groups, GINT_TO_POINTER (id), group);
684  
685 return group;
686 }
687  
688 static void
689 g_menu_exporter_free (gpointer user_data)
690 {
691 GMenuExporter *exporter = user_data;
692  
693 g_menu_exporter_menu_free (exporter->root);
694 g_hash_table_unref (exporter->remotes);
695 g_hash_table_unref (exporter->groups);
696 g_object_unref (exporter->connection);
697 g_free (exporter->object_path);
698  
699 g_slice_free (GMenuExporter, exporter);
700 }
701  
702 static void
703 g_menu_exporter_method_call (GDBusConnection *connection,
704 const gchar *sender,
705 const gchar *object_path,
706 const gchar *interface_name,
707 const gchar *method_name,
708 GVariant *parameters,
709 GDBusMethodInvocation *invocation,
710 gpointer user_data)
711 {
712 GMenuExporter *exporter = user_data;
713 GVariant *group_ids;
714  
715 group_ids = g_variant_get_child_value (parameters, 0);
716  
717 if (g_str_equal (method_name, "Start"))
718 g_dbus_method_invocation_return_value (invocation, g_menu_exporter_subscribe (exporter, sender, group_ids));
719  
720 else if (g_str_equal (method_name, "End"))
721 {
722 g_menu_exporter_unsubscribe (exporter, sender, group_ids);
723 g_dbus_method_invocation_return_value (invocation, NULL);
724 }
725  
726 else
727 g_assert_not_reached ();
728  
729 g_variant_unref (group_ids);
730 }
731  
732 /* {{{1 Public API */
733  
734 /**
735 * g_dbus_connection_export_menu_model:
736 * @connection: a #GDBusConnection
737 * @object_path: a D-Bus object path
738 * @menu: a #GMenuModel
739 * @error: return location for an error, or %NULL
740 *
741 * Exports @menu on @connection at @object_path.
742 *
743 * The implemented D-Bus API should be considered private.
744 * It is subject to change in the future.
745 *
746 * An object path can only have one menu model exported on it. If this
747 * constraint is violated, the export will fail and 0 will be
748 * returned (with @error set accordingly).
749 *
750 * You can unexport the menu model using
751 * g_dbus_connection_unexport_menu_model() with the return value of
752 * this function.
753 *
754 * Returns: the ID of the export (never zero), or 0 in case of failure
755 *
756 * Since: 2.32
757 */
758 guint
759 g_dbus_connection_export_menu_model (GDBusConnection *connection,
760 const gchar *object_path,
761 GMenuModel *menu,
762 GError **error)
763 {
764 const GDBusInterfaceVTable vtable = {
765 g_menu_exporter_method_call,
766 };
767 GMenuExporter *exporter;
768 guint id;
769  
770 exporter = g_slice_new0 (GMenuExporter);
771  
772 id = g_dbus_connection_register_object (connection, object_path, org_gtk_Menus_get_interface (),
773 &vtable, exporter, g_menu_exporter_free, error);
774  
775 if (id == 0)
776 {
777 g_slice_free (GMenuExporter, exporter);
778 return 0;
779 }
780  
781 exporter->connection = g_object_ref (connection);
782 exporter->object_path = g_strdup (object_path);
783 exporter->groups = g_hash_table_new (NULL, NULL);
784 exporter->remotes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_menu_exporter_remote_free);
785 exporter->root = g_menu_exporter_group_add_menu (g_menu_exporter_create_group (exporter), menu);
786  
787 return id;
788 }
789  
790 /**
791 * g_dbus_connection_unexport_menu_model:
792 * @connection: a #GDBusConnection
793 * @export_id: the ID from g_dbus_connection_export_menu_model()
794 *
795 * Reverses the effect of a previous call to
796 * g_dbus_connection_export_menu_model().
797 *
798 * It is an error to call this function with an ID that wasn't returned
799 * from g_dbus_connection_export_menu_model() or to call it with the
800 * same ID more than once.
801 *
802 * Since: 2.32
803 */
804 void
805 g_dbus_connection_unexport_menu_model (GDBusConnection *connection,
806 guint export_id)
807 {
808 g_dbus_connection_unregister_object (connection, export_id);
809 }
810  
811 /* {{{1 Epilogue */
812 /* vim:set foldmethod=marker: */