Merge lp:~indicator-applet-developers/libindicator/ubuntu into lp:~ubuntu-desktop/libindicator/ubuntu

[Ted Gould]

=== modified file '.bzrignore'
--- .bzrignore	2009-08-07 15:06:32 +0000
+++ .bzrignore	2009-12-10 17:02:12 +0000
@@ -103,3 +103,43 @@
 data/GNOME_IndicatorAppletSUS.server
 data/GNOME_IndicatorAppletSUS.server.in
 src-sus/indicator-applet-no-sus
+libindicator/libindicator.la
+libindicator/libindicator_la-indicator-object.
+libindicator/libindicator_la-indicator-object.lo
+tests/loader-check-results.xml
+tests/loader-check-results.html
+tests/test-loader
+tests/libdummy-indicator-null.la
+tests/libdummy_indicator_null_la-dummy-indicator-null.lo
+tests/libdummy-indicator-simple.la
+tests/libdummy_indicator_simple_la-dummy-indicator-simple.lo
+tests/libdummy-indicator-blank.la
+tests/libdummy_indicator_blank_la-dummy-indicator-blank.lo
+libindicator-[0-9].[0-9].[0-9].tar.gz
+libindicator-[0-9].[0-9].[0-9].tar.gz.asc
+libindicator/libindicator_la-indicator-instance.lo
+tests/libdummy-indicator-signaler.la
+tests/libdummy_indicator_signaler_la-dummy-indicator-signaler.lo
+libindicator/indicator-service-client.h
+libindicator/indicator-service-server.h
+libindicator/libindicator_la-indicator-service.lo
+libindicator/libindicator_la-indicator-service-manager.lo
+tests/service-shutdown-timeout
+tests/loader-tester
+tests/service-shutdown-timeout-tester
+tests/service-manager-no-connect
+tests/service-manager-no-connect-tester
+tests/service-manager-connect
+tests/service-manager-connect-service
+tests/service-manager-connect-tester
+tests/session.conf
+tests/service-manager-connect.service
+tools/indicator-loader
+tests/service-version-bad-service
+tests/service-version-bad.service
+tests/service-version-good-service
+tests/service-version-good.service
+tests/service-version-manager
+tests/service-version-tester
+tests/service-manager-connect-nostart-tester
+tests/service-manager-nostart-connect

=== modified file 'Makefile.am'
--- Makefile.am	2009-08-18 16:52:09 +0000
+++ Makefile.am	2009-12-10 17:02:12 +0000
@@ -1,6 +1,8 @@
 
 SUBDIRS = \
-	libindicator
+	libindicator \
+	tests \
+	tools
 
 DISTCLEANFILES = \
 	libindicator-*.tar.gz

=== modified file 'autogen.sh'
--- autogen.sh	2009-08-18 16:52:09 +0000
+++ autogen.sh	2009-12-10 17:02:12 +0000
@@ -8,4 +8,4 @@
 }
 
 USE_GNOME2_MACROS=1 \
-gnome-autogen.sh
+. gnome-autogen.sh

=== modified file 'configure.ac'
--- configure.ac	2009-10-08 14:16:40 +0000
+++ configure.ac	2009-12-10 17:02:12 +0000
@@ -1,10 +1,10 @@
 
-AC_INIT(libindicator, 0.2.1, [e-mail])
+AC_INIT(libindicator, 0.3.0, [e-mail])
 
 AC_PREREQ(2.53)
 
 AM_CONFIG_HEADER(config.h)
-AM_INIT_AUTOMAKE(libindicator, 0.2.1)
+AM_INIT_AUTOMAKE(libindicator, 0.3.0)
 
 AM_MAINTAINER_MODE
 m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES])
@@ -21,6 +21,19 @@
 m4_ifdef([AM_SILENT_RULES],[AM_SILENT_RULES([yes])])
 
 ##############################
+# Dependencies
+##############################
+
+GTK_REQUIRED_VERSION=2.18
+DBUS_REQUIRED_VERSION=0.76
+
+PKG_CHECK_MODULES(LIBINDICATOR, gtk+-2.0 >= $GTK_REQUIRED_VERSION
+                                dbus-glib-1 >= $DBUS_REQUIRED_VERSION)
+
+AC_SUBST(LIBINDICATOR_CFLAGS)
+AC_SUBST(LIBINDICATOR_LIBS)
+
+##############################
 # Custom Junk
 ##############################
 
@@ -73,6 +86,8 @@
 Makefile
 libindicator/Makefile
 libindicator/indicator.pc
+tests/Makefile
+tools/Makefile
 ])
 
 ###########################

