glib/gio/gmenuproxy.c

/*
 * Copyright © 2011 Canonical Ltd.
 *
 * This library is free software; you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as
 * published by the Free Software Foundation; either version 2 of the
 * licence, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
 * USA.
 *
 * Author: Ryan Lortie <desrt@desrt.ca>
 */

#include "gmenuproxy.h"

#include "gmenumodel.h"

/* Prelude {{{1 */

/**
 * SECTION:gmenuproxy
 * @title: GMenuProxy
 * @short_description: A D-Bus GMenuModel implementation
 * @see_also: <link linkend="gio-GMenuModel-exporter">GMenuModel Exporter</link>
 *
 * #GMenuProxy is an implementation of #GMenuModel that can be used
 * as a proxy for a menu model that is exported over D-Bus with
 * g_menu_model_dbus_export_start().
 */

/*
 * There are 3 main (quasi-)classes involved here:
 *
 *   - GMenuProxyPath
 *   - GMenuProxyGroup
 *   - GMenuProxy
 *
 * Each of these classes exists as a parameterised singleton keyed to a
 * particular thing:
 *
 *   - GMenuProxyPath represents a D-Bus object path on a particular
 *     unique bus name on a particular GDBusConnection.
 *
 *   - GMenuProxyGroup represents a particular group on a particular
 *     GMenuProxyPath.
 *
 *   - GMenuProxy represents a particular menu within a particular
 *     GMenuProxyGroup.
 *
 * There are also two (and a half) utility structs:
 *
 *  - PathIdentifier and ConstPathIdentifier
 *  - GMenuProxyItem
 *
 * PathIdentifier is the triplet of (GDBusConnection, unique name,
 * object path) that uniquely identifies a particular GMenuProxyPath.
 * It holds ownership on each of these things, so we have a
 * ConstPathIdentifier variant that does not.
 *
 * We have a 3-level hierarchy of hashtables:
 *
 *   - a global hashtable (g_menu_proxy_paths) maps from PathIdentifier
 *     to GMenuProxyPath
 *
 *   - each GMenuProxyPath has a hashtable mapping from guint (group
 *     number) to GMenuProxyGroup
 *
 *   - each GMenuProxyGroup has a hashtable mapping from guint (menu
 *     number) to GMenuProxy.
 *
 * In this way, each quintuplet of (connection, bus name, object path,
 * group id, menu id) maps to a single GMenuProxy instance that can be
 * located via 3 hashtable lookups.
 *
 * All of the 3 classes are refcounted (GMenuProxyPath and
 * GMenuProxyGroup manually, and GMenuProxy by virtue of being a
 * GObject).  The hashtables do not hold references -- rather, when the
 * last reference is dropped, the object is removed from the hashtable.
 *
 * The hard references go in the other direction: GMenuProxy is created
 * as the user requests it and only exists as long as the user holds a
 * reference on it.  GMenuProxy holds a reference on the GMenuProxyGroup
 * from which it came. GMenuProxyGroup holds a reference on
 * GMenuProxyPath.
 *
 * In addition to refcounts, each object has an 'active' variable (ints
 * for GMenuProxyPath and GMenuProxyGroup, boolean for GMenuProxy).
 *
 *   - GMenuProxy is inactive when created and becomes active only when
 *     first queried for information.  This prevents extra work from
 *     happening just by someone acquiring a GMenuProxy (and not
 *     actually trying to display it yet).
 *
 *   - The active count on GMenuProxyGroup is equal to the number of
 *     GMenuProxy instances in that group that are active.  When the
 *     active count transitions from 0 to 1, the group calls the 'Start'
 *     method on the service to begin monitoring that group.  When it
 *     drops from 1 to 0, the group calls the 'End' method to stop
 *     monitoring.
 *
 *   - The active count on GMenuProxyPath is equal to the number of
 *     GMenuProxyGroup instances on that path with a non-zero active
 *     count.  When the active count transitions from 0 to 1, the path
 *     sets up a signal subscription to monitor any changes.  The signal
 *     subscription is taken down when the active count transitions from
 *     1 to 0.
 *
 * When active, GMenuProxyPath gets incoming signals when changes occur.
 * If the change signal mentions a group for which we currently have an
 * active GMenuProxyGroup, the change signal is passed along to that
 * group.  If the group is inactive, the change signal is ignored.
 *
 * Most of the "work" occurs in GMenuProxyGroup.  In addition to the
 * hashtable of GMenuProxy instances, it keeps a hashtable of the actual
 * menu contents, each encoded as GSequence of GMenuProxyItem.  It
 * initially populates this table with the results of the "Start" method
 * call and then updates it according to incoming change signals.  If
 * the change signal mentions a menu for which we current have an active
 * GMenuProxy, the change signal is passed along to that proxy.  If the
 * proxy is inactive, the change signal is ignored.
 *
 * GMenuProxyItem is just a pair of hashtables, one for the attributes
 * and one for the links of the item.  Both map strings to GVariant
 * instances.  In the case of links, the GVariant has type '(uu)' and is
 * turned into a GMenuProxy at the point that the user pulls it through
 * the API.
 *
 * Following the "empty is the same as non-existent" rule, the hashtable
 * of GSequence of GMenuProxyItem holds NULL for empty menus.
 *
 * GMenuProxy contains very little functionality of its own.  It holds a
 * (weak) reference to the GSequence of GMenuProxyItem contained in the
 * GMenuProxyGroup.  It uses this GSequence to implement the GMenuModel
 * interface.  It also emits the "items-changed" signal if it is active
 * and it was told that the contents of the GSequence changed.
 */

