Support a set of defaults and not sending them over the bus.

4 files changed, 468 insertions, 8 deletions

diff --git a/libdbusmenu-glib/Makefile.am b/libdbusmenu-glib/Makefile.am
index 92de502..5ddbeb8 100644
--- a/libdbusmenu-glib/Makefile.am
+++ b/libdbusmenu-glib/Makefile.am
@@ -24,6 +24,8 @@ libdbusmenu_glibinclude_HEADERS = \
 libdbusmenu_glib_la_SOURCES = \
 	dbus-menu-clean.xml.h \
 	dbus-menu-clean.xml.c \
+	defaults.h \
+	defaults.c \
 	menuitem.h \
 	menuitem.c \
 	menuitem-marshal.h \
diff --git a/libdbusmenu-glib/defaults.c b/libdbusmenu-glib/defaults.c
new file mode 100644
index 0000000..3ad5d76
--- /dev/null
+++ b/libdbusmenu-glib/defaults.c
@@ -0,0 +1,291 @@
+/*
+A library to communicate a menu object set accross DBus and
+track updates and maintain consistency.
+
+Copyright 2011 Canonical Ltd.
+
+Authors:
+    Ted Gould <ted@canonical.com>
+
+This program is free software: you can redistribute it and/or modify it 
+under the terms of either or both of the following licenses:
+
+1) the GNU Lesser General Public License version 3, as published by the 
+Free Software Foundation; and/or
+2) the GNU Lesser General Public License version 2.1, as published by 
+the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful, but 
+WITHOUT ANY WARRANTY; without even the implied warranties of 
+MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR 
+PURPOSE.  See the applicable version of the GNU Lesser General Public 
+License for more details.
+
+You should have received a copy of both the GNU Lesser General Public 
+License version 3 and version 2.1 along with this program.  If not, see 
+<http://www.gnu.org/licenses/>
+*/
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include <glib/gi18n.h>
+
+#include "defaults.h"
+#include "menuitem.h"
+#include "client.h"
+
+struct _DbusmenuDefaultsPrivate {
+	GHashTable * types;
+};
+
+typedef struct _DefaultEntry DefaultEntry;
+struct _DefaultEntry {
+	GVariantType * type;
+	GVariant * value;
+};
+
+#define DBUSMENU_DEFAULTS_GET_PRIVATE(o) \
+(G_TYPE_INSTANCE_GET_PRIVATE ((o), DBUSMENU_TYPE_DEFAULTS, DbusmenuDefaultsPrivate))
+
+static void dbusmenu_defaults_class_init (DbusmenuDefaultsClass *klass);
+static void dbusmenu_defaults_init       (DbusmenuDefaults *self);
+static void dbusmenu_defaults_dispose    (GObject *object);
+static void dbusmenu_defaults_finalize   (GObject *object);
+
+static DefaultEntry * entry_create (const GVariantType * type, GVariant * variant);
+static void entry_destroy (gpointer entry);
+
+G_DEFINE_TYPE (DbusmenuDefaults, dbusmenu_defaults, G_TYPE_OBJECT);
+
+static void
+dbusmenu_defaults_class_init (DbusmenuDefaultsClass *klass)
+{
+	GObjectClass *object_class = G_OBJECT_CLASS (klass);
+
+	g_type_class_add_private (klass, sizeof (DbusmenuDefaultsPrivate));
+
+	object_class->dispose = dbusmenu_defaults_dispose;
+	object_class->finalize = dbusmenu_defaults_finalize;
+	return;
+}
+
+static void
+dbusmenu_defaults_init (DbusmenuDefaults *self)
+{
+	self->priv = DBUSMENU_DEFAULTS_GET_PRIVATE(self); 
+
+	self->priv->types = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, (GDestroyNotify)g_hash_table_destroy);
+
+	/* Standard defaults */
+	dbusmenu_defaults_default_set(self,   DBUSMENU_CLIENT_TYPES_DEFAULT,    DBUSMENU_MENUITEM_PROP_VISIBLE,        G_VARIANT_TYPE_BOOLEAN,   g_variant_new_boolean(TRUE)); 
+	dbusmenu_defaults_default_set(self,   DBUSMENU_CLIENT_TYPES_DEFAULT,    DBUSMENU_MENUITEM_PROP_ENABLED,        G_VARIANT_TYPE_BOOLEAN,   g_variant_new_boolean(TRUE)); 
+	dbusmenu_defaults_default_set(self,   DBUSMENU_CLIENT_TYPES_DEFAULT,    DBUSMENU_MENUITEM_PROP_LABEL,          G_VARIANT_TYPE_STRING,    g_variant_new_string(_("Label Empty"))); 
+	dbusmenu_defaults_default_set(self,   DBUSMENU_CLIENT_TYPES_DEFAULT,    DBUSMENU_MENUITEM_PROP_ICON_NAME,      G_VARIANT_TYPE_STRING,    NULL); 
+	dbusmenu_defaults_default_set(self,   DBUSMENU_CLIENT_TYPES_DEFAULT,    DBUSMENU_MENUITEM_PROP_TOGGLE_TYPE,    G_VARIANT_TYPE_STRING,    NULL); 
+	dbusmenu_defaults_default_set(self,   DBUSMENU_CLIENT_TYPES_DEFAULT,    DBUSMENU_MENUITEM_PROP_TOGGLE_STATE,   G_VARIANT_TYPE_INT32,     NULL); 
+	dbusmenu_defaults_default_set(self,   DBUSMENU_CLIENT_TYPES_DEFAULT,    DBUSMENU_MENUITEM_PROP_SHORTCUT,       G_VARIANT_TYPE_ARRAY,     NULL); 
+	dbusmenu_defaults_default_set(self,   DBUSMENU_CLIENT_TYPES_DEFAULT,    DBUSMENU_MENUITEM_PROP_CHILD_DISPLAY,  G_VARIANT_TYPE_STRING,    NULL); 
+
+	/* Separator defaults */
+	dbusmenu_defaults_default_set(self,   DBUSMENU_CLIENT_TYPES_SEPARATOR,  DBUSMENU_MENUITEM_PROP_VISIBLE,        G_VARIANT_TYPE_BOOLEAN,   g_variant_new_boolean(TRUE)); 
+
+	return;
+}
+
+static void
+dbusmenu_defaults_dispose (GObject *object)
+{
+	DbusmenuDefaults * self = DBUSMENU_DEFAULTS(object);
+
+	if (self->priv->types != NULL) {
+		g_hash_table_destroy(self->priv->types);
+		self->priv->types = NULL;
+	}
+
+	G_OBJECT_CLASS (dbusmenu_defaults_parent_class)->dispose (object);
+	return;
+}
+
+static void
+dbusmenu_defaults_finalize (GObject *object)
+{
+
+	G_OBJECT_CLASS (dbusmenu_defaults_parent_class)->finalize (object);
+	return;
+}
+
+/* Create a new entry based on the info provided */
+static DefaultEntry *
+entry_create (const GVariantType * type, GVariant * variant)
+{
+	DefaultEntry * defentry = g_new0(DefaultEntry, 1);
+
+	if (type != NULL) {
+		defentry->type = g_variant_type_copy(type);
+	}
+
+	if (variant != NULL) {
+		defentry->value = variant;
+		g_variant_ref_sink(variant);
+	}
+
+	return defentry;
+}
+
+/* Destroy an entry */
+static void
+entry_destroy (gpointer entry)
+{
+	DefaultEntry * defentry = (DefaultEntry *)entry;
+
+	if (defentry->type != NULL) {
+		g_variant_type_free(defentry->type);
+		defentry->type = NULL;
+	}
+
+	if (defentry->value != NULL) {
+		g_variant_unref(defentry->value);
+		defentry->value = NULL;
+	}
+
+	g_free(defentry);
+	return;
+}
+
+static DbusmenuDefaults * default_defaults = NULL;
+
+/**
+ * dbusmenu_defaults_ref_default:
+ *
+ * Get a reference to the default instance.  If it doesn't exist this
+ * function will create it.
+ *
+ * Return value: (transfer full): A reference to the defaults
+ */
+DbusmenuDefaults *
+dbusmenu_defaults_ref_default (void)
+{
+	if (default_defaults == NULL) {
+		default_defaults = DBUSMENU_DEFAULTS(g_object_new(DBUSMENU_TYPE_DEFAULTS, NULL));
+		g_object_add_weak_pointer(G_OBJECT(default_defaults), (gpointer *)&default_defaults);
+	} else {
+		g_object_ref(default_defaults);
+	}
+
+	return default_defaults;
+}
+
+/**
+ * dbusmenu_defaults_default_set:
+ * @defaults: The #DbusmenuDefaults object to add to
+ * @type: (allow-none): The #DbusmenuMenuitem type for this default if #NULL will default to #DBUSMENU_CLIENT_TYPE_DEFAULT
+ * @property: Property name for the default
+ * @prop_type: (allow-none): Type of the property for runtime checking.  To disable checking set to #NULL.
+ * @value: (allow-none): Default value for @property.  #NULL if by default it is unset, but you want type checking from @prop_type.
+ *
+ * Sets up an entry in the defaults database for a given @property
+ * and menuitem type @type.  @prop_type and @value can both be #NULL
+ * but both of them can not.
+ */
+void
+dbusmenu_defaults_default_set (DbusmenuDefaults * defaults, const gchar * type, const gchar * property, const GVariantType * prop_type, GVariant * value)
+{
+	g_return_if_fail(DBUSMENU_IS_DEFAULTS(defaults));
+	g_return_if_fail(property != NULL);
+	g_return_if_fail(prop_type != NULL || value != NULL);
+
+	if (type == NULL) {
+		type = DBUSMENU_CLIENT_TYPES_DEFAULT;
+	}
+
+	GHashTable * prop_table = (GHashTable *)g_hash_table_lookup(defaults->priv->types, type);
+
+	/* We've never had a default for this type, so we need
+	   to create a table for it. */
+	if (prop_table == NULL) {
+		prop_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, entry_destroy);
+
+		g_hash_table_insert(prop_table, g_strdup(property), entry_create(prop_type, value));
+		g_hash_table_insert(defaults->priv->types, g_strdup(type), prop_table);
+	} else {
+		g_hash_table_replace(prop_table, g_strdup(property), entry_create(prop_type, value));
+	}
+
+	return;
+}
+
+/**
+ * dbusmenu_defaults_default_get:
+ * @defaults: The default database to use
+ * @type: (allow-none): The #DbusmenuMenuitem type for this default if #NULL will default to #DBUSMENU_CLIENT_TYPE_DEFAULT
+ * @property: Property name to lookup
+ *
+ * Gets an entry in the database for a give @property and @type.
+ *
+ * Return value: (transfer none): Returns a variant that does not
+ * have it's ref count increased.  If you want to keep it, you should
+ * do that.
+ */
+GVariant *
+dbusmenu_defaults_default_get (DbusmenuDefaults * defaults, const gchar * type, const gchar * property)
+{
+	g_return_val_if_fail(DBUSMENU_IS_DEFAULTS(defaults), NULL);
+	g_return_val_if_fail(property != NULL, NULL);
+
+	if (type == NULL) {
+		type = DBUSMENU_CLIENT_TYPES_DEFAULT;
+	}
+
+	GHashTable * prop_table = (GHashTable *)g_hash_table_lookup(defaults->priv->types, type);
+
+	if (prop_table == NULL) {
+		return NULL;
+	}
+
+	DefaultEntry * entry = (DefaultEntry *)g_hash_table_lookup(prop_table, property);
+
+	if (entry == NULL) {
+		return NULL;
+	}
+
+	return entry->value;
+}
+
+/**
+ * dbusmenu_defaults_default_get_type:
+ * @defaults: The default database to use
+ * @type: (allow-none): The #DbusmenuMenuitem type for this default if #NULL will default to #DBUSMENU_CLIENT_TYPE_DEFAULT
+ * @property: Property name to lookup
+ *
+ * Gets the type for an entry in the database for a give @property and @type.
+ *
+ * Return value: (transfer none): Returns a type for the given
+ * @property value.
+ */
+GVariantType *
+dbusmenu_defaults_default_get_type (DbusmenuDefaults * defaults, const gchar * type, const gchar * property)
+{
+	g_return_val_if_fail(DBUSMENU_IS_DEFAULTS(defaults), NULL);
+	g_return_val_if_fail(property != NULL, NULL);
+
+	if (type == NULL) {
+		type = DBUSMENU_CLIENT_TYPES_DEFAULT;
+	}
+
+	GHashTable * prop_table = (GHashTable *)g_hash_table_lookup(defaults->priv->types, type);
+
+	if (prop_table == NULL) {
+		return NULL;
+	}
+
+	DefaultEntry * entry = (DefaultEntry *)g_hash_table_lookup(prop_table, property);
+
+	if (entry == NULL) {
+		return NULL;
+	}
+
+	return entry->type;
+}
+
diff --git a/libdbusmenu-glib/defaults.h b/libdbusmenu-glib/defaults.h
new file mode 100644
index 0000000..ab377f7
--- /dev/null
+++ b/libdbusmenu-glib/defaults.h
@@ -0,0 +1,86 @@
+/*
+A library to communicate a menu object set accross DBus and
+track updates and maintain consistency.
+
+Copyright 2011 Canonical Ltd.
+
+Authors:
+    Ted Gould <ted@canonical.com>
+
+This program is free software: you can redistribute it and/or modify it 
+under the terms of either or both of the following licenses:
+
+1) the GNU Lesser General Public License version 3, as published by the 
+Free Software Foundation; and/or
+2) the GNU Lesser General Public License version 2.1, as published by 
+the Free Software Foundation.
+
+This program is distributed in the hope that it will be useful, but 
+WITHOUT ANY WARRANTY; without even the implied warranties of 
+MERCHANTABILITY, SATISFACTORY QUALITY or FITNESS FOR A PARTICULAR 
+PURPOSE.  See the applicable version of the GNU Lesser General Public 
+License for more details.
+
+You should have received a copy of both the GNU Lesser General Public 
+License version 3 and version 2.1 along with this program.  If not, see 
+<http://www.gnu.org/licenses/>
+*/
+
+#ifndef __DBUSMENU_DEFAULTS_H__
+#define __DBUSMENU_DEFAULTS_H__
+
+#include <glib.h>
+#include <glib-object.h>
+
+G_BEGIN_DECLS
+
+#define DBUSMENU_TYPE_DEFAULTS            (dbusmenu_defaults_get_type ())
+#define DBUSMENU_DEFAULTS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), DBUSMENU_TYPE_DEFAULTS, DbusmenuDefaults))
+#define DBUSMENU_DEFAULTS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), DBUSMENU_TYPE_DEFAULTS, DbusmenuDefaultsClass))
+#define DBUSMENU_IS_DEFAULTS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), DBUSMENU_TYPE_DEFAULTS))
+#define DBUSMENU_IS_DEFAULTS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), DBUSMENU_TYPE_DEFAULTS))
+#define DBUSMENU_DEFAULTS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), DBUSMENU_TYPE_DEFAULTS, DbusmenuDefaultsClass))
+
+typedef struct _DbusmenuDefaults        DbusmenuDefaults;
+typedef struct _DbusmenuDefaultsClass   DbusmenuDefaultsClass;
+typedef struct _DbusmenuDefaultsPrivate DbusmenuDefaultsPrivate;
+
+/**
+ * DbusmenuDefaultsClass:
+ *
+ * All of the signals and functions for #DbusmenuDefaults
+ */
+struct _DbusmenuDefaultsClass {
+	GObjectClass parent_class;
+};
+
+/**
+ * DbusmenuDefaults:
+ *
+ * A singleton to hold all of the defaults for the menuitems
+ * so they can use those easily.
+ */
+struct _DbusmenuDefaults {
+	GObject parent;
+
+	/*< Private >*/
+	DbusmenuDefaultsPrivate * priv;
+};
+
+GType                 dbusmenu_defaults_get_type             (void);
+DbusmenuDefaults *    dbusmenu_defaults_ref_default          (void);
+void                  dbusmenu_defaults_default_set          (DbusmenuDefaults * defaults,
+                                                              const gchar * type,
+                                                              const gchar * property,
+                                                              const GVariantType * prop_type,
+                                                              GVariant * value);
+GVariant *            dbusmenu_defaults_default_get          (DbusmenuDefaults * defaults,
+                                                              const gchar * type,
+                                                              const gchar * property);
+GVariantType *        dbusmenu_defaults_default_get_type     (DbusmenuDefaults * defaults,
+                                                              const gchar * type,
+                                                              const gchar * property);
+
+G_END_DECLS
+
+#endif
diff --git a/libdbusmenu-glib/menuitem.c b/libdbusmenu-glib/menuitem.c
index c994130..ee18fab 100644
--- a/libdbusmenu-glib/menuitem.c
+++ b/libdbusmenu-glib/menuitem.c
@@ -33,6 +33,7 @@ License version 3 and version 2.1 along with this program.  If not, see
 #include "menuitem.h"
 #include "menuitem-marshal.h"
 #include "menuitem-private.h"