=== modified file 'debian/changelog'
--- debian/changelog	2009-10-09 06:12:31 +0000
+++ debian/changelog	2009-12-10 17:02:12 +0000
@@ -1,3 +1,24 @@
+libindicator (0.3.0-0ubuntu1~ppa1) karmic; urgency=low
+
+  * Upstream 0.3.0 Release 
+    * Adds a new tool to load indicators from the command line.
+    * Adds an object for loading indicators.
+    * Changes the indicator interface to be object based.
+  * debian/control, debian/libindicator0: Adding in a new packages
+    for the binary library.
+  * debian/control, debian/libindicator-tools: Adding in a new
+    package for the tools of libindicator.
+
+ -- Ted Gould <[e-mail]>  Thu, 10 Dec 2009 10:59:37 -0600
+
+libindicator (0.2.1-0ubuntu2~ppa1) karmic; urgency=low
+
+  * Adding in service management code.
+  * debian/control: Adding a target for libindicator0
+  * Adding libindicator0.install and libindicator-dev.install
+
+ -- Ted Gould <[e-mail]>  Wed, 04 Nov 2009 08:19:01 -0600
+
 libindicator (0.2.1-0ubuntu1) karmic; urgency=low
 
   * Upstream release 0.2.1 (LP: #446619)

=== modified file 'debian/control'
--- debian/control	2009-08-25 06:33:06 +0000
+++ debian/control	2009-12-10 17:02:12 +0000
@@ -4,21 +4,45 @@
 Maintainer: Ubuntu Core Developers <[e-mail]>
 Build-Depends: debhelper (>= 5.0),
                cdbs (>= 0.4.41),
-               libtool
+               libgtk2.0-dev (>= 2.12.0),
+               libdbus-glib-1-dev,
+               libtool,
+               intltool,
+               gtk-doc-tools
 Standards-Version: 3.8.0
 Homepage: https://launchpad.net/libindicator
 Vcs-Bzr: https://code.launchpad.net/~ubuntu-desktop/libindicator/ubuntu
 Vcs-Browser: http://bazaar.launchpad.net/~ubuntu-desktop/libindicator/ubuntu
 
+Package: libindicator0
+Section: libs
+Architecture: any
+Depends: ${shlibs:Depends},
+         ${misc:Depends}
+Description: GNOME panel indicator applet - shared library
+ This library contains information to build indicators to go into
+ the indicator applet.
+ .
+ This package contains files that are needed to build applications.
+
 Package: libindicator-dev
 Section: libdevel
 Architecture: any
 Depends: ${shlibs:Depends},
          ${misc:Depends},
-         libgtk2.0-dev (>= 2.12.0)
+         libgtk2.0-dev (>= 2.12.0),
+         libindicator0 (= ${binary:Version})
 Description: GNOME panel indicator applet - shared library
  This library contains information to build indicators to go into
  the indicator applet.
  .
  This package contains files that are needed to build applications.
 
+Package: libindicator-tools
+Section: devel
+Architecture: any
+Depends: ${shlibs:Depends},
+         ${misc:Depends},
+         libindicator0 (= ${binary:Version})
+Description: Need a better description
+

=== added file 'debian/libindicator-dev.install'
--- debian/libindicator-dev.install	1970-01-01 00:00:00 +0000
+++ debian/libindicator-dev.install	2009-12-10 17:02:12 +0000
@@ -0,0 +1,4 @@
+debian/tmp/usr/include/libindicator-0.3/libindicator/*
+debian/tmp/usr/lib/pkgconfig/indicator.pc
+debian/tmp/usr/lib/libindicator.a
+debian/tmp/usr/lib/libindicator.so

=== added file 'debian/libindicator-tools.install'
--- debian/libindicator-tools.install	1970-01-01 00:00:00 +0000
+++ debian/libindicator-tools.install	2009-12-10 17:02:12 +0000
@@ -0,0 +1,1 @@
+debian/tmp/usr/lib/libindicator/*

=== added file 'debian/libindicator0.install'
--- debian/libindicator0.install	1970-01-01 00:00:00 +0000
+++ debian/libindicator0.install	2009-12-10 17:02:12 +0000
@@ -0,0 +1,1 @@
+debian/tmp/usr/lib/libindicator.so.*

=== modified file 'libindicator/Makefile.am'
--- libindicator/Makefile.am	2009-04-21 19:15:22 +0000
+++ libindicator/Makefile.am	2009-12-10 17:02:12 +0000
@@ -1,14 +1,65 @@
+BUILT_SOURCES = 
+CLEANFILES = 
 EXTRA_DIST = \
 	indicator.pc.in
 
-libindicatorincludedir=$(includedir)/libindicator-0.1/libindicator
+libindicatorincludedir=$(includedir)/libindicator-0.3/libindicator
 
 indicator_headers = \
-	indicator.h
+	indicator.h \
+	indicator-object.h \
+	indicator-service.h \
+	indicator-service-manager.h
 
 libindicatorinclude_HEADERS = \
 	$(indicator_headers)
 
+lib_LTLIBRARIES = \
+	libindicator.la
+
+libindicator_la_SOURCES = \
+	$(indicator_headers) \
+	dbus-shared.h \
+	indicator-object.c \
+	indicator-service.c \
+	indicator-service-manager.c
+
+libindicator_la_CFLAGS = \
+	$(LIBINDICATOR_CFLAGS) \
+	-DG_LOG_DOMAIN=\"libindicator\" \
+	-Wall -Werror
+
+libindicator_la_LIBADD = \
+	$(LIBINDICATOR_LIBS)
+
 pkgconfig_DATA = indicator.pc
 pkgconfigdir = $(libdir)/pkgconfig
 
+##################################
+# DBus Specs
+##################################
+
+DBUS_SPECS = \
+	indicator-service.xml
+
+%-client.h: %.xml
+	dbus-binding-tool \
+		--prefix=_$(subst -,_,$(basename $(notdir $<)))_client \
+		--mode=glib-client \
+		--output=$@ \
+		$<
+
+%-server.h: %.xml
+	dbus-binding-tool \
+		--prefix=_$(subst -,_,$(basename $(notdir $<)))_server \
+		--mode=glib-server \
+		--output=$@ \
+		$<
+
+BUILT_SOURCES += \
+	$(DBUS_SPECS:.xml=-client.h) \
+	$(DBUS_SPECS:.xml=-server.h)
+
+CLEANFILES += $(BUILT_SOURCES)
+
+EXTRA_DIST += $(DBUS_SPECS)

=== added file 'libindicator/dbus-shared.h'
--- libindicator/dbus-shared.h	1970-01-01 00:00:00 +0000
+++ libindicator/dbus-shared.h	2009-12-10 17:02:12 +0000
@@ -0,0 +1,28 @@
+/*
+Shared defines for DBus interfaces and API versions to
+make sure the server and client agree.
+
+Copyright 2009 Canonical Ltd.
+
+Authors:
+    Ted Gould <[e-mail]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+version 3.0 as published by the Free Software Foundation.
+
+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 General Public License version 3.0 for more details.
+
+You should have received a copy of the GNU General Public
+License along with this library. If not, see
+<http://www.gnu.org/licenses/>.
+*/
+
+#define  INDICATOR_SERVICE_INTERFACE   "org.ayatana.indicator.service"
+#define  INDICATOR_SERVICE_OBJECT      "/org/ayatana/indicator/service"
+
+#define  INDICATOR_SERVICE_VERSION     1
+

=== added file 'libindicator/indicator-object.c'
--- libindicator/indicator-object.c	1970-01-01 00:00:00 +0000
+++ libindicator/indicator-object.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,344 @@
+/*
+An object to represent loadable indicator modules to make loading
+them easy and objectified.
+
+Copyright 2009 Canonical Ltd.
+
+Authors:
+    Ted Gould <[e-mail]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+version 3.0 as published by the Free Software Foundation.
+
+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 General Public License version 3.0 for more details.
+
+You should have received a copy of the GNU General Public
+License along with this library. If not, see
+<http://www.gnu.org/licenses/>.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "indicator.h"
+#include "indicator-object.h"
+
+/**
+	IndicatorObjectPrivate:
+	@module: The loaded module representing the object.  Note to
+		subclasses: This will not be set when you're initalized.
+	@entry: A default entry for objects that don't need all the
+		fancy stuff.  This works with #get_entries_default.
+	@gotten_entries: A check to see if the @entry has been
+		populated intelligently yet.
+
+	Structure to define the memory for the private area
+	of the object instance.
+*/
+struct _IndicatorObjectPrivate {
+	GModule * module;
+
+	/* For get_entries_default */
+	IndicatorObjectEntry entry;
+	gboolean gotten_entries;
+};
+
+#define INDICATOR_OBJECT_GET_PRIVATE(o) (INDICATOR_OBJECT(o)->priv)
+
+/* Signals Stuff */
+enum {
+	ENTRY_ADDED,
+	ENTRY_REMOVED,
+	LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+/* GObject stuff */
+static void indicator_object_class_init (IndicatorObjectClass *klass);
+static void indicator_object_init       (IndicatorObject *self);
+static void indicator_object_dispose    (GObject *object);
+static void indicator_object_finalize   (GObject *object);
+
+static GList * get_entries_default (IndicatorObject * io);
+
+G_DEFINE_TYPE (IndicatorObject, indicator_object, G_TYPE_OBJECT);
+
+/* Setup the class and put the functions into the
+   class structure */
+static void
+indicator_object_class_init (IndicatorObjectClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	g_type_class_add_private (klass, sizeof (IndicatorObjectPrivate));
+
+	object_class->dispose = indicator_object_dispose;
+	object_class->finalize = indicator_object_finalize;
+
+	klass->get_label =  NULL;
+	klass->get_menu =   NULL;
+	klass->get_image =  NULL;
+
+	klass->get_entries = get_entries_default;
+
+	/**
+		IndicatorObject::entry-added:
+		@arg0: The #IndicatorObject object
+		
+		Signaled when a new entry is added and should
+		be shown by the person using this object.
+	*/
+	signals[ENTRY_ADDED] = g_signal_new (INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED,
+	                                     G_TYPE_FROM_CLASS(klass),
+	                                     G_SIGNAL_RUN_LAST,
+	                                     G_STRUCT_OFFSET (IndicatorObjectClass, entry_added),
+	                                     NULL, NULL,
+	                                     g_cclosure_marshal_VOID__POINTER,
+	                                     G_TYPE_NONE, 1, G_TYPE_POINTER, G_TYPE_NONE);
+
+	/**
+		IndicatorObject::entry-removed:
+		@arg0: The #IndicatorObject object
+		
+		Signaled when an entry is removed and should
+		be removed by the person using this object.
+	*/
+	signals[ENTRY_REMOVED] = g_signal_new (INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED,
+	                                       G_TYPE_FROM_CLASS(klass),
+	                                       G_SIGNAL_RUN_LAST,
+	                                       G_STRUCT_OFFSET (IndicatorObjectClass, entry_removed),
+	                                       NULL, NULL,
+	                                       g_cclosure_marshal_VOID__POINTER,
+	                                       G_TYPE_NONE, 1, G_TYPE_POINTER, G_TYPE_NONE);
+
+	return;
+}
+
+/* Initialize an instance */
+static void
+indicator_object_init (IndicatorObject *self)
+{
+	self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, INDICATOR_OBJECT_TYPE, IndicatorObjectPrivate);
+
+	self->priv->module = NULL;
+
+	self->priv->entry.menu = NULL;
+	self->priv->entry.label = NULL;
+	self->priv->entry.image = NULL;
+
+	self->priv->gotten_entries = FALSE;
+
+	return;
+}
+
+/* Unref the objects that we're holding on to. */
+static void
+indicator_object_dispose (GObject *object)
+{
+
+	G_OBJECT_CLASS (indicator_object_parent_class)->dispose (object);
+	return;
+}
+
+/* A small helper function that closes a module but
+   in the function prototype of a GSourceFunc. */
+static gboolean
+module_unref (gpointer data)
+{
+	if (!g_module_close((GModule *)data)) {
+		/* All we can do is warn. */
+		g_warning("Unable to close module!");
+	}
+	return FALSE;
+}
+
+/* Free memory */
+static void
+indicator_object_finalize (GObject *object)
+{
+	IndicatorObjectPrivate * priv = INDICATOR_OBJECT_GET_PRIVATE(object);
+	
+	if (priv->module != NULL) {
+		/* Wow, this is convoluted.  So basically we want to unref
+		   the module which will cause the code it included to be
+		   removed.  But, since it's finalize function is the function
+		   that called this one, we can't really remove it before
+		   it finishes being executed.  So we're putting the job into
+		   the main loop to remove it the next time it gets a chance.
+		   Slightly non-deterministic, but should work. */
+		g_idle_add(module_unref, priv->module);
+		priv->module = NULL;
+	}
+
+	G_OBJECT_CLASS (indicator_object_parent_class)->finalize (object);
+	return;
+}
+
+/**
+	indicator_object_new_from_file:
+	@file: Filename containing a loadable module
+
+	This function builds an #IndicatorObject using the symbols
+	that are found in @file.  The module is loaded and the
+	references are all kept by the object.  To unload the 
+	module the object must be destroyed.
+
+	Return value: A valid #IndicatorObject or #NULL if error.
+*/
+IndicatorObject *
+indicator_object_new_from_file (const gchar * file)
+{
+	GObject * object = NULL;
+	GModule * module = NULL;
+
+	/* Check to make sure the name exists and that the
+	   file itself exists */
+	if (file == NULL) {
+		g_warning("Invalid filename.");
+		return NULL;
+	}
+
+	if (!g_file_test(file, G_FILE_TEST_EXISTS)) {
+		g_warning("File '%s' does not exist.", file);
+		return NULL;
+	}
+
+	/* Grab the g_module reference, pull it in but let's
+	   keep the symbols local to avoid conflicts. */
+	module = g_module_open(file,
+                           G_MODULE_BIND_LAZY | G_MODULE_BIND_LOCAL);
+	if (module == NULL) {
+		g_warning("Unable to load module: %s", file);
+		return NULL;
+	}
+
+	/* Look for the version function, error if not found. */
+	get_version_t lget_version = NULL;
+	if (!g_module_symbol(module, INDICATOR_GET_VERSION_S, (gpointer *)(&lget_version))) {
+		g_warning("Unable to get the symbol for getting the version.");
+		return NULL;
+	}
+
+	/* Check the version with the macro and make sure we're
+	   all talking the same language. */
+	if (!INDICATOR_VERSION_CHECK(lget_version())) {
+		g_warning("Indicator using API version '%s' we're expecting '%s'", lget_version(), INDICATOR_VERSION);
+		return NULL;
+	}
+
+	/* The function for grabbing a label from the module
+	   execute it, and make sure everything is a-okay */
+	get_type_t lget_type = NULL;
+	if (!g_module_symbol(module, INDICATOR_GET_TYPE_S, (gpointer *)(&lget_type))) {
+		g_warning("Unable to get '" INDICATOR_GET_TYPE_S "' symbol from module: %s", file);
+		goto unrefandout;
+	}
+	if (lget_type == NULL) {
+		g_warning("Symbol '" INDICATOR_GET_TYPE_S "' is (null) in module: %s", file);
+		goto unrefandout;
+	}
+
+	/* A this point we allocate the object, any code beyond
+	   here needs to deallocate it if we're returning in an
+	   error'd state. */
+	object = g_object_new(lget_type(), NULL);
+	if (object == NULL) {
+		g_warning("Unable to build an object if type '%d' in module: %s", (gint)lget_type(), file);
+		goto unrefandout;
+	}
+	if (!INDICATOR_IS_OBJECT(object)) {
+		g_warning("Type '%d' in file %s is not a subclass of IndicatorObject.", (gint)lget_type(), file);
+		goto unrefandout;
+	}
+
+	IndicatorObjectPrivate * priv = INDICATOR_OBJECT_GET_PRIVATE(object);
+	/* Now we can track the module */
+	priv->module = module;
+
+	return INDICATOR_OBJECT(object);
+
+	/* Error, let's drop the object and return NULL.  Sad when
+	   this happens. */
+unrefandout:
+	if (object != NULL) {
+		g_object_unref(object);
+	}
+	if (module != NULL) {
+		g_object_unref(module);
+	}
+	g_warning("Error building IndicatorObject from file: %s", file);
+	return NULL;
+}
+
+/* The default get entries function uses the other single
+   entries in the class to create an entry structure and
+   put it into a list.  This makes it simple for simple objects
+   to create the list.  Small changes from the way they 
+   previously were. */
+static GList *
+get_entries_default (IndicatorObject * io)
+{
+	IndicatorObjectPrivate * priv = INDICATOR_OBJECT_GET_PRIVATE(io);
+
+	if (!priv->gotten_entries) {
+		IndicatorObjectClass * class = INDICATOR_OBJECT_GET_CLASS(io);
+
+		if (class->get_label) {
+			priv->entry.label = class->get_label(io);
+		}
+
+		if (class->get_image) {
+			priv->entry.image = class->get_image(io);
+		}
+
+		if (priv->entry.image == NULL && priv->entry.label == NULL) {
+			g_warning("IndicatorObject class does not create an image or a label.  We need one of those.");
+			return NULL;
+		}
+
+		if (class->get_menu) {
+			priv->entry.menu = class->get_menu(io);
+		}
+
+		if (priv->entry.menu == NULL) {
+			g_warning("IndicatorObject class does not create a menu.  We need one of those.");
+			return NULL;
+		}
+
+		priv->gotten_entries = TRUE;
+	}
+
+	return g_list_append(NULL, &(priv->entry));
+}
+
+/**
+	indicator_object_get_entires:
+	@io: #IndicatorObject to query
+
+	This function looks on the class for the object and calls
+	it's #IndicatorObjectClass::get_entries function.  The
+	list should be owned by the caller, but the individual
+	enteries should not be.
+
+	Return value: A list if #IndicatorObjectEntry structures or
+		NULL if there is an error.
+*/
+GList *
+indicator_object_get_entries (IndicatorObject * io)
+{
+	g_return_val_if_fail(INDICATOR_IS_OBJECT(io), NULL);
+	IndicatorObjectClass * class = INDICATOR_OBJECT_GET_CLASS(io);
+
+	if (class->get_entries) {
+		return class->get_entries(io);
+	}
+
+	g_error("No get_entries function on object.  It must have been deleted?!?!");
+	return NULL;
+}

=== added file 'libindicator/indicator-object.h'
--- libindicator/indicator-object.h	1970-01-01 00:00:00 +0000
+++ libindicator/indicator-object.h	2009-12-10 17:02:12 +0000
@@ -0,0 +1,123 @@
+/*
+An object to represent loadable indicator modules to make loading
+them easy and objectified.
+
+Copyright 2009 Canonical Ltd.
+
+Authors:
+    Ted Gould <[e-mail]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+version 3.0 as published by the Free Software Foundation.
+
+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 General Public License version 3.0 for more details.
+
+You should have received a copy of the GNU General Public
+License along with this library. If not, see
+<http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __INDICATOR_OBJECT_H__
+#define __INDICATOR_OBJECT_H__
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define INDICATOR_OBJECT_TYPE            (indicator_object_get_type ())
+#define INDICATOR_OBJECT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), INDICATOR_OBJECT_TYPE, IndicatorObject))
+#define INDICATOR_OBJECT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), INDICATOR_OBJECT_TYPE, IndicatorObjectClass))
+#define INDICATOR_IS_OBJECT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), INDICATOR_OBJECT_TYPE))
+#define INDICATOR_IS_OBJECT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), INDICATOR_OBJECT_TYPE))
+#define INDICATOR_OBJECT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), INDICATOR_OBJECT_TYPE, IndicatorObjectClass))
+
+#define INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED       "entry-added"
+#define INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED_ID    (g_signal_lookup(INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED, INDICATOR_OBJECT_TYPE))
+#define INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED     "entry-removed"
+#define INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED_ID  (g_signal_lookup(INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED, INDICATOR_OBJECT_TYPE))
+
+typedef struct _IndicatorObject        IndicatorObject;
+typedef struct _IndicatorObjectClass   IndicatorObjectClass;
+typedef struct _IndicatorObjectPrivate IndicatorObjectPrivate;
+typedef struct _IndicatorObjectEntry   IndicatorObjectEntry;
+
+/**
+	IndicatorObjectClass:
+	@parent_class: #GObjectClass
+	@get_label: Gets the label for this object.  Should be set
+		to #NULL if @get_entries is set.  Should NOT ref the
+		object.
+	@get_image: Gets the image for this object.  Should be set
+		to #NULL if @get_entries is set.  Should NOT ref the
+		object.
+	@get_menu: Gets the image for this object.  Should be set
+		to #NULL if @get_entries is set.  Should NOT ref the
+		object.
+	@get_entries: Gets all of the entires for this object returning
+		a #GList of #IndicatorObjectEntries.  The list should be
+		under the ownership of the caller but the entires will
+		not be.
+	@entry_added: Slot for #IndicatorObject::entry-added
+	@entry_removed: Slot for #IndicatorObject::entry-removed
+	@indicator_object_reserved_1: Reserved for future use
+	@indicator_object_reserved_2: Reserved for future use
+	@indicator_object_reserved_3: Reserved for future use
+	@indicator_object_reserved_4: Reserved for future use
+*/
+struct _IndicatorObjectClass {
+	GObjectClass parent_class;
+	
+	/* Virtual Functions */
+	GtkLabel * (*get_label) (IndicatorObject * io);
+	GtkImage * (*get_image) (IndicatorObject * io);
+	GtkMenu  * (*get_menu)  (IndicatorObject * io);
+
+	GList *    (*get_entries) (IndicatorObject * io);
+
+	/* Signals */
+	void       (*entry_added) (IndicatorObject * io, IndicatorObjectEntry * entry, gpointer user_data);
+	void       (*entry_removed) (IndicatorObject * io, IndicatorObjectEntry * entry, gpointer user_data);
+
+	/* Reserved */
+	void (* indicator_object_reserved_1) (void);
+	void (* indicator_object_reserved_2) (void);
+	void (* indicator_object_reserved_3) (void);
+	void (* indicator_object_reserved_4) (void);
+};
+
+/**
+	IndicatorObject:
+	@parent: #GObject
+	@priv: A cached reference to the private data for the
+		instance.
+*/
+struct _IndicatorObject {
+	GObject parent;
+	IndicatorObjectPrivate * priv;
+};
+
+/**
+	IndicatorObjectEntry:
+	@label: The label to be shown on the panel
+	@image: The image to be shown on the panel
+	@menu: The menu to be added to the menubar
+*/
+struct _IndicatorObjectEntry {
+	GtkLabel * label;
+	GtkImage * image;
+	GtkMenu  * menu;
+};
+
+GType indicator_object_get_type (void);
+IndicatorObject * indicator_object_new_from_file (const gchar * file);
+
+GList * indicator_object_get_entries (IndicatorObject * io);
+
+G_END_DECLS
+
+#endif

=== added file 'libindicator/indicator-service-manager.c'
--- libindicator/indicator-service-manager.c	1970-01-01 00:00:00 +0000
+++ libindicator/indicator-service-manager.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,493 @@
+/*
+An object used to manage services.  Either start them or
+just connect to them.
+
+Copyright 2009 Canonical Ltd.
+
+Authors:
+    Ted Gould <[e-mail]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+version 3.0 as published by the Free Software Foundation.
+
+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 General Public License version 3.0 for more details.
+
+You should have received a copy of the GNU General Public
+License along with this library. If not, see
+<http://www.gnu.org/licenses/>.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <dbus/dbus-glib-bindings.h>
+#include <dbus/dbus-glib-lowlevel.h>
+
+#include "indicator-service-manager.h"
+#include "indicator-service-client.h"
+#include "dbus-shared.h"
+
+/* Private Stuff */
+/**
+	IndicatorServiceManagerPrivate:
+	@name: The well known dbus name the service should be on.
+	@dbus_proxy: A proxy to talk to the dbus daemon.
+	@service_proxy: The proxy to the service itself.
+	@connected: Whether we're connected to the service or not.
+	@this_service_version: The version of the service that we're looking for.
+	@bus: A reference to the bus so we don't have to keep getting it.
+*/
+typedef struct _IndicatorServiceManagerPrivate IndicatorServiceManagerPrivate;
+struct _IndicatorServiceManagerPrivate {
+	gchar * name;
+	DBusGProxy * dbus_proxy;
+	DBusGProxy * service_proxy;
+	gboolean connected;
+	guint this_service_version;
+	DBusGConnection * bus;
+};
+
+/* Signals Stuff */
+enum {
+	CONNECTION_CHANGE,
+	LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+
+/* Properties */
+/* Enum for the properties so that they can be quickly
+   found and looked up. */
+enum {
+	PROP_0,
+	PROP_NAME,
+	PROP_VERSION
+};
+
+/* The strings so that they can be slowly looked up. */
+#define PROP_NAME_S                    "name"
+#define PROP_VERSION_S                 "version"
+
+/* GObject Stuff */
+#define INDICATOR_SERVICE_MANAGER_GET_PRIVATE(o) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((o), INDICATOR_SERVICE_MANAGER_TYPE, IndicatorServiceManagerPrivate))
+
+static void indicator_service_manager_class_init (IndicatorServiceManagerClass *klass);
+static void indicator_service_manager_init       (IndicatorServiceManager *self);
+static void indicator_service_manager_dispose    (GObject *object);
+static void indicator_service_manager_finalize   (GObject *object);
+
+/* Prototypes */
+static void set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec);
+static void get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec);
+static void start_service (IndicatorServiceManager * service);
+
+G_DEFINE_TYPE (IndicatorServiceManager, indicator_service_manager, G_TYPE_OBJECT);
+
+/* Build all of our signals and proxies and tie everything
+   all together.  Lovely. */
+static void
+indicator_service_manager_class_init (IndicatorServiceManagerClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	g_type_class_add_private (klass, sizeof (IndicatorServiceManagerPrivate));
+
+	object_class->dispose = indicator_service_manager_dispose;
+	object_class->finalize = indicator_service_manager_finalize;
+
+	/* Property funcs */
+	object_class->set_property = set_property;
+	object_class->get_property = get_property;
+
+	/**
+		IndicatorServiceManager::connecton-change:
+		@arg0: The #IndicatorServiceManager object
+		@arg1: The state of the connection, TRUE is connected.
+		
+		Signaled when the service is connected or disconnected
+		depending on it's previous state.
+	*/
+	signals[CONNECTION_CHANGE] = g_signal_new (INDICATOR_SERVICE_MANAGER_SIGNAL_CONNECTION_CHANGE,
+	                                  G_TYPE_FROM_CLASS(klass),
+	                                  G_SIGNAL_RUN_LAST,
+	                                  G_STRUCT_OFFSET (IndicatorServiceManagerClass, connection_change),
+	                                  NULL, NULL,
+	                                  g_cclosure_marshal_VOID__BOOLEAN,
+	                                  G_TYPE_NONE, 1, G_TYPE_BOOLEAN, G_TYPE_NONE);
+
+	/* Properties */
+	g_object_class_install_property(object_class, PROP_NAME,
+	                                g_param_spec_string(PROP_NAME_S,
+	                                                    "The DBus name for the service to monitor",
+	                                                    "This is the name that should be used to start a service.",
+	                                                    NULL,
+	                                                    G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+	g_object_class_install_property(object_class, PROP_VERSION,
+	                                g_param_spec_uint(PROP_VERSION_S,
+	                                                  "The version of the service that we're expecting.",
+	                                                  "A number to check and reject a service if it gives us the wrong number.  This should match across the manager and the service",
+	                                                  0, G_MAXUINT, 0,
+	                                                  G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+	return;
+}
+
+/* This inits all the variable and sets up the proxy
+   to dbus.  It doesn't look for the service as at this
+   point we don't know it's name. */
+static void
+indicator_service_manager_init (IndicatorServiceManager *self)
+{
+	IndicatorServiceManagerPrivate * priv = INDICATOR_SERVICE_MANAGER_GET_PRIVATE(self);
+
+	/* Get the private variables in a decent state */
+	priv->name = NULL;
+	priv->dbus_proxy = NULL;
+	priv->service_proxy = NULL;
+	priv->connected = FALSE;
+	priv->this_service_version = 0;
+	priv->bus = NULL;
+
+	/* Start talkin' dbus */
+	GError * error = NULL;
+	priv->bus = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
+	if (error != NULL) {
+		g_error("Unable to get session bus for manager: %s", error->message);
+		g_error_free(error);
+		return;
+	}
+
+	priv->dbus_proxy = dbus_g_proxy_new_for_name_owner(priv->bus,
+	                                                   DBUS_SERVICE_DBUS,
+	                                                   DBUS_PATH_DBUS,
+	                                                   DBUS_INTERFACE_DBUS,
+	                                                   &error);
+	if (error != NULL) {
+		g_error("Unable to get the proxy to DBus: %s", error->message);
+		g_error_free(error);
+		return;
+	}
+
+	return;
+}
+
+/* If we're connected this provides all the signals to say
+   that we're about to not be.  Then it takes down the proxies
+   and tells the service that we're not interested in being
+   its friend anymore either. */
+static void
+indicator_service_manager_dispose (GObject *object)
+{
+	IndicatorServiceManagerPrivate * priv = INDICATOR_SERVICE_MANAGER_GET_PRIVATE(object);
+
+	/* If we were connected we need to make sure to
+	   tell people that it's no longer the case. */
+	if (priv->connected) {
+		priv->connected = FALSE;
+		g_signal_emit(object, signals[CONNECTION_CHANGE], 0, FALSE, TRUE);
+	}
+
+	/* Destory our DBus proxy, we won't need it. */
+	if (priv->dbus_proxy != NULL) {
+		g_object_unref(G_OBJECT(priv->dbus_proxy));
+		priv->dbus_proxy = NULL;
+	}
+
+	/* If we have a proxy, tell it we're shutting down.  Just
+	   to be polite about it. */
+	if (priv->service_proxy != NULL) {
+		dbus_g_proxy_call_no_reply(priv->service_proxy, "UnWatch", G_TYPE_INVALID);
+	}
+
+	/* Destory our service proxy, we won't need it. */
+	if (priv->service_proxy != NULL) {
+		g_object_unref(G_OBJECT(priv->service_proxy));
+		priv->service_proxy = NULL;
+	}
+
+	/* Let's see if our parents want to do anything. */
+	G_OBJECT_CLASS (indicator_service_manager_parent_class)->dispose (object);
+	return;
+}
+
+/* Ironically, we don't allocate a lot of memory ourselves. */
+static void
+indicator_service_manager_finalize (GObject *object)
+{
+	IndicatorServiceManagerPrivate * priv = INDICATOR_SERVICE_MANAGER_GET_PRIVATE(object);
+
+	if (priv->name != NULL) {
+		g_free(priv->name);
+		priv->name = NULL;
+	}
+
+	G_OBJECT_CLASS (indicator_service_manager_parent_class)->finalize (object);
+	return;
+}
+
+/* Either copies the name into the private variable or
+   sets the version.  Do it wrong and it'll get upset. */
+static void
+set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec)
+{
+	IndicatorServiceManager * self = INDICATOR_SERVICE_MANAGER(object);
+	g_return_if_fail(self != NULL);
+
+	IndicatorServiceManagerPrivate * priv = INDICATOR_SERVICE_MANAGER_GET_PRIVATE(self);
+	g_return_if_fail(priv != NULL);
+
+	switch (prop_id) {
+	/* *********************** */
+	case PROP_NAME:
+		if (priv->name != NULL) {
+			g_error("Name can not be set twice!");
+			return;
+		}
+		priv->name = g_value_dup_string(value);
+		start_service(self);
+		break;
+	/* *********************** */
+	case PROP_VERSION:
+		priv->this_service_version = g_value_get_uint(value);
+		break;
+	/* *********************** */
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		break;
+	}
+
+	return;
+}
+
+/* Grabs the values from the private variables and
+   puts them into the value. */
+static void
+get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec)
+{
+	IndicatorServiceManager * self = INDICATOR_SERVICE_MANAGER(object);
+	g_return_if_fail(self != NULL);
+
+	IndicatorServiceManagerPrivate * priv = INDICATOR_SERVICE_MANAGER_GET_PRIVATE(self);
+	g_return_if_fail(priv != NULL);
+
+	switch (prop_id) {
+	/* *********************** */
+	case PROP_NAME:
+		g_value_set_string(value, priv->name);
+		break;
+	/* *********************** */
+	case PROP_VERSION:
+		g_value_set_uint(value, priv->this_service_version);
+		break;
+	/* *********************** */
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		break;
+	}
+
+	return;
+}
+
+/* A callback from telling a service that we want to watch
+   it.  It gives us the service API version and the version
+   of the other APIs it supports.  We check both of those.
+   If they don't match then we unwatch it.  Otherwise, we
+   signal a connection change to tell the rest of the world
+   that we have a service now.  */
+static void
+watch_cb (DBusGProxy * proxy, guint service_api_version, guint this_service_version, GError * error, gpointer user_data)
+{
+	IndicatorServiceManagerPrivate * priv = INDICATOR_SERVICE_MANAGER_GET_PRIVATE(user_data);
+
+	if (error != NULL) {
+		g_warning("Unable to set watch on '%s': '%s'", priv->name, error->message);
+		g_error_free(error);
+		return;
+	}
+
+	if (service_api_version != INDICATOR_SERVICE_VERSION) {
+		g_warning("Service is using a different version of the service interface.  Expecting %d and got %d.", INDICATOR_SERVICE_VERSION, service_api_version);
+		dbus_g_proxy_call_no_reply(priv->service_proxy, "UnWatch", G_TYPE_INVALID);
+		return;
+	}
+
+	if (this_service_version != priv->this_service_version) {
+		g_warning("Service is using a different API version than the manager.  Expecting %d and got %d.", priv->this_service_version, this_service_version);
+		dbus_g_proxy_call_no_reply(priv->service_proxy, "UnWatch", G_TYPE_INVALID);
+		return;
+	}
+
+	if (!priv->connected) {
+		priv->connected = TRUE;
+		g_signal_emit(G_OBJECT(user_data), signals[CONNECTION_CHANGE], 0, TRUE, TRUE);
+	}
+
+	return;
+}
+
+/* The callback after asking the dbus-daemon to start a
+   service for us.  It can return success or failure, on
+   failure we can't do much.  But, with sucess, we start
+   to build a proxy and tell the service that we're watching. */
+static void
+start_service_cb (DBusGProxy * proxy, guint status, GError * error, gpointer user_data)
+{
+	IndicatorServiceManagerPrivate * priv = INDICATOR_SERVICE_MANAGER_GET_PRIVATE(user_data);
+
+	if (error != NULL) {
+		g_warning("Unable to start service '%s': %s", priv->name, error->message);
+		return;
+	}
+
+	if (status != DBUS_START_REPLY_SUCCESS && status != DBUS_START_REPLY_ALREADY_RUNNING) {
+		g_warning("Status of starting the process '%s' was an error: %d", priv->name, status);
+		return;
+	}
+
+	/* Woot! it's running.  Let's do it some more. */
+	priv->service_proxy = dbus_g_proxy_new_for_name_owner(priv->bus,
+	                                                  priv->name,
+	                                                  INDICATOR_SERVICE_OBJECT,
+	                                                  INDICATOR_SERVICE_INTERFACE,
+	                                                  &error);
+	g_object_add_weak_pointer(G_OBJECT(priv->service_proxy), (gpointer *)&(priv->service_proxy));
+
+	org_ayatana_indicator_service_watch_async(priv->service_proxy,
+	                                          watch_cb,
+	                                          user_data);
+
+	return;
+}
+
+/* The function that handles getting us connected to the service.
+   In many cases it will start the service, but if the service
+   is already there it just allocates the service proxy and acts
+   like it was no big deal. */
+static void
+start_service (IndicatorServiceManager * service)
+{
+	GError * error = NULL;
+	IndicatorServiceManagerPrivate * priv = INDICATOR_SERVICE_MANAGER_GET_PRIVATE(service);
+
+	g_return_if_fail(priv->dbus_proxy != NULL);
+	g_return_if_fail(priv->name != NULL);
+
+	/* Check to see if we can get a proxy to it first. */
+	priv->service_proxy = dbus_g_proxy_new_for_name_owner(priv->bus,
+	                                                      priv->name,
+	                                                      INDICATOR_SERVICE_OBJECT,
+	                                                      INDICATOR_SERVICE_INTERFACE,
+	                                                      &error);
+
+	if (error != NULL) {
+		/* We don't care about the error, just start the service anyway. */
+		g_error_free(error);
+		org_freedesktop_DBus_start_service_by_name_async (priv->dbus_proxy,
+		                                                  priv->name,
+		                                                  0,
+		                                                  start_service_cb,
+		                                                  service);
+	} else {
+		g_object_add_weak_pointer(G_OBJECT(priv->service_proxy), (gpointer *)&(priv->service_proxy));
+
+		/* If we got a proxy just because we're good people then
+		   we need to call watch on it just like 'start_service_cb'
+		   does. */
+		org_ayatana_indicator_service_watch_async(priv->service_proxy,
+		                                          watch_cb,
+		                                          service);
+	}
+
+	return;
+}
+
+/* API */
+
+/**
+	indicator_service_manager_new:
+	@dbus_name: The well known name of the service on DBus
+
+	This creates a new service manager object.  If the service
+	is not running it will start it.  No matter what, it will
+	give a IndicatorServiceManager::connection-changed event
+	signal when it gets connected.
+
+	Return value: A brand new lovely #IndicatorServiceManager
+		object.
+*/
+IndicatorServiceManager *
+indicator_service_manager_new (gchar * dbus_name)
+{
+	GObject * obj = g_object_new(INDICATOR_SERVICE_MANAGER_TYPE,
+	                             PROP_NAME_S, dbus_name,
+	                             NULL);
+
+	return INDICATOR_SERVICE_MANAGER(obj);
+}
+
+/**
+	inicator_service_manager_new_version:
+	@dbus_name: The well known name of the service on DBus
+	@version: Version of the service we expect
+
+	This creates a new service manager object.  It also sets
+	the version of the service that we're expecting to see.
+	In general, it behaves similarly to #indicator_service_manager_new()
+	except that it checks @version against the version returned
+	by the service.
+
+	Return value: A brand new lovely #IndicatorServiceManager
+		object.
+*/
+IndicatorServiceManager *
+indicator_service_manager_new_version (gchar * dbus_name, guint version)
+{
+	GObject * obj = g_object_new(INDICATOR_SERVICE_MANAGER_TYPE,
+	                             PROP_NAME_S, dbus_name,
+	                             PROP_VERSION_S, version,
+	                             NULL);
+
+	return INDICATOR_SERVICE_MANAGER(obj);
+}
+
+/**
+	indicator_service_manager_connected:
+	@sm: #IndicatorServiceManager object to check
+
+	Checks to see if the service manager is connected to a
+	service.
+
+	Return value: #TRUE if there is a service connceted.
+*/
+gboolean
+indicator_service_manager_connected (IndicatorServiceManager * sm)
+{
+	g_return_val_if_fail(INDICATOR_IS_SERVICE_MANAGER(sm), FALSE);
+	IndicatorServiceManagerPrivate * priv = INDICATOR_SERVICE_MANAGER_GET_PRIVATE(sm);
+	return priv->connected;
+}
+
+/**
+	indicator_service_manager_set_refresh:
+	@sm: #IndicatorServiceManager object to configure
+	@time_in_ms: The refresh time in milliseconds
+
+	Use this function to set the amount of time between restarting
+	services that may crash or shutdown.  This is mostly useful
+	for testing and development.
+
+	NOTE: Not yet implemented.
+*/
+void
+indicator_service_manager_set_refresh (IndicatorServiceManager * sm, guint time_in_ms)
+{
+
+	return;
+}

=== added file 'libindicator/indicator-service-manager.h'
--- libindicator/indicator-service-manager.h	1970-01-01 00:00:00 +0000
+++ libindicator/indicator-service-manager.h	2009-12-10 17:02:12 +0000
@@ -0,0 +1,88 @@
+/*
+An object used to manage services.  Either start them or
+just connect to them.
+
+Copyright 2009 Canonical Ltd.
+
+Authors:
+    Ted Gould <[e-mail]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+version 3.0 as published by the Free Software Foundation.
+
+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 General Public License version 3.0 for more details.
+
+You should have received a copy of the GNU General Public
+License along with this library. If not, see
+<http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __INDICATOR_SERVICE_MANAGER_H__
+#define __INDICATOR_SERVICE_MANAGER_H__
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define INDICATOR_SERVICE_MANAGER_TYPE            (indicator_service_manager_get_type ())
+#define INDICATOR_SERVICE_MANAGER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), INDICATOR_SERVICE_MANAGER_TYPE, IndicatorServiceManager))
+#define INDICATOR_SERVICE_MANAGER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), INDICATOR_SERVICE_MANAGER_TYPE, IndicatorServiceManagerClass))
+#define INDICATOR_IS_SERVICE_MANAGER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), INDICATOR_SERVICE_MANAGER_TYPE))
+#define INDICATOR_IS_SERVICE_MANAGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), INDICATOR_SERVICE_MANAGER_TYPE))
+#define INDICATOR_SERVICE_MANAGER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), INDICATOR_SERVICE_MANAGER_TYPE, IndicatorServiceManagerClass))
+
+#define INDICATOR_SERVICE_MANAGER_SIGNAL_CONNECTION_CHANGE   "connection-change"
+
+typedef struct _IndicatorServiceManager      IndicatorServiceManager;
+typedef struct _IndicatorServiceManagerClass IndicatorServiceManagerClass;
+
+/**
+	IndicatorServiceManagerClass:
+	@parent: #GObjectClass
+	@connection_changed: Slot for #IndicatorServiceManager::connection-changed.
+	@indicator_service_manager_reserved1: Reserved for future use.
+	@indicator_service_manager_reserved2: Reserved for future use.
+	@indicator_service_manager_reserved3: Reserved for future use.
+	@indicator_service_manager_reserved4: Reserved for future use.
+
+*/
+struct _IndicatorServiceManagerClass {
+	GObjectClass parent_class;
+
+	/* Signals */
+	void (*connection_change) (IndicatorServiceManager * sm, gboolean connected, gpointer user_data);
+
+	/* Buffer */
+	void (*indicator_service_manager_reserved1) (void);
+	void (*indicator_service_manager_reserved2) (void);
+	void (*indicator_service_manager_reserved3) (void);
+	void (*indicator_service_manager_reserved4) (void);
+};
+
+/**
+	IndicatorServiceManager:
+	@parent: #GObject
+
+*/
+struct _IndicatorServiceManager {
+	GObject parent;
+
+};
+
+GType indicator_service_manager_get_type (void);
+
+IndicatorServiceManager *   indicator_service_manager_new         (gchar * dbus_name);
+IndicatorServiceManager *   indicator_service_manager_new_version (gchar * dbus_name,
+                                                                   guint version);
+gboolean                    indicator_service_manager_connected   (IndicatorServiceManager * sm);
+void                        indicator_service_manager_set_refresh (IndicatorServiceManager * sm,
+                                                                   guint time_in_ms);
+
+G_END_DECLS
+
+#endif

=== added file 'libindicator/indicator-service.c'
--- libindicator/indicator-service.c	1970-01-01 00:00:00 +0000
+++ libindicator/indicator-service.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,479 @@
+/*
+An object used to provide a simple interface for a service
+to query version and manage whether it's running.
+
+Copyright 2009 Canonical Ltd.
+
+Authors:
+    Ted Gould <[e-mail]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+version 3.0 as published by the Free Software Foundation.
+
+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 General Public License version 3.0 for more details.
+
+You should have received a copy of the GNU General Public
+License along with this library. If not, see
+<http://www.gnu.org/licenses/>.
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+#include <dbus/dbus-glib-bindings.h>
+#include <dbus/dbus-glib-lowlevel.h>
+
+#include "indicator-service.h"
+
+/* DBus Prototypes */
+static gboolean _indicator_service_server_watch (IndicatorService * service, DBusGMethodInvocation * method);
+static gboolean _indicator_service_server_un_watch (IndicatorService * service, DBusGMethodInvocation * method);
+
+#include "indicator-service-server.h"
+#include "dbus-shared.h"
+
+/* Private Stuff */
+/**
+	IndicatorSevicePrivate:
+	@name: The DBus well known name for the service.
+	@dbus_proxy: A proxy for talking to the dbus bus manager.
+	@timeout: The source ID for the timeout event.
+	@watcher: A list of processes on dbus that are watching us.
+	@this_service_version: The version to hand out that we're
+		implementing.  May not be set, so we'll send zero (default).
+*/
+typedef struct _IndicatorServicePrivate IndicatorServicePrivate;
+struct _IndicatorServicePrivate {
+	gchar * name;
+	DBusGProxy * dbus_proxy;
+	guint timeout;
+	GList * watchers;
+	guint this_service_version;
+};
+
+/* Signals Stuff */
+enum {
+	SHUTDOWN,
+	LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL] = { 0 };
+
+/* Properties */
+/* Enum for the properties so that they can be quickly
+   found and looked up. */
+enum {
+	PROP_0,
+	PROP_NAME,
+	PROP_VERSION
+};
+
+/* The strings so that they can be slowly looked up. */
+#define PROP_NAME_S                    "name"
+#define PROP_VERSION_S                 "version"
+
+/* GObject Stuff */
+#define INDICATOR_SERVICE_GET_PRIVATE(o) \
+			(G_TYPE_INSTANCE_GET_PRIVATE ((o), INDICATOR_SERVICE_TYPE, IndicatorServicePrivate))
+
+static void indicator_service_class_init (IndicatorServiceClass *klass);
+static void indicator_service_init       (IndicatorService *self);
+static void indicator_service_dispose    (GObject *object);
+static void indicator_service_finalize   (GObject *object);
+
+/* Other prototypes */
+static void set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec);
+static void get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec);
+static void try_and_get_name (IndicatorService * service);
+
+G_DEFINE_TYPE (IndicatorService, indicator_service, G_TYPE_OBJECT);
+
+static void
+indicator_service_class_init (IndicatorServiceClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	g_type_class_add_private (klass, sizeof (IndicatorServicePrivate));
+
+	object_class->dispose = indicator_service_dispose;
+	object_class->finalize = indicator_service_finalize;
+
+	/* Property funcs */
+	object_class->set_property = set_property;
+	object_class->get_property = get_property;
+
+	/* Properties */
+	g_object_class_install_property(object_class, PROP_NAME,
+	                                g_param_spec_string(PROP_NAME_S,
+	                                                    "The DBus name for this service",
+	                                                    "This is the name that should be used on DBus for this service.",
+	                                                    NULL,
+	                                                    G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+	g_object_class_install_property(object_class, PROP_VERSION,
+	                                g_param_spec_uint(PROP_VERSION_S,
+	                                                  "The version of the service that we're implementing.",
+	                                                  "A number to represent the version of the other APIs the service provides.  This should match across the manager and the service",
+	                                                  0, G_MAXUINT, 0,
+	                                                  G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS));
+
+	/* Signals */
+
+	/**
+		IndicatorService::shutdown:
+		@arg0: The #IndicatorService object
+		
+		Signaled when the service should shutdown as no one
+		is listening anymore.
+	*/
+	signals[SHUTDOWN] = g_signal_new (INDICATOR_SERVICE_SIGNAL_SHUTDOWN,
+	                                  G_TYPE_FROM_CLASS(klass),
+	                                  G_SIGNAL_RUN_LAST,
+	                                  G_STRUCT_OFFSET (IndicatorServiceClass, shutdown),
+	                                  NULL, NULL,
+	                                  g_cclosure_marshal_VOID__VOID,
+	                                  G_TYPE_NONE, 0, G_TYPE_NONE);
+
+	/* Initialize the object as a DBus type */
+	dbus_g_object_type_install_info(INDICATOR_SERVICE_TYPE,
+	                                &dbus_glib__indicator_service_server_object_info);
+
+	return;
+}
+
+/* This function builds the variables, sets up the dbus
+   proxy and registers the object on dbus.  Importantly,
+   it does not request a name as we don't know what name
+   we have yet. */
+static void
+indicator_service_init (IndicatorService *self)
+{
+	IndicatorServicePrivate * priv = INDICATOR_SERVICE_GET_PRIVATE(self);
+
+	/* Get the private variables in a decent state */
+	priv->name = NULL;
+	priv->dbus_proxy = NULL;
+	priv->timeout = 0;
+	priv->watchers = NULL;
+	priv->this_service_version = 0;
+
+	/* Start talkin' dbus */
+	GError * error = NULL;
+	DBusGConnection * bus = dbus_g_bus_get(DBUS_BUS_STARTER, &error);
+	if (error != NULL) {
+		g_error("Unable to get starter bus: %s", error->message);
+		g_error_free(error);
+
+		/* Okay, fine let's try the session bus then. */
+		/* I think this should automatically, but I can't find confirmation
+		   of that, so we're putting the extra little code in here. */
+		error = NULL;
+		bus = dbus_g_bus_get(DBUS_BUS_SESSION, &error);
+		if (error != NULL) {
+			g_error("Unable to get session bus: %s", error->message);
+			g_error_free(error);
+			return;
+		}
+	}
+
+	priv->dbus_proxy = dbus_g_proxy_new_for_name_owner(bus,
+	                                                   DBUS_SERVICE_DBUS,
+	                                                   DBUS_PATH_DBUS,
+	                                                   DBUS_INTERFACE_DBUS,
+	                                                   &error);
+	if (error != NULL) {
+		g_error("Unable to get the proxy to DBus: %s", error->message);
+		g_error_free(error);
+		return;
+	}
+
+	dbus_g_connection_register_g_object(bus,
+	                                    INDICATOR_SERVICE_OBJECT,
+	                                    G_OBJECT(self));
+
+	return;
+}
+
+/* Unrefcounting the proxies and making sure that our
+   timeout doesn't come to haunt us. */
+static void
+indicator_service_dispose (GObject *object)
+{
+	IndicatorServicePrivate * priv = INDICATOR_SERVICE_GET_PRIVATE(object);
+
+	if (priv->dbus_proxy != NULL) {
+		g_object_unref(G_OBJECT(priv->dbus_proxy));
+		priv->dbus_proxy = NULL;
+	}
+
+	if (priv->timeout != 0) {
+		g_source_remove(priv->timeout);
+		priv->timeout = 0;
+	}
+
+	G_OBJECT_CLASS (indicator_service_parent_class)->dispose (object);
+	return;
+}
+
+/* Freeing the name we're looking for and all of the
+   information on the watchers we're tracking. */
+static void
+indicator_service_finalize (GObject *object)
+{
+	IndicatorServicePrivate * priv = INDICATOR_SERVICE_GET_PRIVATE(object);
+
+	if (priv->name != NULL) {
+		g_free(priv->name);
+	}
+
+	if (priv->watchers != NULL) {
+		g_list_foreach(priv->watchers, (GFunc)g_free, NULL);
+		g_list_free(priv->watchers);
+		priv->watchers = NULL;
+	}
+
+	G_OBJECT_CLASS (indicator_service_parent_class)->finalize (object);
+	return;
+}
+
+/* Either copies a string for the name or it just grabs
+   the value of the version. */
+static void
+set_property (GObject * object, guint prop_id, const GValue * value, GParamSpec * pspec)
+{
+	IndicatorService * self = INDICATOR_SERVICE(object);
+	g_return_if_fail(self != NULL);
+
+	IndicatorServicePrivate * priv = INDICATOR_SERVICE_GET_PRIVATE(self);
+	g_return_if_fail(priv != NULL);
+
+	switch (prop_id) {
+	/* *********************** */
+	case PROP_NAME:
+		if (G_VALUE_HOLDS_STRING(value)) {
+			if (priv->name != NULL) {
+				g_error("Name can not be set twice!");
+				return;
+			}
+			priv->name = g_value_dup_string(value);
+			try_and_get_name(self);
+		} else {
+			g_warning("Name property requires a string value.");
+		}
+		break;
+	/* *********************** */
+	case PROP_VERSION:
+		priv->this_service_version = g_value_get_uint(value);
+		break;
+	/* *********************** */
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		break;
+	}
+
+	return;
+}
+
+/* Copies out the name into a value or the version number.
+   Probably this is the least useful code in this file. */
+static void
+get_property (GObject * object, guint prop_id, GValue * value, GParamSpec * pspec)
+{
+	IndicatorService * self = INDICATOR_SERVICE(object);
+	g_return_if_fail(self != NULL);
+
+	IndicatorServicePrivate * priv = INDICATOR_SERVICE_GET_PRIVATE(self);
+	g_return_if_fail(priv != NULL);
+
+	switch (prop_id) {
+	/* *********************** */
+	case PROP_NAME:
+		if (G_VALUE_HOLDS_STRING(value)) {
+			g_value_set_string(value, priv->name);
+		} else {
+			g_warning("Name property requires a string value.");
+		}
+		break;
+	/* *********************** */
+	case PROP_VERSION:
+		g_value_set_uint(value, priv->this_service_version);
+		break;
+	/* *********************** */
+	default:
+		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+		break;
+	}
+
+	return;
+}
+
+/* This is the function that gets executed if we timeout
+   because there are no watchers.  We sent the shutdown
+   signal and hope someone does something sane with it. */
+static gboolean
+timeout_no_watchers (gpointer data)
+{
+	g_signal_emit(G_OBJECT(data), signals[SHUTDOWN], 0, TRUE);
+	return FALSE;
+}
+
+/* The callback from our request to get a well known name
+   on dbus.  If we can't get it we send the shutdown signal.
+   Else we start the timer to see if anyone cares about us. */
+static void
+try_and_get_name_cb (DBusGProxy * proxy, guint status, GError * error, gpointer data)
+{
+	IndicatorService * service = INDICATOR_SERVICE(data);
+	g_return_if_fail(service != NULL);
+
+	if (status != DBUS_REQUEST_NAME_REPLY_PRIMARY_OWNER && status != DBUS_REQUEST_NAME_REPLY_ALREADY_OWNER) {
+		/* The already owner seems like it shouldn't ever
+		   happen, but I have a hard time throwing an error
+		   on it as we did achieve our goals. */
+		g_signal_emit(G_OBJECT(data), signals[SHUTDOWN], 0, TRUE);
+		return;
+	}
+
+	IndicatorServicePrivate * priv = INDICATOR_SERVICE_GET_PRIVATE(service);
+	priv->timeout = g_timeout_add(500, timeout_no_watchers, service);
+
+	return;
+}
+
+/* This function sets up the request for the name on dbus. */
+static void
+try_and_get_name (IndicatorService * service)
+{
+	IndicatorServicePrivate * priv = INDICATOR_SERVICE_GET_PRIVATE(service);
+	g_return_if_fail(priv->dbus_proxy != NULL);
+	g_return_if_fail(priv->name != NULL);
+
+	org_freedesktop_DBus_request_name_async(priv->dbus_proxy,
+	                                        priv->name,
+	                                        DBUS_NAME_FLAG_DO_NOT_QUEUE,
+	                                        try_and_get_name_cb,
+	                                        service);
+
+	return;
+}
+
+/* Here is the function that gets called by the dbus
+   interface "Watch" function.  It is an async function so
+   that we can get the sender and store that information.  We
+   put them in a list and reset the timeout. */
+static gboolean
+_indicator_service_server_watch (IndicatorService * service, DBusGMethodInvocation * method)
+{
+	g_return_val_if_fail(INDICATOR_IS_SERVICE(service), FALSE);
+	IndicatorServicePrivate * priv = INDICATOR_SERVICE_GET_PRIVATE(service);
+
+	priv->watchers = g_list_append(priv->watchers,
+	                               g_strdup(dbus_g_method_get_sender(method)));
+
+	if (priv->timeout != 0) {
+		g_source_remove(priv->timeout);
+		priv->timeout = 0;
+	}
+
+	dbus_g_method_return(method, INDICATOR_SERVICE_VERSION, priv->this_service_version);
+	return TRUE;
+}
+
+/* Mung g_strcmp0 into GCompareFunc */
+static gint
+find_watcher (gconstpointer a, gconstpointer b)
+{
+	return g_strcmp0((const gchar *)a, (const gchar *)b);
+}
+
+/* A function connecting into the dbus interface for the
+   "UnWatch" function.  It is also an async function to get
+   the sender.  It then looks the sender up and removes them
+   from the list of watchers.  If there are none left, it then
+   starts the timer for the shutdown signal. */
+static gboolean
+_indicator_service_server_un_watch (IndicatorService * service, DBusGMethodInvocation * method)
+{
+	g_return_val_if_fail(INDICATOR_IS_SERVICE(service), FALSE);
+	IndicatorServicePrivate * priv = INDICATOR_SERVICE_GET_PRIVATE(service);
+
+	/* Remove us from the watcher list here */
+	GList * watcher_item = g_list_find_custom(priv->watchers, dbus_g_method_get_sender(method), find_watcher);
+	if (watcher_item != NULL) {
+		/* Free the watcher */
+		gchar * name = watcher_item->data;
+		priv->watchers = g_list_remove(priv->watchers, name);
+		g_free(name);
+	} else {
+		/* Odd that we couldn't find the person, but, eh */
+		g_warning("Unable to find watcher who is unwatching: %s", dbus_g_method_get_sender(method));
+	}
+
+	/* If we're out of watchers set the timeout for shutdown */
+	if (priv->watchers == NULL) {
+		if (priv->timeout != 0) {
+			/* This should never really happen, but let's ensure that
+			   bad things don't happen if it does. */
+			g_warning("No watchers timeout set twice.  Resolving, but odd.");
+			g_source_remove(priv->timeout);
+			priv->timeout = 0;
+		}
+		/* If we don't get a new watcher quickly, we'll shutdown. */
+		priv->timeout = g_timeout_add(500, timeout_no_watchers, service);
+	}
+
+	dbus_g_method_return(method);
+	return TRUE;
+}
+
+/* API */
+
+/**
+	indicator_service_new:
+	@name: The name for the service on dbus
+
+	This function creates the service on DBus and tries to
+	get a well-known name specified in @name.  If the name
+	can't be estabilished then the #IndicatorService::shutdown
+	signal will be sent.
+
+	Return value: A brand new #IndicatorService object or #NULL
+		if there is an error.
+*/
+IndicatorService *
+indicator_service_new (gchar * name)
+{
+	GObject * obj = g_object_new(INDICATOR_SERVICE_TYPE,
+	                             PROP_NAME_S, name,
+	                             NULL);
+
+	return INDICATOR_SERVICE(obj);
+}
+
+/**
+	indicator_service_new_version:
+	@name: The name for the service on dbus
+	@version: The version of the other interfaces provide
+		by the service.
+
+	This function creates the service on DBus and tries to
+	get a well-known name specified in @name.  If the name
+	can't be estabilished then the #IndicatorService::shutdown
+	signal will be sent.
+
+	Return value: A brand new #IndicatorService object or #NULL
+		if there is an error.
+*/
+IndicatorService *
+indicator_service_new_version (gchar * name, guint version)
+{
+	GObject * obj = g_object_new(INDICATOR_SERVICE_TYPE,
+	                             PROP_NAME_S, name,
+	                             PROP_VERSION_S, version,
+	                             NULL);
+
+	return INDICATOR_SERVICE(obj);
+}

=== added file 'libindicator/indicator-service.h'
--- libindicator/indicator-service.h	1970-01-01 00:00:00 +0000
+++ libindicator/indicator-service.h	2009-12-10 17:02:12 +0000
@@ -0,0 +1,85 @@
+/*
+An object used to provide a simple interface for a service
+to query version and manage whether it's running.
+
+Copyright 2009 Canonical Ltd.
+
+Authors:
+    Ted Gould <[e-mail]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+version 3.0 as published by the Free Software Foundation.
+
+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 General Public License version 3.0 for more details.
+
+You should have received a copy of the GNU General Public
+License along with this library. If not, see
+<http://www.gnu.org/licenses/>.
+*/
+
+#ifndef __INDICATOR_SERVICE_H__
+#define __INDICATOR_SERVICE_H__
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define INDICATOR_SERVICE_TYPE            (indicator_service_get_type ())
+#define INDICATOR_SERVICE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), INDICATOR_SERVICE_TYPE, IndicatorService))
+#define INDICATOR_SERVICE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), INDICATOR_SERVICE_TYPE, IndicatorServiceClass))
+#define INDICATOR_IS_SERVICE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), INDICATOR_SERVICE_TYPE))
+#define INDICATOR_IS_SERVICE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), INDICATOR_SERVICE_TYPE))
+#define INDICATOR_SERVICE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), INDICATOR_SERVICE_TYPE, IndicatorServiceClass))
+
+#define INDICATOR_SERVICE_SIGNAL_SHUTDOWN  "shutdown"
+
+typedef struct _IndicatorService      IndicatorService;
+typedef struct _IndicatorServiceClass IndicatorServiceClass;
+
+/**
+	IndicatorServiceClass:
+	@parent_class: #GObjectClass
+	@shutdown: Slot for IndicatorServiceClass::shutdown
+	@indicator_service_reserved1: Reserved for future use
+	@indicator_service_reserved2: Reserved for future use
+	@indicator_service_reserved3: Reserved for future use
+	@indicator_service_reserved4: Reserved for future use
+
+*/
+struct _IndicatorServiceClass {
+	GObjectClass parent_class;
+	
+	/* Signals */
+	void (*shutdown) (IndicatorService * service, gpointer user_data);
+
+	/* Reserved */
+	void (*indicator_service_reserved1) (void);
+	void (*indicator_service_reserved2) (void);
+	void (*indicator_service_reserved3) (void);
+	void (*indicator_service_reserved4) (void);
+};
+
+/**
+	IndicatorService:
+	@parent: #GObject
+
+*/
+struct _IndicatorService {
+	GObject parent;
+
+};
+
+GType indicator_service_get_type (void);
+
+IndicatorService *   indicator_service_new            (gchar * name);
+IndicatorService *   indicator_service_new_version    (gchar * name,
+                                                       guint version);
+
+G_END_DECLS
+
+#endif

=== added file 'libindicator/indicator-service.xml'
--- libindicator/indicator-service.xml	1970-01-01 00:00:00 +0000
+++ libindicator/indicator-service.xml	2009-12-10 17:02:12 +0000
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<node name="/">
+	<interface name="org.ayatana.indicator.service">
+<!-- Properties -->
+		<!-- None currently -->
+
+<!-- Methods -->
+		<method name="Watch">
+			<annotation name="org.freedesktop.DBus.GLib.Async" value="true" />
+			<arg type="u" name="version" direction="out" />
+			<arg type="u" name="service_version" direction="out" />
+		</method>
+		<method name="UnWatch">
+			<annotation name="org.freedesktop.DBus.GLib.Async" value="true" />
+		</method>
+
+<!-- Signals -->
+		<!-- None currently -->
+
+	</interface>
+</node>

=== modified file 'libindicator/indicator.h'
--- libindicator/indicator.h	2009-10-06 15:00:34 +0000
+++ libindicator/indicator.h	2009-12-10 17:02:12 +0000
@@ -25,31 +25,17 @@
 
 #include <gtk/gtk.h>
 
-#define INDICATOR_GET_LABEL_S  "get_label"
-typedef GtkLabel * (*get_label_t)(void);
-GtkLabel * get_label (void);
-
-#define INDICATOR_GET_ICON_S   "get_icon"
-typedef GtkImage * (*get_icon_t)  (void);
-GtkImage * get_icon (void);
-
-#define INDICATOR_GET_MENU_S   "get_menu"
-typedef GtkMenu * (*get_menu_t) (void);
-GtkMenu * get_menu (void);
-
 #define INDICATOR_GET_VERSION_S "get_version"
 typedef gchar * (*get_version_t) (void);
 gchar * get_version (void);
 
-#define INDICATOR_VERSION "0.2.0"
+#define INDICATOR_VERSION "0.3.0"
 #define INDICATOR_SET_VERSION  gchar * get_version(void) { return INDICATOR_VERSION; }
 #define INDICATOR_VERSION_CHECK(x)  (!g_strcmp0(x, INDICATOR_VERSION))
 
-#define INDICATOR_GET_NAME_S "get_name"
-typedef gchar * (*get_name_t) (void);
-gchar * get_name (void);
-#define INDICATOR_SET_NAME(x)  gchar * get_name(void) {return (x); }
-
+#define INDICATOR_GET_TYPE_S "get_type"
+typedef GType (*get_type_t) (void);
+#define INDICATOR_SET_TYPE(x)  GType get_type (void) { return x; }
 
 #endif /* __LIBINDICATOR_INDICATOR_H_SEEN__ */
 

=== modified file 'libindicator/indicator.pc.in'
--- libindicator/indicator.pc.in	2009-08-08 15:55:54 +0000
+++ libindicator/indicator.pc.in	2009-12-10 17:02:12 +0000
@@ -4,12 +4,12 @@
 bindir=@bindir@
 includedir=@includedir@
 
-indicatordir=${libdir}/indicators/2/
+indicatordir=${libdir}/indicators/3/
 iconsdir=@datarootdir@/@PACKAGE@/icons/
 
-Cflags: -I${includedir}/libindicator-0.1
+Cflags: -I${includedir}/libindicator-0.3
 Requires: gtk+-2.0
-Libs: 
+Libs: -lindicator
 
 Name: libindicator
 Description: libindicator.

=== added directory 'tests'
=== added file 'tests/Makefile.am'
--- tests/Makefile.am	1970-01-01 00:00:00 +0000
+++ tests/Makefile.am	2009-12-10 17:02:12 +0000
@@ -0,0 +1,308 @@
+TESTS =
+DISTCLEANFILES =
+
+check_PROGRAMS = 
+
+lib_LTLIBRARIES = \
+	libdummy-indicator-blank.la \
+	libdummy-indicator-null.la \
+	libdummy-indicator-signaler.la \
+	libdummy-indicator-simple.la
+
+DBUS_RUNNER=dbus-test-runner --dbus-config /usr/share/dbus-test-runner/session.conf
+
+#############################
+# Test Loader
+#############################
+
+check_PROGRAMS += test-loader
+
+test_loader_SOURCES = \
+	test-loader.c
+
+test_loader_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir) \
+	-DBUILD_DIR="\"$(builddir)\""
+
+test_loader_LDADD = \
+	$(LIBINDICATOR_LIBS) \
+	-L$(top_builddir)/libindicator/.libs \
+	-lindicator
+
+#############################
+# Dummy Indicator Blank
+#############################
+
+libdummy_indicator_blank_la_SOURCES = \
+	dummy-indicator-blank.c
+
+libdummy_indicator_blank_la_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir)
+
+libdummy_indicator_blank_la_LIBADD = \
+	$(LIBINDICATOR_LIBS) \
+	-L$(top_builddir)/libindicator/.libs \
+	-lindicator
+
+libdummy_indicator_blank_la_LDFLAGS = \
+	-module \
+	-avoid-version
+
+#############################
+# Dummy Indicator NULL
+#############################
+
+libdummy_indicator_null_la_SOURCES = \
+	dummy-indicator-null.c
+
+libdummy_indicator_null_la_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir)
+
+libdummy_indicator_null_la_LIBADD = \
+	$(LIBINDICATOR_LIBS) \
+	-L$(top_builddir)/libindicator/.libs \
+	-lindicator
+
+libdummy_indicator_null_la_LDFLAGS = \
+	-module \
+	-avoid-version
+
+#############################
+# Dummy Indicator Signaler
+#############################
+
+libdummy_indicator_signaler_la_SOURCES = \
+	dummy-indicator-signaler.c
+
+libdummy_indicator_signaler_la_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir)
+
+libdummy_indicator_signaler_la_LIBADD = \
+	$(LIBINDICATOR_LIBS) \
+	-L$(top_builddir)/libindicator/.libs \
+	-lindicator
+
+libdummy_indicator_signaler_la_LDFLAGS = \
+	-module \
+	-avoid-version
+
+#############################
+# Dummy Indicator Simple
+#############################
+
+libdummy_indicator_simple_la_SOURCES = \
+	dummy-indicator-simple.c
+
+libdummy_indicator_simple_la_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir)
+
+libdummy_indicator_simple_la_LIBADD = \
+	$(LIBINDICATOR_LIBS) \
+	-L$(top_builddir)/libindicator/.libs \
+	-lindicator
+
+libdummy_indicator_simple_la_LDFLAGS = \
+	-module \
+	-avoid-version
+
+#############################
+# Service Shutdown Timeout
+#############################
+
+check_PROGRAMS += service-shutdown-timeout
+
+service_shutdown_timeout_SOURCES = \
+	service-shutdown-timeout.c
+
+service_shutdown_timeout_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir)
+
+service_shutdown_timeout_LDADD = \
+	$(LIBINDICATOR_LIBS) \
+	$(top_builddir)/libindicator/.libs/libindicator.a
+
+service-shutdown-timeout-tester: service-shutdown-timeout Makefile
+	@echo "#!/bin/sh" > service-shutdown-timeout-tester
+	@echo $(DBUS_RUNNER) --task ./service-shutdown-timeout >> service-shutdown-timeout-tester
+	@chmod +x service-shutdown-timeout-tester
+
+TESTS += service-shutdown-timeout-tester
+DISTCLEANFILES += service-shutdown-timeout-tester
+
+#############################
+# Service Manager No Connect
+#############################
+
+check_PROGRAMS += service-manager-no-connect
+
+service_manager_no_connect_SOURCES = \
+	service-manager-no-connect.c
+
+service_manager_no_connect_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir)
+
+service_manager_no_connect_LDADD = \
+	$(LIBINDICATOR_LIBS) \
+	$(top_builddir)/libindicator/.libs/libindicator.a
+
+service-manager-no-connect-tester: service-manager-no-connect Makefile.am
+	@echo "#!/bin/sh" > service-manager-no-connect-tester
+	@echo $(DBUS_RUNNER) --task ./service-manager-no-connect >> service-manager-no-connect-tester
+	@chmod +x service-manager-no-connect-tester
+
+TESTS += service-manager-no-connect-tester
+DISTCLEANFILES += service-manager-no-connect-tester
+
+#############################
+# Service Manager Connect
+#############################
+
+session.conf: $(srcdir)/session.conf.in Makefile.am
+	sed -e "s|\@servicedir\@|$(abspath $(builddir))|" $< > $@
+
+service-manager-connect.service: $(srcdir)/service-manager-connect.service.in Makefile.am
+	sed -e "s|\@builddir\@|$(abspath $(builddir))|" $< > $@
+
+check_PROGRAMS += service-manager-connect
+
+service_manager_connect_SOURCES = \
+	service-manager-connect.c
+
+service_manager_connect_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir)
+
+service_manager_connect_LDADD = \
+	$(LIBINDICATOR_LIBS) \
+	$(top_builddir)/libindicator/.libs/libindicator.a
+
+check_PROGRAMS += service-manager-connect-service
+
+service_manager_connect_service_SOURCES = \
+	service-manager-connect-service.c
+
+service_manager_connect_service_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir)
+
+service_manager_connect_service_LDADD = \
+	$(LIBINDICATOR_LIBS) \
+	$(top_builddir)/libindicator/.libs/libindicator.a
+
+service-manager-connect-tester: service-manager-connect service-manager-connect-service session.conf service-manager-connect.service Makefile.am
+	@echo "#!/bin/sh" > service-manager-connect-tester
+	@echo dbus-test-runner --dbus-config $(builddir)/session.conf --task ./service-manager-connect >> service-manager-connect-tester
+	@chmod +x service-manager-connect-tester
+
+TESTS += service-manager-connect-tester
+DISTCLEANFILES += service-manager-connect-tester session.conf service-manager-connect.service
+
+#############################
+# Service Versions
+#############################
+
+service-version-good.service: $(srcdir)/service-version-good.service.in Makefile.am
+	sed -e "s|\@builddir\@|$(abspath $(builddir))|" $< > $@
+
+service-version-bad.service: $(srcdir)/service-version-bad.service.in Makefile.am
+	sed -e "s|\@builddir\@|$(abspath $(builddir))|" $< > $@
+
+check_PROGRAMS += service-version-manager
+
+service_version_manager_SOURCES = \
+	service-version-values.h \
+	service-version-manager.c
+
+service_version_manager_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir)
+
+service_version_manager_LDADD = \
+	$(LIBINDICATOR_LIBS) \
+	$(top_builddir)/libindicator/.libs/libindicator.a
+
+check_PROGRAMS += service-version-bad-service
+
+service_version_bad_service_SOURCES = \
+	service-version-values.h \
+	service-version-bad-service.c
+
+service_version_bad_service_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir)
+
+service_version_bad_service_LDADD = \
+	$(LIBINDICATOR_LIBS) \
+	$(top_builddir)/libindicator/.libs/libindicator.a
+
+check_PROGRAMS += service-version-good-service
+
+service_version_good_service_SOURCES = \
+	service-version-values.h \
+	service-version-good-service.c
+
+service_version_good_service_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir)
+
+service_version_good_service_LDADD = \
+	$(LIBINDICATOR_LIBS) \
+	$(top_builddir)/libindicator/.libs/libindicator.a
+
+service-version-tester: service-version-manager service-version-bad-service service-version-good-service session.conf service-version-bad.service service-version-good.service Makefile.am
+	@echo "#!/bin/sh" > $@
+	@echo dbus-test-runner --dbus-config $(builddir)/session.conf --task ./service-version-manager >> $@
+	@chmod +x $@
+
+TESTS += service-version-tester
+DISTCLEANFILES += service-version-tester service-version-bad.service service-version-good.service
+
+#############################
+# Service Manager Shutdown
+#############################
+
+check_PROGRAMS += service-manager-nostart-connect
+
+service_manager_nostart_connect_SOURCES = \
+	service-manager-nostart-connect.c
+
+service_manager_nostart_connect_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir)
+
+service_manager_nostart_connect_LDADD = \
+	$(LIBINDICATOR_LIBS) \
+	$(top_builddir)/libindicator/.libs/libindicator.a
+
+service-manager-connect-nostart-tester: service-manager-nostart-connect service-manager-connect-service Makefile.am
+	@echo "#!/bin/sh" > $@
+	@echo dbus-test-runner --task ./service-manager-nostart-connect --task ./service-manager-connect-service >> $@
+	@chmod +x $@
+
+TESTS += service-manager-connect-nostart-tester
+DISTCLEANFILES += service-manager-connect-nostart-tester
+
+#############################
+# Test stuff
+#############################
+
+XML_REPORT  = loader-check-results.xml
+HTML_REPORT = loader-check-results.html
+
+loader-tester: test-loader libdummy-indicator-null.la libdummy-indicator-simple.la Makefile
+	@echo "#!/bin/sh" > loader-tester
+	@echo gtester -k --verbose -o=$(XML_REPORT) ./test-loader >> loader-tester
+	@chmod +x loader-tester
+
+TESTS += loader-tester
+DISTCLEANFILES += loader-tester
+
+DISTCLEANFILES += $(XML_REPORT) $(HTML_REPORT)
+