typedef struct _GMenuProxyGroup GMenuProxyGroup;
typedef struct _GMenuProxyPath GMenuProxyPath;

static void                     g_menu_proxy_group_changed              (GMenuProxyGroup *group,
                                                                         guint            menu_id,
                                                                         gint             position,
                                                                         gint             removed,
                                                                         GVariant        *added);
static void                     g_menu_proxy_changed                    (GMenuProxy      *proxy,
                                                                         GSequence       *items,
                                                                         gint             position,
                                                                         gint             removed,
                                                                         gint             added);
static GMenuProxyGroup *        g_menu_proxy_group_get_from_path        (GMenuProxyPath  *path,
                                                                         guint            group_id);
static GMenuProxy *             g_menu_proxy_get_from_group             (GMenuProxyGroup *group,
                                                                         guint            menu_id);

/* PathIdentifier {{{1 */
typedef struct
{
  GDBusConnection *connection;
  gchar *bus_name;
  gchar *object_path;
} PathIdentifier;

typedef const struct
{
  GDBusConnection *connection;
  const gchar *bus_name;
  const gchar *object_path;
} ConstPathIdentifier;

static guint
path_identifier_hash (gconstpointer data)
{
  ConstPathIdentifier *id = data;

  return g_str_hash (id->object_path);
}

static gboolean
path_identifier_equal (gconstpointer a,
                       gconstpointer b)
{
  ConstPathIdentifier *id_a = a;
  ConstPathIdentifier *id_b = b;

  return id_a->connection == id_b->connection &&
         g_str_equal (id_a->bus_name, id_b->bus_name) &&
         g_str_equal (id_a->object_path, id_b->object_path);
}

static void
path_identifier_free (PathIdentifier *id)
{
  g_object_unref (id->connection);
  g_free (id->bus_name);
  g_free (id->object_path);

  g_slice_free (PathIdentifier, id);
}

static PathIdentifier *
path_identifier_new (ConstPathIdentifier *cid)
{
  PathIdentifier *id;

  id = g_slice_new (PathIdentifier);
  id->connection = g_object_ref (cid->connection);
  id->bus_name = g_strdup (cid->bus_name);
  id->object_path = g_strdup (cid->object_path);

  return id;
}

/* GMenuProxyPath {{{1 */

struct _GMenuProxyPath
{
  PathIdentifier *id;
  gint ref_count;

  GHashTable *groups;
  gint active;
  guint watch_id;
};

static GHashTable *g_menu_proxy_paths;

