Merge lp:~ted/indicator-appmenu/dbusmenu-collector-rename into lp:indicator-appmenu/0.4

[Ted Gould]

Rename the dbusmenu-collector to menuitem-collector to avoid a potential namespace collision.

[Mikkel Kamstrup Erlandsen (kamstrup)]

Looks good. And the diffstat can be used as a checksum to validate it #added==#removed+1. And the extra added line is in .bzrignore. So all checks up :-)

review: Approve

=== modified file '.bzrignore'
--- .bzrignore	2012-01-26 16:51:25 +0000
+++ .bzrignore	2012-01-26 16:51:25 +0000
@@ -125,7 +125,7 @@
 src/hud_cli-hud-cli.gcno
 src/hud_dump_application-dump-app-info.gcno
 src/hud_dump_application-hud-dump-application.gcno
-src/hud_service-dbusmenu-collector.gcno
+src/hud_service-menuitem-collector.gcno
 src/hud_service-distance.gcno
 src/hud_service-dump-app-info.gcno
 src/hud_service-hud-dbus.gcno
@@ -168,3 +168,4 @@
 tests/test_usage_db_simple-test-usage-db-simple.gcno
 tests/test_usage_db_testapp-test-usage-db-testapp.gcda
 tests/test_usage_db_testapp-test-usage-db-testapp.gcno
+po/indicator-appmenu.pot
 
=== modified file 'po/POTFILES.in'
--- po/POTFILES.in	2012-01-26 16:51:25 +0000
+++ po/POTFILES.in	2012-01-26 16:51:25 +0000
@@ -4,7 +4,7 @@
 src/hud-service.c
 src/indicator-tracker.c
 src/hud-dbus.c
-src/dbusmenu-collector.c
+src/menuitem-collector.c
 src/usage-tracker.c
 src/hud.interface.c
 src/hud-search.c
 
=== modified file 'src/Makefile.am'
--- src/Makefile.am	2012-01-26 16:51:25 +0000
+++ src/Makefile.am	2012-01-26 16:51:25 +0000
@@ -81,8 +81,8 @@
 ####################
 
 hud_service_SOURCES = \
-	dbusmenu-collector.h \
-	dbusmenu-collector.c \
+	menuitem-collector.h \
+	menuitem-collector.c \
 	distance.h \
 	distance.c \
 	dump-app-info.h \
 
=== modified file 'src/hud-search.c'
--- src/hud-search.c	2012-01-26 16:51:25 +0000
+++ src/hud-search.c	2012-01-26 16:51:25 +0000
@@ -29,7 +29,7 @@
 #include <gio/gdesktopappinfo.h>
 
 #include "hud-search.h"
-#include "dbusmenu-collector.h"
+#include "menuitem-collector.h"
 #include "indicator-tracker.h"
 #include "usage-tracker.h"
 #include "utils.h"
@@ -41,7 +41,7 @@
 	guint32 active_xid;
 	BamfApplication * active_app;
 
-	DbusmenuCollector * collector;
+	MenuitemCollector * collector;
 	UsageTracker * usage;
 
 	GDBusProxy * appmenu;
@@ -111,7 +111,7 @@
 	}
 
 	/* DBusMenu */
-	self->priv->collector = dbusmenu_collector_new();
+	self->priv->collector = menuitem_collector_new();
 
 	/* Usage Tracker */
 	self->priv->usage = usage_tracker_new();