=== added file 'tests/dummy-indicator-blank.c'
--- tests/dummy-indicator-blank.c	1970-01-01 00:00:00 +0000
+++ tests/dummy-indicator-blank.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,5 @@
+
+#include "libindicator/indicator.h"
+
+INDICATOR_SET_VERSION
+

=== added file 'tests/dummy-indicator-null.c'
--- tests/dummy-indicator-null.c	1970-01-01 00:00:00 +0000
+++ tests/dummy-indicator-null.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,95 @@
+
+#include <glib.h>
+#include <glib-object.h>
+
+#include "libindicator/indicator.h"
+#include "libindicator/indicator-object.h"
+
+#define DUMMY_INDICATOR_NULL_TYPE            (dummy_indicator_null_get_type ())
+#define DUMMY_INDICATOR_NULL(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), DUMMY_INDICATOR_NULL_TYPE, DummyIndicatorNull))
+#define DUMMY_INDICATOR_NULL_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), DUMMY_INDICATOR_NULL_TYPE, DummyIndicatorNullClass))
+#define IS_DUMMY_INDICATOR_NULL(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DUMMY_INDICATOR_NULL_TYPE))
+#define IS_DUMMY_INDICATOR_NULL_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DUMMY_INDICATOR_NULL_TYPE))
+#define DUMMY_INDICATOR_NULL_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), DUMMY_INDICATOR_NULL_TYPE, DummyIndicatorNullClass))
+
+typedef struct _DummyIndicatorNull      DummyIndicatorNull;
+typedef struct _DummyIndicatorNullClass DummyIndicatorNullClass;
+
+struct _DummyIndicatorNullClass {
+	IndicatorObjectClass parent_class;
+};
+
+struct _DummyIndicatorNull {
+	IndicatorObject parent;
+};
+
+GType dummy_indicator_null_get_type (void);
+
+INDICATOR_SET_VERSION
+INDICATOR_SET_TYPE(DUMMY_INDICATOR_NULL_TYPE)
+
+
+GtkLabel *
+get_label (IndicatorObject * io)
+{
+	return NULL;
+}
+
+GtkImage *
+get_icon (IndicatorObject * io)
+{
+	return NULL;
+}
+
+GtkMenu *
+get_menu (IndicatorObject * io)
+{
+	return NULL;
+}
+
+static void dummy_indicator_null_class_init (DummyIndicatorNullClass *klass);
+static void dummy_indicator_null_init       (DummyIndicatorNull *self);
+static void dummy_indicator_null_dispose    (GObject *object);
+static void dummy_indicator_null_finalize   (GObject *object);
+
+G_DEFINE_TYPE (DummyIndicatorNull, dummy_indicator_null, INDICATOR_OBJECT_TYPE);
+
+static void
+dummy_indicator_null_class_init (DummyIndicatorNullClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	object_class->dispose = dummy_indicator_null_dispose;
+	object_class->finalize = dummy_indicator_null_finalize;
+
+	IndicatorObjectClass * io_class = INDICATOR_OBJECT_CLASS(klass);
+
+	io_class->get_label = get_label;
+	io_class->get_image = get_icon;
+	io_class->get_menu = get_menu;
+
+	return;
+}
+
+static void
+dummy_indicator_null_init (DummyIndicatorNull *self)
+{
+
+	return;
+}
+
+static void
+dummy_indicator_null_dispose (GObject *object)
+{
+
+	G_OBJECT_CLASS (dummy_indicator_null_parent_class)->dispose (object);
+	return;
+}
+
+static void
+dummy_indicator_null_finalize (GObject *object)
+{
+
+	G_OBJECT_CLASS (dummy_indicator_null_parent_class)->finalize (object);
+	return;
+}