static GMenuProxyPath *
g_menu_proxy_path_ref (GMenuProxyPath *path)
{
  path->ref_count++;

  return path;
}

static void
g_menu_proxy_path_unref (GMenuProxyPath *path)
{
  if (--path->ref_count == 0)
    {
      g_hash_table_remove (g_menu_proxy_paths, path->id);
      g_hash_table_unref (path->groups);
      path_identifier_free (path->id);

      g_slice_free (GMenuProxyPath, path);
    }
}

static void
g_menu_proxy_path_signal (GDBusConnection *connection,
                          const gchar     *sender_name,
                          const gchar     *object_path,
                          const gchar     *interface_name,
                          const gchar     *signal_name,
                          GVariant        *parameters,
                          gpointer         user_data)
{
  GMenuProxyPath *path = user_data;
  GVariantIter *iter;
  guint group_id;
  guint menu_id;
  guint position;
  guint removes;
  GVariant *adds;

  if (!g_variant_is_of_type (parameters, G_VARIANT_TYPE ("(a(uuuuaa{sv}))")))
    return;

  g_variant_get (parameters, "(a(uuuuaa{sv}))", &iter);
  while (g_variant_iter_loop (iter, "(uuuu@aa{sv})", &group_id, &menu_id, &position, &removes, &adds))
    {
      GMenuProxyGroup *group;

      group = g_hash_table_lookup (path->groups, GINT_TO_POINTER (group_id));

      if (group != NULL)
        g_menu_proxy_group_changed (group, menu_id, position, removes, adds);
    }
  g_variant_iter_free (iter);
}

static void
g_menu_proxy_path_activate (GMenuProxyPath *path)
{
  if (path->active++ == 0)
    path->watch_id = g_dbus_connection_signal_subscribe (path->id->connection, path->id->bus_name,
                                                         "org.gtk.Menus", "Changed", path->id->object_path,
                                                         NULL, G_DBUS_SIGNAL_FLAGS_NONE,
                                                         g_menu_proxy_path_signal, path, NULL);
}

static void
g_menu_proxy_path_deactivate (GMenuProxyPath *path)
{
  if (--path->active == 0)
    g_dbus_connection_signal_unsubscribe (path->id->connection, path->watch_id);
}

static GMenuProxyPath *
g_menu_proxy_path_get (GDBusConnection *connection,
                       const gchar     *bus_name,
                       const gchar     *object_path)
{
  ConstPathIdentifier cid = { connection, bus_name, object_path };
  GMenuProxyPath *path;

  if (g_menu_proxy_paths == NULL)
    g_menu_proxy_paths = g_hash_table_new (path_identifier_hash, path_identifier_equal);

  path = g_hash_table_lookup (g_menu_proxy_paths, &cid);

  if (path == NULL)
    {
      path = g_slice_new (GMenuProxyPath);
      path->id = path_identifier_new (&cid);
      path->groups = g_hash_table_new (NULL, NULL);
      path->ref_count = 0;
      path->active = 0;

      g_hash_table_insert (g_menu_proxy_paths, path->id, path);
    }

  return g_menu_proxy_path_ref (path);
}

/* GMenuProxyGroup, GMenuProxyItem {{{1 */
typedef enum
{
  GROUP_OFFLINE,
  GROUP_PENDING,
  GROUP_ONLINE
} GroupStatus;

struct _GMenuProxyGroup
{
  GMenuProxyPath *path;
  guint id;

  GHashTable *proxies; /* uint -> unowned GMenuProxy */
  GHashTable *menus;   /* uint -> owned GSequence */
  gint ref_count;
  GroupStatus state;
  gint active;
};

typedef struct
{
  GHashTable *attributes;
  GHashTable *links;
} GMenuProxyItem;

static GMenuProxyGroup *
g_menu_proxy_group_ref (GMenuProxyGroup *group)
{
  group->ref_count++;

  return group;
}

