Catching up to trunk

1 files changed, 494 insertions, 79 deletions

diff --git a/libdbusmenu-glib/client.c b/libdbusmenu-glib/client.c
index e64d923..34f8b8d 100644
--- a/libdbusmenu-glib/client.c
+++ b/libdbusmenu-glib/client.c
@@ -52,7 +52,8 @@ enum {
 	PROP_DBUSOBJECT,
 	PROP_DBUSNAME,
 	PROP_STATUS,
-	PROP_TEXT_DIRECTION
+	PROP_TEXT_DIRECTION,
+	PROP_GROUP_EVENTS
 };
 
 /* Signals */
@@ -66,6 +67,12 @@ enum {
 	LAST_SIGNAL
 };
 
+/* Errors */
+enum {
+	ERROR_DISPOSAL,
+	ERROR_ID_NOT_FOUND
+};
+
 typedef void (*properties_func) (GVariant * properties, GError * error, gpointer user_data);
 
 static guint signals[LAST_SIGNAL] = { 0 };
@@ -100,6 +107,13 @@ struct _DbusmenuClientPrivate
 	DbusmenuTextDirection text_direction;
 	DbusmenuStatus status;
 	GStrv icon_dirs;
+
+	gboolean group_events;
+	guint event_idle;
+	GQueue * events_to_go; /* type: event_data_t * */
+
+	guint about_to_show_idle;
+	GQueue * about_to_show_to_go; /* type: about_to_show_t * */
 };
 
 typedef struct _newItemPropData newItemPropData;
@@ -120,6 +134,7 @@ struct _properties_listener_t {
 
 typedef struct _event_data_t event_data_t;
 struct _event_data_t {
+	gint id;
 	DbusmenuClient * client;
 	DbusmenuMenuitem * menuitem;
 	gchar * event;
@@ -171,6 +186,8 @@ static void menuproxy_prop_changed_cb (GDBusProxy * proxy, GVariant * properties
 static void menuproxy_name_changed_cb (GObject * object, GParamSpec * pspec, gpointer user_data);
 static void menuproxy_signal_cb (GDBusProxy * proxy, gchar * sender, gchar * signal, GVariant * params, gpointer user_data);
 static void type_handler_destroy (gpointer user_data);
+static void event_data_end (event_data_t * eventd, GError * error);
+static void about_to_show_finish_pntr (gpointer data, gpointer user_data);
 
 /* Globals */
 static GDBusNodeInfo *            dbusmenu_node_info = NULL;
@@ -309,6 +326,10 @@ dbusmenu_client_class_init (DbusmenuClientClass *klass)
 	                                              "Signals which direction the default text direction is for the menus",
 	                                              DBUSMENU_TYPE_TEXT_DIRECTION, DBUSMENU_TEXT_DIRECTION_NONE,
 	                                              G_PARAM_READABLE | G_PARAM_STATIC_STRINGS));
+	g_object_class_install_property (object_class, PROP_GROUP_EVENTS,
+	                                 g_param_spec_boolean(DBUSMENU_CLIENT_PROP_GROUP_EVENTS, "Whether or not multiple events should be grouped",
+	                                              "Event grouping lowers the number of messages on DBus and will be set automatically based on the version to optimize traffic.  It can be disabled for testing or other purposes.",
+	                                              FALSE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
 
 	if (dbusmenu_node_info == NULL) {
 		GError * error = NULL;
@@ -380,6 +401,13 @@ dbusmenu_client_init (DbusmenuClient *self)
 	priv->status = DBUSMENU_STATUS_NORMAL;
 	priv->icon_dirs = NULL;
 
+	priv->group_events = FALSE;
+	priv->event_idle = 0;
+	priv->events_to_go = NULL;
+
+	priv->about_to_show_idle = 0;
+	priv->about_to_show_to_go = NULL;
+
 	return;
 }
 
@@ -393,6 +421,32 @@ dbusmenu_client_dispose (GObject *object)
 		priv->delayed_idle = 0;
 	}
 
+	if (priv->event_idle != 0) {
+		g_source_remove(priv->event_idle);
+		priv->event_idle = 0;
+	}
+
+	if (priv->about_to_show_idle != 0) {
+		g_source_remove(priv->about_to_show_idle);
+		priv->about_to_show_idle = 0;
+	}
+
+	if (priv->events_to_go != NULL) {
+		g_warning("Getting to client dispose with events pending.  This is odd.  Probably there's a ref count problem somewhere, but we're going to be cool about it now and clean up.  But there's probably a bug.");
+		GError * error = g_error_new_literal(error_domain(), ERROR_DISPOSAL, "Client disposed before event signal returned");
+		g_queue_foreach(priv->events_to_go, (GFunc)event_data_end, error);
+		g_queue_free(priv->events_to_go);
+		priv->events_to_go = NULL;
+		g_error_free(error);
+	}
+
+	if (priv->about_to_show_to_go != NULL) {
+		g_warning("Getting to client dispose with about_to_show's pending.  This is odd.  Probably there's a ref count problem somewhere, but we're going to be cool about it now and clean up.  But there's probably a bug.");
+		g_queue_foreach(priv->about_to_show_to_go, about_to_show_finish_pntr, GINT_TO_POINTER(FALSE));
+		g_queue_free(priv->about_to_show_to_go);
+		priv->about_to_show_to_go = NULL;
+	}
+
 	/* Only used for queueing up a new command, so we can
 	   just drop this array. */
 	if (priv->delayed_property_list != NULL) {
@@ -517,6 +571,9 @@ set_property (GObject * obj, guint id, const GValue * value, GParamSpec * pspec)
 			build_proxies(DBUSMENU_CLIENT(obj));
 		}
 		break;
+	case PROP_GROUP_EVENTS:
+		priv->group_events = g_value_get_boolean(value);
+		break;
 	default:
 		g_warning("Unknown property %d.", id);
 		return;
@@ -543,6 +600,9 @@ get_property (GObject * obj, guint id, GValue * value, GParamSpec * pspec)
 	case PROP_TEXT_DIRECTION:
 		g_value_set_enum(value, priv->text_direction);
 		break;
+	case PROP_GROUP_EVENTS:
+		g_value_set_boolean(value, priv->group_events);
+		break;
 	default:
 		g_warning("Unknown property %d.", id);
 		return;
@@ -601,64 +661,66 @@ get_properties_callback (GObject *obj, GAsyncResult * res, gpointer user_data)
 			listener->callback(NULL, error, listener->user_data);
 		}
 		g_error_free(error);
-		goto out;
 	}
 
 	/* Callback all the folks we can find */
