Add visibility concept to the default indicator object

7 files changed, 590 insertions, 31 deletions

diff --git a/libindicator/indicator-desktop-shortcuts.c b/libindicator/indicator-desktop-shortcuts.c
index 5d16cda..62bf504 100644
--- a/libindicator/indicator-desktop-shortcuts.c
+++ b/libindicator/indicator-desktop-shortcuts.c
@@ -369,7 +369,7 @@ should_show (GKeyFile * keyfile, const gchar * group, const gchar * identity, gb
 	return TRUE;
 }
 
-/* Looks through the nicks ot see if this one is in the list,
+/* Looks through the nicks to see if this one is in the list,
    and thus valid to use. */
 static gboolean
 is_valid_nick (gchar ** list, const gchar * nick)
diff --git a/libindicator/indicator-object.c b/libindicator/indicator-object.c
index adaa9ed..849fb9f 100644
--- a/libindicator/indicator-object.c
+++ b/libindicator/indicator-object.c
@@ -31,6 +31,24 @@ License along with this library. If not, see
 #include "indicator-object-enum-types.h"
 
 /**
+	@ENTRY_INIT: The entry hasn't been initialized yet, so its
+		visibility will depend upon the inital-visibility property.
+	@ENTRY_VISIBLE: The entry is visible
+	@ENTRY_INVISIBLE: The entry is invisible
+*/
+typedef enum {
+    ENTRY_INIT,
+    ENTRY_VISIBLE,
+    ENTRY_INVISIBLE
+}
+EntryVisibility;
+
+typedef struct _IndicatorObjectEntryPrivate {
+     EntryVisibility visibility;
+}
+IndicatorObjectEntryPrivate;
+
+/**
 	IndicatorObjectPrivate:
 	@module: The loaded module representing the object.  Note to
 		subclasses: This will not be set when you're initalized.
@@ -49,11 +67,16 @@ struct _IndicatorObjectPrivate {
 	IndicatorObjectEntry entry;
 	gboolean gotten_entries;
 
+	/* Whether or not entries are visible by default */
+	gboolean default_visibility;
+	GHashTable * entry_privates;
+
 	GStrv environments;
 };
 
 #define INDICATOR_OBJECT_GET_PRIVATE(o) (INDICATOR_OBJECT(o)->priv)
 
+
 /* Signals Stuff */
 enum {
 	ENTRY_ADDED,
@@ -67,6 +90,16 @@ enum {
 	LAST_SIGNAL
 };
 
+/* Properties */
+/* Enum for the properties so that they can be quickly
+   found and looked up. */
+enum {
+	PROP_0,
+	PROP_GSETTINGS_SCHEMA_ID,
+	PROP_DEFAULT_VISIBILITY,
+};
+
+
 static guint signals[LAST_SIGNAL] = { 0 };
 
 /* GObject stuff */
@@ -74,8 +107,17 @@ 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);
+static void set_property (GObject*, guint prop_id, const GValue*, GParamSpec* );
+static void get_property (GObject*, guint prop_id,       GValue*, GParamSpec* );
+
+/* entries' visibility */
+static GList * get_entries_default               (IndicatorObject*);
+static GList * get_all_entries                   (IndicatorObject*);
+static void entry_being_removed_default          (IndicatorObject*, IndicatorObjectEntry*);
+static void indicator_object_entry_being_removed (IndicatorObject*, IndicatorObjectEntry*);
+static void entry_was_added_default              (IndicatorObject*, IndicatorObjectEntry*);
+static void indicator_object_entry_was_added     (IndicatorObject*, IndicatorObjectEntry*);
+static IndicatorObjectEntryPrivate * entry_get_private (IndicatorObject*, IndicatorObjectEntry*);
 
 G_DEFINE_TYPE (IndicatorObject, indicator_object, G_TYPE_OBJECT);
 
@@ -90,14 +132,17 @@ indicator_object_class_init (IndicatorObjectClass *klass)
 
 	object_class->dispose = indicator_object_dispose;
 	object_class->finalize = indicator_object_finalize;
