~indicator-applet-developers/indicator-appmenu/trunk.13.04

#include <glib.h>

#include <gio/gio.h>

 

#include "indicator-appmenu-marshal.h"

 

/* Private parts */

 

        guint windowid;

        DbusmenuGtkClient * client;

        DbusmenuMenuitem * root;

        gboolean disabled;

        gboolean hidden;

        DbusmenuMenuitem * mi;

 

/* Prototypes */

 

static void root_changed            (DbusmenuClient * client, DbusmenuMenuitem * new_root, gpointer user_data);

static void event_status            (DbusmenuClient * client, DbusmenuMenuitem * mi, gchar * event, GVariant * evdata, guint timestamp, GError * error, gpointer user_data);

static void item_activate           (DbusmenuClient * client, DbusmenuMenuitem * item, guint timestamp, gpointer user_data);

static void menu_prop_changed       (DbusmenuMenuitem * item, const gchar * property, GVariant * value, gpointer user_data);

static void menu_child_realized     (DbusmenuMenuitem * child, gpointer user_data);

static void props_cb (GObject * object, GAsyncResult * res, gpointer user_data);

 

 

/* Build the one-time class */

static void

{

        GObjectClass *object_class = G_OBJECT_CLASS (klass);

 

 

        return;

}

 

/* Initialize the per-instance data */

static void