-	GVariant * parent = g_variant_get_child_value(params, 0);
-	GVariantIter iter;
-	g_variant_iter_init(&iter, parent);
-	GVariant * child;
-	while ((child = g_variant_iter_next_value(&iter)) != NULL) {
-		if (g_strcmp0(g_variant_get_type_string(child), "(ia{sv})") != 0) {
-			g_warning("Properties return signature is not '(ia{sv})' it is '%s'", g_variant_get_type_string(child));
-			g_variant_unref(child);
-			continue;
-		}
+	if (error == NULL) {
+		GVariant * parent = g_variant_get_child_value(params, 0);
+		GVariantIter iter;
+		g_variant_iter_init(&iter, parent);
+		GVariant * child;
+		while ((child = g_variant_iter_next_value(&iter)) != NULL) {
+			if (g_strcmp0(g_variant_get_type_string(child), "(ia{sv})") != 0) {
+				g_warning("Properties return signature is not '(ia{sv})' it is '%s'", g_variant_get_type_string(child));
+				g_variant_unref(child);
+				continue;
+			}
 
-		GVariant * idv = g_variant_get_child_value(child, 0);
-		gint id = g_variant_get_int32(idv);
-		g_variant_unref(idv);
+			GVariant * idv = g_variant_get_child_value(child, 0);
+			gint id = g_variant_get_int32(idv);
+			g_variant_unref(idv);
 
-		GVariant * properties = g_variant_get_child_value(child, 1);
+			GVariant * properties = g_variant_get_child_value(child, 1);
 
-		properties_listener_t * listener = find_listener(listeners, 0, id);
-		if (listener == NULL) {
-			g_warning("Unable to find listener for ID %d", id);
+			properties_listener_t * listener = find_listener(listeners, 0, id);
+			if (listener == NULL) {
+				g_warning("Unable to find listener for ID %d", id);
+				g_variant_unref(properties);
+				g_variant_unref(child);
+				continue;
+			}
+
+			if (!listener->replied) {
+				listener->callback(properties, NULL, listener->user_data);
+				listener->replied = TRUE;
+			} else {
+				g_warning("Odd, we've already replied to the listener on ID %d", id);
+			}
 			g_variant_unref(properties);
 			g_variant_unref(child);
-			continue;
 		}
-
-		if (!listener->replied) {
-			listener->callback(properties, NULL, listener->user_data);
-			listener->replied = TRUE;
-		} else {
-			g_warning("Odd, we've already replied to the listener on ID %d", id);
-		}
-		g_variant_unref(properties);
-		g_variant_unref(child);
+		g_variant_unref(parent);
+		g_variant_unref(params);
 	}
-	g_variant_unref(parent);
-	g_variant_unref(params);
 
 	/* Provide errors for those who we can't */
-	GError * localerror = NULL;
-	for (i = 0; i < listeners->len; i++) {
-		properties_listener_t * listener = &g_array_index(listeners, properties_listener_t, i);
-		if (!listener->replied) {
-			g_warning("Generating properties error for: %d", listener->id);
-			if (localerror == NULL) {
-				g_set_error_literal(&localerror, error_domain(), 0, "Error getting properties for ID");
+	if (error == NULL && listeners->len > 0) {
+		GError * localerror = NULL;
+		for (i = 0; i < listeners->len; i++) {
+			properties_listener_t * listener = &g_array_index(listeners, properties_listener_t, i);
+			if (!listener->replied) {
+				g_debug("Generating properties error for: %d", listener->id);
+				if (localerror == NULL) {
+					g_set_error_literal(&localerror, error_domain(), 0, "Error getting properties for ID");
+				}
+				listener->callback(NULL, localerror, listener->user_data);
 			}
-			listener->callback(NULL, localerror, listener->user_data);
 		}
-	}
-	if (localerror != NULL) {
-		g_error_free(localerror);
+		if (localerror != NULL) {
+			g_error_free(localerror);
+		}
 	}
 
-out:
 	/* Clean up */
 	g_array_free(listeners, TRUE);
 	g_object_unref(cbdata->client);
@@ -1084,6 +1146,7 @@ menuproxy_build_cb (GObject * object, GAsyncResult * res, gpointer user_data)
 		g_object_notify(G_OBJECT(user_data), DBUSMENU_CLIENT_PROP_TEXT_DIRECTION);
 
 		g_variant_unref(textdir);
+		textdir = NULL;
 	}
 
 	/* Check the status if available */
@@ -1099,6 +1162,7 @@ menuproxy_build_cb (GObject * object, GAsyncResult * res, gpointer user_data)
 		g_object_notify(G_OBJECT(user_data), DBUSMENU_CLIENT_PROP_STATUS);
 
 		g_variant_unref(status);
+		status = NULL;
 	}
 
 	/* Get the icon theme directories if available */
@@ -1113,6 +1177,33 @@ menuproxy_build_cb (GObject * object, GAsyncResult * res, gpointer user_data)
 		g_signal_emit(G_OBJECT(client), signals[ICON_THEME_DIRS], 0, priv->icon_dirs, TRUE);
 
 		g_variant_unref(icon_dirs);
+		icon_dirs = NULL;
+	}
+
+	/* Get the dbusmenu protocol version if available */
+	GVariant * version = g_dbus_proxy_get_cached_property(priv->menuproxy, "Version");
+	if (version != NULL) {
+		guint32 remote_version = 0;
+
+		if (g_variant_is_of_type(version, G_VARIANT_TYPE_UINT32)) {
+			remote_version = g_variant_get_uint32(version);
+		}
+
+		gboolean old_group = priv->group_events;
+		/* Figure out if we can group the events or not */
+		if (remote_version >= 3) {
+			priv->group_events = TRUE;
+		} else {
+			priv->group_events = FALSE;
+		}
+
+		/* Notify listeners if we changed the value */
+		if (old_group != priv->group_events) {
+			g_object_notify(G_OBJECT(client), DBUSMENU_CLIENT_PROP_GROUP_EVENTS);
+		}
+
+		g_variant_unref(version);
+		version = NULL;
 	}
 
 	/* If we get here, we don't need the DBus proxy */
@@ -1194,6 +1285,19 @@ menuproxy_prop_changed_cb (GDBusProxy * proxy, GVariant * properties, GStrv inva
 			priv->icon_dirs = g_variant_dup_strv(value, NULL);
 			dirs_changed = TRUE;
 		}
+		if (g_strcmp0(key, "Version") == 0) {
+			guint32 remote_version = 0;
+
+			if (g_variant_is_of_type(value, G_VARIANT_TYPE_UINT32)) {
+				remote_version = g_variant_get_uint32(value);
+			}
+
+			if (remote_version >= 3) {
+				priv->group_events = TRUE;
+			} else {
+				priv->group_events = FALSE;
+			}
+		}
 	}
 
 	if (olddir != priv->text_direction) {
@@ -1439,7 +1543,7 @@ menuitem_get_properties_new_cb (GVariant * properties, GError * error, gpointer
 	newItemPropData * propdata = (newItemPropData *)data;
 
 	if (error != NULL) {
-		g_warning("Error getting properties on a new menuitem: %s", error->message);
+		g_debug("Error getting properties on a new menuitem: %s", error->message);
 		goto out;
 	}
 
@@ -1486,6 +1590,22 @@ out:
 	return;
 }
 
+/* A function to work with an event_data_t and make sure it gets
+   free'd and in a terminal state. */
+static void
+event_data_end (event_data_t * edata, GError * error)
+{
+	g_signal_emit(edata->client, signals[EVENT_RESULT], 0, edata->menuitem, edata->event, edata->variant, edata->timestamp, error, TRUE);
+
+	g_variant_unref(edata->variant);
+	g_free(edata->event);
+	g_object_unref(edata->menuitem);
+	g_object_unref(edata->client);
+	g_free(edata);
+
+	return;
+}
+
 /* Respond to the call function to make sure that the other side
    got it, or print a warning. */
 static void
@@ -1501,13 +1621,7 @@ menuitem_call_cb (GObject * proxy, GAsyncResult * res, gpointer userdata)
 		g_warning("Unable to call event '%s' on menu item %d: %s", edata->event, dbusmenu_menuitem_get_id(edata->menuitem), error->message);
 	}
 
-	g_signal_emit(edata->client, signals[EVENT_RESULT], 0, edata->menuitem, edata->event, edata->variant, edata->timestamp, error, TRUE);
-
-	g_variant_unref(edata->variant);
-	g_free(edata->event);
-	g_object_unref(edata->menuitem);
-	g_object_unref(edata->client);
-	g_free(edata);
+	event_data_end(edata, error);
 
 	if (G_UNLIKELY(error != NULL)) {
 		g_error_free(error);
@@ -1519,6 +1633,128 @@ menuitem_call_cb (GObject * proxy, GAsyncResult * res, gpointer userdata)
 	return;
 }
 
+/* Looks at event_data_t structs to match an ID */
+gint
+event_data_find (gconstpointer data, gconstpointer user_data)
+{
+	event_data_t * edata = (event_data_t *)data;
+	gint id = GPOINTER_TO_INT(user_data);
+
+	if (edata->id == id) {
+		return 0;
+	} else {
+		return -1;
+	}
+}
+
+/* The callback from the dbus message to pass events to the
+   to the server en masse */
+static void
+event_group_cb (GObject * proxy, GAsyncResult * res, gpointer user_data)
+{
+	GQueue * events = (GQueue *)user_data;
+
+	GError * error = NULL;
+	GVariant * params;
+	params = g_dbus_proxy_call_finish(G_DBUS_PROXY(proxy), res, &error);
+
+	if (error != NULL) {
+		/* If we got an actual DBus error, we should just pass that
+		   along and finish up */
+		g_queue_foreach(events, (GFunc)event_data_end, error);
+		g_queue_free(events);
+		events = NULL;
+		return;
+	}
+
+	gint id = 0;
+	GVariant * array = g_variant_get_child_value(params, 0);
+	GVariantIter iter;
+	g_variant_iter_init(&iter, array);
+
+	while (g_variant_iter_loop(&iter, "i", &id)) {
+		GList * item = g_queue_find_custom(events, GINT_TO_POINTER(id), event_data_find);
+
+		if (item != NULL) {
+			GError * iderror = g_error_new(error_domain(), ERROR_ID_NOT_FOUND, "Unable to find ID: %d", id);
+			event_data_end((event_data_t *)item->data, iderror);
+			g_queue_delete_link(events, item);
+			g_error_free(iderror);
+		}
+	}
+
+	g_variant_unref(array);
+	g_variant_unref(params);
+
+	/* If we have any left send non-error responses */
+	g_queue_foreach(events, (GFunc)event_data_end, NULL);
+	g_queue_free(events);
+	return;
+}
+
+/* Turn an event structure into the variant builder form */
+static void
+events_to_builder (gpointer data, gpointer user_data)
+{
+	event_data_t * edata = (event_data_t *)data;
+	GVariantBuilder * builder = (GVariantBuilder *)user_data;
+
+	GVariantBuilder tuple;
+	g_variant_builder_init(&tuple, G_VARIANT_TYPE_TUPLE);
+
+	g_variant_builder_add_value(&tuple, g_variant_new_int32(edata->id));
+	g_variant_builder_add_value(&tuple, g_variant_new_string(edata->event));
+	g_variant_builder_add_value(&tuple, g_variant_new_variant(edata->variant));
+	g_variant_builder_add_value(&tuple, g_variant_new_uint32(edata->timestamp));
+
+	GVariant * vtuple = g_variant_builder_end(&tuple);
+	g_variant_builder_add_value(builder, vtuple);
+	return;
+}
+
+/* Group all the events into a single Dbus message and send
+   that out */
+static gboolean
+event_idle_cb (gpointer user_data)
+{
+	g_return_val_if_fail(DBUSMENU_IS_CLIENT(user_data), FALSE);
+	DbusmenuClient * client = DBUSMENU_CLIENT(user_data);
+	DbusmenuClientPrivate * priv = DBUSMENU_CLIENT_GET_PRIVATE(user_data);
+
+	/* We use prepend for speed, but now we want to have them
+	   in the order they were called incase that matters. */
+	GQueue * levents = priv->events_to_go;
+	priv->events_to_go = NULL;
+	priv->event_idle = 0;
+
+	GVariantBuilder array;
+	g_variant_builder_init(&array, G_VARIANT_TYPE("a(isvu)"));
+	g_queue_foreach(levents, events_to_builder, &array);
+	GVariant * vevents = g_variant_builder_end(&array);
+
+	if (g_signal_has_handler_pending (client, signals[EVENT_RESULT], 0, TRUE)) {
+		g_dbus_proxy_call(priv->menuproxy,
+		                  "EventGroup",
+		                  g_variant_new_tuple(&vevents, 1),
+		                  G_DBUS_CALL_FLAGS_NONE,
+		                  1000,   /* timeout */
+		                  NULL, /* cancellable */
+		                  event_group_cb, levents);
+	} else {
+		g_dbus_proxy_call(priv->menuproxy,
+		                  "EventGroup",
+		                  g_variant_new_tuple(&vevents, 1),
+		                  G_DBUS_CALL_FLAGS_NONE,
+		                  1000,   /* timeout */
+		                  NULL, /* cancellable */
+		                  NULL, NULL);
+		g_queue_foreach(levents, (GFunc)event_data_end, NULL);
+		g_queue_free(levents);
+	}
+
+	return FALSE;
+}
+
 /* Sends the event over DBus to the server on the other side
    of the bus. */
 void
@@ -1538,7 +1774,20 @@ dbusmenu_client_send_event (DbusmenuClient * client, gint id, const gchar * name
 		variant = g_variant_new_int32(0);
 	}
 
+	/* Don't bother with the reply handling if nobody is watching... */
+	if (!priv->group_events && !g_signal_has_handler_pending (client, signals[EVENT_RESULT], 0, TRUE)) {
+		g_dbus_proxy_call(priv->menuproxy,
+		                  "Event",
+		                  g_variant_new("(isvu)", id, name, variant, timestamp),
+		                  G_DBUS_CALL_FLAGS_NONE,
+		                  1000,   /* timeout */
+		                  NULL, /* cancellable */
+		                  NULL, NULL);
+		return;
+	}
+
 	event_data_t * edata = g_new0(event_data_t, 1);
+	edata->id = id;
 	edata->client = client;
 	g_object_ref(client);
 	edata->menuitem = mi;
@@ -1548,25 +1797,181 @@ dbusmenu_client_send_event (DbusmenuClient * client, gint id, const gchar * name
 	edata->variant = variant;
 	g_variant_ref_sink(variant);
 
-	g_dbus_proxy_call(priv->menuproxy,
-	                  "Event",
-	                  g_variant_new("(isvu)", id, name, variant, timestamp),
-	                  G_DBUS_CALL_FLAGS_NONE,
-	                  1000,   /* timeout */
-	                  NULL, /* cancellable */
-	                  menuitem_call_cb,
-	                  edata);
+	if (!priv->group_events) {
+		g_dbus_proxy_call(priv->menuproxy,
+		                  "Event",
+		                  g_variant_new("(isvu)", id, name, variant, timestamp),
+		                  G_DBUS_CALL_FLAGS_NONE,
+		                  1000,   /* timeout */
+		                  NULL, /* cancellable */
+		                  menuitem_call_cb,
+		                  edata);
+	} else {
+		if (priv->events_to_go == NULL) {
+			priv->events_to_go = g_queue_new();
+		}
+
+		g_queue_push_tail(priv->events_to_go, edata);
+
+		if (priv->event_idle == 0) {
+			priv->event_idle = g_idle_add(event_idle_cb, client);
+		}
+	}
 
 	return;
 }
 
 typedef struct _about_to_show_t about_to_show_t;
 struct _about_to_show_t {
+	gint id;
 	DbusmenuClient * client;
 	void (*cb) (gpointer data);
 	gpointer cb_data;
 };
 
+/* Takes an about_to_show_t structure and calls the callback correctly
+   and updates the layout if needed. */
+static void
+about_to_show_finish (about_to_show_t * data, gboolean need_update)
+{
+	/* If we need to update, do that first. */
+	if (need_update) {
+		update_layout(data->client);
+	}
+
+	if (data->cb != NULL) {
+		data->cb(data->cb_data);
+	}
+
+	g_object_unref(data->client);
+	g_free(data);
+
+	return;
+}
+
+/* A little function to match prototypes and make sure to convert from
+   a pointer to an int correctly */
+static void
+about_to_show_finish_pntr (gpointer data, gpointer user_data)
+{
+	return about_to_show_finish((about_to_show_t *)data, GPOINTER_TO_INT(user_data));
+}
+
+/* Respond to the DBus message from sending a bunch of about-to-show events
+   to the server */
+static void
+about_to_show_group_cb (GObject * proxy, GAsyncResult * res, gpointer userdata)
+{
+	GError * error = NULL;
+	GQueue * showers = (GQueue *)userdata;
+	GVariant * params = NULL;
+
+	params = g_dbus_proxy_call_finish(G_DBUS_PROXY(proxy), res, &error);
+
+	if (error != NULL) {
+		g_warning("Unable to send about_to_show_group: %s", error->message);
+		/* Note: we're just ensuring only the callback gets called */
+		g_error_free(error);
+		error = NULL;
+	} else {
+		GVariant * updates = g_variant_get_child_value(params, 0);
+		GVariantIter iter;
+
+		/* Okay, so this is kinda interesting.  We actually don't care which
+		   entries asked us to update the structure, as it's quite simply a
+		   single structure.  So if we have any ask, we get the update once to
+		   avoid itterating through all the structures. */
+		if (g_variant_iter_init(&iter, updates) > 0) {
+			about_to_show_t * first = (about_to_show_t *)g_queue_peek_head(showers);
+			update_layout(first->client);
+		}
+
+		g_variant_unref(updates);
+		g_variant_unref(params);
+		params = NULL;
+	}
+
+	g_queue_foreach(showers, about_to_show_finish_pntr, GINT_TO_POINTER(FALSE));
+	g_queue_free(showers);
+
+	return;
+}
+
+/* Check to see if this about to show entry has a callback associated
+   with it */
+static void
+about_to_show_idle_callbacks (gpointer data, gpointer user_data)
+{
+	about_to_show_t * abts = (about_to_show_t *)data;
+	gboolean * got_callbacks = (gboolean *)user_data;
+
+	if (abts->cb != NULL) {
+		*got_callbacks = TRUE;
+	}
+
+	return;
+}
+
+/* Take the ID out of the about to show structure and put it into the 
+   variant builder */
+static void
+about_to_show_idle_ids (gpointer data, gpointer user_data)
+{
+	about_to_show_t * abts = (about_to_show_t *)data;
+	GVariantBuilder * builder = (GVariantBuilder *)user_data;
+
+	g_variant_builder_add_value(builder, g_variant_new_int32(abts->id));
+
+	return;
+}
+
+/* Function that gets called with all the queued about_to_show messages, let's
+   get these guys on the bus! */
+static gboolean
+about_to_show_idle (gpointer user_data)
+{
+	DbusmenuClient * client = DBUSMENU_CLIENT(user_data);
+	DbusmenuClientPrivate * priv = DBUSMENU_CLIENT_GET_PRIVATE(client);
+
+	/* Reset our object global props and take ownership of these entries */
+	priv->about_to_show_idle = 0;
+	GQueue * showers = priv->about_to_show_to_go;
+	priv->about_to_show_to_go = NULL;
+
+	/* Figure out if we've got any callbacks */
+	gboolean got_callbacks = FALSE;
+	g_queue_foreach(showers, about_to_show_idle_callbacks, &got_callbacks);
+
+	/* Build a list of the IDs */
+	GVariantBuilder idarray;
+	g_variant_builder_init(&idarray, G_VARIANT_TYPE("ai"));
+	g_queue_foreach(showers, about_to_show_idle_ids, &idarray);
+	GVariant * ids = g_variant_builder_end(&idarray);
+
+	/* Setup our callbacks */
+	GAsyncReadyCallback cb = NULL;
+	gpointer cb_data = NULL;
+	if (got_callbacks) {
+		cb = about_to_show_group_cb;
+		cb_data = showers;
+	} else {
+		g_queue_foreach(showers, about_to_show_finish_pntr, GINT_TO_POINTER(FALSE));
+		g_queue_free(showers);
+	}
+
+	/* Let's call it! */
+	g_dbus_proxy_call(priv->menuproxy,
+	                  "AboutToShowGroup",
+	                  g_variant_new_tuple(&ids, 1),
+	                  G_DBUS_CALL_FLAGS_NONE,
+	                  -1,   /* timeout */
+	                  NULL, /* cancellable */
+	                  cb,
+	                  cb_data);
+
+	return FALSE;
+}
+
 /* Reports errors and responds to update request that were a result
    of sending the about to show signal. */
 static void
@@ -1590,18 +1995,7 @@ about_to_show_cb (GObject * proxy, GAsyncResult * res, gpointer userdata)
 		g_variant_unref(params);
 	}
 