static void
g_menu_proxy_group_unref (GMenuProxyGroup *group)
{
  if (--group->ref_count == 0)
    {
      g_assert (group->state == GROUP_OFFLINE);
      g_assert (group->active == 0);

      g_hash_table_remove (group->path->groups, GINT_TO_POINTER (group->id));
      g_hash_table_unref (group->proxies);

      g_menu_proxy_path_unref (group->path);

      g_slice_free (GMenuProxyGroup, group);
    }
}

static void
g_menu_proxy_item_free (gpointer data)
{
  GMenuProxyItem *item = data;

  g_hash_table_unref (item->attributes);
  g_hash_table_unref (item->links);

  g_slice_free (GMenuProxyItem, item);
}

static GMenuProxyItem *
g_menu_proxy_group_create_item (GVariant *description)
{
  GMenuProxyItem *item;
  GVariantIter iter;
  const gchar *key;
  GVariant *value;

  item = g_slice_new (GMenuProxyItem);
  item->attributes = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);
  item->links = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, (GDestroyNotify) g_variant_unref);

  g_variant_iter_init (&iter, description);
  while (g_variant_iter_loop (&iter, "{&sv}", &key, &value))
    if (key[0] == ':')
      /* key + 1 to skip the ':' */
      g_hash_table_insert (item->links, g_strdup (key + 1), g_variant_ref (value));
    else
      g_hash_table_insert (item->attributes, g_strdup (key), g_variant_ref (value));

  return item;
}

/*
 * GMenuProxyGroup can be in three states:
 *
 * OFFLINE: not subscribed to this group
 * PENDING: we made the call to subscribe to this group, but the result
 *          has not come back yet
 * ONLINE: we are fully subscribed
 *
 * We can get into some nasty situations where we make a call due to an
 * activation request but receive a deactivation request before the call
 * returns.  If another activation request occurs then we could risk
 * sending a Start request even though one is already in progress.  For
 * this reason, we have to carefully consider what to do in each of the
 * three states for each of the following situations:
 *
 *  - activation requested
 *  - deactivation requested
 *  - Start call finishes
 *
 * To simplify things a bit, we do not have a callback for the Stop
 * call.  We just send it and assume that it takes effect immediately.
 *
 * Activation requested:
 *   OFFLINE: make the Start call and transition to PENDING
 *   PENDING: do nothing -- call is already in progress.
 *   ONLINE: this should not be possible
 *
 * Deactivation requested:
 *   OFFLINE: this should not be possible
 *   PENDING: do nothing -- handle it when the Start call finishes
 *   ONLINE: send the Stop call and move to OFFLINE immediately
 *
 * Start call finishes:
 *   OFFLINE: this should not be possible
 *   PENDING:
 *     If we should be active (ie: active count > 0): move to ONLINE
 *     If not: send Stop call and move to OFFLINE immediately
 *   ONLINE: this should not be possible
 *
 * We have to take care with regards to signal subscriptions (ie:
 * activation of the GMenuProxyPath).  The signal subscription is always
 * established when transitioning from OFFLINE to PENDING and taken down
 * when transitioning to OFFLINE (from either PENDING or ONLINE).
 *
 * Since there are two places where we transition to OFFLINE, we split
 * that code out into a separate function.
 */
static void
g_menu_proxy_group_go_offline (GMenuProxyGroup *group)
{
  g_menu_proxy_path_deactivate (group->path);
  g_dbus_connection_call (group->path->id->connection,
                          group->path->id->bus_name,
                          group->path->id->object_path,
                          "org.gtk.Menus", "End",
                          g_variant_new_parsed ("([ %u ],)", group->id),
                          NULL, G_DBUS_CALL_FLAGS_NONE, -1,
                          NULL, NULL, NULL);
  group->state = GROUP_OFFLINE;
}


