gio/gdbusmenumodel.c

   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, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  17  * USA.
  18  *
  19  * Author: Ryan Lortie <desrt@desrt.ca>
  20  */
  21
  22 #include "gdbusmenumodel.h"
  23
  24 #include "gmenumodel.h"
  25
  26 /* Prelude {{{1 */
  27
  28 /**
  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>
  33  *
  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().
  37  */
  38
  39 /*
  40  * There are 3 main (quasi-)classes involved here:
  41  *
  42  *   - GDBusMenuPath
  43  *   - GDBusMenuGroup
  44  *   - GDBusMenuModel
  45  *
  46  * Each of these classes exists as a parameterised singleton keyed to a
  47  * particular thing:
  48  *
  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.
  52  *
  53  *   - GDBusMenuGroup represents a particular group on a particular
  54  *     GDBusMenuPath.
  55  *
  56  *   - GDBusMenuModel represents a particular menu within a particular
  57  *     GDBusMenuGroup.
  58  *
  59  * There are also two (and a half) utility structs:
  60  *
  61  *  - PathIdentifier and ConstPathIdentifier
  62  *  - GDBusMenuModelItem
  63  *
  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.
  68  *
  69  * We have a 3-level hierarchy of hashtables:
  70  *
  71  *   - a global hashtable (g_dbus_menu_paths) maps from PathIdentifier
  72  *     to GDBusMenuPath
  73  *
  74  *   - each GDBusMenuPath has a hashtable mapping from guint (group
  75  *     number) to GDBusMenuGroup
  76  *
  77  *   - each GDBusMenuGroup has a hashtable mapping from guint (menu
  78  *     number) to GDBusMenuModel.
  79  *
  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.
  83  *
  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.
  88  *
  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
  93  * GDBusMenuPath.
  94  *
  95  * In addition to refcounts, each object has an 'active' variable (ints
  96  * for GDBusMenuPath and GDBusMenuGroup, boolean for GDBusMenuModel).
  97  *
  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).
 102  *
 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
 108  *     monitoring.
 109  *
 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
 115  *     1 to 0.
 116  *
 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.
 121  *
 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.
 130  *
 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
 135  * the API.
 136  *
 137  * Following the "empty is the same as non-existent" rule, the hashtable
 138  * of GSequence of GDBusMenuModelItem holds NULL for empty menus.
 139  *
 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.
 145  */
 146
 147 typedef struct _GDBusMenuGroup GDBusMenuGroup;
 148 typedef struct _GDBusMenuPath GDBusMenuPath;
 149
 150 static void                     g_dbus_menu_group_changed               (GDBusMenuGroup  *group,
 151                                                                          guint            menu_id,
 152                                                                          gint             position,
 153                                                                          gint             removed,
 154                                                                          GVariant        *added);
 155 static void                     g_dbus_menu_model_changed               (GDBusMenuModel  *proxy,
 156                                                                          GSequence       *items,
 157                                                                          gint             position,
 158                                                                          gint             removed,
 159                                                                          gint             added);
 160 static GDBusMenuGroup *         g_dbus_menu_group_get_from_path         (GDBusMenuPath   *path,
 161                                                                          guint            group_id);
 162 static GDBusMenuModel *         g_dbus_menu_model_get_from_group        (GDBusMenuGroup  *group,
 163                                                                          guint            menu_id);
 164
 165 /* PathIdentifier {{{1 */
 166 typedef struct
 167 {
 168   GMainContext *context;
 169   GDBusConnection *connection;
 170   gchar *bus_name;
 171   gchar *object_path;
 172 } PathIdentifier;
 173
 174 typedef const struct
 175 {
 176   GMainContext *context;
 177   GDBusConnection *connection;
 178   const gchar *bus_name;
 179   const gchar *object_path;
 180 } ConstPathIdentifier;
 181
 182 static guint
 183 path_identifier_hash (gconstpointer data)
 184 {
 185   ConstPathIdentifier *id = data;
 186
 187   return g_str_hash (id->object_path);
 188 }
 189
 190 static gboolean
 191 path_identifier_equal (gconstpointer a,
 192                        gconstpointer b)
 193 {
 194   ConstPathIdentifier *id_a = a;
 195   ConstPathIdentifier *id_b = b;
 196
 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);
 200 }
 201
 202 static void
 203 path_identifier_free (PathIdentifier *id)
 204 {
 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);
 209
 210   g_slice_free (PathIdentifier, id);
 211 }
 212
 213 static PathIdentifier *
 214 path_identifier_new (ConstPathIdentifier *cid)
 215 {
 216   PathIdentifier *id;
 217
 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);
 223
 224   return id;
 225 }
 226
 227 /* GDBusMenuPath {{{1 */
 228
 229 struct _GDBusMenuPath
 230 {
 231   PathIdentifier *id;
 232   gint ref_count;
 233
 234   GHashTable *groups;
 235   gint active;
 236   guint watch_id;
 237 };
 238
 239 static GHashTable *g_dbus_menu_paths;
 240
 241 static GDBusMenuPath *
 242 g_dbus_menu_path_ref (GDBusMenuPath *path)
 243 {
 244   path->ref_count++;
 245
 246   return path;
 247 }
 248
 249 static void
 250 g_dbus_menu_path_unref (GDBusMenuPath *path)
 251 {
 252   if (--path->ref_count == 0)
 253     {
 254       g_hash_table_remove (g_dbus_menu_paths, path->id);
 255       g_hash_table_unref (path->groups);
 256       path_identifier_free (path->id);
 257
 258       g_slice_free (GDBusMenuPath, path);
 259     }
 260 }
 261
 262 static void
 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,
 269                          gpointer         user_data)
 270 {
 271   GDBusMenuPath *path = user_data;
 272   GVariantIter *iter;
 273   guint group_id;
 274   guint menu_id;
 275   guint position;
 276   guint removes;
 277   GVariant *adds;
 278
 279   if (!g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(a(uuuuaa{sv}))")))
 280     return;
 281
 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))
 284     {
 285       GDBusMenuGroup *group;
 286
 287       group = g_hash_table_lookup (path->groups, GINT_TO_POINTER (group_id));
 288
 289       if (group != NULL)
 290         g_dbus_menu_group_changed (group, menu_id, position, removes, adds);
 291     }
 292   g_variant_iter_free (iter);
 293 }
 294
 295 static void
 296 g_dbus_menu_path_activate (GDBusMenuPath *path)
 297 {
 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);
 303 }
 304
 305 static void
 306 g_dbus_menu_path_deactivate (GDBusMenuPath *path)
 307 {
 308   if (--path->active == 0)
 309     g_dbus_connection_signal_unsubscribe (path->id->connection, path->watch_id);
 310 }
 311
 312 static GDBusMenuPath *
 313 g_dbus_menu_path_get (GMainContext    *context,
 314                       GDBusConnection *connection,
 315                       const gchar     *bus_name,
 316                       const gchar     *object_path)
 317 {
 318   ConstPathIdentifier cid = { context, connection, bus_name, object_path };
 319   GDBusMenuPath *path;
 320
 321   if (g_dbus_menu_paths == NULL)
 322     g_dbus_menu_paths = g_hash_table_new (path_identifier_hash, path_identifier_equal);
 323
 324   path = g_hash_table_lookup (g_dbus_menu_paths, &cid);
 325
 326   if (path == NULL)
 327     {
 328       path = g_slice_new (GDBusMenuPath);
 329       path->id = path_identifier_new (&cid);
 330       path->groups = g_hash_table_new (NULL, NULL);
 331       path->ref_count = 0;
 332       path->active = 0;
 333
 334       g_hash_table_insert (g_dbus_menu_paths, path->id, path);
 335     }
 336
 337   return g_dbus_menu_path_ref (path);
 338 }
 339
 340 /* GDBusMenuGroup, GDBusMenuModelItem {{{1 */
 341 typedef enum
 342 {
 343   GROUP_OFFLINE,
 344   GROUP_PENDING,
 345   GROUP_ONLINE
 346 } GroupStatus;
 347
 348 struct _GDBusMenuGroup
 349 {
 350   GDBusMenuPath *path;
 351   guint id;
 352
 353   GHashTable *proxies; /* uint -> unowned GDBusMenuModel */
 354   GHashTable *menus;   /* uint -> owned GSequence */
 355   gint ref_count;
 356   GroupStatus state;
 357   gint active;
 358 };
 359
 360 typedef struct
 361 {
 362   GHashTable *attributes;
 363   GHashTable *links;
 364 } GDBusMenuModelItem;
 365
 366 static GDBusMenuGroup *
 367 g_dbus_menu_group_ref (GDBusMenuGroup *group)
 368 {
 369   group->ref_count++;
 370
 371   return group;
 372 }
 373
 374 static void
 375 g_dbus_menu_group_unref (GDBusMenuGroup *group)
 376 {
 377   if (--group->ref_count == 0)
 378     {
 379       g_assert (group->state == GROUP_OFFLINE);
 380       g_assert (group->active == 0);
 381
 382       g_hash_table_remove (group->path->groups, GINT_TO_POINTER (group->id));
 383       g_hash_table_unref (group->proxies);
 384       g_hash_table_unref (group->menus);
 385
 386       g_dbus_menu_path_unref (group->path);
 387
 388       g_slice_free (GDBusMenuGroup, group);
 389     }
 390 }
 391
 392 static void
 393 g_dbus_menu_model_item_free (gpointer data)
 394 {
 395   GDBusMenuModelItem *item = data;
 396
 397   g_hash_table_unref (item->attributes);
 398   g_hash_table_unref (item->links);
 399
 400   g_slice_free (GDBusMenuModelItem, item);
 401 }
 402
 403 static GDBusMenuModelItem *
 404 g_dbus_menu_group_create_item (GVariant *description)
 405 {
 406   GDBusMenuModelItem *item;
 407   GVariantIter iter;
 408   const gchar *key;
 409   GVariant *value;
 410
 411   item = g_slice_new (GDBusMenuModelItem);
 412   item->attributes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
 413   item->links = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
 414
 415   g_variant_iter_init (&iter, description);
 416   while (g_variant_iter_loop (&iter, "{&sv}", &key, &value))
 417     if (key[0] == ':')
 418       /* key + 1 to skip the ':' */
 419       g_hash_table_insert (item->links, g_strdup (key + 1), g_variant_ref (value));
 420     else
 421       g_hash_table_insert (item->attributes, g_strdup (key), g_variant_ref (value));
 422
 423   return item;
 424 }
 425
 426 /*
 427  * GDBusMenuGroup can be in three states:
 428  *
 429  * OFFLINE: not subscribed to this group
 430  * PENDING: we made the call to subscribe to this group, but the result
 431  *          has not come back yet
 432  * ONLINE: we are fully subscribed
 433  *
 434  * We can get into some nasty situations where we make a call due to an
 435  * activation request but receive a deactivation request before the call
 436  * returns.  If another activation request occurs then we could risk
 437  * sending a Start request even though one is already in progress.  For
 438  * this reason, we have to carefully consider what to do in each of the
 439  * three states for each of the following situations:
 440  *
 441  *  - activation requested
 442  *  - deactivation requested
 443  *  - Start call finishes
 444  *
 445  * To simplify things a bit, we do not have a callback for the Stop
 446  * call.  We just send it and assume that it takes effect immediately.
 447  *
 448  * Activation requested:
 449  *   OFFLINE: make the Start call and transition to PENDING
 450  *   PENDING: do nothing -- call is already in progress.
 451  *   ONLINE: this should not be possible
 452  *
 453  * Deactivation requested:
 454  *   OFFLINE: this should not be possible
 455  *   PENDING: do nothing -- handle it when the Start call finishes
 456  *   ONLINE: send the Stop call and move to OFFLINE immediately
 457  *
 458  * Start call finishes:
 459  *   OFFLINE: this should not be possible
 460  *   PENDING:
 461  *     If we should be active (ie: active count > 0): move to ONLINE
 462  *     If not: send Stop call and move to OFFLINE immediately
 463  *   ONLINE: this should not be possible
 464  *
 465  * We have to take care with regards to signal subscriptions (ie:
 466  * activation of the GDBusMenuPath).  The signal subscription is always
 467  * established when transitioning from OFFLINE to PENDING and taken down
 468  * when transitioning to OFFLINE (from either PENDING or ONLINE).
 469  *
 470  * Since there are two places where we transition to OFFLINE, we split
 471  * that code out into a separate function.
 472  */
 473 static void
 474 g_dbus_menu_group_go_offline (GDBusMenuGroup *group)
 475 {
 476   g_dbus_menu_path_deactivate (group->path);
 477   g_dbus_connection_call (group->path->id->connection,
 478                           group->path->id->bus_name,
 479                           group->path->id->object_path,
 480                           "org.gtk.Menus", "End",
 481                           g_variant_new_parsed ("([ %u ],)", group->id),
 482                           NULL, G_DBUS_CALL_FLAGS_NONE, -1,
 483                           NULL, NULL, NULL);
 484   group->state = GROUP_OFFLINE;
 485 }
 486
 487
 488 static void
 489 g_dbus_menu_group_start_ready (GObject      *source_object,
 490                                GAsyncResult *result,
 491                                gpointer      user_data)
 492 {
 493   GDBusConnection *connection = G_DBUS_CONNECTION (source_object);
 494   GDBusMenuGroup *group = user_data;
 495   GVariant *reply;
 496
 497   g_assert (group->state == GROUP_PENDING);
 498
 499   reply = g_dbus_connection_call_finish (connection, result, NULL);
 500
 501   if (group->active)
 502     {
 503       group->state = GROUP_ONLINE;
 504
 505       /* If we receive no reply, just act like we got an empty reply. */
 506       if (reply)
 507         {
 508           GVariantIter *iter;
 509           GVariant *items;
 510           guint group_id;
 511           guint menu_id;
 512
 513           g_variant_get (reply, "(a(uuaa{sv}))", &iter);
 514           while (g_variant_iter_loop (iter, "(uu@aa{sv})", &group_id, &menu_id, &items))
 515             if (group_id == group->id)
 516               g_dbus_menu_group_changed (group, menu_id, 0, 0, items);
 517           g_variant_iter_free (iter);
 518         }
 519     }
 520   else
 521     g_dbus_menu_group_go_offline (group);
 522
 523   if (reply)
 524     g_variant_unref (reply);
 525
 526   g_dbus_menu_group_unref (group);
 527 }
 528
 529 static void
 530 g_dbus_menu_group_activate (GDBusMenuGroup *group)
 531 {
 532   if (group->active++ == 0)
 533     {
 534       g_assert (group->state != GROUP_ONLINE);
 535
 536       if (group->state == GROUP_OFFLINE)
 537         {
 538           g_dbus_menu_path_activate (group->path);
 539
 540           g_dbus_connection_call (group->path->id->connection,
 541                                   group->path->id->bus_name,
 542                                   group->path->id->object_path,
 543                                   "org.gtk.Menus", "Start",
 544                                   g_variant_new_parsed ("([ %u ],)", group->id),
 545                                   G_VARIANT_TYPE ("(a(uuaa{sv}))"),
 546                                   G_DBUS_CALL_FLAGS_NONE, -1, NULL,
 547                                   g_dbus_menu_group_start_ready,
 548                                   g_dbus_menu_group_ref (group));
 549           group->state = GROUP_PENDING;
 550         }
 551     }
 552 }
 553
 554 static void
 555 g_dbus_menu_group_deactivate (GDBusMenuGroup *group)
 556 {
 557   if (--group->active == 0)
 558     {
 559       g_assert (group->state != GROUP_OFFLINE);
 560
 561       if (group->state == GROUP_ONLINE)
 562         {
 563           /* We are here because nobody is watching, so just free
 564            * everything and don't bother with the notifications.
 565            */
 566           g_hash_table_remove_all (group->menus);
 567
 568           g_dbus_menu_group_go_offline (group);
 569         }
 570     }
 571 }
 572
 573 static void
 574 g_dbus_menu_group_changed (GDBusMenuGroup *group,
 575                            guint           menu_id,
 576                            gint            position,
 577                            gint            removed,
 578                            GVariant       *added)
 579 {
 580   GSequenceIter *point;
 581   GVariantIter iter;
 582   GDBusMenuModel *proxy;
 583   GSequence *items;
 584   GVariant *item;
 585   gint n_added;
 586
 587   /* We could have signals coming to us when we're not active (due to
 588    * some other process having subscribed to this group) or when we're
 589    * pending.  In both of those cases, we want to ignore the signal
 590    * since we'll get our own information when we call "Start" for
 591    * ourselves.
 592    */
 593   if (group->state != GROUP_ONLINE)
 594     return;
 595
 596   items = g_hash_table_lookup (group->menus, GINT_TO_POINTER (menu_id));
 597
 598   if (items == NULL)
 599     {
 600       items = g_sequence_new (g_dbus_menu_model_item_free);
 601       g_hash_table_insert (group->menus, GINT_TO_POINTER (menu_id), items);
 602     }
 603
 604   point = g_sequence_get_iter_at_pos (items, position + removed);
 605
 606   g_return_if_fail (point != NULL);
 607
 608   if (removed)
 609     {
 610       GSequenceIter *start;
 611
 612       start = g_sequence_get_iter_at_pos (items, position);
 613       g_sequence_remove_range (start, point);
 614     }
 615
 616   n_added = g_variant_iter_init (&iter, added);
 617   while (g_variant_iter_loop (&iter, "@a{sv}", &item))
 618     g_sequence_insert_before (point, g_dbus_menu_group_create_item (item));
 619
 620   if (g_sequence_get_length (items) == 0)
 621     {
 622       g_hash_table_remove (group->menus, GINT_TO_POINTER (menu_id));
 623       items = NULL;
 624     }
 625
 626   if ((proxy = g_hash_table_lookup (group->proxies, GINT_TO_POINTER (menu_id))))
 627     g_dbus_menu_model_changed (proxy, items, position, removed, n_added);
 628 }
 629
 630 static GDBusMenuGroup *
 631 g_dbus_menu_group_get_from_path (GDBusMenuPath *path,
 632                                  guint          group_id)
 633 {
 634   GDBusMenuGroup *group;
 635
 636   group = g_hash_table_lookup (path->groups, GINT_TO_POINTER (group_id));
 637
 638   if (group == NULL)
 639     {
 640       group = g_slice_new (GDBusMenuGroup);
 641       group->path = g_dbus_menu_path_ref (path);
 642       group->id = group_id;
 643       group->proxies = g_hash_table_new (NULL, NULL);
 644       group->menus = g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify) g_sequence_free);
 645       group->state = GROUP_OFFLINE;
 646       group->active = 0;
 647       group->ref_count = 0;
 648
 649       g_hash_table_insert (path->groups, GINT_TO_POINTER (group->id), group);
 650     }
 651
 652   return g_dbus_menu_group_ref (group);
 653 }
 654
 655 static GDBusMenuGroup *
 656 g_dbus_menu_group_get (GMainContext    *context,
 657                        GDBusConnection *connection,
 658                        const gchar     *bus_name,
 659                        const gchar     *object_path,
 660                        guint            group_id)
 661 {
 662   GDBusMenuGroup *group;
 663   GDBusMenuPath *path;
 664
 665   path = g_dbus_menu_path_get (context, connection, bus_name, object_path);
 666   group = g_dbus_menu_group_get_from_path (path, group_id);
 667   g_dbus_menu_path_unref (path);
 668
 669   return group;
 670 }
 671
 672 /* GDBusMenuModel {{{1 */
 673
 674 typedef GMenuModelClass GDBusMenuModelClass;
 675 struct _GDBusMenuModel
 676 {
 677   GMenuModel parent;
 678
 679   GDBusMenuGroup *group;
 680   guint id;
 681
 682   GSequence *items; /* unowned */
 683   gboolean active;
 684 };
 685
 686 G_DEFINE_TYPE (GDBusMenuModel, g_dbus_menu_model, G_TYPE_MENU_MODEL)
 687
 688 static gboolean
 689 g_dbus_menu_model_is_mutable (GMenuModel *model)
 690 {
 691   return TRUE;
 692 }
 693
 694 static gint
 695 g_dbus_menu_model_get_n_items (GMenuModel *model)
 696 {
 697   GDBusMenuModel *proxy = G_DBUS_MENU_MODEL (model);
 698
 699   if (!proxy->active)
 700     {
 701       g_dbus_menu_group_activate (proxy->group);
 702       proxy->active = TRUE;
 703     }
 704
 705   return proxy->items ? g_sequence_get_length (proxy->items) : 0;
 706 }
 707
 708 static void
 709 g_dbus_menu_model_get_item_attributes (GMenuModel  *model,
 710                                        gint         item_index,
 711                                        GHashTable **table)
 712 {
 713   GDBusMenuModel *proxy = G_DBUS_MENU_MODEL (model);
 714   GDBusMenuModelItem *item;
 715   GSequenceIter *iter;
 716
 717   g_return_if_fail (proxy->active);
 718   g_return_if_fail (proxy->items);
 719
 720   iter = g_sequence_get_iter_at_pos (proxy->items, item_index);
 721   g_return_if_fail (iter);
 722
 723   item = g_sequence_get (iter);
 724   g_return_if_fail (item);
 725
 726   *table = g_hash_table_ref (item->attributes);
 727 }
 728
 729 static void
 730 g_dbus_menu_model_get_item_links (GMenuModel  *model,
 731                                   gint         item_index,
 732                                   GHashTable **table)
 733 {
 734   GDBusMenuModel *proxy = G_DBUS_MENU_MODEL (model);
 735   GDBusMenuModelItem *item;
 736   GSequenceIter *iter;
 737
 738   g_return_if_fail (proxy->active);
 739   g_return_if_fail (proxy->items);
 740
 741   iter = g_sequence_get_iter_at_pos (proxy->items, item_index);
 742   g_return_if_fail (iter);
 743
 744   item = g_sequence_get (iter);
 745   g_return_if_fail (item);
 746
 747   *table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);
 748
 749   {
 750     GHashTableIter tmp;
 751     gpointer key;
 752     gpointer value;
 753
 754     g_hash_table_iter_init (&tmp, item->links);
 755     while (g_hash_table_iter_next (&tmp, &key, &value))
 756       {
 757         if (g_variant_is_of_type (value, G_VARIANT_TYPE ("(uu)")))
 758           {
 759             guint group_id, menu_id;
 760             GDBusMenuGroup *group;
 761             GDBusMenuModel *link;
 762
 763             g_variant_get (value, "(uu)", &group_id, &menu_id);
 764
 765             /* save the hash lookup in a relatively common case */
 766             if (proxy->group->id != group_id)
 767               group = g_dbus_menu_group_get_from_path (proxy->group->path, group_id);
 768             else
 769               group = g_dbus_menu_group_ref (proxy->group);
 770
 771             link = g_dbus_menu_model_get_from_group (group, menu_id);
 772
 773             g_hash_table_insert (*table, g_strdup (key), link);
 774
 775             g_dbus_menu_group_unref (group);
 776           }
 777       }
 778   }
 779 }
 780
 781 static void
 782 g_dbus_menu_model_finalize (GObject *object)
 783 {
 784   GDBusMenuModel *proxy = G_DBUS_MENU_MODEL (object);
 785
 786   if (proxy->active)
 787     g_dbus_menu_group_deactivate (proxy->group);
 788
 789   g_hash_table_remove (proxy->group->proxies, GINT_TO_POINTER (proxy->id));
 790   g_dbus_menu_group_unref (proxy->group);
 791
 792   G_OBJECT_CLASS (g_dbus_menu_model_parent_class)
 793     ->finalize (object);
 794 }
 795
 796 static void
 797 g_dbus_menu_model_init (GDBusMenuModel *proxy)
 798 {
 799 }
 800
 801 static void
 802 g_dbus_menu_model_class_init (GDBusMenuModelClass *class)
 803 {
 804   GObjectClass *object_class = G_OBJECT_CLASS (class);
 805
 806   class->is_mutable = g_dbus_menu_model_is_mutable;
 807   class->get_n_items = g_dbus_menu_model_get_n_items;
 808   class->get_item_attributes = g_dbus_menu_model_get_item_attributes;
 809   class->get_item_links = g_dbus_menu_model_get_item_links;
 810
 811   object_class->finalize = g_dbus_menu_model_finalize;
 812 }
 813
 814 static void
 815 g_dbus_menu_model_changed (GDBusMenuModel *proxy,
 816                            GSequence      *items,
 817                            gint            position,
 818                            gint            removed,
 819                            gint            added)
 820 {
 821   proxy->items = items;
 822
 823   if (proxy->active && (removed || added))
 824     g_menu_model_items_changed (G_MENU_MODEL (proxy), position, removed, added);
 825 }
 826
 827 static GDBusMenuModel *
 828 g_dbus_menu_model_get_from_group (GDBusMenuGroup *group,
 829                                   guint           menu_id)
 830 {
 831   GDBusMenuModel *proxy;
 832
 833   proxy = g_hash_table_lookup (group->proxies, GINT_TO_POINTER (menu_id));
 834   if (proxy)
 835     g_object_ref (proxy);
 836
 837   if (proxy == NULL)
 838     {
 839       proxy = g_object_new (G_TYPE_DBUS_MENU_MODEL, NULL);
 840       proxy->items = g_hash_table_lookup (group->menus, GINT_TO_POINTER (menu_id));
 841       g_hash_table_insert (group->proxies, GINT_TO_POINTER (menu_id), proxy);
 842       proxy->group = g_dbus_menu_group_ref (group);
 843       proxy->id = menu_id;
 844     }
 845
 846   return proxy;
 847 }
 848
 849 /**
 850  * g_dbus_menu_model_get:
 851  * @connection: a #GDBusConnection
 852  * @bus_name: the bus name which exports the menu model
 853  * @object_path: the object path at which the menu model is exported
 854  *
 855  * Obtains a #GDBusMenuModel for the menu model which is exported
 856  * at the given @bus_name and @object_path.
 857  *
 858  * The thread default main context is taken at the time of this call.
 859  * All signals on the menu model (and any linked models) are reported
 860  * with respect to this context.  All calls on the returned menu model
 861  * (and linked models) must also originate from this same context, with
 862  * the thread default main context unchanged.
 863  *
 864  * Returns: (transfer full): a #GDBusMenuModel object. Free with
 865  *     g_object_unref().
 866  *
 867  * Since: 2.32
 868  */
 869 GDBusMenuModel *
 870 g_dbus_menu_model_get (GDBusConnection *connection,
 871                        const gchar     *bus_name,
 872                        const gchar     *object_path)
 873 {
 874   GDBusMenuGroup *group;
 875   GDBusMenuModel *proxy;
 876   GMainContext *context;
 877
 878   context = g_main_context_get_thread_default ();
 879   if (context == NULL)
 880     context = g_main_context_default ();
 881
 882   group = g_dbus_menu_group_get (context, connection, bus_name, object_path, 0);
 883   proxy = g_dbus_menu_model_get_from_group (group, 0);
 884   g_dbus_menu_group_unref (group);
 885
 886   return proxy;
 887 }
 888
 889 #if 0
 890 static void
 891 dump_proxy (gpointer key, gpointer value, gpointer data)
 892 {
 893   GDBusMenuModel *proxy = value;
 894
 895   g_print ("    menu %d refcount %d active %d\n",
 896            proxy->id, G_OBJECT (proxy)->ref_count, proxy->active);
 897 }
 898
 899 static void
 900 dump_group (gpointer key, gpointer value, gpointer data)
 901 {
 902   GDBusMenuGroup *group = value;
 903
 904   g_print ("  group %d refcount %d state %d active %d\n",
 905            group->id, group->ref_count, group->state, group->active);
 906
 907   g_hash_table_foreach (group->proxies, dump_proxy, NULL);
 908 }
 909
 910 static void
 911 dump_path (gpointer key, gpointer value, gpointer data)
 912 {
 913   PathIdentifier *pid = key;
 914   GDBusMenuPath *path = value;
 915
 916   g_print ("%s active %d\n", pid->object_path, path->active);
 917   g_hash_table_foreach (path->groups, dump_group, NULL);
 918 }
 919
 920 void
 921 g_dbus_menu_model_dump (void)
 922 {
 923   g_hash_table_foreach (g_dbus_menu_paths, dump_path, NULL);
 924 }
 925
 926 #endif
 927
 928 /* Epilogue {{{1 */
 929 /* vim:set foldmethod=marker: */