@@ -199,7 +199,7 @@
 
 typedef struct _usage_wrapper_t usage_wrapper_t;
 struct _usage_wrapper_t {
-	DbusmenuCollectorFound * found;
+	MenuitemCollectorFound * found;
 	guint count;
 	gfloat percent_usage;
 	gfloat percent_distance;
@@ -226,7 +226,7 @@
 	usage_wrapper_t * wa = (usage_wrapper_t *)a;
 	usage_wrapper_t * wb = (usage_wrapper_t *)b;
 
-	return dbusmenu_collector_found_get_distance(wa->found) - dbusmenu_collector_found_get_distance(wb->found);
+	return menuitem_collector_found_get_distance(wa->found) - menuitem_collector_found_get_distance(wb->found);
 }
 
 /* Take the found list and put it into the usage array so that
@@ -241,10 +241,10 @@
 
 	while (found != NULL) {
 		usage_wrapper_t usage;
-		usage.found = (DbusmenuCollectorFound *)found->data;
+		usage.found = (MenuitemCollectorFound *)found->data;
 		usage.count = 0;
 
-		if (dbusmenu_collector_found_get_distance(usage.found) > max_distance) {
+		if (menuitem_collector_found_get_distance(usage.found) > max_distance) {
 			continue;
 		}
 
@@ -308,7 +308,7 @@
 	get_current_window_address(search, &address, &path);
 
 	if (address != NULL && path != NULL) {
-		found_list = dbusmenu_collector_search(search->priv->collector, address, path, NULL, searchstr);
+		found_list = menuitem_collector_search(search->priv->collector, address, path, NULL, searchstr);
 	}
 
 	g_free(address);
@@ -325,13 +325,13 @@
 		gchar * icon = desktop_to_icon(desktop_file);
 
 		while (founditem != NULL) {
-			DbusmenuCollectorFound * found = (DbusmenuCollectorFound *)founditem->data;
+			MenuitemCollectorFound * found = (MenuitemCollectorFound *)founditem->data;
 
 			/* Indicator */
-			dbusmenu_collector_found_set_indicator(found, desktop_file);
+			menuitem_collector_found_set_indicator(found, desktop_file);
 
 			/* Icon */
-			dbusmenu_collector_found_set_app_icon(found, icon);
+			menuitem_collector_found_set_app_icon(found, icon);
 
 			founditem = g_list_next(founditem);
 		}
@@ -364,23 +364,23 @@
 		IndicatorTrackerIndicator * indicator = (IndicatorTrackerIndicator *)lindicator->data;
 
 		/* Search the menu items of the indicator */
-		GList * found_list = dbusmenu_collector_search(search->priv->collector, indicator->dbus_name, indicator->dbus_object, indicator->prefix, searchstr);
+		GList * found_list = menuitem_collector_search(search->priv->collector, indicator->dbus_name, indicator->dbus_object, indicator->prefix, searchstr);
 
 		/* Increase distance */
 		GList * founditem = found_list;
 		while (founditem != NULL) {
-			DbusmenuCollectorFound * found = (DbusmenuCollectorFound *)founditem->data;
+			MenuitemCollectorFound * found = (MenuitemCollectorFound *)founditem->data;
 
 			/* Distance */
-			guint distance = dbusmenu_collector_found_get_distance(found);
+			guint distance = menuitem_collector_found_get_distance(found);
 			distance = distance + ((distance * indicator_penalty) / 100);
-			dbusmenu_collector_found_set_distance(found, distance);
+			menuitem_collector_found_set_distance(found, distance);
 
 			/* Names */
-			dbusmenu_collector_found_set_indicator(found, indicator->name);
+			menuitem_collector_found_set_indicator(found, indicator->name);
 
 			/* Icon */
-			dbusmenu_collector_found_set_app_icon(found, indicator->icon);
+			menuitem_collector_found_set_app_icon(found, indicator->icon);
 
 			founditem = g_list_next(founditem);
 		}
@@ -422,10 +422,10 @@
 
 		const gchar * desktopfile = NULL;
 
-		desktopfile = dbusmenu_collector_found_get_indicator(usage->found);
+		desktopfile = menuitem_collector_found_get_indicator(usage->found);
 
 		if (desktopfile != NULL) {
-			usage->count = usage_tracker_get_usage(search->priv->usage, desktopfile, dbusmenu_collector_found_get_db(usage->found));
+			usage->count = usage_tracker_get_usage(search->priv->usage, desktopfile, menuitem_collector_found_get_db(usage->found));
 		} else {
 			usage->count = 0;
 		}