=== added file 'tests/dummy-indicator-signaler.c'
--- tests/dummy-indicator-signaler.c	1970-01-01 00:00:00 +0000
+++ tests/dummy-indicator-signaler.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,109 @@
+#include <glib.h>
+#include <glib-object.h>
+
+#include "libindicator/indicator.h"
+#include "libindicator/indicator-object.h"
+
+#define DUMMY_INDICATOR_SIGNALER_TYPE            (dummy_indicator_signaler_get_type ())
+#define DUMMY_INDICATOR_SIGNALER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), DUMMY_INDICATOR_SIGNALER_TYPE, DummyIndicatorSignaler))
+#define DUMMY_INDICATOR_SIGNALER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), DUMMY_INDICATOR_SIGNALER_TYPE, DummyIndicatorSignalerClass))
+#define IS_DUMMY_INDICATOR_SIGNALER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DUMMY_INDICATOR_SIGNALER_TYPE))
+#define IS_DUMMY_INDICATOR_SIGNALER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DUMMY_INDICATOR_SIGNALER_TYPE))
+#define DUMMY_INDICATOR_SIGNALER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), DUMMY_INDICATOR_SIGNALER_TYPE, DummyIndicatorSignalerClass))
+
+typedef struct _DummyIndicatorSignaler      DummyIndicatorSignaler;
+typedef struct _DummyIndicatorSignalerClass DummyIndicatorSignalerClass;
+
+struct _DummyIndicatorSignalerClass {
+	IndicatorObjectClass parent_class;
+};
+
+struct _DummyIndicatorSignaler {
+	IndicatorObject parent;
+};
+
+GType dummy_indicator_signaler_get_type (void);
+
+INDICATOR_SET_VERSION
+INDICATOR_SET_TYPE(DUMMY_INDICATOR_SIGNALER_TYPE)
+
+GtkLabel *
+get_label (IndicatorObject * io)
+{
+	return GTK_LABEL(gtk_label_new("Signaler Item"));
+}
+
+GtkImage *
+get_icon (IndicatorObject * io)
+{
+	return GTK_IMAGE(gtk_image_new());
+}
+
+GtkMenu *
+get_menu (IndicatorObject * io)
+{
+	GtkMenu * main_menu = GTK_MENU(gtk_menu_new());
+	GtkWidget * loading_item = gtk_menu_item_new_with_label("Loading...");
+	gtk_menu_shell_append(GTK_MENU_SHELL(main_menu), loading_item);
+	gtk_widget_show(GTK_WIDGET(loading_item));
+
+	return main_menu;
+}
+
+static void dummy_indicator_signaler_class_init (DummyIndicatorSignalerClass *klass);
+static void dummy_indicator_signaler_init       (DummyIndicatorSignaler *self);
+static void dummy_indicator_signaler_dispose    (GObject *object);
+static void dummy_indicator_signaler_finalize   (GObject *object);
+
+G_DEFINE_TYPE (DummyIndicatorSignaler, dummy_indicator_signaler, INDICATOR_OBJECT_TYPE);
+
+static void
+dummy_indicator_signaler_class_init (DummyIndicatorSignalerClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	object_class->dispose = dummy_indicator_signaler_dispose;
+	object_class->finalize = dummy_indicator_signaler_finalize;
+
+	IndicatorObjectClass * io_class = INDICATOR_OBJECT_CLASS(klass);
+
+	io_class->get_label = get_label;
+	io_class->get_image = get_icon;
+	io_class->get_menu = get_menu;
+
+	return;
+}
+
+static gboolean
+idle_signal (gpointer data)
+{
+	DummyIndicatorSignaler * self = DUMMY_INDICATOR_SIGNALER(data);
+
+	g_signal_emit(G_OBJECT(self), INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED_ID, 0,   GUINT_TO_POINTER(5), TRUE);
+	g_signal_emit(G_OBJECT(self), INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED_ID, 0, GUINT_TO_POINTER(5), TRUE);
+
+	return FALSE; /* Don't queue again */
+}
+
+static void
+dummy_indicator_signaler_init (DummyIndicatorSignaler *self)
+{
+	g_idle_add(idle_signal, self);
+	return;
+}
+
+static void
+dummy_indicator_signaler_dispose (GObject *object)
+{
+
+	G_OBJECT_CLASS (dummy_indicator_signaler_parent_class)->dispose (object);
+	return;
+}
+
+static void
+dummy_indicator_signaler_finalize (GObject *object)
+{
+
+	G_OBJECT_CLASS (dummy_indicator_signaler_parent_class)->finalize (object);
+	return;
+}