+	object_class->set_property = set_property;
+	object_class->get_property = get_property;
 
 	klass->get_label =  NULL;
-	klass->get_menu =   NULL;
+	klass->get_menu  =  NULL;
 	klass->get_image =  NULL;
 	klass->get_accessible_desc = NULL;
-
 	klass->get_entries = get_entries_default;
 	klass->get_location = NULL;
+	klass->entry_being_removed = entry_being_removed_default;
+	klass->entry_was_added = entry_was_added_default;
 
 	klass->entry_activate = NULL;
 	klass->entry_activate_window = NULL;
@@ -245,39 +290,68 @@ indicator_object_class_init (IndicatorObjectClass *klass)
 	                                     g_cclosure_marshal_VOID__POINTER,
 	                                     G_TYPE_NONE, 1, G_TYPE_POINTER, G_TYPE_NONE);
 
+	/* Properties */
 
-	return;
+	GParamSpec * pspec = g_param_spec_boolean (INDICATOR_OBJECT_DEFAULT_VISIBILITY,
+			"default visibility",
+			"Whether or not entries should initially be visible.",
+			TRUE,
+			G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
+	g_object_class_install_property (object_class, PROP_DEFAULT_VISIBILITY, pspec);
 }
 
 /* Initialize an instance */
 static void
 indicator_object_init (IndicatorObject *self)
 {
-	self->priv = G_TYPE_INSTANCE_GET_PRIVATE (self, INDICATOR_OBJECT_TYPE, IndicatorObjectPrivate);
+	IndicatorObjectPrivate * priv = G_TYPE_INSTANCE_GET_PRIVATE (self, INDICATOR_OBJECT_TYPE, IndicatorObjectPrivate);
 
-	self->priv->module = NULL;
+	priv->module = NULL;
 
-	self->priv->entry.parent_object = self;
-	self->priv->entry.menu = NULL;
-	self->priv->entry.label = NULL;
-	self->priv->entry.image = NULL;
-	self->priv->entry.accessible_desc = NULL;
-	self->priv->entry.name_hint = NULL;
+	priv->entry.parent_object = self;
+	priv->entry.menu = NULL;
+	priv->entry.label = NULL;
+	priv->entry.image = NULL;
+	priv->entry.accessible_desc = NULL;
+	priv->entry.name_hint = NULL;
 
-	self->priv->gotten_entries = FALSE;
+	priv->gotten_entries = FALSE;
+	priv->default_visibility = TRUE;
+	priv->entry_privates = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free);
 
-	self->priv->environments = NULL;
+	priv->environments = NULL;
 