@@ -437,7 +437,7 @@
 	for (count = 0; count < usagedata->len; count++) {
 		usage_wrapper_t * usage = &g_array_index(usagedata, usage_wrapper_t, count);
 		overall_usage += usage->count;
-		overall_distance += dbusmenu_collector_found_get_distance(usage->found);
+		overall_distance += menuitem_collector_found_get_distance(usage->found);
 	}
 
 
@@ -451,7 +451,7 @@
 			usage->percent_usage = 1.0;
 		}
 
-		usage->percent_distance = (gfloat)dbusmenu_collector_found_get_distance(usage->found)/(gfloat)overall_distance;
+		usage->percent_distance = (gfloat)menuitem_collector_found_get_distance(usage->found)/(gfloat)overall_distance;
 	}
 
 	/* Sort based on aggregate */
@@ -508,19 +508,19 @@
 	for (count = 0; count < 5 && count < usagedata->len; count++) {
 		usage_wrapper_t * usage = &g_array_index(usagedata, usage_wrapper_t, count);
 
-		const gchar * desktopfile = dbusmenu_collector_found_get_indicator(usage->found);
+		const gchar * desktopfile = menuitem_collector_found_get_indicator(usage->found);
 		if (desktopfile == NULL) {
 			desktopfile = appdesktopfile;
 		}
 
 		HudSearchSuggest * suggest = hud_search_suggest_new(desktopfile,
-		                                                    dbusmenu_collector_found_get_app_icon(usage->found),
-		                                                    dbusmenu_collector_found_get_display(usage->found),
-		                                                    dbusmenu_collector_found_get_db(usage->found),
+		                                                    menuitem_collector_found_get_app_icon(usage->found),
+		                                                    menuitem_collector_found_get_display(usage->found),
+		                                                    menuitem_collector_found_get_db(usage->found),
 		                                                    "none",
-		                                                    dbusmenu_collector_found_get_dbus_addr(usage->found),
-		                                                    dbusmenu_collector_found_get_dbus_path(usage->found),
-		                                                    dbusmenu_collector_found_get_dbus_id(usage->found)
+		                                                    menuitem_collector_found_get_dbus_addr(usage->found),
+		                                                    menuitem_collector_found_get_dbus_path(usage->found),
+		                                                    menuitem_collector_found_get_dbus_id(usage->found)
 		                                                    );
 
 		retval = g_list_prepend(retval, suggest);
@@ -530,7 +530,7 @@
 
 	/* Free the interim arrays of data */
 	g_array_free(usagedata, TRUE);
-	dbusmenu_collector_found_list_free(found_list);
+	menuitem_collector_found_list_free(found_list);
 
 	return retval;
 }
@@ -557,7 +557,7 @@
 	}
 
 	if (app != NULL && dbstring != NULL && address != NULL && path != NULL && id != 0) {
-		dbusmenu_collector_execute(search->priv->collector, address, path, id, timestamp);
+		menuitem_collector_execute(search->priv->collector, address, path, id, timestamp);
 		usage_tracker_mark_usage(search->priv->usage, app, dbstring);
 	}
 
 
=== renamed file 'src/dbusmenu-collector.c' => 'src/menuitem-collector.c'
--- src/dbusmenu-collector.c	2012-01-26 16:51:25 +0000
+++ src/menuitem-collector.c	2012-01-26 16:51:25 +0000
@@ -30,23 +30,23 @@
 
 #include <libdbusmenu-glib/client.h>
 
-#include "dbusmenu-collector.h"
+#include "menuitem-collector.h"
 #include "distance.h"
 #include "shared-values.h"
 #include "utils.h"
 
 #define GENERIC_ICON   "dbusmenu-lens-panel"
 
-typedef struct _DbusmenuCollectorPrivate DbusmenuCollectorPrivate;
+typedef struct _MenuitemCollectorPrivate MenuitemCollectorPrivate;
 
