2 * Copyright © 2011 Canonical Ltd.
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.
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.
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
19 * Author: Ryan Lortie <desrt@desrt.ca>
22 #include "gdbusmenumodel.h"
24 #include "gmenumodel.h"
29 * SECTION:gdbusmenumodel
30 * @title: GDBusMenuModel
31 * @short_description: A D-Bus GMenuModel implementation
32 * @see_also: <link linkend="gio-GMenuModel-exporter">GMenuModel Exporter</link>
34 * #GDBusMenuModel is an implementation of #GMenuModel that can be used
35 * as a proxy for a menu model that is exported over D-Bus with
36 * g_dbus_connection_export_menu_model().
40 * There are 3 main (quasi-)classes involved here:
46 * Each of these classes exists as a parameterised singleton keyed to a
49 * - GDBusMenuPath represents a D-Bus object path on a particular
50 * unique bus name on a particular GDBusConnection and in a
51 * particular GMainContext.
53 * - GDBusMenuGroup represents a particular group on a particular
56 * - GDBusMenuModel represents a particular menu within a particular
59 * There are also two (and a half) utility structs:
61 * - PathIdentifier and ConstPathIdentifier
62 * - GDBusMenuModelItem
64 * PathIdentifier is the 4-tuple of (GMainContext, GDBusConnection,
65 * unique name, object path) that uniquely identifies a particular
66 * GDBusMenuPath. It holds ownership on each of these things, so we
67 * have a ConstPathIdentifier variant that does not.
69 * We have a 3-level hierarchy of hashtables:
71 * - a global hashtable (g_dbus_menu_paths) maps from PathIdentifier
74 * - each GDBusMenuPath has a hashtable mapping from guint (group
75 * number) to GDBusMenuGroup
77 * - each GDBusMenuGroup has a hashtable mapping from guint (menu
78 * number) to GDBusMenuModel.
80 * In this way, each quintuplet of (connection, bus name, object path,
81 * group id, menu id) maps to a single GDBusMenuModel instance that can be
82 * located via 3 hashtable lookups.
84 * All of the 3 classes are refcounted (GDBusMenuPath and
85 * GDBusMenuGroup manually, and GDBusMenuModel by virtue of being a
86 * GObject). The hashtables do not hold references -- rather, when the
87 * last reference is dropped, the object is removed from the hashtable.
89 * The hard references go in the other direction: GDBusMenuModel is created
90 * as the user requests it and only exists as long as the user holds a
91 * reference on it. GDBusMenuModel holds a reference on the GDBusMenuGroup
92 * from which it came. GDBusMenuGroup holds a reference on
95 * In addition to refcounts, each object has an 'active' variable (ints
96 * for GDBusMenuPath and GDBusMenuGroup, boolean for GDBusMenuModel).
98 * - GDBusMenuModel is inactive when created and becomes active only when
99 * first queried for information. This prevents extra work from
100 * happening just by someone acquiring a GDBusMenuModel (and not
101 * actually trying to display it yet).
103 * - The active count on GDBusMenuGroup is equal to the number of
104 * GDBusMenuModel instances in that group that are active. When the
105 * active count transitions from 0 to 1, the group calls the 'Start'
106 * method on the service to begin monitoring that group. When it
107 * drops from 1 to 0, the group calls the 'End' method to stop
110 * - The active count on GDBusMenuPath is equal to the number of
111 * GDBusMenuGroup instances on that path with a non-zero active
112 * count. When the active count transitions from 0 to 1, the path
113 * sets up a signal subscription to monitor any changes. The signal
114 * subscription is taken down when the active count transitions from
117 * When active, GDBusMenuPath gets incoming signals when changes occur.
118 * If the change signal mentions a group for which we currently have an
119 * active GDBusMenuGroup, the change signal is passed along to that
120 * group. If the group is inactive, the change signal is ignored.
122 * Most of the "work" occurs in GDBusMenuGroup. In addition to the
123 * hashtable of GDBusMenuModel instances, it keeps a hashtable of the actual
124 * menu contents, each encoded as GSequence of GDBusMenuModelItem. It
125 * initially populates this table with the results of the "Start" method
126 * call and then updates it according to incoming change signals. If
127 * the change signal mentions a menu for which we current have an active
128 * GDBusMenuModel, the change signal is passed along to that model. If the
129 * model is inactive, the change signal is ignored.
131 * GDBusMenuModelItem is just a pair of hashtables, one for the attributes
132 * and one for the links of the item. Both map strings to GVariant
133 * instances. In the case of links, the GVariant has type '(uu)' and is
134 * turned into a GDBusMenuModel at the point that the user pulls it through
137 * Following the "empty is the same as non-existent" rule, the hashtable
138 * of GSequence of GDBusMenuModelItem holds NULL for empty menus.
140 * GDBusMenuModel contains very little functionality of its own. It holds a
141 * (weak) reference to the GSequence of GDBusMenuModelItem contained in the
142 * GDBusMenuGroup. It uses this GSequence to implement the GMenuModel
143 * interface. It also emits the "items-changed" signal if it is active
144 * and it was told that the contents of the GSequence changed.
147 typedef struct _GDBusMenuGroup GDBusMenuGroup
;
148 typedef struct _GDBusMenuPath GDBusMenuPath
;
150 static void g_dbus_menu_group_changed (GDBusMenuGroup
*group
,
155 static void g_dbus_menu_model_changed (GDBusMenuModel
*proxy
,
160 static GDBusMenuGroup
* g_dbus_menu_group_get_from_path (GDBusMenuPath
*path
,
162 static GDBusMenuModel
* g_dbus_menu_model_get_from_group (GDBusMenuGroup
*group
,
165 /* PathIdentifier {{{1 */
168 GMainContext
*context
;
169 GDBusConnection
*connection
;
176 GMainContext
*context
;
177 GDBusConnection
*connection
;
178 const gchar
*bus_name
;
179 const gchar
*object_path
;
180 } ConstPathIdentifier
;
183 path_identifier_hash (gconstpointer data
)
185 ConstPathIdentifier
*id
= data
;
187 return g_str_hash (id
->object_path
);
191 path_identifier_equal (gconstpointer a
,
194 ConstPathIdentifier
*id_a
= a
;
195 ConstPathIdentifier
*id_b
= b
;
197 return id_a
->connection
== id_b
->connection
&&
198 g_str_equal (id_a
->bus_name
, id_b
->bus_name
) &&
199 g_str_equal (id_a
->object_path
, id_b
->object_path
);
203 path_identifier_free (PathIdentifier
*id
)
205 g_main_context_unref (id
->context
);
206 g_object_unref (id
->connection
);
207 g_free (id
->bus_name
);
208 g_free (id
->object_path
);
210 g_slice_free (PathIdentifier
, id
);
213 static PathIdentifier
*
214 path_identifier_new (ConstPathIdentifier
*cid
)
218 id
= g_slice_new (PathIdentifier
);
219 id
->context
= g_main_context_ref (cid
->context
);
220 id
->connection
= g_object_ref (cid
->connection
);
221 id
->bus_name
= g_strdup (cid
->bus_name
);
222 id
->object_path
= g_strdup (cid
->object_path
);
227 /* GDBusMenuPath {{{1 */
229 struct _GDBusMenuPath
239 static GHashTable
*g_dbus_menu_paths
;
241 static GDBusMenuPath
*
242 g_dbus_menu_path_ref (GDBusMenuPath
*path
)
250 g_dbus_menu_path_unref (GDBusMenuPath
*path
)
252 if (--path
->ref_count
== 0)
254 g_hash_table_remove (g_dbus_menu_paths
, path
->id
);
255 g_hash_table_unref (path
->groups
);
256 path_identifier_free (path
->id
);
258 g_slice_free (GDBusMenuPath
, path
);
263 g_dbus_menu_path_signal (GDBusConnection
*connection
,
264 const gchar
*sender_name
,
265 const gchar
*object_path
,
266 const gchar
*interface_name
,
267 const gchar
*signal_name
,
268 GVariant
*parameters
,
271 GDBusMenuPath
*path
= user_data
;
279 if (!g_variant_is_of_type (parameters
, G_VARIANT_TYPE ("(a(uuuuaa{sv}))")))
282 g_variant_get (parameters
, "(a(uuuuaa{sv}))", &iter
);
283 while (g_variant_iter_loop (iter
, "(uuuu@aa{sv})", &group_id
, &menu_id
, &position
, &removes
, &adds
))
285 GDBusMenuGroup
*group
;
287 group
= g_hash_table_lookup (path
->groups
, GINT_TO_POINTER (group_id
));
290 g_dbus_menu_group_changed (group
, menu_id
, position
, removes
, adds
);
292 g_variant_iter_free (iter
);
296 g_dbus_menu_path_activate (GDBusMenuPath
*path
)
298 if (path
->active
++ == 0)
299 path
->watch_id
= g_dbus_connection_signal_subscribe (path
->id
->connection
, path
->id
->bus_name
,
300 "org.gtk.Menus", "Changed", path
->id
->object_path
,
301 NULL
, G_DBUS_SIGNAL_FLAGS_NONE
,
302 g_dbus_menu_path_signal
, path
, NULL
);
306 g_dbus_menu_path_deactivate (GDBusMenuPath
*path
)
308 if (--path
->active
== 0)
309 g_dbus_connection_signal_unsubscribe (path
->id
->connection
, path
->watch_id
);
312 static GDBusMenuPath
*
313 g_dbus_menu_path_get (GMainContext
*context
,
314 GDBusConnection
*connection
,
315 const gchar
*bus_name
,
316 const gchar
*object_path
)
318 ConstPathIdentifier cid
= { context
, connection
, bus_name
, object_path
};
321 if (g_dbus_menu_paths
== NULL
)
322 g_dbus_menu_paths
= g_hash_table_new (path_identifier_hash
, path_identifier_equal
);
324 path
= g_hash_table_lookup (g_dbus_menu_paths
, &cid
);
328 path
= g_slice_new (GDBusMenuPath
);
329 path
->id
= path_identifier_new (&cid
);
330 path
->groups
= g_hash_table_new (NULL
, NULL
);
334 g_hash_table_insert (g_dbus_menu_paths
, path
->id
, path
);
337 return g_dbus_menu_path_ref (path
);
340 /* GDBusMenuGroup, GDBusMenuModelItem {{{1 */
348 struct _GDBusMenuGroup
353 GHashTable
*proxies
; /* uint -> unowned GDBusMenuModel */
354 GHashTable
*menus
; /* uint -> owned GSequence */
362 GHashTable
*attributes
;
364 } GDBusMenuModelItem
;
366 static GDBusMenuGroup
*
367 g_dbus_menu_group_ref (GDBusMenuGroup
*group
)
375 g_dbus_menu_group_unref (GDBusMenuGroup
*group
)
377 if (--group
->ref_count
== 0)
379 g_assert (group
->state
== GROUP_OFFLINE
);
380 g_assert (group
->active
== 0);
382 g_hash_table_remove (group
->path
->groups
, GINT_TO_POINTER (group
->id
));
383 g_hash_table_unref (group
->proxies
);
385 g_dbus_menu_path_unref (group
->path
);
387 g_slice_free (GDBusMenuGroup
, group
);
392 g_dbus_menu_model_item_free (gpointer data
)
394 GDBusMenuModelItem
*item
= data
;
396 g_hash_table_unref (item
->attributes
);
397 g_hash_table_unref (item
->links
);
399 g_slice_free (GDBusMenuModelItem
, item
);
402 static GDBusMenuModelItem
*
403 g_dbus_menu_group_create_item (GVariant
*description
)
405 GDBusMenuModelItem
*item
;
410 item
= g_slice_new (GDBusMenuModelItem
);
411 item
->attributes
= g_hash_table_new_full (g_str_hash
, g_str_equal
, g_free
, (GDestroyNotify
) g_variant_unref
);
412 item
->links
= g_hash_table_new_full (g_str_hash
, g_str_equal
, g_free
, (GDestroyNotify
) g_variant_unref
);
414 g_variant_iter_init (&iter
, description
);
415 while (g_variant_iter_loop (&iter
, "{&sv}", &key
, &value
))
417 /* key + 1 to skip the ':' */
418 g_hash_table_insert (item
->links
, g_strdup (key
+ 1), g_variant_ref (value
));
420 g_hash_table_insert (item
->attributes
, g_strdup (key
), g_variant_ref (value
));
426 * GDBusMenuGroup can be in three states:
428 * OFFLINE: not subscribed to this group
429 * PENDING: we made the call to subscribe to this group, but the result
430 * has not come back yet
431 * ONLINE: we are fully subscribed
433 * We can get into some nasty situations where we make a call due to an
434 * activation request but receive a deactivation request before the call
435 * returns. If another activation request occurs then we could risk
436 * sending a Start request even though one is already in progress. For
437 * this reason, we have to carefully consider what to do in each of the
438 * three states for each of the following situations:
440 * - activation requested
441 * - deactivation requested
442 * - Start call finishes
444 * To simplify things a bit, we do not have a callback for the Stop
445 * call. We just send it and assume that it takes effect immediately.
447 * Activation requested:
448 * OFFLINE: make the Start call and transition to PENDING
449 * PENDING: do nothing -- call is already in progress.
450 * ONLINE: this should not be possible
452 * Deactivation requested:
453 * OFFLINE: this should not be possible
454 * PENDING: do nothing -- handle it when the Start call finishes
455 * ONLINE: send the Stop call and move to OFFLINE immediately
457 * Start call finishes:
458 * OFFLINE: this should not be possible
460 * If we should be active (ie: active count > 0): move to ONLINE
461 * If not: send Stop call and move to OFFLINE immediately
462 * ONLINE: this should not be possible
464 * We have to take care with regards to signal subscriptions (ie:
465 * activation of the GDBusMenuPath). The signal subscription is always
466 * established when transitioning from OFFLINE to PENDING and taken down
467 * when transitioning to OFFLINE (from either PENDING or ONLINE).
469 * Since there are two places where we transition to OFFLINE, we split
470 * that code out into a separate function.
473 g_dbus_menu_group_go_offline (GDBusMenuGroup
*group
)
475 g_dbus_menu_path_deactivate (group
->path
);
476 g_dbus_connection_call (group
->path
->id
->connection
,
477 group
->path
->id
->bus_name
,
478 group
->path
->id
->object_path
,
479 "org.gtk.Menus", "End",
480 g_variant_new_parsed ("([ %u ],)", group
->id
),
481 NULL
, G_DBUS_CALL_FLAGS_NONE
, -1,
483 group
->state
= GROUP_OFFLINE
;
488 g_dbus_menu_group_start_ready (GObject
*source_object
,
489 GAsyncResult
*result
,
492 GDBusConnection
*connection
= G_DBUS_CONNECTION (source_object
);
493 GDBusMenuGroup
*group
= user_data
;
496 g_assert (group
->state
== GROUP_PENDING
);
498 reply
= g_dbus_connection_call_finish (connection
, result
, NULL
);
502 group
->state
= GROUP_ONLINE
;
504 /* If we receive no reply, just act like we got an empty reply. */
512 g_variant_get (reply
, "(a(uuaa{sv}))", &iter
);
513 while (g_variant_iter_loop (iter
, "(uu@aa{sv})", &group_id
, &menu_id
, &items
))
514 if (group_id
== group
->id
)
515 g_dbus_menu_group_changed (group
, menu_id
, 0, 0, items
);
516 g_variant_iter_free (iter
);
520 g_dbus_menu_group_go_offline (group
);
523 g_variant_unref (reply
);
525 g_dbus_menu_group_unref (group
);
529 g_dbus_menu_group_activate (GDBusMenuGroup
*group
)
531 if (group
->active
++ == 0)
533 g_assert (group
->state
!= GROUP_ONLINE
);
535 if (group
->state
== GROUP_OFFLINE
)
537 g_dbus_menu_path_activate (group
->path
);
539 g_dbus_connection_call (group
->path
->id
->connection
,
540 group
->path
->id
->bus_name
,
541 group
->path
->id
->object_path
,
542 "org.gtk.Menus", "Start",
543 g_variant_new_parsed ("([ %u ],)", group
->id
),
544 G_VARIANT_TYPE ("(a(uuaa{sv}))"),
545 G_DBUS_CALL_FLAGS_NONE
, -1, NULL
,
546 g_dbus_menu_group_start_ready
,
547 g_dbus_menu_group_ref (group
));
548 group
->state
= GROUP_PENDING
;
554 g_dbus_menu_group_deactivate (GDBusMenuGroup
*group
)
556 if (--group
->active
== 0)
558 g_assert (group
->state
!= GROUP_OFFLINE
);
560 if (group
->state
== GROUP_ONLINE
)
562 /* We are here because nobody is watching, so just free
563 * everything and don't bother with the notifications.
565 g_hash_table_remove_all (group
->menus
);
567 g_dbus_menu_group_go_offline (group
);
573 g_dbus_menu_group_changed (GDBusMenuGroup
*group
,
579 GSequenceIter
*point
;
581 GDBusMenuModel
*proxy
;
586 /* We could have signals coming to us when we're not active (due to
587 * some other process having subscribed to this group) or when we're
588 * pending. In both of those cases, we want to ignore the signal
589 * since we'll get our own information when we call "Start" for
592 if (group
->state
!= GROUP_ONLINE
)
595 items
= g_hash_table_lookup (group
->menus
, GINT_TO_POINTER (menu_id
));
599 items
= g_sequence_new (g_dbus_menu_model_item_free
);
600 g_hash_table_insert (group
->menus
, GINT_TO_POINTER (menu_id
), items
);
603 point
= g_sequence_get_iter_at_pos (items
, position
+ removed
);
605 g_return_if_fail (point
!= NULL
);
609 GSequenceIter
*start
;
611 start
= g_sequence_get_iter_at_pos (items
, position
);
612 g_sequence_remove_range (start
, point
);
615 n_added
= g_variant_iter_init (&iter
, added
);
616 while (g_variant_iter_loop (&iter
, "@a{sv}", &item
))
617 g_sequence_insert_before (point
, g_dbus_menu_group_create_item (item
));
619 if (g_sequence_get_length (items
) == 0)
621 g_hash_table_remove (group
->menus
, GINT_TO_POINTER (menu_id
));
625 if ((proxy
= g_hash_table_lookup (group
->proxies
, GINT_TO_POINTER (menu_id
))))
626 g_dbus_menu_model_changed (proxy
, items
, position
, removed
, n_added
);
629 static GDBusMenuGroup
*
630 g_dbus_menu_group_get_from_path (GDBusMenuPath
*path
,
633 GDBusMenuGroup
*group
;
635 group
= g_hash_table_lookup (path
->groups
, GINT_TO_POINTER (group_id
));
639 group
= g_slice_new (GDBusMenuGroup
);
640 group
->path
= g_dbus_menu_path_ref (path
);
641 group
->id
= group_id
;
642 group
->proxies
= g_hash_table_new (NULL
, NULL
);
643 group
->menus
= g_hash_table_new_full (NULL
, NULL
, NULL
, (GDestroyNotify
) g_sequence_free
);
644 group
->state
= GROUP_OFFLINE
;
646 group
->ref_count
= 0;
648 g_hash_table_insert (path
->groups
, GINT_TO_POINTER (group
->id
), group
);
651 return g_dbus_menu_group_ref (group
);
654 static GDBusMenuGroup
*
655 g_dbus_menu_group_get (GMainContext
*context
,
656 GDBusConnection
*connection
,
657 const gchar
*bus_name
,
658 const gchar
*object_path
,
661 GDBusMenuGroup
*group
;
664 path
= g_dbus_menu_path_get (context
, connection
, bus_name
, object_path
);
665 group
= g_dbus_menu_group_get_from_path (path
, group_id
);
666 g_dbus_menu_path_unref (path
);
671 /* GDBusMenuModel {{{1 */
673 typedef GMenuModelClass GDBusMenuModelClass
;
674 struct _GDBusMenuModel
678 GDBusMenuGroup
*group
;
681 GSequence
*items
; /* unowned */
685 G_DEFINE_TYPE (GDBusMenuModel
, g_dbus_menu_model
, G_TYPE_MENU_MODEL
)
688 g_dbus_menu_model_is_mutable (GMenuModel
*model
)
694 g_dbus_menu_model_get_n_items (GMenuModel
*model
)
696 GDBusMenuModel
*proxy
= G_DBUS_MENU_MODEL (model
);
700 g_dbus_menu_group_activate (proxy
->group
);
701 proxy
->active
= TRUE
;
704 return proxy
->items
? g_sequence_get_length (proxy
->items
) : 0;
708 g_dbus_menu_model_get_item_attributes (GMenuModel
*model
,
712 GDBusMenuModel
*proxy
= G_DBUS_MENU_MODEL (model
);
713 GDBusMenuModelItem
*item
;
716 g_return_if_fail (proxy
->active
);
717 g_return_if_fail (proxy
->items
);
719 iter
= g_sequence_get_iter_at_pos (proxy
->items
, item_index
);
720 g_return_if_fail (iter
);
722 item
= g_sequence_get (iter
);
723 g_return_if_fail (item
);
725 *table
= g_hash_table_ref (item
->attributes
);
729 g_dbus_menu_model_get_item_links (GMenuModel
*model
,
733 GDBusMenuModel
*proxy
= G_DBUS_MENU_MODEL (model
);
734 GDBusMenuModelItem
*item
;
737 g_return_if_fail (proxy
->active
);
738 g_return_if_fail (proxy
->items
);
740 iter
= g_sequence_get_iter_at_pos (proxy
->items
, item_index
);
741 g_return_if_fail (iter
);
743 item
= g_sequence_get (iter
);
744 g_return_if_fail (item
);
746 *table
= g_hash_table_new_full (g_str_hash
, g_str_equal
, g_free
, g_object_unref
);
753 g_hash_table_iter_init (&tmp
, item
->links
);
754 while (g_hash_table_iter_next (&tmp
, &key
, &value
))
756 if (g_variant_is_of_type (value
, G_VARIANT_TYPE ("(uu)")))
758 guint group_id
, menu_id
;
759 GDBusMenuGroup
*group
;
760 GDBusMenuModel
*link
;
762 g_variant_get (value
, "(uu)", &group_id
, &menu_id
);
764 /* save the hash lookup in a relatively common case */
765 if (proxy
->group
->id
!= group_id
)
766 group
= g_dbus_menu_group_get_from_path (proxy
->group
->path
, group_id
);
768 group
= g_dbus_menu_group_ref (proxy
->group
);
770 link
= g_dbus_menu_model_get_from_group (group
, menu_id
);
772 g_hash_table_insert (*table
, g_strdup (key
), link
);
774 g_dbus_menu_group_unref (group
);
781 g_dbus_menu_model_finalize (GObject
*object
)
783 GDBusMenuModel
*proxy
= G_DBUS_MENU_MODEL (object
);
786 g_dbus_menu_group_deactivate (proxy
->group
);
788 g_hash_table_remove (proxy
->group
->proxies
, GINT_TO_POINTER (proxy
->id
));
789 g_dbus_menu_group_unref (proxy
->group
);
791 G_OBJECT_CLASS (g_dbus_menu_model_parent_class
)
796 g_dbus_menu_model_init (GDBusMenuModel
*proxy
)
801 g_dbus_menu_model_class_init (GDBusMenuModelClass
*class)
803 GObjectClass
*object_class
= G_OBJECT_CLASS (class);
805 class->is_mutable
= g_dbus_menu_model_is_mutable
;
806 class->get_n_items
= g_dbus_menu_model_get_n_items
;
807 class->get_item_attributes
= g_dbus_menu_model_get_item_attributes
;
808 class->get_item_links
= g_dbus_menu_model_get_item_links
;
810 object_class
->finalize
= g_dbus_menu_model_finalize
;
814 g_dbus_menu_model_changed (GDBusMenuModel
*proxy
,
820 proxy
->items
= items
;
822 if (proxy
->active
&& (removed
|| added
))
823 g_menu_model_items_changed (G_MENU_MODEL (proxy
), position
, removed
, added
);
826 static GDBusMenuModel
*
827 g_dbus_menu_model_get_from_group (GDBusMenuGroup
*group
,
830 GDBusMenuModel
*proxy
;
832 proxy
= g_hash_table_lookup (group
->proxies
, GINT_TO_POINTER (menu_id
));
834 g_object_ref (proxy
);
838 proxy
= g_object_new (G_TYPE_DBUS_MENU_MODEL
, NULL
);
839 proxy
->items
= g_hash_table_lookup (group
->menus
, GINT_TO_POINTER (menu_id
));
840 g_hash_table_insert (group
->proxies
, GINT_TO_POINTER (menu_id
), proxy
);
841 proxy
->group
= g_dbus_menu_group_ref (group
);
849 * g_dbus_menu_model_get:
850 * @connection: a #GDBusConnection
851 * @bus_name: the bus name which exports the menu model
852 * @object_path: the object path at which the menu model is exported
854 * Obtains a #GDBusMenuModel for the menu model which is exported
855 * at the given @bus_name and @object_path.
857 * The thread default main context is taken at the time of this call.
858 * All signals on the menu model (and any linked models) are reported
859 * with respect to this context. All calls on the returned menu model
860 * (and linked models) must also originate from this same context, with
861 * the thread default main context unchanged.
863 * Returns: (transfer full): a #GDBusMenuModel object. Free with
869 g_dbus_menu_model_get (GDBusConnection
*connection
,
870 const gchar
*bus_name
,
871 const gchar
*object_path
)
873 GDBusMenuGroup
*group
;
874 GDBusMenuModel
*proxy
;
875 GMainContext
*context
;
877 context
= g_main_context_get_thread_default ();
879 context
= g_main_context_default ();
881 group
= g_dbus_menu_group_get (context
, connection
, bus_name
, object_path
, 0);
882 proxy
= g_dbus_menu_model_get_from_group (group
, 0);
883 g_dbus_menu_group_unref (group
);
890 dump_proxy (gpointer key
, gpointer value
, gpointer data
)
892 GDBusMenuModel
*proxy
= value
;
894 g_print (" menu %d refcount %d active %d\n",
895 proxy
->id
, G_OBJECT (proxy
)->ref_count
, proxy
->active
);
899 dump_group (gpointer key
, gpointer value
, gpointer data
)
901 GDBusMenuGroup
*group
= value
;
903 g_print (" group %d refcount %d state %d active %d\n",
904 group
->id
, group
->ref_count
, group
->state
, group
->active
);
906 g_hash_table_foreach (group
->proxies
, dump_proxy
, NULL
);
910 dump_path (gpointer key
, gpointer value
, gpointer data
)
912 PathIdentifier
*pid
= key
;
913 GDBusMenuPath
*path
= value
;
915 g_print ("%s active %d\n", pid
->object_path
, path
->active
);
916 g_hash_table_foreach (path
->groups
, dump_group
, NULL
);
920 g_dbus_menu_model_dump (void)
922 g_hash_table_foreach (g_dbus_menu_paths
, dump_path
, NULL
);
928 /* vim:set foldmethod=marker: */