-	return;
+	self->priv = priv;
+
+	GObject * o = G_OBJECT(self);
+	/* Invoke the entry-being-removed virtual function first */
+	g_signal_connect (o, INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED,
+	                  G_CALLBACK(indicator_object_entry_being_removed), NULL);
+	/* Invoke the entry-was-added virtual function last */
+	g_signal_connect_after (o, INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED,
+	                        G_CALLBACK(indicator_object_entry_was_added), NULL);
 }
 
 /* Unref the objects that we're holding on to. */
 static void
 indicator_object_dispose (GObject *object)
 {
+	IndicatorObject * io = INDICATOR_OBJECT(object);
+
+	/* Ensure that hidden entries are re-added so their widgetry will
+	   be cleaned up properly by the client */
+	GList * l;
+	GList * entries = get_all_entries (io);
+	const GQuark detail = (GQuark)0;
+	for (l=entries; l!=NULL; l=l->next) {
+		IndicatorObjectEntry * entry = l->data;
+		if (entry_get_private(io, entry)->visibility == ENTRY_INVISIBLE) {
+			g_signal_emit(io, signals[ENTRY_ADDED], detail, entry);
+		}
+	}
+	g_list_free (entries);
 
 	G_OBJECT_CLASS (indicator_object_parent_class)->dispose (object);
-	return;
 }
 
 /* A small helper function that closes a module but
@@ -298,6 +372,11 @@ indicator_object_finalize (GObject *object)
 {
 	IndicatorObjectPrivate * priv = INDICATOR_OBJECT_GET_PRIVATE(object);
 
+	if (priv->entry_privates != NULL) {
+		g_hash_table_destroy (priv->entry_privates);
+		priv->entry_privates = NULL;
+	}
+
 	if (priv->environments != NULL) {
 		g_strfreev(priv->environments);
 		priv->environments = NULL;
@@ -306,7 +385,7 @@ indicator_object_finalize (GObject *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
+		   removed.  But, since its 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.
@@ -468,30 +547,81 @@ get_entries_default (IndicatorObject * io)
 	return g_list_append(NULL, &(priv->entry));
 }
 
+/* returns a list of all IndicatorObjectEntires, visible or not */
+static GList*
+get_all_entries (IndicatorObject * io)
+{
+	GList * all_entries = NULL;
+
+	g_return_val_if_fail(INDICATOR_IS_OBJECT(io), NULL);
+	IndicatorObjectClass * class = INDICATOR_OBJECT_GET_CLASS(io);
+
+	if (class->get_entries == NULL)
+		g_error("No get_entries function on object.  It must have been deleted?!?!");
+	else
+		all_entries = class->get_entries(io);
+
+	return all_entries;
+}
+
+/* get the private structure that corresponds to a caller-specified entry */
+static IndicatorObjectEntryPrivate *
+entry_get_private (IndicatorObject * io, IndicatorObjectEntry * entry)
+{
+	g_return_val_if_fail (INDICATOR_IS_OBJECT(io), NULL);
+	g_return_val_if_fail (io->priv != NULL, NULL);
+
+	GHashTable * h = io->priv->entry_privates;
+	IndicatorObjectEntryPrivate * priv = g_hash_table_lookup (h, entry);
+	if (priv == NULL)
+	{
+		priv = g_new0 (IndicatorObjectEntryPrivate, 1);
+		priv->visibility = ENTRY_INIT;
+		g_hash_table_insert (h, entry, priv);
+	}
+
+	return priv;
+}
+
 /**
 	indicator_object_get_entries:
 	@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
-	entries should not be.
+	This function returns a list of visible entries. The list is built
+	by calling the object's #IndicatorObjectClass::get_entries
+	virtual function and testing each of the results for visibility.
+	Callers should free the GList with g_list_free(), but the entries
+	are owned by the IndicatorObject and should not be freed.
 
-	Return value: (element-type IndicatorObjectEntry) (transfer container): A list if #IndicatorObjectEntry structures or
-		NULL if there is an error.
+	Return value: (element-type IndicatorObjectEntry) (transfer container):
+		A list if #IndicatorObjectEntry structures or NULL on 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);
+	GList * l;
+	GList * ret = NULL;
+	GList * all_entries = get_all_entries (io);
+	const gboolean default_visibility = INDICATOR_OBJECT_GET_PRIVATE(io)->default_visibility;
+
+	for (l=all_entries; l!=NULL; l=l->next)
+	{
+		gboolean show_me;
+		IndicatorObjectEntry * entry = l->data;
+
+		switch (entry_get_private(io,entry)->visibility) {
+			case ENTRY_VISIBLE:   show_me = TRUE; break;
+			case ENTRY_INVISIBLE: show_me = FALSE; break;
+			case ENTRY_INIT:      show_me = default_visibility; break;
+			default:              show_me = TRUE; g_warn_if_reached(); break;
+		}
 
-	if (class->get_entries) {
-		return class->get_entries(io);
+		if (show_me)
+			ret = g_list_prepend (ret, entry);
 	}
 
-	g_error("No get_entries function on object.  It must have been deleted?!?!");
-	return NULL;
+	g_list_free (all_entries);
+	return g_list_reverse (ret);
 }
 
 /**
@@ -620,6 +750,30 @@ indicator_object_entry_close (IndicatorObject * io, IndicatorObjectEntry * entry
 	return;
 }
 
+static void
+indicator_object_entry_being_removed (IndicatorObject * io, IndicatorObjectEntry * entry)
+{
+	g_return_if_fail(INDICATOR_IS_OBJECT(io));
+	IndicatorObjectClass * class = INDICATOR_OBJECT_GET_CLASS(io);
+
+	entry_get_private (io, entry)->visibility = ENTRY_INVISIBLE;
+
+	if (class->entry_being_removed != NULL)
+		class->entry_being_removed (io, entry);
+}
+
+static void
+indicator_object_entry_was_added (IndicatorObject * io, IndicatorObjectEntry * entry)
+{
+	g_return_if_fail(INDICATOR_IS_OBJECT(io));
+	IndicatorObjectClass * class = INDICATOR_OBJECT_GET_CLASS(io);
+
+	entry_get_private (io, entry)->visibility = ENTRY_VISIBLE;
+
+	if (class->entry_was_added != NULL)
+		class->entry_was_added (io, entry);
+}
+
 /**
 	indicator_object_set_environment:
 	@io: #IndicatorObject to set on
@@ -632,6 +786,7 @@ indicator_object_entry_close (IndicatorObject * io, IndicatorObjectEntry * entry
 void
 indicator_object_set_environment (IndicatorObject * io, const GStrv env)
 {
+	/* FIXME: should this be a property? */
 	g_return_if_fail(INDICATOR_IS_OBJECT(io));
 
 	if (io->priv->environments != NULL) {
@@ -690,3 +845,142 @@ indicator_object_check_environment (IndicatorObject * io, const gchar * env)
 
 	return FALSE;
 }