=== added file 'tests/dummy-indicator-simple.c'
--- tests/dummy-indicator-simple.c	1970-01-01 00:00:00 +0000
+++ tests/dummy-indicator-simple.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,98 @@
+#include <glib.h>
+#include <glib-object.h>
+
+#include "libindicator/indicator.h"
+#include "libindicator/indicator-object.h"
+
+#define DUMMY_INDICATOR_SIMPLE_TYPE            (dummy_indicator_simple_get_type ())
+#define DUMMY_INDICATOR_SIMPLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), DUMMY_INDICATOR_SIMPLE_TYPE, DummyIndicatorSimple))
+#define DUMMY_INDICATOR_SIMPLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), DUMMY_INDICATOR_SIMPLE_TYPE, DummyIndicatorSimpleClass))
+#define IS_DUMMY_INDICATOR_SIMPLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DUMMY_INDICATOR_SIMPLE_TYPE))
+#define IS_DUMMY_INDICATOR_SIMPLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DUMMY_INDICATOR_SIMPLE_TYPE))
+#define DUMMY_INDICATOR_SIMPLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), DUMMY_INDICATOR_SIMPLE_TYPE, DummyIndicatorSimpleClass))
+
+typedef struct _DummyIndicatorSimple      DummyIndicatorSimple;
+typedef struct _DummyIndicatorSimpleClass DummyIndicatorSimpleClass;
+
+struct _DummyIndicatorSimpleClass {
+	IndicatorObjectClass parent_class;
+};
+
+struct _DummyIndicatorSimple {
+	IndicatorObject parent;
+};
+
+GType dummy_indicator_simple_get_type (void);
+
+INDICATOR_SET_VERSION
+INDICATOR_SET_TYPE(DUMMY_INDICATOR_SIMPLE_TYPE)
+
+GtkLabel *
+get_label (IndicatorObject * io)
+{
+	return GTK_LABEL(gtk_label_new("Simple Item"));
+}
+
+GtkImage *
+get_icon (IndicatorObject * io)
+{
+	return GTK_IMAGE(gtk_image_new());
+}
+
+GtkMenu *
+get_menu (IndicatorObject * io)
+{
+	GtkMenu * main_menu = GTK_MENU(gtk_menu_new());
+	GtkWidget * loading_item = gtk_menu_item_new_with_label("Loading...");
+	gtk_menu_shell_append(GTK_MENU_SHELL(main_menu), loading_item);
+	gtk_widget_show(GTK_WIDGET(loading_item));
+
+	return main_menu;
+}
+
+static void dummy_indicator_simple_class_init (DummyIndicatorSimpleClass *klass);
+static void dummy_indicator_simple_init       (DummyIndicatorSimple *self);
+static void dummy_indicator_simple_dispose    (GObject *object);
+static void dummy_indicator_simple_finalize   (GObject *object);
+
+G_DEFINE_TYPE (DummyIndicatorSimple, dummy_indicator_simple, INDICATOR_OBJECT_TYPE);
+
+static void
+dummy_indicator_simple_class_init (DummyIndicatorSimpleClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	object_class->dispose = dummy_indicator_simple_dispose;
+	object_class->finalize = dummy_indicator_simple_finalize;
+
+	IndicatorObjectClass * io_class = INDICATOR_OBJECT_CLASS(klass);
+
+	io_class->get_label = get_label;
+	io_class->get_image = get_icon;
+	io_class->get_menu = get_menu;
+
+	return;
+}
+
+static void
+dummy_indicator_simple_init (DummyIndicatorSimple *self)
+{
+
+	return;
+}
+
+static void
+dummy_indicator_simple_dispose (GObject *object)
+{
+
+	G_OBJECT_CLASS (dummy_indicator_simple_parent_class)->dispose (object);
+	return;
+}
+
+static void
+dummy_indicator_simple_finalize (GObject *object)
+{
+
+	G_OBJECT_CLASS (dummy_indicator_simple_parent_class)->finalize (object);
+	return;
+}