+#include "defaults.h"
 
 #ifdef MASSIVEDEBUGGING
 #define LABEL(x)  dbusmenu_menuitem_property_get(DBUSMENU_MENUITEM(x), DBUSMENU_MENUITEM_PROP_LABEL)
@@ -59,6 +60,7 @@ struct _DbusmenuMenuitemPrivate
 	GHashTable * properties;
 	gboolean root;
 	gboolean realized;
+	DbusmenuDefaults * defaults;
 };
 
 /* Signals */
@@ -312,6 +314,8 @@ dbusmenu_menuitem_init (DbusmenuMenuitem *self)
 
 	priv->root = FALSE;
 	priv->realized = FALSE;
+
+	priv->defaults = dbusmenu_defaults_ref_default();
 	
 	return;
 }
@@ -328,6 +332,11 @@ dbusmenu_menuitem_dispose (GObject *object)
 	g_list_free(priv->children);
 	priv->children = NULL;
 
+	if (priv->defaults != NULL) {
+		g_object_unref(priv->defaults);
+		priv->defaults = NULL;
+	}
+
 	G_OBJECT_CLASS (dbusmenu_menuitem_parent_class)->dispose (object);
 	return;
 }
@@ -425,6 +434,19 @@ send_about_to_show (DbusmenuMenuitem * mi, void (*cb) (DbusmenuMenuitem * mi, gp
 	return;
 }
 
+/* A helper function to get the type of the menuitem, this might
+   be a candidate for optimization in the future. */
+static const gchar *
+menuitem_get_type (DbusmenuMenuitem * mi)
+{
+	DbusmenuMenuitemPrivate * priv = DBUSMENU_MENUITEM_GET_PRIVATE(mi);
+	GVariant * currentval = (GVariant *)g_hash_table_lookup(priv->properties, DBUSMENU_MENUITEM_PROP_TYPE);
+	if (currentval != NULL) {
+		return g_variant_get_string(currentval, NULL);
+	}
+	return NULL;
+}
+
 /* Public interface */
 
 /**
@@ -1004,17 +1026,49 @@ dbusmenu_menuitem_property_set_variant (DbusmenuMenuitem * mi, const gchar * pro
 
 	DbusmenuMenuitemPrivate * priv = DBUSMENU_MENUITEM_GET_PRIVATE(mi);
 
+	const gchar * type = menuitem_get_type(mi);
+
+	/* Check the expected type to see if we want to have a warning */
+	GVariantType * default_type = dbusmenu_defaults_default_get_type(priv->defaults, type, property);
+	if (default_type != NULL) {
+		/* If we have an expected type we should check to see if
+		   the value we've been given is of the same type and generate
+		   a warning if it isn't */
+		if (!g_variant_is_of_type(value, default_type)) {
+			g_warning("Setting menuitem property '%s' with value of type '%s' when expecting '%s'", property, g_variant_get_type_string(value), g_variant_type_peek_string(default_type));
+		}
+	}
+
+	/* Check the defaults database to see if we have a default
+	   for this property. */
+	GVariant * default_value = dbusmenu_defaults_default_get(priv->defaults, type, property);
+	if (default_value != NULL) {
+		/* Now see if we're setting this to the same value as the
+		   default.  If we are then we just want to swallow this variant
+		   and make the function behave like we're clearing it. */
+		if (g_variant_equal(default_value, value)) {
+			g_variant_ref_sink(value);
+			g_variant_unref(value);
+			value = NULL;
+		}
+	}
+
 	gboolean replaced = FALSE;
 	gpointer currentval = g_hash_table_lookup(priv->properties, property);
 
 	if (value != NULL) {
-		gchar * lprop = g_strdup(property);
-		g_variant_ref_sink(value);
-
+		/* NOTE: We're only marking this as replaced if this is true
+		   but we're actually replacing it no matter.  This is so that
+		   the variant passed in sticks around which the caller may
+		   expect.  They shouldn't, but it's low cost to remove bugs. */
 		if (currentval == NULL || !g_variant_equal((GVariant*)currentval, value)) {
-			g_hash_table_replace(priv->properties, lprop, value);
 			replaced = TRUE;
 		}
+
+		gchar * lprop = g_strdup(property);
+		g_variant_ref_sink(value);
+
+		g_hash_table_replace(priv->properties, lprop, value);
 	} else {
 		if (currentval != NULL) {
 			g_hash_table_remove(priv->properties, property);
@@ -1027,7 +1081,15 @@ dbusmenu_menuitem_property_set_variant (DbusmenuMenuitem * mi, const gchar * pro
 	   table.  But the fact that there was a value is
 	   the imporant part. */
 	if (currentval == NULL || replaced) {
-		g_signal_emit(G_OBJECT(mi), signals[PROPERTY_CHANGED], 0, property, value, TRUE);
+		GVariant * signalval = value;
+
+		if (signalval == NULL) {
+			/* Might also be NULL, but if it is we're definitely
+			   clearing this thing. */
+			signalval = default_value;
+		}
+
+		g_signal_emit(G_OBJECT(mi), signals[PROPERTY_CHANGED], 0, property, signalval, TRUE);
 	}
 
 	return TRUE;
@@ -1074,7 +1136,13 @@ dbusmenu_menuitem_property_get_variant (DbusmenuMenuitem * mi, const gchar * pro
 
 	DbusmenuMenuitemPrivate * priv = DBUSMENU_MENUITEM_GET_PRIVATE(mi);
 
-	return (GVariant *)g_hash_table_lookup(priv->properties, property);
+	GVariant * currentval = (GVariant *)g_hash_table_lookup(priv->properties, property);
+
+	if (currentval == NULL) {
+		currentval = dbusmenu_defaults_default_get(priv->defaults, menuitem_get_type(mi), property);
+	}
+
+	return currentval;
 }
 
 /**
@@ -1503,10 +1571,23 @@ dbusmenu_menuitem_show_to_user (DbusmenuMenuitem * mi, guint timestamp)
 
 /* Checks to see if the value of this property is unique or just the
    default value. */
-/* TODO: Implement this */
 gboolean
 dbusmenu_menuitem_property_is_default (DbusmenuMenuitem * mi, const gchar * property)
 {
-	/* No defaults system yet */
+	g_return_val_if_fail(DBUSMENU_IS_MENUITEM(mi), FALSE);
+	DbusmenuMenuitemPrivate * priv = DBUSMENU_MENUITEM_GET_PRIVATE(mi);
+
+	GVariant * currentval = (GVariant *)g_hash_table_lookup(priv->properties, property);
+	if (currentval != NULL) {
+		/* If we're storing it locally, then it shouldn't be a default */
+		return FALSE;
+	}
+
+	currentval = dbusmenu_defaults_default_get(priv->defaults, menuitem_get_type(mi), property);
+	if (currentval != NULL) {
+		return TRUE;
+	}
+
+	g_warn_if_reached();
 	return FALSE;
 }