moving from https://github.com/perberos/mate-desktop-environment

1 files changed, 3872 insertions, 0 deletions

diff --git a/libmate-desktop/mate-desktop-item.c b/libmate-desktop/mate-desktop-item.c
new file mode 100644
index 0000000..cf86a6d
--- /dev/null
+++ b/libmate-desktop/mate-desktop-item.c
@@ -0,0 +1,3872 @@
+/* -*- Mode: C; c-set-style: linux indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*- */
+/* mate-desktop-item.c - MATE Desktop File Representation
+
+   Copyright (C) 1999, 2000 Red Hat Inc.
+   Copyright (C) 2001 Sid Vicious
+   All rights reserved.
+
+   This file is part of the Mate Library.
+
+   Developed by Elliot Lee <[email protected]> and Sid Vicious
+
+   The Mate Library is free software; you can redistribute it and/or
+   modify it under the terms of the GNU Library General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   The Mate 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
+   Library General Public License for more details.
+
+   You should have received a copy of the GNU Library General Public
+   License along with the Mate Library; see the file COPYING.LIB.  If not,
+   write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.  */
+/*
+  @NOTATION@
+ */
+
+#include "config.h"
+
+#include <limits.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <glib.h>
+#include <sys/types.h>
+#include <dirent.h>
+#include <unistd.h>
+#include <time.h>
+#include <string.h>
+#include <glib/gi18n-lib.h>
+#include <locale.h>
+#include <stdlib.h>
+
+#include <gio/gio.h>
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+#define SN_API_NOT_YET_FROZEN
+#include <libsn/sn.h>
+#include <gdk/gdk.h>
+#include <gdk/gdkx.h>
+#include <gtk/gtk.h>
+#endif
+
+#define sure_string(s) ((s)!=NULL?(s):"")
+
+#define MATE_DESKTOP_USE_UNSTABLE_API
+#undef MATE_DISABLE_DEPRECATED
+#include <libmate/mate-desktop-item.h>
+#include <libmate/mate-desktop-utils.h>
+
+#include "private.h"
+
+struct _MateDesktopItem {
+	int refcount;
+
+	/* all languages used */
+	GList *languages;
+
+	MateDesktopItemType type;
+
+	/* `modified' means that the ditem has been
+	 * modified since the last save. */
+	gboolean modified;
+
+	/* Keys of the main section only */
+	GList *keys;
+
+	GList *sections;
+
+	/* This includes ALL keys, including
+	 * other sections, separated by '/' */
+	GHashTable *main_hash;
+
+	char *location;
+
+	time_t mtime;
+
+	guint32 launch_time;
+};
+
+/* If mtime is set to this, set_location won't update mtime,
+ * this is to be used internally only. */
+#define DONT_UPDATE_MTIME ((time_t)-2)
+
+typedef struct {
+	char *name;
+	GList *keys;
+} Section;
+
+typedef enum {
+	ENCODING_UNKNOWN,
+	ENCODING_UTF8,
+	ENCODING_LEGACY_MIXED
+} Encoding;
+
+/*
+ * IO reading utils, that look like the libc buffered io stuff
+ */
+
+#define READ_BUF_SIZE (32 * 1024)
+
+typedef struct {
+	GFile *file;
+	GFileInputStream *stream;
+	char *uri;
+	char *buf;
+	gboolean buf_needs_free;
+	gboolean past_first_read;
+	gboolean eof;
+	guint64 size;
+	gsize pos;
+} ReadBuf;
+
+static MateDesktopItem *ditem_load (ReadBuf           *rb,
+				     gboolean           no_translations,
+				     GError           **error);
+static gboolean          ditem_save (MateDesktopItem  *item,
+				     const char        *uri,
+				     GError           **error);
+
+static void mate_desktop_item_set_location_gfile (MateDesktopItem *item,
+						   GFile            *file);
+
+static MateDesktopItem *mate_desktop_item_new_from_gfile (GFile *file,
+							    MateDesktopItemLoadFlags flags,
+							    GError **error);
+
+static int
+readbuf_getc (ReadBuf *rb)
+{
+	if (rb->eof)
+		return EOF;
+
+	if (rb->size == 0 ||
+	    rb->pos == rb->size) {
+		gssize bytes_read;
+
+		if (rb->stream == NULL)
+			bytes_read = 0;
+		else
+			bytes_read = g_input_stream_read (G_INPUT_STREAM (rb->stream),
+							  rb->buf,
+							  READ_BUF_SIZE,
+							  NULL, NULL);
+
+		/* FIXME: handle errors other than EOF */
+		if (bytes_read <= 0) {
+			rb->eof = TRUE;
+			return EOF;
+		}
+
+		if (rb->size != 0)
+			rb->past_first_read = TRUE;
+		rb->size = bytes_read;
+		rb->pos = 0;
+
+	}
+
+	return (guchar) rb->buf[rb->pos++];
+}
+
+/* Note, does not include the trailing \n */
+static char *
+readbuf_gets (char *buf, gsize bufsize, ReadBuf *rb)
+{
+	int c;
+	gsize pos;
+
+	g_return_val_if_fail (buf != NULL, NULL);
+	g_return_val_if_fail (rb != NULL, NULL);
+
+	pos = 0;
+	buf[0] = '\0';
+
+	do {
+		c = readbuf_getc (rb);
+		if (c == EOF || c == '\n')
+			break;
+		buf[pos++] = c;
+	} while (pos < bufsize-1);
+
+	if (c == EOF && pos == 0)
+		return NULL;
+
+	buf[pos++] = '\0';
+
+	return buf;
+}
+
+static ReadBuf *
+readbuf_open (GFile *file, GError **error)
+{
+	GError *local_error;
+	GFileInputStream *stream;
+	char *uri;
+	ReadBuf *rb;
+
+	g_return_val_if_fail (file != NULL, NULL);
+
+	uri = g_file_get_uri (file);
+	local_error = NULL;
+	stream = g_file_read (file, NULL, &local_error);
+
+	if (stream == NULL) {
+		g_set_error (error,
+			     /* FIXME: better errors */
+			     MATE_DESKTOP_ITEM_ERROR,
+			     MATE_DESKTOP_ITEM_ERROR_CANNOT_OPEN,
+			     _("Error reading file '%s': %s"),
+			     uri, local_error->message);
+		g_error_free (local_error);
+		g_free (uri);
+		return NULL;
+	}
+
+	rb = g_new0 (ReadBuf, 1);
+	rb->stream = stream;
+	rb->file = g_file_dup (file);
+	rb->uri = uri;
+	rb->buf = g_malloc (READ_BUF_SIZE);
+	rb->buf_needs_free = TRUE;
+	/* rb->past_first_read = FALSE; */
+	/* rb->eof = FALSE; */
+	/* rb->size = 0; */
+	/* rb->pos = 0; */
+
+	return rb;
+}
+
+static ReadBuf *
+readbuf_new_from_string (const char *uri, const char *string, gssize length)
+{
+	ReadBuf *rb;
+
+	g_return_val_if_fail (string != NULL, NULL);
+	g_return_val_if_fail (length >= 0, NULL);
+
+	rb = g_new0 (ReadBuf, 1);
+	/* rb->file = NULL; */
+	/* rb->stream = NULL; */
+	rb->uri = g_strdup (uri);
+	rb->buf = (char *) string;
+	/* rb->buf_needs_free = FALSE; */
+	/* rb->past_first_read = FALSE; */
+	/* rb->eof = FALSE; */
+	rb->size = length;
+	/* rb->pos = 0; */
+
+	return rb;
+}
+
+static gboolean
+readbuf_rewind (ReadBuf *rb, GError **error)
+{
+	GError *local_error;
+
+	rb->eof = FALSE;
+	rb->pos = 0;
+
+	if (!rb->past_first_read)
+		return TRUE;
+
+	rb->size = 0;
+
+	if (g_seekable_seek (G_SEEKABLE (rb->stream),
+			     0, G_SEEK_SET, NULL, NULL))
+		return TRUE;
+
+	g_object_unref (rb->stream);
+	local_error = NULL;
+	rb->stream = g_file_read (rb->file, NULL, &local_error);
+
+	if (rb->stream == NULL) {
+		g_set_error (
+			error, MATE_DESKTOP_ITEM_ERROR,
+			MATE_DESKTOP_ITEM_ERROR_CANNOT_OPEN,
+			_("Error rewinding file '%s': %s"),
+			rb->uri, local_error->message);
+		g_error_free (local_error);
+
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static void
+readbuf_close (ReadBuf *rb)
+{
+	if (rb->stream != NULL)
+		g_object_unref (rb->stream);
+	if (rb->file != NULL)
+		g_object_unref (rb->file);
+	g_free (rb->uri);
+	if (rb->buf_needs_free)
+		g_free (rb->buf);
+	g_free (rb);
+}
+
+static MateDesktopItemType
+type_from_string (const char *type)
+{
+	if (!type)
+		return MATE_DESKTOP_ITEM_TYPE_NULL;
+
+	switch (type [0]) {
+	case 'A':
+		if (!strcmp (type, "Application"))
+			return MATE_DESKTOP_ITEM_TYPE_APPLICATION;
+		break;
+	case 'L':
+		if (!strcmp (type, "Link"))
+			return MATE_DESKTOP_ITEM_TYPE_LINK;
+		break;
+	case 'F':
+		if (!strcmp (type, "FSDevice"))
+			return MATE_DESKTOP_ITEM_TYPE_FSDEVICE;
+		break;
+	case 'M':
+		if (!strcmp (type, "MimeType"))
+			return MATE_DESKTOP_ITEM_TYPE_MIME_TYPE;
+		break;
+	case 'D':
+		if (!strcmp (type, "Directory"))
+			return MATE_DESKTOP_ITEM_TYPE_DIRECTORY;
+		break;
+	case 'S':
+		if (!strcmp (type, "Service"))
+			return MATE_DESKTOP_ITEM_TYPE_SERVICE;
+
+		else if (!strcmp (type, "ServiceType"))
+			return MATE_DESKTOP_ITEM_TYPE_SERVICE_TYPE;
+		break;
+	default:
+		break;
+	}
+
+	return MATE_DESKTOP_ITEM_TYPE_OTHER;
+}
+
+/**
+ * mate_desktop_item_new:
+ *
+ * Creates a MateDesktopItem object. The reference count on the returned value is set to '1'.
+ *
+ * Returns: The new MateDesktopItem
+ */
+MateDesktopItem *
+mate_desktop_item_new (void)
+{
+	MateDesktopItem *retval;
+
+	_mate_desktop_init_i18n ();
+
+	retval = g_new0 (MateDesktopItem, 1);
+
+	retval->refcount++;
+
+	retval->main_hash = g_hash_table_new_full (g_str_hash, g_str_equal,
+						   (GDestroyNotify) g_free,
+						   (GDestroyNotify) g_free);
+
+	/* These are guaranteed to be set */
+	mate_desktop_item_set_string (retval,
+				       MATE_DESKTOP_ITEM_NAME,
+				       /* Translators: the "name" mentioned
+					* here is the name of an application or
+					* a document */
+				       _("No name"));
+	mate_desktop_item_set_string (retval,
+				       MATE_DESKTOP_ITEM_ENCODING,
+				       "UTF-8");
+	mate_desktop_item_set_string (retval,
+				       MATE_DESKTOP_ITEM_VERSION,
+				       "1.0");
+
+	retval->launch_time = 0;
+
+	return retval;
+}
+
+static Section *
+dup_section (Section *sec)
+{
+	GList *li;
+	Section *retval = g_new0 (Section, 1);
+
+	retval->name = g_strdup (sec->name);
+
+	retval->keys = g_list_copy (sec->keys);
+	for (li = retval->keys; li != NULL; li = li->next)
+		li->data = g_strdup (li->data);
+
+	return retval;
+}
+
+static void
+copy_string_hash (gpointer key, gpointer value, gpointer user_data)
+{
+	GHashTable *copy = user_data;
+	g_hash_table_replace (copy,
+			      g_strdup (key),
+			      g_strdup (value));
+}
+
+
+/**
+ * mate_desktop_item_copy:
+ * @item: The item to be copied
+ *
+ * Creates a copy of a MateDesktopItem.  The new copy has a refcount of 1.
+ * Note: Section stack is NOT copied.
+ *
+ * Returns: The new copy
+ */
+MateDesktopItem *
+mate_desktop_item_copy (const MateDesktopItem *item)
+{
+	GList *li;
+	MateDesktopItem *retval;
+
+	g_return_val_if_fail (item != NULL, NULL);
+	g_return_val_if_fail (item->refcount > 0, NULL);
+
+	retval = mate_desktop_item_new ();
+
+	retval->type = item->type;
+	retval->modified = item->modified;
+	retval->location = g_strdup (item->location);
+	retval->mtime = item->mtime;
+	retval->launch_time = item->launch_time;
+
+	/* Languages */
+	retval->languages = g_list_copy (item->languages);
+	for (li = retval->languages; li != NULL; li = li->next)
+		li->data = g_strdup (li->data);
+
+	/* Keys */
+	retval->keys = g_list_copy (item->keys);
+	for (li = retval->keys; li != NULL; li = li->next)
+		li->data = g_strdup (li->data);
+
+	/* Sections */
+	retval->sections = g_list_copy (item->sections);
+	for (li = retval->sections; li != NULL; li = li->next)
+		li->data = dup_section (li->data);
+
+	retval->main_hash = g_hash_table_new_full (g_str_hash, g_str_equal,
+						   (GDestroyNotify) g_free,
+						   (GDestroyNotify) g_free);
+
+	g_hash_table_foreach (item->main_hash,
+			      copy_string_hash,
+			      retval->main_hash);
+
+	return retval;
+}
+
+static void
+read_sort_order (MateDesktopItem *item, GFile *dir)
+{
+	GFile *child;
+	char buf[BUFSIZ];
+	GString *str;
+	ReadBuf *rb;
+
+	child = g_file_get_child (dir, ".order");
+
+	rb = readbuf_open (child, NULL);
+	g_object_unref (child);
+
+	if (rb == NULL)
+		return;
+
+	str = NULL;
+	while (readbuf_gets (buf, sizeof (buf), rb) != NULL) {
+		if (str == NULL)
+			str = g_string_new (buf);
+		else
+			g_string_append (str, buf);
+		g_string_append_c (str, ';');
+	}
+	readbuf_close (rb);
+	if (str != NULL) {
+		mate_desktop_item_set_string (item, MATE_DESKTOP_ITEM_SORT_ORDER,
+					       str->str);
+		g_string_free (str, TRUE);
+	}
+}
+
+static MateDesktopItem *
+make_fake_directory (GFile *dir)
+{
+	MateDesktopItem *item;
+	GFile *child;
+
+	item = mate_desktop_item_new ();
+	mate_desktop_item_set_entry_type (item,
+					   MATE_DESKTOP_ITEM_TYPE_DIRECTORY);
+
+
+	item->mtime = DONT_UPDATE_MTIME; /* it doesn't exist, we know that */
+	child = g_file_get_child (dir, ".directory");
+	mate_desktop_item_set_location_gfile (item, child);
+	item->mtime = 0;
+	g_object_unref (child);
+
+	read_sort_order (item, dir);
+
+	return item;
+}
+
+/**
+ * mate_desktop_item_new_from_file:
+ * @file: The filename or directory path to load the MateDesktopItem from
+ * @flags: Flags to influence the loading process
+ *
+ * This function loads 'file' and turns it into a MateDesktopItem.
+ *
+ * Returns: The newly loaded item.
+ */
+MateDesktopItem *
+mate_desktop_item_new_from_file (const char *file,
+				  MateDesktopItemLoadFlags flags,
+				  GError **error)
+{
+	MateDesktopItem *retval;
+	GFile *gfile;
+
+	g_return_val_if_fail (file != NULL, NULL);
+
+	gfile = g_file_new_for_path (file);
+	retval = mate_desktop_item_new_from_gfile (gfile, flags, error);
+	g_object_unref (gfile);
+
+	return retval;
+}
+
+/**
+ * mate_desktop_item_new_from_uri:
+ * @uri: URI to load the MateDesktopItem from
+ * @flags: Flags to influence the loading process
+ *
+ * This function loads 'uri' and turns it into a MateDesktopItem.
+ *
+ * Returns: The newly loaded item.
+ */
+MateDesktopItem *
+mate_desktop_item_new_from_uri (const char *uri,
+				 MateDesktopItemLoadFlags flags,
+				 GError **error)
+{
+	MateDesktopItem *retval;
+	GFile *file;
+
+	g_return_val_if_fail (uri != NULL, NULL);
+
+	file = g_file_new_for_uri (uri);
+	retval = mate_desktop_item_new_from_gfile (file, flags, error);
+	g_object_unref (file);
+
+	return retval;
+}
+
+static MateDesktopItem *
+mate_desktop_item_new_from_gfile (GFile *file,
+				   MateDesktopItemLoadFlags flags,
+				   GError **error)
+{
+	MateDesktopItem *retval;
+	GFile *subfn;
+	GFileInfo *info;
+	GFileType type;
+	GFile *parent;
+	time_t mtime = 0;
+	ReadBuf *rb;
+
+	g_return_val_if_fail (file != NULL, NULL);
+
+	info = g_file_query_info (file,
+			          G_FILE_ATTRIBUTE_STANDARD_TYPE","G_FILE_ATTRIBUTE_TIME_MODIFIED,
+				  G_FILE_QUERY_INFO_NONE, NULL, error);
+	if (info == NULL)
+		return NULL;
+
+	type = g_file_info_get_file_type (info);
+
+	if (type != G_FILE_TYPE_REGULAR && type != G_FILE_TYPE_DIRECTORY) {
+		char *uri;
+
+		uri = g_file_get_uri (file);
+		g_set_error (error,
+			     /* FIXME: better errors */
+			     MATE_DESKTOP_ITEM_ERROR,
+			     MATE_DESKTOP_ITEM_ERROR_INVALID_TYPE,
+			     _("File '%s' is not a regular file or directory."),
+			     uri);
+
+		g_free (uri);
+		g_object_unref (info);
+
+		return NULL;
+	}
+
+	mtime = g_file_info_get_attribute_uint64 (info,
+						  G_FILE_ATTRIBUTE_TIME_MODIFIED);
+
+	g_object_unref (info);
+
+	if (type == G_FILE_TYPE_DIRECTORY) {
+		GFile *child;
+		GFileInfo *child_info;
+
+		child = g_file_get_child (file, ".directory");
+		child_info = g_file_query_info (child,
+						G_FILE_ATTRIBUTE_TIME_MODIFIED,
+						G_FILE_QUERY_INFO_NONE,
+						NULL, NULL);
+
+		if (child_info == NULL) {
+			g_object_unref (child);
+
+			if (flags & MATE_DESKTOP_ITEM_LOAD_ONLY_IF_EXISTS) {
+				return NULL;
+			} else {
+				return make_fake_directory (file);
+			}
+		}
+
+		mtime = g_file_info_get_attribute_uint64 (child_info,
+							  G_FILE_ATTRIBUTE_TIME_MODIFIED);
+		g_object_unref (child_info);
+
+		subfn = child;
+	} else {
+		subfn = g_file_dup (file);
+	}
+
+	rb = readbuf_open (subfn, error);
+
+	if (rb == NULL) {
+		g_object_unref (subfn);
+		return NULL;
+	}
+
+	retval = ditem_load (rb,
+			     (flags & MATE_DESKTOP_ITEM_LOAD_NO_TRANSLATIONS) != 0,
+			     error);
+
+	if (retval == NULL) {
+		g_object_unref (subfn);
+		return NULL;
+	}
+
+	if (flags & MATE_DESKTOP_ITEM_LOAD_ONLY_IF_EXISTS &&
+	    ! mate_desktop_item_exists (retval)) {
+		mate_desktop_item_unref (retval);
+		g_object_unref (subfn);
+		return NULL;
+	}
+
+	retval->mtime = DONT_UPDATE_MTIME;
+	mate_desktop_item_set_location_gfile (retval, subfn);
+	retval->mtime = mtime;
+
+	parent = g_file_get_parent (file);
+	if (parent != NULL) {
+		read_sort_order (retval, parent);
+		g_object_unref (parent);
+	}
+
+	g_object_unref (subfn);
+
+	return retval;
+}
+
+/**
+ * mate_desktop_item_new_from_string:
+ * @string: string to load the MateDesktopItem from
+ * @length: length of string, or -1 to use strlen
+ * @flags: Flags to influence the loading process
+ * @error: place to put errors
+ *
+ * This function turns the contents of the string into a MateDesktopItem.
+ *
+ * Returns: The newly loaded item.
+ */
+MateDesktopItem *
+mate_desktop_item_new_from_string (const char *uri,
+				    const char *string,
+				    gssize length,
+				    MateDesktopItemLoadFlags flags,
+				    GError **error)
+{
+	MateDesktopItem *retval;
+	ReadBuf *rb;
+
+	g_return_val_if_fail (string != NULL, NULL);
+	g_return_val_if_fail (length >= -1, NULL);
+
+	if (length == -1) {
+		length = strlen (string);
+	}
+
+	rb = readbuf_new_from_string (uri, string, length);
+
+	retval = ditem_load (rb,
+			     (flags & MATE_DESKTOP_ITEM_LOAD_NO_TRANSLATIONS) != 0,
+			     error);
+
+	if (retval == NULL) {
+		return NULL;
+	}
+
+	/* FIXME: Sort order? */
+
+	return retval;
+}
+
+static char *
+lookup_desktop_file_in_data_dir (const char *desktop_file,
+                                 const char *data_dir)
+{
+	char *path;
+
+	path = g_build_filename (data_dir, "applications", desktop_file, NULL);
+	if (!g_file_test (path, G_FILE_TEST_EXISTS)) {
+		g_free (path);
+		return NULL;
+	}
+	return path;
+}
+
+static char *
+file_from_basename (const char *basename)
+{
+	const char * const *system_data_dirs;
+	const char         *user_data_dir;
+	char               *retval;
+	int                 i;
+
+	user_data_dir = g_get_user_data_dir ();
+	system_data_dirs = g_get_system_data_dirs ();
+
+	if ((retval = lookup_desktop_file_in_data_dir (basename, user_data_dir))) {
+		return retval;
+	}
+	for (i = 0; system_data_dirs[i]; i++) {
+		if ((retval = lookup_desktop_file_in_data_dir (basename, system_data_dirs[i]))) {
+			return retval;
+		}
+	}
+	return NULL;
+}
+
+/**
+ * mate_desktop_item_new_from_basename:
+ * @basename: The basename of the MateDesktopItem to load.
+ * @flags: Flags to influence the loading process
+ *
+ * This function loads 'basename' from a system data directory and
+ * returns its MateDesktopItem.
+ *
+ * Returns: The newly loaded item.
+ */
+MateDesktopItem *
+mate_desktop_item_new_from_basename (const char *basename,
+                                      MateDesktopItemLoadFlags flags,
+                                      GError **error)
+{
+	MateDesktopItem *retval;
+	char *file;
+
+	g_return_val_if_fail (basename != NULL, NULL);
+
+	if (!(file = file_from_basename (basename))) {
+		g_set_error (error,
+			     MATE_DESKTOP_ITEM_ERROR,
+			     MATE_DESKTOP_ITEM_ERROR_CANNOT_OPEN,
+			     _("Cannot find file '%s'"),
+			     basename);
+		return NULL;
+	}
+
+	retval = mate_desktop_item_new_from_file (file, flags, error);
+	g_free (file);
+
+	return retval;
+}
+
+/**
+ * mate_desktop_item_save:
+ * @item: A desktop item
+ * @under: A new uri (location) for this #MateDesktopItem
+ * @force: Save even if it wasn't modified
+ * @error: #GError return
+ *
+ * Writes the specified item to disk.  If the 'under' is NULL, the original
+ * location is used.  It sets the location of this entry to point to the
+ * new location.
+ *
+ * Returns: boolean. %TRUE if the file was saved, %FALSE otherwise
+ */
+gboolean
+mate_desktop_item_save (MateDesktopItem *item,
+			 const char *under,
+			 gboolean force,
+			 GError **error)
+{
+	const char *uri;
+
+	if (under == NULL &&
+	    ! force &&
+	    ! item->modified)
+		return TRUE;
+
+	if (under == NULL)
+		uri = item->location;
+	else
+		uri = under;
+
+	if (uri == NULL) {
+		g_set_error (error,
+			     MATE_DESKTOP_ITEM_ERROR,
+			     MATE_DESKTOP_ITEM_ERROR_NO_FILENAME,
+			     _("No filename to save to"));
+		return FALSE;
+	}
+
+	if ( ! ditem_save (item, uri, error))
+		return FALSE;
+
+	item->modified = FALSE;
+	item->mtime = time (NULL);
+
+	return TRUE;
+}
+
+/**
+ * mate_desktop_item_ref:
+ * @item: A desktop item
+ *
+ * Description: Increases the reference count of the specified item.
+ *
+ * Returns: the newly referenced @item
+ */
+MateDesktopItem *
+mate_desktop_item_ref (MateDesktopItem *item)
+{
+	g_return_val_if_fail (item != NULL, NULL);
+
+	item->refcount++;
+
+	return item;
+}
+
+static void
+free_section (gpointer data, gpointer user_data)
+{
+	Section *section = data;
+
+	g_free (section->name);
+	section->name = NULL;
+
+	g_list_foreach (section->keys, (GFunc)g_free, NULL);
+	g_list_free (section->keys);
+	section->keys = NULL;
+
+	g_free (section);
+}
+
+/**
+ * mate_desktop_item_unref:
+ * @item: A desktop item
+ *
+ * Decreases the reference count of the specified item, and destroys the item if there are no more references left.
+ */
+void
+mate_desktop_item_unref (MateDesktopItem *item)
+{
+	g_return_if_fail (item != NULL);
+	g_return_if_fail (item->refcount > 0);
+
+	item->refcount--;
+
+	if(item->refcount != 0)
+		return;
+
+	g_list_foreach (item->languages, (GFunc)g_free, NULL);
+	g_list_free (item->languages);
+	item->languages = NULL;
+
+	g_list_foreach (item->keys, (GFunc)g_free, NULL);
+	g_list_free (item->keys);
+	item->keys = NULL;
+
+	g_list_foreach (item->sections, free_section, NULL);
+	g_list_free (item->sections);
+	item->sections = NULL;
+
+	g_hash_table_destroy (item->main_hash);
+	item->main_hash = NULL;
+
+	g_free (item->location);
+	item->location = NULL;
+
+	g_free (item);
+}
+
+static Section *
+find_section (MateDesktopItem *item, const char *section)
+{
+	GList *li;
+	Section *sec;
+
+	if (section == NULL)
+		return NULL;
+	if (strcmp (section, "Desktop Entry") == 0)
+		return NULL;
+
+	for (li = item->sections; li != NULL; li = li->next) {
+		sec = li->data;
+		if (strcmp (sec->name, section) == 0)
+			return sec;
+	}
+
+	sec = g_new0 (Section, 1);
+	sec->name = g_strdup (section);
+	sec->keys = NULL;
+
+	item->sections = g_list_append (item->sections, sec);
+
+	/* Don't mark the item modified, this is just an empty section,
+	 * it won't be saved even */
+
+	return sec;
+}
+
+static Section *
+section_from_key (MateDesktopItem *item, const char *key)
+{
+	char *p;
+	char *name;
+	Section *sec;
+
+	if (key == NULL)
+		return NULL;
+
+	p = strchr (key, '/');
+	if (p == NULL)
+		return NULL;
+
+	name = g_strndup (key, p - key);
+
+	sec = find_section (item, name);
+
+	g_free (name);
+
+	return sec;
+}
+
+static const char *
+key_basename (const char *key)
+{
+	char *p = strrchr (key, '/');
+	if (p != NULL)
+		return p+1;
+	else
+		return key;
+}
+
+
+static const char *
+lookup (const MateDesktopItem *item, const char *key)
+{
+	return g_hash_table_lookup (item->main_hash, key);
+}
+
+static const char *
+lookup_locale (const MateDesktopItem *item, const char *key, const char *locale)
+{
+	if (locale == NULL ||
+	    strcmp (locale, "C") == 0) {
+		return lookup (item, key);
+	} else {
+		const char *ret;
+		char *full = g_strdup_printf ("%s[%s]", key, locale);
+		ret = lookup (item, full);
+		g_free (full);
+		return ret;
+	}
+}
+
+static const char *
+lookup_best_locale (const MateDesktopItem *item, const char *key)
+{
+	const char * const *langs_pointer;
+	int                 i;
+
+	langs_pointer = g_get_language_names ();
+	for (i = 0; langs_pointer[i] != NULL; i++) {
+		const char *ret = NULL;
+
+		ret = lookup_locale (item, key, langs_pointer[i]);
+		if (ret != NULL)
+			return ret;
+	}
+
+	return NULL;
+}
+
+static void
+set (MateDesktopItem *item, const char *key, const char *value)
+{
+	Section *sec = section_from_key (item, key);
+
+	if (sec != NULL) {
+		if (value != NULL) {
+			if (g_hash_table_lookup (item->main_hash, key) == NULL)
+				sec->keys = g_list_append
+					(sec->keys,
+					 g_strdup (key_basename (key)));
+
+			g_hash_table_replace (item->main_hash,
+					      g_strdup (key),
+					      g_strdup (value));
+		} else {
+			GList *list = g_list_find_custom
+				(sec->keys, key_basename (key),
+				 (GCompareFunc)strcmp);
+			if (list != NULL) {
+				g_free (list->data);
+				sec->keys =
+					g_list_delete_link (sec->keys, list);
+			}
+			g_hash_table_remove (item->main_hash, key);
+		}
+	} else {
+		if (value != NULL) {
+			if (g_hash_table_lookup (item->main_hash, key) == NULL)
+				item->keys = g_list_append (item->keys,
+							    g_strdup (key));
+
+			g_hash_table_replace (item->main_hash,
+					      g_strdup (key),
+					      g_strdup (value));
+		} else {
+			GList *list = g_list_find_custom
+				(item->keys, key, (GCompareFunc)strcmp);
+			if (list != NULL) {
+				g_free (list->data);
+				item->keys =
+					g_list_delete_link (item->keys, list);
+			}
+			g_hash_table_remove (item->main_hash, key);
+		}
+	}
+	item->modified = TRUE;
+}
+
+static void
+set_locale (MateDesktopItem *item, const char *key,
+	    const char *locale, const char *value)
+{
+	if (locale == NULL ||
+	    strcmp (locale, "C") == 0) {
+		set (item, key, value);
+	} else {
+		char *full = g_strdup_printf ("%s[%s]", key, locale);
+		set (item, full, value);
+		g_free (full);
+
+		/* add the locale to the list of languages if it wasn't there
+		 * before */
+		if (g_list_find_custom (item->languages, locale,
+					(GCompareFunc)strcmp) == NULL)
+			item->languages = g_list_prepend (item->languages,
+							  g_strdup (locale));
+	}
+}
+
+static char **
+list_to_vector (GSList *list)
+{
+	int len = g_slist_length (list);
+	char **argv;
+	int i;
+	GSList *li;
+
+	argv = g_new0 (char *, len+1);
+
+	for (i = 0, li = list;
+	     li != NULL;
+	     li = li->next, i++) {
+		argv[i] = g_strdup (li->data);
+	}
+	argv[i] = NULL;
+
+	return argv;
+}
+
+static GSList *
+make_args (GList *files)
+{
+	GSList *list = NULL;
+	GList *li;
+
+	for (li = files; li != NULL; li = li->next) {
+		GFile *gfile;
+		const char *file = li->data;
+		if (file == NULL)
+			continue;
+		gfile = g_file_new_for_uri (file);
+		list = g_slist_prepend (list, gfile);
+	}
+
+	return g_slist_reverse (list);
+}
+
+static void
+free_args (GSList *list)
+{
+	GSList *li;
+
+	for (li = list; li != NULL; li = li->next) {
+		g_object_unref (G_FILE (li->data));
+		li->data = NULL;
+	}
+	g_slist_free (list);
+}
+
+static char *
+escape_single_quotes (const char *s,
+		      gboolean in_single_quotes,
+		      gboolean in_double_quotes)
+{
+	const char *p;
+	GString *gs;
+	const char *pre = "";
+	const char *post = "";
+
+	if ( ! in_single_quotes && ! in_double_quotes) {
+		pre = "'";
+		post = "'";
+	} else if ( ! in_single_quotes && in_double_quotes) {
+		pre = "\"'";
+		post = "'\"";
+	}
+
+	if (strchr (s, '\'') == NULL) {
+		return g_strconcat (pre, s, post, NULL);
+	}
+
+	gs = g_string_new (pre);
+
+	for (p = s; *p != '\0'; p++) {
+		if (*p == '\'')
+			g_string_append (gs, "'\\''");
+		else
+			g_string_append_c (gs, *p);
+	}
+
+	g_string_append (gs, post);
+
+	return g_string_free (gs, FALSE);
+}
+
+typedef enum {
+	URI_TO_STRING,
+	URI_TO_LOCAL_PATH,
+	URI_TO_LOCAL_DIRNAME,
+	URI_TO_LOCAL_BASENAME
+} ConversionType;
+
+static char *
+convert_uri (GFile          *file,
+	     ConversionType  conversion)
+{
+	char *retval = NULL;
+
+	switch (conversion) {
+	case URI_TO_STRING:
+		retval = g_file_get_uri (file);
+		break;
+	case URI_TO_LOCAL_PATH:
+		retval = g_file_get_path (file);
+		break;
+	case URI_TO_LOCAL_DIRNAME:
+		{
+			char *local_path;
+
+			local_path = g_file_get_path (file);
+			retval = g_path_get_dirname (local_path);
+			g_free (local_path);
+		}
+		break;
+	case URI_TO_LOCAL_BASENAME:
+		retval = g_file_get_basename (file);
+		break;
+	default:
+		g_assert_not_reached ();
+	}
+
+	return retval;
+}
+
+typedef enum {
+	ADDED_NONE = 0,
+	ADDED_SINGLE,
+	ADDED_ALL
+} AddedStatus;
+
+static AddedStatus
+append_all_converted (GString        *str,
+		      ConversionType  conversion,
+		      GSList         *args,
+		      gboolean        in_single_quotes,
+		      gboolean        in_double_quotes,
+		      AddedStatus     added_status)
+{
+	GSList *l;
+
+	for (l = args; l; l = l->next) {
+		char *converted;
+		char *escaped;
+
+		if (!(converted = convert_uri (l->data, conversion)))
+			continue;
+
+		g_string_append (str, " ");
+
+		escaped = escape_single_quotes (converted,
+						in_single_quotes,
+						in_double_quotes);
+		g_string_append (str, escaped);
+
+		g_free (escaped);
+		g_free (converted);
+	}
+
+	return ADDED_ALL;
+}
+
+static AddedStatus
+append_first_converted (GString         *str,
+			ConversionType   conversion,
+			GSList         **arg_ptr,
+			gboolean         in_single_quotes,
+			gboolean         in_double_quotes,
+			AddedStatus      added_status)
+{
+	GSList *l;
+	char   *converted = NULL;
+	char   *escaped;
+
+	for (l = *arg_ptr; l; l = l->next) {
+		if ((converted = convert_uri (l->data, conversion)))
+			break;
+
+		*arg_ptr = l->next;
+	}
+
+	if (!converted)
+		return added_status;
+
+	escaped = escape_single_quotes (converted, in_single_quotes, in_double_quotes);
+	g_string_append (str, escaped);
+	g_free (escaped);
+	g_free (converted);
+
+	return added_status != ADDED_ALL ? ADDED_SINGLE : added_status;
+}
+
+static gboolean
+do_percent_subst (const MateDesktopItem  *item,
+		  const char              *arg,
+		  GString                 *str,
+		  gboolean                 in_single_quotes,
+		  gboolean                 in_double_quotes,
+		  GSList                  *args,
+		  GSList                 **arg_ptr,
+		  AddedStatus             *added_status)
+{
+	char *esc;
+	const char *cs;
+
+	if (arg[0] != '%' || arg[1] == '\0') {
+		return FALSE;
+	}
+
+	switch (arg[1]) {
+	case '%':
+		g_string_append_c (str, '%');
+		break;
+	case 'U':
+		*added_status = append_all_converted (str,
+						      URI_TO_STRING,
+						      args,
+						      in_single_quotes,
+						      in_double_quotes,
+						      *added_status);
+		break;
+	case 'F':
+		*added_status = append_all_converted (str,
+						      URI_TO_LOCAL_PATH,
+						      args,
+						      in_single_quotes,
+						      in_double_quotes,
+						      *added_status);
+		break;
+	case 'N':
+		*added_status = append_all_converted (str,
+						      URI_TO_LOCAL_BASENAME,
+						      args,
+						      in_single_quotes,
+						      in_double_quotes,
+						      *added_status);
+		break;
+	case 'D':
+		*added_status = append_all_converted (str,
+						      URI_TO_LOCAL_DIRNAME,
+						      args,
+						      in_single_quotes,
+						      in_double_quotes,
+						      *added_status);
+		break;
+	case 'f':
+		*added_status = append_first_converted (str,
+							URI_TO_LOCAL_PATH,
+							arg_ptr,
+							in_single_quotes,
+							in_double_quotes,
+							*added_status);
+		break;
+	case 'u':
+		*added_status = append_first_converted (str,
+							URI_TO_STRING,
+							arg_ptr,
+							in_single_quotes,
+							in_double_quotes,
+							*added_status);
+		break;
+	case 'd':
+		*added_status = append_first_converted (str,
+							URI_TO_LOCAL_DIRNAME,
+							arg_ptr,
+							in_single_quotes,
+							in_double_quotes,
+							*added_status);
+		break;
+	case 'n':
+		*added_status = append_first_converted (str,
+							URI_TO_LOCAL_BASENAME,
+							arg_ptr,
+							in_single_quotes,
+							in_double_quotes,
+							*added_status);
+		break;
+	case 'm':
+		/* Note: v0.9.4 of the spec says this is deprecated
+		 * and replace with --miniicon iconname */
+		cs = mate_desktop_item_get_string (item, MATE_DESKTOP_ITEM_MINI_ICON);
+		if (cs != NULL) {
+			g_string_append (str, "--miniicon=");
+			esc = escape_single_quotes (cs, in_single_quotes, in_double_quotes);
+			g_string_append (str, esc);
+		}
+		break;
+	case 'i':
+		/* Note: v0.9.4 of the spec says replace with --icon iconname */
+		cs = mate_desktop_item_get_string (item, MATE_DESKTOP_ITEM_ICON);
+		if (cs != NULL) {
+			g_string_append (str, "--icon=");
+			esc = escape_single_quotes (cs, in_single_quotes, in_double_quotes);
+			g_string_append (str, esc);
+		}
+		break;
+	case 'c':
+		cs = mate_desktop_item_get_localestring (item, MATE_DESKTOP_ITEM_NAME);
+		if (cs != NULL) {
+			esc = escape_single_quotes (cs, in_single_quotes, in_double_quotes);
+			g_string_append (str, esc);
+			g_free (esc);
+		}
+		break;
+	case 'k':
+		if (item->location != NULL) {
+			esc = escape_single_quotes (item->location, in_single_quotes, in_double_quotes);
+			g_string_append (str, esc);
+			g_free (esc);
+		}
+		break;
+	case 'v':
+		cs = mate_desktop_item_get_localestring (item, MATE_DESKTOP_ITEM_DEV);
+		if (cs != NULL) {
+			esc = escape_single_quotes (cs, in_single_quotes, in_double_quotes);
+			g_string_append (str, esc);
+			g_free (esc);
+		}
+		break;
+	default:
+		/* Maintain special characters - e.g. "%20" */
+		if (g_ascii_isdigit (arg [1]))
+			g_string_append_c (str, '%');
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static char *
+expand_string (const MateDesktopItem  *item,
+	       const char              *s,
+	       GSList                  *args,
+	       GSList                 **arg_ptr,
+	       AddedStatus             *added_status)
+{
+	const char *p;
+	gboolean escape = FALSE;
+	gboolean single_quot = FALSE;
+	gboolean double_quot = FALSE;
+	GString *gs = g_string_new (NULL);
+
+	for (p = s; *p != '\0'; p++) {
+		if (escape) {
+			escape = FALSE;
+			g_string_append_c (gs, *p);
+		} else if (*p == '\\') {
+			if ( ! single_quot)
+				escape = TRUE;
+			g_string_append_c (gs, *p);
+		} else if (*p == '\'') {
+			g_string_append_c (gs, *p);
+			if ( ! single_quot && ! double_quot) {
+				single_quot = TRUE;
+			} else if (single_quot) {
+				single_quot = FALSE;
+			}
+		} else if (*p == '"') {
+			g_string_append_c (gs, *p);
+			if ( ! single_quot && ! double_quot) {
+				double_quot = TRUE;
+			} else if (double_quot) {
+				double_quot = FALSE;
+			}
+		} else if (*p == '%') {
+			if (do_percent_subst (item, p, gs,
+					      single_quot, double_quot,
+					      args, arg_ptr,
+					      added_status)) {
+				p++;
+			}
+		} else {
+			g_string_append_c (gs, *p);
+		}
+	}
+	return g_string_free (gs, FALSE);
+}
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+static void
+sn_error_trap_push (SnDisplay *display,
+		    Display   *xdisplay)
+{
+	gdk_error_trap_push ();
+}
+
+static void
+sn_error_trap_pop (SnDisplay *display,
+		   Display   *xdisplay)
+{
+	gdk_error_trap_pop ();
+}
+
+static char **
+make_spawn_environment_for_sn_context (SnLauncherContext *sn_context,
+				       char             **envp)
+{
+	char **retval;
+	char **freeme;
+	int    i, j;
+	int    desktop_startup_id_len;
+
+	retval = freeme = NULL;
+
+	if (envp == NULL) {
+		envp = freeme = g_listenv ();
+		for (i = 0; envp[i]; i++) {
+			char *name = envp[i];
+
+			envp[i] = g_strjoin ("=", name, g_getenv (name), NULL);
+			g_free (name);
+		}
+	} else {
+		for (i = 0; envp[i]; i++)
+			;
+	}
+
+	retval = g_new (char *, i + 2);
+
+	desktop_startup_id_len = strlen ("DESKTOP_STARTUP_ID");
+
+	for (i = 0, j = 0; envp[i]; i++) {
+		if (strncmp (envp[i], "DESKTOP_STARTUP_ID", desktop_startup_id_len) != 0) {
+			retval[j] = g_strdup (envp[i]);
+			++j;
+	        }
+	}
+
+	retval[j] = g_strdup_printf ("DESKTOP_STARTUP_ID=%s",
+				     sn_launcher_context_get_startup_id (sn_context));
+	++j;
+	retval[j] = NULL;
+
+	g_strfreev (freeme);
+
+	return retval;
+}
+
+/* This should be fairly long, as it's confusing to users if a startup
+ * ends when it shouldn't (it appears that the startup failed, and
+ * they have to relaunch the app). Also the timeout only matters when
+ * there are bugs and apps don't end their own startup sequence.
+ *
+ * This timeout is a "last resort" timeout that ignores whether the
+ * startup sequence has shown activity or not.  Marco and the
+ * tasklist have smarter, and correspondingly able-to-be-shorter
+ * timeouts. The reason our timeout is dumb is that we don't monitor
+ * the sequence (don't use an SnMonitorContext)
+ */
+#define STARTUP_TIMEOUT_LENGTH_SEC 30 /* seconds */
+#define STARTUP_TIMEOUT_LENGTH (STARTUP_TIMEOUT_LENGTH_SEC * 1000)
+
+typedef struct
+{
+	GdkScreen *screen;
+	GSList *contexts;
+	guint timeout_id;
+} StartupTimeoutData;
+
+static void
+free_startup_timeout (void *data)
+{
+	StartupTimeoutData *std = data;
+
+	g_slist_foreach (std->contexts,
+			 (GFunc) sn_launcher_context_unref,
+			 NULL);
+	g_slist_free (std->contexts);
+
+	if (std->timeout_id != 0) {
+		g_source_remove (std->timeout_id);
+		std->timeout_id = 0;
+	}
+
+	g_free (std);
+}
+
+static gboolean
+startup_timeout (void *data)
+{
+	StartupTimeoutData *std = data;
+	GSList *tmp;
+	GTimeVal now;
+	int min_timeout;
+
+	min_timeout = STARTUP_TIMEOUT_LENGTH;
+
+	g_get_current_time (&now);
+
+	tmp = std->contexts;
+	while (tmp != NULL) {
+		SnLauncherContext *sn_context = tmp->data;
+		GSList *next = tmp->next;
+		long tv_sec, tv_usec;
+		double elapsed;
+
+		sn_launcher_context_get_last_active_time (sn_context,
+							  &tv_sec, &tv_usec);
+
+		elapsed =
+			((((double)now.tv_sec - tv_sec) * G_USEC_PER_SEC +
+			  (now.tv_usec - tv_usec))) / 1000.0;
+
+		if (elapsed >= STARTUP_TIMEOUT_LENGTH) {
+			std->contexts = g_slist_remove (std->contexts,
+							sn_context);
+			sn_launcher_context_complete (sn_context);
+			sn_launcher_context_unref (sn_context);
+		} else {
+			min_timeout = MIN (min_timeout, (STARTUP_TIMEOUT_LENGTH - elapsed));
+		}
+
+		tmp = next;
+	}
+
+	/* we'll use seconds for the timeout */
+	if (min_timeout < 1000)
+		min_timeout = 1000;
+
+	if (std->contexts == NULL) {
+		std->timeout_id = 0;
+	} else {
+		std->timeout_id = g_timeout_add_seconds (min_timeout / 1000,
+							 startup_timeout,
+							 std);
+	}
+
+	/* always remove this one, but we may have reinstalled another one. */
+	return FALSE;
+}
+
+static void
+add_startup_timeout (GdkScreen         *screen,
+		     SnLauncherContext *sn_context)
+{
+	StartupTimeoutData *data;
+
+	data = g_object_get_data (G_OBJECT (screen), "mate-startup-data");
+	if (data == NULL) {
+		data = g_new (StartupTimeoutData, 1);
+		data->screen = screen;
+		data->contexts = NULL;
+		data->timeout_id = 0;
+
+		g_object_set_data_full (G_OBJECT (screen), "mate-startup-data",
+					data, free_startup_timeout);
+	}
+
+	sn_launcher_context_ref (sn_context);
+	data->contexts = g_slist_prepend (data->contexts, sn_context);
+
+	if (data->timeout_id == 0) {
+		data->timeout_id = g_timeout_add_seconds (
+						STARTUP_TIMEOUT_LENGTH_SEC,
+						startup_timeout,
+						data);
+	}
+}
+#endif /* HAVE_STARTUP_NOTIFICATION */
+
+static inline char *
+stringify_uris (GSList *args)
+{
+	GString *str;
+
+	str = g_string_new (NULL);
+
+	append_all_converted (str, URI_TO_STRING, args, FALSE, FALSE, ADDED_NONE);
+
+	return g_string_free (str, FALSE);
+}
+
+static inline char *
+stringify_files (GSList *args)
+{
+	GString *str;
+
+	str = g_string_new (NULL);
+
+	append_all_converted (str, URI_TO_LOCAL_PATH, args, FALSE, FALSE, ADDED_NONE);
+
+	return g_string_free (str, FALSE);
+}
+
+static char **
+make_environment_for_screen (GdkScreen  *screen,
+			     char      **envp)
+{
+	char **retval;
+	char **freeme;
+	char  *display_name;
+	int    display_index = -1;
+	int    i, env_len;
+
+	g_return_val_if_fail (GDK_IS_SCREEN (screen), NULL);
+
+	retval = freeme = NULL;
+
+	if (envp == NULL) {
+		envp = freeme = g_listenv ();
+		for (i = 0; envp [i]; i++) {
+			char *name = envp[i];
+
+			envp[i] = g_strjoin ("=", name, g_getenv (name), NULL);
+			g_free (name);
+		}
+	}
+
+	for (env_len = 0; envp [env_len]; env_len++)
+		if (strncmp (envp [env_len], "DISPLAY", strlen ("DISPLAY")) == 0)
+			display_index = env_len;
+
+	retval = g_new (char *, env_len + 1);
+	retval [env_len] = NULL;
+
+	display_name = gdk_screen_make_display_name (screen);
+
+	for (i = 0; i < env_len; i++)
+		if (i == display_index)
+			retval [i] = g_strconcat ("DISPLAY=", display_name, NULL);
+		else
+			retval [i] = g_strdup (envp[i]);
+
+	g_assert (i == env_len);
+
+	g_free (display_name);
+	g_strfreev (freeme);
+
+	return retval;
+}
+
+static int
+ditem_execute (const MateDesktopItem *item,
+	       const char *exec,
+	       GList *file_list,
+	       GdkScreen *screen,
+	       int workspace,
+               char **envp,
+	       gboolean launch_only_one,
+	       gboolean use_current_dir,
+	       gboolean append_uris,
+	       gboolean append_paths,
+	       gboolean do_not_reap_child,
+	       GError **error)
+{
+	char **free_me = NULL;
+	char **real_argv;
+	int i, ret;
+	char **term_argv = NULL;
+	int term_argc = 0;
+	GSList *vector_list;
+	GSList *args, *arg_ptr;
+	AddedStatus added_status;
+	const char *working_dir = NULL;
+	char **temp_argv = NULL;
+	int temp_argc = 0;
+	char *new_exec, *uris, *temp;
+	char *exec_locale;
+	int launched = 0;
+#ifdef HAVE_STARTUP_NOTIFICATION
+	GdkDisplay *gdkdisplay;
+	SnLauncherContext *sn_context;
+	SnDisplay *sn_display;
+	const char *startup_class;
+#endif
+
+	g_return_val_if_fail (item, -1);
+
+	if (item->type == MATE_DESKTOP_ITEM_TYPE_APPLICATION) {
+		working_dir = mate_desktop_item_get_string (item, MATE_DESKTOP_ITEM_PATH);
+		if (working_dir &&
+		    !g_file_test (working_dir, G_FILE_TEST_IS_DIR))
+			working_dir = NULL;
+	}
+
+	if (working_dir == NULL && !use_current_dir)
+		working_dir = g_get_home_dir ();
+
+	if (mate_desktop_item_get_boolean (item, MATE_DESKTOP_ITEM_TERMINAL)) {
+		const char *options =
+			mate_desktop_item_get_string (item, MATE_DESKTOP_ITEM_TERMINAL_OPTIONS);
+
+		if (options != NULL) {
+			g_shell_parse_argv (options,
+					    &term_argc,
+					    &term_argv,
+					    NULL /* error */);
+			/* ignore errors */
+		}
+
+		mate_desktop_prepend_terminal_to_vector (&term_argc, &term_argv);
+	}
+
+	args = make_args (file_list);
+	arg_ptr = make_args (file_list);
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+	if (screen)
+		gdkdisplay = gdk_screen_get_display (screen);
+	else
+		gdkdisplay = gdk_display_get_default ();
+
+	sn_display = sn_display_new (GDK_DISPLAY_XDISPLAY (gdkdisplay),
+				     sn_error_trap_push,
+				     sn_error_trap_pop);
+
+
+	/* Only initiate notification if desktop file supports it.
+	 * (we could avoid setting up the SnLauncherContext if we aren't going
+	 * to initiate, but why bother)
+	 */
+
+	startup_class = mate_desktop_item_get_string (item,
+						       "StartupWMClass");
+	if (startup_class ||
+	    mate_desktop_item_get_boolean (item, "StartupNotify")) {
+		const char *name;
+		const char *icon;
+
+		sn_context = sn_launcher_context_new (sn_display,
+						      screen ? gdk_screen_get_number (screen) :
+						      DefaultScreen (GDK_DISPLAY_XDISPLAY (gdkdisplay)));
+
+		name = mate_desktop_item_get_localestring (item,
+							    MATE_DESKTOP_ITEM_NAME);
+
+		if (name == NULL)
+			name = mate_desktop_item_get_localestring (item,
+								    MATE_DESKTOP_ITEM_GENERIC_NAME);
+
+		if (name != NULL) {
+			char *description;
+
+			sn_launcher_context_set_name (sn_context, name);
+
+			description = g_strdup_printf (_("Starting %s"), name);
+
+			sn_launcher_context_set_description (sn_context, description);
+
+			g_free (description);
+		}
+
+		icon = mate_desktop_item_get_string (item,
+						      MATE_DESKTOP_ITEM_ICON);
+
+		if (icon != NULL)
+			sn_launcher_context_set_icon_name (sn_context, icon);
+
+		sn_launcher_context_set_workspace (sn_context, workspace);
+
+		if (startup_class != NULL)
+			sn_launcher_context_set_wmclass (sn_context,
+							 startup_class);
+	} else {
+		sn_context = NULL;
+	}
+#endif
+
+	if (screen) {
+		envp = make_environment_for_screen (screen, envp);
+		if (free_me)
+			g_strfreev (free_me);
+		free_me = envp;
+	}
+
+	exec_locale = g_filename_from_utf8 (exec, -1, NULL, NULL, NULL);
+
+	if (exec_locale == NULL) {
+		exec_locale = g_strdup ("");
+	}
+
+	do {
+		added_status = ADDED_NONE;
+		new_exec = expand_string (item,
+					  exec_locale,
+					  args, &arg_ptr, &added_status);
+
+		if (launched == 0 && added_status == ADDED_NONE && append_uris) {
+			uris = stringify_uris (args);
+			temp = g_strconcat (new_exec, " ", uris, NULL);
+			g_free (uris);
+			g_free (new_exec);
+			new_exec = temp;
+			added_status = ADDED_ALL;
+		}
+
+		/* append_uris and append_paths are mutually exlusive */
+		if (launched == 0 && added_status == ADDED_NONE && append_paths) {
+			uris = stringify_files (args);
+			temp = g_strconcat (new_exec, " ", uris, NULL);
+			g_free (uris);
+			g_free (new_exec);
+			new_exec = temp;
+			added_status = ADDED_ALL;
+		}
+
+		if (launched > 0 && added_status == ADDED_NONE) {
+			g_free (new_exec);
+			break;
+		}
+
+		if ( ! g_shell_parse_argv (new_exec,
+					   &temp_argc, &temp_argv, error)) {
+			/* The error now comes from g_shell_parse_argv */
+			g_free (new_exec);
+			ret = -1;
+			break;
+		}
+		g_free (new_exec);
+
+		vector_list = NULL;
+		for(i = 0; i < term_argc; i++)
+			vector_list = g_slist_append (vector_list,
+						      g_strdup (term_argv[i]));
+
+		for(i = 0; i < temp_argc; i++)
+			vector_list = g_slist_append (vector_list,
+						      g_strdup (temp_argv[i]));
+
+		g_strfreev (temp_argv);
+
+		real_argv = list_to_vector (vector_list);
+		g_slist_foreach (vector_list, (GFunc)g_free, NULL);
+		g_slist_free (vector_list);
+
+#ifdef HAVE_STARTUP_NOTIFICATION
+		if (sn_context != NULL &&
+		    !sn_launcher_context_get_initiated (sn_context)) {
+			guint32 launch_time;
+
+			/* This means that we always use the first real_argv[0]
+			 * we select for the "binary name", but it's probably
+			 * OK to do that. Binary name isn't super-important
+			 * anyway, and we can't initiate twice, and we
+			 * must initiate prior to fork/exec.
+			 */
+
+			sn_launcher_context_set_binary_name (sn_context,
+							     real_argv[0]);
+
+			if (item->launch_time > 0)
+				launch_time = item->launch_time;
+			else
+				launch_time = gdk_x11_display_get_user_time (gdkdisplay);
+
+			sn_launcher_context_initiate (sn_context,
+						      g_get_prgname () ? g_get_prgname () : "unknown",
+						      real_argv[0],
+						      launch_time);
+
+			/* Don't allow accidental reuse of same timestamp */
+			((MateDesktopItem *)item)->launch_time = 0;
+
+			envp = make_spawn_environment_for_sn_context (sn_context, envp);
+			if (free_me)
+				g_strfreev (free_me);
+			free_me = envp;
+		}
+#endif
+
+
+		if ( ! g_spawn_async (working_dir,
+				      real_argv,
+				      envp,
+				      (do_not_reap_child ? G_SPAWN_DO_NOT_REAP_CHILD : 0) | G_SPAWN_SEARCH_PATH /* flags */,
+				      NULL, /* child_setup_func */
+				      NULL, /* child_setup_func_data */
+				      &ret /* child_pid */,
+				      error)) {
+			/* The error was set for us,
+			 * we just can't launch this thingie */
+			ret = -1;
+			g_strfreev (real_argv);
+			break;
+		}
+		launched ++;
+
+		g_strfreev (real_argv);
+
+		if (arg_ptr != NULL)
+			arg_ptr = arg_ptr->next;
+
+	/* rinse, repeat until we run out of arguments (That
+	 * is if we were adding singles anyway) */
+	} while (added_status == ADDED_SINGLE &&
+		 arg_ptr != NULL &&
+		 ! launch_only_one);
+
+	g_free (exec_locale);
+#ifdef HAVE_STARTUP_NOTIFICATION
+	if (sn_context != NULL) {
+		if (ret < 0)
+			sn_launcher_context_complete (sn_context); /* end sequence */
+		else
+			add_startup_timeout (screen ? screen :
+					     gdk_display_get_default_screen (gdk_display_get_default ()),
+					     sn_context);
+		sn_launcher_context_unref (sn_context);
+	}
+
+	sn_display_unref (sn_display);
+#endif /* HAVE_STARTUP_NOTIFICATION */
+
+	free_args (args);
+
+	if (term_argv)
+		g_strfreev (term_argv);
+
+	if (free_me)
+		g_strfreev (free_me);
+
+	return ret;
+}
+
+/* strip any trailing &, return FALSE if bad things happen and
+   we end up with an empty string */
+static gboolean
+strip_the_amp (char *exec)
+{
+	size_t exec_len;
+
+	g_strstrip (exec);
+	if (*exec == '\0')
+		return FALSE;
+
+	exec_len = strlen (exec);
+	/* kill any trailing '&' */
+	if (exec[exec_len-1] == '&') {
+		exec[exec_len-1] = '\0';
+		g_strchomp (exec);
+	}
+
+	/* can't exactly launch an empty thing */
+	if (*exec == '\0')
+		return FALSE;
+
+	return TRUE;
+}
+
+
+static int
+mate_desktop_item_launch_on_screen_with_env (
+		const MateDesktopItem       *item,
+		GList                        *file_list,
+		MateDesktopItemLaunchFlags   flags,
+		GdkScreen                    *screen,
+		int                           workspace,
+		char                        **envp,
+		GError                      **error)
+{
+	const char *exec;
+	char *the_exec;
+	int ret;
+
+	exec = mate_desktop_item_get_string (item, MATE_DESKTOP_ITEM_EXEC);
+	/* This is a URL, so launch it as a url */
+	if (item->type == MATE_DESKTOP_ITEM_TYPE_LINK) {
+		const char *url;
+		gboolean    retval;
+
+		url = mate_desktop_item_get_string (item, MATE_DESKTOP_ITEM_URL);
+		/* Mate panel used to put this in Exec */
+		if (!(url && url[0] != '\0'))
+			url = exec;
+
+		if (!(url && url[0] != '\0')) {
+			g_set_error (error,
+				     MATE_DESKTOP_ITEM_ERROR,
+				     MATE_DESKTOP_ITEM_ERROR_NO_URL,
+				     _("No URL to launch"));
+			return -1;
+		}
+
+		retval = gtk_show_uri  (screen,
+					url,
+					GDK_CURRENT_TIME,
+					error);
+		return retval ? 0 : -1;
+	}
+
+	/* check the type, if there is one set */
+	if (item->type != MATE_DESKTOP_ITEM_TYPE_APPLICATION) {
+		g_set_error (error,
+			     MATE_DESKTOP_ITEM_ERROR,
+			     MATE_DESKTOP_ITEM_ERROR_NOT_LAUNCHABLE,
+			     _("Not a launchable item"));
+		return -1;
+	}
+
+
+	if (exec == NULL ||
+	    exec[0] == '\0') {
+		g_set_error (error,
+			     MATE_DESKTOP_ITEM_ERROR,
+			     MATE_DESKTOP_ITEM_ERROR_NO_EXEC_STRING,
+			     _("No command (Exec) to launch"));
+		return -1;
+	}
+
+
+	/* make a new copy and get rid of spaces */
+	the_exec = g_alloca (strlen (exec) + 1);
+	strcpy (the_exec, exec);
+
+	if ( ! strip_the_amp (the_exec)) {
+		g_set_error (error,
+			     MATE_DESKTOP_ITEM_ERROR,
+			     MATE_DESKTOP_ITEM_ERROR_BAD_EXEC_STRING,
+			     _("Bad command (Exec) to launch"));
+		return -1;
+	}
+
+	ret = ditem_execute (item, the_exec, file_list, screen, workspace, envp,
+			     (flags & MATE_DESKTOP_ITEM_LAUNCH_ONLY_ONE),
+			     (flags & MATE_DESKTOP_ITEM_LAUNCH_USE_CURRENT_DIR),
+			     (flags & MATE_DESKTOP_ITEM_LAUNCH_APPEND_URIS),
+			     (flags & MATE_DESKTOP_ITEM_LAUNCH_APPEND_PATHS),
+			     (flags & MATE_DESKTOP_ITEM_LAUNCH_DO_NOT_REAP_CHILD),
+			     error);
+
+	return ret;
+}
+
+/**
+ * mate_desktop_item_launch:
+ * @item: A desktop item
+ * @file_list:  Files/URIs to launch this item with, can be %NULL
+ * @flags: FIXME
+ * @error: FIXME
+ *
+ * This function runs the program listed in the specified 'item',
+ * optionally appending additional arguments to its command line.  It uses
+ * #g_shell_parse_argv to parse the the exec string into a vector which is
+ * then passed to #g_spawn_async for execution. This can return all
+ * the errors from MateURL, #g_shell_parse_argv and #g_spawn_async,
+ * in addition to it's own.  The files are
+ * only added if the entry defines one of the standard % strings in it's
+ * Exec field.
+ *
+ * Returns: The the pid of the process spawned.  If more then one
+ * process was spawned the last pid is returned.  On error -1
+ * is returned and @error is set.
+ */
+int
+mate_desktop_item_launch (const MateDesktopItem       *item,
+			   GList                        *file_list,
+			   MateDesktopItemLaunchFlags   flags,
+			   GError                      **error)
+{
+	return mate_desktop_item_launch_on_screen_with_env (
+			item, file_list, flags, NULL, -1, NULL, error);
+}
+
+/**
+ * mate_desktop_item_launch_with_env:
+ * @item: A desktop item
+ * @file_list:  Files/URIs to launch this item with, can be %NULL
+ * @flags: FIXME
+ * @envp: child's environment, or %NULL to inherit parent's
+ * @error: FIXME
+ *
+ * See mate_desktop_item_launch for a full description. This function
+ * additionally passes an environment vector for the child process
+ * which is to be launched.
+ *
+ * Returns: The the pid of the process spawned.  If more then one
+ * process was spawned the last pid is returned.  On error -1
+ * is returned and @error is set.
+ */
+int
+mate_desktop_item_launch_with_env (const MateDesktopItem       *item,
+				    GList                        *file_list,
+				    MateDesktopItemLaunchFlags   flags,
+				    char                        **envp,
+				    GError                      **error)
+{
+	return mate_desktop_item_launch_on_screen_with_env (
+			item, file_list, flags,
+			NULL, -1, envp, error);
+}
+
+/**
+ * mate_desktop_item_launch_on_screen:
+ * @item: A desktop item
+ * @file_list:  Files/URIs to launch this item with, can be %NULL
+ * @flags: FIXME
+ * @screen: the %GdkScreen on which the application should be launched
+ * @workspace: the workspace on which the app should be launched (-1 for current)
+ * @error: FIXME
+ *
+ * See mate_desktop_item_launch for a full description. This function
+ * additionally attempts to launch the application on a given screen
+ * and workspace.
+ *
+ * Returns: The the pid of the process spawned.  If more then one
+ * process was spawned the last pid is returned.  On error -1
+ * is returned and @error is set.
+ */
+int
+mate_desktop_item_launch_on_screen (const MateDesktopItem       *item,
+				     GList                        *file_list,
+				     MateDesktopItemLaunchFlags   flags,
+				     GdkScreen                    *screen,
+				     int                           workspace,
+				     GError                      **error)
+{
+	return mate_desktop_item_launch_on_screen_with_env (
+			item, file_list, flags,
+			screen, workspace, NULL, error);
+}
+
+/**
+ * mate_desktop_item_drop_uri_list:
+ * @item: A desktop item
+ * @uri_list: text as gotten from a text/uri-list
+ * @flags: FIXME
+ * @error: FIXME
+ *
+ * A list of files or urls dropped onto an icon, the proper (Url or File)
+ * exec is run you can pass directly string that you got as the
+ * text/uri-list.  This just parses the list and calls
+ *
+ * Returns: The value returned by #mate_execute_async() upon execution of
+ * the specified item or -1 on error.  If multiple instances are run, the
+ * return of the last one is returned.
+ */
+int
+mate_desktop_item_drop_uri_list (const MateDesktopItem *item,
+				  const char *uri_list,
+				  MateDesktopItemLaunchFlags flags,
+				  GError **error)
+{
+	return mate_desktop_item_drop_uri_list_with_env (item, uri_list,
+							  flags, NULL, error);
+}
+
+/**
+* mate_desktop_item_drop_uri_list_with_env:
+* @item: A desktop item
+* @uri_list: text as gotten from a text/uri-list
+* @flags: FIXME
+* @envp: child's environment
+* @error: FIXME
+*
+* See mate_desktop_item_drop_uri_list for a full description. This function
+* additionally passes an environment vector for the child process
+* which is to be launched.
+*
+* Returns: The value returned by #mate_execute_async() upon execution of
+* the specified item or -1 on error.  If multiple instances are run, the
+* return of the last one is returned.
+*/
+int
+mate_desktop_item_drop_uri_list_with_env (const MateDesktopItem *item,
+					   const char *uri_list,
+					   MateDesktopItemLaunchFlags flags,
+					   char                        **envp,
+					   GError **error)
+{
+	int ret;
+	char  *uri;
+	char **uris;
+	GList *list = NULL;
+
+	uris = g_uri_list_extract_uris (uri_list);
+
+	for (uri = uris[0]; uri != NULL; uri++) {
+		list = g_list_prepend (list, uri);
+	}
+	list = g_list_reverse (list);
+
+	ret =  mate_desktop_item_launch_with_env (
+			item, list, flags, envp, error);
+
+	g_strfreev (uris);
+	g_list_free (list);
+
+	return ret;
+}
+
+static gboolean
+exec_exists (const char *exec)
+{
+	if (g_path_is_absolute (exec)) {
+		if (access (exec, X_OK) == 0)
+			return TRUE;
+		else
+			return FALSE;
+	} else {
+		char *tryme;
+
+		tryme = g_find_program_in_path (exec);
+		if (tryme != NULL) {
+			g_free (tryme);
+			return TRUE;
+		}
+		return FALSE;
+	}
+}
+
+/**
+ * mate_desktop_item_exists:
+ * @item: A desktop item
+ *
+ * Attempt to figure out if the program that can be executed by this item
+ * actually exists.  First it tries the TryExec attribute to see if that
+ * contains a program that is in the path.  Then if there is no such
+ * attribute, it tries the first word of the Exec attribute.
+ *
+ * Returns: A boolean, %TRUE if it exists, %FALSE otherwise.
+ */
+gboolean
+mate_desktop_item_exists (const MateDesktopItem *item)
+{
+	const char *try_exec;
+	const char *exec;
+
+	g_return_val_if_fail (item != NULL, FALSE);
+
+	try_exec = lookup (item, MATE_DESKTOP_ITEM_TRY_EXEC);
+
+	if (try_exec != NULL &&
+	    ! exec_exists (try_exec)) {
+		return FALSE;
+	}
+
+	if (item->type == MATE_DESKTOP_ITEM_TYPE_APPLICATION) {
+		int argc;
+		char **argv;
+		const char *exe;
+
+		exec = lookup (item, MATE_DESKTOP_ITEM_EXEC);
+		if (exec == NULL)
+			return FALSE;
+
+		if ( ! g_shell_parse_argv (exec, &argc, &argv, NULL))
+			return FALSE;
+
+		if (argc < 1) {
+			g_strfreev (argv);
+			return FALSE;
+		}
+
+		exe = argv[0];
+
+		if ( ! exec_exists (exe)) {
+			g_strfreev (argv);
+			return FALSE;
+		}
+		g_strfreev (argv);
+	}
+
+	return TRUE;
+}
+
+/**
+ * mate_desktop_item_get_entry_type:
+ * @item: A desktop item
+ *
+ * Gets the type attribute (the 'Type' field) of the item.  This should
+ * usually be 'Application' for an application, but it can be 'Directory'
+ * for a directory description.  There are other types available as well.
+ * The type usually indicates how the desktop item should be handeled and
+ * how the 'Exec' field should be handeled.
+ *
+ * Returns: The type of the specified 'item'. The returned
+ * memory remains owned by the MateDesktopItem and should not be freed.
+ */
+MateDesktopItemType
+mate_desktop_item_get_entry_type (const MateDesktopItem *item)
+{
+	g_return_val_if_fail (item != NULL, 0);
+	g_return_val_if_fail (item->refcount > 0, 0);
+
+	return item->type;
+}
+
+void
+mate_desktop_item_set_entry_type (MateDesktopItem *item,
+				   MateDesktopItemType type)
+{
+	g_return_if_fail (item != NULL);
+	g_return_if_fail (item->refcount > 0);
+
+	item->type = type;
+
+	switch (type) {
+	case MATE_DESKTOP_ITEM_TYPE_NULL:
+		set (item, MATE_DESKTOP_ITEM_TYPE, NULL);
+		break;
+	case MATE_DESKTOP_ITEM_TYPE_APPLICATION:
+		set (item, MATE_DESKTOP_ITEM_TYPE, "Application");
+		break;
+	case MATE_DESKTOP_ITEM_TYPE_LINK:
+		set (item, MATE_DESKTOP_ITEM_TYPE, "Link");
+		break;
+	case MATE_DESKTOP_ITEM_TYPE_FSDEVICE:
+		set (item, MATE_DESKTOP_ITEM_TYPE, "FSDevice");
+		break;
+	case MATE_DESKTOP_ITEM_TYPE_MIME_TYPE:
+		set (item, MATE_DESKTOP_ITEM_TYPE, "MimeType");
+		break;
+	case MATE_DESKTOP_ITEM_TYPE_DIRECTORY:
+		set (item, MATE_DESKTOP_ITEM_TYPE, "Directory");
+		break;
+	case MATE_DESKTOP_ITEM_TYPE_SERVICE:
+		set (item, MATE_DESKTOP_ITEM_TYPE, "Service");
+		break;
+	case MATE_DESKTOP_ITEM_TYPE_SERVICE_TYPE:
+		set (item, MATE_DESKTOP_ITEM_TYPE, "ServiceType");
+		break;
+	default:
+		break;
+	}
+}
+
+
+
+/**
+ * mate_desktop_item_get_file_status:
+ * @item: A desktop item
+ *
+ * This function checks the modification time of the on-disk file to
+ * see if it is more recent than the in-memory data.
+ *
+ * Returns: An enum value that specifies whether the item has changed since being loaded.
+ */
+MateDesktopItemStatus
+mate_desktop_item_get_file_status (const MateDesktopItem *item)
+{
+	MateDesktopItemStatus retval;
+	GFile *file;
+	GFileInfo *info;
+
+	g_return_val_if_fail (item != NULL, MATE_DESKTOP_ITEM_DISAPPEARED);
+	g_return_val_if_fail (item->refcount > 0, MATE_DESKTOP_ITEM_DISAPPEARED);
+
+	if (item->location == NULL)
+		return MATE_DESKTOP_ITEM_DISAPPEARED;
+
+	file = g_file_new_for_uri (item->location);
+	info = g_file_query_info (file, G_FILE_ATTRIBUTE_TIME_MODIFIED,
+				  G_FILE_QUERY_INFO_NONE, NULL, NULL);
+
+	retval = MATE_DESKTOP_ITEM_UNCHANGED;
+
+	if (!g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_TIME_MODIFIED))
+		retval = MATE_DESKTOP_ITEM_DISAPPEARED;
+	else if (item->mtime < g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED))
+		retval = MATE_DESKTOP_ITEM_CHANGED;
+
+	g_object_unref (info);
+	g_object_unref (file);
+
+	return retval;
+}
+
+/**
+ * mate_desktop_item_find_icon:
+ * @icon_theme: a #GtkIconTheme
+ * @icon: icon name, something you'd get out of the Icon key
+ * @desired_size: FIXME
+ * @flags: FIXME
+ *
+ * Description:  This function goes and looks for the icon file.  If the icon
+ * is not an absolute filename, this will look for it in the standard places.
+ * If it can't find the icon, it will return %NULL
+ *
+ * Returns: A newly allocated string
+ */
+char *
+mate_desktop_item_find_icon (GtkIconTheme *icon_theme,
+			      const char *icon,
+			      int desired_size,
+			      int flags)
+{
+	GtkIconInfo *info;
+	char *full = NULL;
+
+	g_return_val_if_fail (icon_theme == NULL ||
+			      GTK_IS_ICON_THEME (icon_theme), NULL);
+
+	if (icon == NULL || strcmp(icon,"") == 0) {
+		return NULL;
+	} else if (g_path_is_absolute (icon)) {
+		if (g_file_test (icon, G_FILE_TEST_EXISTS)) {
+			return g_strdup (icon);
+		} else {
+			return NULL;
+		}
+	} else {
+		char *icon_no_extension;
+		char *p;
+
+		if (icon_theme == NULL)
+			icon_theme = gtk_icon_theme_get_default ();
+
+		icon_no_extension = g_strdup (icon);
+		p = strrchr (icon_no_extension, '.');
+		if (p &&
+		    (strcmp (p, ".png") == 0 ||
+		     strcmp (p, ".xpm") == 0 ||
+		     strcmp (p, ".svg") == 0)) {
+		    *p = 0;
+		}
+
+
+		info = gtk_icon_theme_lookup_icon (icon_theme,
+						   icon_no_extension,
+						   desired_size,
+						   0);
+
+		full = NULL;
+		if (info) {
+			full = g_strdup (gtk_icon_info_get_filename (info));
+			gtk_icon_info_free (info);
+		}
+		g_free (icon_no_extension);
+	}
+
+	return full;
+
+}
+
+/**
+ * mate_desktop_item_get_icon:
+ * @icon_theme: a #GtkIconTheme
+ * @item: A desktop item
+ *
+ * Description:  This function goes and looks for the icon file.  If the icon
+ * is not set as an absolute filename, this will look for it in the standard places.
+ * If it can't find the icon, it will return %NULL
+ *
+ * Returns: A newly allocated string
+ */
+char *
+mate_desktop_item_get_icon (const MateDesktopItem *item,
+			     GtkIconTheme *icon_theme)
+{
+	/* maybe this function should be deprecated in favour of find icon
+	 * -George */
+	const char *icon;
+
+	g_return_val_if_fail (item != NULL, NULL);
+	g_return_val_if_fail (item->refcount > 0, NULL);
+
+	icon = mate_desktop_item_get_string (item, MATE_DESKTOP_ITEM_ICON);
+
+	return mate_desktop_item_find_icon (icon_theme, icon,
+					     48 /* desired_size */,
+					     0 /* flags */);
+}
+
+/**
+ * mate_desktop_item_get_location:
+ * @item: A desktop item
+ *
+ * Returns: The file location associated with 'item'.
+ *
+ */
+const char *
+mate_desktop_item_get_location (const MateDesktopItem *item)
+{
+	g_return_val_if_fail (item != NULL, NULL);
+	g_return_val_if_fail (item->refcount > 0, NULL);
+
+	return item->location;
+}
+
+/**
+ * mate_desktop_item_set_location:
+ * @item: A desktop item
+ * @location: A uri string specifying the file location of this particular item.
+ *
+ * Set's the 'location' uri of this item.
+ */
+void
+mate_desktop_item_set_location (MateDesktopItem *item, const char *location)
+{
+	g_return_if_fail (item != NULL);
+	g_return_if_fail (item->refcount > 0);
+
+	if (item->location != NULL &&
+	    location != NULL &&
+	    strcmp (item->location, location) == 0)
+		return;
+
+	g_free (item->location);
+	item->location = g_strdup (location);
+
+	/* This is ugly, but useful internally */
+	if (item->mtime != DONT_UPDATE_MTIME) {
+		item->mtime = 0;
+
+		if (item->location) {
+			GFile     *file;
+			GFileInfo *info;
+
+			file = g_file_new_for_uri (item->location);
+
+			info = g_file_query_info (file,
+						  G_FILE_ATTRIBUTE_TIME_MODIFIED,
+						  G_FILE_QUERY_INFO_NONE,
+						  NULL, NULL);
+			if (info) {
+				if (g_file_info_has_attribute (info,
+							       G_FILE_ATTRIBUTE_TIME_MODIFIED))
+					item->mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
+				g_object_unref (info);
+			}
+
+			g_object_unref (file);
+		}
+	}
+
+	/* Make sure that save actually saves */
+	item->modified = TRUE;
+}
+
+/**
+ * mate_desktop_item_set_location_file:
+ * @item: A desktop item
+ * @file: A local filename specifying the file location of this particular item.
+ *
+ * Set's the 'location' uri of this item to the given @file.
+ */
+void
+mate_desktop_item_set_location_file (MateDesktopItem *item, const char *file)
+{
+	g_return_if_fail (item != NULL);
+	g_return_if_fail (item->refcount > 0);
+
+	if (file != NULL) {
+		GFile *gfile;
+
+		gfile = g_file_new_for_path (file);
+		mate_desktop_item_set_location_gfile (item, gfile);
+		g_object_unref (gfile);
+	} else {
+		mate_desktop_item_set_location (item, NULL);
+	}
+}
+
+static void
+mate_desktop_item_set_location_gfile (MateDesktopItem *item, GFile *file)
+{
+	g_return_if_fail (item != NULL);
+	g_return_if_fail (item->refcount > 0);
+
+	if (file != NULL) {
+		char *uri;
+
+		uri = g_file_get_uri (file);
+		mate_desktop_item_set_location (item, uri);
+		g_free (uri);
+	} else {
+		mate_desktop_item_set_location (item, NULL);
+	}
+}
+
+/*
+ * Reading/Writing different sections, NULL is the standard section
+ */
+
+gboolean
+mate_desktop_item_attr_exists (const MateDesktopItem *item,
+				const char *attr)
+{
+	g_return_val_if_fail (item != NULL, FALSE);
+	g_return_val_if_fail (item->refcount > 0, FALSE);
+	g_return_val_if_fail (attr != NULL, FALSE);
+
+	return lookup (item, attr) != NULL;
+}
+
+/*
+ * String type
+ */
+const char *
+mate_desktop_item_get_string (const MateDesktopItem *item,
+			       const char *attr)
+{
+	g_return_val_if_fail (item != NULL, NULL);
+	g_return_val_if_fail (item->refcount > 0, NULL);
+	g_return_val_if_fail (attr != NULL, NULL);
+
+	return lookup (item, attr);
+}
+
+void
+mate_desktop_item_set_string (MateDesktopItem *item,
+			       const char *attr,
+			       const char *value)
+{
+	g_return_if_fail (item != NULL);
+	g_return_if_fail (item->refcount > 0);
+	g_return_if_fail (attr != NULL);
+
+	set (item, attr, value);
+
+	if (strcmp (attr, MATE_DESKTOP_ITEM_TYPE) == 0)
+		item->type = type_from_string (value);
+}
+
+/*
+ * LocaleString type
+ */
+const char* mate_desktop_item_get_localestring(const MateDesktopItem* item, const char* attr)
+{
+	g_return_val_if_fail(item != NULL, NULL);
+	g_return_val_if_fail(item->refcount > 0, NULL);
+	g_return_val_if_fail(attr != NULL, NULL);
+
+	return lookup_best_locale(item, attr);
+}
+
+const char* mate_desktop_item_get_localestring_lang(const MateDesktopItem* item, const char* attr, const char* language)
+{
+	g_return_val_if_fail(item != NULL, NULL);
+	g_return_val_if_fail(item->refcount > 0, NULL);
+	g_return_val_if_fail(attr != NULL, NULL);
+
+	return lookup_locale(item, attr, language);
+}
+
+/**
+ * mate_desktop_item_get_string_locale:
+ * @item: A desktop item
+ * @attr: An attribute name
+ *
+ * Returns the current locale that is used for the given attribute.
+ * This might not be the same for all attributes. For example, if your
+ * locale is "en_US.ISO8859-1" but attribute FOO only has "en_US" then
+ * that would be returned for attr = "FOO". If attribute BAR has
+ * "en_US.ISO8859-1" then that would be returned for "BAR".
+ *
+ * Returns: a string equal to the current locale or NULL
+ * if the attribute is invalid or there is no matching locale.
+ */
+const char *
+mate_desktop_item_get_attr_locale (const MateDesktopItem *item,
+				    const char             *attr)
+{
+	const char * const *langs_pointer;
+	int                 i;
+
+	langs_pointer = g_get_language_names ();
+	for (i = 0; langs_pointer[i] != NULL; i++) {
+		const char *value = NULL;
+
+		value = lookup_locale (item, attr, langs_pointer[i]);
+		if (value)
+			return langs_pointer[i];
+	}
+
+	return NULL;
+}
+
+GList *
+mate_desktop_item_get_languages (const MateDesktopItem *item,
+				  const char *attr)
+{
+	GList *li;
+	GList *list = NULL;
+
+	g_return_val_if_fail (item != NULL, NULL);
+	g_return_val_if_fail (item->refcount > 0, NULL);
+
+	for (li = item->languages; li != NULL; li = li->next) {
+		char *language = li->data;
+		if (attr == NULL ||
+		    lookup_locale (item, attr, language) != NULL) {
+			list = g_list_prepend (list, language);
+		}
+	}
+
+	return g_list_reverse (list);
+}
+
+static const char *
+get_language (void)
+{
+	const char * const *langs_pointer;
+	int                 i;
+
+	langs_pointer = g_get_language_names ();
+	for (i = 0; langs_pointer[i] != NULL; i++) {
+		/* find first without encoding  */
+		if (strchr (langs_pointer[i], '.') == NULL) {
+			return langs_pointer[i];
+		}
+	}
+	return NULL;
+}
+
+void
+mate_desktop_item_set_localestring (MateDesktopItem *item,
+				     const char *attr,
+				     const char *value)
+{
+	g_return_if_fail (item != NULL);
+	g_return_if_fail (item->refcount > 0);
+	g_return_if_fail (attr != NULL);
+
+	set_locale (item, attr, get_language (), value);
+}
+
+void
+mate_desktop_item_set_localestring_lang (MateDesktopItem *item,
+					  const char *attr,
+					  const char *language,
+					  const char *value)
+{
+	g_return_if_fail (item != NULL);
+	g_return_if_fail (item->refcount > 0);
+	g_return_if_fail (attr != NULL);
+
+	set_locale (item, attr, language, value);
+}
+
+void
+mate_desktop_item_clear_localestring (MateDesktopItem *item,
+				       const char *attr)
+{
+	GList *l;
+
+	g_return_if_fail (item != NULL);
+	g_return_if_fail (item->refcount > 0);
+	g_return_if_fail (attr != NULL);
+
+	for (l = item->languages; l != NULL; l = l->next)
+		set_locale (item, attr, l->data, NULL);
+
+	set (item, attr, NULL);
+}
+
+/*
+ * Strings, Regexps types
+ */
+
+char **
+mate_desktop_item_get_strings (const MateDesktopItem *item,
+				const char *attr)
+{
+	const char *value;
+
+	g_return_val_if_fail (item != NULL, NULL);
+	g_return_val_if_fail (item->refcount > 0, NULL);
+	g_return_val_if_fail (attr != NULL, NULL);
+
+	value = lookup (item, attr);
+	if (value == NULL)
+		return NULL;
+
+	/* FIXME: there's no way to escape semicolons apparently */
+	return g_strsplit (value, ";", -1);
+}
+
+void
+mate_desktop_item_set_strings (MateDesktopItem *item,
+				const char *attr,
+				char **strings)
+{
+	char *str, *str2;
+
+	g_return_if_fail (item != NULL);
+	g_return_if_fail (item->refcount > 0);
+	g_return_if_fail (attr != NULL);
+
+	str = g_strjoinv (";", strings);
+	str2 = g_strconcat (str, ";", NULL);
+	/* FIXME: there's no way to escape semicolons apparently */
+	set (item, attr, str2);
+	g_free (str);
+	g_free (str2);
+}
+
+/*
+ * Boolean type
+ */
+gboolean
+mate_desktop_item_get_boolean (const MateDesktopItem *item,
+				const char *attr)
+{
+	const char *value;
+
+	g_return_val_if_fail (item != NULL, FALSE);
+	g_return_val_if_fail (item->refcount > 0, FALSE);
+	g_return_val_if_fail (attr != NULL, FALSE);
+
+	value = lookup (item, attr);
+	if (value == NULL)
+		return FALSE;
+
+	return (value[0] == 'T' ||
+		value[0] == 't' ||
+		value[0] == 'Y' ||
+		value[0] == 'y' ||
+		atoi (value) != 0);
+}
+
+void
+mate_desktop_item_set_boolean (MateDesktopItem *item,
+				const char *attr,
+				gboolean value)
+{
+	g_return_if_fail (item != NULL);
+	g_return_if_fail (item->refcount > 0);
+	g_return_if_fail (attr != NULL);
+
+	set (item, attr, value ? "true" : "false");
+}
+
+void
+mate_desktop_item_set_launch_time (MateDesktopItem *item,
+				    guint32           timestamp)
+{
+	g_return_if_fail (item != NULL);
+
+	item->launch_time = timestamp;
+}
+
+/*
+ * Clearing attributes
+ */
+void
+mate_desktop_item_clear_section (MateDesktopItem *item,
+				  const char *section)
+{
+	Section *sec;
+	GList *li;
+
+	g_return_if_fail (item != NULL);
+	g_return_if_fail (item->refcount > 0);
+
+	sec = find_section (item, section);
+
+	if (sec == NULL) {
+		for (li = item->keys; li != NULL; li = li->next) {
+			g_hash_table_remove (item->main_hash, li->data);
+			g_free (li->data);
+			li->data = NULL;
+		}
+		g_list_free (item->keys);
+		item->keys = NULL;
+	} else {
+		for (li = sec->keys; li != NULL; li = li->next) {
+			char *key = li->data;
+			char *full = g_strdup_printf ("%s/%s",
+						      sec->name, key);
+			g_hash_table_remove (item->main_hash, full);
+			g_free (full);
+			g_free (key);
+			li->data = NULL;
+		}
+		g_list_free (sec->keys);
+		sec->keys = NULL;
+	}
+	item->modified = TRUE;
+}
+
+/************************************************************
+ * Parser:                                                  *
+ ************************************************************/
+
+static gboolean G_GNUC_CONST
+standard_is_boolean (const char * key)
+{
+	static GHashTable *bools = NULL;
+
+	if (bools == NULL) {
+		bools = g_hash_table_new (g_str_hash, g_str_equal);
+		g_hash_table_insert (bools,
+				     MATE_DESKTOP_ITEM_NO_DISPLAY,
+				     MATE_DESKTOP_ITEM_NO_DISPLAY);
+		g_hash_table_insert (bools,
+				     MATE_DESKTOP_ITEM_HIDDEN,
+				     MATE_DESKTOP_ITEM_HIDDEN);
+		g_hash_table_insert (bools,
+				     MATE_DESKTOP_ITEM_TERMINAL,
+				     MATE_DESKTOP_ITEM_TERMINAL);
+		g_hash_table_insert (bools,
+				     MATE_DESKTOP_ITEM_READ_ONLY,
+				     MATE_DESKTOP_ITEM_READ_ONLY);
+	}
+
+	return g_hash_table_lookup (bools, key) != NULL;
+}
+
+static gboolean G_GNUC_CONST
+standard_is_strings (const char *key)
+{
+	static GHashTable *strings = NULL;
+
+	if (strings == NULL) {
+		strings = g_hash_table_new (g_str_hash, g_str_equal);
+		g_hash_table_insert (strings,
+				     MATE_DESKTOP_ITEM_FILE_PATTERN,
+				     MATE_DESKTOP_ITEM_FILE_PATTERN);
+		g_hash_table_insert (strings,
+				     MATE_DESKTOP_ITEM_ACTIONS,
+				     MATE_DESKTOP_ITEM_ACTIONS);
+		g_hash_table_insert (strings,
+				     MATE_DESKTOP_ITEM_MIME_TYPE,
+				     MATE_DESKTOP_ITEM_MIME_TYPE);
+		g_hash_table_insert (strings,
+				     MATE_DESKTOP_ITEM_PATTERNS,
+				     MATE_DESKTOP_ITEM_PATTERNS);
+		g_hash_table_insert (strings,
+				     MATE_DESKTOP_ITEM_SORT_ORDER,
+				     MATE_DESKTOP_ITEM_SORT_ORDER);
+	}
+
+	return g_hash_table_lookup (strings, key) != NULL;
+}
+
+/* If no need to cannonize, returns NULL */
+static char *
+cannonize (const char *key, const char *value)
+{
+	if (standard_is_boolean (key)) {
+		if (value[0] == 'T' ||
+		    value[0] == 't' ||
+		    value[0] == 'Y' ||
+		    value[0] == 'y' ||
+		    atoi (value) != 0) {
+			return g_strdup ("true");
+		} else {
+			return g_strdup ("false");
+		}
+	} else if (standard_is_strings (key)) {
+		int len = strlen (value);
+		if (len == 0 || value[len-1] != ';') {
+			return g_strconcat (value, ";", NULL);
+		}
+	}
+	/* XXX: Perhaps we should canonize numeric values as well, but this
+	 * has caused some subtle problems before so it needs to be done
+	 * carefully if at all */
+	return NULL;
+}
+
+
+static char *
+decode_string_and_dup (const char *s)
+{
+	char *p = g_malloc (strlen (s) + 1);
+	char *q = p;
+
+	do {
+		if (*s == '\\'){
+			switch (*(++s)){
+			case 's':
+				*p++ = ' ';
+				break;
+			case 't':
+				*p++ = '\t';
+				break;
+			case 'n':
+				*p++ = '\n';
+				break;
+			case '\\':
+				*p++ = '\\';
+				break;
+			case 'r':
+				*p++ = '\r';
+				break;
+			default:
+				*p++ = '\\';
+				*p++ = *s;
+				break;
+			}
+		} else {
+			*p++ = *s;
+		}
+	} while (*s++);
+
+	return q;
+}
+
+static char *
+escape_string_and_dup (const char *s)
+{
+	char *return_value, *p;
+	const char *q;
+	int len = 0;
+
+	if (s == NULL)
+		return g_strdup("");
+
+	q = s;
+	while (*q){
+		len++;
+		if (strchr ("\n\r\t\\", *q) != NULL)
+			len++;
+		q++;
+	}
+	return_value = p = (char *) g_malloc (len + 1);
+	do {
+		switch (*s){
+		case '\t':
+			*p++ = '\\';
+			*p++ = 't';
+			break;
+		case '\n':
+			*p++ = '\\';
+			*p++ = 'n';
+			break;
+		case '\r':
+			*p++ = '\\';
+			*p++ = 'r';
+			break;
+		case '\\':
+			*p++ = '\\';
+			*p++ = '\\';
+			break;
+		default:
+			*p++ = *s;
+		}
+	} while (*s++);
+	return return_value;
+}
+
+static gboolean
+check_locale (const char *locale)
+{
+	GIConv cd = g_iconv_open ("UTF-8", locale);
+	if ((GIConv)-1 == cd)
+		return FALSE;
+	g_iconv_close (cd);
+	return TRUE;
+}
+
+static void
+insert_locales (GHashTable *encodings, char *enc, ...)
+{
+	va_list args;
+	char *s;
+
+	va_start (args, enc);
+	for (;;) {
+		s = va_arg (args, char *);
+		if (s == NULL)
+			break;
+		g_hash_table_insert (encodings, s, enc);
+	}
+	va_end (args);
+}
+
+/* make a standard conversion table from the desktop standard spec */
+static GHashTable *
+init_encodings (void)
+{
+	GHashTable *encodings = g_hash_table_new (g_str_hash, g_str_equal);
+
+	/* "C" is plain ascii */
+	insert_locales (encodings, "ASCII", "C", NULL);
+
+	insert_locales (encodings, "ARMSCII-8", "by", NULL);
+	insert_locales (encodings, "BIG5", "zh_TW", NULL);
+	insert_locales (encodings, "CP1251", "be", "bg", NULL);
+	if (check_locale ("EUC-CN")) {
+		insert_locales (encodings, "EUC-CN", "zh_CN", NULL);
+	} else {
+		insert_locales (encodings, "GB2312", "zh_CN", NULL);
+	}
+	insert_locales (encodings, "EUC-JP", "ja", NULL);
+	insert_locales (encodings, "EUC-KR", "ko", NULL);
+	/*insert_locales (encodings, "GEORGIAN-ACADEMY", NULL);*/
+	insert_locales (encodings, "GEORGIAN-PS", "ka", NULL);
+	insert_locales (encodings, "ISO-8859-1", "br", "ca", "da", "de", "en", "es", "eu", "fi", "fr", "gl", "it", "nl", "wa", "no", "pt", "pt", "sv", NULL);
+	insert_locales (encodings, "ISO-8859-2", "cs", "hr", "hu", "pl", "ro", "sk", "sl", "sq", "sr", NULL);
+	insert_locales (encodings, "ISO-8859-3", "eo", NULL);
+	insert_locales (encodings, "ISO-8859-5", "mk", "sp", NULL);
+	insert_locales (encodings, "ISO-8859-7", "el", NULL);
+	insert_locales (encodings, "ISO-8859-9", "tr", NULL);
+	insert_locales (encodings, "ISO-8859-13", "lt", "lv", "mi", NULL);
+	insert_locales (encodings, "ISO-8859-14", "ga", "cy", NULL);
+	insert_locales (encodings, "ISO-8859-15", "et", NULL);
+	insert_locales (encodings, "KOI8-R", "ru", NULL);
+	insert_locales (encodings, "KOI8-U", "uk", NULL);
+	if (check_locale ("TCVN-5712")) {
+		insert_locales (encodings, "TCVN-5712", "vi", NULL);
+	} else {
+		insert_locales (encodings, "TCVN", "vi", NULL);
+	}
+	insert_locales (encodings, "TIS-620", "th", NULL);
+	/*insert_locales (encodings, "VISCII", NULL);*/
+
+	return encodings;
+}
+
+static const char *
+get_encoding_from_locale (const char *locale)
+{
+	char lang[3];
+	const char *encoding;
+	static GHashTable *encodings = NULL;
+
+	if (locale == NULL)
+		return NULL;
+
+	/* if locale includes encoding, use it */
+	encoding = strchr (locale, '.');
+	if (encoding != NULL) {
+		return encoding+1;
+	}
+
+	if (encodings == NULL)
+		encodings = init_encodings ();
+
+	/* first try the entire locale (at this point ll_CC) */
+	encoding = g_hash_table_lookup (encodings, locale);
+	if (encoding != NULL)
+		return encoding;
+
+	/* Try just the language */
+	strncpy (lang, locale, 2);
+	lang[2] = '\0';
+	return g_hash_table_lookup (encodings, lang);
+}
+
+static Encoding
+get_encoding (ReadBuf *rb)
+{
+	gboolean old_kde = FALSE;
+	char     buf [BUFSIZ];
+	gboolean all_valid_utf8 = TRUE;
+
+	while (readbuf_gets (buf, sizeof (buf), rb) != NULL) {
+		if (strncmp (MATE_DESKTOP_ITEM_ENCODING,
+			     buf,
+			     strlen (MATE_DESKTOP_ITEM_ENCODING)) == 0) {
+			char *p = &buf[strlen (MATE_DESKTOP_ITEM_ENCODING)];
+			if (*p == ' ')
+				p++;
+			if (*p != '=')
+				continue;
+			p++;
+			if (*p == ' ')
+				p++;
+			if (strcmp (p, "UTF-8") == 0) {
+				return ENCODING_UTF8;
+			} else if (strcmp (p, "Legacy-Mixed") == 0) {
+				return ENCODING_LEGACY_MIXED;
+			} else {
+				/* According to the spec we're not supposed
+				 * to read a file like this */
+				return ENCODING_UNKNOWN;
+			}
+		} else if (strcmp ("[KDE Desktop Entry]", buf) == 0) {
+			old_kde = TRUE;
+			/* don't break yet, we still want to support
+			 * Encoding even here */
+		}
+		if (all_valid_utf8 && ! g_utf8_validate (buf, -1, NULL))
+			all_valid_utf8 = FALSE;
+	}
+
+	if (old_kde)
+		return ENCODING_LEGACY_MIXED;
+
+	/* try to guess by location */
+	if (rb->uri != NULL && strstr (rb->uri, "mate/apps/") != NULL) {
+		/* old mate */
+		return ENCODING_LEGACY_MIXED;
+	}
+
+	/* A dilemma, new KDE files are in UTF-8 but have no Encoding
+	 * info, at this time we really can't tell.  The best thing to
+	 * do right now is to just assume UTF-8 if the whole file
+	 * validates as utf8 I suppose */
+
+	if (all_valid_utf8)
+		return ENCODING_UTF8;
+	else
+		return ENCODING_LEGACY_MIXED;
+}
+
+static char *
+decode_string (const char *value, Encoding encoding, const char *locale)
+{
+	char *retval = NULL;
+
+	/* if legacy mixed, then convert */
+	if (locale != NULL && encoding == ENCODING_LEGACY_MIXED) {
+		const char *char_encoding = get_encoding_from_locale (locale);
+		char *utf8_string;
+		if (char_encoding == NULL)
+			return NULL;
+		if (strcmp (char_encoding, "ASCII") == 0) {
+			return decode_string_and_dup (value);
+		}
+		utf8_string = g_convert (value, -1, "UTF-8", char_encoding,
+					NULL, NULL, NULL);
+		if (utf8_string == NULL)
+			return NULL;
+		retval = decode_string_and_dup (utf8_string);
+		g_free (utf8_string);
+		return retval;
+	/* if utf8, then validate */
+	} else if (locale != NULL && encoding == ENCODING_UTF8) {
+		if ( ! g_utf8_validate (value, -1, NULL))
+			/* invalid utf8, ignore this key */
+			return NULL;
+		return decode_string_and_dup (value);
+	} else {
+		/* Meaning this is not a localized string */
+		return decode_string_and_dup (value);
+	}
+}
+
+static char *
+snarf_locale_from_key (const char *key)
+{
+	const char *brace;
+	char *locale, *p;
+
+	brace = strchr (key, '[');
+	if (brace == NULL)
+		return NULL;
+
+	locale = g_strdup (brace + 1);
+	if (*locale == '\0') {
+		g_free (locale);
+		return NULL;
+	}
+	p = strchr (locale, ']');
+	if (p == NULL) {
+		g_free (locale);
+		return NULL;
+	}
+	*p = '\0';
+	return locale;
+}
+
+static void
+insert_key (MateDesktopItem *item,
+	    Section *cur_section,
+	    Encoding encoding,
+	    const char *key,
+	    const char *value,
+	    gboolean old_kde,
+	    gboolean no_translations)
+{
+	char *k;
+	char *val;
+	/* we always store everything in UTF-8 */
+	if (cur_section == NULL &&
+	    strcmp (key, MATE_DESKTOP_ITEM_ENCODING) == 0) {
+		k = g_strdup (key);
+		val = g_strdup ("UTF-8");
+	} else {
+		char *locale = snarf_locale_from_key (key);
+		/* If we're ignoring translations */
+		if (no_translations && locale != NULL) {
+			g_free (locale);
+			return;
+		}
+		val = decode_string (value, encoding, locale);
+
+		/* Ignore this key, it's whacked */
+		if (val == NULL) {
+			g_free (locale);
+			return;
+		}
+
+		g_strchomp (val);
+
+		/* For old KDE entries, we can also split by a comma
+		 * on sort order, so convert to semicolons */
+		if (old_kde &&
+		    cur_section == NULL &&
+		    strcmp (key, MATE_DESKTOP_ITEM_SORT_ORDER) == 0 &&
+		    strchr (val, ';') == NULL) {
+			int i;
+			for (i = 0; val[i] != '\0'; i++) {
+				if (val[i] == ',')
+					val[i] = ';';
+			}
+		}
+
+		/* Check some types, not perfect, but catches a lot
+		 * of things */
+		if (cur_section == NULL) {
+			char *cannon = cannonize (key, val);
+			if (cannon != NULL) {
+				g_free (val);
+				val = cannon;
+			}
+		}
+
+		k = g_strdup (key);
+
+		/* Take care of the language part */
+		if (locale != NULL &&
+		    strcmp (locale, "C") == 0) {
+			char *p;
+			/* Whack C locale */
+			p = strchr (k, '[');
+			*p = '\0';
+			g_free (locale);
+		} else if (locale != NULL) {
+			char *p, *brace;
+
+			/* Whack the encoding part */
+			p = strchr (locale, '.');
+			if (p != NULL)
+				*p = '\0';
+
+			if (g_list_find_custom (item->languages, locale,
+						(GCompareFunc)strcmp) == NULL) {
+				item->languages = g_list_prepend
+					(item->languages, locale);
+			} else {
+				g_free (locale);
+			}
+
+			/* Whack encoding from encoding in the key */
+			brace = strchr (k, '[');
+			p = strchr (brace, '.');
+			if (p != NULL) {
+				*p = ']';
+				*(p+1) = '\0';
+			}
+		}
+	}
+
+
+	if (cur_section == NULL) {
+		/* only add to list if we haven't seen it before */
+		if (g_hash_table_lookup (item->main_hash, k) == NULL) {
+			item->keys = g_list_prepend (item->keys,
+						     g_strdup (k));
+		}
+		/* later duplicates override earlier ones */
+		g_hash_table_replace (item->main_hash, k, val);
+	} else {
+		char *full = g_strdup_printf
+			("%s/%s",
+			 cur_section->name, k);
+		/* only add to list if we haven't seen it before */
+		if (g_hash_table_lookup (item->main_hash, full) == NULL) {
+			cur_section->keys =
+				g_list_prepend (cur_section->keys, k);
+		}
+		/* later duplicates override earlier ones */
+		g_hash_table_replace (item->main_hash,
+				      full, val);
+	}
+}
+
+static void
+setup_type (MateDesktopItem *item, const char *uri)
+{
+	const char *type = g_hash_table_lookup (item->main_hash,
+						MATE_DESKTOP_ITEM_TYPE);
+	if (type == NULL && uri != NULL) {
+		char *base = g_path_get_basename (uri);
+		if (base != NULL &&
+		    strcmp (base, ".directory") == 0) {
+			/* This gotta be a directory */
+			g_hash_table_replace (item->main_hash,
+					      g_strdup (MATE_DESKTOP_ITEM_TYPE),
+					      g_strdup ("Directory"));
+			item->keys = g_list_prepend
+				(item->keys, g_strdup (MATE_DESKTOP_ITEM_TYPE));
+			item->type = MATE_DESKTOP_ITEM_TYPE_DIRECTORY;
+		} else {
+			item->type = MATE_DESKTOP_ITEM_TYPE_NULL;
+		}
+		g_free (base);
+	} else {
+		item->type = type_from_string (type);
+	}
+}
+
+/* fallback to find something suitable for C locale */
+static char *
+try_english_key (MateDesktopItem *item, const char *key)
+{
+	char *str;
+	char *locales[] = { "en_US", "en_GB", "en_AU", "en", NULL };
+	int i;
+
+	str = NULL;
+	for (i = 0; locales[i] != NULL && str == NULL; i++) {
+		str = g_strdup (lookup_locale (item, key, locales[i]));
+	}
+	if (str != NULL) {
+		/* We need a 7-bit ascii string, so whack all
+		 * above 127 chars */
+		guchar *p;
+		for (p = (guchar *)str; *p != '\0'; p++) {
+			if (*p > 127)
+				*p = '?';
+		}
+	}
+	return str;
+}
+
+
+static void
+sanitize (MateDesktopItem *item, const char *uri)
+{
+	const char *type;
+
+	type = lookup (item, MATE_DESKTOP_ITEM_TYPE);
+
+	/* understand old mate style url exec thingies */
+	if (type != NULL && strcmp (type, "URL") == 0) {
+		const char *exec = lookup (item, MATE_DESKTOP_ITEM_EXEC);
+		set (item, MATE_DESKTOP_ITEM_TYPE, "Link");
+		if (exec != NULL) {
+			/* Note, this must be in this order */
+			set (item, MATE_DESKTOP_ITEM_URL, exec);
+			set (item, MATE_DESKTOP_ITEM_EXEC, NULL);
+		}
+	}
+
+	/* we make sure we have Name, Encoding and Version */
+	if (lookup (item, MATE_DESKTOP_ITEM_NAME) == NULL) {
+		char *name = try_english_key (item, MATE_DESKTOP_ITEM_NAME);
+		/* If no name, use the basename */
+		if (name == NULL && uri != NULL)
+			name = g_path_get_basename (uri);
+		/* If no uri either, use same default as mate_desktop_item_new */
+		if (name == NULL) {
+		       /* Translators: the "name" mentioned here is the name of
+			* an application or a document */
+			name = g_strdup (_("No name"));
+		}
+		g_hash_table_replace (item->main_hash,
+				      g_strdup (MATE_DESKTOP_ITEM_NAME),
+				      name);
+		item->keys = g_list_prepend
+			(item->keys, g_strdup (MATE_DESKTOP_ITEM_NAME));
+	}
+	if (lookup (item, MATE_DESKTOP_ITEM_ENCODING) == NULL) {
+		/* We store everything in UTF-8 so write that down */
+		g_hash_table_replace (item->main_hash,
+				      g_strdup (MATE_DESKTOP_ITEM_ENCODING),
+				      g_strdup ("UTF-8"));
+		item->keys = g_list_prepend
+			(item->keys, g_strdup (MATE_DESKTOP_ITEM_ENCODING));
+	}
+	if (lookup (item, MATE_DESKTOP_ITEM_VERSION) == NULL) {
+		/* this is the version that we follow, so write it down */
+		g_hash_table_replace (item->main_hash,
+				      g_strdup (MATE_DESKTOP_ITEM_VERSION),
+				      g_strdup ("1.0"));
+		item->keys = g_list_prepend
+			(item->keys, g_strdup (MATE_DESKTOP_ITEM_VERSION));
+	}
+}
+
+enum {
+	FirstBrace,
+	OnSecHeader,
+	IgnoreToEOL,
+	IgnoreToEOLFirst,
+	KeyDef,
+	KeyDefOnKey,
+	KeyValue
+};
+
+static MateDesktopItem *
+ditem_load (ReadBuf *rb,
+	    gboolean no_translations,
+	    GError **error)
+{
+	int state;
+	char CharBuffer [1024];
+	char *next = CharBuffer;
+	int c;
+	Encoding encoding;
+	MateDesktopItem *item;
+	Section *cur_section = NULL;
+	char *key = NULL;
+	gboolean old_kde = FALSE;
+
+	encoding = get_encoding (rb);
+	if (encoding == ENCODING_UNKNOWN) {
+		/* spec says, don't read this file */
+		g_set_error (error,
+			     MATE_DESKTOP_ITEM_ERROR,
+			     MATE_DESKTOP_ITEM_ERROR_UNKNOWN_ENCODING,
+			     _("Unknown encoding of: %s"),
+			     rb->uri);
+		readbuf_close (rb);
+		return NULL;
+	}
+
+	/* Rewind since get_encoding goes through the file */
+	if (! readbuf_rewind (rb, error)) {
+		readbuf_close (rb);
+		/* spec says, don't read this file */
+		return NULL;
+	}
+
+	item = mate_desktop_item_new ();
+	item->modified = FALSE;
+
+	/* Note: location and mtime are filled in by the new_from_file
+	 * function since it has those values */
+
+#define OVERFLOW (next == &CharBuffer [sizeof(CharBuffer)-1])
+
+	state = FirstBrace;
+	while ((c = readbuf_getc (rb)) != EOF) {
+		if (c == '\r')		/* Ignore Carriage Return */
+			continue;
+
+		switch (state) {
+
+		case OnSecHeader:
+			if (c == ']' || OVERFLOW) {
+				*next = '\0';
+				next = CharBuffer;
+
+				/* keys were inserted in reverse */
+				if (cur_section != NULL &&
+				    cur_section->keys != NULL) {
+					cur_section->keys = g_list_reverse
+						(cur_section->keys);
+				}
+				if (strcmp (CharBuffer,
+					    "KDE Desktop Entry") == 0) {
+					/* Main section */
+					cur_section = NULL;
+					old_kde = TRUE;
+				} else if (strcmp (CharBuffer,
+						   "Desktop Entry") == 0) {
+					/* Main section */
+					cur_section = NULL;
+				} else {
+					cur_section = g_new0 (Section, 1);
+					cur_section->name =
+						g_strdup (CharBuffer);
+					cur_section->keys = NULL;
+					item->sections = g_list_prepend
+						(item->sections, cur_section);
+				}
+				state = IgnoreToEOL;
+			} else if (c == '[') {
+				/* FIXME: probably error out instead of ignoring this */
+			} else {
+				*next++ = c;
+			}
+			break;
+
+		case IgnoreToEOL:
+		case IgnoreToEOLFirst:
+			if (c == '\n'){
+				if (state == IgnoreToEOLFirst)
+					state = FirstBrace;
+				else
+					state = KeyDef;
+				next = CharBuffer;
+			}
+			break;
+
+		case FirstBrace:
+		case KeyDef:
+		case KeyDefOnKey:
+			if (c == '#') {
+				if (state == FirstBrace)
+					state = IgnoreToEOLFirst;
+				else
+					state = IgnoreToEOL;
+				break;
+			}
+
+			if (c == '[' && state != KeyDefOnKey){
+				state = OnSecHeader;
+				next = CharBuffer;
+				g_free (key);
+				key = NULL;
+				break;
+			}
+			/* On first pass, don't allow dangling keys */
+			if (state == FirstBrace)
+				break;
+
+			if ((c == ' ' && state != KeyDefOnKey) || c == '\t')
+				break;
+
+			if (c == '\n' || OVERFLOW) { /* Abort Definition */
+				next = CharBuffer;
+				state = KeyDef;
+				break;
+			}
+
+			if (c == '=' || OVERFLOW){
+				*next = '\0';
+
+				g_free (key);
+				key = g_strdup (CharBuffer);
+				state = KeyValue;
+				next = CharBuffer;
+			} else {
+				*next++ = c;
+				state = KeyDefOnKey;
+			}
+			break;
+
+		case KeyValue:
+			if (OVERFLOW || c == '\n'){
+				*next = '\0';
+
+				insert_key (item, cur_section, encoding,
+					    key, CharBuffer, old_kde,
+					    no_translations);
+
+				g_free (key);
+				key = NULL;
+
+				state = (c == '\n') ? KeyDef : IgnoreToEOL;
+				next = CharBuffer;
+			} else {
+				*next++ = c;
+			}
+			break;
+
+		} /* switch */
+
+	} /* while ((c = getc_unlocked (f)) != EOF) */
+	if (c == EOF && state == KeyValue) {
+		*next = '\0';
+
+		insert_key (item, cur_section, encoding,
+			    key, CharBuffer, old_kde,
+			    no_translations);
+
+		g_free (key);
+		key = NULL;
+	}
+
+#undef OVERFLOW
+
+	/* keys were inserted in reverse */
+	if (cur_section != NULL &&
+	    cur_section->keys != NULL) {
+		cur_section->keys = g_list_reverse (cur_section->keys);
+	}
+	/* keys were inserted in reverse */
+	item->keys = g_list_reverse (item->keys);
+	/* sections were inserted in reverse */
+	item->sections = g_list_reverse (item->sections);
+
+	/* sanitize some things */
+	sanitize (item, rb->uri);
+
+	/* make sure that we set up the type */
+	setup_type (item, rb->uri);
+
+	readbuf_close (rb);
+
+	return item;
+}
+
+static void stream_printf (GFileOutputStream *stream,
+			   const char *format, ...) G_GNUC_PRINTF (2, 3);
+
+static void
+stream_printf (GFileOutputStream *stream, const char *format, ...)
+{
+    va_list args;
+    gchar *s;
+
+    va_start (args, format);
+    s = g_strdup_vprintf (format, args);
+    va_end (args);
+
+    /* FIXME: what about errors */
+    g_output_stream_write (G_OUTPUT_STREAM (stream), s, strlen (s),
+		    	   NULL, NULL);
+    g_free (s);
+}
+
+static void
+dump_section (MateDesktopItem *item, GFileOutputStream *stream, Section *section)
+{
+	GList *li;
+
+	stream_printf (stream, "[%s]\n", section->name);
+	for (li = section->keys; li != NULL; li = li->next) {
+		const char *key = li->data;
+		char *full = g_strdup_printf ("%s/%s", section->name, key);
+		const char *value = g_hash_table_lookup (item->main_hash, full);
+		if (value != NULL) {
+			char *val = escape_string_and_dup (value);
+			stream_printf (stream, "%s=%s\n", key, val);
+			g_free (val);
+		}
+		g_free (full);
+	}
+}
+
+static gboolean
+ditem_save (MateDesktopItem *item, const char *uri, GError **error)
+{
+	GList *li;
+	GFile *file;
+	GFileOutputStream *stream;
+
+	file = g_file_new_for_uri (uri);
+	stream = g_file_replace (file, NULL, FALSE, G_FILE_CREATE_NONE,
+				 NULL, error);
+	if (stream == NULL)
+		return FALSE;
+
+	stream_printf (stream, "[Desktop Entry]\n");
+	for (li = item->keys; li != NULL; li = li->next) {
+		const char *key = li->data;
+		const char *value = g_hash_table_lookup (item->main_hash, key);
+		if (value != NULL) {
+			char *val = escape_string_and_dup (value);
+			stream_printf (stream, "%s=%s\n", key, val);
+			g_free (val);
+		}
+	}
+
+	if (item->sections != NULL)
+		stream_printf (stream, "\n");
+
+	for (li = item->sections; li != NULL; li = li->next) {
+		Section *section = li->data;
+
+		/* Don't write empty sections */
+		if (section->keys == NULL)
+			continue;
+
+		dump_section (item, stream, section);
+
+		if (li->next != NULL)
+			stream_printf (stream, "\n");
+	}
+
+	g_object_unref (stream);
+	g_object_unref (file);
+
+	return TRUE;
+}
+
+static gpointer
+_mate_desktop_item_copy (gpointer boxed)
+{
+	return mate_desktop_item_copy (boxed);
+}
+
+static void
+_mate_desktop_item_free (gpointer boxed)
+{
+	mate_desktop_item_unref (boxed);
+}
+
+GType
+mate_desktop_item_get_type (void)
+{
+	static GType type = 0;
+
+	if (type == 0) {
+		type = g_boxed_type_register_static ("MateDesktopItem",
+						     _mate_desktop_item_copy,
+						     _mate_desktop_item_free);
+	}
+
+	return type;
+}
+
+GQuark
+mate_desktop_item_error_quark (void)
+{
+	static GQuark q = 0;
+	if (q == 0)
+		q = g_quark_from_static_string ("mate-desktop-item-error-quark");
+
+	return q;
+}