-struct _DbusmenuCollectorPrivate {
+struct _MenuitemCollectorPrivate {
 	GDBusConnection * bus;
 	guint signal;
 	GHashTable * hash;
 	GSettings * search_settings;
 };
 
-struct _DbusmenuCollectorFound {
+struct _MenuitemCollectorFound {
 	gchar * dbus_addr;
 	gchar * dbus_path;
 	gint dbus_id;
@@ -73,35 +73,35 @@
 	guint distance;
 };
 
-static void dbusmenu_collector_class_init (DbusmenuCollectorClass *klass);
-static void dbusmenu_collector_init       (DbusmenuCollector *self);
-static void dbusmenu_collector_dispose    (GObject *object);
-static void dbusmenu_collector_finalize   (GObject *object);
+static void menuitem_collector_class_init (MenuitemCollectorClass *klass);
+static void menuitem_collector_init       (MenuitemCollector *self);
+static void menuitem_collector_dispose    (GObject *object);
+static void menuitem_collector_finalize   (GObject *object);
 static void update_layout_cb (GDBusConnection * connection, const gchar * sender, const gchar * path, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data);
 static guint menu_hash_func (gconstpointer key);
 static gboolean menu_equal_func (gconstpointer a, gconstpointer b);
 static void menu_key_destroy (gpointer key);
-static DbusmenuCollectorFound * dbusmenu_collector_found_new (DbusmenuClient * client, DbusmenuMenuitem * item, GStrv strings, guint distance, GStrv usedstrings, const gchar * indicator_name);
+static MenuitemCollectorFound * menuitem_collector_found_new (DbusmenuClient * client, DbusmenuMenuitem * item, GStrv strings, guint distance, GStrv usedstrings, const gchar * indicator_name);
 
-G_DEFINE_TYPE (DbusmenuCollector, dbusmenu_collector, G_TYPE_OBJECT);
+G_DEFINE_TYPE (MenuitemCollector, menuitem_collector, G_TYPE_OBJECT);
 
 static void
-dbusmenu_collector_class_init (DbusmenuCollectorClass *klass)
+menuitem_collector_class_init (MenuitemCollectorClass *klass)
 {
 	GObjectClass *object_class = G_OBJECT_CLASS (klass);
 
-	g_type_class_add_private (klass, sizeof (DbusmenuCollectorPrivate));
+	g_type_class_add_private (klass, sizeof (MenuitemCollectorPrivate));
 
-	object_class->dispose = dbusmenu_collector_dispose;
-	object_class->finalize = dbusmenu_collector_finalize;
+	object_class->dispose = menuitem_collector_dispose;
+	object_class->finalize = menuitem_collector_finalize;
 
 	return;
 }
 
 static void
-dbusmenu_collector_init (DbusmenuCollector *self)
+menuitem_collector_init (MenuitemCollector *self)
 {
-	self->priv = G_TYPE_INSTANCE_GET_PRIVATE ((self), DBUSMENU_COLLECTOR_TYPE, DbusmenuCollectorPrivate);
+	self->priv = G_TYPE_INSTANCE_GET_PRIVATE ((self), MENUITEM_COLLECTOR_TYPE, MenuitemCollectorPrivate);
 
 	self->priv->bus = NULL;
 	self->priv->signal = 0;
@@ -144,9 +144,9 @@
 }
 
 static void
-dbusmenu_collector_dispose (GObject *object)
+menuitem_collector_dispose (GObject *object)
 {
-	DbusmenuCollector * collector = DBUSMENU_COLLECTOR(object);
+	MenuitemCollector * collector = MENUITEM_COLLECTOR(object);
 
 	if (collector->priv->signal != 0) {
 		g_dbus_connection_signal_unsubscribe(collector->priv->bus, collector->priv->signal);
@@ -163,29 +163,29 @@
 		collector->priv->search_settings = NULL;
 	}
 
-	G_OBJECT_CLASS (dbusmenu_collector_parent_class)->dispose (object);
+	G_OBJECT_CLASS (menuitem_collector_parent_class)->dispose (object);
 	return;
 }
 
 static void
-dbusmenu_collector_finalize (GObject *object)
+menuitem_collector_finalize (GObject *object)
 {
 
-	G_OBJECT_CLASS (dbusmenu_collector_parent_class)->finalize (object);
+	G_OBJECT_CLASS (menuitem_collector_parent_class)->finalize (object);
 	return;
 }
 
-DbusmenuCollector *
-dbusmenu_collector_new (void)
+MenuitemCollector *
+menuitem_collector_new (void)
 {
-	return DBUSMENU_COLLECTOR(g_object_new(DBUSMENU_COLLECTOR_TYPE, NULL));
+	return MENUITEM_COLLECTOR(g_object_new(MENUITEM_COLLECTOR_TYPE, NULL));
 }
 
 static void
 update_layout_cb (GDBusConnection * connection, const gchar * sender, const gchar * path, const gchar * interface, const gchar * signal, GVariant * params, gpointer user_data)
 {
 	g_debug("Client updating %s:%s", sender, path);
-	DbusmenuCollector * collector = DBUSMENU_COLLECTOR(user_data);
+	MenuitemCollector * collector = MENUITEM_COLLECTOR(user_data);
 	g_return_if_fail(collector != NULL);
 
 	menu_key_t search_key = {
@@ -376,7 +376,7 @@
 		guint distance = calculate_distance(search, newstr, &used_strings);
 		if (distance < G_MAXUINT) {
 			// g_debug("Distance %d for '%s' in \"'%s'\" using \"'%s'\"", distance, search, g_strjoinv("' '", newstr), g_strjoinv("' '", used_strings));
-			results = g_list_prepend(results, dbusmenu_collector_found_new(client, rootitem, newstr, distance, used_strings, indicator_name));
+			results = g_list_prepend(results, menuitem_collector_found_new(client, rootitem, newstr, distance, used_strings, indicator_name));
 		}
 		g_strfreev(used_strings);
 	}
@@ -399,7 +399,7 @@
 }
 
 static GList *
-process_client (DbusmenuCollector * collector, DbusmenuClient * client, const gchar * search, GList * results, const gchar * indicator_name, GStrv prefix)
+process_client (MenuitemCollector * collector, DbusmenuClient * client, const gchar * search, GList * results, const gchar * indicator_name, GStrv prefix)
 {
 	/* Handle the case where there are no search terms */
 	if (search == NULL || search[0] == '\0') {
@@ -418,7 +418,7 @@
 			array[0] = label;
 			array[1] = NULL;
 
-			results = g_list_prepend(results, dbusmenu_collector_found_new(client, item, (GStrv)array, calculate_distance(NULL, (GStrv)array, NULL), NULL, indicator_name));
+			results = g_list_prepend(results, menuitem_collector_found_new(client, item, (GStrv)array, calculate_distance(NULL, (GStrv)array, NULL), NULL, indicator_name));
 		}
 
 		return results;
@@ -439,9 +439,9 @@
 }
 
 static GList *
-just_do_it (DbusmenuCollector * collector, const gchar * dbus_addr, const gchar * dbus_path, const gchar * search, GList * results, const gchar * indicator_name, GStrv prefix)
+just_do_it (MenuitemCollector * collector, const gchar * dbus_addr, const gchar * dbus_path, const gchar * search, GList * results, const gchar * indicator_name, GStrv prefix)
 {
-	g_return_val_if_fail(IS_DBUSMENU_COLLECTOR(collector), results);
+	g_return_val_if_fail(IS_MENUITEM_COLLECTOR(collector), results);
 
 	menu_key_t search_key = {
 		sender: (gchar *)dbus_addr,
@@ -462,7 +462,7 @@
 }
 
 GList *
-dbusmenu_collector_search (DbusmenuCollector * collector, const gchar * dbus_addr, const gchar * dbus_path, const gchar * prefix, const gchar * search)
+menuitem_collector_search (MenuitemCollector * collector, const gchar * dbus_addr, const gchar * dbus_path, const gchar * prefix, const gchar * search)
 {
 	GList * items = NULL;
 	GStrv prefixarray = NULL;
@@ -483,9 +483,9 @@
 }
 
 void
-dbusmenu_collector_execute (DbusmenuCollector * collector, const gchar * dbus_addr, const gchar * dbus_path, gint id, guint timestamp)
+menuitem_collector_execute (MenuitemCollector * collector, const gchar * dbus_addr, const gchar * dbus_path, gint id, guint timestamp)
 {
-	g_return_if_fail(IS_DBUSMENU_COLLECTOR(collector));
+	g_return_if_fail(IS_MENUITEM_COLLECTOR(collector));
 
 	menu_key_t search_key = {
 		sender: (gchar *)dbus_addr,
@@ -517,14 +517,14 @@
 }
 
 guint
-dbusmenu_collector_found_get_distance (DbusmenuCollectorFound * found)
+menuitem_collector_found_get_distance (MenuitemCollectorFound * found)
 {
 	g_return_val_if_fail(found != NULL, G_MAXUINT);
 	return found->distance;
 }
 
 void
-dbusmenu_collector_found_set_distance (DbusmenuCollectorFound * found, guint distance)
+menuitem_collector_found_set_distance (MenuitemCollectorFound * found, guint distance)
 {
 	g_return_if_fail(found != NULL);
 	found->distance = distance;
@@ -532,31 +532,31 @@
 }
 
 const gchar *
-dbusmenu_collector_found_get_display (DbusmenuCollectorFound * found)
+menuitem_collector_found_get_display (MenuitemCollectorFound * found)
 {
 	g_return_val_if_fail(found != NULL, NULL);
 	return found->display_string;
 }
 
 const gchar *
-dbusmenu_collector_found_get_db (DbusmenuCollectorFound * found)
+menuitem_collector_found_get_db (MenuitemCollectorFound * found)
 {
 	g_return_val_if_fail(found != NULL, NULL);
 	return found->db_string;
 }
 
 void
-dbusmenu_collector_found_list_free (GList * found_list)
+menuitem_collector_found_list_free (GList * found_list)
 {
-	g_list_free_full(found_list, (GDestroyNotify)dbusmenu_collector_found_free);
+	g_list_free_full(found_list, (GDestroyNotify)menuitem_collector_found_free);
 	return;
 }
 
-static DbusmenuCollectorFound *
-dbusmenu_collector_found_new (DbusmenuClient * client, DbusmenuMenuitem * item, GStrv strings, guint distance, GStrv usedstrings, const gchar * indicator_name)
+static MenuitemCollectorFound *
+menuitem_collector_found_new (DbusmenuClient * client, DbusmenuMenuitem * item, GStrv strings, guint distance, GStrv usedstrings, const gchar * indicator_name)
 {
 	// g_debug("New Found: '%s', %d, '%s'", string, distance, indicator_name);
-	DbusmenuCollectorFound * found = g_new0(DbusmenuCollectorFound, 1);
+	MenuitemCollectorFound * found = g_new0(MenuitemCollectorFound, 1);
 
 	g_object_get(client,
 	             DBUSMENU_CLIENT_PROP_DBUS_NAME, &found->dbus_addr,
@@ -631,7 +631,7 @@
 }
 
 void
-dbusmenu_collector_found_free (DbusmenuCollectorFound * found)
+menuitem_collector_found_free (MenuitemCollectorFound * found)
 {
 	g_return_if_fail(found != NULL);
 	g_free(found->dbus_addr);
@@ -646,7 +646,7 @@
 }
 
 const gchar *
-dbusmenu_collector_found_get_indicator (DbusmenuCollectorFound * found)
+menuitem_collector_found_get_indicator (MenuitemCollectorFound * found)
 {
 	// g_debug("Getting indicator for found '%s', indicator: '%s'", found->display_string, found->indicator);
 	g_return_val_if_fail(found != NULL, NULL);
@@ -654,7 +654,7 @@
 }
 
 void
-dbusmenu_collector_found_set_indicator (DbusmenuCollectorFound * found, const gchar * indicator)
+menuitem_collector_found_set_indicator (MenuitemCollectorFound * found, const gchar * indicator)
 {
 	g_return_if_fail(found != NULL);
 	g_free(found->indicator);
@@ -663,35 +663,35 @@
 }
 
 const gchar *
-dbusmenu_collector_found_get_dbus_addr (DbusmenuCollectorFound * found)
+menuitem_collector_found_get_dbus_addr (MenuitemCollectorFound * found)
 {
 	g_return_val_if_fail(found != NULL, NULL);
 	return found->dbus_addr;
 }
 
 const gchar *
-dbusmenu_collector_found_get_dbus_path (DbusmenuCollectorFound * found)
+menuitem_collector_found_get_dbus_path (MenuitemCollectorFound * found)
 {
 	g_return_val_if_fail(found != NULL, NULL);
 	return found->dbus_path;
 }
 
 gint
-dbusmenu_collector_found_get_dbus_id (DbusmenuCollectorFound * found)
+menuitem_collector_found_get_dbus_id (MenuitemCollectorFound * found)
 {
 	g_return_val_if_fail(found != NULL, -1);
 	return found->dbus_id;
 }
 
 const gchar *
-dbusmenu_collector_found_get_app_icon (DbusmenuCollectorFound * found)
+menuitem_collector_found_get_app_icon (MenuitemCollectorFound * found)
 {
 	g_return_val_if_fail(found != NULL, NULL);
 	return found->app_icon;
 }
 
 void
-dbusmenu_collector_found_set_app_icon (DbusmenuCollectorFound * found, const gchar * app_icon)
+menuitem_collector_found_set_app_icon (MenuitemCollectorFound * found, const gchar * app_icon)
 {
 	g_return_if_fail(found != NULL);
 	g_free(found->app_icon);
 
=== renamed file 'src/dbusmenu-collector.h' => 'src/menuitem-collector.h'
--- src/dbusmenu-collector.h	2012-01-26 16:51:25 +0000
+++ src/menuitem-collector.h	2012-01-26 16:51:25 +0000
@@ -20,54 +20,54 @@
 with this program.  If not, see <http://www.gnu.org/licenses/>.
 */
 
-#ifndef __DBUSMENU_COLLECTOR_H__
-#define __DBUSMENU_COLLECTOR_H__
+#ifndef __MENUITEM_COLLECTOR_H__
+#define __MENUITEM_COLLECTOR_H__
 
 #include <glib.h>
 #include <glib-object.h>
 
 G_BEGIN_DECLS
 
-#define DBUSMENU_COLLECTOR_TYPE            (dbusmenu_collector_get_type ())
-#define DBUSMENU_COLLECTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUSMENU_COLLECTOR_TYPE, DbusmenuCollector))
-#define DBUSMENU_COLLECTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), DBUSMENU_COLLECTOR_TYPE, DbusmenuCollectorClass))
-#define IS_DBUSMENU_COLLECTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUSMENU_COLLECTOR_TYPE))
-#define IS_DBUSMENU_COLLECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DBUSMENU_COLLECTOR_TYPE))
-#define DBUSMENU_COLLECTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), DBUSMENU_COLLECTOR_TYPE, DbusmenuCollectorClass))
-
-typedef struct _DbusmenuCollector          DbusmenuCollector;
-typedef struct _DbusmenuCollectorClass     DbusmenuCollectorClass;
-typedef struct _DbusmenuCollectorPrivate   DbusmenuCollectorPrivate;
-typedef struct _DbusmenuCollectorFound     DbusmenuCollectorFound;
-
-struct _DbusmenuCollectorClass {
+#define MENUITEM_COLLECTOR_TYPE            (menuitem_collector_get_type ())
+#define MENUITEM_COLLECTOR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), MENUITEM_COLLECTOR_TYPE, MenuitemCollector))
+#define MENUITEM_COLLECTOR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), MENUITEM_COLLECTOR_TYPE, MenuitemCollectorClass))
+#define IS_MENUITEM_COLLECTOR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), MENUITEM_COLLECTOR_TYPE))
+#define IS_MENUITEM_COLLECTOR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), MENUITEM_COLLECTOR_TYPE))
+#define MENUITEM_COLLECTOR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), MENUITEM_COLLECTOR_TYPE, MenuitemCollectorClass))
+
+typedef struct _MenuitemCollector          MenuitemCollector;
+typedef struct _MenuitemCollectorClass     MenuitemCollectorClass;
+typedef struct _MenuitemCollectorPrivate   MenuitemCollectorPrivate;
+typedef struct _MenuitemCollectorFound     MenuitemCollectorFound;
+
+struct _MenuitemCollectorClass {
 	GObjectClass parent_class;
 };
 
-struct _DbusmenuCollector {
+struct _MenuitemCollector {
 	GObject parent;
 
-	DbusmenuCollectorPrivate * priv;
+	MenuitemCollectorPrivate * priv;
 };
 
-GType dbusmenu_collector_get_type (void);
-DbusmenuCollector * dbusmenu_collector_new (void);
-GList * dbusmenu_collector_search (DbusmenuCollector * collector, const gchar * dbus_addr, const gchar * dbus_path, const gchar * prefix, const gchar * search);
-void dbusmenu_collector_execute (DbusmenuCollector * collector, const gchar * dbus_addr, const gchar * dbus_path, gint id, guint timestamp);
+GType menuitem_collector_get_type (void);
+MenuitemCollector * menuitem_collector_new (void);
+GList * menuitem_collector_search (MenuitemCollector * collector, const gchar * dbus_addr, const gchar * dbus_path, const gchar * prefix, const gchar * search);
+void menuitem_collector_execute (MenuitemCollector * collector, const gchar * dbus_addr, const gchar * dbus_path, gint id, guint timestamp);
 
-guint dbusmenu_collector_found_get_distance (DbusmenuCollectorFound * found);
-void dbusmenu_collector_found_set_distance (DbusmenuCollectorFound * found, guint distance);
-const gchar * dbusmenu_collector_found_get_display (DbusmenuCollectorFound * found);
-const gchar * dbusmenu_collector_found_get_db (DbusmenuCollectorFound * found);
-void dbusmenu_collector_found_free (DbusmenuCollectorFound * found);
-void dbusmenu_collector_found_list_free (GList * found_list);
-const gchar *  dbusmenu_collector_found_get_indicator (DbusmenuCollectorFound * found);
-void dbusmenu_collector_found_set_indicator (DbusmenuCollectorFound * found, const gchar * indicator);
-const gchar * dbusmenu_collector_found_get_dbus_addr (DbusmenuCollectorFound * found);
-const gchar * dbusmenu_collector_found_get_dbus_path (DbusmenuCollectorFound * found);
-gint dbusmenu_collector_found_get_dbus_id (DbusmenuCollectorFound * found);
-const gchar * dbusmenu_collector_found_get_app_icon (DbusmenuCollectorFound * found);
-void dbusmenu_collector_found_set_app_icon (DbusmenuCollectorFound * found, const gchar * app_icon);
+guint menuitem_collector_found_get_distance (MenuitemCollectorFound * found);
+void menuitem_collector_found_set_distance (MenuitemCollectorFound * found, guint distance);
+const gchar * menuitem_collector_found_get_display (MenuitemCollectorFound * found);
+const gchar * menuitem_collector_found_get_db (MenuitemCollectorFound * found);
+void menuitem_collector_found_free (MenuitemCollectorFound * found);
+void menuitem_collector_found_list_free (GList * found_list);
+const gchar *  menuitem_collector_found_get_indicator (MenuitemCollectorFound * found);
+void menuitem_collector_found_set_indicator (MenuitemCollectorFound * found, const gchar * indicator);
+const gchar * menuitem_collector_found_get_dbus_addr (MenuitemCollectorFound * found);
+const gchar * menuitem_collector_found_get_dbus_path (MenuitemCollectorFound * found);
+gint menuitem_collector_found_get_dbus_id (MenuitemCollectorFound * found);
+const gchar * menuitem_collector_found_get_app_icon (MenuitemCollectorFound * found);
+void menuitem_collector_found_set_app_icon (MenuitemCollectorFound * found, const gchar * app_icon);
 
 G_END_DECLS