static void
g_menu_proxy_group_start_ready (GObject      *source_object,
                                GAsyncResult *result,
                                gpointer      user_data)
{
  GDBusConnection *connection = G_DBUS_CONNECTION (source_object);
  GMenuProxyGroup *group = user_data;
  GVariant *reply;

  g_assert (group->state == GROUP_PENDING);

  reply = g_dbus_connection_call_finish (connection, result, NULL);

  if (group->active)
    {
      group->state = GROUP_ONLINE;

      /* If we receive no reply, just act like we got an empty reply. */
      if (reply)
        {
          GVariantIter *iter;
          GVariant *items;
          guint group_id;
          guint menu_id;

          g_variant_get (reply, "(a(uuaa{sv}))", &iter);
          while (g_variant_iter_loop (iter, "(uu@aa{sv})", &group_id, &menu_id, &items))
            if (group_id == group->id)
              g_menu_proxy_group_changed (group, menu_id, 0, 0, items);
          g_variant_iter_free (iter);
        }
    }
  else
    g_menu_proxy_group_go_offline (group);

  if (reply)
    g_variant_unref (reply);

  g_menu_proxy_group_unref (group);
}

static void
g_menu_proxy_group_activate (GMenuProxyGroup *group)
{
  if (group->active++ == 0)
    {
      g_assert (group->state != GROUP_ONLINE);

      if (group->state == GROUP_OFFLINE)
        {
          g_menu_proxy_path_activate (group->path);

          g_dbus_connection_call (group->path->id->connection,
                                  group->path->id->bus_name,
                                  group->path->id->object_path,
                                  "org.gtk.Menus", "Start",
                                  g_variant_new_parsed ("([ %u ],)", group->id),
                                  G_VARIANT_TYPE ("(a(uuaa{sv}))"),
                                  G_DBUS_CALL_FLAGS_NONE, -1, NULL,
                                  g_menu_proxy_group_start_ready,
                                  g_menu_proxy_group_ref (group));
          group->state = GROUP_PENDING;
        }
    }
}

static void
g_menu_proxy_group_deactivate (GMenuProxyGroup *group)
{
  if (--group->active == 0)
    {
      g_assert (group->state != GROUP_OFFLINE);

      if (group->state == GROUP_ONLINE)
        {
          /* We are here because nobody is watching, so just free
           * everything and don't bother with the notifications.
           */
          g_hash_table_remove_all (group->menus);

          g_menu_proxy_group_go_offline (group);
        }
    }
}

static void
g_menu_proxy_group_changed (GMenuProxyGroup *group,
                            guint            menu_id,
                            gint             position,
                            gint             removed,
                            GVariant        *added)
{
  GSequenceIter *point;
  GVariantIter iter;
  GMenuProxy *proxy;
  GSequence *items;
  GVariant *item;
  gint n_added;

  /* We could have signals coming to us when we're not active (due to
   * some other process having subscribed to this group) or when we're
   * pending.  In both of those cases, we want to ignore the signal
   * since we'll get our own information when we call "Start" for
   * ourselves.
   */
  if (group->state != GROUP_ONLINE)
    return;

  items = g_hash_table_lookup (group->menus, GINT_TO_POINTER (menu_id));

  if (items == NULL)
    {
      items = g_sequence_new (g_menu_proxy_item_free);
      g_hash_table_insert (group->menus, GINT_TO_POINTER (menu_id), items);
    }

  point = g_sequence_get_iter_at_pos (items, position + removed);

  g_return_if_fail (point != NULL);

  if (removed)
    {
      GSequenceIter *start;

      start = g_sequence_get_iter_at_pos (items, position);
      g_sequence_remove_range (start, point);
    }

  n_added = g_variant_iter_init (&iter, added);
  while (g_variant_iter_loop (&iter, "@a{sv}", &item))
    g_sequence_insert_before (point, g_menu_proxy_group_create_item (item));

  if (g_sequence_get_length (items) == 0)
    {
      g_hash_table_remove (group->menus, GINT_TO_POINTER (menu_id));
      items = NULL;
    }

  if ((proxy = g_hash_table_lookup (group->proxies, GINT_TO_POINTER (menu_id))))
    g_menu_proxy_changed (proxy, items, position, removed, n_added);
}