-	/* If we need to update, do that first. */
-	if (need_update) {
-		update_layout(data->client);
-	}
-
-	if (data->cb != NULL) {
-		data->cb(data->cb_data);
-	}
-
-	g_object_unref(data->client);
-	g_free(data);
-
+	about_to_show_finish(data, need_update);
 	return;
 }
 
@@ -1617,19 +2011,40 @@ dbusmenu_client_send_about_to_show(DbusmenuClient * client, gint id, void (*cb)(
 	g_return_if_fail(priv != NULL);
 
 	about_to_show_t * data = g_new0(about_to_show_t, 1);
+	data->id = id;
 	data->client = client;
 	data->cb = cb;
 	data->cb_data = cb_data;
 	g_object_ref(client);
 
-	g_dbus_proxy_call(priv->menuproxy,
-	                  "AboutToShow",
-	                  g_variant_new("(i)", id),
-	                  G_DBUS_CALL_FLAGS_NONE,
-	                  -1,   /* timeout */
-	                  NULL, /* cancellable */
-	                  about_to_show_cb,
-	                  data);
+	if (priv->group_events) {
+		if (priv->about_to_show_to_go == NULL) {
+			priv->about_to_show_to_go = g_queue_new();
+		}
+
+		g_queue_push_tail(priv->about_to_show_to_go, data);
+
+		if (priv->about_to_show_idle == 0) {
+			priv->about_to_show_idle = g_idle_add(about_to_show_idle, client);
+		}
+	} else {
+		/* If there's no callback we don't need this data, let's
+		   clean it up in a consistent way */
+		if (cb == NULL) {
+			about_to_show_finish(data, FALSE);
+			data = NULL;
+		}
+
+		g_dbus_proxy_call(priv->menuproxy,
+		                  "AboutToShow",
+		                  g_variant_new("(i)", id),
+		                  G_DBUS_CALL_FLAGS_NONE,
+		                  -1,   /* timeout */
+		                  NULL, /* cancellable */
+		                  about_to_show_cb,
+		                  data);
+	}
+
 	return;
 }