From 4f4190f71f8495e5bcf6779d73157931572e42ac Mon Sep 17 00:00:00 2001 From: Charles Kerr Date: Mon, 23 Jan 2012 05:39:50 -0600 Subject: another iteration of the indicator-object visibility support patch, incorporating ideas from discussion with ted - some functions were public when they should have been private - the hide/show handler is now a virtual function & is documented in indicator-object.h - added unit tests - the GSettings monitor has been removed --- libindicator/indicator-object.c | 240 ++++++++++++--------------------------- libindicator/indicator-object.h | 12 +- tests/Makefile.am | 23 +++- tests/dummy-indicator-signaler.c | 2 + tests/dummy-indicator-visible.c | 139 +++++++++++++++++++++++ tests/test-loader.c | 90 +++++++++++++++ 6 files changed, 337 insertions(+), 169 deletions(-) create mode 100644 tests/dummy-indicator-visible.c diff --git a/libindicator/indicator-object.c b/libindicator/indicator-object.c index f4a4265..8deb706 100644 --- a/libindicator/indicator-object.c +++ b/libindicator/indicator-object.c @@ -32,19 +32,18 @@ License along with this library. If not, see /** @ENTRY_INIT: The entry hasn't been initialized yet, so its - visibility will depend upon the inital-visibility property - and the 'visible' setting in the optional GSettings schema-id - @ENTRY_CLOAKED: The entry has been initialized but is not visible + 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_CLOAKED, - ENTRY_VISIBLE + ENTRY_VISIBLE, + ENTRY_INVISIBLE } EntryVisibility; -typedef struct IndicatorObjectEntryPrivate { +typedef struct _IndicatorObjectEntryPrivate { EntryVisibility visibility; } IndicatorObjectEntryPrivate; @@ -68,10 +67,6 @@ struct _IndicatorObjectPrivate { IndicatorObjectEntry entry; gboolean gotten_entries; - /* For indicator objects that monitor a GSettings schema-id */ - GSettings * gsettings; - gchar * gsettings_schema_id; - /* Whether or not entries are visible by default */ gboolean default_visibility; GHashTable * entry_privates; @@ -115,16 +110,14 @@ static void indicator_object_finalize (GObject *object); static void set_property (GObject*, guint prop_id, const GValue*, GParamSpec* ); static void get_property (GObject*, guint prop_id, GValue*, GParamSpec* ); -/* GSettings schema handling */ -static void schema_clear (IndicatorObject* ); -static void schema_set (IndicatorObject* , const char * schema_id); - /* entries' visibility */ -static void on_entry_added (IndicatorObject*, IndicatorObjectEntry*, gpointer); -static void on_entry_removed(IndicatorObject*, IndicatorObjectEntry*, gpointer); -static void decloak_entry (IndicatorObject*, IndicatorObjectEntry*); -static GList * get_entries_default (IndicatorObject*); -static GList * get_all_entries (IndicatorObject*); +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); @@ -148,6 +141,8 @@ indicator_object_class_init (IndicatorObjectClass *klass) 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; /** IndicatorObject::entry-added: @@ -293,15 +288,7 @@ indicator_object_class_init (IndicatorObjectClass *klass) /* Properties */ - GParamSpec * pspec; - pspec = g_param_spec_string (INDICATOR_OBJECT_GSETTINGS_SCHEMA_ID, - "schema id", - "The schema-id of the GSettings (if any) to monitor.", - NULL, - G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS); - g_object_class_install_property (object_class, PROP_GSETTINGS_SCHEMA_ID, pspec); - - pspec = g_param_spec_boolean (INDICATOR_OBJECT_DEFAULT_VISIBILITY, + GParamSpec * pspec = g_param_spec_boolean (INDICATOR_OBJECT_DEFAULT_VISIBILITY, "default visibility", "Whether or not entries should initially be visible.", TRUE, @@ -329,19 +316,15 @@ indicator_object_init (IndicatorObject *self) priv->environments = NULL; - priv->gsettings = NULL; - priv->gsettings_schema_id = NULL; - self->priv = priv; - /* Listen for entries to be added/removed so that we can manage them. - By being first in line for the "removed" signal we can cloak the - entry before the client code destroys its widgetry... */ GObject * o = G_OBJECT(self); + /* Invoke the entry-being-removed virtual function first */ g_signal_connect (o, INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED, - G_CALLBACK(on_entry_removed), NULL); + 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(on_entry_added), NULL); + G_CALLBACK(indicator_object_entry_was_added), NULL); } /* Unref the objects that we're holding on to. */ @@ -350,21 +333,18 @@ indicator_object_dispose (GObject *object) { IndicatorObject * io = INDICATOR_OBJECT(object); - /* stop listening to schema changes */ - schema_clear (io); - - /* decloak any cloaked entries so they won't leak */ + /* 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); - for (l=entries; l!=NULL; l=l->next) - decloak_entry (io, l->data); - g_list_free (entries); - - /* destroy the EntryPrivate hashtable */ - if (io->priv && io->priv->entry_privates) { - g_hash_table_destroy (io->priv->entry_privates); - io->priv->entry_privates = NULL; + 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); } @@ -387,6 +367,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; @@ -575,7 +560,7 @@ get_all_entries (IndicatorObject * io) } /* get the private structure that corresponds to a caller-specified entry */ -IndicatorObjectEntryPrivate * +static IndicatorObjectEntryPrivate * entry_get_private (IndicatorObject * io, IndicatorObjectEntry * entry) { g_return_val_if_fail (INDICATOR_IS_OBJECT(io), NULL); @@ -593,22 +578,6 @@ entry_get_private (IndicatorObject * io, IndicatorObjectEntry * entry) return priv; } -/* Returns whether or not entries should be shown by default on startup. - This is usually 'true', but can be changed via GSettings and/or by the - INDICATOR_OBJECT_DEFAULT_VISIBILITY property. */ -static gboolean -get_default_visibility (IndicatorObject * io) -{ - g_return_val_if_fail (INDICATOR_IS_OBJECT(io), FALSE); - IndicatorObjectPrivate * priv = INDICATOR_OBJECT_GET_PRIVATE(io); - g_return_val_if_fail (priv != NULL, FALSE); - - if (priv->gsettings != NULL) - return g_settings_get_boolean (priv->gsettings, "visible"); - - return priv->default_visibility; -} - /** indicator_object_get_entries: @io: #IndicatorObject to query @@ -628,6 +597,7 @@ indicator_object_get_entries (IndicatorObject * 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) { @@ -635,17 +605,18 @@ indicator_object_get_entries (IndicatorObject * io) IndicatorObjectEntry * entry = l->data; switch (entry_get_private(io,entry)->visibility) { - case ENTRY_VISIBLE: show_me = TRUE; break; - case ENTRY_CLOAKED: show_me = FALSE; break; - default: show_me = get_default_visibility (io); break; + 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 (show_me) - ret = g_list_append (ret, entry); + ret = g_list_prepend (ret, entry); } g_list_free (all_entries); - return ret; + return g_list_reverse (ret); } /** @@ -743,6 +714,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 @@ -825,16 +820,14 @@ indicator_object_check_environment (IndicatorObject * io, const gchar * env) void indicator_object_set_visible (IndicatorObject * io, gboolean visible) { - GList * l; - GList * entries; - const char * name = visible ? INDICATOR_OBJECT_SIGNAL_ENTRY_ADDED - : INDICATOR_OBJECT_SIGNAL_ENTRY_REMOVED; - g_return_if_fail(INDICATOR_IS_OBJECT(io)); - entries = get_all_entries (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_by_name (io, name, l->data); + g_signal_emit(io, signal_id, detail, l->data); g_list_free (entries); } @@ -852,14 +845,6 @@ get_property (GObject * object, switch (prop_id) { /* *********************** */ - case PROP_GSETTINGS_SCHEMA_ID: - if (G_VALUE_HOLDS_STRING(value)) { - g_value_set_string(value, priv->gsettings_schema_id); - } else { - g_warning("schema-id property requires a string value."); - } - break; - /* *********************** */ case PROP_DEFAULT_VISIBILITY: if (G_VALUE_HOLDS_BOOLEAN(value)) { g_value_set_boolean(value, priv->default_visibility); @@ -889,15 +874,6 @@ set_property (GObject * object, switch (prop_id) { - /* *********************** */ - case PROP_GSETTINGS_SCHEMA_ID: - if (G_VALUE_HOLDS_STRING(value)) { - schema_set (self, g_value_get_string (value)); - } else { - g_warning("schema-id property requires a string value."); - } - break; - /* *********************** */ case PROP_DEFAULT_VISIBILITY: if (G_VALUE_HOLDS_BOOLEAN(value)) { @@ -918,58 +894,9 @@ set_property (GObject * object, **** ***/ -static void -on_settings_changed (GSettings * gsettings, gchar * key, gpointer user_data) -{ - if (!g_strcmp0 (key, "visible")) { - IndicatorObject * io = INDICATOR_OBJECT (user_data); - gboolean visible = g_settings_get_boolean (gsettings, key); - indicator_object_set_visible (io, visible); - } -} - -static void -schema_clear (IndicatorObject * self) -{ - IndicatorObjectPrivate * priv = INDICATOR_OBJECT_GET_PRIVATE(self); - g_return_if_fail (priv != NULL); - - if (priv->gsettings != NULL) { - g_object_unref (priv->gsettings); - priv->gsettings = NULL; - } - - if (priv->gsettings_schema_id != NULL) { - g_free (priv->gsettings_schema_id); - priv->gsettings_schema_id = NULL; - } -} - -static void -schema_set (IndicatorObject * object, const char * gsettings_schema_id) -{ - schema_clear (object); - - IndicatorObjectPrivate * priv = INDICATOR_OBJECT_GET_PRIVATE(object); - g_return_if_fail (priv != NULL); - - priv->gsettings_schema_id = g_strdup (gsettings_schema_id); - if (priv->gsettings_schema_id != NULL) { - priv->gsettings = g_settings_new (priv->gsettings_schema_id); - } - if (priv->gsettings != NULL) { - g_signal_connect (G_OBJECT(priv->gsettings), "changed", - G_CALLBACK(on_settings_changed), object); - } -} - -/*** -**** -***/ - /* Cloaked entries are ones which are hidden but may be re-added later. - We cloak them by reffing them + unparenting to ensure their survival - even if their gtk parent's widgetry is destroyed */ + 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 @@ -977,33 +904,20 @@ decloak_widget (gpointer w) { if (w != NULL) { GObject * o = G_OBJECT(w); - if (g_object_get_data(o, CLOAKED_KEY)) { - g_object_steal_data (o, CLOAKED_KEY); + if (g_object_steal_data (o, CLOAKED_KEY) != NULL) { g_object_unref (o); } } } static void -decloak_entry (IndicatorObject * io, IndicatorObjectEntry * entry) +entry_was_added_default (IndicatorObject * io, IndicatorObjectEntry * entry) { - entry_get_private (io, entry)->visibility = ENTRY_VISIBLE; - decloak_widget (entry->image); decloak_widget (entry->label); decloak_widget (entry->menu); } -static void -on_entry_added (IndicatorObject * io, - IndicatorObjectEntry * entry, - gpointer unused G_GNUC_UNUSED) -{ - decloak_entry (io, entry); -} - -/* The panels like to destroy an entry's widgetry when it's removed. - Protect the image, label, and menu for future reuse */ static void cloak_widget (gpointer w) { @@ -1028,12 +942,8 @@ cloak_widget (gpointer w) } static void -on_entry_removed (IndicatorObject * io, - IndicatorObjectEntry * entry, - gpointer unused G_GNUC_UNUSED) +entry_being_removed_default (IndicatorObject * io, IndicatorObjectEntry * entry) { - entry_get_private(io,entry)->visibility = ENTRY_CLOAKED; - 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 a46600f..803f1b3 100644 --- a/libindicator/indicator-object.h +++ b/libindicator/indicator-object.h @@ -60,9 +60,6 @@ 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 GSettings schema-id property */ -#define INDICATOR_OBJECT_GSETTINGS_SCHEMA_ID "indicator-object-gsettings-schema-id" - /* the name of the property to decide whether or not entries are visible by default */ #define INDICATOR_OBJECT_DEFAULT_VISIBILITY "indicator-object-default-visibility" @@ -97,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. @@ -123,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_close) (IndicatorObject * io, IndicatorObjectEntry * entry, guint timestamp); diff --git a/tests/Makefile.am b/tests/Makefile.am index f11a9d1..a70ee58 100644 --- a/tests/Makefile.am +++ b/tests/Makefile.am @@ -14,7 +14,8 @@ lib_LTLIBRARIES = \ libdummy-indicator-blank.la \ libdummy-indicator-null.la \ libdummy-indicator-signaler.la \ - libdummy-indicator-simple.la + libdummy-indicator-simple.la \ + libdummy-indicator-visible.la DBUS_RUNNER=dbus-test-runner --dbus-config /usr/share/dbus-test-runner/session.conf XVFB_RUN=". $(srcdir)/run-xvfb.sh" @@ -161,6 +162,26 @@ libdummy_indicator_simple_la_LDFLAGS = \ -module \ -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 + +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 +. +*/ + +#include +#include + +#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 ac9d4e5..51ea6f3 100644 --- a/tests/test-loader.c +++ b/tests/test-loader.c @@ -68,6 +68,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) { @@ -174,6 +263,7 @@ test_loader_creation_deletion_suite (void) g_test_add_func ("/libindicator/loader/dummy/simple_accessors", test_loader_filename_dummy_simple_accessors); g_test_add_func ("/libindicator/loader/dummy/simple_location", test_loader_filename_dummy_simple_location); g_test_add_func ("/libindicator/loader/dummy/signaler", test_loader_filename_dummy_signaler); + g_test_add_func ("/libindicator/loader/dummy/visible", test_loader_filename_dummy_visible); return; } -- cgit v1.2.3