+
+/**
+	indicator_object_set_visible:
+	@io: #IndicatorObject to check on
+	@visible: whether or not the entries should be visible
+
+	Used to set all of an indicator's entries to be visible or hidden.
+*/
+void
+indicator_object_set_visible (IndicatorObject * io, gboolean visible)
+{
+	g_return_if_fail(INDICATOR_IS_OBJECT(io));
+
+	GList * l;
+	GList * entries = get_all_entries (io);
+	const guint signal_id = signals[visible ? ENTRY_ADDED : ENTRY_REMOVED];
+	const GQuark detail = (GQuark)0;
+	for (l=entries; l!=NULL; l=l->next)
+		g_signal_emit(io, signal_id, detail, l->data);
+	g_list_free (entries);
+}
+
+static void
+get_property (GObject     * object,
+              guint         prop_id,
+              GValue      * value,
+              GParamSpec  * pspec)
+{
+        IndicatorObject * self = INDICATOR_OBJECT(object);
+        g_return_if_fail(self != NULL);
+
+        IndicatorObjectPrivate * priv = INDICATOR_OBJECT_GET_PRIVATE(self);
+        g_return_if_fail(priv != NULL);
+
+        switch (prop_id) {
+        /* *********************** */
+        case PROP_DEFAULT_VISIBILITY:
+                if (G_VALUE_HOLDS_BOOLEAN(value)) {
+                        g_value_set_boolean(value, priv->default_visibility);
+                } else {
+                        g_warning("default-visibility property requires a boolean value.");
+                }
+                break;
+        /* *********************** */
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                break;
+        }
+}
+
+static void
+set_property (GObject       * object,
+              guint           prop_id,
+              const GValue  * value,
+              GParamSpec    * pspec)
+{
+        IndicatorObject * self = INDICATOR_OBJECT(object);
+        g_return_if_fail (self != NULL);
+
+        IndicatorObjectPrivate * priv = INDICATOR_OBJECT_GET_PRIVATE(self);
+        g_return_if_fail (priv != NULL);
+
+
+        switch (prop_id) {
+
+        /* *********************** */
+        case PROP_DEFAULT_VISIBILITY:
+                if (G_VALUE_HOLDS_BOOLEAN(value)) {
+                        priv->default_visibility = g_value_get_boolean (value);
+                } else {
+                        g_warning("default-visibility property requires a boolean value.");
+                }
+                break;
+    
+    
+        default:
+                G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
+                break;
+        }
+}
+
+/***
+****
+***/
+
+/* Cloaked entries are ones which are hidden but may be re-added later.
+   They are reffed + unparented so that they'll survive even if the
+   rest of the widgetry is destroyed */
+#define CLOAKED_KEY "entry-is-cloaked"
+
+static void
+decloak_widget (gpointer w)
+{
+	if (w != NULL) {
+		GObject * o = G_OBJECT(w);
+		if (g_object_steal_data (o, CLOAKED_KEY) != NULL) {
+			g_object_unref (o);
+		}
+	}
+}
+
+static void
+entry_was_added_default (IndicatorObject * io, IndicatorObjectEntry * entry)
+{
+	decloak_widget (entry->image);
+	decloak_widget (entry->label);
+	decloak_widget (entry->menu);
+}
+
+static void
+cloak_widget (gpointer w)
+{
+	if (w != NULL) {
+		GtkWidget * parent;
+
+		/* tag this object as cloaked */
+		GObject * o = G_OBJECT(w);
+		g_object_ref (o);
+		g_object_set_data (o, CLOAKED_KEY, GINT_TO_POINTER(1));
+
+		/* remove it from its surrounding widgetry */
+		if(GTK_IS_MENU(w)) {
+			if (gtk_menu_get_attach_widget (GTK_MENU(w)) != NULL) {
+				gtk_menu_detach (GTK_MENU(w));
+			}
+		}
+		else if((parent = gtk_widget_get_parent(w))) {
+			gtk_container_remove(GTK_CONTAINER(parent), w);
+		}
+	}
+}
+
+static void
+entry_being_removed_default (IndicatorObject * io, IndicatorObjectEntry * entry)
+{
+	cloak_widget (entry->image);
+	cloak_widget (entry->label);
+	cloak_widget (entry->menu);
+}
diff --git a/libindicator/indicator-object.h b/libindicator/indicator-object.h
index b8b9a8b..2d69b1b 100644
--- a/libindicator/indicator-object.h
+++ b/libindicator/indicator-object.h
@@ -60,6 +60,9 @@ typedef enum
 #define INDICATOR_OBJECT_SIGNAL_SECONDARY_ACTIVATE "secondary-activate"
 #define INDICATOR_OBJECT_SIGNAL_SECONDARY_ACTIVATE_ID (g_signal_lookup(INDICATOR_OBJECT_SIGNAL_SECONDARY_ACTIVATE, INDICATOR_OBJECT_TYPE))
 