{

 

        priv->client = NULL;

        priv->props_cancel = NULL;

static void

free_entries(GObject *object, gboolean should_signal)

{

 

 

        if (priv->entries != NULL) {

                while (priv->entries->len > 0) {

                        entry = g_array_index(priv->entries, IndicatorObjectEntry *, 0);

                        g_array_remove_index(priv->entries, 0);

                        if (should_signal) {                    

                        }

                        entry_free(entry);

                }

 

/* Destroy objects */

static void

{

 

        free_entries(object, FALSE);

 

                priv->retry_timer = 0;

        }

 

        return;

}

 

retry_event (gpointer user_data)

{

        g_debug("Retrying event");

 

        dbusmenu_menuitem_handle_event(dbusmenu_client_get_root(DBUSMENU_CLIENT(priv->client)),

                                       "x-appmenu-retry-ping",

static void

event_status (DbusmenuClient * client, DbusmenuMenuitem * mi, gchar * event, GVariant * evdata, guint timestamp, GError * error, gpointer user_data)

{

 

        /* We don't care about status where there are no errors

           when we're in a happy state, just let them go. */

        if (error == NULL) {

                g_debug("Error state repaired");

                priv->error_state = FALSE;

 

                for (i = 0; i < priv->entries->len; i++) {

                        IndicatorObjectEntry * entry = g_array_index(priv->entries, IndicatorObjectEntry *, i);

                }

 

                if (priv->retry_timer != 0) {

        /* Uhg, means that events are breaking, now we need to

           try and handle that case. */

        priv->error_state = TRUE;

 

        for (i = 0; i < priv->entries->len; i++) {

                IndicatorObjectEntry * entry = g_array_index(priv->entries, IndicatorObjectEntry *, i);

}

 

static IndicatorObjectEntry *

{

 

        guint position = 0;

        for (position = 0; position < priv->entries->len; ++position) {

static void

item_activate (DbusmenuClient * client, DbusmenuMenuitem * item, guint timestamp, gpointer user_data)

{

 

        if (priv->root == NULL) {

                return;

        }

 

        if (entry == NULL) {

                /* Not found */

                return;

        }

 

 

        return;

}

static void

status_changed (DbusmenuClient * client, GParamSpec * pspec, gpointer user_data)

{

}

 

{

 

}

 

/* Build a new window menus object and attach to the signals to build

   up the representative menu. */

{

        g_debug("Creating new windows menu: %X, %s, %s", windowid, dbus_addr, dbus_object);

 

        g_return_val_if_fail(dbus_addr != NULL, NULL);

        g_return_val_if_fail(dbus_object != NULL, NULL);

 

 

        priv->windowid = windowid;

 

                return; // Must exit before accessing freed memory

        }

 

        g_return_if_fail(self != NULL);

 

 

        if (priv->props_cancel != NULL) {

                g_object_unref(priv->props_cancel);

}

 

/* Get the location of this entry */

{

        if (entry == NULL) {

                return 0;

        }

 

        guint i;

        for (i = 0; i < priv->entries->len; i++) {

                if (entry == g_array_index(priv->entries, IndicatorObjectEntry *, i)) {

                        break;

}

 

/* Get the entries that we have */

{

 

        int i;

        GList * output = NULL;

static void

new_root_helper (DbusmenuMenuitem * item, gpointer user_data)

{

        menu_entry_added(dbusmenu_client_get_root(DBUSMENU_CLIENT(priv->client)), item, priv->entries->len, user_data);

        return;

}

static void

root_changed (DbusmenuClient * client, DbusmenuMenuitem * new_root, gpointer user_data)

{

 

        /* Remove the old entries */

        free_entries(G_OBJECT(user_data), TRUE);

static void

menu_entry_added (DbusmenuMenuitem * root, DbusmenuMenuitem * newentry, guint position, gpointer user_data)

{

 

        g_signal_connect(G_OBJECT(newentry), DBUSMENU_MENUITEM_SIGNAL_REALIZED, G_CALLBACK(menu_entry_realized), user_data);

 

static void

menu_entry_realized (DbusmenuMenuitem * newentry, gpointer user_data)

{

 

        GtkMenu * menu = dbusmenu_gtkclient_menuitem_get_submenu(priv->client, newentry);

 

                entry->accessible_desc = g_variant_get_string(value, NULL);

 

                if (wmentry->wm != NULL) {

                }

        }

 

{

        /* Grab our values out to stack variables */

        DbusmenuMenuitem * newentry = DBUSMENU_MENUITEM(((gpointer *)user_data)[1]);

 

        g_return_if_fail(newentry != NULL);

        g_return_if_fail(wm != NULL);

                g_signal_handlers_disconnect_by_func(G_OBJECT(child), menu_child_realized, user_data);

        }

 

        WMEntry * wmentry = g_new0(WMEntry, 1);

        wmentry->wm = wm;

        IndicatorObjectEntry * entry = &wmentry->ioentry;

 

        g_array_append_val(priv->entries, wmentry);

 

 

        g_object_unref(newentry);

 

static void

menu_entry_removed (DbusmenuMenuitem * root, DbusmenuMenuitem * oldentry, gpointer user_data)

{

        g_return_if_fail(DBUSMENU_IS_MENUITEM(oldentry));

 

        if (priv->entries == NULL || priv->entries->len == 0) {

                return;

        }

 

        guint position;

 

        if (entry != NULL) {

                g_array_remove_index(priv->entries, position);

                entry_free(entry);

        } else {

                /* We've been called before menu_child_realized fired,

}

 

/* Get the XID of this window */

{

        return priv->windowid;

}

 

/* Get the path for this object */

gchar *

{

        GValue obj = {0};

        g_value_init(&obj, G_TYPE_STRING);

        g_object_get_property(G_OBJECT(priv->client), DBUSMENU_CLIENT_PROP_DBUS_OBJECT, &obj);

 

/* Get the address of this object */

gchar *

{

        GValue obj = {0};

        g_value_init(&obj, G_TYPE_STRING);

        g_object_get_property(G_OBJECT(priv->client), DBUSMENU_CLIENT_PROP_DBUS_NAME, &obj);

}

 

/* Return whether we're in an error state or not */

{

        return priv->error_state;

}

 

/* Regain whether we're supposed to be hidden or disabled, we

   want to keep that if that's the case, otherwise bring back

   to the base state */

{

        WMEntry * wmentry = (WMEntry *)entry;

 

        if (entry->label != NULL) {

 

/* Signaled when the menu item is activated on the panel so we

   can pass it down the stack. */

{

        WMEntry * wme = (WMEntry *)entry;

        dbusmenu_menuitem_send_about_to_show(wme->mi, NULL, NULL);

        return;