static GMenuProxyGroup *
g_menu_proxy_group_get_from_path (GMenuProxyPath *path,
                                  guint           group_id)
{
  GMenuProxyGroup *group;

  group = g_hash_table_lookup (path->groups, GINT_TO_POINTER (group_id));

  if (group == NULL)
    {
      group = g_slice_new (GMenuProxyGroup);
      group->path = g_menu_proxy_path_ref (path);
      group->id = group_id;
      group->proxies = g_hash_table_new (NULL, NULL);
      group->menus = g_hash_table_new_full (NULL, NULL, NULL, (GDestroyNotify) g_sequence_free);
      group->state = GROUP_OFFLINE;
      group->active = 0;
      group->ref_count = 0;

      g_hash_table_insert (path->groups, GINT_TO_POINTER (group->id), group);
    }

  return g_menu_proxy_group_ref (group);
}

static GMenuProxyGroup *
g_menu_proxy_group_get (GDBusConnection *connection,
                        const gchar     *bus_name,
                        const gchar     *object_path,
                        guint            group_id)
{
  GMenuProxyGroup *group;
  GMenuProxyPath *path;

  path = g_menu_proxy_path_get (connection, bus_name, object_path);
  group = g_menu_proxy_group_get_from_path (path, group_id);
  g_menu_proxy_path_unref (path);

  return group;
}

/* GMenuProxy {{{1 */

typedef GMenuModelClass GMenuProxyClass;
struct _GMenuProxy
{
  GMenuModel parent;

  GMenuProxyGroup *group;
  guint id;

  GSequence *items; /* unowned */
  gboolean active;
};

G_DEFINE_TYPE (GMenuProxy, g_menu_proxy, G_TYPE_MENU_MODEL)

static gboolean
g_menu_proxy_is_mutable (GMenuModel *model)
{
  return TRUE;
}

static gint
g_menu_proxy_get_n_items (GMenuModel *model)
{
  GMenuProxy *proxy = G_MENU_PROXY (model);

  if (!proxy->active)
    {
      g_menu_proxy_group_activate (proxy->group);
      proxy->active = TRUE;
    }

  return proxy->items ? g_sequence_get_length (proxy->items) : 0;
}

static void
g_menu_proxy_get_item_attributes (GMenuModel  *model,
                                  gint         item_index,
                                  GHashTable **table)
{
  GMenuProxy *proxy = G_MENU_PROXY (model);
  GMenuProxyItem *item;
  GSequenceIter *iter;

  g_return_if_fail (proxy->active);
  g_return_if_fail (proxy->items);

  iter = g_sequence_get_iter_at_pos (proxy->items, item_index);
  g_return_if_fail (iter);

  item = g_sequence_get (iter);
  g_return_if_fail (item);

  *table = g_hash_table_ref (item->attributes);
}

static void
g_menu_proxy_get_item_links (GMenuModel  *model,
                             gint         item_index,
                             GHashTable **table)
{
  GMenuProxy *proxy = G_MENU_PROXY (model);
  GMenuProxyItem *item;
  GSequenceIter *iter;

  g_return_if_fail (proxy->active);
  g_return_if_fail (proxy->items);

  iter = g_sequence_get_iter_at_pos (proxy->items, item_index);
  g_return_if_fail (iter);

  item = g_sequence_get (iter);
  g_return_if_fail (item);

  *table = g_hash_table_new_full (g_str_hash, g_str_equal, g_free, g_object_unref);

  {
    GHashTableIter tmp;
    gpointer key;
    gpointer value;

    g_hash_table_iter_init (&tmp, item->links);
    while (g_hash_table_iter_next (&tmp, &key, &value))
      {
        if (g_variant_is_of_type (value, G_VARIANT_TYPE ("(uu)")))
          {
            guint group_id, menu_id;
            GMenuProxyGroup *group;
            GMenuProxy *link;

            g_variant_get (value, "(uu)", &group_id, &menu_id);

            /* save the hash lookup in a relatively common case */
            if (proxy->group->id != group_id)
              group = g_menu_proxy_group_get_from_path (proxy->group->path, group_id);
            else
              group = g_menu_proxy_group_ref (proxy->group);

            link = g_menu_proxy_get_from_group (group, menu_id);

            g_hash_table_insert (*table, g_strdup (key), link);

            g_menu_proxy_group_unref (group);
          }
      }
  }
}