+/* the name of the property to decide whether or not entries are visible by default */
+#define INDICATOR_OBJECT_DEFAULT_VISIBILITY        "indicator-object-default-visibility"
+
 typedef struct _IndicatorObject        IndicatorObject;
 typedef struct _IndicatorObjectClass   IndicatorObjectClass;
 typedef struct _IndicatorObjectPrivate IndicatorObjectPrivate;
@@ -91,6 +94,12 @@ typedef struct _IndicatorObjectEntry   IndicatorObjectEntry;
 	@get_show_now: Returns whether the entry is requesting to
 		be shown "right now" in that it has something important
 		to tell the user.
+	@entry_being_removed: Called before an entry is removed.
+		The default implementation is to ref and unparent the
+		entry's widgets so that they can be re-added later.
+	@entry_was_added: Called after an entry is added.
+		The default implementation is to unref the entry's widgets if
+		previously reffed by entry_being_removed's default impementation
 	@entry_activate: Should be called when the menus for a given
 		entry are shown to the user.
 	@entry_close: Called when the menu is closed.
@@ -117,6 +126,9 @@ struct _IndicatorObjectClass {
 	guint      (*get_location) (IndicatorObject * io, IndicatorObjectEntry * entry);
 	gboolean   (*get_show_now) (IndicatorObject * io, IndicatorObjectEntry * entry);
 
+	void       (*entry_being_removed) (IndicatorObject * io, IndicatorObjectEntry * entry);
+	void       (*entry_was_added) (IndicatorObject * io, IndicatorObjectEntry * entry);
+
 	void       (*entry_activate) (IndicatorObject * io, IndicatorObjectEntry * entry, guint timestamp);
 	void       (*entry_activate_window) (IndicatorObject * io, IndicatorObjectEntry * entry, guint windowid, guint timestamp);
 	void       (*entry_close) (IndicatorObject * io, IndicatorObjectEntry * entry, guint timestamp);
@@ -186,6 +198,7 @@ IndicatorObject * indicator_object_new_from_file (const gchar * file);
 GList * indicator_object_get_entries (IndicatorObject * io);
 guint   indicator_object_get_location (IndicatorObject * io, IndicatorObjectEntry * entry);
 guint   indicator_object_get_show_now (IndicatorObject * io, IndicatorObjectEntry * entry);
+void	indicator_object_set_visible (IndicatorObject * io, gboolean visible);
 void    indicator_object_entry_activate (IndicatorObject * io, IndicatorObjectEntry * entry, guint timestamp);
 void    indicator_object_entry_activate_window (IndicatorObject * io, IndicatorObjectEntry * entry, guint windowid, guint timestamp);
 void    indicator_object_entry_close (IndicatorObject * io, IndicatorObjectEntry * entry, guint timestamp);
diff --git a/tests/Makefile.am b/tests/Makefile.am
index c8a9ba7..9319087 100644
--- a/tests/Makefile.am
+++ b/tests/Makefile.am
@@ -15,6 +15,7 @@ lib_LTLIBRARIES = \
 	libdummy-indicator-null.la \
 	libdummy-indicator-signaler.la \
 	libdummy-indicator-simple.la \
+	libdummy-indicator-visible.la \
 	libdummy-indicator-entry-func.la
 
 DBUS_RUNNER=dbus-test-runner --dbus-config /usr/share/dbus-test-runner/session.conf
@@ -184,6 +185,26 @@ libdummy_indicator_entry_func_la_LDFLAGS = \
 	-avoid-version
 
 #############################
+# Dummy Indicator Visible
+#############################
+
+libdummy_indicator_visible_la_SOURCES = \
+	dummy-indicator-visible.c
+
+libdummy_indicator_visible_la_CFLAGS = \
+	-Wall -Werror \
+	$(LIBINDICATOR_CFLAGS) -I$(top_srcdir)
+
+libdummy_indicator_visible_la_LIBADD = \
+	$(LIBINDICATOR_LIBS) \
+	-L$(top_builddir)/libindicator/.libs \
+	$(INDICATOR_LIB)
+
+libdummy_indicator_visible_la_LDFLAGS = \
+	-module \
+	-avoid-version
+
+#############################
 # Service Shutdown Timeout
 #############################
 
diff --git a/tests/dummy-indicator-signaler.c b/tests/dummy-indicator-signaler.c
index 00eee3b..c7a5c1f 100644
--- a/tests/dummy-indicator-signaler.c
+++ b/tests/dummy-indicator-signaler.c
@@ -99,6 +99,8 @@ dummy_indicator_signaler_class_init (DummyIndicatorSignalerClass *klass)
 	io_class->get_image = get_icon;
 	io_class->get_menu = get_menu;
 	io_class->get_accessible_desc = get_accessible_desc;
+	io_class->entry_being_removed  = NULL;
+	io_class->entry_was_added  = NULL;
 
 	return;
 }