=== added file 'tests/service-manager-connect-service.c'
--- tests/service-manager-connect-service.c	1970-01-01 00:00:00 +0000
+++ tests/service-manager-connect-service.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,48 @@
+
+#include <glib.h>
+#include "libindicator/indicator-service.h"
+
+static GMainLoop * mainloop = NULL;
+static gboolean passed = FALSE;
+
+gboolean
+timeout (gpointer data)
+{
+	passed = FALSE;
+	g_debug("Timeout with no shutdown.");
+	g_main_loop_quit(mainloop);
+	return FALSE;
+}
+
+void
+shutdown (void)
+{
+	g_debug("Shutdown");
+	passed = TRUE;
+	g_main_loop_quit(mainloop);
+	return;
+}
+
+int
+main (int argc, char ** argv)
+{
+	g_type_init();
+
+	g_debug("Starting service");
+
+	IndicatorService * is = indicator_service_new("org.ayatana.test");
+	g_signal_connect(G_OBJECT(is), INDICATOR_SERVICE_SIGNAL_SHUTDOWN, shutdown, NULL);
+
+	g_timeout_add_seconds(1, timeout, NULL);
+
+	mainloop = g_main_loop_new(NULL, FALSE);
+	g_main_loop_run(mainloop);
+
+	g_debug("Quiting");
+	if (passed) {
+		g_debug("Passed");
+		return 0;
+	}
+	g_debug("Failed");
+	return 1;
+}