static void
g_menu_proxy_finalize (GObject *object)
{
  GMenuProxy *proxy = G_MENU_PROXY (object);

  if (proxy->active)
    g_menu_proxy_group_deactivate (proxy->group);

  g_hash_table_remove (proxy->group->proxies, GINT_TO_POINTER (proxy->id));
  g_menu_proxy_group_unref (proxy->group);

  G_OBJECT_CLASS (g_menu_proxy_parent_class)
    ->finalize (object);
}

static void
g_menu_proxy_init (GMenuProxy *proxy)
{
}

static void
g_menu_proxy_class_init (GMenuProxyClass *class)
{
  GObjectClass *object_class = G_OBJECT_CLASS (class);

  class->is_mutable = g_menu_proxy_is_mutable;
  class->get_n_items = g_menu_proxy_get_n_items;
  class->get_item_attributes = g_menu_proxy_get_item_attributes;
  class->get_item_links = g_menu_proxy_get_item_links;

  object_class->finalize = g_menu_proxy_finalize;
}

static void
g_menu_proxy_changed (GMenuProxy *proxy,
                      GSequence  *items,
                      gint        position,
                      gint        removed,
                      gint        added)
{
  proxy->items = items;

  if (proxy->active && (removed || added))
    g_menu_model_items_changed (G_MENU_MODEL (proxy), position, removed, added);
}

static GMenuProxy *
g_menu_proxy_get_from_group (GMenuProxyGroup *group,
                             guint            menu_id)
{
  GMenuProxy *proxy;

  proxy = g_hash_table_lookup (group->proxies, GINT_TO_POINTER (menu_id));
  if (proxy)
    g_object_ref (proxy);

  if (proxy == NULL)
    {
      proxy = g_object_new (G_TYPE_MENU_PROXY, NULL);
      proxy->items = g_hash_table_lookup (group->menus, GINT_TO_POINTER (menu_id));
      g_hash_table_insert (group->proxies, GINT_TO_POINTER (menu_id), proxy);
      proxy->group = g_menu_proxy_group_ref (group);
      proxy->id = menu_id;
    }

  return proxy;
}

/**
 * g_menu_proxy_get:
 * @connection: a #GDBusConnection
 * @bus_name: the bus name which exports the menu model
 * @object_path: the object path at which the menu model is exported
 *
 * Obtains a #GMenuProxy for the menu model which is exported
 * at the given @bus_name and @object_path.
 *
 * Returns: (transfer full): a #GMenuProxy object. Free with g_object_unref().
 */
GMenuProxy *
g_menu_proxy_get (GDBusConnection *connection,
                  const gchar     *bus_name,
                  const gchar     *object_path)
{
  GMenuProxyGroup *group;
  GMenuProxy *proxy;

  group = g_menu_proxy_group_get (connection, bus_name, object_path, 0);
  proxy = g_menu_proxy_get_from_group (group, 0);
  g_menu_proxy_group_unref (group);

  return proxy;
}

#if 0
static void
dump_proxy (gpointer key, gpointer value, gpointer data)
{
  GMenuProxy *proxy = value;

  g_print ("    menu %d refcount %d active %d\n",
           proxy->id, G_OBJECT (proxy)->ref_count, proxy->active);
}

static void
dump_group (gpointer key, gpointer value, gpointer data)
{
  GMenuProxyGroup *group = value;

  g_print ("  group %d refcount %d state %d active %d\n",
           group->id, group->ref_count, group->state, group->active);

  g_hash_table_foreach (group->proxies, dump_proxy, NULL);
}

static void
dump_path (gpointer key, gpointer value, gpointer data)
{
  PathIdentifier *pid = key;
  GMenuProxyPath *path = value;

  g_print ("%s active %d\n", pid->object_path, path->active);
  g_hash_table_foreach (path->groups, dump_group, NULL);
}

void
g_menu_proxy_dump (void)
{
  g_hash_table_foreach (g_menu_proxy_paths, dump_path, NULL);
}

#endif

/* Epilogue {{{1 */
/* vim:set foldmethod=marker: */