diff --git a/tests/dummy-indicator-visible.c b/tests/dummy-indicator-visible.c
new file mode 100644
index 0000000..0bb9e89
--- /dev/null
+++ b/tests/dummy-indicator-visible.c
@@ -0,0 +1,139 @@
+/*
+Test for libindicator
+
+Copyright 2012 Canonical Ltd.
+
+Authors:
+    Charles Kerr <charles.kerr@canonical.com>
+
+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 <glib.h>
+#include <glib-object.h>
+
+#include "libindicator/indicator.h"
+#include "libindicator/indicator-object.h"
+
+#define DUMMY_INDICATOR_VISIBLE_TYPE            (dummy_indicator_visible_get_type ())
+#define DUMMY_INDICATOR_VISIBLE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), DUMMY_INDICATOR_VISIBLE_TYPE, DummyIndicatorVisible))
+#define DUMMY_INDICATOR_VISIBLE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), DUMMY_INDICATOR_VISIBLE_TYPE, DummyIndicatorVisibleClass))
+#define IS_DUMMY_INDICATOR_VISIBLE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DUMMY_INDICATOR_VISIBLE_TYPE))
+#define IS_DUMMY_INDICATOR_VISIBLE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DUMMY_INDICATOR_VISIBLE_TYPE))
+#define DUMMY_INDICATOR_VISIBLE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), DUMMY_INDICATOR_VISIBLE_TYPE, DummyIndicatorVisibleClass))
+
+typedef struct _DummyIndicatorVisible      DummyIndicatorVisible;
+typedef struct _DummyIndicatorVisibleClass DummyIndicatorVisibleClass;
+
+struct _DummyIndicatorVisibleClass {
+	IndicatorObjectClass parent_class;
+};
+
+struct _DummyIndicatorVisible {
+	IndicatorObject parent;
+};
+
+GType dummy_indicator_visible_get_type (void);
+
+INDICATOR_SET_VERSION
+INDICATOR_SET_TYPE(DUMMY_INDICATOR_VISIBLE_TYPE)
+
+GtkLabel *
+get_label (IndicatorObject * io)
+{
+	return GTK_LABEL(gtk_label_new("Visible 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;
+}
+
+const gchar *
+get_accessible_desc (IndicatorObject * io)
+{
+	return "Visible Item";
+}
+
+static void dummy_indicator_visible_class_init (DummyIndicatorVisibleClass *klass);
+static void dummy_indicator_visible_init       (DummyIndicatorVisible *self);
+static void dummy_indicator_visible_dispose    (GObject *object);
+static void dummy_indicator_visible_finalize   (GObject *object);
+
+G_DEFINE_TYPE (DummyIndicatorVisible, dummy_indicator_visible, INDICATOR_OBJECT_TYPE);
+
+static void
+dummy_indicator_entry_being_removed (IndicatorObject * io, IndicatorObjectEntry * entry)
+{
+	g_object_set_data(G_OBJECT(entry->label), "is-hidden", GINT_TO_POINTER(1));
+
+        INDICATOR_OBJECT_CLASS(dummy_indicator_visible_parent_class)->entry_being_removed (io, entry);
+}
+
+static void
+dummy_indicator_entry_was_added (IndicatorObject * io, IndicatorObjectEntry * entry)
+{
+	g_object_steal_data(G_OBJECT(entry->label), "is-hidden");
+
+        INDICATOR_OBJECT_CLASS(dummy_indicator_visible_parent_class)->entry_was_added (io, entry);
+}
+
+static void
+dummy_indicator_visible_class_init (DummyIndicatorVisibleClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	object_class->dispose = dummy_indicator_visible_dispose;
+	object_class->finalize = dummy_indicator_visible_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;
+	io_class->get_accessible_desc = get_accessible_desc;
+	io_class->entry_being_removed = dummy_indicator_entry_being_removed;
+	io_class->entry_was_added = dummy_indicator_entry_was_added;
+}
+
+static void
+dummy_indicator_visible_init (DummyIndicatorVisible *self)
+{
+}
+
+static void
+dummy_indicator_visible_dispose (GObject *object)
+{
+
+	G_OBJECT_CLASS (dummy_indicator_visible_parent_class)->dispose (object);
+}
+
+static void
+dummy_indicator_visible_finalize (GObject *object)
+{
+
+	G_OBJECT_CLASS (dummy_indicator_visible_parent_class)->finalize (object);
+}
diff --git a/tests/test-loader.c b/tests/test-loader.c
index 38f2cb1..6f9d25b 100644
--- a/tests/test-loader.c
+++ b/tests/test-loader.c
@@ -140,6 +140,95 @@ test_loader_filename_dummy_signaler (void)
 	return;
 }
 
+/***
+****
+***/
+
+static void
+visible_entry_added (IndicatorObject * io, IndicatorObjectEntry * entry, gpointer box)
+{
+	// make a frame for the entry, and add the frame to the box
+	GtkWidget * frame = gtk_frame_new (NULL);
+	GtkWidget * child = GTK_WIDGET(entry->label);
+	g_assert (child != NULL);
+	gtk_container_add (GTK_CONTAINER(frame), child);
+	gtk_box_pack_start (GTK_BOX(box), frame, FALSE, FALSE, 0);
+	g_object_set_data (G_OBJECT(child), "frame-parent", frame);
+}
+
+static void
+visible_entry_removed (IndicatorObject * io, IndicatorObjectEntry * entry, gpointer box)
+{
+	// destroy this entry's frame
+	gpointer parent = g_object_steal_data (G_OBJECT(entry->label), "frame-parent");
+	if (GTK_IS_WIDGET(parent))
+		gtk_widget_destroy(GTK_WIDGET(parent));
+}
+
+void
+test_loader_filename_dummy_visible (void)
+{
+	const GQuark is_hidden_quark = g_quark_from_static_string ("is-hidden");
+	IndicatorObject * object = indicator_object_new_from_file(BUILD_DIR "/.libs/libdummy-indicator-visible.so");
+	g_assert(object != NULL);
+
+	// create our local parent widgetry
+#if GTK_CHECK_VERSION(3,0,0)
+	GtkWidget * box = gtk_box_new (GTK_ORIENTATION_HORIZONTAL, 0);
+#else
+	GtkWidget * box = gtk_hbox_new (TRUE, 0);
+#endif
+	g_signal_connect(object, INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED,
+	                 G_CALLBACK(visible_entry_added), box);
+	g_signal_connect(object, INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED,
+	                 G_CALLBACK(visible_entry_removed), box);
+
+	// on startup, DummyVisible has one entry and it has a label
+	GList * list = indicator_object_get_entries(object);
+	g_assert(g_list_length(list) == 1);
+	IndicatorObjectEntry * entry = list->data;
+	g_assert(entry != NULL);
+	g_list_free(list);
+	g_assert(GTK_IS_LABEL(entry->label));
+	GtkWidget * label = GTK_WIDGET(entry->label);
+        g_assert(g_object_get_qdata(G_OBJECT(label), is_hidden_quark) == NULL);
+
+	// add the inital entry to our local parent widgetry
+	visible_entry_added (object, entry, box);
+	entry = NULL;
+	list = gtk_container_get_children (GTK_CONTAINER(box));
+	g_assert(g_list_length(list) == 1);
+	g_list_free(list);
+	
+	// hide the entries and confirm that the label survived
+	indicator_object_set_visible (object, FALSE);
+	while (g_main_context_pending(NULL))
+		g_main_context_iteration(NULL, TRUE);
+	g_assert(GTK_IS_LABEL(label));
+        g_assert(g_object_get_qdata(G_OBJECT(label), is_hidden_quark) != NULL);
+	list = gtk_container_get_children (GTK_CONTAINER(box));
+	g_assert(g_list_length(list) == 0);
+	g_list_free(list);
+
+	// restore the entries and confirm that the label survived
+	indicator_object_set_visible (object, TRUE);
+	while (g_main_context_pending(NULL))
+		g_main_context_iteration(NULL, TRUE);
+	g_assert(GTK_IS_LABEL(label));
+        g_assert(g_object_get_qdata(G_OBJECT(label), is_hidden_quark) == NULL);
+	list = gtk_container_get_children (GTK_CONTAINER(box));
+	g_assert(g_list_length(list) == 1);
+	g_list_free(list);
+
+	// cleanup
+	g_object_unref(object);
+	gtk_widget_destroy(box);
+}
+
+/***
+****
+***/
+
 void
 test_loader_filename_dummy_simple_location (void)
 {
@@ -249,6 +338,7 @@ test_loader_creation_deletion_suite (void)
 	g_test_add_func ("/libindicator/loader/dummy/signaler",  test_loader_filename_dummy_signaler);
 	g_test_add_func ("/libindicator/loader/dummy/entry_funcs",  test_loader_entry_funcs);
 	g_test_add_func ("/libindicator/loader/dummy/entry_func_window",  test_loader_entry_func_window);
+	g_test_add_func ("/libindicator/loader/dummy/visible",  test_loader_filename_dummy_visible);
 
 	return;
 }