=== added file 'tests/service-manager-connect.c'
--- tests/service-manager-connect.c	1970-01-01 00:00:00 +0000
+++ tests/service-manager-connect.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,63 @@
+
+#include <glib.h>
+#include "libindicator/indicator-service-manager.h"
+
+static GMainLoop * mainloop = NULL;
+static gboolean passed = FALSE;
+
+gboolean
+timeout (gpointer data)
+{
+	passed = FALSE;
+	g_error("Timeout with no connection.");
+	g_main_loop_quit(mainloop);
+	return FALSE;
+}
+
+void
+connection (IndicatorServiceManager * sm, gboolean connected, gpointer user_data)
+{
+	static gboolean has_connected = FALSE;
+
+	if (has_connected && connected) {
+		g_warning("We got two connected signals.  FAIL.");
+		passed = FALSE;
+		return;
+	}
+
+	if (!connected) {
+		g_debug("Not connected");
+		return;
+	}
+
+	has_connected = TRUE;
+	g_debug("Connection");
+	passed = TRUE;
+	g_main_loop_quit(mainloop);
+	return;
+}
+
+int
+main (int argc, char ** argv)
+{
+	g_type_init();
+	g_log_set_always_fatal(G_LOG_LEVEL_CRITICAL);
+
+	IndicatorServiceManager * is = indicator_service_manager_new("org.ayatana.test");
+	g_signal_connect(G_OBJECT(is), INDICATOR_SERVICE_MANAGER_SIGNAL_CONNECTION_CHANGE, G_CALLBACK(connection), NULL);
+
+	g_timeout_add_seconds(1, timeout, NULL);
+
+	mainloop = g_main_loop_new(NULL, FALSE);
+	g_main_loop_run(mainloop);
+
+	g_object_unref(is);
+
+	g_debug("Quiting");
+	if (passed) {
+		g_debug("Passed");
+		return 0;
+	}
+	g_debug("Failed");
+	return 1;
+}

=== added file 'tests/service-manager-connect.service.in'
--- tests/service-manager-connect.service.in	1970-01-01 00:00:00 +0000
+++ tests/service-manager-connect.service.in	2009-12-10 17:02:12 +0000
@@ -0,0 +1,3 @@
+[D-BUS Service]
+Name=org.ayatana.test
+Exec=@builddir@/service-manager-connect-service

=== added file 'tests/service-manager-no-connect.c'
--- tests/service-manager-no-connect.c	1970-01-01 00:00:00 +0000
+++ tests/service-manager-no-connect.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,47 @@
+
+#include <glib.h>
+#include "libindicator/indicator-service-manager.h"
+
+static GMainLoop * mainloop = NULL;
+static gboolean passed = FALSE;
+
+gboolean
+timeout (gpointer data)
+{
+	passed = TRUE;
+	g_debug("Timeout with no connection.");
+	g_main_loop_quit(mainloop);
+	return FALSE;
+}
+
+void
+connection (void)
+{
+	g_debug("Connection");
+	passed = FALSE;
+	g_main_loop_quit(mainloop);
+	return;
+}
+
+int
+main (int argc, char ** argv)
+{
+	g_type_init();
+	g_log_set_always_fatal(G_LOG_LEVEL_CRITICAL);
+
+	IndicatorServiceManager * is = indicator_service_manager_new("my.test.name");
+	g_signal_connect(G_OBJECT(is), INDICATOR_SERVICE_MANAGER_SIGNAL_CONNECTION_CHANGE, connection, NULL);
+
+	g_timeout_add_seconds(1, timeout, NULL);
+
+	mainloop = g_main_loop_new(NULL, FALSE);
+	g_main_loop_run(mainloop);
+
+	g_debug("Quiting");
+	if (passed) {
+		g_debug("Passed");
+		return 0;
+	}
+	g_debug("Failed");
+	return 1;
+}

=== added file 'tests/service-manager-nostart-connect.c'
--- tests/service-manager-nostart-connect.c	1970-01-01 00:00:00 +0000
+++ tests/service-manager-nostart-connect.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,65 @@
+
+#include <glib.h>
+#include "libindicator/indicator-service-manager.h"
+
+static GMainLoop * mainloop = NULL;
+static gboolean passed = FALSE;
+
+gboolean
+timeout (gpointer data)
+{
+	passed = FALSE;
+	g_error("Timeout with no connection.");
+	g_main_loop_quit(mainloop);
+	return FALSE;
+}
+
+void
+connection (IndicatorServiceManager * sm, gboolean connected, gpointer user_data)
+{
+	static gboolean has_connected = FALSE;
+
+	if (has_connected && connected) {
+		g_warning("We got two connected signals.  FAIL.");
+		passed = FALSE;
+		return;
+	}
+
+	if (!connected) {
+		g_debug("Not connected");
+		return;
+	}
+
+	has_connected = TRUE;
+	g_debug("Connection");
+	passed = TRUE;
+	g_main_loop_quit(mainloop);
+	return;
+}
+
+int
+main (int argc, char ** argv)
+{
+	g_type_init();
+	g_log_set_always_fatal(G_LOG_LEVEL_CRITICAL);
+
+	g_usleep(150000);
+
+	IndicatorServiceManager * is = indicator_service_manager_new("org.ayatana.test");
+	g_signal_connect(G_OBJECT(is), INDICATOR_SERVICE_MANAGER_SIGNAL_CONNECTION_CHANGE, G_CALLBACK(connection), NULL);
+
+	g_timeout_add_seconds(1, timeout, NULL);
+
+	mainloop = g_main_loop_new(NULL, FALSE);
+	g_main_loop_run(mainloop);
+
+	g_object_unref(is);
+
+	g_debug("Quiting");
+	if (passed) {
+		g_debug("Passed");
+		return 0;
+	}
+	g_debug("Failed");
+	return 1;
+}

=== added file 'tests/service-shutdown-timeout.c'
--- tests/service-shutdown-timeout.c	1970-01-01 00:00:00 +0000
+++ tests/service-shutdown-timeout.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,46 @@
+
+#include <glib.h>
+#include "libindicator/indicator-service.h"
+
+static GMainLoop * mainloop = NULL;
+static gboolean passed = FALSE;
+
+gboolean
+timeout (gpointer data)
+{
+	passed = FALSE;
+	g_error("Timeout with no shutdown.");
+	g_main_loop_quit(mainloop);
+	return FALSE;
+}
+
+void
+shutdown (void)
+{
+	g_debug("Shutdown");
+	passed = TRUE;
+	g_main_loop_quit(mainloop);
+	return;
+}
+
+int
+main (int argc, char ** argv)
+{
+	g_type_init();
+
+	IndicatorService * is = indicator_service_new("my.test.name");
+	g_signal_connect(G_OBJECT(is), INDICATOR_SERVICE_SIGNAL_SHUTDOWN, shutdown, NULL);
+
+	g_timeout_add_seconds(1, timeout, NULL);
+
+	mainloop = g_main_loop_new(NULL, FALSE);
+	g_main_loop_run(mainloop);
+
+	g_debug("Quiting");
+	if (passed) {
+		g_debug("Passed");
+		return 0;
+	}
+	g_debug("Failed");
+	return 1;
+}

=== added file 'tests/service-version-bad-service.c'
--- tests/service-version-bad-service.c	1970-01-01 00:00:00 +0000
+++ tests/service-version-bad-service.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,47 @@
+
+#include <glib.h>
+#include "libindicator/indicator-service.h"
+#include "service-version-values.h"
+
+static GMainLoop * mainloop = NULL;
+static gboolean passed = FALSE;
+
+gboolean
+timeout (gpointer data)
+{
+	passed = FALSE;
+	g_debug("Timeout with no shutdown.");
+	g_main_loop_quit(mainloop);
+	return FALSE;
+}
+
+void
+shutdown (void)
+{
+	g_debug("Shutdown");
+	passed = TRUE;
+	g_main_loop_quit(mainloop);
+	return;
+}
+
+int
+main (int argc, char ** argv)
+{
+	g_type_init();
+
+	IndicatorService * is = indicator_service_new_version("org.ayatana.version.bad", SERVICE_VERSION_BAD);
+	g_signal_connect(G_OBJECT(is), INDICATOR_SERVICE_SIGNAL_SHUTDOWN, shutdown, NULL);
+
+	g_timeout_add_seconds(1, timeout, NULL);
+
+	mainloop = g_main_loop_new(NULL, FALSE);
+	g_main_loop_run(mainloop);
+
+	g_debug("Quiting");
+	if (passed) {
+		g_debug("Passed");
+		return 0;
+	}
+	g_debug("Failed");
+	return 1;
+}

=== added file 'tests/service-version-bad.service.in'
--- tests/service-version-bad.service.in	1970-01-01 00:00:00 +0000
+++ tests/service-version-bad.service.in	2009-12-10 17:02:12 +0000
@@ -0,0 +1,3 @@
+[D-BUS Service]
+Name=org.ayatana.version.bad
+Exec=@builddir@/service-version-bad-service

=== added file 'tests/service-version-good-service.c'
--- tests/service-version-good-service.c	1970-01-01 00:00:00 +0000
+++ tests/service-version-good-service.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,47 @@
+
+#include <glib.h>
+#include "libindicator/indicator-service.h"
+#include "service-version-values.h"
+
+static GMainLoop * mainloop = NULL;
+static gboolean passed = FALSE;
+
+gboolean
+timeout (gpointer data)
+{
+	passed = FALSE;
+	g_debug("Timeout with no shutdown.");
+	g_main_loop_quit(mainloop);
+	return FALSE;
+}
+
+void
+shutdown (void)
+{
+	g_debug("Shutdown");
+	passed = TRUE;
+	g_main_loop_quit(mainloop);
+	return;
+}
+
+int
+main (int argc, char ** argv)
+{
+	g_type_init();
+
+	IndicatorService * is = indicator_service_new_version("org.ayatana.version.good", SERVICE_VERSION_GOOD);
+	g_signal_connect(G_OBJECT(is), INDICATOR_SERVICE_SIGNAL_SHUTDOWN, shutdown, NULL);
+
+	g_timeout_add_seconds(1, timeout, NULL);
+
+	mainloop = g_main_loop_new(NULL, FALSE);
+	g_main_loop_run(mainloop);
+
+	g_debug("Quiting");
+	if (passed) {
+		g_debug("Passed");
+		return 0;
+	}
+	g_debug("Failed");
+	return 1;
+}

=== added file 'tests/service-version-good.service.in'
--- tests/service-version-good.service.in	1970-01-01 00:00:00 +0000
+++ tests/service-version-good.service.in	2009-12-10 17:02:12 +0000
@@ -0,0 +1,3 @@
+[D-BUS Service]
+Name=org.ayatana.version.good
+Exec=@builddir@/service-version-good-service

=== added file 'tests/service-version-manager.c'
--- tests/service-version-manager.c	1970-01-01 00:00:00 +0000
+++ tests/service-version-manager.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,64 @@
+
+#include <glib.h>
+#include "libindicator/indicator-service-manager.h"
+#include "service-version-values.h"
+
+static GMainLoop * mainloop = NULL;
+static gboolean con_good = FALSE;
+static gboolean con_bad = FALSE;
+
+gboolean
+timeout (gpointer data)
+{
+	g_debug("Timeout.");
+	g_main_loop_quit(mainloop);
+	return FALSE;
+}
+
+void
+connection_bad (IndicatorServiceManager * sm, gboolean connected, gpointer user_data)
+{
+	if (!connected) return;
+	g_debug("Connection From Bad!");
+	con_bad = TRUE;
+	return;
+}
+
+void
+connection_good (IndicatorServiceManager * sm, gboolean connected, gpointer user_data)
+{
+	if (!connected) return;
+	g_debug("Connection From Good.");
+	con_good = TRUE;
+	return;
+}
+
+int
+main (int argc, char ** argv)
+{
+	g_type_init();
+	g_log_set_always_fatal(G_LOG_LEVEL_CRITICAL);
+	g_print("Manager: DBUS_SESSION_BUS_ADDRESS = %s\n", g_getenv("DBUS_SESSION_BUS_ADDRESS"));
+
+	IndicatorServiceManager * goodis = indicator_service_manager_new_version("org.ayatana.version.good", SERVICE_VERSION_GOOD);
+	g_signal_connect(G_OBJECT(goodis), INDICATOR_SERVICE_MANAGER_SIGNAL_CONNECTION_CHANGE, G_CALLBACK(connection_good), NULL);
+
+	IndicatorServiceManager * badis = indicator_service_manager_new_version("org.ayatana.version.bad", SERVICE_VERSION_GOOD);
+	g_signal_connect(G_OBJECT(badis), INDICATOR_SERVICE_MANAGER_SIGNAL_CONNECTION_CHANGE, G_CALLBACK(connection_bad), NULL);
+
+	g_timeout_add_seconds(1, timeout, NULL);
+
+	mainloop = g_main_loop_new(NULL, FALSE);
+	g_main_loop_run(mainloop);
+
+	g_object_unref(goodis);
+	g_object_unref(badis);
+
+	g_debug("Quiting");
+	if (con_good && !con_bad) {
+		g_debug("Passed");
+		return 0;
+	}
+	g_debug("Failed");
+	return 1;
+}

=== added file 'tests/service-version-values.h'
--- tests/service-version-values.h	1970-01-01 00:00:00 +0000
+++ tests/service-version-values.h	2009-12-10 17:02:12 +0000
@@ -0,0 +1,4 @@
+
+#define  SERVICE_VERSION_GOOD  1342
+#define  SERVICE_VERSION_BAD   543
+

=== added file 'tests/session.conf.in'
--- tests/session.conf.in	1970-01-01 00:00:00 +0000
+++ tests/session.conf.in	2009-12-10 17:02:12 +0000
@@ -0,0 +1,40 @@
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-Bus Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+  <!-- If we fork, keep the user's original umask to avoid affecting
+       the behavior of child processes. -->
+  <keep_umask/>
+
+  <listen>unix:tmpdir=/tmp</listen>
+
+  <servicedir>@servicedir@</servicedir>
+
+  <policy context="default">
+    <!-- Allow everything to be sent -->
+    <allow send_destination="*" eavesdrop="true"/>
+    <!-- Allow everything to be received -->
+    <allow eavesdrop="true"/>
+    <!-- Allow anyone to own anything -->
+    <allow own="*"/>
+  </policy>
+
+  <!-- raise the service start timeout to 40 seconds as it can timeout
+       on the live cd on slow machines -->
+  <limit name="service_start_timeout">60000</limit>
+
+  <!-- the memory limits are 1G instead of say 4G because they can't exceed 32-bit signed int max -->
+  <limit name="max_incoming_bytes">1000000000</limit>
+  <limit name="max_outgoing_bytes">1000000000</limit>
+  <limit name="max_message_size">1000000000</limit>
+  <limit name="service_start_timeout">120000</limit>  
+  <limit name="auth_timeout">240000</limit>
+  <limit name="max_completed_connections">100000</limit>  
+  <limit name="max_incomplete_connections">10000</limit>
+  <limit name="max_connections_per_user">100000</limit>
+  <limit name="max_pending_service_starts">10000</limit>
+  <limit name="max_names_per_connection">50000</limit>
+  <limit name="max_match_rules_per_connection">50000</limit>
+  <limit name="max_replies_per_connection">50000</limit>
+  <limit name="reply_timeout">300000</limit>
+
+</busconfig>

=== added file 'tests/test-loader.c'
--- tests/test-loader.c	1970-01-01 00:00:00 +0000
+++ tests/test-loader.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,146 @@
+#include <gtk/gtk.h>
+#include "libindicator/indicator-object.h"
+
+void destroy_cb (gpointer data, GObject * object);
+
+void
+entry_change_cb (IndicatorObject * io, IndicatorObjectEntry * entry, gpointer data)
+{
+	gpointer * valuestore = (gpointer *)data;
+	*valuestore = entry;
+	return;
+}
+
+void
+test_loader_filename_dummy_signaler (void)
+{
+	IndicatorObject * object = indicator_object_new_from_file(BUILD_DIR "/.libs/libdummy-indicator-signaler.so");
+	g_assert(object != NULL);
+
+	gpointer added_value = NULL, removed_value = NULL;
+
+	g_signal_connect(G_OBJECT(object), INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED,   G_CALLBACK(entry_change_cb), &added_value);
+	g_signal_connect(G_OBJECT(object), INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED, G_CALLBACK(entry_change_cb), &removed_value);
+
+	GList * list = indicator_object_get_entries(object);
+	g_assert(list != NULL);
+	g_list_free(list);
+
+	while (g_main_context_pending(NULL)) {
+		g_main_context_iteration(NULL, TRUE);
+	}
+
+	g_assert(GPOINTER_TO_UINT(added_value) == 5);
+	g_assert(GPOINTER_TO_UINT(removed_value) == 5);
+
+	g_object_unref(object);
+
+	return;
+}
+
+
+void
+test_loader_filename_dummy_simple_accessors (void)
+{
+	IndicatorObject * object = indicator_object_new_from_file(BUILD_DIR "/.libs/libdummy-indicator-simple.so");
+	g_assert(object != NULL);
+
+	g_assert(indicator_object_get_entries(object) != NULL);
+
+	g_object_unref(object);
+
+	return;
+}
+
+void
+test_loader_filename_dummy_simple (void)
+{
+	IndicatorObject * object = indicator_object_new_from_file(BUILD_DIR "/.libs/libdummy-indicator-simple.so");
+	g_assert(object != NULL);
+
+	gboolean unreffed = FALSE;
+	g_object_weak_ref(G_OBJECT(object), destroy_cb, &unreffed);
+
+	g_object_unref(object);
+	g_assert(unreffed == TRUE);
+
+	return;
+}
+
+void
+test_loader_filename_dummy_blank (void)
+{
+	IndicatorObject * object = indicator_object_new_from_file(BUILD_DIR "/.libs/libdummy-indicator-blank.so");
+	g_assert(object == NULL);
+	return;
+}
+
+void
+test_loader_filename_dummy_null (void)
+{
+	IndicatorObject * object = indicator_object_new_from_file(BUILD_DIR "/.libs/libdummy-indicator-null.so");
+	g_assert(object != NULL);
+	g_assert(indicator_object_get_entries(object) == NULL);
+	g_object_unref(G_OBJECT(object));
+	return;
+}
+
+void
+test_loader_filename_bad (void)
+{
+	IndicatorObject * object = indicator_object_new_from_file("/this/file/should/not/exist.so");
+	g_assert(object == NULL);
+	return;
+}
+
+void
+destroy_cb (gpointer data, GObject * object)
+{
+	gboolean * bob = (gboolean *)data;
+	*bob = TRUE;
+	return;
+}
+
+void
+test_loader_refunref (void)
+{
+	GObject * object = g_object_new(INDICATOR_OBJECT_TYPE, NULL);
+
+	gboolean unreffed = FALSE;
+	g_object_weak_ref(object, destroy_cb, &unreffed);
+
+	g_object_unref(object);
+
+	g_assert(unreffed == TRUE);
+
+	return;
+}
+
+void
+test_loader_creation_deletion_suite (void)
+{
+	g_test_add_func ("/libindicator/loader/ref_and_unref", test_loader_refunref);
+	g_test_add_func ("/libindicator/loader/filename_bad",  test_loader_filename_bad);
+	g_test_add_func ("/libindicator/loader/dummy/null_load",  test_loader_filename_dummy_null);
+	g_test_add_func ("/libindicator/loader/dummy/blank_load",  test_loader_filename_dummy_null);
+	g_test_add_func ("/libindicator/loader/dummy/simple_load",  test_loader_filename_dummy_simple);
+	g_test_add_func ("/libindicator/loader/dummy/simple_accessors", test_loader_filename_dummy_simple_accessors);
+	g_test_add_func ("/libindicator/loader/dummy/signaler",  test_loader_filename_dummy_signaler);
+
+	return;
+}
+
+
+int
+main (int argc, char ** argv)
+{
+	g_type_init (); 
+	g_test_init (&argc, &argv, NULL);
+	gtk_init(&argc, &argv);
+
+	test_loader_creation_deletion_suite();
+
+	g_log_set_always_fatal(G_LOG_LEVEL_CRITICAL);
+
+	return g_test_run();
+}

=== added directory 'tools'
=== added file 'tools/Makefile.am'
--- tools/Makefile.am	1970-01-01 00:00:00 +0000
+++ tools/Makefile.am	2009-12-10 17:02:12 +0000
@@ -0,0 +1,21 @@
+
+libexec_PROGRAMS = \
+	indicator-loader
+
+#############################
+# Indicator Loader
+#############################
+
+indicator_loader_SOURCES = \
+	indicator-loader.c
+
+indicator_loader_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir) \
+	-DBUILD_DIR="\"$(builddir)\""
+
+indicator_loader_LDADD = \
+	$(LIBINDICATOR_LIBS) \
+	-L$(top_builddir)/libindicator/.libs \
+	-lindicator
+

=== added file 'tools/indicator-loader.c'
--- tools/indicator-loader.c	1970-01-01 00:00:00 +0000
+++ tools/indicator-loader.c	2009-12-10 17:02:12 +0000
@@ -0,0 +1,149 @@
+/*
+A small test loader for loading indicators in test suites
+and during development of them.
+
+Copyright 2009 Canonical Ltd.
+
+Authors:
+    Ted Gould <[e-mail]>
+
+This library is free software; you can redistribute it and/or
+modify it under the terms of the GNU General Public License
+version 3.0 as published by the Free Software Foundation.
+
+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 General Public License version 3.0 for more details.
+
+You should have received a copy of the GNU General Public
+License along with this library. If not, see
+<http://www.gnu.org/licenses/>.
+*/
+
+
+#include <gtk/gtk.h>
+#include <libindicator/indicator-object.h>
+
+#define ENTRY_DATA_NAME "indicator-custom-entry-data"
+
+static void
+entry_added (IndicatorObject * io, IndicatorObjectEntry * entry, gpointer user_data)
+{
+	g_debug("Signal: Entry Added");
+
+	GtkWidget * menuitem = gtk_menu_item_new();
+	GtkWidget * hbox = gtk_hbox_new(FALSE, 3);
+
+	if (entry->image != NULL) {
+		gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(entry->image), FALSE, FALSE, 0);
+	}
+	if (entry->label != NULL) {
+		gtk_box_pack_start(GTK_BOX(hbox), GTK_WIDGET(entry->label), FALSE, FALSE, 0);
+	}
+	gtk_container_add(GTK_CONTAINER(menuitem), hbox);
+	gtk_widget_show(hbox);
+
+	if (entry->menu != NULL) {
+		gtk_menu_item_set_submenu(GTK_MENU_ITEM(menuitem), GTK_WIDGET(entry->menu));
+	}
+
+	gtk_menu_shell_append(GTK_MENU_SHELL(user_data), menuitem);
+	gtk_widget_show(menuitem);
+
+	g_object_set_data(G_OBJECT(menuitem), ENTRY_DATA_NAME, entry);
+
+	return;
+}
+
+static void
+entry_removed_cb (GtkWidget * widget, gpointer userdata)
+{
+	gpointer data = g_object_get_data(G_OBJECT(widget), ENTRY_DATA_NAME);
+
+	if (data != userdata) {
+		return;
+	}
+
+	gtk_widget_destroy(widget);
+	return;
+}
+
+static void 
+entry_removed (IndicatorObject * io, IndicatorObjectEntry * entry, gpointer user_data)
+{
+	g_debug("Signal: Entry Removed");
+
+	gtk_container_foreach(GTK_CONTAINER(user_data), entry_removed_cb, entry);
+
+	return;
+}
+
+static gboolean
+load_module (const gchar * name, GtkWidget * menu)
+{
+	g_debug("Looking at Module: %s", name);
+	g_return_val_if_fail(name != NULL, FALSE);
+
+	if (!g_str_has_suffix(name, G_MODULE_SUFFIX)) {
+		return FALSE;
+	}
+
+	g_debug("Loading Module: %s", name);
+
+	/* Build the object for the module */
+	IndicatorObject * io = indicator_object_new_from_file(name);
+
+	/* Connect to it's signals */
+	g_signal_connect(G_OBJECT(io), INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED,   G_CALLBACK(entry_added),    menu);
+	g_signal_connect(G_OBJECT(io), INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED, G_CALLBACK(entry_removed),  menu);
+
+	/* Work on the entries */
+	GList * entries = indicator_object_get_entries(io);
+	GList * entry = NULL;
+
+	for (entry = entries; entry != NULL; entry = g_list_next(entry)) {
+		IndicatorObjectEntry * entrydata = (IndicatorObjectEntry *)entry->data;
+		entry_added(io, entrydata, menu);
+	}
+
+	g_list_free(entries);
+
+	return TRUE;
+}
+
+static void
+destroy (gpointer data)
+{
+	gtk_main_quit();
+	return;
+}
+
+int
+main (int argc, char ** argv)
+{
+	gtk_init(&argc, &argv);
+
+	if (argc != 2) {
+		g_error("Need filename");
+		return 1;
+	}
+
+	GtkWidget * menubar = gtk_menu_bar_new();
+	if (!load_module(argv[1], menubar)) {
+		g_error("Unable to load module");
+		return 1;
+	}
+
+	GtkWidget * window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
+	g_signal_connect(G_OBJECT(window), "destroy", G_CALLBACK(destroy), NULL);
+
+	gtk_container_add(GTK_CONTAINER(window), menubar);
+
+	gtk_widget_show(menubar);
+	gtk_widget_show(window);
+
+	gtk_main();
+
+	return 0;
+}