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

17 files changed, 10722 insertions, 0 deletions

diff --git a/libmenu/Makefile.am b/libmenu/Makefile.am
new file mode 100644
index 0000000..3d06096
--- /dev/null
+++ b/libmenu/Makefile.am
@@ -0,0 +1,78 @@
+lib_LTLIBRARIES = libmate-menu.la
+
+AM_CPPFLAGS = \
+	$(GLIB_CFLAGS) \
+	-DMATEMENU_I_KNOW_THIS_IS_UNSTABLE	\
+	$(DISABLE_DEPRECATED_CFLAGS) \
+	$(DEBUG_CFLAGS)
+
+AM_CFLAGS = $(WARN_CFLAGS)
+
+libmate_menu_includedir = $(includedir)/mate-menus
+libmate_menu_include_HEADERS = \
+	matemenu-tree.h
+
+libmate_menu_sources = \
+	canonicalize.c \
+	desktop-entries.c \
+	entry-directories.c \
+	matemenu-tree.c \
+	menu-layout.c \
+	menu-monitor.c \
+	menu-util.c
+
+libmate_menu_la_SOURCES = \
+	$(libmate_menu_sources) \
+	canonicalize.h \
+	desktop-entries.h \
+	entry-directories.h \
+	matemenu-tree.h \
+	menu-layout.h \
+	menu-monitor.h \
+	menu-util.h
+
+libmate_menu_la_LIBADD = \
+	$(GLIB_LIBS)
+
+libmate_menu_la_LDFLAGS = \
+	-version-info $(LIB_MENU_LT_VERSION) \
+	-no-undefined \
+	-export-symbols-regex matemenu_tree
+
+pkgconfigdir = $(libdir)/pkgconfig
+pkgconfig_DATA = libmate-menu.pc
+
+EXTRA_DIST = \
+	libmate-menu.pc.in \
+	libmate-menu-uninstalled.pc.in
+
+CLEANFILES =
+
+# Introspection
+-include $(INTROSPECTION_MAKEFILE)
+INTROSPECTION_GIRS =
+INTROSPECTION_SCANNER_ARGS = --warn-all --add-include-path=$(srcdir)
+INTROSPECTION_COMPILER_ARGS = --includedir=$(srcdir)
+
+if HAVE_INTROSPECTION
+# Note: we only include the headers here so far because there's no gtk-doc at all anyway
+introspection_sources = $(libmate_menu_include_HEADERS)
+
+MateMenu-2.0.gir: libmate-menu.la
+MateMenu_2_0_gir_INCLUDES = GObject-2.0
+MateMenu_2_0_gir_CFLAGS = $(AM_CPPFLAGS)
+MateMenu_2_0_gir_LIBS = libmate-menu.la
+MateMenu_2_0_gir_SCANNERFLAGS = --pkg-export=libmate-menu
+MateMenu_2_0_gir_FILES = $(addprefix $(srcdir)/,$(introspection_sources))
+INTROSPECTION_GIRS += MateMenu-2.0.gir
+
+girdir = $(INTROSPECTION_GIRDIR)
+gir_DATA = $(INTROSPECTION_GIRS)
+
+typelibdir = $(INTROSPECTION_TYPELIBDIR)
+typelib_DATA = $(INTROSPECTION_GIRS:.gir=.typelib)
+
+CLEANFILES += $(gir_DATA) $(typelib_DATA)
+endif
+
+-include $(top_srcdir)/git.mk
diff --git a/libmenu/canonicalize.c b/libmenu/canonicalize.c
new file mode 100644
index 0000000..82082e9
--- /dev/null
+++ b/libmenu/canonicalize.c
@@ -0,0 +1,326 @@
+/* Return the canonical absolute name of a given file.
+ * Copyright (C) 1996-2001, 2002 Free Software Foundation, Inc.
+ * This file is part of the GNU C Library.
+ *
+ * Copyright (C) 2002 Red Hat, Inc. (trivial port to GLib)
+ *
+ * The GNU C Library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * The GNU C 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the GNU C Library; if not, write to the Free
+ * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ * 02111-1307 USA.
+ */
+
+#include <config.h>
+
+#include "canonicalize.h"
+
+#include <stdlib.h>
+#include <string.h>
+#include <unistd.h>
+#include <limits.h>
+#include <sys/param.h>
+#include <sys/stat.h>
+#include <errno.h>
+#include <stddef.h>
+
+/* Return the canonical absolute name of file NAME.  A canonical name
+   does not contain any `.', `..' components nor any repeated path
+   separators ('/') or symlinks.  All path components must exist.  If
+   RESOLVED is null, the result is malloc'd; otherwise, if the
+   canonical name is PATH_MAX chars or more, returns null with `errno'
+   set to ENAMETOOLONG; if the name fits in fewer than PATH_MAX chars,
+   returns the name in RESOLVED.  If the name cannot be resolved and
+   RESOLVED is non-NULL, it contains the path of the first component
+   that cannot be resolved.  If the path can be resolved, RESOLVED
+   holds the same value as the value returned.  */
+
+static char* menu_realpath(const char* name, char* resolved)
+{
+	char* rpath = NULL;
+	char* dest = NULL;
+	char* extra_buf = NULL;
+	const char* start;
+	const char* end;
+	const char* rpath_limit;
+	long int path_max;
+	int num_links = 0;
+
+	if (name == NULL)
+	{
+		/* As per Single Unix Specification V2 we must return an error if
+		 * either parameter is a null pointer.  We extend this to allow
+		 * the RESOLVED parameter to be NULL in case the we are expected to
+		 * allocate the room for the return value.  */
+		errno = EINVAL;
+		return NULL;
+	}
+
+	if (name[0] == '\0')
+	{
+		/* As per Single Unix Specification V2 we must return an error if
+		 * the name argument points to an empty string.  */
+		errno = ENOENT;
+		return NULL;
+	}
+
+	#ifdef PATH_MAX
+		path_max = PATH_MAX;
+	#else
+		path_max = pathconf(name, _PC_PATH_MAX);
+
+		if (path_max <= 0)
+		{
+			path_max = 1024;
+		}
+	#endif
+
+	rpath = resolved ? g_alloca(path_max) : g_malloc(path_max);
+	rpath_limit = rpath + path_max;
+
+	if (name[0] != G_DIR_SEPARATOR)
+	{
+		if (!getcwd(rpath, path_max))
+		{
+			rpath[0] = '\0';
+			goto error;
+		}
+
+		dest = strchr(rpath, '\0');
+	}
+	else
+	{
+		rpath[0] = G_DIR_SEPARATOR;
+		dest = rpath + 1;
+	}
+
+	for (start = end = name; *start; start = end)
+    {
+		struct stat st;
+		int n;
+
+		/* Skip sequence of multiple path-separators.  */
+		while (*start == G_DIR_SEPARATOR)
+		{
+			++start;
+		}
+
+		/* Find end of path component.  */
+		for (end = start; *end && *end != G_DIR_SEPARATOR; ++end)
+		{
+			/* Nothing.  */;
+		}
+
+		if (end - start == 0)
+		{
+			break;
+		}
+		else if (end - start == 1 && start[0] == '.')
+		{
+			/* nothing */;
+		}
+		else if (end - start == 2 && start[0] == '.' && start[1] == '.')
+        {
+			/* Back up to previous component, ignore if at root already.  */
+			if (dest > rpath + 1)
+			{
+				while ((--dest)[-1] != G_DIR_SEPARATOR)
+				{
+					/* Nothing.  */;
+				}
+			}
+        }
+		else
+        {
+			size_t new_size;
+
+			if (dest[-1] != G_DIR_SEPARATOR)
+			{
+				*dest++ = G_DIR_SEPARATOR;
+			}
+
+			if (dest + (end - start) >= rpath_limit)
+            {
+				char* new_rpath;
+				ptrdiff_t dest_offset = dest - rpath;
+
+				if (resolved)
+				{
+					#ifdef ENAMETOOLONG
+					  errno = ENAMETOOLONG;
+					#else
+					  /* Uh... just pick something */
+					  errno = EINVAL;
+					#endif
+
+					if (dest > rpath + 1)
+					{
+						dest--;
+					}
+
+					*dest = '\0';
+					goto error;
+                }
+
+				new_size = rpath_limit - rpath;
+
+				if (end - start + 1 > path_max)
+				{
+					new_size += end - start + 1;
+				}
+				else
+				{
+					new_size += path_max;
+				}
+
+				new_rpath = (char*) realloc(rpath, new_size);
+
+				if (new_rpath == NULL)
+				{
+					goto error;
+				}
+
+				rpath = new_rpath;
+				rpath_limit = rpath + new_size;
+
+				dest = rpath + dest_offset;
+            }
+
+			memcpy(dest, start, end - start);
+			dest = dest + (end - start);
+			*dest = '\0';
+
+			if (stat(rpath, &st) < 0)
+			{
+				goto error;
+			}
+
+			if (S_ISLNK(st.st_mode))
+			{
+				char* buf = alloca(path_max);
+				size_t len;
+
+				if (++num_links > MAXSYMLINKS)
+				{
+					errno = ELOOP;
+					goto error;
+				}
+
+				n = readlink(rpath, buf, path_max);
+
+				if (n < 0)
+				{
+					goto error;
+				}
+
+				buf[n] = '\0';
+
+
+
+				if (!extra_buf)
+				{
+					extra_buf = g_alloca(path_max);
+				}
+
+				len = strlen(end);
+
+				if ((long int) (n + len) >= path_max)
+                {
+					#ifdef ENAMETOOLONG
+					  errno = ENAMETOOLONG;
+					#else
+					  /* Uh... just pick something */
+					  errno = EINVAL;
+					#endif
+
+					goto error;
+                }
+
+				/* Careful here, end may be a pointer into extra_buf... */
+				g_memmove(&extra_buf[n], end, len + 1);
+				name = end = memcpy(extra_buf, buf, n);
+
+				if (buf[0] == G_DIR_SEPARATOR)
+				{
+					dest = rpath + 1;       /* It's an absolute symlink */
+				}
+				else
+				{
+					/* Back up to previous component, ignore if at root already: */
+					if (dest > rpath + 1)
+					{
+						while ((--dest)[-1] != G_DIR_SEPARATOR)
+						{
+							/* Nothing.  */;
+						}
+					}
+				}
+            }
+        }
+    }
+
+	if (dest > rpath + 1 && dest[-1] == G_DIR_SEPARATOR)
+	{
+		--dest;
+	}
+
+	*dest = '\0';
+
+	return resolved ? memcpy(resolved, rpath, dest - rpath + 1) : rpath;
+
+	error:
+
+	if (resolved)
+	{
+		strcpy(resolved, rpath);
+	}
+	else
+	{
+		g_free(rpath);
+	}
+
+	return NULL;
+}
+
+char* menu_canonicalize_file_name(const char* name, gboolean allow_missing_basename)
+{
+	char* retval;
+
+	retval = menu_realpath(name, NULL);
+
+	/* We could avoid some system calls by using the second
+	 * argument to realpath() instead of doing realpath
+	 * all over again, but who cares really. we'll see if
+	 * it's ever in a profile.
+	 */
+	if (allow_missing_basename && retval == NULL)
+	{
+		char* dirname;
+		char* canonical_dirname;
+
+		dirname = g_path_get_dirname(name);
+		canonical_dirname = menu_realpath(dirname, NULL);
+		g_free(dirname);
+
+		if (canonical_dirname)
+		{
+			char* basename;
+
+			basename = g_path_get_basename(name);
+			retval = g_build_filename(canonical_dirname, basename, NULL);
+			g_free(basename);
+			g_free(canonical_dirname);
+		}
+	}
+
+	return retval;
+}
diff --git a/libmenu/canonicalize.h b/libmenu/canonicalize.h
new file mode 100644
index 0000000..b5deddc
--- /dev/null
+++ b/libmenu/canonicalize.h
@@ -0,0 +1,38 @@
+/* Return the canonical absolute name of a given file.
+ * Copyright (C) 1996-2001, 2002 Free Software Foundation, Inc.
+ * This file is part of the GNU C Library.
+ *
+ * Copyright (C) 2002 Red Hat, Inc. (trivial port to GLib)
+ *
+ * The GNU C Library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2.1 of the License, or (at your option) any later version.
+ *
+ * The GNU C 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
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with the GNU C Library; if not, write to the Free
+ * Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
+ * 02111-1307 USA.
+ */
+
+#ifndef G_CANONICALIZE_H
+#define G_CANONICALIZE_H
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+char* menu_canonicalize_file_name(const char* name, gboolean allow_missing_basename);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* G_CANONICALIZE_H */
diff --git a/libmenu/desktop-entries.c b/libmenu/desktop-entries.c
new file mode 100644
index 0000000..9488bde
--- /dev/null
+++ b/libmenu/desktop-entries.c
@@ -0,0 +1,816 @@
+/*
+ * Copyright (C) 2002 - 2004 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "desktop-entries.h"
+
+#include <string.h>
+
+#include "menu-util.h"
+
+#define DESKTOP_ENTRY_GROUP     "Desktop Entry"
+#define KDE_DESKTOP_ENTRY_GROUP "KDE Desktop Entry"
+
+enum {
+	DESKTOP_ENTRY_NO_DISPLAY     = 1 << 0,
+	DESKTOP_ENTRY_HIDDEN         = 1 << 1,
+	DESKTOP_ENTRY_SHOW_IN_MATE   = 1 << 2,
+	DESKTOP_ENTRY_TRYEXEC_FAILED = 1 << 3
+};
+
+struct DesktopEntry {
+	char* path;
+	char* basename;
+
+	GQuark* categories;
+
+	char* name;
+	char* generic_name;
+	char* full_name;
+	char* comment;
+	char* icon;
+	char* exec;
+	gboolean terminal;
+
+	guint type: 2;
+	guint flags: 4;
+	guint refcount: 24;
+};
+
+struct DesktopEntrySet {
+	int refcount;
+	GHashTable* hash;
+};
+
+/*
+ * Desktop entries
+ */
+
+static guint get_flags_from_key_file(DesktopEntry* entry, GKeyFile* key_file, const char* desktop_entry_group)
+{
+  GError    *error;
+  char     **strv;
+  gboolean   no_display;
+  gboolean   hidden;
+  gboolean   show_in_mate;
+  gboolean   tryexec_failed;
+  char      *tryexec;
+  guint      flags;
+  int        i;
+
+  error = NULL;
+  no_display = g_key_file_get_boolean (key_file,
+                                       desktop_entry_group,
+                                       "NoDisplay",
+                                       &error);
+  if (error)
+    {
+      no_display = FALSE;
+      g_error_free (error);
+    }
+
+  error = NULL;
+  hidden = g_key_file_get_boolean (key_file,
+                                   desktop_entry_group,
+                                   "Hidden",
+                                   &error);
+  if (error)
+    {
+      hidden = FALSE;
+      g_error_free (error);
+    }
+
+  show_in_mate = TRUE;
+  strv = g_key_file_get_string_list (key_file,
+                                     desktop_entry_group,
+                                     "OnlyShowIn",
+                                     NULL,
+                                     NULL);
+  if (strv)
+    {
+      show_in_mate = FALSE;
+      for (i = 0; strv[i]; i++)
+        {
+          if (!strcmp (strv[i], "MATE"))
+            {
+              show_in_mate = TRUE;
+              break;
+            }
+        }
+    }
+  else
+    {
+      strv = g_key_file_get_string_list (key_file,
+                                         desktop_entry_group,
+                                         "NotShowIn",
+                                         NULL,
+                                         NULL);
+      if (strv)
+        {
+          show_in_mate = TRUE;
+          for (i = 0; strv[i]; i++)
+            {
+              if (!strcmp (strv[i], "MATE"))
+                {
+                  show_in_mate = FALSE;
+                }
+            }
+        }
+    }
+  g_strfreev (strv);
+
+  tryexec_failed = FALSE;
+  tryexec = g_key_file_get_string (key_file,
+                                   desktop_entry_group,
+                                   "TryExec",
+                                   NULL);
+  if (tryexec)
+    {
+      char *path;
+
+      path = g_find_program_in_path (g_strstrip (tryexec));
+
+      tryexec_failed = (path == NULL);
+
+      g_free (path);
+      g_free (tryexec);
+    }
+
+  flags = 0;
+  if (no_display)
+    flags |= DESKTOP_ENTRY_NO_DISPLAY;
+  if (hidden)
+    flags |= DESKTOP_ENTRY_HIDDEN;
+  if (show_in_mate)
+    flags |= DESKTOP_ENTRY_SHOW_IN_MATE;
+  if (tryexec_failed)
+    flags |= DESKTOP_ENTRY_TRYEXEC_FAILED;
+
+  return flags;
+}
+
+static GQuark* get_categories_from_key_file (DesktopEntry* entry, GKeyFile* key_file, const char* desktop_entry_group)
+{
+  GQuark  *retval;
+  char   **strv;
+  gsize    len;
+  int      i;
+
+  strv = g_key_file_get_string_list (key_file,
+                                     desktop_entry_group,
+                                     "Categories",
+                                     &len,
+                                     NULL);
+  if (!strv)
+    return NULL;
+
+  retval = g_new0 (GQuark, len + 1);
+
+  for (i = 0; strv[i]; i++)
+    retval[i] = g_quark_from_string (strv[i]);
+
+  g_strfreev (strv);
+
+  return retval;
+}
+
+static DesktopEntry* desktop_entry_load(DesktopEntry* entry)
+{
+  DesktopEntry *retval = NULL;
+  GKeyFile     *key_file;
+  GError       *error;
+  const char   *desktop_entry_group;
+  char         *name_str;
+  char         *type_str;
+
+  key_file = g_key_file_new ();
+
+  error = NULL;
+  if (!g_key_file_load_from_file (key_file, entry->path, 0, &error))
+    {
+      menu_verbose ("Failed to load \"%s\": %s\n",
+                    entry->path, error->message);
+      g_error_free (error);
+      goto out;
+    }
+
+  if (g_key_file_has_group (key_file, DESKTOP_ENTRY_GROUP))
+    {
+      desktop_entry_group = DESKTOP_ENTRY_GROUP;
+    }
+  else
+    {
+      menu_verbose ("\"%s\" contains no \"" DESKTOP_ENTRY_GROUP "\" group\n",
+                    entry->path);
+
+      if (g_key_file_has_group (key_file, KDE_DESKTOP_ENTRY_GROUP))
+        {
+          desktop_entry_group = KDE_DESKTOP_ENTRY_GROUP;
+          menu_verbose ("\"%s\" contains deprecated \"" KDE_DESKTOP_ENTRY_GROUP "\" group\n",
+                        entry->path);
+        }
+      else
+        {
+          goto out;
+        }
+    }
+
+  if (!g_key_file_has_key (key_file, desktop_entry_group, "Name", NULL))
+    {
+      menu_verbose ("\"%s\" contains no \"Name\" key\n", entry->path);
+      goto out;
+    }
+
+  name_str = g_key_file_get_locale_string (key_file, desktop_entry_group, "Name", NULL, NULL);
+  if (!name_str)
+    {
+      menu_verbose ("\"%s\" contains an invalid \"Name\" key\n", entry->path);
+      goto out;
+    }
+
+  g_free (name_str);
+
+  type_str = g_key_file_get_string (key_file, desktop_entry_group, "Type", NULL);
+  if (!type_str)
+    {
+      menu_verbose ("\"%s\" contains no \"Type\" key\n", entry->path);
+      goto out;
+    }
+
+  if ((entry->type == DESKTOP_ENTRY_DESKTOP && strcmp (type_str, "Application") != 0) ||
+      (entry->type == DESKTOP_ENTRY_DIRECTORY && strcmp (type_str, "Directory") != 0))
+    {
+      menu_verbose ("\"%s\" does not contain the correct \"Type\" value\n", entry->path);
+      g_free (type_str);
+      goto out;
+    }
+
+  g_free (type_str);
+
+  if (entry->type == DESKTOP_ENTRY_DESKTOP &&
+      !g_key_file_has_key (key_file, desktop_entry_group, "Exec", NULL))
+    {
+      menu_verbose ("\"%s\" does not contain an \"Exec\" key\n", entry->path);
+      goto out;
+    }
+
+  retval = entry;
+
+#define GET_LOCALE_STRING(n) g_key_file_get_locale_string (key_file, desktop_entry_group, (n), NULL, NULL)
+
+  retval->name         = GET_LOCALE_STRING ("Name");
+  retval->generic_name = GET_LOCALE_STRING ("GenericName");
+  retval->full_name    = GET_LOCALE_STRING ("X-MATE-FullName");
+  retval->comment      = GET_LOCALE_STRING ("Comment");
+  retval->icon         = GET_LOCALE_STRING ("Icon");
+  retval->flags        = get_flags_from_key_file (retval, key_file, desktop_entry_group);
+  retval->categories   = get_categories_from_key_file (retval, key_file, desktop_entry_group);
+
+  if (entry->type == DESKTOP_ENTRY_DESKTOP)
+    {
+      retval->exec = g_key_file_get_string (key_file, desktop_entry_group, "Exec", NULL);
+      retval->terminal = g_key_file_get_boolean (key_file, desktop_entry_group, "Terminal", NULL);
+    }
+
+#undef GET_LOCALE_STRING
+
+  menu_verbose ("Desktop entry \"%s\" (%s, %s, %s, %s, %s) flags: NoDisplay=%s, Hidden=%s, ShowInMATE=%s, TryExecFailed=%s\n",
+                retval->basename,
+                retval->name,
+                retval->generic_name ? retval->generic_name : "(null)",
+                retval->full_name ? retval->full_name : "(null)",
+                retval->comment ? retval->comment : "(null)",
+                retval->icon ? retval->icon : "(null)",
+                retval->flags & DESKTOP_ENTRY_NO_DISPLAY     ? "(true)" : "(false)",
+                retval->flags & DESKTOP_ENTRY_HIDDEN         ? "(true)" : "(false)",
+                retval->flags & DESKTOP_ENTRY_SHOW_IN_MATE  ? "(true)" : "(false)",
+                retval->flags & DESKTOP_ENTRY_TRYEXEC_FAILED ? "(true)" : "(false)");
+
+ out:
+  g_key_file_free (key_file);
+
+  if (!retval)
+    desktop_entry_unref (entry);
+
+  return retval;
+}
+
+DesktopEntry* desktop_entry_new(const char* path)
+{
+  DesktopEntryType  type;
+  DesktopEntry     *retval;
+
+  menu_verbose ("Loading desktop entry \"%s\"\n", path);
+
+  if (g_str_has_suffix (path, ".desktop"))
+    {
+      type = DESKTOP_ENTRY_DESKTOP;
+    }
+  else if (g_str_has_suffix (path, ".directory"))
+    {
+      type = DESKTOP_ENTRY_DIRECTORY;
+    }
+  else
+    {
+      menu_verbose ("Unknown desktop entry suffix in \"%s\"\n",
+                    path);
+      return NULL;
+    }
+
+  retval = g_new0 (DesktopEntry, 1);
+
+  retval->refcount = 1;
+  retval->type     = type;
+  retval->basename = g_path_get_basename (path);
+  retval->path     = g_strdup (path);
+
+  return desktop_entry_load (retval);
+}
+
+DesktopEntry* desktop_entry_reload(DesktopEntry* entry)
+{
+  g_return_val_if_fail (entry != NULL, NULL);
+
+  menu_verbose ("Re-loading desktop entry \"%s\"\n", entry->path);
+
+  g_free (entry->categories);
+  entry->categories = NULL;
+
+  g_free (entry->name);
+  entry->name = NULL;
+
+  g_free (entry->generic_name);
+  entry->generic_name = NULL;
+
+  g_free (entry->full_name);
+  entry->full_name = NULL;
+
+  g_free (entry->comment);
+  entry->comment = NULL;
+
+  g_free (entry->icon);
+  entry->icon = NULL;
+
+  g_free (entry->exec);
+  entry->exec = NULL;
+
+  entry->terminal = 0;
+  entry->flags = 0;
+
+  return desktop_entry_load (entry);
+}
+
+DesktopEntry* desktop_entry_ref(DesktopEntry* entry)
+{
+  g_return_val_if_fail (entry != NULL, NULL);
+  g_return_val_if_fail (entry->refcount > 0, NULL);
+
+  entry->refcount += 1;
+
+  return entry;
+}
+
+DesktopEntry* desktop_entry_copy(DesktopEntry* entry)
+{
+  DesktopEntry *retval;
+  int           i;
+
+  menu_verbose ("Copying desktop entry \"%s\"\n",
+                entry->basename);
+
+  retval = g_new0 (DesktopEntry, 1);
+
+  retval->refcount     = 1;
+  retval->type         = entry->type;
+  retval->basename     = g_strdup (entry->basename);
+  retval->path         = g_strdup (entry->path);
+  retval->name         = g_strdup (entry->name);
+  retval->generic_name = g_strdup (entry->generic_name);
+  retval->full_name    = g_strdup (entry->full_name);
+  retval->comment      = g_strdup (entry->comment);
+  retval->icon         = g_strdup (entry->icon);
+  retval->exec         = g_strdup (entry->exec);
+  retval->terminal     = entry->terminal;
+  retval->flags        = entry->flags;
+
+  i = 0;
+  if (entry->categories != NULL)
+    {
+      for (; entry->categories[i]; i++);
+    }
+
+  retval->categories = g_new0 (GQuark, i + 1);
+
+  i = 0;
+  if (entry->categories != NULL)
+    {
+      for (; entry->categories[i]; i++)
+        retval->categories[i] = entry->categories[i];
+    }
+
+  return retval;
+}
+
+void desktop_entry_unref(DesktopEntry* entry)
+{
+  g_return_if_fail (entry != NULL);
+  g_return_if_fail (entry->refcount > 0);
+
+  entry->refcount -= 1;
+  if (entry->refcount == 0)
+    {
+      g_free (entry->categories);
+      entry->categories = NULL;
+
+      g_free (entry->name);
+      entry->name = NULL;
+
+      g_free (entry->generic_name);
+      entry->generic_name = NULL;
+
+      g_free (entry->full_name);
+      entry->full_name = NULL;
+
+      g_free (entry->comment);
+      entry->comment = NULL;
+
+      g_free (entry->icon);
+      entry->icon = NULL;
+
+      g_free (entry->exec);
+      entry->exec = NULL;
+
+      g_free (entry->basename);
+      entry->basename = NULL;
+
+      g_free (entry->path);
+      entry->path = NULL;
+
+      g_free (entry);
+    }
+}
+
+DesktopEntryType desktop_entry_get_type(DesktopEntry* entry)
+{
+	return entry->type;
+}
+
+const char* desktop_entry_get_path(DesktopEntry* entry)
+{
+	return entry->path;
+}
+
+const char *
+desktop_entry_get_basename (DesktopEntry *entry)
+{
+	return entry->basename;
+}
+
+const char* desktop_entry_get_name(DesktopEntry* entry)
+{
+	return entry->name;
+}
+
+const char* desktop_entry_get_generic_name(DesktopEntry* entry)
+{
+	return entry->generic_name;
+}
+
+const char* desktop_entry_get_full_name(DesktopEntry* entry)
+{
+  return entry->full_name;
+}
+
+const char* desktop_entry_get_comment(DesktopEntry* entry)
+{
+	return entry->comment;
+}
+
+const char* desktop_entry_get_icon(DesktopEntry* entry)
+{
+	return entry->icon;
+}
+
+const char* desktop_entry_get_exec(DesktopEntry* entry)
+{
+	return entry->exec;
+}
+
+gboolean desktop_entry_get_launch_in_terminal(DesktopEntry* entry)
+{
+	return entry->terminal;
+}
+
+gboolean desktop_entry_get_hidden(DesktopEntry* entry)
+{
+	return (entry->flags & DESKTOP_ENTRY_HIDDEN) != 0;
+}
+
+gboolean desktop_entry_get_no_display(DesktopEntry* entry)
+{
+	return (entry->flags & DESKTOP_ENTRY_NO_DISPLAY) != 0;
+}
+
+gboolean desktop_entry_get_show_in_mate(DesktopEntry* entry)
+{
+	return (entry->flags & DESKTOP_ENTRY_SHOW_IN_MATE) != 0;
+}
+
+gboolean desktop_entry_get_tryexec_failed(DesktopEntry* entry)
+{
+	return (entry->flags & DESKTOP_ENTRY_TRYEXEC_FAILED) != 0;
+}
+
+gboolean desktop_entry_has_categories(DesktopEntry* entry)
+{
+	return (entry->categories != NULL && entry->categories[0] != 0);
+}
+
+gboolean desktop_entry_has_category(DesktopEntry* entry, const char* category)
+{
+  GQuark quark;
+  int    i;
+
+  if (entry->categories == NULL)
+    return FALSE;
+
+  if (!(quark = g_quark_try_string (category)))
+    return FALSE;
+
+  for (i = 0; entry->categories[i]; i++)
+    {
+      if (quark == entry->categories[i])
+        return TRUE;
+    }
+
+  return FALSE;
+}
+
+void desktop_entry_add_legacy_category(DesktopEntry* entry)
+{
+  GQuark *categories;
+  int     i;
+
+  menu_verbose ("Adding Legacy category to \"%s\"\n",
+                entry->basename);
+
+  i = 0;
+  if (entry->categories != NULL)
+    {
+      for (; entry->categories[i]; i++);
+    }
+
+  categories = g_new0 (GQuark, i + 2);
+
+  i = 0;
+  if (entry->categories != NULL)
+    {
+      for (; entry->categories[i]; i++)
+        categories[i] = entry->categories[i];
+    }
+
+  categories[i] = g_quark_from_string ("Legacy");
+
+  g_free (entry->categories);
+  entry->categories = categories;
+}
+
+/*
+ * Entry sets
+ */
+
+DesktopEntrySet* desktop_entry_set_new(void)
+{
+  DesktopEntrySet *set;
+
+  set = g_new0 (DesktopEntrySet, 1);
+  set->refcount = 1;
+
+  menu_verbose (" New entry set %p\n", set);
+
+  return set;
+}
+
+DesktopEntrySet* desktop_entry_set_ref(DesktopEntrySet* set)
+{
+  g_return_val_if_fail (set != NULL, NULL);
+  g_return_val_if_fail (set->refcount > 0, NULL);
+
+  set->refcount += 1;
+
+  return set;
+}
+
+void desktop_entry_set_unref(DesktopEntrySet* set)
+{
+  g_return_if_fail (set != NULL);
+  g_return_if_fail (set->refcount > 0);
+
+  set->refcount -= 1;
+  if (set->refcount == 0)
+    {
+      menu_verbose (" Deleting entry set %p\n", set);
+
+      if (set->hash)
+        g_hash_table_destroy (set->hash);
+      set->hash = NULL;
+
+      g_free (set);
+    }
+}
+
+void desktop_entry_set_add_entry(DesktopEntrySet* set, DesktopEntry* entry, const char* file_id)
+{
+  menu_verbose (" Adding to set %p entry %s\n", set, file_id);
+
+  if (set->hash == NULL)
+    {
+      set->hash = g_hash_table_new_full (g_str_hash,
+                                         g_str_equal,
+                                         g_free,
+                                         (GDestroyNotify) desktop_entry_unref);
+    }
+
+  g_hash_table_replace (set->hash,
+                        g_strdup (file_id),
+                        desktop_entry_ref (entry));
+}
+
+DesktopEntry* desktop_entry_set_lookup(DesktopEntrySet* set, const char* file_id)
+{
+  if (set->hash == NULL)
+    return NULL;
+
+  return g_hash_table_lookup (set->hash, file_id);
+}
+
+typedef struct {
+	DesktopEntrySetForeachFunc func;
+	gpointer user_data;
+} EntryHashForeachData;
+
+static void entry_hash_foreach(const char* file_id, DesktopEntry* entry, EntryHashForeachData* fd)
+{
+	fd->func(file_id, entry, fd->user_data);
+}
+
+void desktop_entry_set_foreach(DesktopEntrySet* set, DesktopEntrySetForeachFunc func, gpointer user_data)
+{
+  g_return_if_fail (set != NULL);
+  g_return_if_fail (func != NULL);
+
+  if (set->hash != NULL)
+    {
+      EntryHashForeachData fd;
+
+      fd.func      = func;
+      fd.user_data = user_data;
+
+      g_hash_table_foreach (set->hash,
+                            (GHFunc) entry_hash_foreach,
+                            &fd);
+    }
+}
+
+static void desktop_entry_set_clear(DesktopEntrySet* set)
+{
+  menu_verbose (" Clearing set %p\n", set);
+
+  if (set->hash != NULL)
+    {
+      g_hash_table_destroy (set->hash);
+      set->hash = NULL;
+    }
+}
+
+int desktop_entry_set_get_count(DesktopEntrySet* set)
+{
+  if (set->hash == NULL)
+    return 0;
+
+  return g_hash_table_size (set->hash);
+}
+
+static void union_foreach(const char* file_id, DesktopEntry* entry, DesktopEntrySet* set)
+{
+	/* we are iterating over "with" adding anything not
+	 * already in "set". We unconditionally overwrite
+	 * the stuff in "set" because we can assume
+	 * two entries with the same name are equivalent.
+	 */
+	desktop_entry_set_add_entry(set, entry, file_id);
+}
+
+void desktop_entry_set_union(DesktopEntrySet* set, DesktopEntrySet* with)
+{
+  menu_verbose (" Union of %p and %p\n", set, with);
+
+  if (desktop_entry_set_get_count (with) == 0)
+    return; /* A fast simple case */
+
+  g_hash_table_foreach (with->hash,
+                        (GHFunc) union_foreach,
+                        set);
+}
+
+typedef struct {
+	DesktopEntrySet *set;
+	DesktopEntrySet *with;
+} IntersectData;
+
+static gboolean intersect_foreach_remove(const char* file_id, DesktopEntry* entry, IntersectData* id)
+{
+  /* Remove everything in "set" which is not in "with" */
+
+  if (g_hash_table_lookup (id->with->hash, file_id) != NULL)
+    return FALSE;
+
+  menu_verbose (" Removing from %p entry %s\n", id->set, file_id);
+
+  return TRUE; /* return TRUE to remove */
+}
+
+void desktop_entry_set_intersection(DesktopEntrySet* set, DesktopEntrySet* with)
+{
+  IntersectData id;
+
+  menu_verbose (" Intersection of %p and %p\n", set, with);
+
+  if (desktop_entry_set_get_count (set) == 0 ||
+      desktop_entry_set_get_count (with) == 0)
+    {
+      /* A fast simple case */
+      desktop_entry_set_clear (set);
+      return;
+    }
+
+  id.set  = set;
+  id.with = with;
+
+  g_hash_table_foreach_remove (set->hash,
+                               (GHRFunc) intersect_foreach_remove,
+                               &id);
+}
+
+typedef struct {
+	DesktopEntrySet *set;
+	DesktopEntrySet *other;
+} SubtractData;
+
+static gboolean subtract_foreach_remove(const char* file_id, DesktopEntry* entry, SubtractData* sd)
+{
+  /* Remove everything in "set" which is not in "other" */
+
+  if (g_hash_table_lookup (sd->other->hash, file_id) == NULL)
+    return FALSE;
+
+  menu_verbose (" Removing from %p entry %s\n", sd->set, file_id);
+
+  return TRUE; /* return TRUE to remove */
+}
+
+void desktop_entry_set_subtract(DesktopEntrySet* set, DesktopEntrySet* other)
+{
+  SubtractData sd;
+
+  menu_verbose (" Subtract from %p set %p\n", set, other);
+
+  if (desktop_entry_set_get_count (set) == 0 ||
+      desktop_entry_set_get_count (other) == 0)
+    return; /* A fast simple case */
+
+  sd.set   = set;
+  sd.other = other;
+
+  g_hash_table_foreach_remove (set->hash,
+                               (GHRFunc) subtract_foreach_remove,
+                               &sd);
+}
+
+void desktop_entry_set_swap_contents(DesktopEntrySet* a, DesktopEntrySet* b)
+{
+	GHashTable *tmp;
+
+	menu_verbose (" Swap contents of %p and %p\n", a, b);
+
+	tmp = a->hash;
+	 a->hash = b->hash;
+	b->hash = tmp;
+}
diff --git a/libmenu/desktop-entries.h b/libmenu/desktop-entries.h
new file mode 100644
index 0000000..19d9abd
--- /dev/null
+++ b/libmenu/desktop-entries.h
@@ -0,0 +1,90 @@
+/*
+ * Copyright (C) 2002 - 2004 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __DESKTOP_ENTRIES_H__
+#define __DESKTOP_ENTRIES_H__
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef enum {
+	DESKTOP_ENTRY_INVALID = 0,
+	DESKTOP_ENTRY_DESKTOP,
+	DESKTOP_ENTRY_DIRECTORY
+} DesktopEntryType;
+
+typedef struct DesktopEntry DesktopEntry;
+
+DesktopEntry* desktop_entry_new(const char* path);
+
+DesktopEntry* desktop_entry_ref(DesktopEntry* entry);
+DesktopEntry* desktop_entry_copy(DesktopEntry* entry);
+DesktopEntry* desktop_entry_reload(DesktopEntry* entry);
+void desktop_entry_unref(DesktopEntry* entry);
+
+DesktopEntryType desktop_entry_get_type(DesktopEntry* entry);
+const char* desktop_entry_get_path(DesktopEntry* entry);
+const char* desktop_entry_get_basename(DesktopEntry* entry);
+
+const char* desktop_entry_get_name(DesktopEntry* entry);
+const char* desktop_entry_get_generic_name(DesktopEntry* entry);
+const char* desktop_entry_get_full_name(DesktopEntry* entry);
+const char* desktop_entry_get_comment(DesktopEntry* entry);
+const char* desktop_entry_get_icon(DesktopEntry* entry);
+const char* desktop_entry_get_exec(DesktopEntry* entry);
+gboolean desktop_entry_get_launch_in_terminal(DesktopEntry* entry);
+
+gboolean desktop_entry_get_hidden(DesktopEntry* entry);
+gboolean desktop_entry_get_no_display(DesktopEntry* entry);
+gboolean desktop_entry_get_show_in_mate(DesktopEntry* entry);
+gboolean desktop_entry_get_tryexec_failed(DesktopEntry* entry);
+
+gboolean desktop_entry_has_categories(DesktopEntry* entry);
+gboolean desktop_entry_has_category(DesktopEntry* entry, const char* category);
+
+void desktop_entry_add_legacy_category(DesktopEntry* src);
+
+
+typedef struct DesktopEntrySet DesktopEntrySet;
+
+DesktopEntrySet* desktop_entry_set_new(void);
+DesktopEntrySet* desktop_entry_set_ref(DesktopEntrySet* set);
+void desktop_entry_set_unref(DesktopEntrySet* set);
+
+void desktop_entry_set_add_entry(DesktopEntrySet* set, DesktopEntry* entry, const char* file_id);
+DesktopEntry* desktop_entry_set_lookup(DesktopEntrySet* set, const char* file_id);
+int desktop_entry_set_get_count(DesktopEntrySet* set);
+
+void desktop_entry_set_union(DesktopEntrySet* set, DesktopEntrySet* with);
+void desktop_entry_set_intersection(DesktopEntrySet* set, DesktopEntrySet* with);
+void desktop_entry_set_subtract(DesktopEntrySet* set, DesktopEntrySet* other);
+void desktop_entry_set_swap_contents(DesktopEntrySet* a, DesktopEntrySet* b);
+
+typedef void (*DesktopEntrySetForeachFunc) (const char* file_id, DesktopEntry* entry, gpointer user_data);
+
+void desktop_entry_set_foreach(DesktopEntrySet* set, DesktopEntrySetForeachFunc func, gpointer user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __DESKTOP_ENTRIES_H__ */
diff --git a/libmenu/entry-directories.c b/libmenu/entry-directories.c
new file mode 100644
index 0000000..a442a65
--- /dev/null
+++ b/libmenu/entry-directories.c
@@ -0,0 +1,1105 @@
+/*
+ * Copyright (C) 2002 - 2004 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "entry-directories.h"
+
+#include <string.h>
+#include <errno.h>
+#include <sys/types.h>
+#include <dirent.h>
+
+#include "menu-util.h"
+#include "menu-monitor.h"
+#include "canonicalize.h"
+
+typedef struct CachedDir CachedDir;
+typedef struct CachedDirMonitor CachedDirMonitor;
+
+struct EntryDirectory {
+	CachedDir* dir;
+	char* legacy_prefix;
+
+	guint entry_type: 2;
+	guint is_legacy: 1;
+	guint refcount: 24;
+};
+
+struct EntryDirectoryList {
+	int refcount;
+	int length;
+	GList* dirs;
+};
+
+struct CachedDir {
+	CachedDir* parent;
+	char* name;
+
+	GSList* entries;
+	GSList* subdirs;
+
+	MenuMonitor* dir_monitor;
+	GSList* monitors;
+
+	guint have_read_entries: 1;
+	guint deleted: 1;
+
+	guint references: 28;
+};
+
+struct CachedDirMonitor {
+	EntryDirectory* ed;
+	EntryDirectoryChangedFunc callback;
+	gpointer user_data;
+};
+
+static void cached_dir_free(CachedDir* dir);
+static gboolean cached_dir_load_entries_recursive(CachedDir* dir, const char* dirname);
+
+static void handle_cached_dir_changed(MenuMonitor* monitor, MenuMonitorEvent event, const char* path, CachedDir* dir);
+
+/*
+ * Entry directory cache
+ */
+
+static CachedDir* dir_cache = NULL;
+
+static CachedDir* cached_dir_new(const char *name)
+{
+	CachedDir* dir;
+
+	dir = g_new0(CachedDir, 1);
+
+	dir->name = g_strdup(name);
+
+	return dir;
+}
+
+static void cached_dir_free(CachedDir* dir)
+{
+  if (dir->dir_monitor)
+    {
+      menu_monitor_remove_notify (dir->dir_monitor,
+				  (MenuMonitorNotifyFunc) handle_cached_dir_changed,
+				  dir);
+      menu_monitor_unref (dir->dir_monitor);
+      dir->dir_monitor = NULL;
+    }
+
+  g_slist_foreach (dir->monitors, (GFunc) g_free, NULL);
+  g_slist_free (dir->monitors);
+  dir->monitors = NULL;
+
+  g_slist_foreach (dir->entries,
+                   (GFunc) desktop_entry_unref,
+                   NULL);
+  g_slist_free (dir->entries);
+  dir->entries = NULL;
+
+  g_slist_foreach (dir->subdirs,
+                   (GFunc) cached_dir_free,
+                   NULL);
+  g_slist_free (dir->subdirs);
+  dir->subdirs = NULL;
+
+  g_free (dir->name);
+  g_free (dir);
+}
+
+static inline CachedDir* find_subdir(CachedDir* dir, const char* subdir)
+{
+  GSList *tmp;
+
+  tmp = dir->subdirs;
+  while (tmp != NULL)
+    {
+      CachedDir *sub = tmp->data;
+
+      if (strcmp (sub->name, subdir) == 0)
+        return sub;
+
+      tmp = tmp->next;
+    }
+
+  return NULL;
+}
+
+static DesktopEntry* find_entry(CachedDir* dir, const char* basename)
+{
+  GSList *tmp;
+
+  tmp = dir->entries;
+  while (tmp != NULL)
+    {
+      if (strcmp (desktop_entry_get_basename (tmp->data), basename) == 0)
+        return tmp->data;
+
+      tmp = tmp->next;
+    }
+
+  return NULL;
+}
+
+static DesktopEntry* cached_dir_find_relative_path(CachedDir* dir, const char* relative_path)
+{
+  DesktopEntry  *retval = NULL;
+  char         **split;
+  int            i;
+
+  split = g_strsplit (relative_path, "/", -1);
+
+  i = 0;
+  while (split[i] != NULL)
+    {
+      if (split[i + 1] != NULL)
+        {
+          if ((dir = find_subdir (dir, split[i])) == NULL)
+            break;
+        }
+      else
+        {
+          retval = find_entry (dir, split[i]);
+          break;
+        }
+
+      ++i;
+    }
+
+  g_strfreev (split);
+
+  return retval;
+}
+
+static CachedDir* cached_dir_lookup(const char* canonical)
+{
+  CachedDir  *dir;
+  char      **split;
+  int         i;
+
+  if (dir_cache == NULL)
+    dir_cache = cached_dir_new ("/");
+  dir = dir_cache;
+
+  g_assert (canonical != NULL && canonical[0] == G_DIR_SEPARATOR);
+
+  menu_verbose ("Looking up cached dir \"%s\"\n", canonical);
+
+  split = g_strsplit (canonical + 1, "/", -1);
+
+  i = 0;
+  while (split[i] != NULL)
+    {
+      CachedDir *subdir;
+
+      if ((subdir = find_subdir (dir, split[i])) == NULL)
+        {
+          subdir = cached_dir_new (split[i]);
+          dir->subdirs = g_slist_prepend (dir->subdirs, subdir);
+          subdir->parent = dir;
+        }
+
+      dir = subdir;
+
+      ++i;
+    }
+
+  g_strfreev (split);
+
+  g_assert (dir != NULL);
+
+  return dir;
+}
+
+static gboolean cached_dir_add_entry(CachedDir* dir, const char* basename, const char* path)
+{
+  DesktopEntry *entry;
+
+  entry = desktop_entry_new (path);
+  if (entry == NULL)
+    return FALSE;
+
+  dir->entries = g_slist_prepend (dir->entries, entry);
+
+  return TRUE;
+}
+
+static gboolean cached_dir_update_entry(CachedDir* dir, const char* basename, const char* path)
+{
+  GSList *tmp;
+
+  tmp = dir->entries;
+  while (tmp != NULL)
+    {
+      if (strcmp (desktop_entry_get_basename (tmp->data), basename) == 0)
+        {
+          if (!desktop_entry_reload (tmp->data))
+	    {
+	      dir->entries = g_slist_delete_link (dir->entries, tmp);
+	    }
+
+          return TRUE;
+        }
+
+      tmp = tmp->next;
+    }
+
+  return cached_dir_add_entry (dir, basename, path);
+}
+
+static gboolean cached_dir_remove_entry(CachedDir* dir, const char* basename)
+{
+  GSList *tmp;
+
+  tmp = dir->entries;
+  while (tmp != NULL)
+    {
+      if (strcmp (desktop_entry_get_basename (tmp->data), basename) == 0)
+        {
+          desktop_entry_unref (tmp->data);
+          dir->entries = g_slist_delete_link (dir->entries, tmp);
+          return TRUE;
+        }
+
+      tmp = tmp->next;
+    }
+
+  return FALSE;
+}
+
+static gboolean cached_dir_add_subdir(CachedDir* dir, const char* basename, const char* path)
+{
+  CachedDir *subdir;
+
+  subdir = find_subdir (dir, basename);
+
+  if (subdir != NULL)
+    {
+      subdir->deleted = FALSE;
+      return TRUE;
+    }
+
+  subdir = cached_dir_new (basename);
+
+  if (!cached_dir_load_entries_recursive (subdir, path))
+    {
+      cached_dir_free (subdir);
+      return FALSE;
+    }
+
+  menu_verbose ("Caching dir \"%s\"\n", basename);
+
+  subdir->parent = dir;
+  dir->subdirs = g_slist_prepend (dir->subdirs, subdir);
+
+  return TRUE;
+}
+
+static gboolean cached_dir_remove_subdir(CachedDir* dir, const char* basename)
+{
+  CachedDir *subdir;
+
+  subdir = find_subdir (dir, basename);
+
+  if (subdir != NULL)
+    {
+      subdir->deleted = TRUE;
+
+      if (subdir->references == 0)
+        {
+          cached_dir_free (subdir);
+          dir->subdirs = g_slist_remove (dir->subdirs, subdir);
+        }
+
+      return TRUE;
+    }
+
+  return FALSE;
+}
+
+static void cached_dir_invoke_monitors(CachedDir* dir)
+{
+  GSList *tmp;
+
+  tmp = dir->monitors;
+  while (tmp != NULL)
+    {
+      CachedDirMonitor *monitor = tmp->data;
+      GSList           *next    = tmp->next;
+
+      monitor->callback (monitor->ed, monitor->user_data);
+
+      tmp = next;
+    }
+
+  if (dir->parent)
+    {
+      cached_dir_invoke_monitors (dir->parent);
+    }
+}
+
+static void handle_cached_dir_changed (MenuMonitor* monitor, MenuMonitorEvent event, const char* path, CachedDir* dir)
+{
+  gboolean  handled = FALSE;
+  char     *basename;
+  char     *dirname;
+
+  menu_verbose ("'%s' notified of '%s' %s - invalidating cache\n",
+		dir->name,
+                path,
+                event == MENU_MONITOR_EVENT_CREATED ? ("created") :
+                event == MENU_MONITOR_EVENT_DELETED ? ("deleted") : ("changed"));
+
+  dirname  = g_path_get_dirname  (path);
+  basename = g_path_get_basename (path);
+
+  dir = cached_dir_lookup (dirname);
+
+  if (g_str_has_suffix (basename, ".desktop") ||
+      g_str_has_suffix (basename, ".directory"))
+    {
+      switch (event)
+        {
+        case MENU_MONITOR_EVENT_CREATED:
+        case MENU_MONITOR_EVENT_CHANGED:
+          handled = cached_dir_update_entry (dir, basename, path);
+          break;
+
+        case MENU_MONITOR_EVENT_DELETED:
+          handled = cached_dir_remove_entry (dir, basename);
+          break;
+
+        default:
+          g_assert_not_reached ();
+          break;
+        }
+    }
+  else /* Try recursing */
+    {
+      switch (event)
+        {
+        case MENU_MONITOR_EVENT_CREATED:
+          handled = cached_dir_add_subdir (dir, basename, path);
+          break;
+
+        case MENU_MONITOR_EVENT_CHANGED:
+          break;
+
+        case MENU_MONITOR_EVENT_DELETED:
+          handled = cached_dir_remove_subdir (dir, basename);
+          break;
+
+        default:
+          g_assert_not_reached ();
+          break;
+        }
+    }
+
+  g_free (basename);
+  g_free (dirname);
+
+  if (handled)
+    {
+      /* CHANGED events don't change the set of desktop entries */
+      if (event == MENU_MONITOR_EVENT_CREATED || event == MENU_MONITOR_EVENT_DELETED)
+        {
+          _entry_directory_list_empty_desktop_cache ();
+        }
+
+      cached_dir_invoke_monitors (dir);
+    }
+}
+
+static void cached_dir_ensure_monitor(CachedDir* dir, const char* dirname)
+{
+  if (dir->dir_monitor == NULL)
+    {
+      dir->dir_monitor = menu_get_directory_monitor (dirname);
+      menu_monitor_add_notify (dir->dir_monitor,
+			       (MenuMonitorNotifyFunc) handle_cached_dir_changed,
+			       dir);
+    }
+}
+
+static gboolean cached_dir_load_entries_recursive(CachedDir* dir, const char* dirname)
+{
+  DIR           *dp;
+  struct dirent *dent;
+  GString       *fullpath;
+  gsize          fullpath_len;
+
+  g_assert (dir != NULL);
+
+  if (dir->have_read_entries)
+    return TRUE;
+
+  menu_verbose ("Attempting to read entries from %s (full path %s)\n",
+                dir->name, dirname);
+
+  dp = opendir (dirname);
+  if (dp == NULL)
+    {
+      menu_verbose ("Unable to list directory \"%s\"\n",
+                    dirname);
+      return FALSE;
+    }
+
+  cached_dir_ensure_monitor (dir, dirname);
+
+  fullpath = g_string_new (dirname);
+  if (fullpath->str[fullpath->len - 1] != G_DIR_SEPARATOR)
+    g_string_append_c (fullpath, G_DIR_SEPARATOR);
+
+  fullpath_len = fullpath->len;
+
+  while ((dent = readdir (dp)) != NULL)
+    {
+      /* ignore . and .. */
+      if (dent->d_name[0] == '.' &&
+          (dent->d_name[1] == '\0' ||
+           (dent->d_name[1] == '.' &&
+            dent->d_name[2] == '\0')))
+        continue;
+
+      g_string_append (fullpath, dent->d_name);
+
+      if (g_str_has_suffix (dent->d_name, ".desktop") ||
+          g_str_has_suffix (dent->d_name, ".directory"))
+        {
+          cached_dir_add_entry (dir, dent->d_name, fullpath->str);
+        }
+      else /* Try recursing */
+        {
+          cached_dir_add_subdir (dir, dent->d_name, fullpath->str);
+        }
+
+      g_string_truncate (fullpath, fullpath_len);
+    }
+
+  closedir (dp);
+
+  g_string_free (fullpath, TRUE);
+
+  dir->have_read_entries = TRUE;
+
+  return TRUE;
+}
+
+static void cached_dir_add_monitor(CachedDir* dir, EntryDirectory* ed, EntryDirectoryChangedFunc callback, gpointer user_data)
+{
+  CachedDirMonitor *monitor;
+  GSList           *tmp;
+
+  tmp = dir->monitors;
+  while (tmp != NULL)
+    {
+      monitor = tmp->data;
+
+      if (monitor->ed == ed &&
+          monitor->callback == callback &&
+          monitor->user_data == user_data)
+        break;
+
+      tmp = tmp->next;
+    }
+
+  if (tmp == NULL)
+    {
+      monitor            = g_new0 (CachedDirMonitor, 1);
+      monitor->ed        = ed;
+      monitor->callback  = callback;
+      monitor->user_data = user_data;
+
+      dir->monitors = g_slist_append (dir->monitors, monitor);
+    }
+}
+
+static void cached_dir_remove_monitor(CachedDir* dir, EntryDirectory* ed, EntryDirectoryChangedFunc callback, gpointer user_data)
+{
+  GSList *tmp;
+
+  tmp = dir->monitors;
+  while (tmp != NULL)
+    {
+      CachedDirMonitor *monitor = tmp->data;
+      GSList           *next = tmp->next;
+
+      if (monitor->ed == ed &&
+          monitor->callback == callback &&
+          monitor->user_data == user_data)
+        {
+          dir->monitors = g_slist_delete_link (dir->monitors, tmp);
+          g_free (monitor);
+        }
+
+      tmp = next;
+    }
+}
+
+static void cached_dir_add_reference(CachedDir* dir)
+{
+  dir->references++;
+
+  if (dir->parent != NULL)
+    {
+      cached_dir_add_reference (dir->parent);
+    }
+}
+
+static void cached_dir_remove_reference(CachedDir* dir)
+{
+  CachedDir *parent;
+
+  parent = dir->parent;
+
+  if (--dir->references == 0 && dir->deleted)
+    {
+      if (dir->parent != NULL)
+	{
+	  GSList *tmp;
+
+	  tmp = parent->subdirs;
+	  while (tmp != NULL)
+	    {
+	      CachedDir *subdir = tmp->data;
+
+	      if (!strcmp (subdir->name, dir->name))
+		{
+		  parent->subdirs = g_slist_delete_link (parent->subdirs, tmp);
+		  break;
+		}
+
+	      tmp = tmp->next;
+	    }
+	}
+
+      cached_dir_free (dir);
+    }
+
+  if (parent != NULL)
+    {
+      cached_dir_remove_reference (parent);
+    }
+}
+
+/*
+ * Entry directories
+ */
+
+static EntryDirectory* entry_directory_new_full(DesktopEntryType entry_type, const char* path, gboolean is_legacy, const char* legacy_prefix)
+{
+  EntryDirectory *ed;
+  char           *canonical;
+
+  menu_verbose ("Loading entry directory \"%s\" (legacy %s)\n",
+                path,
+                is_legacy ? "<yes>" : "<no>");
+
+  canonical = menu_canonicalize_file_name (path, FALSE);
+  if (canonical == NULL)
+    {
+      menu_verbose ("Failed to canonicalize \"%s\": %s\n",
+                    path, g_strerror (errno));
+      return NULL;
+    }
+
+  ed = g_new0 (EntryDirectory, 1);
+
+  ed->dir = cached_dir_lookup (canonical);
+  g_assert (ed->dir != NULL);
+
+  cached_dir_add_reference (ed->dir);
+  cached_dir_load_entries_recursive (ed->dir, canonical);
+
+  ed->legacy_prefix = g_strdup (legacy_prefix);
+  ed->entry_type    = entry_type;
+  ed->is_legacy     = is_legacy != FALSE;
+  ed->refcount      = 1;
+
+  g_free (canonical);
+
+  return ed;
+}
+
+EntryDirectory* entry_directory_new(DesktopEntryType entry_type, const char* path)
+{
+	return entry_directory_new_full (entry_type, path, FALSE, NULL);
+}
+
+EntryDirectory* entry_directory_new_legacy(DesktopEntryType entry_type, const char* path, const char* legacy_prefix)
+{
+	return entry_directory_new_full(entry_type, path, TRUE, legacy_prefix);
+}
+
+EntryDirectory* entry_directory_ref(EntryDirectory* ed)
+{
+	g_return_val_if_fail(ed != NULL, NULL);
+	g_return_val_if_fail(ed->refcount > 0, NULL);
+
+	ed->refcount++;
+
+	return ed;
+}
+
+void entry_directory_unref(EntryDirectory* ed)
+{
+  g_return_if_fail (ed != NULL);
+  g_return_if_fail (ed->refcount > 0);
+
+  if (--ed->refcount == 0)
+    {
+      cached_dir_remove_reference (ed->dir);
+
+      ed->dir        = NULL;
+      ed->entry_type = DESKTOP_ENTRY_INVALID;
+      ed->is_legacy  = FALSE;
+
+      g_free (ed->legacy_prefix);
+      ed->legacy_prefix = NULL;
+
+      g_free (ed);
+    }
+}
+
+static void entry_directory_add_monitor(EntryDirectory* ed, EntryDirectoryChangedFunc callback, gpointer user_data)
+{
+  cached_dir_add_monitor (ed->dir, ed, callback, user_data);
+}
+
+static void entry_directory_remove_monitor(EntryDirectory* ed, EntryDirectoryChangedFunc callback, gpointer user_data)
+{
+  cached_dir_remove_monitor (ed->dir, ed, callback, user_data);
+}
+
+static DesktopEntry* entry_directory_get_directory(EntryDirectory* ed, const char* relative_path)
+{
+  DesktopEntry *entry;
+
+  if (ed->entry_type != DESKTOP_ENTRY_DIRECTORY)
+    return NULL;
+
+  entry = cached_dir_find_relative_path (ed->dir, relative_path);
+  if (entry == NULL || desktop_entry_get_type (entry) != DESKTOP_ENTRY_DIRECTORY)
+    return NULL;
+
+  return desktop_entry_ref (entry);
+}
+
+static char* get_desktop_file_id_from_path(EntryDirectory* ed, DesktopEntryType  entry_type, const char* relative_path)
+{
+  char *retval;
+
+  retval = NULL;
+
+  if (entry_type == DESKTOP_ENTRY_DESKTOP)
+    {
+      if (!ed->is_legacy)
+	{
+	  retval = g_strdelimit (g_strdup (relative_path), "/", '-');
+	}
+      else
+	{
+	  char *basename;
+
+	  basename = g_path_get_basename (relative_path);
+
+	  if (ed->legacy_prefix)
+	    {
+	      retval = g_strjoin ("-", ed->legacy_prefix, basename, NULL);
+	      g_free (basename);
+	    }
+	  else
+	    {
+	      retval = basename;
+	    }
+	}
+    }
+  else
+    {
+      retval = g_strdup (relative_path);
+    }
+
+  return retval;
+}
+
+typedef gboolean (*EntryDirectoryForeachFunc) (EntryDirectory* ed, DesktopEntry* entry, const char* file_id, DesktopEntrySet* set, gpointer user_data);
+
+static gboolean entry_directory_foreach_recursive(EntryDirectory* ed, CachedDir* cd, GString* relative_path, EntryDirectoryForeachFunc func, DesktopEntrySet* set, gpointer user_data)
+{
+  GSList *tmp;
+  int     relative_path_len;
+
+  if (cd->deleted)
+    return TRUE;
+
+  relative_path_len = relative_path->len;
+
+  tmp = cd->entries;
+  while (tmp != NULL)
+    {
+      DesktopEntry *entry = tmp->data;
+
+      if (desktop_entry_get_type (entry) == ed->entry_type)
+        {
+          gboolean  ret;
+          char     *file_id;
+
+          g_string_append (relative_path,
+                           desktop_entry_get_basename (entry));
+
+	  file_id = get_desktop_file_id_from_path (ed,
+						   ed->entry_type,
+						   relative_path->str);
+
+          ret = func (ed, entry, file_id, set, user_data);
+
+          g_free (file_id);
+
+          g_string_truncate (relative_path, relative_path_len);
+
+          if (!ret)
+            return FALSE;
+        }
+
+      tmp = tmp->next;
+    }
+
+  tmp = cd->subdirs;
+  while (tmp != NULL)
+    {
+      CachedDir *subdir = tmp->data;
+
+      g_string_append (relative_path, subdir->name);
+      g_string_append_c (relative_path, G_DIR_SEPARATOR);
+
+      if (!entry_directory_foreach_recursive (ed,
+                                              subdir,
+                                              relative_path,
+                                              func,
+                                              set,
+                                              user_data))
+        return FALSE;
+
+      g_string_truncate (relative_path, relative_path_len);
+
+      tmp = tmp->next;
+    }
+
+  return TRUE;
+}
+
+static void entry_directory_foreach(EntryDirectory* ed, EntryDirectoryForeachFunc func, DesktopEntrySet* set, gpointer user_data)
+{
+  GString *path;
+
+  path = g_string_new (NULL);
+
+  entry_directory_foreach_recursive (ed,
+                                     ed->dir,
+                                     path,
+                                     func,
+                                     set,
+                                     user_data);
+
+  g_string_free (path, TRUE);
+}
+
+void entry_directory_get_flat_contents(EntryDirectory* ed, DesktopEntrySet* desktop_entries, DesktopEntrySet* directory_entries, GSList** subdirs)
+{
+  GSList *tmp;
+
+  if (subdirs)
+    *subdirs = NULL;
+
+  tmp = ed->dir->entries;
+  while (tmp != NULL)
+    {
+      DesktopEntry *entry = tmp->data;
+      const char   *basename;
+
+      basename = desktop_entry_get_basename (entry);
+
+      if (desktop_entries &&
+          desktop_entry_get_type (entry) == DESKTOP_ENTRY_DESKTOP)
+        {
+          char *file_id;
+
+          file_id = get_desktop_file_id_from_path (ed,
+						   DESKTOP_ENTRY_DESKTOP,
+						   basename);
+
+          desktop_entry_set_add_entry (desktop_entries,
+                                       entry,
+                                       file_id);
+
+          g_free (file_id);
+        }
+
+      if (directory_entries &&
+          desktop_entry_get_type (entry) == DESKTOP_ENTRY_DIRECTORY)
+        {
+          desktop_entry_set_add_entry (directory_entries,
+				       entry,
+				       basename);
+        }
+
+      tmp = tmp->next;
+    }
+
+  if (subdirs)
+    {
+      tmp = ed->dir->subdirs;
+      while (tmp != NULL)
+        {
+          CachedDir *cd = tmp->data;
+
+	  if (!cd->deleted)
+	    {
+	      *subdirs = g_slist_prepend (*subdirs, g_strdup (cd->name));
+	    }
+
+          tmp = tmp->next;
+        }
+    }
+
+  if (subdirs)
+    *subdirs = g_slist_reverse (*subdirs);
+}
+
+/*
+ * Entry directory lists
+ */
+
+EntryDirectoryList* entry_directory_list_new(void)
+{
+  EntryDirectoryList *list;
+
+  list = g_new0 (EntryDirectoryList, 1);
+
+  list->refcount = 1;
+  list->dirs = NULL;
+  list->length = 0;
+
+  return list;
+}
+
+EntryDirectoryList* entry_directory_list_ref(EntryDirectoryList* list)
+{
+  g_return_val_if_fail (list != NULL, NULL);
+  g_return_val_if_fail (list->refcount > 0, NULL);
+
+  list->refcount += 1;
+
+  return list;
+}
+
+void entry_directory_list_unref(EntryDirectoryList* list)
+{
+  g_return_if_fail (list != NULL);
+  g_return_if_fail (list->refcount > 0);
+
+  list->refcount -= 1;
+  if (list->refcount == 0)
+    {
+      g_list_foreach (list->dirs, (GFunc) entry_directory_unref, NULL);
+      g_list_free (list->dirs);
+      list->dirs = NULL;
+      list->length = 0;
+      g_free (list);
+    }
+}
+
+void entry_directory_list_prepend(EntryDirectoryList* list, EntryDirectory* ed)
+{
+  list->length += 1;
+  list->dirs = g_list_prepend (list->dirs,
+                               entry_directory_ref (ed));
+}
+
+int entry_directory_list_get_length(EntryDirectoryList* list)
+{
+  return list->length;
+}
+
+void entry_directory_list_append_list(EntryDirectoryList* list, EntryDirectoryList* to_append)
+{
+  GList *tmp;
+  GList *new_dirs = NULL;
+
+  if (to_append->length == 0)
+    return;
+
+  tmp = to_append->dirs;
+  while (tmp != NULL)
+    {
+      list->length += 1;
+      new_dirs = g_list_prepend (new_dirs,
+                                 entry_directory_ref (tmp->data));
+
+      tmp = tmp->next;
+    }
+
+  new_dirs   = g_list_reverse (new_dirs);
+  list->dirs = g_list_concat (list->dirs, new_dirs);
+}
+
+DesktopEntry* entry_directory_list_get_directory(EntryDirectoryList *list, const char* relative_path)
+{
+  DesktopEntry *retval = NULL;
+  GList        *tmp;
+
+  tmp = list->dirs;
+  while (tmp != NULL)
+    {
+      if ((retval = entry_directory_get_directory (tmp->data, relative_path)) != NULL)
+        break;
+
+      tmp = tmp->next;
+    }
+
+  return retval;
+}
+
+gboolean _entry_directory_list_compare(const EntryDirectoryList* a, const EntryDirectoryList* b)
+{
+  GList *al, *bl;
+
+  if (a == NULL && b == NULL)
+    return TRUE;
+
+  if ((a == NULL || b == NULL))
+    return FALSE;
+
+  if (a->length != b->length)
+    return FALSE;
+
+  al = a->dirs; bl = b->dirs;
+  while (al && bl && al->data == bl->data)
+    {
+      al = al->next;
+      bl = bl->next;
+    }
+
+  return (al == NULL && bl == NULL);
+}
+
+static gboolean get_all_func(EntryDirectory* ed, DesktopEntry* entry, const char* file_id, DesktopEntrySet* set, gpointer user_data)
+{
+  if (ed->is_legacy && !desktop_entry_has_categories (entry))
+    {
+      entry = desktop_entry_copy (entry);
+      desktop_entry_add_legacy_category (entry);
+    }
+  else
+    {
+      entry = desktop_entry_ref (entry);
+    }
+
+  desktop_entry_set_add_entry (set, entry, file_id);
+  desktop_entry_unref (entry);
+
+  return TRUE;
+}
+
+static DesktopEntrySet* entry_directory_last_set = NULL;
+static EntryDirectoryList* entry_directory_last_list = NULL;
+
+void _entry_directory_list_empty_desktop_cache(void)
+{
+  if (entry_directory_last_set != NULL)
+    desktop_entry_set_unref (entry_directory_last_set);
+  entry_directory_last_set = NULL;
+
+  if (entry_directory_last_list != NULL)
+    entry_directory_list_unref (entry_directory_last_list);
+  entry_directory_last_list = NULL;
+}
+
+DesktopEntrySet* _entry_directory_list_get_all_desktops(EntryDirectoryList* list)
+{
+  GList *tmp;
+  DesktopEntrySet *set;
+
+  /* The only tricky thing here is that desktop files later
+   * in the search list with the same relative path
+   * are "hidden" by desktop files earlier in the path,
+   * so we have to do the earlier files first causing
+   * the later files to replace the earlier files
+   * in the DesktopEntrySet
+   *
+   * We go from the end of the list so we can just
+   * g_hash_table_replace and not have to do two
+   * hash lookups (check for existing entry, then insert new
+   * entry)
+   */
+
+  /* This method is -extremely- slow, so we have a simple
+     one-entry cache here */
+  if (_entry_directory_list_compare (list, entry_directory_last_list))
+    {
+      menu_verbose (" Hit desktop list (%p) cache\n", list);
+      return desktop_entry_set_ref (entry_directory_last_set);
+    }
+
+  if (entry_directory_last_set != NULL)
+    desktop_entry_set_unref (entry_directory_last_set);
+  if (entry_directory_last_list != NULL)
+    entry_directory_list_unref (entry_directory_last_list);
+
+  set = desktop_entry_set_new ();
+  menu_verbose (" Storing all of list %p in set %p\n",
+                list, set);
+
+  tmp = g_list_last (list->dirs);
+  while (tmp != NULL)
+    {
+      entry_directory_foreach (tmp->data, get_all_func, set, NULL);
+
+      tmp = tmp->prev;
+    }
+
+  entry_directory_last_list = entry_directory_list_ref (list);
+  entry_directory_last_set = desktop_entry_set_ref (set);
+
+  return set;
+}
+
+void entry_directory_list_add_monitors(EntryDirectoryList* list, EntryDirectoryChangedFunc callback, gpointer user_data)
+{
+  GList *tmp;
+
+  tmp = list->dirs;
+  while (tmp != NULL)
+    {
+      entry_directory_add_monitor (tmp->data, callback, user_data);
+      tmp = tmp->next;
+    }
+}
+
+void entry_directory_list_remove_monitors(EntryDirectoryList* list, EntryDirectoryChangedFunc callback, gpointer user_data)
+{
+  GList *tmp;
+
+  tmp = list->dirs;
+  while (tmp != NULL)
+    {
+      entry_directory_remove_monitor (tmp->data, callback, user_data);
+      tmp = tmp->next;
+    }
+}
diff --git a/libmenu/entry-directories.h b/libmenu/entry-directories.h
new file mode 100644
index 0000000..3cc4d9b
--- /dev/null
+++ b/libmenu/entry-directories.h
@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2002 - 2004 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __ENTRY_DIRECTORIES_H__
+#define __ENTRY_DIRECTORIES_H__
+
+#include <glib.h>
+#include "desktop-entries.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct EntryDirectory EntryDirectory;
+
+typedef void (*EntryDirectoryChangedFunc) (EntryDirectory* ed, gpointer user_data);
+
+EntryDirectory* entry_directory_new(DesktopEntryType entry_type, const char* path);
+EntryDirectory* entry_directory_new_legacy(DesktopEntryType entry_type, const char* path, const char* legacy_prefix);
+
+EntryDirectory* entry_directory_ref(EntryDirectory* ed);
+void entry_directory_unref(EntryDirectory* ed);
+
+void entry_directory_get_flat_contents(EntryDirectory* ed, DesktopEntrySet* desktop_entries, DesktopEntrySet* directory_entries, GSList** subdirs);
+
+
+typedef struct EntryDirectoryList EntryDirectoryList;
+
+EntryDirectoryList* entry_directory_list_new(void);
+EntryDirectoryList* entry_directory_list_ref(EntryDirectoryList* list);
+void entry_directory_list_unref(EntryDirectoryList* list);
+
+int  entry_directory_list_get_length(EntryDirectoryList* list);
+gboolean _entry_directory_list_compare(const EntryDirectoryList* a, const EntryDirectoryList* b);
+
+void entry_directory_list_prepend(EntryDirectoryList* list, EntryDirectory* ed);
+void entry_directory_list_append_list(EntryDirectoryList* list, EntryDirectoryList* to_append);
+
+void entry_directory_list_add_monitors(EntryDirectoryList* list, EntryDirectoryChangedFunc callback, gpointer user_data);
+void entry_directory_list_remove_monitors(EntryDirectoryList* list, EntryDirectoryChangedFunc callback, gpointer user_data);
+
+DesktopEntry* entry_directory_list_get_directory (EntryDirectoryList* list, const char* relative_path);
+
+DesktopEntrySet* _entry_directory_list_get_all_desktops(EntryDirectoryList* list);
+void _entry_directory_list_empty_desktop_cache(void);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __ENTRY_DIRECTORIES_H__ */
diff --git a/libmenu/libmate-menu-uninstalled.pc.in b/libmenu/libmate-menu-uninstalled.pc.in
new file mode 100644
index 0000000..e0b0496
--- /dev/null
+++ b/libmenu/libmate-menu-uninstalled.pc.in
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libmate-menu
+Description: Desktop Menu Specification Implementation
+Requires: glib-2.0
+Version: @VERSION@
+Libs: ${pc_top_builddir}/${pcfiledir}/libmate-menu.la
+Cflags: -I${pc_top_builddir}/${pcfiledir}
diff --git a/libmenu/libmate-menu.pc.in b/libmenu/libmate-menu.pc.in
new file mode 100644
index 0000000..ab593d2
--- /dev/null
+++ b/libmenu/libmate-menu.pc.in
@@ -0,0 +1,11 @@
+prefix=@prefix@
+exec_prefix=@exec_prefix@
+libdir=@libdir@
+includedir=@includedir@
+
+Name: libmate-menu
+Description: Desktop Menu Specification Implementation
+Requires: glib-2.0
+Version: @VERSION@
+Libs: -L${libdir} -lmate-menu
+Cflags: -I${includedir}/mate-menus
diff --git a/libmenu/matemenu-tree.c b/libmenu/matemenu-tree.c
new file mode 100644
index 0000000..683eb55
--- /dev/null
+++ b/libmenu/matemenu-tree.c
@@ -0,0 +1,4520 @@
+/*
+ * Copyright (C) 2003, 2004 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "matemenu-tree.h"
+
+#include <string.h>
+#include <errno.h>
+
+#include "menu-layout.h"
+#include "menu-monitor.h"
+#include "menu-util.h"
+#include "canonicalize.h"
+
+/*
+ * FIXME: it might be useful to be able to construct a menu
+ * tree from a traditional directory based menu hierarchy
+ * too.
+ */
+
+typedef enum
+{
+  MATEMENU_TREE_ABSOLUTE = 0,
+  MATEMENU_TREE_BASENAME = 1
+} MateMenuTreeType;
+
+struct MateMenuTree
+{
+  MateMenuTreeType type;
+  guint         refcount;
+
+  char *basename;
+  char *absolute_path;
+  char *canonical_path;
+
+  MateMenuTreeFlags flags;
+  MateMenuTreeSortKey sort_key;
+
+  GSList *menu_file_monitors;
+
+  MenuLayoutNode *layout;
+  MateMenuTreeDirectory *root;
+
+  GSList *monitors;
+
+  gpointer       user_data;
+  GDestroyNotify dnotify;
+
+  guint canonical : 1;
+};
+
+typedef struct
+{
+  MateMenuTreeChangedFunc callback;
+  gpointer             user_data;
+} MateMenuTreeMonitor;
+
+struct MateMenuTreeItem
+{
+  MateMenuTreeItemType type;
+
+  MateMenuTreeDirectory *parent;
+
+  gpointer       user_data;
+  GDestroyNotify dnotify;
+
+  guint refcount;
+};
+
+struct MateMenuTreeDirectory
+{
+	MateMenuTreeItem item;
+
+	DesktopEntry *directory_entry;
+	char         *name;
+
+	GSList *entries;
+	GSList *subdirs;
+
+	MenuLayoutValues  default_layout_values;
+	GSList           *default_layout_info;
+	GSList           *layout_info;
+	GSList           *contents;
+
+	guint only_unallocated : 1;
+	guint is_root : 1;
+	guint is_nodisplay : 1;
+	guint layout_pending_separator : 1;
+	guint preprocessed : 1;
+
+	/* 16 bits should be more than enough; G_MAXUINT16 means no inline header */
+	guint will_inline_header : 16;
+};
+
+typedef struct
+{
+  MateMenuTreeDirectory directory;
+
+  MateMenuTree *tree;
+} MateMenuTreeDirectoryRoot;
+
+struct MateMenuTreeEntry
+{
+  MateMenuTreeItem item;
+
+  DesktopEntry *desktop_entry;
+  char         *desktop_file_id;
+
+  guint is_excluded : 1;
+  guint is_nodisplay : 1;
+};
+
+struct MateMenuTreeSeparator
+{
+  MateMenuTreeItem item;
+};
+
+struct MateMenuTreeHeader
+{
+  MateMenuTreeItem item;
+
+  MateMenuTreeDirectory *directory;
+};
+
+struct MateMenuTreeAlias
+{
+  MateMenuTreeItem item;
+
+  MateMenuTreeDirectory *directory;
+  MateMenuTreeItem      *aliased_item;
+};
+
+static MateMenuTree *matemenu_tree_new                 (MateMenuTreeType    type,
+						  const char      *menu_file,
+						  gboolean         canonical,
+						  MateMenuTreeFlags   flags);
+static void      matemenu_tree_load_layout          (MateMenuTree       *tree);
+static void      matemenu_tree_force_reload         (MateMenuTree       *tree);
+static void      matemenu_tree_build_from_layout    (MateMenuTree       *tree);
+static void      matemenu_tree_force_rebuild        (MateMenuTree       *tree);
+static void      matemenu_tree_resolve_files        (MateMenuTree       *tree,
+						  GHashTable      *loaded_menu_files,
+						  MenuLayoutNode  *layout);
+static void      matemenu_tree_force_recanonicalize (MateMenuTree       *tree);
+static void      matemenu_tree_invoke_monitors      (MateMenuTree       *tree);
+
+static void matemenu_tree_item_unref_and_unset_parent (gpointer itemp);
+
+/*
+ * The idea is that we cache the menu tree for either a given
+ * menu basename or an absolute menu path.
+ * If no files exist in $XDG_DATA_DIRS for the basename or the
+ * absolute path doesn't exist we just return (and cache) the
+ * empty menu tree.
+ * We also add a file monitor for the basename in each dir in
+ * $XDG_DATA_DIRS, or the absolute path to the menu file, and
+ * re-compute if there are any changes.
+ */
+
+static GHashTable *matemenu_tree_cache = NULL;
+
+static inline char *
+get_cache_key (MateMenuTree      *tree,
+	       MateMenuTreeFlags  flags)
+{
+  const char *tree_name;
+
+  switch (tree->type)
+    {
+    case MATEMENU_TREE_ABSOLUTE:
+      tree_name = tree->canonical ? tree->canonical_path : tree->absolute_path;
+      break;
+
+    case MATEMENU_TREE_BASENAME:
+      tree_name = tree->basename;
+      break;
+
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+  return g_strdup_printf ("%s:0x%x", tree_name, flags);
+}
+
+static void
+matemenu_tree_add_to_cache (MateMenuTree      *tree,
+			 MateMenuTreeFlags  flags)
+{
+  char *cache_key;
+
+  if (matemenu_tree_cache == NULL)
+    {
+      matemenu_tree_cache =
+        g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+    }
+
+  cache_key = get_cache_key (tree, flags);
+
+  menu_verbose ("Adding menu tree to cache: %s\n", cache_key);
+
+  g_hash_table_replace (matemenu_tree_cache, cache_key, tree);
+}
+
+static void
+matemenu_tree_remove_from_cache (MateMenuTree      *tree,
+			      MateMenuTreeFlags  flags)
+{
+  char *cache_key;
+
+  cache_key = get_cache_key (tree, flags);
+
+  menu_verbose ("Removing menu tree from cache: %s\n", cache_key);
+
+  g_hash_table_remove (matemenu_tree_cache, cache_key);
+
+  g_free (cache_key);
+
+  if (g_hash_table_size (matemenu_tree_cache) == 0)
+    {
+      g_hash_table_destroy (matemenu_tree_cache);
+      matemenu_tree_cache = NULL;
+
+      _entry_directory_list_empty_desktop_cache ();
+    }
+}
+
+static MateMenuTree *
+matemenu_tree_lookup_from_cache (const char    *tree_name,
+			      MateMenuTreeFlags  flags)
+{
+  MateMenuTree *retval;
+  char     *cache_key;
+
+  if (matemenu_tree_cache == NULL)
+    return NULL;
+
+  cache_key = g_strdup_printf ("%s:0x%x", tree_name, flags);
+
+  menu_verbose ("Looking up '%s' from menu cache\n", cache_key);
+
+  retval = g_hash_table_lookup (matemenu_tree_cache, cache_key);
+
+  g_free (cache_key);
+
+  return retval ? matemenu_tree_ref (retval) : NULL;
+}
+
+typedef enum
+{
+  MENU_FILE_MONITOR_INVALID = 0,
+  MENU_FILE_MONITOR_FILE,
+  MENU_FILE_MONITOR_NONEXISTENT_FILE,
+  MENU_FILE_MONITOR_DIRECTORY
+} MenuFileMonitorType;
+
+typedef struct
+{
+  MenuFileMonitorType  type;
+  MenuMonitor         *monitor;
+} MenuFileMonitor;
+
+static void
+handle_nonexistent_menu_file_changed (MenuMonitor      *monitor,
+				      MenuMonitorEvent  event,
+				      const char       *path,
+				      MateMenuTree        *tree)
+{
+  if (event == MENU_MONITOR_EVENT_CHANGED ||
+      event == MENU_MONITOR_EVENT_CREATED)
+    {
+      menu_verbose ("\"%s\" %s, marking tree for recanonicalization\n",
+                    path,
+                    event == MENU_MONITOR_EVENT_CREATED ? "created" : "changed");
+
+      matemenu_tree_force_recanonicalize (tree);
+      matemenu_tree_invoke_monitors (tree);
+    }
+}
+
+static void
+handle_menu_file_changed (MenuMonitor      *monitor,
+			  MenuMonitorEvent  event,
+			  const char       *path,
+                          MateMenuTree        *tree)
+{
+  menu_verbose ("\"%s\" %s, marking tree for recanicalization\n",
+		path,
+		event == MENU_MONITOR_EVENT_CREATED ? "created" :
+		event == MENU_MONITOR_EVENT_CHANGED ? "changed" : "deleted");
+
+  matemenu_tree_force_recanonicalize (tree);
+  matemenu_tree_invoke_monitors (tree);
+}
+
+static void
+handle_menu_file_directory_changed (MenuMonitor      *monitor,
+				    MenuMonitorEvent  event,
+				    const char       *path,
+				    MateMenuTree        *tree)
+{
+  if (!g_str_has_suffix (path, ".menu"))
+    return;
+
+  menu_verbose ("\"%s\" %s, marking tree for recanicalization\n",
+		path,
+		event == MENU_MONITOR_EVENT_CREATED ? "created" :
+		event == MENU_MONITOR_EVENT_CHANGED ? "changed" : "deleted");
+
+  matemenu_tree_force_recanonicalize (tree);
+  matemenu_tree_invoke_monitors (tree);
+}
+
+static void
+matemenu_tree_add_menu_file_monitor (MateMenuTree           *tree,
+				  const char          *path,
+				  MenuFileMonitorType  type)
+{
+  MenuFileMonitor *monitor;
+
+  monitor = g_new0 (MenuFileMonitor, 1);
+
+  monitor->type = type;
+
+  switch (type)
+    {
+    case MENU_FILE_MONITOR_FILE:
+      menu_verbose ("Adding a menu file monitor for \"%s\"\n", path);
+
+      monitor->monitor = menu_get_file_monitor (path);
+      menu_monitor_add_notify (monitor->monitor,
+			       (MenuMonitorNotifyFunc) handle_menu_file_changed,
+			       tree);
+      break;
+
+    case MENU_FILE_MONITOR_NONEXISTENT_FILE:
+      menu_verbose ("Adding a menu file monitor for non-existent \"%s\"\n", path);
+
+      monitor->monitor = menu_get_file_monitor (path);
+      menu_monitor_add_notify (monitor->monitor,
+			       (MenuMonitorNotifyFunc) handle_nonexistent_menu_file_changed,
+			       tree);
+      break;
+
+    case MENU_FILE_MONITOR_DIRECTORY:
+      menu_verbose ("Adding a menu directory monitor for \"%s\"\n", path);
+
+      monitor->monitor = menu_get_directory_monitor (path);
+      menu_monitor_add_notify (monitor->monitor,
+			       (MenuMonitorNotifyFunc) handle_menu_file_directory_changed,
+			       tree);
+      break;
+
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+  tree->menu_file_monitors = g_slist_prepend (tree->menu_file_monitors, monitor);
+}
+
+static void
+remove_menu_file_monitor (MenuFileMonitor *monitor,
+			  MateMenuTree       *tree)
+{
+  switch (monitor->type)
+    {
+    case MENU_FILE_MONITOR_FILE:
+      menu_monitor_remove_notify (monitor->monitor,
+				  (MenuMonitorNotifyFunc) handle_menu_file_changed,
+				  tree);
+      break;
+
+    case MENU_FILE_MONITOR_NONEXISTENT_FILE:
+      menu_monitor_remove_notify (monitor->monitor,
+				  (MenuMonitorNotifyFunc) handle_nonexistent_menu_file_changed,
+				  tree);
+      break;
+
+    case MENU_FILE_MONITOR_DIRECTORY:
+      menu_monitor_remove_notify (monitor->monitor,
+				  (MenuMonitorNotifyFunc) handle_menu_file_directory_changed,
+				  tree);
+      break;
+
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+  menu_monitor_unref (monitor->monitor);
+  monitor->monitor = NULL;
+
+  monitor->type = MENU_FILE_MONITOR_INVALID;
+
+  g_free (monitor);
+}
+
+static void
+matemenu_tree_remove_menu_file_monitors (MateMenuTree *tree)
+{
+  menu_verbose ("Removing all menu file monitors\n");
+
+  g_slist_foreach (tree->menu_file_monitors,
+                   (GFunc) remove_menu_file_monitor,
+                   tree);
+  g_slist_free (tree->menu_file_monitors);
+  tree->menu_file_monitors = NULL;
+}
+
+static MateMenuTree *
+matemenu_tree_lookup_absolute (const char    *absolute,
+			    MateMenuTreeFlags  flags)
+{
+  MateMenuTree  *tree;
+  gboolean    canonical;
+  const char *canonical_path;
+  char       *freeme;
+
+  menu_verbose ("Looking up absolute path in tree cache: \"%s\"\n", absolute);
+
+  if ((tree = matemenu_tree_lookup_from_cache (absolute, flags)) != NULL)
+    return tree;
+
+  canonical = TRUE;
+  canonical_path = freeme = menu_canonicalize_file_name (absolute, FALSE);
+  if (canonical_path == NULL)
+    {
+      menu_verbose ("Failed to canonicalize absolute menu path \"%s\": %s\n",
+                    absolute, g_strerror (errno));
+      canonical = FALSE;
+      canonical_path = absolute;
+    }
+
+  if ((tree = matemenu_tree_lookup_from_cache (canonical_path, flags)) != NULL)
+    return tree;
+
+  tree = matemenu_tree_new (MATEMENU_TREE_ABSOLUTE, canonical_path, canonical, flags);
+
+  g_free (freeme);
+
+  return tree;
+}
+
+static MateMenuTree *
+matemenu_tree_lookup_basename (const char    *basename,
+			    MateMenuTreeFlags  flags)
+{
+  MateMenuTree *tree;
+
+  menu_verbose ("Looking up menu file in tree cache: \"%s\"\n", basename);
+
+  if ((tree = matemenu_tree_lookup_from_cache (basename, flags)) != NULL)
+    return tree;
+
+  return matemenu_tree_new (MATEMENU_TREE_BASENAME, basename, FALSE, flags);
+}
+
+static gboolean
+canonicalize_basename_with_config_dir (MateMenuTree   *tree,
+                                       const char *basename,
+                                       const char *config_dir)
+{
+  char *path;
+
+  path = g_build_filename (config_dir, "menus",  basename,  NULL);
+
+  tree->canonical_path = menu_canonicalize_file_name (path, FALSE);
+  if (tree->canonical_path)
+    {
+      tree->canonical = TRUE;
+      matemenu_tree_add_menu_file_monitor (tree,
+					tree->canonical_path,
+					MENU_FILE_MONITOR_FILE);
+    }
+  else
+    {
+      matemenu_tree_add_menu_file_monitor (tree,
+					path,
+					MENU_FILE_MONITOR_NONEXISTENT_FILE);
+    }
+
+  g_free (path);
+
+  return tree->canonical;
+}
+
+static void
+canonicalize_basename (MateMenuTree  *tree,
+                       const char *basename)
+{
+  if (!canonicalize_basename_with_config_dir (tree,
+                                              basename,
+                                              g_get_user_config_dir ()))
+    {
+      const char * const *system_config_dirs;
+      int                 i;
+
+      system_config_dirs = g_get_system_config_dirs ();
+
+      i = 0;
+      while (system_config_dirs[i] != NULL)
+        {
+          if (canonicalize_basename_with_config_dir (tree,
+                                                     basename,
+                                                     system_config_dirs[i]))
+            break;
+
+          ++i;
+        }
+    }
+}
+
+static gboolean matemenu_tree_canonicalize_path(MateMenuTree* tree)
+{
+	if (tree->canonical)
+		return TRUE;
+
+	g_assert(tree->canonical_path == NULL);
+
+	if (tree->type == MATEMENU_TREE_BASENAME)
+	{
+		matemenu_tree_remove_menu_file_monitors (tree);
+
+		if (strcmp(tree->basename, "mate-applications.menu") == 0 && g_getenv("XDG_MENU_PREFIX"))
+		{
+			char* prefixed_basename;
+			prefixed_basename = g_strdup_printf("%s%s", g_getenv("XDG_MENU_PREFIX"), tree->basename);
+			canonicalize_basename(tree, prefixed_basename);
+			g_free(prefixed_basename);
+		}
+
+		if (!tree->canonical)
+			canonicalize_basename(tree, tree->basename);
+
+		if (tree->canonical)
+			menu_verbose("Successfully looked up menu_file for \"%s\": %s\n", tree->basename, tree->canonical_path);
+		else
+			menu_verbose("Failed to look up menu_file for \"%s\"\n", tree->basename);
+	}
+	else /* if (tree->type == MATEMENU_TREE_ABSOLUTE) */
+	{
+		tree->canonical_path = menu_canonicalize_file_name(tree->absolute_path, FALSE);
+
+		if (tree->canonical_path != NULL)
+		{
+			menu_verbose("Successfully looked up menu_file for \"%s\": %s\n", tree->absolute_path, tree->canonical_path);
+
+			/*
+			* Replace the cache entry with the canonicalized version
+			*/
+			matemenu_tree_remove_from_cache (tree, tree->flags);
+
+			matemenu_tree_remove_menu_file_monitors(tree);
+			matemenu_tree_add_menu_file_monitor(tree, tree->canonical_path, MENU_FILE_MONITOR_FILE);
+
+			tree->canonical = TRUE;
+
+			matemenu_tree_add_to_cache (tree, tree->flags);
+		}
+		else
+		{
+			menu_verbose("Failed to look up menu_file for \"%s\"\n", tree->absolute_path);
+		}
+	}
+
+	return tree->canonical;
+}
+
+static void
+matemenu_tree_force_recanonicalize (MateMenuTree *tree)
+{
+  matemenu_tree_remove_menu_file_monitors (tree);
+
+  if (tree->canonical)
+    {
+      matemenu_tree_force_reload (tree);
+
+      g_free (tree->canonical_path);
+      tree->canonical_path = NULL;
+
+      tree->canonical = FALSE;
+    }
+}
+
+MateMenuTree* matemenu_tree_lookup(const char* menu_file, MateMenuTreeFlags flags)
+{
+  MateMenuTree *retval;
+
+  g_return_val_if_fail (menu_file != NULL, NULL);
+
+  flags &= MATEMENU_TREE_FLAGS_MASK;
+
+  if (g_path_is_absolute (menu_file))
+    retval = matemenu_tree_lookup_absolute (menu_file, flags);
+  else
+    retval = matemenu_tree_lookup_basename (menu_file, flags);
+
+  g_assert (retval != NULL);
+
+  return retval;
+}
+
+static MateMenuTree *
+matemenu_tree_new (MateMenuTreeType   type,
+		const char     *menu_file,
+		gboolean        canonical,
+		MateMenuTreeFlags  flags)
+{
+  MateMenuTree *tree;
+
+  tree = g_new0 (MateMenuTree, 1);
+
+  tree->type     = type;
+  tree->flags    = flags;
+  tree->refcount = 1;
+
+  tree->sort_key = MATEMENU_TREE_SORT_NAME;
+
+  if (tree->type == MATEMENU_TREE_BASENAME)
+    {
+      g_assert (canonical == FALSE);
+      tree->basename = g_strdup (menu_file);
+    }
+  else
+    {
+      tree->canonical     = canonical != FALSE;
+      tree->absolute_path = g_strdup (menu_file);
+
+      if (tree->canonical)
+	{
+	  tree->canonical_path = g_strdup (menu_file);
+	  matemenu_tree_add_menu_file_monitor (tree,
+					    tree->canonical_path,
+					    MENU_FILE_MONITOR_FILE);
+	}
+      else
+	{
+	  matemenu_tree_add_menu_file_monitor (tree,
+					    tree->absolute_path,
+					    MENU_FILE_MONITOR_NONEXISTENT_FILE);
+	}
+    }
+
+  matemenu_tree_add_to_cache (tree, tree->flags);
+
+  return tree;
+}
+
+MateMenuTree *
+matemenu_tree_ref (MateMenuTree *tree)
+{
+  g_return_val_if_fail (tree != NULL, NULL);
+  g_return_val_if_fail (tree->refcount > 0, NULL);
+
+  tree->refcount++;
+
+  return tree;
+}
+
+void
+matemenu_tree_unref (MateMenuTree *tree)
+{
+  g_return_if_fail (tree != NULL);
+  g_return_if_fail (tree->refcount >= 1);
+
+  if (--tree->refcount > 0)
+    return;
+
+  if (tree->dnotify)
+    tree->dnotify (tree->user_data);
+  tree->user_data = NULL;
+  tree->dnotify   = NULL;
+
+  matemenu_tree_remove_from_cache (tree, tree->flags);
+
+  matemenu_tree_force_recanonicalize (tree);
+
+  if (tree->basename != NULL)
+    g_free (tree->basename);
+  tree->basename = NULL;
+
+  if (tree->absolute_path != NULL)
+    g_free (tree->absolute_path);
+  tree->absolute_path = NULL;
+
+  g_slist_foreach (tree->monitors, (GFunc) g_free, NULL);
+  g_slist_free (tree->monitors);
+  tree->monitors = NULL;
+
+  g_free (tree);
+}
+
+void
+matemenu_tree_set_user_data (MateMenuTree       *tree,
+			  gpointer        user_data,
+			  GDestroyNotify  dnotify)
+{
+  g_return_if_fail (tree != NULL);
+
+  if (tree->dnotify != NULL)
+    tree->dnotify (tree->user_data);
+
+  tree->dnotify   = dnotify;
+  tree->user_data = user_data;
+}
+
+gpointer
+matemenu_tree_get_user_data (MateMenuTree *tree)
+{
+  g_return_val_if_fail (tree != NULL, NULL);
+
+  return tree->user_data;
+}
+
+const char *
+matemenu_tree_get_menu_file (MateMenuTree *tree)
+{
+  /* FIXME: this is horribly ugly. But it's done to keep the API. Would be bad
+   * to break the API only for a "const char *" => "char *" change. The other
+   * alternative is to leak the memory, which is bad too. */
+  static char *ugly_result_cache = NULL;
+
+  g_return_val_if_fail (tree != NULL, NULL);
+
+  /* we need to canonicalize the path so we actually find out the real menu
+   * file that is being used -- and take into account XDG_MENU_PREFIX */
+  if (!matemenu_tree_canonicalize_path (tree))
+    return NULL;
+
+  if (ugly_result_cache != NULL)
+    {
+      g_free (ugly_result_cache);
+      ugly_result_cache = NULL;
+    }
+
+  if (tree->type == MATEMENU_TREE_BASENAME)
+    {
+      ugly_result_cache = g_path_get_basename (tree->canonical_path);
+      return ugly_result_cache;
+    }
+  else
+    return tree->absolute_path;
+}
+
+MateMenuTreeDirectory *
+matemenu_tree_get_root_directory (MateMenuTree *tree)
+{
+  g_return_val_if_fail (tree != NULL, NULL);
+
+  if (!tree->root)
+    {
+      matemenu_tree_build_from_layout (tree);
+
+      if (!tree->root)
+        return NULL;
+    }
+
+  return matemenu_tree_item_ref (tree->root);
+}
+
+static MateMenuTreeDirectory *
+find_path (MateMenuTreeDirectory *directory,
+	   const char         *path)
+{
+  const char *name;
+  char       *slash;
+  char       *freeme;
+  GSList     *tmp;
+
+  while (path[0] == G_DIR_SEPARATOR) path++;
+
+  if (path[0] == '\0')
+    return directory;
+
+  freeme = NULL;
+  slash = strchr (path, G_DIR_SEPARATOR);
+  if (slash)
+    {
+      name = freeme = g_strndup (path, slash - path);
+      path = slash + 1;
+    }
+  else
+    {
+      name = path;
+      path = NULL;
+    }
+
+  tmp = directory->contents;
+  while (tmp != NULL)
+    {
+      MateMenuTreeItem *item = tmp->data;
+
+      if (matemenu_tree_item_get_type (item) != MATEMENU_TREE_ITEM_DIRECTORY)
+        {
+          tmp = tmp->next;
+          continue;
+        }
+
+      if (!strcmp (name, MATEMENU_TREE_DIRECTORY (item)->name))
+	{
+	  g_free (freeme);
+
+	  if (path)
+	    return find_path (MATEMENU_TREE_DIRECTORY (item), path);
+	  else
+	    return MATEMENU_TREE_DIRECTORY (item);
+	}
+
+      tmp = tmp->next;
+    }
+
+  g_free (freeme);
+
+  return NULL;
+}
+
+MateMenuTreeDirectory *
+matemenu_tree_get_directory_from_path (MateMenuTree  *tree,
+				    const char *path)
+{
+  MateMenuTreeDirectory *root;
+  MateMenuTreeDirectory *directory;
+
+  g_return_val_if_fail (tree != NULL, NULL);
+  g_return_val_if_fail (path != NULL, NULL);
+
+  if (path[0] != G_DIR_SEPARATOR)
+    return NULL;
+
+  if (!(root = matemenu_tree_get_root_directory (tree)))
+    return NULL;
+
+  directory = find_path (root, path);
+
+  matemenu_tree_item_unref (root);
+
+  return directory ? matemenu_tree_item_ref (directory) : NULL;
+}
+
+MateMenuTreeSortKey
+matemenu_tree_get_sort_key (MateMenuTree *tree)
+{
+  g_return_val_if_fail (tree != NULL, MATEMENU_TREE_SORT_NAME);
+  g_return_val_if_fail (tree->refcount > 0, MATEMENU_TREE_SORT_NAME);
+
+  return tree->sort_key;
+}
+
+void
+matemenu_tree_set_sort_key (MateMenuTree        *tree,
+			 MateMenuTreeSortKey  sort_key)
+{
+  g_return_if_fail (tree != NULL);
+  g_return_if_fail (tree->refcount > 0);
+  g_return_if_fail (sort_key >= MATEMENU_TREE_SORT_FIRST);
+  g_return_if_fail (sort_key <= MATEMENU_TREE_SORT_LAST);
+
+  if (sort_key == tree->sort_key)
+    return;
+
+  tree->sort_key = sort_key;
+  matemenu_tree_force_rebuild (tree);
+}
+
+void
+matemenu_tree_add_monitor (MateMenuTree            *tree,
+                       MateMenuTreeChangedFunc   callback,
+                       gpointer               user_data)
+{
+  MateMenuTreeMonitor *monitor;
+  GSList           *tmp;
+
+  g_return_if_fail (tree != NULL);
+  g_return_if_fail (callback != NULL);
+
+  tmp = tree->monitors;
+  while (tmp != NULL)
+    {
+      monitor = tmp->data;
+
+      if (monitor->callback  == callback &&
+          monitor->user_data == user_data)
+        break;
+
+      tmp = tmp->next;
+    }
+
+  if (tmp == NULL)
+    {
+      monitor = g_new0 (MateMenuTreeMonitor, 1);
+
+      monitor->callback  = callback;
+      monitor->user_data = user_data;
+
+      tree->monitors = g_slist_append (tree->monitors, monitor);
+    }
+}
+
+void
+matemenu_tree_remove_monitor (MateMenuTree            *tree,
+			   MateMenuTreeChangedFunc  callback,
+			   gpointer              user_data)
+{
+  GSList *tmp;
+
+  g_return_if_fail (tree != NULL);
+  g_return_if_fail (callback != NULL);
+
+  tmp = tree->monitors;
+  while (tmp != NULL)
+    {
+      MateMenuTreeMonitor *monitor = tmp->data;
+      GSList          *next = tmp->next;
+
+      if (monitor->callback  == callback &&
+          monitor->user_data == user_data)
+        {
+          tree->monitors = g_slist_delete_link (tree->monitors, tmp);
+          g_free (monitor);
+        }
+
+      tmp = next;
+    }
+}
+
+static void
+matemenu_tree_invoke_monitors (MateMenuTree *tree)
+{
+  GSList *tmp;
+
+  tmp = tree->monitors;
+  while (tmp != NULL)
+    {
+      MateMenuTreeMonitor *monitor = tmp->data;
+      GSList           *next    = tmp->next;
+
+      monitor->callback (tree, monitor->user_data);
+
+      tmp = next;
+    }
+}
+
+MateMenuTreeItemType
+matemenu_tree_item_get_type (MateMenuTreeItem *item)
+{
+  g_return_val_if_fail (item != NULL, 0);
+
+  return item->type;
+}
+
+MateMenuTreeDirectory *
+matemenu_tree_item_get_parent (MateMenuTreeItem *item)
+{
+  g_return_val_if_fail (item != NULL, NULL);
+
+  return item->parent ? matemenu_tree_item_ref (item->parent) : NULL;
+}
+
+static void
+matemenu_tree_item_set_parent (MateMenuTreeItem      *item,
+			    MateMenuTreeDirectory *parent)
+{
+  g_return_if_fail (item != NULL);
+
+  item->parent = parent;
+}
+
+GSList *
+matemenu_tree_directory_get_contents (MateMenuTreeDirectory *directory)
+{
+  GSList *retval;
+  GSList *tmp;
+
+  g_return_val_if_fail (directory != NULL, NULL);
+
+  retval = NULL;
+
+  tmp = directory->contents;
+  while (tmp != NULL)
+    {
+      retval = g_slist_prepend (retval,
+                                matemenu_tree_item_ref (tmp->data));
+
+      tmp = tmp->next;
+    }
+
+  return g_slist_reverse (retval);
+}
+
+const char *
+matemenu_tree_directory_get_name (MateMenuTreeDirectory *directory)
+{
+  g_return_val_if_fail (directory != NULL, NULL);
+
+  if (!directory->directory_entry)
+    return directory->name;
+
+  return desktop_entry_get_name (directory->directory_entry);
+}
+
+const char *
+matemenu_tree_directory_get_comment (MateMenuTreeDirectory *directory)
+{
+  g_return_val_if_fail (directory != NULL, NULL);
+
+  if (!directory->directory_entry)
+    return NULL;
+
+  return desktop_entry_get_comment (directory->directory_entry);
+}
+
+const char* matemenu_tree_directory_get_icon(MateMenuTreeDirectory* directory)
+{
+	g_return_val_if_fail(directory != NULL, NULL);
+
+	if (!directory->directory_entry)
+		return NULL;
+
+	return desktop_entry_get_icon(directory->directory_entry);
+}
+
+const char *
+matemenu_tree_directory_get_desktop_file_path (MateMenuTreeDirectory *directory)
+{
+  g_return_val_if_fail (directory != NULL, NULL);
+
+  if (!directory->directory_entry)
+    return NULL;
+
+  return desktop_entry_get_path (directory->directory_entry);
+}
+
+const char *
+matemenu_tree_directory_get_menu_id (MateMenuTreeDirectory *directory)
+{
+  g_return_val_if_fail (directory != NULL, NULL);
+
+  return directory->name;
+}
+
+static void
+matemenu_tree_directory_set_tree (MateMenuTreeDirectory *directory,
+			       MateMenuTree          *tree)
+{
+  MateMenuTreeDirectoryRoot *root;
+
+  g_assert (directory != NULL);
+  g_assert (directory->is_root);
+
+  root = (MateMenuTreeDirectoryRoot *) directory;
+
+  root->tree = tree;
+}
+
+MateMenuTree *
+matemenu_tree_directory_get_tree (MateMenuTreeDirectory *directory)
+{
+  MateMenuTreeDirectoryRoot *root;
+
+  g_return_val_if_fail (directory != NULL, NULL);
+
+  while (MATEMENU_TREE_ITEM (directory)->parent != NULL)
+    directory = MATEMENU_TREE_DIRECTORY (MATEMENU_TREE_ITEM (directory)->parent);
+
+  if (!directory->is_root)
+    return NULL;
+
+  root = (MateMenuTreeDirectoryRoot *) directory;
+
+  if (root->tree)
+    matemenu_tree_ref (root->tree);
+
+  return root->tree;
+}
+
+gboolean
+matemenu_tree_directory_get_is_nodisplay (MateMenuTreeDirectory *directory)
+{
+  g_return_val_if_fail (directory != NULL, FALSE);
+
+  return directory->is_nodisplay;
+}
+
+static void
+append_directory_path (MateMenuTreeDirectory *directory,
+		       GString            *path)
+{
+
+  if (!directory->item.parent)
+    {
+      g_string_append_c (path, G_DIR_SEPARATOR);
+      return;
+    }
+
+  append_directory_path (directory->item.parent, path);
+
+  g_string_append (path, directory->name);
+  g_string_append_c (path, G_DIR_SEPARATOR);
+}
+
+char *
+matemenu_tree_directory_make_path (MateMenuTreeDirectory *directory,
+				MateMenuTreeEntry     *entry)
+{
+  GString *path;
+
+  g_return_val_if_fail (directory != NULL, NULL);
+
+  path = g_string_new (NULL);
+
+  append_directory_path (directory, path);
+
+  if (entry != NULL)
+    g_string_append (path,
+		     desktop_entry_get_basename (entry->desktop_entry));
+
+  return g_string_free (path, FALSE);
+}
+
+const char *
+matemenu_tree_entry_get_name (MateMenuTreeEntry *entry)
+{
+  g_return_val_if_fail (entry != NULL, NULL);
+
+  return desktop_entry_get_name (entry->desktop_entry);
+}
+
+const char *
+matemenu_tree_entry_get_generic_name (MateMenuTreeEntry *entry)
+{
+  g_return_val_if_fail (entry != NULL, NULL);
+
+  return desktop_entry_get_generic_name (entry->desktop_entry);
+}
+
+const char *
+matemenu_tree_entry_get_display_name (MateMenuTreeEntry *entry)
+{
+  const char *display_name;
+
+  g_return_val_if_fail (entry != NULL, NULL);
+
+  display_name = desktop_entry_get_full_name (entry->desktop_entry);
+  if (!display_name || display_name[0] == '\0')
+    display_name = desktop_entry_get_name (entry->desktop_entry);
+
+  return display_name;
+}
+
+const char *
+matemenu_tree_entry_get_comment (MateMenuTreeEntry *entry)
+{
+  g_return_val_if_fail (entry != NULL, NULL);
+
+  return desktop_entry_get_comment (entry->desktop_entry);
+}
+
+const char* matemenu_tree_entry_get_icon(MateMenuTreeEntry *entry)
+{
+	g_return_val_if_fail (entry != NULL, NULL);
+
+	return desktop_entry_get_icon(entry->desktop_entry);
+}
+
+const char* matemenu_tree_entry_get_exec(MateMenuTreeEntry* entry)
+{
+	g_return_val_if_fail(entry != NULL, NULL);
+
+	return desktop_entry_get_exec(entry->desktop_entry);
+}
+
+gboolean matemenu_tree_entry_get_launch_in_terminal(MateMenuTreeEntry* entry)
+{
+  g_return_val_if_fail(entry != NULL, FALSE);
+
+  return desktop_entry_get_launch_in_terminal(entry->desktop_entry);
+}
+
+const char* matemenu_tree_entry_get_desktop_file_path(MateMenuTreeEntry* entry)
+{
+	g_return_val_if_fail(entry != NULL, NULL);
+
+	return desktop_entry_get_path(entry->desktop_entry);
+}
+
+const char* matemenu_tree_entry_get_desktop_file_id(MateMenuTreeEntry* entry)
+{
+	g_return_val_if_fail(entry != NULL, NULL);
+
+	return entry->desktop_file_id;
+}
+
+gboolean matemenu_tree_entry_get_is_excluded(MateMenuTreeEntry* entry)
+{
+	g_return_val_if_fail(entry != NULL, FALSE);
+
+	return entry->is_excluded;
+}
+
+gboolean matemenu_tree_entry_get_is_nodisplay(MateMenuTreeEntry* entry)
+{
+	g_return_val_if_fail(entry != NULL, FALSE);
+
+	return entry->is_nodisplay;
+}
+
+MateMenuTreeDirectory* matemenu_tree_header_get_directory(MateMenuTreeHeader* header)
+{
+	g_return_val_if_fail (header != NULL, NULL);
+
+	return matemenu_tree_item_ref(header->directory);
+}
+
+MateMenuTreeDirectory* matemenu_tree_alias_get_directory(MateMenuTreeAlias* alias)
+{
+	g_return_val_if_fail (alias != NULL, NULL);
+
+	return matemenu_tree_item_ref(alias->directory);
+}
+
+MateMenuTreeItem *
+matemenu_tree_alias_get_item (MateMenuTreeAlias *alias)
+{
+  g_return_val_if_fail (alias != NULL, NULL);
+
+  return matemenu_tree_item_ref (alias->aliased_item);
+}
+
+static MateMenuTreeDirectory *
+matemenu_tree_directory_new (MateMenuTreeDirectory *parent,
+			  const char         *name,
+			  gboolean            is_root)
+{
+  MateMenuTreeDirectory *retval;
+
+  if (!is_root)
+    {
+      retval = g_new0 (MateMenuTreeDirectory, 1);
+    }
+  else
+    {
+      MateMenuTreeDirectoryRoot *root;
+
+      root = g_new0 (MateMenuTreeDirectoryRoot, 1);
+
+      retval = MATEMENU_TREE_DIRECTORY (root);
+
+      retval->is_root = TRUE;
+    }
+
+
+  retval->item.type     = MATEMENU_TREE_ITEM_DIRECTORY;
+  retval->item.parent   = parent;
+  retval->item.refcount = 1;
+
+  retval->name                = g_strdup (name);
+  retval->directory_entry     = NULL;
+  retval->entries             = NULL;
+  retval->subdirs             = NULL;
+  retval->default_layout_info = NULL;
+  retval->layout_info         = NULL;
+  retval->contents            = NULL;
+  retval->only_unallocated    = FALSE;
+  retval->is_nodisplay        = FALSE;
+  retval->layout_pending_separator = FALSE;
+  retval->preprocessed        = FALSE;
+  retval->will_inline_header  = G_MAXUINT16;
+
+  retval->default_layout_values.mask          = MENU_LAYOUT_VALUES_NONE;
+  retval->default_layout_values.show_empty    = FALSE;
+  retval->default_layout_values.inline_menus  = FALSE;
+  retval->default_layout_values.inline_limit  = 4;
+  retval->default_layout_values.inline_header = FALSE;
+  retval->default_layout_values.inline_alias  = FALSE;
+
+  return retval;
+}
+
+static void
+matemenu_tree_directory_finalize (MateMenuTreeDirectory *directory)
+{
+  g_assert (directory->item.refcount == 0);
+
+  g_slist_foreach (directory->contents,
+		   (GFunc) matemenu_tree_item_unref_and_unset_parent,
+		   NULL);
+  g_slist_free (directory->contents);
+  directory->contents = NULL;
+
+  g_slist_foreach (directory->default_layout_info,
+		   (GFunc) menu_layout_node_unref,
+		   NULL);
+  g_slist_free (directory->default_layout_info);
+  directory->default_layout_info = NULL;
+
+  g_slist_foreach (directory->layout_info,
+		   (GFunc) menu_layout_node_unref,
+		   NULL);
+  g_slist_free (directory->layout_info);
+  directory->layout_info = NULL;
+
+  g_slist_foreach (directory->subdirs,
+		   (GFunc) matemenu_tree_item_unref_and_unset_parent,
+		   NULL);
+  g_slist_free (directory->subdirs);
+  directory->subdirs = NULL;
+
+  g_slist_foreach (directory->entries,
+		   (GFunc) matemenu_tree_item_unref_and_unset_parent,
+		   NULL);
+  g_slist_free (directory->entries);
+  directory->entries = NULL;
+
+  if (directory->directory_entry)
+    desktop_entry_unref (directory->directory_entry);
+  directory->directory_entry = NULL;
+
+  g_free (directory->name);
+  directory->name = NULL;
+}
+
+static MateMenuTreeSeparator *
+matemenu_tree_separator_new (MateMenuTreeDirectory *parent)
+{
+  MateMenuTreeSeparator *retval;
+
+  retval = g_new0 (MateMenuTreeSeparator, 1);
+
+  retval->item.type     = MATEMENU_TREE_ITEM_SEPARATOR;
+  retval->item.parent   = parent;
+  retval->item.refcount = 1;
+
+  return retval;
+}
+
+static MateMenuTreeHeader *
+matemenu_tree_header_new (MateMenuTreeDirectory *parent,
+		       MateMenuTreeDirectory *directory)
+{
+  MateMenuTreeHeader *retval;
+
+  retval = g_new0 (MateMenuTreeHeader, 1);
+
+  retval->item.type     = MATEMENU_TREE_ITEM_HEADER;
+  retval->item.parent   = parent;
+  retval->item.refcount = 1;
+
+  retval->directory = matemenu_tree_item_ref (directory);
+
+  matemenu_tree_item_set_parent (MATEMENU_TREE_ITEM (retval->directory), NULL);
+
+  return retval;
+}
+
+static void
+matemenu_tree_header_finalize (MateMenuTreeHeader *header)
+{
+  g_assert (header->item.refcount == 0);
+
+  if (header->directory != NULL)
+    matemenu_tree_item_unref (header->directory);
+  header->directory = NULL;
+}
+
+static MateMenuTreeAlias *
+matemenu_tree_alias_new (MateMenuTreeDirectory *parent,
+		      MateMenuTreeDirectory *directory,
+		      MateMenuTreeItem      *item)
+{
+  MateMenuTreeAlias *retval;
+
+  retval = g_new0 (MateMenuTreeAlias, 1);
+
+  retval->item.type     = MATEMENU_TREE_ITEM_ALIAS;
+  retval->item.parent   = parent;
+  retval->item.refcount = 1;
+
+  retval->directory    = matemenu_tree_item_ref (directory);
+  if (item->type != MATEMENU_TREE_ITEM_ALIAS)
+    retval->aliased_item = matemenu_tree_item_ref (item);
+  else
+    retval->aliased_item = matemenu_tree_item_ref (matemenu_tree_alias_get_item (MATEMENU_TREE_ALIAS (item)));
+
+  matemenu_tree_item_set_parent (MATEMENU_TREE_ITEM (retval->directory), NULL);
+  matemenu_tree_item_set_parent (retval->aliased_item, NULL);
+
+  return retval;
+}
+
+static void
+matemenu_tree_alias_finalize (MateMenuTreeAlias *alias)
+{
+  g_assert (alias->item.refcount == 0);
+
+  if (alias->directory != NULL)
+    matemenu_tree_item_unref (alias->directory);
+  alias->directory = NULL;
+
+  if (alias->aliased_item != NULL)
+    matemenu_tree_item_unref (alias->aliased_item);
+  alias->aliased_item = NULL;
+}
+
+static MateMenuTreeEntry *
+matemenu_tree_entry_new (MateMenuTreeDirectory *parent,
+		      DesktopEntry       *desktop_entry,
+		      const char         *desktop_file_id,
+		      gboolean            is_excluded,
+                      gboolean            is_nodisplay)
+{
+  MateMenuTreeEntry *retval;
+
+  retval = g_new0 (MateMenuTreeEntry, 1);
+
+  retval->item.type     = MATEMENU_TREE_ITEM_ENTRY;
+  retval->item.parent   = parent;
+  retval->item.refcount = 1;
+
+  retval->desktop_entry   = desktop_entry_ref (desktop_entry);
+  retval->desktop_file_id = g_strdup (desktop_file_id);
+  retval->is_excluded     = is_excluded != FALSE;
+  retval->is_nodisplay    = is_nodisplay != FALSE;
+
+  return retval;
+}
+
+static void
+matemenu_tree_entry_finalize (MateMenuTreeEntry *entry)
+{
+  g_assert (entry->item.refcount == 0);
+
+  g_free (entry->desktop_file_id);
+  entry->desktop_file_id = NULL;
+
+  if (entry->desktop_entry)
+    desktop_entry_unref (entry->desktop_entry);
+  entry->desktop_entry = NULL;
+}
+
+static int
+matemenu_tree_entry_compare_by_id (MateMenuTreeItem *a,
+				MateMenuTreeItem *b)
+{
+  if (a->type == MATEMENU_TREE_ITEM_ALIAS)
+    a = MATEMENU_TREE_ALIAS (a)->aliased_item;
+
+  if (b->type == MATEMENU_TREE_ITEM_ALIAS)
+    b = MATEMENU_TREE_ALIAS (b)->aliased_item;
+
+  return strcmp (MATEMENU_TREE_ENTRY (a)->desktop_file_id,
+                 MATEMENU_TREE_ENTRY (b)->desktop_file_id);
+}
+
+gpointer matemenu_tree_item_ref(gpointer itemp)
+{
+	MateMenuTreeItem* item = (MateMenuTreeItem*) itemp;
+
+	g_return_val_if_fail(item != NULL, NULL);
+	g_return_val_if_fail(item->refcount > 0, NULL);
+
+	item->refcount++;
+
+	return item;
+}
+
+void
+matemenu_tree_item_unref (gpointer itemp)
+{
+  MateMenuTreeItem *item;
+
+  item = (MateMenuTreeItem *) itemp;
+
+  g_return_if_fail (item != NULL);
+  g_return_if_fail (item->refcount > 0);
+
+  if (--item->refcount == 0)
+    {
+      switch (item->type)
+	{
+	case MATEMENU_TREE_ITEM_DIRECTORY:
+	  matemenu_tree_directory_finalize (MATEMENU_TREE_DIRECTORY (item));
+	  break;
+
+	case MATEMENU_TREE_ITEM_ENTRY:
+	  matemenu_tree_entry_finalize (MATEMENU_TREE_ENTRY (item));
+	  break;
+
+	case MATEMENU_TREE_ITEM_SEPARATOR:
+	  break;
+
+	case MATEMENU_TREE_ITEM_HEADER:
+	  matemenu_tree_header_finalize (MATEMENU_TREE_HEADER (item));
+	  break;
+
+	case MATEMENU_TREE_ITEM_ALIAS:
+	  matemenu_tree_alias_finalize (MATEMENU_TREE_ALIAS (item));
+	  break;
+
+	default:
+	  g_assert_not_reached ();
+	  break;
+	}
+
+      if (item->dnotify)
+	item->dnotify (item->user_data);
+      item->user_data = NULL;
+      item->dnotify   = NULL;
+
+      item->parent = NULL;
+
+      g_free (item);
+    }
+}
+
+static void
+matemenu_tree_item_unref_and_unset_parent (gpointer itemp)
+{
+  MateMenuTreeItem *item;
+
+  item = (MateMenuTreeItem *) itemp;
+
+  g_return_if_fail (item != NULL);
+
+  matemenu_tree_item_set_parent (item, NULL);
+  matemenu_tree_item_unref (item);
+}
+
+void
+matemenu_tree_item_set_user_data (MateMenuTreeItem  *item,
+			       gpointer        user_data,
+			       GDestroyNotify  dnotify)
+{
+  g_return_if_fail (item != NULL);
+
+  if (item->dnotify != NULL)
+    item->dnotify (item->user_data);
+
+  item->dnotify   = dnotify;
+  item->user_data = user_data;
+}
+
+gpointer
+matemenu_tree_item_get_user_data (MateMenuTreeItem *item)
+{
+  g_return_val_if_fail (item != NULL, NULL);
+
+  return item->user_data;
+}
+
+static inline const char *
+matemenu_tree_item_compare_get_name_helper (MateMenuTreeItem    *item,
+					 MateMenuTreeSortKey  sort_key)
+{
+  const char *name;
+
+  name = NULL;
+
+  switch (item->type)
+    {
+    case MATEMENU_TREE_ITEM_DIRECTORY:
+      if (MATEMENU_TREE_DIRECTORY (item)->directory_entry)
+	name = desktop_entry_get_name (MATEMENU_TREE_DIRECTORY (item)->directory_entry);
+      else
+	name = MATEMENU_TREE_DIRECTORY (item)->name;
+      break;
+
+    case MATEMENU_TREE_ITEM_ENTRY:
+      switch (sort_key)
+	{
+	case MATEMENU_TREE_SORT_NAME:
+	  name = desktop_entry_get_name (MATEMENU_TREE_ENTRY (item)->desktop_entry);
+	  break;
+	case MATEMENU_TREE_SORT_DISPLAY_NAME:
+	  name = matemenu_tree_entry_get_display_name (MATEMENU_TREE_ENTRY (item));
+	  break;
+	default:
+	  g_assert_not_reached ();
+	  break;
+	}
+      break;
+
+    case MATEMENU_TREE_ITEM_ALIAS:
+      {
+        MateMenuTreeItem *dir;
+        dir = MATEMENU_TREE_ITEM (MATEMENU_TREE_ALIAS (item)->directory);
+        name = matemenu_tree_item_compare_get_name_helper (dir, sort_key);
+      }
+      break;
+
+    case MATEMENU_TREE_ITEM_SEPARATOR:
+    case MATEMENU_TREE_ITEM_HEADER:
+    default:
+      g_assert_not_reached ();
+      break;
+    }
+
+  return name;
+}
+
+static int
+matemenu_tree_item_compare (MateMenuTreeItem *a,
+			 MateMenuTreeItem *b,
+			 gpointer       sort_key_p)
+{
+  const char       *name_a;
+  const char       *name_b;
+  MateMenuTreeSortKey  sort_key;
+
+  sort_key = GPOINTER_TO_INT (sort_key_p);
+
+  name_a = matemenu_tree_item_compare_get_name_helper (a, sort_key);
+  name_b = matemenu_tree_item_compare_get_name_helper (b, sort_key);
+
+  return g_utf8_collate (name_a, name_b);
+}
+
+static MenuLayoutNode *
+find_menu_child (MenuLayoutNode *layout)
+{
+  MenuLayoutNode *child;
+
+  child = menu_layout_node_get_children (layout);
+  while (child && menu_layout_node_get_type (child) != MENU_LAYOUT_NODE_MENU)
+    child = menu_layout_node_get_next (child);
+
+  return child;
+}
+
+static void
+merge_resolved_children (MateMenuTree      *tree,
+			 GHashTable     *loaded_menu_files,
+                         MenuLayoutNode *where,
+                         MenuLayoutNode *from)
+{
+  MenuLayoutNode *insert_after;
+  MenuLayoutNode *menu_child;
+  MenuLayoutNode *from_child;
+
+  matemenu_tree_resolve_files (tree, loaded_menu_files, from);
+
+  insert_after = where;
+  g_assert (menu_layout_node_get_type (insert_after) != MENU_LAYOUT_NODE_ROOT);
+  g_assert (menu_layout_node_get_parent (insert_after) != NULL);
+
+  /* skip root node */
+  menu_child = find_menu_child (from);
+  g_assert (menu_child != NULL);
+  g_assert (menu_layout_node_get_type (menu_child) == MENU_LAYOUT_NODE_MENU);
+
+  /* merge children of toplevel <Menu> */
+  from_child = menu_layout_node_get_children (menu_child);
+  while (from_child != NULL)
+    {
+      MenuLayoutNode *next;
+
+      next = menu_layout_node_get_next (from_child);
+
+      menu_verbose ("Merging ");
+      menu_debug_print_layout (from_child, FALSE);
+      menu_verbose (" after ");
+      menu_debug_print_layout (insert_after, FALSE);
+
+      switch (menu_layout_node_get_type (from_child))
+        {
+        case MENU_LAYOUT_NODE_NAME:
+          menu_layout_node_unlink (from_child); /* delete this */
+          break;
+
+        default:
+          menu_layout_node_steal (from_child);
+          menu_layout_node_insert_after (insert_after, from_child);
+          menu_layout_node_unref (from_child);
+
+          insert_after = from_child;
+          break;
+        }
+
+      from_child = next;
+    }
+}
+
+static gboolean
+load_merge_file (MateMenuTree      *tree,
+		 GHashTable     *loaded_menu_files,
+                 const char     *filename,
+                 gboolean        is_canonical,
+		 gboolean        add_monitor,
+                 MenuLayoutNode *where)
+{
+  MenuLayoutNode *to_merge;
+  const char     *canonical;
+  char           *freeme;
+  gboolean        retval;
+
+  freeme = NULL;
+  retval = FALSE;
+
+  if (!is_canonical)
+    {
+      canonical = freeme = menu_canonicalize_file_name (filename, FALSE);
+      if (canonical == NULL)
+        {
+	  if (add_monitor)
+	    matemenu_tree_add_menu_file_monitor (tree,
+					     filename,
+					     MENU_FILE_MONITOR_NONEXISTENT_FILE);
+
+          menu_verbose ("Failed to canonicalize merge file path \"%s\": %s\n",
+                        filename, g_strerror (errno));
+	  goto out;
+        }
+    }
+  else
+    {
+      canonical = filename;
+    }
+
+  if (g_hash_table_lookup (loaded_menu_files, canonical) != NULL)
+    {
+      g_warning ("Not loading \"%s\": recursive loop detected in .menu files",
+		 canonical);
+      retval = TRUE;
+      goto out;
+    }
+
+  menu_verbose ("Merging file \"%s\"\n", canonical);
+
+  to_merge = menu_layout_load (canonical, NULL, NULL);
+  if (to_merge == NULL)
+    {
+      menu_verbose ("No menu for file \"%s\" found when merging\n",
+                    canonical);
+      goto out;
+    }
+
+  retval = TRUE;
+
+  g_hash_table_insert (loaded_menu_files, (char *) canonical, GUINT_TO_POINTER (TRUE));
+
+  if (add_monitor)
+    matemenu_tree_add_menu_file_monitor (tree,
+				      canonical,
+				      MENU_FILE_MONITOR_FILE);
+
+  merge_resolved_children (tree, loaded_menu_files, where, to_merge);
+
+  g_hash_table_remove (loaded_menu_files, canonical);
+
+  menu_layout_node_unref (to_merge);
+
+ out:
+  if (freeme)
+    g_free (freeme);
+
+  return retval;
+}
+
+static gboolean
+load_merge_file_with_config_dir (MateMenuTree      *tree,
+				 GHashTable     *loaded_menu_files,
+				 const char     *menu_file,
+				 const char     *config_dir,
+				 MenuLayoutNode *where)
+{
+  char     *merge_file;
+  gboolean  loaded;
+
+  loaded = FALSE;
+
+  merge_file = g_build_filename (config_dir, "menus", menu_file, NULL);
+
+  if (load_merge_file (tree, loaded_menu_files, merge_file, FALSE, TRUE, where))
+    loaded = TRUE;
+
+  g_free (merge_file);
+
+  return loaded;
+}
+
+static gboolean
+compare_basedir_to_config_dir (const char *canonical_basedir,
+			       const char *config_dir)
+{
+  char     *dirname;
+  char     *canonical_menus_dir;
+  gboolean  retval;
+
+  menu_verbose ("Checking to see if basedir '%s' is in '%s'\n",
+		canonical_basedir, config_dir);
+
+  dirname = g_build_filename (config_dir, "menus", NULL);
+
+  retval = FALSE;
+
+  canonical_menus_dir = menu_canonicalize_file_name (dirname, FALSE);
+  if (canonical_menus_dir != NULL &&
+      strcmp (canonical_basedir, canonical_menus_dir) == 0)
+    {
+      retval = TRUE;
+    }
+
+  g_free (canonical_menus_dir);
+  g_free (dirname);
+
+  return retval;
+}
+
+static gboolean
+load_parent_merge_file_from_basename (MateMenuTree      *tree,
+                                      GHashTable     *loaded_menu_files,
+			              MenuLayoutNode *layout,
+                                      const char     *menu_file,
+                                      const char     *canonical_basedir)
+{
+  gboolean            found_basedir;
+  const char * const *system_config_dirs;
+  int                 i;
+
+  /* We're not interested in menu files that are in directories which are not a
+   * parent of the base directory of this menu file */
+  found_basedir = compare_basedir_to_config_dir (canonical_basedir,
+						 g_get_user_config_dir ());
+
+  system_config_dirs = g_get_system_config_dirs ();
+
+  i = 0;
+  while (system_config_dirs[i] != NULL)
+    {
+      if (!found_basedir)
+	{
+	  found_basedir = compare_basedir_to_config_dir (canonical_basedir,
+							 system_config_dirs[i]);
+	}
+      else
+	{
+	  menu_verbose ("Looking for parent menu file '%s' in '%s'\n",
+			menu_file, system_config_dirs[i]);
+
+	  if (load_merge_file_with_config_dir (tree,
+					       loaded_menu_files,
+					       menu_file,
+					       system_config_dirs[i],
+					       layout))
+	    {
+	      break;
+	    }
+	}
+
+      ++i;
+    }
+
+  return system_config_dirs[i] != NULL;
+}
+
+static gboolean load_parent_merge_file(MateMenuTree* tree, GHashTable* loaded_menu_files, MenuLayoutNode* layout)
+{
+	MenuLayoutNode* root;
+	const char* basedir;
+	const char* menu_name;
+	char* canonical_basedir;
+	char* menu_file;
+	gboolean found;
+
+	root = menu_layout_node_get_root(layout);
+
+	basedir   = menu_layout_node_root_get_basedir(root);
+	menu_name = menu_layout_node_root_get_name(root);
+
+	canonical_basedir = menu_canonicalize_file_name(basedir, FALSE);
+
+	if (canonical_basedir == NULL)
+	{
+		menu_verbose("Menu basedir '%s' no longer exists, not merging parent\n", basedir);
+		return FALSE;
+	}
+
+	found = FALSE;
+	menu_file = g_strconcat(menu_name, ".menu", NULL);
+
+	if (strcmp(menu_file, "mate-applications.menu") == 0 && g_getenv("XDG_MENU_PREFIX"))
+	{
+		char* prefixed_basename;
+		prefixed_basename = g_strdup_printf("%s%s", g_getenv("XDG_MENU_PREFIX"), menu_file);
+		found = load_parent_merge_file_from_basename(tree, loaded_menu_files, layout, prefixed_basename, canonical_basedir);
+		g_free(prefixed_basename);
+	}
+
+	if (!found)
+	{
+		found = load_parent_merge_file_from_basename(tree, loaded_menu_files, layout, menu_file, canonical_basedir);
+	}
+
+	g_free(menu_file);
+	g_free(canonical_basedir);
+
+	return found;
+}
+
+static void
+load_merge_dir (MateMenuTree      *tree,
+		GHashTable     *loaded_menu_files,
+                const char     *dirname,
+                MenuLayoutNode *where)
+{
+  GDir       *dir;
+  const char *menu_file;
+
+  menu_verbose ("Loading merge dir \"%s\"\n", dirname);
+
+  matemenu_tree_add_menu_file_monitor (tree,
+				    dirname,
+				    MENU_FILE_MONITOR_DIRECTORY);
+
+  if ((dir = g_dir_open (dirname, 0, NULL)) == NULL)
+    return;
+
+  while ((menu_file = g_dir_read_name (dir)))
+    {
+      if (g_str_has_suffix (menu_file, ".menu"))
+        {
+          char *full_path;
+
+          full_path = g_build_filename (dirname, menu_file, NULL);
+
+          load_merge_file (tree, loaded_menu_files, full_path, TRUE, FALSE, where);
+
+          g_free (full_path);
+        }
+    }
+
+  g_dir_close (dir);
+}
+
+static void
+load_merge_dir_with_config_dir (MateMenuTree      *tree,
+				GHashTable     *loaded_menu_files,
+                                const char     *config_dir,
+                                const char     *dirname,
+                                MenuLayoutNode *where)
+{
+  char *path;
+
+  path = g_build_filename (config_dir, "menus", dirname, NULL);
+
+  load_merge_dir (tree, loaded_menu_files, path, where);
+
+  g_free (path);
+}
+
+static void
+resolve_merge_file (MateMenuTree      *tree,
+		    GHashTable     *loaded_menu_files,
+                    MenuLayoutNode *layout)
+{
+  char *filename;
+
+  if (menu_layout_node_merge_file_get_type (layout) == MENU_MERGE_FILE_TYPE_PARENT)
+    {
+      if (load_parent_merge_file (tree, loaded_menu_files, layout))
+        return;
+    }
+
+  filename = menu_layout_node_get_content_as_path (layout);
+  if (filename == NULL)
+    {
+      menu_verbose ("didn't get node content as a path, not merging file\n");
+    }
+  else
+    {
+      load_merge_file (tree, loaded_menu_files, filename, FALSE, TRUE, layout);
+
+      g_free (filename);
+    }
+
+  /* remove the now-replaced node */
+  menu_layout_node_unlink (layout);
+}
+
+static void
+resolve_merge_dir (MateMenuTree      *tree,
+		   GHashTable     *loaded_menu_files,
+                   MenuLayoutNode *layout)
+{
+  char *path;
+
+  path = menu_layout_node_get_content_as_path (layout);
+  if (path == NULL)
+    {
+      menu_verbose ("didn't get layout node content as a path, not merging dir\n");
+    }
+  else
+    {
+      load_merge_dir (tree, loaded_menu_files, path, layout);
+
+      g_free (path);
+    }
+
+  /* remove the now-replaced node */
+  menu_layout_node_unlink (layout);
+}
+
+static MenuLayoutNode *
+add_app_dir (MateMenuTree      *tree,
+             MenuLayoutNode *before,
+             const char     *data_dir)
+{
+  MenuLayoutNode *tmp;
+  char           *dirname;
+
+  tmp = menu_layout_node_new (MENU_LAYOUT_NODE_APP_DIR);
+  dirname = g_build_filename (data_dir, "applications", NULL);
+  menu_layout_node_set_content (tmp, dirname);
+  menu_layout_node_insert_before (before, tmp);
+  menu_layout_node_unref (before);
+
+  menu_verbose ("Adding <AppDir>%s</AppDir> in <DefaultAppDirs/>\n",
+                dirname);
+
+  g_free (dirname);
+
+  return tmp;
+}
+
+static void
+resolve_default_app_dirs (MateMenuTree      *tree,
+                          MenuLayoutNode *layout)
+{
+  MenuLayoutNode     *before;
+  const char * const *system_data_dirs;
+  int                 i;
+
+  system_data_dirs = g_get_system_data_dirs ();
+
+  before = add_app_dir (tree,
+			menu_layout_node_ref (layout),
+			g_get_user_data_dir ());
+
+  i = 0;
+  while (system_data_dirs[i] != NULL)
+    {
+      before = add_app_dir (tree, before, system_data_dirs[i]);
+
+      ++i;
+    }
+
+  menu_layout_node_unref (before);
+
+  /* remove the now-replaced node */
+  menu_layout_node_unlink (layout);
+}
+
+static MenuLayoutNode* add_directory_dir(MateMenuTree* tree, MenuLayoutNode* before, const char* data_dir)
+{
+	MenuLayoutNode* tmp;
+	char* dirname;
+
+	tmp = menu_layout_node_new(MENU_LAYOUT_NODE_DIRECTORY_DIR);
+	dirname = g_build_filename(data_dir, "desktop-directories", NULL);
+	menu_layout_node_set_content(tmp, dirname);
+	menu_layout_node_insert_before(before, tmp);
+	menu_layout_node_unref(before);
+
+	menu_verbose("Adding <DirectoryDir>%s</DirectoryDir> in <DefaultDirectoryDirs/>\n", dirname);
+
+	g_free(dirname);
+
+	return tmp;
+}
+
+static void
+resolve_default_directory_dirs (MateMenuTree      *tree,
+                                MenuLayoutNode *layout)
+{
+  MenuLayoutNode     *before;
+  const char * const *system_data_dirs;
+  int                 i;
+
+  system_data_dirs = g_get_system_data_dirs ();
+
+  before = add_directory_dir (tree,
+			      menu_layout_node_ref (layout),
+			      g_get_user_data_dir ());
+
+  i = 0;
+  while (system_data_dirs[i] != NULL)
+    {
+      before = add_directory_dir (tree, before, system_data_dirs[i]);
+
+      ++i;
+    }
+
+  menu_layout_node_unref (before);
+
+  /* remove the now-replaced node */
+  menu_layout_node_unlink (layout);
+}
+
+static void
+resolve_default_merge_dirs (MateMenuTree      *tree,
+			    GHashTable     *loaded_menu_files,
+                            MenuLayoutNode *layout)
+{
+  MenuLayoutNode     *root;
+  const char         *menu_name;
+  char               *merge_name;
+  const char * const *system_config_dirs;
+  int                 i;
+
+  root = menu_layout_node_get_root (layout);
+  menu_name = menu_layout_node_root_get_name (root);
+
+  merge_name = g_strconcat (menu_name, "-merged", NULL);
+
+  system_config_dirs = g_get_system_config_dirs ();
+
+  /* Merge in reverse order */
+  i = 0;
+  while (system_config_dirs[i] != NULL) i++;
+  while (i > 0)
+    {
+      i--;
+      load_merge_dir_with_config_dir (tree,
+				      loaded_menu_files,
+                                      system_config_dirs[i],
+                                      merge_name,
+                                      layout);
+    }
+
+  load_merge_dir_with_config_dir (tree,
+				  loaded_menu_files,
+                                  g_get_user_config_dir (),
+                                  merge_name,
+                                  layout);
+
+  g_free (merge_name);
+
+  /* remove the now-replaced node */
+  menu_layout_node_unlink (layout);
+}
+
+static void
+add_filename_include (const char     *desktop_file_id,
+                      DesktopEntry   *entry,
+                      MenuLayoutNode *include)
+{
+  if (!desktop_entry_has_categories (entry))
+    {
+      MenuLayoutNode *node;
+
+      node = menu_layout_node_new (MENU_LAYOUT_NODE_FILENAME);
+      menu_layout_node_set_content (node, desktop_file_id);
+
+      menu_layout_node_append_child (include, node);
+      menu_layout_node_unref (node);
+    }
+}
+
+static void
+is_dot_directory (const char   *basename,
+		  DesktopEntry *entry,
+		  gboolean     *has_dot_directory)
+{
+  if (!strcmp (basename, ".directory"))
+    *has_dot_directory = TRUE;
+}
+
+static gboolean
+add_menu_for_legacy_dir (MenuLayoutNode *parent,
+                         const char     *legacy_dir,
+                	 const char     *relative_path,
+                         const char     *legacy_prefix,
+                         const char     *menu_name)
+{
+  EntryDirectory  *ed;
+  DesktopEntrySet *desktop_entries;
+  DesktopEntrySet *directory_entries;
+  GSList          *subdirs;
+  gboolean         menu_added;
+  gboolean         has_dot_directory;
+
+  ed = entry_directory_new_legacy (DESKTOP_ENTRY_INVALID, legacy_dir, legacy_prefix);
+  if (!ed)
+    return FALSE;
+
+  subdirs = NULL;
+  desktop_entries   = desktop_entry_set_new ();
+  directory_entries = desktop_entry_set_new ();
+
+  entry_directory_get_flat_contents (ed,
+                                     desktop_entries,
+                                     directory_entries,
+                                     &subdirs);
+  entry_directory_unref (ed);
+
+  has_dot_directory = FALSE;
+  desktop_entry_set_foreach (directory_entries,
+			     (DesktopEntrySetForeachFunc) is_dot_directory,
+			     &has_dot_directory);
+  desktop_entry_set_unref (directory_entries);
+
+  menu_added = FALSE;
+  if (desktop_entry_set_get_count (desktop_entries) > 0 || subdirs)
+    {
+      MenuLayoutNode *menu;
+      MenuLayoutNode *node;
+      GString        *subdir_path;
+      GString        *subdir_relative;
+      GSList         *tmp;
+      int             legacy_dir_len;
+      int             relative_path_len;
+
+      menu = menu_layout_node_new (MENU_LAYOUT_NODE_MENU);
+      menu_layout_node_append_child (parent, menu);
+
+      menu_added = TRUE;
+
+      g_assert (menu_name != NULL);
+
+      node = menu_layout_node_new (MENU_LAYOUT_NODE_NAME);
+      menu_layout_node_set_content (node, menu_name);
+      menu_layout_node_append_child (menu, node);
+      menu_layout_node_unref (node);
+
+      if (has_dot_directory)
+	{
+	  node = menu_layout_node_new (MENU_LAYOUT_NODE_DIRECTORY);
+	  if (relative_path != NULL)
+	    {
+	      char *directory_entry_path;
+
+	      directory_entry_path = g_strdup_printf ("%s/.directory", relative_path);
+	      menu_layout_node_set_content (node, directory_entry_path);
+	      g_free (directory_entry_path);
+	    }
+	  else
+	    {
+	      menu_layout_node_set_content (node, ".directory");
+	    }
+	  menu_layout_node_append_child (menu, node);
+	  menu_layout_node_unref (node);
+	}
+
+      if (desktop_entry_set_get_count (desktop_entries) > 0)
+	{
+	  MenuLayoutNode *include;
+
+	  include = menu_layout_node_new (MENU_LAYOUT_NODE_INCLUDE);
+	  menu_layout_node_append_child (menu, include);
+
+	  desktop_entry_set_foreach (desktop_entries,
+				     (DesktopEntrySetForeachFunc) add_filename_include,
+				     include);
+
+	  menu_layout_node_unref (include);
+	}
+
+      subdir_path = g_string_new (legacy_dir);
+      legacy_dir_len = strlen (legacy_dir);
+
+      subdir_relative = g_string_new (relative_path);
+      relative_path_len = relative_path ? strlen (relative_path) : 0;
+
+      tmp = subdirs;
+      while (tmp != NULL)
+        {
+          const char *subdir = tmp->data;
+
+          g_string_append_c (subdir_path, G_DIR_SEPARATOR);
+          g_string_append (subdir_path, subdir);
+
+	  if (relative_path_len)
+	    {
+	      g_string_append_c (subdir_relative, G_DIR_SEPARATOR);
+	    }
+          g_string_append (subdir_relative, subdir);
+
+          add_menu_for_legacy_dir (menu,
+                                   subdir_path->str,
+				   subdir_relative->str,
+                                   legacy_prefix,
+                                   subdir);
+
+          g_string_truncate (subdir_relative, relative_path_len);
+          g_string_truncate (subdir_path, legacy_dir_len);
+
+          tmp = tmp->next;
+        }
+
+      g_string_free (subdir_path, TRUE);
+      g_string_free (subdir_relative, TRUE);
+
+      menu_layout_node_unref (menu);
+    }
+
+  desktop_entry_set_unref (desktop_entries);
+
+  g_slist_foreach (subdirs, (GFunc) g_free, NULL);
+  g_slist_free (subdirs);
+
+  return menu_added;
+}
+
+static void
+resolve_legacy_dir (MateMenuTree      *tree,
+		    GHashTable     *loaded_menu_files,
+                    MenuLayoutNode *legacy)
+{
+  MenuLayoutNode *to_merge;
+  MenuLayoutNode *menu;
+
+  to_merge = menu_layout_node_new (MENU_LAYOUT_NODE_ROOT);
+
+  menu = menu_layout_node_get_parent (legacy);
+  g_assert (menu_layout_node_get_type (menu) == MENU_LAYOUT_NODE_MENU);
+
+  if (add_menu_for_legacy_dir (to_merge,
+                               menu_layout_node_get_content (legacy),
+			       NULL,
+                               menu_layout_node_legacy_dir_get_prefix (legacy),
+                               menu_layout_node_menu_get_name (menu)))
+    {
+      merge_resolved_children (tree, loaded_menu_files, legacy, to_merge);
+    }
+
+  menu_layout_node_unref (to_merge);
+}
+
+static MenuLayoutNode *
+add_legacy_dir (MateMenuTree      *tree,
+		GHashTable     *loaded_menu_files,
+                MenuLayoutNode *before,
+                const char     *data_dir)
+{
+  MenuLayoutNode *legacy;
+  char           *dirname;
+
+  dirname = g_build_filename (data_dir, "applnk", NULL);
+
+  legacy = menu_layout_node_new (MENU_LAYOUT_NODE_LEGACY_DIR);
+  menu_layout_node_set_content (legacy, dirname);
+  menu_layout_node_legacy_dir_set_prefix (legacy, "kde");
+  menu_layout_node_insert_before (before, legacy);
+  menu_layout_node_unref (before);
+
+  menu_verbose ("Adding <LegacyDir>%s</LegacyDir> in <KDELegacyDirs/>\n",
+                dirname);
+
+  resolve_legacy_dir (tree, loaded_menu_files, legacy);
+
+  g_free (dirname);
+
+  return legacy;
+}
+
+static void
+resolve_kde_legacy_dirs (MateMenuTree      *tree,
+			 GHashTable     *loaded_menu_files,
+                         MenuLayoutNode *layout)
+{
+  MenuLayoutNode     *before;
+  const char * const *system_data_dirs;
+  int                 i;
+
+  system_data_dirs = g_get_system_data_dirs ();
+
+  before = add_legacy_dir (tree,
+			   loaded_menu_files,
+			   menu_layout_node_ref (layout),
+			   g_get_user_data_dir ());
+
+  i = 0;
+  while (system_data_dirs[i] != NULL)
+    {
+      before = add_legacy_dir (tree, loaded_menu_files, before, system_data_dirs[i]);
+
+      ++i;
+    }
+
+  menu_layout_node_unref (before);
+
+  /* remove the now-replaced node */
+  menu_layout_node_unlink (layout);
+}
+
+static void
+matemenu_tree_resolve_files (MateMenuTree      *tree,
+			  GHashTable     *loaded_menu_files,
+			  MenuLayoutNode *layout)
+{
+  MenuLayoutNode *child;
+
+  menu_verbose ("Resolving files in: ");
+  menu_debug_print_layout (layout, TRUE);
+
+  switch (menu_layout_node_get_type (layout))
+    {
+    case MENU_LAYOUT_NODE_MERGE_FILE:
+      resolve_merge_file (tree, loaded_menu_files, layout);
+      break;
+
+    case MENU_LAYOUT_NODE_MERGE_DIR:
+      resolve_merge_dir (tree, loaded_menu_files, layout);
+      break;
+
+    case MENU_LAYOUT_NODE_DEFAULT_APP_DIRS:
+      resolve_default_app_dirs (tree, layout);
+      break;
+
+    case MENU_LAYOUT_NODE_DEFAULT_DIRECTORY_DIRS:
+      resolve_default_directory_dirs (tree, layout);
+      break;
+
+    case MENU_LAYOUT_NODE_DEFAULT_MERGE_DIRS:
+      resolve_default_merge_dirs (tree, loaded_menu_files, layout);
+      break;
+
+    case MENU_LAYOUT_NODE_LEGACY_DIR:
+      resolve_legacy_dir (tree, loaded_menu_files, layout);
+      break;
+
+    case MENU_LAYOUT_NODE_KDE_LEGACY_DIRS:
+      resolve_kde_legacy_dirs (tree, loaded_menu_files, layout);
+      break;
+
+    case MENU_LAYOUT_NODE_PASSTHROUGH:
+      /* Just get rid of these, we don't need the memory usage */
+      menu_layout_node_unlink (layout);
+      break;
+
+    default:
+      /* Recurse */
+      child = menu_layout_node_get_children (layout);
+      while (child != NULL)
+        {
+          MenuLayoutNode *next = menu_layout_node_get_next (child);
+
+          matemenu_tree_resolve_files (tree, loaded_menu_files, child);
+
+          child = next;
+        }
+      break;
+    }
+}
+
+static void
+move_children (MenuLayoutNode *from,
+               MenuLayoutNode *to)
+{
+  MenuLayoutNode *from_child;
+  MenuLayoutNode *insert_before;
+
+  insert_before = menu_layout_node_get_children (to);
+  from_child    = menu_layout_node_get_children (from);
+
+  while (from_child != NULL)
+    {
+      MenuLayoutNode *next;
+
+      next = menu_layout_node_get_next (from_child);
+
+      menu_layout_node_steal (from_child);
+
+      if (menu_layout_node_get_type (from_child) == MENU_LAYOUT_NODE_NAME)
+        {
+          ; /* just drop the Name in the old <Menu> */
+        }
+      else if (insert_before)
+        {
+          menu_layout_node_insert_before (insert_before, from_child);
+          g_assert (menu_layout_node_get_next (from_child) == insert_before);
+        }
+      else
+        {
+          menu_layout_node_append_child (to, from_child);
+        }
+
+      menu_layout_node_unref (from_child);
+
+      from_child = next;
+    }
+}
+
+static int
+null_safe_strcmp (const char *a,
+                  const char *b)
+{
+  if (a == NULL && b == NULL)
+    return 0;
+  else if (a == NULL)
+    return -1;
+  else if (b == NULL)
+    return 1;
+  else
+    return strcmp (a, b);
+}
+
+static int
+node_compare_func (const void *a,
+                   const void *b)
+{
+  MenuLayoutNode *node_a = (MenuLayoutNode*) a;
+  MenuLayoutNode *node_b = (MenuLayoutNode*) b;
+  MenuLayoutNodeType t_a = menu_layout_node_get_type (node_a);
+  MenuLayoutNodeType t_b = menu_layout_node_get_type (node_b);
+
+  if (t_a < t_b)
+    return -1;
+  else if (t_a > t_b)
+    return 1;
+  else
+    {
+      const char *c_a = menu_layout_node_get_content (node_a);
+      const char *c_b = menu_layout_node_get_content (node_b);
+
+      return null_safe_strcmp (c_a, c_b);
+    }
+}
+
+static int
+node_menu_compare_func (const void *a,
+                        const void *b)
+{
+  MenuLayoutNode *node_a = (MenuLayoutNode*) a;
+  MenuLayoutNode *node_b = (MenuLayoutNode*) b;
+  MenuLayoutNode *parent_a = menu_layout_node_get_parent (node_a);
+  MenuLayoutNode *parent_b = menu_layout_node_get_parent (node_b);
+
+  if (parent_a < parent_b)
+    return -1;
+  else if (parent_a > parent_b)
+    return 1;
+  else
+    return null_safe_strcmp (menu_layout_node_menu_get_name (node_a),
+                             menu_layout_node_menu_get_name (node_b));
+}
+
+static void
+matemenu_tree_strip_duplicate_children (MateMenuTree      *tree,
+				     MenuLayoutNode *layout)
+{
+  MenuLayoutNode *child;
+  GSList         *simple_nodes;
+  GSList         *menu_layout_nodes;
+  GSList         *prev;
+  GSList         *tmp;
+
+  /* to strip dups, we find all the child nodes where
+   * we want to kill dups, sort them,
+   * then nuke the adjacent nodes that are equal
+   */
+
+  simple_nodes = NULL;
+  menu_layout_nodes = NULL;
+
+  child = menu_layout_node_get_children (layout);
+  while (child != NULL)
+    {
+      switch (menu_layout_node_get_type (child))
+        {
+          /* These are dups if their content is the same */
+        case MENU_LAYOUT_NODE_APP_DIR:
+        case MENU_LAYOUT_NODE_DIRECTORY_DIR:
+        case MENU_LAYOUT_NODE_DIRECTORY:
+          simple_nodes = g_slist_prepend (simple_nodes, child);
+          break;
+
+          /* These have to be merged in a more complicated way,
+           * and then recursed
+           */
+        case MENU_LAYOUT_NODE_MENU:
+          menu_layout_nodes = g_slist_prepend (menu_layout_nodes, child);
+          break;
+
+        default:
+          break;
+        }
+
+      child = menu_layout_node_get_next (child);
+    }
+
+  /* Note that the lists are all backward. So we want to keep
+   * the items that are earlier in the list, because they were
+   * later in the file
+   */
+
+  /* stable sort the simple nodes */
+  simple_nodes = g_slist_sort (simple_nodes,
+                               node_compare_func);
+
+  prev = NULL;
+  tmp = simple_nodes;
+  while (tmp != NULL)
+    {
+      GSList *next = tmp->next;
+
+      if (prev)
+        {
+          MenuLayoutNode *p = prev->data;
+          MenuLayoutNode *n = tmp->data;
+
+          if (node_compare_func (p, n) == 0)
+            {
+              /* nuke it! */
+              menu_layout_node_unlink (n);
+	      simple_nodes = g_slist_delete_link (simple_nodes, tmp);
+	      tmp = prev;
+            }
+        }
+
+      prev = tmp;
+      tmp = next;
+    }
+
+  g_slist_free (simple_nodes);
+  simple_nodes = NULL;
+
+  /* stable sort the menu nodes (the sort includes the
+   * parents of the nodes in the comparison). Remember
+   * the list is backward.
+   */
+  menu_layout_nodes = g_slist_sort (menu_layout_nodes,
+				    node_menu_compare_func);
+
+  prev = NULL;
+  tmp = menu_layout_nodes;
+  while (tmp != NULL)
+    {
+      GSList *next = tmp->next;
+
+      if (prev)
+        {
+          MenuLayoutNode *p = prev->data;
+          MenuLayoutNode *n = tmp->data;
+
+          if (node_menu_compare_func (p, n) == 0)
+            {
+              /* Move children of first menu to the start of second
+               * menu and nuke the first menu
+               */
+              move_children (n, p);
+              menu_layout_node_unlink (n);
+	      menu_layout_nodes = g_slist_delete_link (menu_layout_nodes, tmp);
+	      tmp = prev;
+            }
+        }
+
+      prev = tmp;
+      tmp = next;
+    }
+
+  g_slist_free (menu_layout_nodes);
+  menu_layout_nodes = NULL;
+
+  /* Recursively clean up all children */
+  child = menu_layout_node_get_children (layout);
+  while (child != NULL)
+    {
+      if (menu_layout_node_get_type (child) == MENU_LAYOUT_NODE_MENU)
+        matemenu_tree_strip_duplicate_children (tree, child);
+
+      child = menu_layout_node_get_next (child);
+    }
+}
+
+static MenuLayoutNode *
+find_submenu (MenuLayoutNode *layout,
+              const char     *path,
+              gboolean        create_if_not_found)
+{
+  MenuLayoutNode *child;
+  const char     *slash;
+  const char     *next_path;
+  char           *name;
+
+  menu_verbose (" (splitting \"%s\")\n", path);
+
+  if (path[0] == '\0' || path[0] == G_DIR_SEPARATOR)
+    return NULL;
+
+  slash = strchr (path, G_DIR_SEPARATOR);
+  if (slash != NULL)
+    {
+      name = g_strndup (path, slash - path);
+      next_path = slash + 1;
+      if (*next_path == '\0')
+        next_path = NULL;
+    }
+  else
+    {
+      name = g_strdup (path);
+      next_path = NULL;
+    }
+
+  child = menu_layout_node_get_children (layout);
+  while (child != NULL)
+    {
+      switch (menu_layout_node_get_type (child))
+        {
+        case MENU_LAYOUT_NODE_MENU:
+          {
+            if (strcmp (name, menu_layout_node_menu_get_name (child)) == 0)
+              {
+                menu_verbose ("MenuNode %p found for path component \"%s\"\n",
+                              child, name);
+
+                g_free (name);
+
+                if (!next_path)
+                  {
+                    menu_verbose (" Found menu node %p parent is %p\n",
+                                  child, layout);
+                    return child;
+                  }
+
+                return find_submenu (child, next_path, create_if_not_found);
+              }
+          }
+          break;
+
+        default:
+          break;
+        }
+
+      child = menu_layout_node_get_next (child);
+    }
+
+  if (create_if_not_found)
+    {
+      MenuLayoutNode *name_node;
+
+      child = menu_layout_node_new (MENU_LAYOUT_NODE_MENU);
+      menu_layout_node_append_child (layout, child);
+
+      name_node = menu_layout_node_new (MENU_LAYOUT_NODE_NAME);
+      menu_layout_node_set_content (name_node, name);
+      menu_layout_node_append_child (child, name_node);
+      menu_layout_node_unref (name_node);
+
+      menu_verbose (" Created menu node %p parent is %p\n",
+                    child, layout);
+
+      menu_layout_node_unref (child);
+      g_free (name);
+
+      if (!next_path)
+        return child;
+
+      return find_submenu (child, next_path, create_if_not_found);
+    }
+  else
+    {
+      g_free (name);
+      return NULL;
+    }
+}
+
+/* To call this you first have to strip duplicate children once,
+ * otherwise when you move a menu Foo to Bar then you may only
+ * move one of Foo, not all the merged Foo.
+ */
+static void
+matemenu_tree_execute_moves (MateMenuTree      *tree,
+			  MenuLayoutNode *layout,
+			  gboolean       *need_remove_dups_p)
+{
+  MenuLayoutNode *child;
+  gboolean        need_remove_dups;
+  GSList         *move_nodes;
+  GSList         *tmp;
+
+  need_remove_dups = FALSE;
+
+  move_nodes = NULL;
+
+  child = menu_layout_node_get_children (layout);
+  while (child != NULL)
+    {
+      switch (menu_layout_node_get_type (child))
+        {
+        case MENU_LAYOUT_NODE_MENU:
+          /* Recurse - we recurse first and process the current node
+           * second, as the spec dictates.
+           */
+          matemenu_tree_execute_moves (tree, child, &need_remove_dups);
+          break;
+
+        case MENU_LAYOUT_NODE_MOVE:
+          move_nodes = g_slist_prepend (move_nodes, child);
+          break;
+
+        default:
+          break;
+        }
+
+      child = menu_layout_node_get_next (child);
+    }
+
+  /* We need to execute the move operations in the order that they appear */
+  move_nodes = g_slist_reverse (move_nodes);
+
+  tmp = move_nodes;
+  while (tmp != NULL)
+    {
+      MenuLayoutNode *move_node = tmp->data;
+      MenuLayoutNode *old_node;
+      GSList         *next = tmp->next;
+      const char     *old;
+      const char     *new;
+
+      old = menu_layout_node_move_get_old (move_node);
+      new = menu_layout_node_move_get_new (move_node);
+      g_assert (old != NULL && new != NULL);
+
+      menu_verbose ("executing <Move> old = \"%s\" new = \"%s\"\n",
+                    old, new);
+
+      old_node = find_submenu (layout, old, FALSE);
+      if (old_node != NULL)
+        {
+          MenuLayoutNode *new_node;
+
+          /* here we can create duplicates anywhere below the
+           * node
+           */
+          need_remove_dups = TRUE;
+
+          /* look up new node creating it and its parents if
+           * required
+           */
+          new_node = find_submenu (layout, new, TRUE);
+          g_assert (new_node != NULL);
+
+          move_children (old_node, new_node);
+
+          menu_layout_node_unlink (old_node);
+        }
+
+      menu_layout_node_unlink (move_node);
+
+      tmp = next;
+    }
+
+  g_slist_free (move_nodes);
+
+  /* This oddness is to ensure we only remove dups once,
+   * at the root, instead of recursing the tree over
+   * and over.
+   */
+  if (need_remove_dups_p)
+    *need_remove_dups_p = need_remove_dups;
+  else if (need_remove_dups)
+    matemenu_tree_strip_duplicate_children (tree, layout);
+}
+
+static void
+matemenu_tree_load_layout (MateMenuTree *tree)
+{
+  GHashTable *loaded_menu_files;
+  GError     *error;
+
+  if (tree->layout)
+    return;
+
+  if (!matemenu_tree_canonicalize_path (tree))
+    return;
+
+  menu_verbose ("Loading menu layout from \"%s\"\n",
+                tree->canonical_path);
+
+  error = NULL;
+  tree->layout = menu_layout_load (tree->canonical_path,
+                                   tree->type == MATEMENU_TREE_BASENAME ?
+                                        tree->basename : NULL,
+                                   &error);
+  if (tree->layout == NULL)
+    {
+      g_warning ("Error loading menu layout from \"%s\": %s",
+                 tree->canonical_path, error->message);
+      g_error_free (error);
+      return;
+    }
+
+  loaded_menu_files = g_hash_table_new (g_str_hash, g_str_equal);
+  g_hash_table_insert (loaded_menu_files, tree->canonical_path, GUINT_TO_POINTER (TRUE));
+  matemenu_tree_resolve_files (tree, loaded_menu_files, tree->layout);
+  g_hash_table_destroy (loaded_menu_files);
+
+  matemenu_tree_strip_duplicate_children (tree, tree->layout);
+  matemenu_tree_execute_moves (tree, tree->layout, NULL);
+}
+
+static void
+matemenu_tree_force_reload (MateMenuTree *tree)
+{
+  matemenu_tree_force_rebuild (tree);
+
+  if (tree->layout)
+    menu_layout_node_unref (tree->layout);
+  tree->layout = NULL;
+}
+
+typedef struct
+{
+  DesktopEntrySet *set;
+  const char      *category;
+} GetByCategoryForeachData;
+
+static void
+get_by_category_foreach (const char               *file_id,
+			 DesktopEntry             *entry,
+			 GetByCategoryForeachData *data)
+{
+  if (desktop_entry_has_category (entry, data->category))
+    desktop_entry_set_add_entry (data->set, entry, file_id);
+}
+
+static void
+get_by_category (DesktopEntrySet *entry_pool,
+		 DesktopEntrySet *set,
+		 const char      *category)
+{
+  GetByCategoryForeachData data;
+
+  data.set      = set;
+  data.category = category;
+
+  desktop_entry_set_foreach (entry_pool,
+			     (DesktopEntrySetForeachFunc) get_by_category_foreach,
+			     &data);
+}
+
+static DesktopEntrySet *
+process_include_rules (MenuLayoutNode  *layout,
+		       DesktopEntrySet *entry_pool)
+{
+  DesktopEntrySet *set = NULL;
+
+  switch (menu_layout_node_get_type (layout))
+    {
+    case MENU_LAYOUT_NODE_AND:
+      {
+        MenuLayoutNode *child;
+
+	menu_verbose ("Processing <And>\n");
+
+        child = menu_layout_node_get_children (layout);
+        while (child != NULL)
+          {
+            DesktopEntrySet *child_set;
+
+            child_set = process_include_rules (child, entry_pool);
+
+            if (set == NULL)
+              {
+                set = child_set;
+              }
+            else
+              {
+                desktop_entry_set_intersection (set, child_set);
+                desktop_entry_set_unref (child_set);
+              }
+
+            /* as soon as we get empty results, we can bail,
+             * because it's an AND
+             */
+            if (desktop_entry_set_get_count (set) == 0)
+              break;
+
+            child = menu_layout_node_get_next (child);
+          }
+	menu_verbose ("Processed <And>\n");
+      }
+      break;
+
+    case MENU_LAYOUT_NODE_OR:
+      {
+        MenuLayoutNode *child;
+
+	menu_verbose ("Processing <Or>\n");
+
+        child = menu_layout_node_get_children (layout);
+        while (child != NULL)
+          {
+            DesktopEntrySet *child_set;
+
+            child_set = process_include_rules (child, entry_pool);
+
+            if (set == NULL)
+              {
+                set = child_set;
+              }
+            else
+              {
+                desktop_entry_set_union (set, child_set);
+                desktop_entry_set_unref (child_set);
+              }
+
+            child = menu_layout_node_get_next (child);
+          }
+	menu_verbose ("Processed <Or>\n");
+      }
+      break;
+
+    case MENU_LAYOUT_NODE_NOT:
+      {
+        /* First get the OR of all the rules */
+        MenuLayoutNode *child;
+
+	menu_verbose ("Processing <Not>\n");
+
+        child = menu_layout_node_get_children (layout);
+        while (child != NULL)
+          {
+            DesktopEntrySet *child_set;
+
+            child_set = process_include_rules (child, entry_pool);
+
+            if (set == NULL)
+              {
+                set = child_set;
+              }
+            else
+              {
+                desktop_entry_set_union (set, child_set);
+                desktop_entry_set_unref (child_set);
+              }
+
+            child = menu_layout_node_get_next (child);
+          }
+
+        if (set != NULL)
+          {
+	    DesktopEntrySet *inverted;
+
+	    /* Now invert the result */
+	    inverted = desktop_entry_set_new ();
+	    desktop_entry_set_union (inverted, entry_pool);
+	    desktop_entry_set_subtract (inverted, set);
+	    desktop_entry_set_unref (set);
+	    set = inverted;
+          }
+	menu_verbose ("Processed <Not>\n");
+      }
+      break;
+
+    case MENU_LAYOUT_NODE_ALL:
+      menu_verbose ("Processing <All>\n");
+      set = desktop_entry_set_new ();
+      desktop_entry_set_union (set, entry_pool);
+      menu_verbose ("Processed <All>\n");
+      break;
+
+    case MENU_LAYOUT_NODE_FILENAME:
+      {
+        DesktopEntry *entry;
+
+	menu_verbose ("Processing <Filename>%s</Filename>\n",
+		      menu_layout_node_get_content (layout));
+
+        entry = desktop_entry_set_lookup (entry_pool,
+					  menu_layout_node_get_content (layout));
+        if (entry != NULL)
+          {
+            set = desktop_entry_set_new ();
+            desktop_entry_set_add_entry (set,
+                                         entry,
+                                         menu_layout_node_get_content (layout));
+          }
+	menu_verbose ("Processed <Filename>%s</Filename>\n",
+		      menu_layout_node_get_content (layout));
+      }
+      break;
+
+    case MENU_LAYOUT_NODE_CATEGORY:
+      menu_verbose ("Processing <Category>%s</Category>\n",
+		    menu_layout_node_get_content (layout));
+      set = desktop_entry_set_new ();
+      get_by_category (entry_pool, set, menu_layout_node_get_content (layout));
+      menu_verbose ("Processed <Category>%s</Category>\n",
+		    menu_layout_node_get_content (layout));
+      break;
+
+    default:
+      break;
+    }
+
+  if (set == NULL)
+    set = desktop_entry_set_new (); /* create an empty set */
+
+  menu_verbose ("Matched %d entries\n", desktop_entry_set_get_count (set));
+
+  return set;
+}
+
+static void
+collect_layout_info (MenuLayoutNode  *layout,
+		     GSList         **layout_info)
+{
+  MenuLayoutNode *iter;
+
+  g_slist_foreach (*layout_info,
+		   (GFunc) menu_layout_node_unref,
+		   NULL);
+  g_slist_free (*layout_info);
+  *layout_info = NULL;
+
+  iter = menu_layout_node_get_children (layout);
+  while (iter != NULL)
+    {
+      switch (menu_layout_node_get_type (iter))
+	{
+	case MENU_LAYOUT_NODE_MENUNAME:
+	case MENU_LAYOUT_NODE_FILENAME:
+	case MENU_LAYOUT_NODE_SEPARATOR:
+	case MENU_LAYOUT_NODE_MERGE:
+	  *layout_info = g_slist_prepend (*layout_info,
+					  menu_layout_node_ref (iter));
+	  break;
+
+	default:
+	  break;
+	}
+
+      iter = menu_layout_node_get_next (iter);
+    }
+
+  *layout_info = g_slist_reverse (*layout_info);
+}
+
+static void
+entries_listify_foreach (const char         *desktop_file_id,
+                         DesktopEntry       *desktop_entry,
+                         MateMenuTreeDirectory *directory)
+{
+  directory->entries =
+    g_slist_prepend (directory->entries,
+		     matemenu_tree_entry_new (directory,
+                                           desktop_entry,
+                                           desktop_file_id,
+                                           FALSE,
+                                           desktop_entry_get_no_display (desktop_entry)));
+}
+
+static void
+excluded_entries_listify_foreach (const char         *desktop_file_id,
+				  DesktopEntry       *desktop_entry,
+				  MateMenuTreeDirectory *directory)
+{
+  directory->entries =
+    g_slist_prepend (directory->entries,
+		     matemenu_tree_entry_new (directory,
+					   desktop_entry,
+					   desktop_file_id,
+					   TRUE,
+                                           desktop_entry_get_no_display (desktop_entry)));
+}
+
+static void
+set_default_layout_values (MateMenuTreeDirectory *parent,
+                           MateMenuTreeDirectory *child)
+{
+  GSList *tmp;
+
+  /* if the child has a defined default layout, we don't want to override its
+   * values. The parent might have a non-defined layout info (ie, no child of
+   * the DefaultLayout node) but it doesn't meant the default layout values
+   * (ie, DefaultLayout attributes) aren't different from the global defaults.
+   */
+  if (child->default_layout_info != NULL ||
+      child->default_layout_values.mask != MENU_LAYOUT_VALUES_NONE)
+    return;
+
+  child->default_layout_values = parent->default_layout_values;
+
+  tmp = child->subdirs;
+  while (tmp != NULL)
+    {
+      MateMenuTreeDirectory *subdir = tmp->data;
+
+      set_default_layout_values (child, subdir);
+
+      tmp = tmp->next;
+   }
+}
+
+static MateMenuTreeDirectory *
+process_layout (MateMenuTree          *tree,
+                MateMenuTreeDirectory *parent,
+                MenuLayoutNode     *layout,
+                DesktopEntrySet    *allocated)
+{
+  MenuLayoutNode     *layout_iter;
+  MateMenuTreeDirectory *directory;
+  DesktopEntrySet    *entry_pool;
+  DesktopEntrySet    *entries;
+  DesktopEntrySet    *allocated_set;
+  DesktopEntrySet    *excluded_set;
+  gboolean            deleted;
+  gboolean            only_unallocated;
+  GSList             *tmp;
+
+  g_assert (menu_layout_node_get_type (layout) == MENU_LAYOUT_NODE_MENU);
+  g_assert (menu_layout_node_menu_get_name (layout) != NULL);
+
+  directory = matemenu_tree_directory_new (parent,
+					menu_layout_node_menu_get_name (layout),
+					parent == NULL);
+
+  menu_verbose ("=== Menu name = %s ===\n", directory->name);
+
+
+  deleted = FALSE;
+  only_unallocated = FALSE;
+
+  entries = desktop_entry_set_new ();
+  allocated_set = desktop_entry_set_new ();
+
+  if (tree->flags & MATEMENU_TREE_FLAGS_INCLUDE_EXCLUDED)
+    excluded_set = desktop_entry_set_new ();
+  else
+    excluded_set = NULL;
+
+  entry_pool = _entry_directory_list_get_all_desktops (menu_layout_node_menu_get_app_dirs (layout));
+
+  layout_iter = menu_layout_node_get_children (layout);
+  while (layout_iter != NULL)
+    {
+      switch (menu_layout_node_get_type (layout_iter))
+        {
+        case MENU_LAYOUT_NODE_MENU:
+          /* recurse */
+          {
+            MateMenuTreeDirectory *child_dir;
+
+	    menu_verbose ("Processing <Menu>\n");
+
+            child_dir = process_layout (tree,
+                                        directory,
+                                        layout_iter,
+                                        allocated);
+            if (child_dir)
+              directory->subdirs = g_slist_prepend (directory->subdirs,
+                                                    child_dir);
+
+	    menu_verbose ("Processed <Menu>\n");
+          }
+          break;
+
+        case MENU_LAYOUT_NODE_INCLUDE:
+          {
+            /* The match rule children of the <Include> are
+             * independent (logical OR) so we can process each one by
+             * itself
+             */
+            MenuLayoutNode *rule;
+
+	    menu_verbose ("Processing <Include> (%d entries)\n",
+			  desktop_entry_set_get_count (entries));
+
+            rule = menu_layout_node_get_children (layout_iter);
+            while (rule != NULL)
+              {
+                DesktopEntrySet *rule_set;
+
+                rule_set = process_include_rules (rule, entry_pool);
+                if (rule_set != NULL)
+                  {
+                    desktop_entry_set_union (entries, rule_set);
+                    desktop_entry_set_union (allocated_set, rule_set);
+		    if (excluded_set != NULL)
+		      desktop_entry_set_subtract (excluded_set, rule_set);
+                    desktop_entry_set_unref (rule_set);
+                  }
+
+                rule = menu_layout_node_get_next (rule);
+              }
+
+	    menu_verbose ("Processed <Include> (%d entries)\n",
+			  desktop_entry_set_get_count (entries));
+          }
+          break;
+
+        case MENU_LAYOUT_NODE_EXCLUDE:
+          {
+            /* The match rule children of the <Exclude> are
+             * independent (logical OR) so we can process each one by
+             * itself
+             */
+            MenuLayoutNode *rule;
+
+	    menu_verbose ("Processing <Exclude> (%d entries)\n",
+			  desktop_entry_set_get_count (entries));
+
+            rule = menu_layout_node_get_children (layout_iter);
+            while (rule != NULL)
+              {
+                DesktopEntrySet *rule_set;
+
+                rule_set = process_include_rules (rule, entry_pool);
+                if (rule_set != NULL)
+                  {
+		    if (excluded_set != NULL)
+		      desktop_entry_set_union (excluded_set, rule_set);
+		    desktop_entry_set_subtract (entries, rule_set);
+		    desktop_entry_set_unref (rule_set);
+                  }
+
+                rule = menu_layout_node_get_next (rule);
+              }
+
+	    menu_verbose ("Processed <Exclude> (%d entries)\n",
+			  desktop_entry_set_get_count (entries));
+          }
+          break;
+
+        case MENU_LAYOUT_NODE_DIRECTORY:
+          {
+            DesktopEntry *entry;
+
+	    menu_verbose ("Processing <Directory>%s</Directory>\n",
+			  menu_layout_node_get_content (layout_iter));
+
+	    /*
+             * The last <Directory> to exist wins, so we always try overwriting
+             */
+            entry = entry_directory_list_get_directory (menu_layout_node_menu_get_directory_dirs (layout),
+                                                        menu_layout_node_get_content (layout_iter));
+
+            if (entry != NULL)
+              {
+                if (!desktop_entry_get_hidden (entry))
+                  {
+                    if (directory->directory_entry)
+                      desktop_entry_unref (directory->directory_entry);
+                    directory->directory_entry = entry; /* pass ref ownership */
+                  }
+                else
+                  {
+                    desktop_entry_unref (entry);
+                  }
+              }
+
+            menu_verbose ("Processed <Directory> new directory entry = %p (%s)\n",
+                          directory->directory_entry,
+			  directory->directory_entry? desktop_entry_get_path (directory->directory_entry) : "null");
+          }
+          break;
+
+        case MENU_LAYOUT_NODE_DELETED:
+	  menu_verbose ("Processed <Deleted/>\n");
+          deleted = TRUE;
+          break;
+
+        case MENU_LAYOUT_NODE_NOT_DELETED:
+	  menu_verbose ("Processed <NotDeleted/>\n");
+          deleted = FALSE;
+          break;
+
+        case MENU_LAYOUT_NODE_ONLY_UNALLOCATED:
+	  menu_verbose ("Processed <OnlyUnallocated/>\n");
+          only_unallocated = TRUE;
+          break;
+
+        case MENU_LAYOUT_NODE_NOT_ONLY_UNALLOCATED:
+	  menu_verbose ("Processed <NotOnlyUnallocated/>\n");
+          only_unallocated = FALSE;
+          break;
+
+	case MENU_LAYOUT_NODE_DEFAULT_LAYOUT:
+	  menu_layout_node_default_layout_get_values (layout_iter,
+						      &directory->default_layout_values);
+	  collect_layout_info (layout_iter, &directory->default_layout_info);
+	  menu_verbose ("Processed <DefaultLayout/>\n");
+	  break;
+
+	case MENU_LAYOUT_NODE_LAYOUT:
+	  collect_layout_info (layout_iter, &directory->layout_info);
+	  menu_verbose ("Processed <Layout/>\n");
+	  break;
+
+        default:
+          break;
+        }
+
+      layout_iter = menu_layout_node_get_next (layout_iter);
+    }
+
+  desktop_entry_set_unref (entry_pool);
+
+  directory->only_unallocated = only_unallocated;
+
+  if (!directory->only_unallocated)
+    desktop_entry_set_union (allocated, allocated_set);
+
+  desktop_entry_set_unref (allocated_set);
+
+  if (directory->directory_entry)
+    {
+      if (desktop_entry_get_no_display (directory->directory_entry))
+        {
+          directory->is_nodisplay = TRUE;
+
+          if (!(tree->flags & MATEMENU_TREE_FLAGS_INCLUDE_NODISPLAY))
+            {
+              menu_verbose ("Not showing menu %s because NoDisplay=true\n",
+                        desktop_entry_get_name (directory->directory_entry));
+              deleted = TRUE;
+            }
+        }
+
+      if (!desktop_entry_get_show_in_mate (directory->directory_entry))
+        {
+          menu_verbose ("Not showing menu %s because OnlyShowIn!=MATE or NotShowIn=MATE\n",
+                        desktop_entry_get_name (directory->directory_entry));
+          deleted = TRUE;
+        }
+    }
+
+  if (deleted)
+    {
+      if (excluded_set != NULL)
+	desktop_entry_set_unref (excluded_set);
+      desktop_entry_set_unref (entries);
+      matemenu_tree_item_unref (directory);
+      return NULL;
+    }
+
+  desktop_entry_set_foreach (entries,
+                             (DesktopEntrySetForeachFunc) entries_listify_foreach,
+                             directory);
+  desktop_entry_set_unref (entries);
+
+  if (excluded_set != NULL)
+    {
+      desktop_entry_set_foreach (excluded_set,
+				 (DesktopEntrySetForeachFunc) excluded_entries_listify_foreach,
+				 directory);
+      desktop_entry_set_unref (excluded_set);
+    }
+
+  tmp = directory->subdirs;
+  while (tmp != NULL)
+    {
+      MateMenuTreeDirectory *subdir = tmp->data;
+
+      set_default_layout_values (directory, subdir);
+
+      tmp = tmp->next;
+   }
+
+  tmp = directory->entries;
+  while (tmp != NULL)
+    {
+      MateMenuTreeEntry *entry = tmp->data;
+      GSList         *next  = tmp->next;
+      gboolean        delete = FALSE;
+
+      if (desktop_entry_get_hidden (entry->desktop_entry))
+        {
+          menu_verbose ("Deleting %s because Hidden=true\n",
+                        desktop_entry_get_name (entry->desktop_entry));
+          delete = TRUE;
+        }
+
+      if (!(tree->flags & MATEMENU_TREE_FLAGS_INCLUDE_NODISPLAY) &&
+          desktop_entry_get_no_display (entry->desktop_entry))
+        {
+          menu_verbose ("Deleting %s because NoDisplay=true\n",
+                        desktop_entry_get_name (entry->desktop_entry));
+          delete = TRUE;
+        }
+
+      if (!desktop_entry_get_show_in_mate (entry->desktop_entry))
+        {
+          menu_verbose ("Deleting %s because OnlyShowIn!=MATE or NotShowIn=MATE\n",
+                        desktop_entry_get_name (entry->desktop_entry));
+          delete = TRUE;
+        }
+
+      if (desktop_entry_get_tryexec_failed (entry->desktop_entry))
+        {
+          menu_verbose ("Deleting %s because TryExec failed\n",
+                        desktop_entry_get_name (entry->desktop_entry));
+          delete = TRUE;
+        }
+
+      if (delete)
+        {
+          directory->entries = g_slist_delete_link (directory->entries,
+                                                   tmp);
+          matemenu_tree_item_unref_and_unset_parent (entry);
+        }
+
+      tmp = next;
+    }
+
+  g_assert (directory->name != NULL);
+
+  return directory;
+}
+
+static void
+process_only_unallocated (MateMenuTree          *tree,
+			  MateMenuTreeDirectory *directory,
+			  DesktopEntrySet    *allocated)
+{
+  GSList *tmp;
+
+  /* For any directory marked only_unallocated, we have to remove any
+   * entries that were in fact allocated.
+   */
+
+  if (directory->only_unallocated)
+    {
+      tmp = directory->entries;
+      while (tmp != NULL)
+        {
+          MateMenuTreeEntry *entry = tmp->data;
+          GSList         *next  = tmp->next;
+
+          if (desktop_entry_set_lookup (allocated, entry->desktop_file_id))
+            {
+              directory->entries = g_slist_delete_link (directory->entries,
+                                                        tmp);
+              matemenu_tree_item_unref_and_unset_parent (entry);
+            }
+
+          tmp = next;
+        }
+    }
+
+  tmp = directory->subdirs;
+  while (tmp != NULL)
+    {
+      MateMenuTreeDirectory *subdir = tmp->data;
+
+      process_only_unallocated (tree, subdir, allocated);
+
+      tmp = tmp->next;
+   }
+}
+
+static void preprocess_layout_info (MateMenuTree          *tree,
+                                    MateMenuTreeDirectory *directory);
+
+static GSList *
+get_layout_info (MateMenuTreeDirectory *directory,
+                 gboolean           *is_default_layout)
+{
+  MateMenuTreeDirectory *iter;
+
+  if (directory->layout_info != NULL)
+    {
+      if (is_default_layout)
+        {
+          *is_default_layout = FALSE;
+        }
+      return directory->layout_info;
+    }
+
+  /* Even if there's no layout information at all, the result will be an
+   * implicit default layout */
+  if (is_default_layout)
+    {
+      *is_default_layout = TRUE;
+    }
+
+  iter = directory;
+  while (iter != NULL)
+    {
+      /* FIXME: this is broken: we might skip real parent in the
+       * XML structure, that are hidden because of inlining. */
+      if (iter->default_layout_info != NULL)
+	{
+	  return iter->default_layout_info;
+	}
+
+      iter = MATEMENU_TREE_ITEM (iter)->parent;
+    }
+
+  return NULL;
+}
+
+static void
+get_values_with_defaults (MenuLayoutNode   *node,
+			  MenuLayoutValues *layout_values,
+			  MenuLayoutValues *default_layout_values)
+{
+  menu_layout_node_menuname_get_values (node, layout_values);
+
+  if (!(layout_values->mask & MENU_LAYOUT_VALUES_SHOW_EMPTY))
+    layout_values->show_empty = default_layout_values->show_empty;
+
+  if (!(layout_values->mask & MENU_LAYOUT_VALUES_INLINE_MENUS))
+    layout_values->inline_menus = default_layout_values->inline_menus;
+
+  if (!(layout_values->mask & MENU_LAYOUT_VALUES_INLINE_LIMIT))
+    layout_values->inline_limit = default_layout_values->inline_limit;
+
+  if (!(layout_values->mask & MENU_LAYOUT_VALUES_INLINE_HEADER))
+    layout_values->inline_header = default_layout_values->inline_header;
+
+  if (!(layout_values->mask & MENU_LAYOUT_VALUES_INLINE_ALIAS))
+    layout_values->inline_alias = default_layout_values->inline_alias;
+}
+
+static guint
+get_real_subdirs_len (MateMenuTreeDirectory *directory)
+{
+  guint   len;
+  GSList *tmp;
+
+  len = 0;
+
+  tmp = directory->subdirs;
+  while (tmp != NULL)
+    {
+      MateMenuTreeDirectory *subdir = tmp->data;
+
+      tmp = tmp->next;
+
+      if (subdir->will_inline_header != G_MAXUINT16)
+        {
+          len += get_real_subdirs_len (subdir) + g_slist_length (subdir->entries) + 1;
+        }
+      else
+        len += 1;
+    }
+
+  return len;
+}
+
+static void
+preprocess_layout_info_subdir_helper (MateMenuTree          *tree,
+                                      MateMenuTreeDirectory *directory,
+                                      MateMenuTreeDirectory *subdir,
+                                      MenuLayoutValues   *layout_values,
+                                      gboolean           *contents_added,
+                                      gboolean           *should_remove)
+{
+  preprocess_layout_info (tree, subdir);
+
+  *should_remove = FALSE;
+  *contents_added = FALSE;
+
+  if (subdir->subdirs == NULL && subdir->entries == NULL)
+    {
+      if (!(tree->flags & MATEMENU_TREE_FLAGS_SHOW_EMPTY) &&
+          !layout_values->show_empty)
+	{
+	  menu_verbose ("Not showing empty menu '%s'\n", subdir->name);
+	  *should_remove = TRUE;
+	}
+    }
+
+  else if (layout_values->inline_menus)
+    {
+      guint real_subdirs_len;
+
+      real_subdirs_len = get_real_subdirs_len (subdir);
+
+      if (layout_values->inline_alias &&
+          real_subdirs_len + g_slist_length (subdir->entries) == 1)
+        {
+          MateMenuTreeAlias *alias;
+          MateMenuTreeItem  *item;
+          GSList         *list;
+
+          if (subdir->subdirs != NULL)
+            list = subdir->subdirs;
+          else
+            list = subdir->entries;
+
+          item = MATEMENU_TREE_ITEM (list->data);
+
+          menu_verbose ("Inline aliasing '%s' to '%s'\n",
+                        item->type == MATEMENU_TREE_ITEM_ENTRY ?
+                          matemenu_tree_entry_get_name (MATEMENU_TREE_ENTRY (item)) :
+                          (item->type == MATEMENU_TREE_ITEM_DIRECTORY ?
+                             matemenu_tree_directory_get_name (MATEMENU_TREE_DIRECTORY (item)) :
+                             matemenu_tree_directory_get_name (MATEMENU_TREE_ALIAS (item)->directory)),
+                        subdir->name);
+
+          alias = matemenu_tree_alias_new (directory, subdir, item);
+
+          g_slist_foreach (list,
+                           (GFunc) matemenu_tree_item_unref_and_unset_parent,
+                           NULL);
+          g_slist_free (list);
+          subdir->subdirs = NULL;
+          subdir->entries = NULL;
+
+          if (item->type == MATEMENU_TREE_ITEM_DIRECTORY)
+            directory->subdirs = g_slist_append (directory->subdirs, alias);
+          else
+            directory->entries = g_slist_append (directory->entries, alias);
+
+          *contents_added = TRUE;
+          *should_remove = TRUE;
+        }
+
+      else if (layout_values->inline_limit == 0 ||
+               layout_values->inline_limit >= real_subdirs_len + g_slist_length (subdir->entries))
+        {
+          if (layout_values->inline_header)
+            {
+              menu_verbose ("Creating inline header with name '%s'\n", subdir->name);
+              /* we're limited to 16-bits to spare some memory; if the limit is
+               * higher than that (would be crazy), we just consider it's
+               * unlimited */
+              if (layout_values->inline_limit < G_MAXUINT16)
+                subdir->will_inline_header = layout_values->inline_limit;
+              else
+                subdir->will_inline_header = 0;
+            }
+          else
+            {
+              g_slist_foreach (subdir->subdirs,
+                               (GFunc) matemenu_tree_item_set_parent,
+                               directory);
+              directory->subdirs = g_slist_concat (directory->subdirs,
+                                                   subdir->subdirs);
+              subdir->subdirs = NULL;
+
+              g_slist_foreach (subdir->entries,
+                               (GFunc) matemenu_tree_item_set_parent,
+                               directory);
+              directory->entries = g_slist_concat (directory->entries,
+                                                   subdir->entries);
+              subdir->entries = NULL;
+
+              *contents_added = TRUE;
+              *should_remove = TRUE;
+            }
+
+          menu_verbose ("Inlining directory contents of '%s' to '%s'\n",
+                        subdir->name, directory->name);
+        }
+    }
+}
+
+static void
+preprocess_layout_info (MateMenuTree          *tree,
+                        MateMenuTreeDirectory *directory)
+{
+  GSList   *tmp;
+  GSList   *layout_info;
+  gboolean  using_default_layout;
+  GSList   *last_subdir;
+  gboolean  strip_duplicates;
+  gboolean  contents_added;
+  gboolean  should_remove;
+  GSList   *subdirs_sentinel;
+
+  /* Note: we need to preprocess all menus, even if the layout mask for a menu
+   * is MENU_LAYOUT_VALUES_NONE: in this case, we need to remove empty menus;
+   * and the layout mask can be different for a submenu anyway */
+
+  menu_verbose ("Processing menu layout inline hints for %s\n", directory->name);
+  g_assert (!directory->preprocessed);
+
+  strip_duplicates = FALSE;
+  /* we use last_subdir to track the last non-inlined subdirectory */
+  last_subdir = g_slist_last (directory->subdirs);
+
+  /*
+   * First process subdirectories with explicit layout
+   */
+  layout_info = get_layout_info (directory, &using_default_layout);
+  tmp = layout_info;
+  /* see comment below about Menuname to understand why we leave the loop if
+   * last_subdir is NULL */
+  while (tmp != NULL && last_subdir != NULL)
+    {
+      MenuLayoutNode     *node = tmp->data;
+      MenuLayoutValues    layout_values;
+      const char         *name;
+      MateMenuTreeDirectory *subdir;
+      GSList             *subdir_l;
+
+      tmp = tmp->next;
+
+      /* only Menuname nodes are relevant here */
+      if (menu_layout_node_get_type (node) != MENU_LAYOUT_NODE_MENUNAME)
+        continue;
+
+      get_values_with_defaults (node,
+                                &layout_values,
+                                &directory->default_layout_values);
+
+      /* find the subdirectory that is affected by those attributes */
+      name = menu_layout_node_get_content (node);
+      subdir = NULL;
+      subdir_l = directory->subdirs;
+      while (subdir_l != NULL)
+        {
+          subdir = subdir_l->data;
+
+          if (!strcmp (subdir->name, name))
+            break;
+
+          subdir = NULL;
+          subdir_l = subdir_l->next;
+
+          /* We do not want to use Menuname on a menu that appeared via
+           * inlining: without inlining, the Menuname wouldn't have matched
+           * anything, and we want to keep the same behavior.
+           * Unless the layout is a default layout, in which case the Menuname
+           * does match the subdirectory. */
+          if (!using_default_layout && subdir_l == last_subdir)
+            {
+              subdir_l = NULL;
+              break;
+            }
+        }
+
+      if (subdir == NULL)
+        continue;
+
+      preprocess_layout_info_subdir_helper (tree, directory,
+                                            subdir, &layout_values,
+                                            &contents_added, &should_remove);
+      strip_duplicates = strip_duplicates || contents_added;
+      if (should_remove)
+        {
+          if (last_subdir == subdir_l)
+            {
+              /* we need to recompute last_subdir since we'll remove it from
+               * the list */
+              GSList *buf;
+
+              if (subdir_l == directory->subdirs)
+                last_subdir = NULL;
+              else
+                {
+                  buf = directory->subdirs;
+                  while (buf != NULL && buf->next != subdir_l)
+                    buf = buf->next;
+                  last_subdir = buf;
+                }
+            }
+
+          directory->subdirs = g_slist_remove (directory->subdirs, subdir);
+          matemenu_tree_item_unref_and_unset_parent (MATEMENU_TREE_ITEM (subdir));
+        }
+    }
+
+  /*
+   * Now process the subdirectories with no explicit layout
+   */
+  /* this is bogus data, but we just need the pointer anyway */
+  subdirs_sentinel = g_slist_prepend (directory->subdirs, PACKAGE);
+  directory->subdirs = subdirs_sentinel;
+
+  tmp = directory->subdirs;
+  while (tmp->next != NULL)
+    {
+      MateMenuTreeDirectory *subdir = tmp->next->data;
+
+      if (subdir->preprocessed)
+        {
+          tmp = tmp->next;
+          continue;
+        }
+
+      preprocess_layout_info_subdir_helper (tree, directory,
+                                            subdir, &directory->default_layout_values,
+                                            &contents_added, &should_remove);
+      strip_duplicates = strip_duplicates || contents_added;
+      if (should_remove)
+        {
+          tmp = g_slist_delete_link (tmp, tmp->next);
+          matemenu_tree_item_unref_and_unset_parent (MATEMENU_TREE_ITEM (subdir));
+        }
+      else
+        tmp = tmp->next;
+    }
+
+  /* remove the sentinel */
+  directory->subdirs = g_slist_delete_link (directory->subdirs,
+                                            directory->subdirs);
+
+  /*
+   * Finally, remove duplicates if needed
+   */
+  if (strip_duplicates)
+    {
+      /* strip duplicate entries; there should be no duplicate directories */
+      directory->entries = g_slist_sort (directory->entries,
+                                         (GCompareFunc) matemenu_tree_entry_compare_by_id);
+      tmp = directory->entries;
+      while (tmp != NULL && tmp->next != NULL)
+        {
+          MateMenuTreeItem *a = tmp->data;
+          MateMenuTreeItem *b = tmp->next->data;
+
+          if (a->type == MATEMENU_TREE_ITEM_ALIAS)
+            a = MATEMENU_TREE_ALIAS (a)->aliased_item;
+
+          if (b->type == MATEMENU_TREE_ITEM_ALIAS)
+            b = MATEMENU_TREE_ALIAS (b)->aliased_item;
+
+          if (strcmp (MATEMENU_TREE_ENTRY (a)->desktop_file_id,
+                      MATEMENU_TREE_ENTRY (b)->desktop_file_id) == 0)
+            {
+              tmp = g_slist_delete_link (tmp, tmp->next);
+              matemenu_tree_item_unref (b);
+            }
+          else
+            tmp = tmp->next;
+        }
+    }
+
+  directory->preprocessed = TRUE;
+}
+
+static void process_layout_info (MateMenuTree          *tree,
+				 MateMenuTreeDirectory *directory);
+
+static void
+check_pending_separator (MateMenuTreeDirectory *directory)
+{
+  if (directory->layout_pending_separator)
+    {
+      menu_verbose ("Adding pending separator in '%s'\n", directory->name);
+
+      directory->contents = g_slist_append (directory->contents,
+					    matemenu_tree_separator_new (directory));
+      directory->layout_pending_separator = FALSE;
+    }
+}
+
+static void
+merge_alias (MateMenuTree          *tree,
+	     MateMenuTreeDirectory *directory,
+	     MateMenuTreeAlias     *alias)
+{
+  menu_verbose ("Merging alias '%s' in directory '%s'\n",
+		alias->directory->name, directory->name);
+
+  if (alias->aliased_item->type == MATEMENU_TREE_ITEM_DIRECTORY)
+    {
+      process_layout_info (tree, MATEMENU_TREE_DIRECTORY (alias->aliased_item));
+    }
+
+  check_pending_separator (directory);
+
+  directory->contents = g_slist_append (directory->contents,
+					matemenu_tree_item_ref (alias));
+}
+
+static void
+merge_subdir (MateMenuTree          *tree,
+	      MateMenuTreeDirectory *directory,
+	      MateMenuTreeDirectory *subdir)
+{
+  menu_verbose ("Merging subdir '%s' in directory '%s'\n",
+		subdir->name, directory->name);
+
+  process_layout_info (tree, subdir);
+
+  check_pending_separator (directory);
+
+  if (subdir->will_inline_header == 0 ||
+      (subdir->will_inline_header != G_MAXUINT16 &&
+       g_slist_length (subdir->contents) <= subdir->will_inline_header))
+    {
+      MateMenuTreeHeader *header;
+
+      header = matemenu_tree_header_new (directory, subdir);
+      directory->contents = g_slist_append (directory->contents, header);
+
+      g_slist_foreach (subdir->contents,
+                       (GFunc) matemenu_tree_item_set_parent,
+                       directory);
+      directory->contents = g_slist_concat (directory->contents,
+                                            subdir->contents);
+      subdir->contents = NULL;
+      subdir->will_inline_header = G_MAXUINT16;
+
+      matemenu_tree_item_set_parent (MATEMENU_TREE_ITEM (subdir), NULL);
+    }
+  else
+    {
+      directory->contents = g_slist_append (directory->contents,
+					    matemenu_tree_item_ref (subdir));
+    }
+}
+
+static void
+merge_subdir_by_name (MateMenuTree          *tree,
+		      MateMenuTreeDirectory *directory,
+		      const char         *subdir_name)
+{
+  GSList *tmp;
+
+  menu_verbose ("Attempting to merge subdir '%s' in directory '%s'\n",
+		subdir_name, directory->name);
+
+  tmp = directory->subdirs;
+  while (tmp != NULL)
+    {
+      MateMenuTreeDirectory *subdir = tmp->data;
+      GSList             *next = tmp->next;
+
+      /* if it's an alias, then it cannot be affected by
+       * the Merge nodes in the layout */
+      if (MATEMENU_TREE_ITEM (subdir)->type == MATEMENU_TREE_ITEM_ALIAS)
+        continue;
+
+      if (!strcmp (subdir->name, subdir_name))
+	{
+	  directory->subdirs = g_slist_delete_link (directory->subdirs, tmp);
+	  merge_subdir (tree, directory, subdir);
+	  matemenu_tree_item_unref (subdir);
+	}
+
+      tmp = next;
+    }
+}
+
+static void
+merge_entry (MateMenuTree          *tree,
+	     MateMenuTreeDirectory *directory,
+	     MateMenuTreeEntry     *entry)
+{
+  menu_verbose ("Merging entry '%s' in directory '%s'\n",
+		entry->desktop_file_id, directory->name);
+
+  check_pending_separator (directory);
+  directory->contents = g_slist_append (directory->contents,
+					matemenu_tree_item_ref (entry));
+}
+
+static void
+merge_entry_by_id (MateMenuTree          *tree,
+		   MateMenuTreeDirectory *directory,
+		   const char         *file_id)
+{
+  GSList *tmp;
+
+  menu_verbose ("Attempting to merge entry '%s' in directory '%s'\n",
+		file_id, directory->name);
+
+  tmp = directory->entries;
+  while (tmp != NULL)
+    {
+      MateMenuTreeEntry *entry = tmp->data;
+      GSList         *next = tmp->next;
+
+      /* if it's an alias, then it cannot be affected by
+       * the Merge nodes in the layout */
+      if (MATEMENU_TREE_ITEM (entry)->type == MATEMENU_TREE_ITEM_ALIAS)
+        continue;
+
+      if (!strcmp (entry->desktop_file_id, file_id))
+	{
+	  directory->entries = g_slist_delete_link (directory->entries, tmp);
+	  merge_entry (tree, directory, entry);
+	  matemenu_tree_item_unref (entry);
+	}
+
+      tmp = next;
+    }
+}
+
+static inline gboolean
+find_name_in_list (const char *name,
+		   GSList     *list)
+{
+  while (list != NULL)
+    {
+      if (!strcmp (name, list->data))
+	return TRUE;
+
+      list = list->next;
+    }
+
+  return FALSE;
+}
+
+static void
+merge_subdirs (MateMenuTree          *tree,
+	       MateMenuTreeDirectory *directory,
+	       GSList             *except)
+{
+  GSList *subdirs;
+  GSList *tmp;
+
+  menu_verbose ("Merging subdirs in directory '%s'\n", directory->name);
+
+  subdirs = directory->subdirs;
+  directory->subdirs = NULL;
+
+  subdirs = g_slist_sort_with_data (subdirs,
+				    (GCompareDataFunc) matemenu_tree_item_compare,
+				     GINT_TO_POINTER (MATEMENU_TREE_SORT_NAME));
+
+  tmp = subdirs;
+  while (tmp != NULL)
+    {
+      MateMenuTreeDirectory *subdir = tmp->data;
+
+      if (MATEMENU_TREE_ITEM (subdir)->type == MATEMENU_TREE_ITEM_ALIAS)
+        {
+	  merge_alias (tree, directory, MATEMENU_TREE_ALIAS (subdir));
+	  matemenu_tree_item_unref (subdir);
+        }
+      else if (!find_name_in_list (subdir->name, except))
+	{
+	  merge_subdir (tree, directory, subdir);
+	  matemenu_tree_item_unref (subdir);
+	}
+      else
+	{
+	  menu_verbose ("Not merging directory '%s' yet\n", subdir->name);
+	  directory->subdirs = g_slist_append (directory->subdirs, subdir);
+	}
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (subdirs);
+  g_slist_free (except);
+}
+
+static void
+merge_entries (MateMenuTree          *tree,
+	       MateMenuTreeDirectory *directory,
+	       GSList             *except)
+{
+  GSList *entries;
+  GSList *tmp;
+
+  menu_verbose ("Merging entries in directory '%s'\n", directory->name);
+
+  entries = directory->entries;
+  directory->entries = NULL;
+
+  entries = g_slist_sort_with_data (entries,
+				    (GCompareDataFunc) matemenu_tree_item_compare,
+				    GINT_TO_POINTER (tree->sort_key));
+
+  tmp = entries;
+  while (tmp != NULL)
+    {
+      MateMenuTreeEntry *entry = tmp->data;
+
+      if (MATEMENU_TREE_ITEM (entry)->type == MATEMENU_TREE_ITEM_ALIAS)
+        {
+	  merge_alias (tree, directory, MATEMENU_TREE_ALIAS (entry));
+	  matemenu_tree_item_unref (entry);
+        }
+      else if (!find_name_in_list (entry->desktop_file_id, except))
+	{
+	  merge_entry (tree, directory, entry);
+	  matemenu_tree_item_unref (entry);
+	}
+      else
+	{
+	  menu_verbose ("Not merging entry '%s' yet\n", entry->desktop_file_id);
+	  directory->entries = g_slist_append (directory->entries, entry);
+	}
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (entries);
+  g_slist_free (except);
+}
+
+static void
+merge_subdirs_and_entries (MateMenuTree          *tree,
+			   MateMenuTreeDirectory *directory,
+			   GSList             *except_subdirs,
+			   GSList             *except_entries)
+{
+  GSList *items;
+  GSList *tmp;
+
+  menu_verbose ("Merging subdirs and entries together in directory %s\n",
+		directory->name);
+
+  items = g_slist_concat (directory->subdirs, directory->entries);
+
+  directory->subdirs = NULL;
+  directory->entries = NULL;
+
+  items = g_slist_sort_with_data (items,
+				  (GCompareDataFunc) matemenu_tree_item_compare,
+				  GINT_TO_POINTER (tree->sort_key));
+
+  tmp = items;
+  while (tmp != NULL)
+    {
+      MateMenuTreeItem     *item = tmp->data;
+      MateMenuTreeItemType  type;
+
+      type = matemenu_tree_item_get_type (item);
+
+      if (type == MATEMENU_TREE_ITEM_ALIAS)
+        {
+          merge_alias (tree, directory, MATEMENU_TREE_ALIAS (item));
+          matemenu_tree_item_unref (item);
+        }
+      else if (type == MATEMENU_TREE_ITEM_DIRECTORY)
+	{
+	  if (!find_name_in_list (MATEMENU_TREE_DIRECTORY (item)->name, except_subdirs))
+	    {
+	      merge_subdir (tree,
+			    directory,
+			    MATEMENU_TREE_DIRECTORY (item));
+	      matemenu_tree_item_unref (item);
+	    }
+	  else
+	    {
+	      menu_verbose ("Not merging directory '%s' yet\n",
+			    MATEMENU_TREE_DIRECTORY (item)->name);
+	      directory->subdirs = g_slist_append (directory->subdirs, item);
+	    }
+	}
+      else if (type == MATEMENU_TREE_ITEM_ENTRY)
+	{
+	  if (!find_name_in_list (MATEMENU_TREE_ENTRY (item)->desktop_file_id, except_entries))
+	    {
+	      merge_entry (tree, directory, MATEMENU_TREE_ENTRY (item));
+	      matemenu_tree_item_unref (item);
+	    }
+	  else
+	    {
+	      menu_verbose ("Not merging entry '%s' yet\n",
+			    MATEMENU_TREE_ENTRY (item)->desktop_file_id);
+	      directory->entries = g_slist_append (directory->entries, item);
+	    }
+	}
+      else
+        {
+          g_assert_not_reached ();
+        }
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (items);
+  g_slist_free (except_subdirs);
+  g_slist_free (except_entries);
+}
+
+static GSList *
+get_subdirs_from_layout_info (GSList *layout_info)
+{
+  GSList *subdirs;
+  GSList *tmp;
+
+  subdirs = NULL;
+
+  tmp = layout_info;
+  while (tmp != NULL)
+    {
+      MenuLayoutNode *node = tmp->data;
+
+      if (menu_layout_node_get_type (node) == MENU_LAYOUT_NODE_MENUNAME)
+	{
+	  subdirs = g_slist_append (subdirs,
+				    (char *) menu_layout_node_get_content (node));
+	}
+
+      tmp = tmp->next;
+    }
+
+  return subdirs;
+}
+
+static GSList *
+get_entries_from_layout_info (GSList *layout_info)
+{
+  GSList *entries;
+  GSList *tmp;
+
+  entries = NULL;
+
+  tmp = layout_info;
+  while (tmp != NULL)
+    {
+      MenuLayoutNode *node = tmp->data;
+
+      if (menu_layout_node_get_type (node) == MENU_LAYOUT_NODE_FILENAME)
+	{
+	  entries = g_slist_append (entries,
+				    (char *) menu_layout_node_get_content (node));
+	}
+
+      tmp = tmp->next;
+    }
+
+  return entries;
+}
+
+static void
+process_layout_info (MateMenuTree          *tree,
+		     MateMenuTreeDirectory *directory)
+{
+  GSList *layout_info;
+
+  menu_verbose ("Processing menu layout hints for %s\n", directory->name);
+
+  g_slist_foreach (directory->contents,
+		   (GFunc) matemenu_tree_item_unref_and_unset_parent,
+		   NULL);
+  g_slist_free (directory->contents);
+  directory->contents = NULL;
+  directory->layout_pending_separator = FALSE;
+
+  layout_info = get_layout_info (directory, NULL);
+
+  if (layout_info == NULL)
+    {
+      merge_subdirs (tree, directory, NULL);
+      merge_entries (tree, directory, NULL);
+    }
+  else
+    {
+      GSList *tmp;
+
+      tmp = layout_info;
+      while (tmp != NULL)
+	{
+	  MenuLayoutNode *node = tmp->data;
+
+	  switch (menu_layout_node_get_type (node))
+	    {
+	    case MENU_LAYOUT_NODE_MENUNAME:
+              merge_subdir_by_name (tree,
+                                    directory,
+                                    menu_layout_node_get_content (node));
+	      break;
+
+	    case MENU_LAYOUT_NODE_FILENAME:
+	      merge_entry_by_id (tree,
+				 directory,
+				 menu_layout_node_get_content (node));
+	      break;
+
+	    case MENU_LAYOUT_NODE_SEPARATOR:
+	      /* Unless explicitly told to show all separators, do not show a
+	       * separator at the beginning of a menu. Note that we don't add
+	       * the separators now, and instead make it pending. This way, we
+	       * won't show two consecutive separators nor will we show a
+	       * separator at the end of a menu. */
+              if (tree->flags & MATEMENU_TREE_FLAGS_SHOW_ALL_SEPARATORS)
+		{
+		  directory->layout_pending_separator = TRUE;
+		  check_pending_separator (directory);
+		}
+	      else if (directory->contents)
+		{
+		  menu_verbose ("Adding a potential separator in '%s'\n",
+				directory->name);
+
+		  directory->layout_pending_separator = TRUE;
+		}
+	      else
+		{
+		  menu_verbose ("Skipping separator at the beginning of '%s'\n",
+				directory->name);
+		}
+	      break;
+
+	    case MENU_LAYOUT_NODE_MERGE:
+	      switch (menu_layout_node_merge_get_type (node))
+		{
+		case MENU_LAYOUT_MERGE_NONE:
+		  break;
+
+		case MENU_LAYOUT_MERGE_MENUS:
+		  merge_subdirs (tree,
+				 directory,
+				 get_subdirs_from_layout_info (tmp->next));
+		  break;
+
+		case MENU_LAYOUT_MERGE_FILES:
+		  merge_entries (tree,
+				 directory,
+				 get_entries_from_layout_info (tmp->next));
+		  break;
+
+		case MENU_LAYOUT_MERGE_ALL:
+		  merge_subdirs_and_entries (tree,
+					     directory,
+					     get_subdirs_from_layout_info (tmp->next),
+					     get_entries_from_layout_info (tmp->next));
+		  break;
+
+		default:
+		  g_assert_not_reached ();
+		  break;
+		}
+	      break;
+
+	    default:
+	      g_assert_not_reached ();
+	      break;
+	    }
+
+	  tmp = tmp->next;
+	}
+    }
+
+  g_slist_foreach (directory->subdirs,
+		   (GFunc) matemenu_tree_item_unref,
+		   NULL);
+  g_slist_free (directory->subdirs);
+  directory->subdirs = NULL;
+
+  g_slist_foreach (directory->entries,
+		   (GFunc) matemenu_tree_item_unref,
+		   NULL);
+  g_slist_free (directory->entries);
+  directory->entries = NULL;
+
+  g_slist_foreach (directory->default_layout_info,
+		   (GFunc) menu_layout_node_unref,
+		   NULL);
+  g_slist_free (directory->default_layout_info);
+  directory->default_layout_info = NULL;
+
+  g_slist_foreach (directory->layout_info,
+		   (GFunc) menu_layout_node_unref,
+		   NULL);
+  g_slist_free (directory->layout_info);
+  directory->layout_info = NULL;
+}
+
+static void
+handle_entries_changed (MenuLayoutNode *layout,
+                        MateMenuTree       *tree)
+{
+  if (tree->layout == layout)
+    {
+      matemenu_tree_force_rebuild (tree);
+      matemenu_tree_invoke_monitors (tree);
+    }
+}
+
+static void
+matemenu_tree_build_from_layout (MateMenuTree *tree)
+{
+  DesktopEntrySet *allocated;
+
+  if (tree->root)
+    return;
+
+  matemenu_tree_load_layout (tree);
+  if (!tree->layout)
+    return;
+
+  menu_verbose ("Building menu tree from layout\n");
+
+  allocated = desktop_entry_set_new ();
+
+  /* create the menu structure */
+  tree->root = process_layout (tree,
+                               NULL,
+                               find_menu_child (tree->layout),
+                               allocated);
+  if (tree->root)
+    {
+      matemenu_tree_directory_set_tree (tree->root, tree);
+
+      process_only_unallocated (tree, tree->root, allocated);
+
+      /* process the layout info part that can move/remove items:
+       * inline, show_empty, etc. */
+      preprocess_layout_info (tree, tree->root);
+      /* populate the menu structure that we got with the items, and order it
+       * according to the layout info */
+      process_layout_info (tree, tree->root);
+
+      menu_layout_node_root_add_entries_monitor (tree->layout,
+                                                 (MenuLayoutNodeEntriesChangedFunc) handle_entries_changed,
+                                                 tree);
+    }
+
+  desktop_entry_set_unref (allocated);
+}
+
+static void
+matemenu_tree_force_rebuild (MateMenuTree *tree)
+{
+  if (tree->root)
+    {
+      matemenu_tree_directory_set_tree (tree->root, NULL);
+      matemenu_tree_item_unref (tree->root);
+      tree->root = NULL;
+
+      g_assert (tree->layout != NULL);
+
+      menu_layout_node_root_remove_entries_monitor (tree->layout,
+                                                    (MenuLayoutNodeEntriesChangedFunc) handle_entries_changed,
+                                                    tree);
+    }
+}
diff --git a/libmenu/matemenu-tree.h b/libmenu/matemenu-tree.h
new file mode 100644
index 0000000..d4916a9
--- /dev/null
+++ b/libmenu/matemenu-tree.h
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2004 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __MATEMENU_TREE_H__
+#define __MATEMENU_TREE_H__
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct MateMenuTree          MateMenuTree;
+typedef struct MateMenuTreeItem      MateMenuTreeItem;
+typedef struct MateMenuTreeDirectory MateMenuTreeDirectory;
+typedef struct MateMenuTreeEntry     MateMenuTreeEntry;
+typedef struct MateMenuTreeSeparator MateMenuTreeSeparator;
+typedef struct MateMenuTreeHeader    MateMenuTreeHeader;
+typedef struct MateMenuTreeAlias     MateMenuTreeAlias;
+
+typedef void (*MateMenuTreeChangedFunc) (MateMenuTree* tree, gpointer user_data);
+
+typedef enum {
+	MATEMENU_TREE_ITEM_INVALID = 0,
+	MATEMENU_TREE_ITEM_DIRECTORY,
+	MATEMENU_TREE_ITEM_ENTRY,
+	MATEMENU_TREE_ITEM_SEPARATOR,
+	MATEMENU_TREE_ITEM_HEADER,
+	MATEMENU_TREE_ITEM_ALIAS
+} MateMenuTreeItemType;
+
+#define MATEMENU_TREE_ITEM(i)      ((MateMenuTreeItem*)(i))
+#define MATEMENU_TREE_DIRECTORY(i) ((MateMenuTreeDirectory*)(i))
+#define MATEMENU_TREE_ENTRY(i)     ((MateMenuTreeEntry*)(i))
+#define MATEMENU_TREE_SEPARATOR(i) ((MateMenuTreeSeparator*)(i))
+#define MATEMENU_TREE_HEADER(i)    ((MateMenuTreeHeader*)(i))
+#define MATEMENU_TREE_ALIAS(i)     ((MateMenuTreeAlias*)(i))
+
+typedef enum {
+	MATEMENU_TREE_FLAGS_NONE                = 0,
+	MATEMENU_TREE_FLAGS_INCLUDE_EXCLUDED    = 1 << 0,
+	MATEMENU_TREE_FLAGS_SHOW_EMPTY          = 1 << 1,
+	MATEMENU_TREE_FLAGS_INCLUDE_NODISPLAY   = 1 << 2,
+	MATEMENU_TREE_FLAGS_SHOW_ALL_SEPARATORS = 1 << 3,
+	MATEMENU_TREE_FLAGS_MASK                = 0x0f
+} MateMenuTreeFlags;
+
+typedef enum {
+	#define MATEMENU_TREE_SORT_FIRST MATEMENU_TREE_SORT_NAME
+	MATEMENU_TREE_SORT_NAME = 0,
+	MATEMENU_TREE_SORT_DISPLAY_NAME
+	#define MATEMENU_TREE_SORT_LAST MATEMENU_TREE_SORT_DISPLAY_NAME
+} MateMenuTreeSortKey;
+
+MateMenuTree* matemenu_tree_lookup(const char* menu_file, MateMenuTreeFlags flags);
+
+MateMenuTree* matemenu_tree_ref(MateMenuTree* tree);
+void matemenu_tree_unref(MateMenuTree* tree);
+
+void matemenu_tree_set_user_data(MateMenuTree* tree, gpointer user_data, GDestroyNotify dnotify);
+gpointer matemenu_tree_get_user_data(MateMenuTree* tree);
+
+const char* matemenu_tree_get_menu_file(MateMenuTree* tree);
+MateMenuTreeDirectory* matemenu_tree_get_root_directory(MateMenuTree* tree);
+MateMenuTreeDirectory* matemenu_tree_get_directory_from_path(MateMenuTree* tree, const char* path);
+
+MateMenuTreeSortKey matemenu_tree_get_sort_key(MateMenuTree* tree);
+void matemenu_tree_set_sort_key(MateMenuTree* tree, MateMenuTreeSortKey sort_key);
+
+
+
+gpointer matemenu_tree_item_ref(gpointer item);
+void matemenu_tree_item_unref(gpointer item);
+
+void matemenu_tree_item_set_user_data(MateMenuTreeItem* item, gpointer user_data, GDestroyNotify dnotify);
+gpointer matemenu_tree_item_get_user_data(MateMenuTreeItem* item);
+
+MateMenuTreeItemType matemenu_tree_item_get_type(MateMenuTreeItem* item);
+MateMenuTreeDirectory* matemenu_tree_item_get_parent(MateMenuTreeItem* item);
+
+
+GSList* matemenu_tree_directory_get_contents(MateMenuTreeDirectory* directory);
+const char* matemenu_tree_directory_get_name(MateMenuTreeDirectory* directory);
+const char* matemenu_tree_directory_get_comment(MateMenuTreeDirectory* directory);
+const char* matemenu_tree_directory_get_icon(MateMenuTreeDirectory* directory);
+const char* matemenu_tree_directory_get_desktop_file_path(MateMenuTreeDirectory* directory);
+const char* matemenu_tree_directory_get_menu_id(MateMenuTreeDirectory* directory);
+MateMenuTree* matemenu_tree_directory_get_tree(MateMenuTreeDirectory* directory);
+
+gboolean matemenu_tree_directory_get_is_nodisplay(MateMenuTreeDirectory* directory);
+
+char* matemenu_tree_directory_make_path(MateMenuTreeDirectory* directory, MateMenuTreeEntry* entry);
+
+
+const char* matemenu_tree_entry_get_name(MateMenuTreeEntry* entry);
+const char* matemenu_tree_entry_get_generic_name(MateMenuTreeEntry* entry);
+const char* matemenu_tree_entry_get_display_name(MateMenuTreeEntry* entry);
+const char* matemenu_tree_entry_get_comment(MateMenuTreeEntry* entry);
+const char* matemenu_tree_entry_get_icon(MateMenuTreeEntry* entry);
+const char* matemenu_tree_entry_get_exec(MateMenuTreeEntry* entry);
+gboolean matemenu_tree_entry_get_launch_in_terminal(MateMenuTreeEntry* entry);
+const char* matemenu_tree_entry_get_desktop_file_path(MateMenuTreeEntry* entry);
+const char* matemenu_tree_entry_get_desktop_file_id(MateMenuTreeEntry* entry);
+gboolean matemenu_tree_entry_get_is_excluded(MateMenuTreeEntry* entry);
+gboolean matemenu_tree_entry_get_is_nodisplay(MateMenuTreeEntry* entry);
+
+MateMenuTreeDirectory* matemenu_tree_header_get_directory(MateMenuTreeHeader* header);
+
+MateMenuTreeDirectory* matemenu_tree_alias_get_directory(MateMenuTreeAlias* alias);
+MateMenuTreeItem* matemenu_tree_alias_get_item(MateMenuTreeAlias* alias);
+
+void matemenu_tree_add_monitor(MateMenuTree* tree, MateMenuTreeChangedFunc callback, gpointer user_data);
+void matemenu_tree_remove_monitor(MateMenuTree* tree, MateMenuTreeChangedFunc callback, gpointer user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MATEMENU_TREE_H__ */
diff --git a/libmenu/menu-layout.c b/libmenu/menu-layout.c
new file mode 100644
index 0000000..d447d2d
--- /dev/null
+++ b/libmenu/menu-layout.c
@@ -0,0 +1,2359 @@
+/* Menu layout in-memory data structure (a custom "DOM tree") */
+
+/*
+ * Copyright (C) 2002 - 2004 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "menu-layout.h"
+
+#include <string.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <errno.h>
+
+#include "canonicalize.h"
+#include "entry-directories.h"
+#include "menu-util.h"
+
+typedef struct MenuLayoutNodeMenu          MenuLayoutNodeMenu;
+typedef struct MenuLayoutNodeRoot          MenuLayoutNodeRoot;
+typedef struct MenuLayoutNodeLegacyDir     MenuLayoutNodeLegacyDir;
+typedef struct MenuLayoutNodeMergeFile     MenuLayoutNodeMergeFile;
+typedef struct MenuLayoutNodeDefaultLayout MenuLayoutNodeDefaultLayout;
+typedef struct MenuLayoutNodeMenuname      MenuLayoutNodeMenuname;
+typedef struct MenuLayoutNodeMerge         MenuLayoutNodeMerge;
+
+struct MenuLayoutNode
+{
+  /* Node lists are circular, for length-one lists
+   * prev/next point back to the node itself.
+   */
+  MenuLayoutNode *prev;
+  MenuLayoutNode *next;
+  MenuLayoutNode *parent;
+  MenuLayoutNode *children;
+
+  char *content;
+
+  guint refcount : 20;
+  guint type : 7;
+};
+
+struct MenuLayoutNodeRoot
+{
+  MenuLayoutNode node;
+
+  char *basedir;
+  char *name;
+
+  GSList *monitors;
+};
+
+struct MenuLayoutNodeMenu
+{
+  MenuLayoutNode node;
+
+  MenuLayoutNode *name_node; /* cache of the <Name> node */
+
+  EntryDirectoryList *app_dirs;
+  EntryDirectoryList *dir_dirs;
+};
+
+struct MenuLayoutNodeLegacyDir
+{
+  MenuLayoutNode node;
+
+  char *prefix;
+};
+
+struct MenuLayoutNodeMergeFile
+{
+  MenuLayoutNode node;
+
+  MenuMergeFileType type;
+};
+
+struct MenuLayoutNodeDefaultLayout
+{
+  MenuLayoutNode node;
+
+  MenuLayoutValues layout_values;
+};
+
+struct MenuLayoutNodeMenuname
+{
+  MenuLayoutNode node;
+
+  MenuLayoutValues layout_values;
+};
+
+struct MenuLayoutNodeMerge
+{
+  MenuLayoutNode node;
+
+  MenuLayoutMergeType merge_type;
+};
+
+typedef struct
+{
+  MenuLayoutNodeEntriesChangedFunc callback;
+  gpointer                         user_data;
+} MenuLayoutNodeEntriesMonitor;
+
+
+static inline MenuLayoutNode *
+node_next (MenuLayoutNode *node)
+{
+  /* root nodes (no parent) never have siblings */
+  if (node->parent == NULL)
+    return NULL;
+
+  /* circular list */
+  if (node->next == node->parent->children)
+    return NULL;
+
+  return node->next;
+}
+
+static void
+handle_entry_directory_changed (EntryDirectory *dir,
+                                MenuLayoutNode *node)
+{
+  MenuLayoutNodeRoot *nr;
+  GSList             *tmp;
+
+  g_assert (node->type == MENU_LAYOUT_NODE_MENU);
+
+  nr = (MenuLayoutNodeRoot *) menu_layout_node_get_root (node);
+
+  tmp = nr->monitors;
+  while (tmp != NULL)
+    {
+      MenuLayoutNodeEntriesMonitor *monitor = tmp->data;
+      GSList                       *next    = tmp->next;
+
+      monitor->callback ((MenuLayoutNode *) nr, monitor->user_data);
+
+      tmp = next;
+    }
+}
+
+static void
+remove_entry_directory_list (MenuLayoutNodeMenu  *nm,
+                             EntryDirectoryList **dirs)
+{
+  if (*dirs)
+    {
+      entry_directory_list_remove_monitors (*dirs,
+                                            (EntryDirectoryChangedFunc) handle_entry_directory_changed,
+                                            nm);
+      entry_directory_list_unref (*dirs);
+      *dirs = NULL;
+    }
+}
+
+MenuLayoutNode *
+menu_layout_node_ref (MenuLayoutNode *node)
+{
+  g_return_val_if_fail (node != NULL, NULL);
+
+  node->refcount += 1;
+
+  return node;
+}
+
+void
+menu_layout_node_unref (MenuLayoutNode *node)
+{
+  g_return_if_fail (node != NULL);
+  g_return_if_fail (node->refcount > 0);
+
+  node->refcount -= 1;
+  if (node->refcount == 0)
+    {
+      MenuLayoutNode *iter;
+
+      iter = node->children;
+      while (iter != NULL)
+        {
+          MenuLayoutNode *next = node_next (iter);
+
+          menu_layout_node_unref (iter);
+
+          iter = next;
+        }
+
+      if (node->type == MENU_LAYOUT_NODE_MENU)
+        {
+          MenuLayoutNodeMenu *nm = (MenuLayoutNodeMenu *) node;
+
+          if (nm->name_node)
+            menu_layout_node_unref (nm->name_node);
+
+          remove_entry_directory_list (nm, &nm->app_dirs);
+          remove_entry_directory_list (nm, &nm->dir_dirs);
+        }
+      else if (node->type == MENU_LAYOUT_NODE_LEGACY_DIR)
+        {
+          MenuLayoutNodeLegacyDir *legacy = (MenuLayoutNodeLegacyDir *) node;
+
+          g_free (legacy->prefix);
+        }
+      else if (node->type == MENU_LAYOUT_NODE_ROOT)
+        {
+          MenuLayoutNodeRoot *nr = (MenuLayoutNodeRoot*) node;
+
+          g_slist_foreach (nr->monitors, (GFunc) g_free, NULL);
+          g_slist_free (nr->monitors);
+
+          g_free (nr->basedir);
+          g_free (nr->name);
+        }
+
+      g_free (node->content);
+      g_free (node);
+    }
+}
+
+MenuLayoutNode *
+menu_layout_node_new (MenuLayoutNodeType type)
+{
+  MenuLayoutNode *node;
+
+  switch (type)
+    {
+    case MENU_LAYOUT_NODE_MENU:
+      node = (MenuLayoutNode *) g_new0 (MenuLayoutNodeMenu, 1);
+      break;
+
+    case MENU_LAYOUT_NODE_LEGACY_DIR:
+      node = (MenuLayoutNode *) g_new0 (MenuLayoutNodeLegacyDir, 1);
+      break;
+
+    case MENU_LAYOUT_NODE_ROOT:
+      node = (MenuLayoutNode*) g_new0 (MenuLayoutNodeRoot, 1);
+      break;
+
+    case MENU_LAYOUT_NODE_MERGE_FILE:
+      node = (MenuLayoutNode *) g_new0 (MenuLayoutNodeMergeFile, 1);
+      break;
+
+    case MENU_LAYOUT_NODE_DEFAULT_LAYOUT:
+      node = (MenuLayoutNode *) g_new0 (MenuLayoutNodeDefaultLayout, 1);
+      break;
+
+    case MENU_LAYOUT_NODE_MENUNAME:
+      node = (MenuLayoutNode *) g_new0 (MenuLayoutNodeMenuname, 1);
+      break;
+
+    case MENU_LAYOUT_NODE_MERGE:
+      node = (MenuLayoutNode *) g_new0 (MenuLayoutNodeMerge, 1);
+      break;
+
+    default:
+      node = g_new0 (MenuLayoutNode, 1);
+      break;
+    }
+
+  node->type = type;
+
+  node->refcount = 1;
+
+  /* we're in a list of one node */
+  node->next = node;
+  node->prev = node;
+
+  return node;
+}
+
+MenuLayoutNode *
+menu_layout_node_get_next (MenuLayoutNode *node)
+{
+  return node_next (node);
+}
+
+MenuLayoutNode *
+menu_layout_node_get_parent (MenuLayoutNode *node)
+{
+  return node->parent;
+}
+
+MenuLayoutNode *
+menu_layout_node_get_children (MenuLayoutNode *node)
+{
+  return node->children;
+}
+
+MenuLayoutNode *
+menu_layout_node_get_root (MenuLayoutNode *node)
+{
+  MenuLayoutNode *parent;
+
+  parent = node;
+  while (parent->parent != NULL)
+    parent = parent->parent;
+
+  g_assert (parent->type == MENU_LAYOUT_NODE_ROOT);
+
+  return parent;
+}
+
+char *
+menu_layout_node_get_content_as_path (MenuLayoutNode *node)
+{
+  if (node->content == NULL)
+    {
+      menu_verbose ("  (node has no content to get as a path)\n");
+      return NULL;
+    }
+
+  if (g_path_is_absolute (node->content))
+    {
+      return g_strdup (node->content);
+    }
+  else
+    {
+      MenuLayoutNodeRoot *root;
+
+      root = (MenuLayoutNodeRoot *) menu_layout_node_get_root (node);
+
+      if (root->basedir == NULL)
+        {
+          menu_verbose ("No basedir available, using \"%s\" as-is\n",
+                        node->content);
+          return g_strdup (node->content);
+        }
+      else
+        {
+          menu_verbose ("Using basedir \"%s\" filename \"%s\"\n",
+                        root->basedir, node->content);
+          return g_build_filename (root->basedir, node->content, NULL);
+        }
+    }
+}
+
+#define RETURN_IF_NO_PARENT(node) G_STMT_START {                  \
+    if ((node)->parent == NULL)                                   \
+      {                                                           \
+        g_warning ("To add siblings to a menu node, "             \
+                   "it must not be the root node, "               \
+                   "and must be linked in below some root node\n" \
+                   "node parent = %p and type = %d",              \
+                   (node)->parent, (node)->type);                 \
+        return;                                                   \
+      }                                                           \
+  } G_STMT_END
+
+#define RETURN_IF_HAS_ENTRY_DIRS(node) G_STMT_START {             \
+    if ((node)->type == MENU_LAYOUT_NODE_MENU &&                  \
+        (((MenuLayoutNodeMenu*)(node))->app_dirs != NULL ||       \
+         ((MenuLayoutNodeMenu*)(node))->dir_dirs != NULL))        \
+      {                                                           \
+        g_warning ("node acquired ->app_dirs or ->dir_dirs "      \
+                   "while not rooted in a tree\n");               \
+        return;                                                   \
+      }                                                           \
+  } G_STMT_END                                                    \
+
+void
+menu_layout_node_insert_before (MenuLayoutNode *node,
+                                MenuLayoutNode *new_sibling)
+{
+  g_return_if_fail (new_sibling != NULL);
+  g_return_if_fail (new_sibling->parent == NULL);
+
+  RETURN_IF_NO_PARENT (node);
+  RETURN_IF_HAS_ENTRY_DIRS (new_sibling);
+
+  new_sibling->next = node;
+  new_sibling->prev = node->prev;
+
+  node->prev = new_sibling;
+  new_sibling->prev->next = new_sibling;
+
+  new_sibling->parent = node->parent;
+
+  if (node == node->parent->children)
+    node->parent->children = new_sibling;
+
+  menu_layout_node_ref (new_sibling);
+}
+
+void
+menu_layout_node_insert_after (MenuLayoutNode *node,
+                               MenuLayoutNode *new_sibling)
+{
+  g_return_if_fail (new_sibling != NULL);
+  g_return_if_fail (new_sibling->parent == NULL);
+
+  RETURN_IF_NO_PARENT (node);
+  RETURN_IF_HAS_ENTRY_DIRS (new_sibling);
+
+  new_sibling->prev = node;
+  new_sibling->next = node->next;
+
+  node->next = new_sibling;
+  new_sibling->next->prev = new_sibling;
+
+  new_sibling->parent = node->parent;
+
+  menu_layout_node_ref (new_sibling);
+}
+
+void
+menu_layout_node_prepend_child (MenuLayoutNode *parent,
+                                MenuLayoutNode *new_child)
+{
+  RETURN_IF_HAS_ENTRY_DIRS (new_child);
+
+  if (parent->children)
+    {
+      menu_layout_node_insert_before (parent->children, new_child);
+    }
+  else
+    {
+      parent->children = menu_layout_node_ref (new_child);
+      new_child->parent = parent;
+    }
+}
+
+void
+menu_layout_node_append_child (MenuLayoutNode *parent,
+                               MenuLayoutNode *new_child)
+{
+  RETURN_IF_HAS_ENTRY_DIRS (new_child);
+
+  if (parent->children)
+    {
+      menu_layout_node_insert_after (parent->children->prev, new_child);
+    }
+  else
+    {
+      parent->children = menu_layout_node_ref (new_child);
+      new_child->parent = parent;
+    }
+}
+
+void
+menu_layout_node_unlink (MenuLayoutNode *node)
+{
+  g_return_if_fail (node != NULL);
+  g_return_if_fail (node->parent != NULL);
+
+  menu_layout_node_steal (node);
+  menu_layout_node_unref (node);
+}
+
+static void
+recursive_clean_entry_directory_lists (MenuLayoutNode *node,
+                                       gboolean        apps)
+{
+  EntryDirectoryList **dirs;
+  MenuLayoutNodeMenu  *nm;
+  MenuLayoutNode      *iter;
+
+  if (node->type != MENU_LAYOUT_NODE_MENU)
+    return;
+
+  nm = (MenuLayoutNodeMenu *) node;
+
+  dirs = apps ? &nm->app_dirs : &nm->dir_dirs;
+
+  if (*dirs == NULL || entry_directory_list_get_length (*dirs) == 0)
+    return; /* child menus continue to have valid lists */
+
+  remove_entry_directory_list (nm, dirs);
+
+  iter = node->children;
+  while (iter != NULL)
+    {
+      if (iter->type == MENU_LAYOUT_NODE_MENU)
+        recursive_clean_entry_directory_lists (iter, apps);
+
+      iter = node_next (iter);
+    }
+}
+
+void
+menu_layout_node_steal (MenuLayoutNode *node)
+{
+  g_return_if_fail (node != NULL);
+  g_return_if_fail (node->parent != NULL);
+
+  switch (node->type)
+    {
+    case MENU_LAYOUT_NODE_NAME:
+      {
+        MenuLayoutNodeMenu *nm = (MenuLayoutNodeMenu *) node->parent;
+
+        if (nm->name_node == node)
+          {
+            menu_layout_node_unref (nm->name_node);
+            nm->name_node = NULL;
+          }
+      }
+      break;
+
+    case MENU_LAYOUT_NODE_APP_DIR:
+      recursive_clean_entry_directory_lists (node->parent, TRUE);
+      break;
+
+    case MENU_LAYOUT_NODE_DIRECTORY_DIR:
+      recursive_clean_entry_directory_lists (node->parent, FALSE);
+      break;
+
+    default:
+      break;
+    }
+
+  if (node->parent && node->parent->children == node)
+    {
+      if (node->next != node)
+        node->parent->children = node->next;
+      else
+        node->parent->children = NULL;
+    }
+
+  /* these are no-ops for length-one node lists */
+  node->prev->next = node->next;
+  node->next->prev = node->prev;
+
+  node->parent = NULL;
+
+  /* point to ourselves, now we're length one */
+  node->next = node;
+  node->prev = node;
+}
+
+MenuLayoutNodeType
+menu_layout_node_get_type (MenuLayoutNode *node)
+{
+  return node->type;
+}
+
+const char *
+menu_layout_node_get_content (MenuLayoutNode *node)
+{
+  return node->content;
+}
+
+void
+menu_layout_node_set_content (MenuLayoutNode *node,
+                              const char     *content)
+{
+  if (node->content == content)
+    return;
+
+  g_free (node->content);
+  node->content = g_strdup (content);
+}
+
+const char *
+menu_layout_node_root_get_name (MenuLayoutNode *node)
+{
+  MenuLayoutNodeRoot *nr;
+
+  g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_ROOT, NULL);
+
+  nr = (MenuLayoutNodeRoot*) node;
+
+  return nr->name;
+}
+
+const char *
+menu_layout_node_root_get_basedir (MenuLayoutNode *node)
+{
+  MenuLayoutNodeRoot *nr;
+
+  g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_ROOT, NULL);
+
+  nr = (MenuLayoutNodeRoot*) node;
+
+  return nr->basedir;
+}
+
+const char *
+menu_layout_node_menu_get_name (MenuLayoutNode *node)
+{
+  MenuLayoutNodeMenu *nm;
+
+  g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_MENU, NULL);
+
+  nm = (MenuLayoutNodeMenu*) node;
+
+  if (nm->name_node == NULL)
+    {
+      MenuLayoutNode *iter;
+
+      iter = node->children;
+      while (iter != NULL)
+        {
+          if (iter->type == MENU_LAYOUT_NODE_NAME)
+            {
+              nm->name_node = menu_layout_node_ref (iter);
+              break;
+            }
+
+          iter = node_next (iter);
+        }
+    }
+
+  if (nm->name_node == NULL)
+    return NULL;
+
+  return menu_layout_node_get_content (nm->name_node);
+}
+
+static void
+ensure_dir_lists (MenuLayoutNodeMenu *nm)
+{
+  MenuLayoutNode     *node;
+  MenuLayoutNode     *iter;
+  EntryDirectoryList *app_dirs;
+  EntryDirectoryList *dir_dirs;
+
+  node = (MenuLayoutNode *) nm;
+
+  if (nm->app_dirs && nm->dir_dirs)
+    return;
+
+  app_dirs = NULL;
+  dir_dirs = NULL;
+
+  if (nm->app_dirs == NULL)
+    {
+      app_dirs = entry_directory_list_new ();
+
+      if (node->parent && node->parent->type == MENU_LAYOUT_NODE_MENU)
+        {
+          EntryDirectoryList *dirs;
+
+          if ((dirs = menu_layout_node_menu_get_app_dirs (node->parent)))
+            entry_directory_list_append_list (app_dirs, dirs);
+        }
+    }
+
+  if (nm->dir_dirs == NULL)
+    {
+      dir_dirs = entry_directory_list_new ();
+
+      if (node->parent && node->parent->type == MENU_LAYOUT_NODE_MENU)
+        {
+          EntryDirectoryList *dirs;
+
+          if ((dirs = menu_layout_node_menu_get_directory_dirs (node->parent)))
+            entry_directory_list_append_list (dir_dirs, dirs);
+        }
+    }
+
+  iter = node->children;
+  while (iter != NULL)
+    {
+      EntryDirectory *ed;
+
+      if (app_dirs != NULL && iter->type == MENU_LAYOUT_NODE_APP_DIR)
+        {
+          char *path;
+
+          path = menu_layout_node_get_content_as_path (iter);
+
+          ed = entry_directory_new (DESKTOP_ENTRY_DESKTOP, path);
+          if (ed != NULL)
+            {
+              entry_directory_list_prepend (app_dirs, ed);
+              entry_directory_unref (ed);
+            }
+
+          g_free (path);
+        }
+
+      if (dir_dirs != NULL && iter->type == MENU_LAYOUT_NODE_DIRECTORY_DIR)
+        {
+          char *path;
+
+          path = menu_layout_node_get_content_as_path (iter);
+
+          ed = entry_directory_new (DESKTOP_ENTRY_DIRECTORY, path);
+          if (ed != NULL)
+            {
+              entry_directory_list_prepend (dir_dirs, ed);
+              entry_directory_unref (ed);
+            }
+
+          g_free (path);
+        }
+
+      if (iter->type == MENU_LAYOUT_NODE_LEGACY_DIR)
+        {
+          MenuLayoutNodeLegacyDir *legacy = (MenuLayoutNodeLegacyDir *) iter;
+          char                    *path;
+
+          path = menu_layout_node_get_content_as_path (iter);
+
+          if (app_dirs != NULL) /* we're loading app dirs */
+            {
+              ed = entry_directory_new_legacy (DESKTOP_ENTRY_DESKTOP,
+                                               path,
+                                               legacy->prefix);
+              if (ed != NULL)
+                {
+                  entry_directory_list_prepend (app_dirs, ed);
+                  entry_directory_unref (ed);
+                }
+            }
+
+          if (dir_dirs != NULL) /* we're loading dir dirs */
+            {
+              ed = entry_directory_new_legacy (DESKTOP_ENTRY_DIRECTORY,
+                                               path,
+                                               legacy->prefix);
+              if (ed != NULL)
+                {
+                  entry_directory_list_prepend (dir_dirs, ed);
+                  entry_directory_unref (ed);
+                }
+            }
+
+          g_free (path);
+        }
+
+      iter = node_next (iter);
+    }
+
+  if (app_dirs)
+    {
+      g_assert (nm->app_dirs == NULL);
+
+      nm->app_dirs = app_dirs;
+      entry_directory_list_add_monitors (nm->app_dirs,
+                                         (EntryDirectoryChangedFunc) handle_entry_directory_changed,
+                                         nm);
+    }
+
+  if (dir_dirs)
+    {
+      g_assert (nm->dir_dirs == NULL);
+
+      nm->dir_dirs = dir_dirs;
+      entry_directory_list_add_monitors (nm->dir_dirs,
+                                         (EntryDirectoryChangedFunc) handle_entry_directory_changed,
+                                         nm);
+    }
+}
+
+EntryDirectoryList *
+menu_layout_node_menu_get_app_dirs (MenuLayoutNode *node)
+{
+  MenuLayoutNodeMenu *nm;
+
+  g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_MENU, NULL);
+
+  nm = (MenuLayoutNodeMenu *) node;
+
+  ensure_dir_lists (nm);
+
+  return nm->app_dirs;
+}
+
+EntryDirectoryList *
+menu_layout_node_menu_get_directory_dirs (MenuLayoutNode *node)
+{
+  MenuLayoutNodeMenu *nm;
+
+  g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_MENU, NULL);
+
+  nm = (MenuLayoutNodeMenu *) node;
+
+  ensure_dir_lists (nm);
+
+  return nm->dir_dirs;
+}
+
+const char *
+menu_layout_node_move_get_old (MenuLayoutNode *node)
+{
+  MenuLayoutNode *iter;
+
+  iter = node->children;
+  while (iter != NULL)
+    {
+      if (iter->type == MENU_LAYOUT_NODE_OLD)
+        return iter->content;
+
+      iter = node_next (iter);
+    }
+
+  return NULL;
+}
+
+const char *
+menu_layout_node_move_get_new (MenuLayoutNode *node)
+{
+  MenuLayoutNode *iter;
+
+  iter = node->children;
+  while (iter != NULL)
+    {
+      if (iter->type == MENU_LAYOUT_NODE_NEW)
+        return iter->content;
+
+      iter = node_next (iter);
+    }
+
+  return NULL;
+}
+
+const char *
+menu_layout_node_legacy_dir_get_prefix (MenuLayoutNode *node)
+{
+  MenuLayoutNodeLegacyDir *legacy;
+
+  g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_LEGACY_DIR, NULL);
+
+  legacy = (MenuLayoutNodeLegacyDir *) node;
+
+  return legacy->prefix;
+}
+
+void
+menu_layout_node_legacy_dir_set_prefix (MenuLayoutNode *node,
+                                        const char     *prefix)
+{
+  MenuLayoutNodeLegacyDir *legacy;
+
+  g_return_if_fail (node->type == MENU_LAYOUT_NODE_LEGACY_DIR);
+
+  legacy = (MenuLayoutNodeLegacyDir *) node;
+
+  g_free (legacy->prefix);
+  legacy->prefix = g_strdup (prefix);
+}
+
+MenuMergeFileType
+menu_layout_node_merge_file_get_type (MenuLayoutNode *node)
+{
+  MenuLayoutNodeMergeFile *merge_file;
+
+  g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_MERGE_FILE, FALSE);
+
+  merge_file = (MenuLayoutNodeMergeFile *) node;
+
+  return merge_file->type;
+}
+
+void
+menu_layout_node_merge_file_set_type (MenuLayoutNode    *node,
+				      MenuMergeFileType  type)
+{
+  MenuLayoutNodeMergeFile *merge_file;
+
+  g_return_if_fail (node->type == MENU_LAYOUT_NODE_MERGE_FILE);
+
+  merge_file = (MenuLayoutNodeMergeFile *) node;
+
+  merge_file->type = type;
+}
+
+MenuLayoutMergeType
+menu_layout_node_merge_get_type (MenuLayoutNode *node)
+{
+  MenuLayoutNodeMerge *merge;
+
+  g_return_val_if_fail (node->type == MENU_LAYOUT_NODE_MERGE, 0);
+
+  merge = (MenuLayoutNodeMerge *) node;
+
+  return merge->merge_type;
+}
+
+static void
+menu_layout_node_merge_set_type (MenuLayoutNode *node,
+                                 const char     *merge_type)
+{
+  MenuLayoutNodeMerge *merge;
+
+  g_return_if_fail (node->type == MENU_LAYOUT_NODE_MERGE);
+
+  merge = (MenuLayoutNodeMerge *) node;
+
+  merge->merge_type = MENU_LAYOUT_MERGE_NONE;
+
+  if (strcmp (merge_type, "menus") == 0)
+    {
+      merge->merge_type = MENU_LAYOUT_MERGE_MENUS;
+    }
+  else if (strcmp (merge_type, "files") == 0)
+    {
+      merge->merge_type = MENU_LAYOUT_MERGE_FILES;
+    }
+  else if (strcmp (merge_type, "all") == 0)
+    {
+      merge->merge_type = MENU_LAYOUT_MERGE_ALL;
+    }
+}
+
+void
+menu_layout_node_default_layout_get_values (MenuLayoutNode   *node,
+					    MenuLayoutValues *values)
+{
+  MenuLayoutNodeDefaultLayout *default_layout;
+
+  g_return_if_fail (node->type == MENU_LAYOUT_NODE_DEFAULT_LAYOUT);
+  g_return_if_fail (values != NULL);
+
+  default_layout = (MenuLayoutNodeDefaultLayout *) node;
+
+  *values = default_layout->layout_values;
+}
+
+void
+menu_layout_node_menuname_get_values (MenuLayoutNode   *node,
+				      MenuLayoutValues *values)
+{
+  MenuLayoutNodeMenuname *menuname;
+
+  g_return_if_fail (node->type == MENU_LAYOUT_NODE_MENUNAME);
+  g_return_if_fail (values != NULL);
+
+  menuname = (MenuLayoutNodeMenuname *) node;
+
+  *values = menuname->layout_values;
+}
+
+static void
+menu_layout_values_set (MenuLayoutValues *values,
+			const char       *show_empty,
+			const char       *inline_menus,
+			const char       *inline_limit,
+			const char       *inline_header,
+			const char       *inline_alias)
+{
+  values->mask          = MENU_LAYOUT_VALUES_NONE;
+  values->show_empty    = FALSE;
+  values->inline_menus  = FALSE;
+  values->inline_limit  = 4;
+  values->inline_header = FALSE;
+  values->inline_alias  = FALSE;
+
+  if (show_empty != NULL)
+    {
+      values->show_empty = strcmp (show_empty, "true") == 0;
+      values->mask |= MENU_LAYOUT_VALUES_SHOW_EMPTY;
+    }
+
+  if (inline_menus != NULL)
+    {
+      values->inline_menus = strcmp (inline_menus, "true") == 0;
+      values->mask |= MENU_LAYOUT_VALUES_INLINE_MENUS;
+    }
+
+  if (inline_limit != NULL)
+    {
+      char *end;
+      int   limit;
+
+      limit = strtol (inline_limit, &end, 10);
+      if (*end == '\0')
+	{
+	  values->inline_limit = limit;
+	  values->mask |= MENU_LAYOUT_VALUES_INLINE_LIMIT;
+	}
+    }
+
+  if (inline_header != NULL)
+    {
+      values->inline_header = strcmp (inline_header, "true") == 0;
+      values->mask |= MENU_LAYOUT_VALUES_INLINE_HEADER;
+    }
+
+  if (inline_alias != NULL)
+    {
+      values->inline_alias = strcmp (inline_alias, "true") == 0;
+      values->mask |= MENU_LAYOUT_VALUES_INLINE_ALIAS;
+    }
+}
+
+static void
+menu_layout_node_default_layout_set_values (MenuLayoutNode *node,
+					    const char     *show_empty,
+					    const char     *inline_menus,
+					    const char     *inline_limit,
+					    const char     *inline_header,
+					    const char     *inline_alias)
+{
+  MenuLayoutNodeDefaultLayout *default_layout;
+
+  g_return_if_fail (node->type == MENU_LAYOUT_NODE_DEFAULT_LAYOUT);
+
+  default_layout = (MenuLayoutNodeDefaultLayout *) node;
+
+  menu_layout_values_set (&default_layout->layout_values,
+			  show_empty,
+			  inline_menus,
+			  inline_limit,
+			  inline_header,
+			  inline_alias);
+}
+
+static void
+menu_layout_node_menuname_set_values (MenuLayoutNode *node,
+				      const char     *show_empty,
+				      const char     *inline_menus,
+				      const char     *inline_limit,
+				      const char     *inline_header,
+				      const char     *inline_alias)
+{
+  MenuLayoutNodeMenuname *menuname;
+
+  g_return_if_fail (node->type == MENU_LAYOUT_NODE_MENUNAME);
+
+  menuname = (MenuLayoutNodeMenuname *) node;
+
+  menu_layout_values_set (&menuname->layout_values,
+			  show_empty,
+			  inline_menus,
+			  inline_limit,
+			  inline_header,
+			  inline_alias);
+}
+
+void
+menu_layout_node_root_add_entries_monitor (MenuLayoutNode                   *node,
+                                           MenuLayoutNodeEntriesChangedFunc  callback,
+                                           gpointer                          user_data)
+{
+  MenuLayoutNodeEntriesMonitor *monitor;
+  MenuLayoutNodeRoot           *nr;
+  GSList                       *tmp;
+
+  g_return_if_fail (node->type == MENU_LAYOUT_NODE_ROOT);
+
+  nr = (MenuLayoutNodeRoot *) node;
+
+  tmp = nr->monitors;
+  while (tmp != NULL)
+    {
+      monitor = tmp->data;
+
+      if (monitor->callback  == callback &&
+          monitor->user_data == user_data)
+        break;
+
+      tmp = tmp->next;
+    }
+
+  if (tmp == NULL)
+    {
+      monitor            = g_new0 (MenuLayoutNodeEntriesMonitor, 1);
+      monitor->callback  = callback;
+      monitor->user_data = user_data;
+
+      nr->monitors = g_slist_append (nr->monitors, monitor);
+    }
+}
+
+void
+menu_layout_node_root_remove_entries_monitor (MenuLayoutNode                   *node,
+                                              MenuLayoutNodeEntriesChangedFunc  callback,
+                                              gpointer                          user_data)
+{
+  MenuLayoutNodeRoot *nr;
+  GSList             *tmp;
+
+  g_return_if_fail (node->type == MENU_LAYOUT_NODE_ROOT);
+
+  nr = (MenuLayoutNodeRoot *) node;
+
+  tmp = nr->monitors;
+  while (tmp != NULL)
+    {
+      MenuLayoutNodeEntriesMonitor *monitor = tmp->data;
+      GSList                       *next = tmp->next;
+
+      if (monitor->callback == callback &&
+          monitor->user_data == user_data)
+        {
+          nr->monitors = g_slist_delete_link (nr->monitors, tmp);
+          g_free (monitor);
+        }
+
+      tmp = next;
+    }
+}
+
+
+/*
+ * Menu file parsing
+ */
+
+typedef struct
+{
+  MenuLayoutNode *root;
+  MenuLayoutNode *stack_top;
+} MenuParser;
+
+static void set_error (GError             **err,
+                       GMarkupParseContext *context,
+                       int                  error_domain,
+                       int                  error_code,
+                       const char          *format,
+                       ...) G_GNUC_PRINTF (5, 6);
+
+static void add_context_to_error (GError             **err,
+                                  GMarkupParseContext *context);
+
+static void start_element_handler (GMarkupParseContext  *context,
+                                   const char           *element_name,
+                                   const char          **attribute_names,
+                                   const char          **attribute_values,
+                                   gpointer              user_data,
+                                   GError              **error);
+static void end_element_handler   (GMarkupParseContext  *context,
+                                   const char           *element_name,
+                                   gpointer              user_data,
+                                   GError              **error);
+static void text_handler          (GMarkupParseContext  *context,
+                                   const char           *text,
+                                   gsize                 text_len,
+                                   gpointer              user_data,
+                                   GError              **error);
+static void passthrough_handler   (GMarkupParseContext  *context,
+                                   const char           *passthrough_text,
+                                   gsize                 text_len,
+                                   gpointer              user_data,
+                                   GError              **error);
+
+
+static GMarkupParser menu_funcs = {
+  start_element_handler,
+  end_element_handler,
+  text_handler,
+  passthrough_handler,
+  NULL
+};
+
+static void
+set_error (GError              **err,
+           GMarkupParseContext  *context,
+           int                   error_domain,
+           int                   error_code,
+           const char           *format,
+           ...)
+{
+  int      line, ch;
+  va_list  args;
+  char    *str;
+
+  g_markup_parse_context_get_position (context, &line, &ch);
+
+  va_start (args, format);
+  str = g_strdup_vprintf (format, args);
+  va_end (args);
+
+  g_set_error (err, error_domain, error_code,
+               "Line %d character %d: %s",
+               line, ch, str);
+
+  g_free (str);
+}
+
+static void
+add_context_to_error (GError             **err,
+                      GMarkupParseContext *context)
+{
+  int   line, ch;
+  char *str;
+
+  if (err == NULL || *err == NULL)
+    return;
+
+  g_markup_parse_context_get_position (context, &line, &ch);
+
+  str = g_strdup_printf ("Line %d character %d: %s",
+                         line, ch, (*err)->message);
+  g_free ((*err)->message);
+  (*err)->message = str;
+}
+
+#define ELEMENT_IS(name) (strcmp (element_name, (name)) == 0)
+
+typedef struct
+{
+  const char  *name;
+  const char **retloc;
+} LocateAttr;
+
+static gboolean
+locate_attributes (GMarkupParseContext  *context,
+                   const char           *element_name,
+                   const char          **attribute_names,
+                   const char          **attribute_values,
+                   GError              **error,
+                   const char           *first_attribute_name,
+                   const char          **first_attribute_retloc,
+                   ...)
+{
+#define MAX_ATTRS 24
+  LocateAttr   attrs[MAX_ATTRS];
+  int          n_attrs;
+  va_list      args;
+  const char  *name;
+  const char **retloc;
+  gboolean     retval;
+  int          i;
+
+  g_return_val_if_fail (first_attribute_name != NULL, FALSE);
+  g_return_val_if_fail (first_attribute_retloc != NULL, FALSE);
+
+  retval = TRUE;
+
+  n_attrs = 1;
+  attrs[0].name = first_attribute_name;
+  attrs[0].retloc = first_attribute_retloc;
+  *first_attribute_retloc = NULL;
+
+  va_start (args, first_attribute_retloc);
+
+  name = va_arg (args, const char *);
+  retloc = va_arg (args, const char **);
+
+  while (name != NULL)
+    {
+      g_return_val_if_fail (retloc != NULL, FALSE);
+
+      g_assert (n_attrs < MAX_ATTRS);
+
+      attrs[n_attrs].name = name;
+      attrs[n_attrs].retloc = retloc;
+      n_attrs += 1;
+      *retloc = NULL;
+
+      name = va_arg (args, const char *);
+      retloc = va_arg (args, const char **);
+    }
+
+  va_end (args);
+
+  i = 0;
+  while (attribute_names[i])
+    {
+      int j;
+
+      j = 0;
+      while (j < n_attrs)
+        {
+          if (strcmp (attrs[j].name, attribute_names[i]) == 0)
+            {
+              retloc = attrs[j].retloc;
+
+              if (*retloc != NULL)
+                {
+                  set_error (error, context,
+                             G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                             "Attribute \"%s\" repeated twice on the same <%s> element",
+                             attrs[j].name, element_name);
+                  retval = FALSE;
+                  goto out;
+                }
+
+              *retloc = attribute_values[i];
+              break;
+            }
+
+          ++j;
+        }
+
+      if (j == n_attrs)
+        {
+          set_error (error, context,
+                     G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     "Attribute \"%s\" is invalid on <%s> element in this context",
+                     attribute_names[i], element_name);
+          retval = FALSE;
+          goto out;
+        }
+
+      ++i;
+    }
+
+ out:
+  return retval;
+
+#undef MAX_ATTRS
+}
+
+static gboolean
+check_no_attributes (GMarkupParseContext  *context,
+                     const char           *element_name,
+                     const char          **attribute_names,
+                     const char          **attribute_values,
+                     GError              **error)
+{
+  if (attribute_names[0] != NULL)
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 "Attribute \"%s\" is invalid on <%s> element in this context",
+                 attribute_names[0], element_name);
+      return FALSE;
+    }
+
+  return TRUE;
+}
+
+static int
+has_child_of_type (MenuLayoutNode     *node,
+                   MenuLayoutNodeType  type)
+{
+  MenuLayoutNode *iter;
+
+  iter = node->children;
+  while (iter)
+    {
+      if (iter->type == type)
+        return TRUE;
+
+      iter = node_next (iter);
+    }
+
+  return FALSE;
+}
+
+static void
+push_node (MenuParser         *parser,
+           MenuLayoutNodeType  type)
+{
+  MenuLayoutNode *node;
+
+  node = menu_layout_node_new (type);
+  menu_layout_node_append_child (parser->stack_top, node);
+  menu_layout_node_unref (node);
+
+  parser->stack_top = node;
+}
+
+static void
+start_menu_element (MenuParser           *parser,
+                    GMarkupParseContext  *context,
+                    const char           *element_name,
+                    const char          **attribute_names,
+                    const char          **attribute_values,
+                    GError              **error)
+{
+  if (!check_no_attributes (context, element_name,
+                            attribute_names, attribute_values,
+                            error))
+    return;
+
+  if (!(parser->stack_top->type == MENU_LAYOUT_NODE_ROOT ||
+        parser->stack_top->type == MENU_LAYOUT_NODE_MENU))
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 "<Menu> element can only appear below other <Menu> elements or at toplevel\n");
+    }
+  else
+    {
+      push_node (parser, MENU_LAYOUT_NODE_MENU);
+    }
+}
+
+static void
+start_menu_child_element (MenuParser           *parser,
+                          GMarkupParseContext  *context,
+                          const char           *element_name,
+                          const char          **attribute_names,
+                          const char          **attribute_values,
+                          GError              **error)
+{
+  if (ELEMENT_IS ("LegacyDir"))
+    {
+      const char *prefix;
+
+      push_node (parser, MENU_LAYOUT_NODE_LEGACY_DIR);
+
+      if (!locate_attributes (context, element_name,
+                              attribute_names, attribute_values,
+                              error,
+                              "prefix", &prefix,
+                              NULL))
+        return;
+
+      menu_layout_node_legacy_dir_set_prefix (parser->stack_top, prefix);
+    }
+  else if (ELEMENT_IS ("MergeFile"))
+    {
+      const char *type;
+
+      push_node (parser, MENU_LAYOUT_NODE_MERGE_FILE);
+
+      if (!locate_attributes (context, element_name,
+                              attribute_names, attribute_values,
+                              error,
+                              "type", &type,
+                              NULL))
+        return;
+
+      if (type != NULL && strcmp (type, "parent") == 0)
+	{
+	  menu_layout_node_merge_file_set_type (parser->stack_top,
+						MENU_MERGE_FILE_TYPE_PARENT);
+	}
+    }
+  else if (ELEMENT_IS ("DefaultLayout"))
+    {
+      const char *show_empty;
+      const char *inline_menus;
+      const char *inline_limit;
+      const char *inline_header;
+      const char *inline_alias;
+
+      push_node (parser, MENU_LAYOUT_NODE_DEFAULT_LAYOUT);
+
+      locate_attributes (context, element_name,
+                         attribute_names, attribute_values,
+                         error,
+                         "show_empty",    &show_empty,
+                         "inline",        &inline_menus,
+                         "inline_limit",  &inline_limit,
+                         "inline_header", &inline_header,
+                         "inline_alias",  &inline_alias,
+                         NULL);
+
+      menu_layout_node_default_layout_set_values (parser->stack_top,
+						  show_empty,
+						  inline_menus,
+						  inline_limit,
+						  inline_header,
+						  inline_alias);
+    }
+  else
+    {
+      if (!check_no_attributes (context, element_name,
+                                attribute_names, attribute_values,
+                                error))
+        return;
+
+      if (ELEMENT_IS ("AppDir"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_APP_DIR);
+        }
+      else if (ELEMENT_IS ("DefaultAppDirs"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_DEFAULT_APP_DIRS);
+        }
+      else if (ELEMENT_IS ("DirectoryDir"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_DIRECTORY_DIR);
+        }
+      else if (ELEMENT_IS ("DefaultDirectoryDirs"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_DEFAULT_DIRECTORY_DIRS);
+        }
+      else if (ELEMENT_IS ("DefaultMergeDirs"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_DEFAULT_MERGE_DIRS);
+        }
+      else if (ELEMENT_IS ("Name"))
+        {
+          if (has_child_of_type (parser->stack_top, MENU_LAYOUT_NODE_NAME))
+            {
+              set_error (error, context,
+                         G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         "Multiple <Name> elements in a <Menu> element is not allowed\n");
+              return;
+            }
+
+          push_node (parser, MENU_LAYOUT_NODE_NAME);
+        }
+      else if (ELEMENT_IS ("Directory"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_DIRECTORY);
+        }
+      else if (ELEMENT_IS ("OnlyUnallocated"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_ONLY_UNALLOCATED);
+        }
+      else if (ELEMENT_IS ("NotOnlyUnallocated"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_NOT_ONLY_UNALLOCATED);
+        }
+      else if (ELEMENT_IS ("Include"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_INCLUDE);
+        }
+      else if (ELEMENT_IS ("Exclude"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_EXCLUDE);
+        }
+      else if (ELEMENT_IS ("MergeDir"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_MERGE_DIR);
+        }
+      else if (ELEMENT_IS ("KDELegacyDirs"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_KDE_LEGACY_DIRS);
+        }
+      else if (ELEMENT_IS ("Move"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_MOVE);
+        }
+      else if (ELEMENT_IS ("Deleted"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_DELETED);
+
+        }
+      else if (ELEMENT_IS ("NotDeleted"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_NOT_DELETED);
+        }
+      else if (ELEMENT_IS ("Layout"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_LAYOUT);
+        }
+      else
+        {
+          set_error (error, context,
+                     G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
+                     "Element <%s> may not appear below <%s>\n",
+                     element_name, "Menu");
+        }
+    }
+}
+
+static void
+start_matching_rule_element (MenuParser           *parser,
+                             GMarkupParseContext  *context,
+                             const char           *element_name,
+                             const char          **attribute_names,
+                             const char          **attribute_values,
+                             GError              **error)
+{
+  if (!check_no_attributes (context, element_name,
+                            attribute_names, attribute_values,
+                            error))
+    return;
+
+
+  if (ELEMENT_IS ("Filename"))
+    {
+      push_node (parser, MENU_LAYOUT_NODE_FILENAME);
+    }
+  else if (ELEMENT_IS ("Category"))
+    {
+      push_node (parser, MENU_LAYOUT_NODE_CATEGORY);
+    }
+  else if (ELEMENT_IS ("All"))
+    {
+      push_node (parser, MENU_LAYOUT_NODE_ALL);
+    }
+  else if (ELEMENT_IS ("And"))
+    {
+      push_node (parser, MENU_LAYOUT_NODE_AND);
+    }
+  else if (ELEMENT_IS ("Or"))
+    {
+      push_node (parser, MENU_LAYOUT_NODE_OR);
+    }
+  else if (ELEMENT_IS ("Not"))
+    {
+      push_node (parser, MENU_LAYOUT_NODE_NOT);
+    }
+  else
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
+                 "Element <%s> may not appear in this context\n",
+                 element_name);
+    }
+}
+
+static void
+start_move_child_element (MenuParser           *parser,
+                          GMarkupParseContext  *context,
+                          const char           *element_name,
+                          const char          **attribute_names,
+                          const char          **attribute_values,
+                          GError              **error)
+{
+  if (!check_no_attributes (context, element_name,
+                            attribute_names, attribute_values,
+                            error))
+    return;
+
+  if (ELEMENT_IS ("Old"))
+    {
+      push_node (parser, MENU_LAYOUT_NODE_OLD);
+    }
+  else if (ELEMENT_IS ("New"))
+    {
+      push_node (parser, MENU_LAYOUT_NODE_NEW);
+    }
+  else
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
+                 "Element <%s> may not appear below <%s>\n",
+                 element_name, "Move");
+    }
+}
+
+static void
+start_layout_child_element (MenuParser           *parser,
+                            GMarkupParseContext  *context,
+                            const char           *element_name,
+                            const char          **attribute_names,
+                            const char          **attribute_values,
+                            GError              **error)
+{
+  if (ELEMENT_IS ("Menuname"))
+    {
+      const char *show_empty;
+      const char *inline_menus;
+      const char *inline_limit;
+      const char *inline_header;
+      const char *inline_alias;
+
+      push_node (parser, MENU_LAYOUT_NODE_MENUNAME);
+
+      locate_attributes (context, element_name,
+                         attribute_names, attribute_values,
+                         error,
+                         "show_empty",    &show_empty,
+                         "inline",        &inline_menus,
+                         "inline_limit",  &inline_limit,
+                         "inline_header", &inline_header,
+                         "inline_alias",  &inline_alias,
+                         NULL);
+
+       menu_layout_node_menuname_set_values (parser->stack_top,
+					     show_empty,
+					     inline_menus,
+					     inline_limit,
+					     inline_header,
+					     inline_alias);
+    }
+  else if (ELEMENT_IS ("Merge"))
+    {
+        const char *type;
+
+        push_node (parser, MENU_LAYOUT_NODE_MERGE);
+
+        locate_attributes (context, element_name,
+                           attribute_names, attribute_values,
+                           error,
+                           "type", &type,
+                           NULL);
+
+	menu_layout_node_merge_set_type (parser->stack_top, type);
+    }
+  else
+    {
+      if (!check_no_attributes (context, element_name,
+                                attribute_names, attribute_values,
+                                error))
+        return;
+
+      if (ELEMENT_IS ("Filename"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_FILENAME);
+        }
+      else if (ELEMENT_IS ("Separator"))
+        {
+          push_node (parser, MENU_LAYOUT_NODE_SEPARATOR);
+        }
+      else
+        {
+          set_error (error, context,
+                     G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
+                     "Element <%s> may not appear below <%s>\n",
+                     element_name, "Move");
+        }
+    }
+}
+
+static void
+start_element_handler (GMarkupParseContext   *context,
+                       const char            *element_name,
+                       const char           **attribute_names,
+                       const char           **attribute_values,
+                       gpointer               user_data,
+                       GError               **error)
+{
+  MenuParser *parser = user_data;
+
+  if (ELEMENT_IS ("Menu"))
+    {
+      if (parser->stack_top == parser->root &&
+          has_child_of_type (parser->root, MENU_LAYOUT_NODE_MENU))
+        {
+          set_error (error, context,
+                     G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     "Multiple root elements in menu file, only one toplevel <Menu> is allowed\n");
+          return;
+        }
+
+      start_menu_element (parser, context, element_name,
+                          attribute_names, attribute_values,
+                          error);
+    }
+  else if (parser->stack_top == parser->root)
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 "Root element in a menu file must be <Menu>, not <%s>\n",
+                 element_name);
+    }
+  else if (parser->stack_top->type == MENU_LAYOUT_NODE_MENU)
+    {
+      start_menu_child_element (parser, context, element_name,
+                                attribute_names, attribute_values,
+                                error);
+    }
+  else if (parser->stack_top->type == MENU_LAYOUT_NODE_INCLUDE ||
+           parser->stack_top->type == MENU_LAYOUT_NODE_EXCLUDE ||
+           parser->stack_top->type == MENU_LAYOUT_NODE_AND     ||
+           parser->stack_top->type == MENU_LAYOUT_NODE_OR      ||
+           parser->stack_top->type == MENU_LAYOUT_NODE_NOT)
+    {
+      start_matching_rule_element (parser, context, element_name,
+                                   attribute_names, attribute_values,
+                                   error);
+    }
+  else if (parser->stack_top->type == MENU_LAYOUT_NODE_MOVE)
+    {
+      start_move_child_element (parser, context, element_name,
+                                attribute_names, attribute_values,
+                                error);
+    }
+  else if (parser->stack_top->type == MENU_LAYOUT_NODE_LAYOUT ||
+           parser->stack_top->type == MENU_LAYOUT_NODE_DEFAULT_LAYOUT)
+    {
+      start_layout_child_element (parser, context, element_name,
+                                  attribute_names, attribute_values,
+                                  error);
+    }
+  else
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_UNKNOWN_ELEMENT,
+                 "Element <%s> may not appear in this context\n",
+                 element_name);
+    }
+
+  add_context_to_error (error, context);
+}
+
+/* we want to make sure that the <Layout> or <DefaultLayout> is either empty,
+ * or contain one <Merge> of type "all", or contain one <Merge> of type "menus"
+ * and one <Merge> of type "files". If this is not the case, we try to clean up
+ * things:
+ *  + if there is at least one <Merge> of type "all", then we only keep the
+ *    last <Merge> of type "all" and remove all others <Merge>
+ *  + if there is no <Merge> with type "all", we keep only the last <Merge> of
+ *    type "menus" and the last <Merge> of type "files". If there's no <Merge>
+ *    of type "menus" we append one, and then if there's no <Merge> of type
+ *    "files", we append one. (So menus are before files)
+ */
+static gboolean
+fixup_layout_node (GMarkupParseContext   *context,
+                   MenuParser            *parser,
+                   MenuLayoutNode        *node,
+                   GError              **error)
+{
+  MenuLayoutNode *child;
+  MenuLayoutNode *last_all;
+  MenuLayoutNode *last_menus;
+  MenuLayoutNode *last_files;
+  int             n_all;
+  int             n_menus;
+  int             n_files;
+
+  if (!node->children)
+    {
+      return TRUE;
+    }
+
+  last_all   = NULL;
+  last_menus = NULL;
+  last_files = NULL;
+  n_all   = 0;
+  n_menus = 0;
+  n_files = 0;
+
+  child = node->children;
+  while (child != NULL)
+    {
+      switch (child->type)
+        {
+        case MENU_LAYOUT_NODE_MERGE:
+	  switch (menu_layout_node_merge_get_type (child))
+	    {
+	    case MENU_LAYOUT_MERGE_NONE:
+	      break;
+
+	    case MENU_LAYOUT_MERGE_MENUS:
+	      last_menus = child;
+	      n_menus++;
+	      break;
+
+	    case MENU_LAYOUT_MERGE_FILES:
+	      last_files = child;
+	      n_files++;
+	      break;
+
+	    case MENU_LAYOUT_MERGE_ALL:
+	      last_all = child;
+	      n_all++;
+	      break;
+
+	    default:
+	      g_assert_not_reached ();
+	      break;
+	    }
+          break;
+
+	  default:
+	    break;
+	}
+
+      child = node_next (child);
+    }
+
+  if ((n_all == 1 && n_menus == 0 && n_files == 0) ||
+      (n_all == 0 && n_menus == 1 && n_files == 1))
+    {
+      return TRUE;
+    }
+  else if (n_all > 1 || n_menus > 1 || n_files > 1 ||
+           (n_all == 1 && (n_menus != 0 || n_files != 0)))
+    {
+      child = node->children;
+      while (child != NULL)
+	{
+	  MenuLayoutNode *next;
+
+	  next = node_next (child);
+
+	  switch (child->type)
+	    {
+	    case MENU_LAYOUT_NODE_MERGE:
+	      switch (menu_layout_node_merge_get_type (child))
+		{
+		case MENU_LAYOUT_MERGE_NONE:
+		  break;
+
+		case MENU_LAYOUT_MERGE_MENUS:
+		  if (n_all || last_menus != child)
+		    {
+		      menu_verbose ("removing duplicated merge menus element\n");
+		      menu_layout_node_unlink (child);
+		    }
+		  break;
+
+		case MENU_LAYOUT_MERGE_FILES:
+		  if (n_all || last_files != child)
+		    {
+		      menu_verbose ("removing duplicated merge files element\n");
+		      menu_layout_node_unlink (child);
+		    }
+		  break;
+
+		case MENU_LAYOUT_MERGE_ALL:
+		  if (last_all != child)
+		    {
+		      menu_verbose ("removing duplicated merge all element\n");
+		      menu_layout_node_unlink (child);
+		    }
+		  break;
+
+		default:
+		  g_assert_not_reached ();
+		  break;
+		}
+	      break;
+
+	      default:
+		break;
+	    }
+
+	  child = next;
+	}
+    }
+
+  if (n_all == 0 && n_menus == 0)
+    {
+      last_menus = menu_layout_node_new (MENU_LAYOUT_NODE_MERGE);
+      menu_layout_node_merge_set_type (last_menus, "menus");
+      menu_verbose ("appending missing merge menus element\n");
+      menu_layout_node_append_child (node, last_menus);
+    }
+
+  if (n_all == 0 && n_files == 0)
+    {
+      last_files = menu_layout_node_new (MENU_LAYOUT_NODE_MERGE);
+      menu_layout_node_merge_set_type (last_files, "files");
+      menu_verbose ("appending missing merge files element\n");
+      menu_layout_node_append_child (node, last_files);
+    }
+
+  return TRUE;
+}
+
+/* we want to a) check that we have old-new pairs and b) canonicalize
+ * such that each <Move> has exactly one old-new pair
+ */
+static gboolean
+fixup_move_node (GMarkupParseContext   *context,
+                 MenuParser            *parser,
+                 MenuLayoutNode        *node,
+                 GError              **error)
+{
+  MenuLayoutNode *child;
+  int             n_old;
+  int             n_new;
+
+  n_old = 0;
+  n_new = 0;
+
+  child = node->children;
+  while (child != NULL)
+    {
+      switch (child->type)
+        {
+        case MENU_LAYOUT_NODE_OLD:
+          if (n_new != n_old)
+            {
+              set_error (error, context,
+                         G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         "<Old>/<New> elements not paired properly\n");
+              return FALSE;
+            }
+
+          n_old += 1;
+
+          break;
+
+        case MENU_LAYOUT_NODE_NEW:
+          n_new += 1;
+
+          if (n_new != n_old)
+            {
+              set_error (error, context,
+                         G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                         "<Old>/<New> elements not paired properly\n");
+              return FALSE;
+            }
+
+          break;
+
+        default:
+          g_assert_not_reached ();
+          break;
+        }
+
+      child = node_next (child);
+    }
+
+  if (n_new == 0 || n_old == 0)
+    {
+      set_error (error, context,
+                 G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                 "<Old>/<New> elements missing under <Move>\n");
+      return FALSE;
+    }
+
+  g_assert (n_new == n_old);
+  g_assert ((n_new + n_old) % 2 == 0);
+
+  if (n_new > 1)
+    {
+      MenuLayoutNode *prev;
+      MenuLayoutNode *append_after;
+
+      /* Need to split the <Move> into multiple <Move> */
+
+      n_old = 0;
+      n_new = 0;
+      prev = NULL;
+      append_after = node;
+
+      child = node->children;
+      while (child != NULL)
+        {
+          MenuLayoutNode *next;
+
+          next = node_next (child);
+
+          switch (child->type)
+            {
+            case MENU_LAYOUT_NODE_OLD:
+              n_old += 1;
+              break;
+
+            case MENU_LAYOUT_NODE_NEW:
+              n_new += 1;
+              break;
+
+            default:
+              g_assert_not_reached ();
+              break;
+            }
+
+          if (n_old == n_new &&
+              n_old > 1)
+            {
+              /* Move the just-completed pair */
+              MenuLayoutNode *new_move;
+
+              g_assert (prev != NULL);
+
+              new_move = menu_layout_node_new (MENU_LAYOUT_NODE_MOVE);
+              menu_verbose ("inserting new_move after append_after\n");
+              menu_layout_node_insert_after (append_after, new_move);
+              append_after = new_move;
+
+              menu_layout_node_steal (prev);
+              menu_layout_node_steal (child);
+
+              menu_verbose ("appending prev to new_move\n");
+              menu_layout_node_append_child (new_move, prev);
+              menu_verbose ("appending child to new_move\n");
+              menu_layout_node_append_child (new_move, child);
+
+              menu_verbose ("Created new move element old = %s new = %s\n",
+                            menu_layout_node_move_get_old (new_move),
+                            menu_layout_node_move_get_new (new_move));
+
+              menu_layout_node_unref (new_move);
+              menu_layout_node_unref (prev);
+              menu_layout_node_unref (child);
+
+              prev = NULL;
+            }
+          else
+            {
+              prev = child;
+            }
+
+          prev = child;
+          child = next;
+        }
+    }
+
+  return TRUE;
+}
+
+static void
+end_element_handler (GMarkupParseContext  *context,
+                     const char           *element_name,
+                     gpointer              user_data,
+                     GError              **error)
+{
+  MenuParser *parser = user_data;
+
+  g_assert (parser->stack_top != NULL);
+
+  switch (parser->stack_top->type)
+    {
+    case MENU_LAYOUT_NODE_APP_DIR:
+    case MENU_LAYOUT_NODE_DIRECTORY_DIR:
+    case MENU_LAYOUT_NODE_NAME:
+    case MENU_LAYOUT_NODE_DIRECTORY:
+    case MENU_LAYOUT_NODE_FILENAME:
+    case MENU_LAYOUT_NODE_CATEGORY:
+    case MENU_LAYOUT_NODE_MERGE_DIR:
+    case MENU_LAYOUT_NODE_LEGACY_DIR:
+    case MENU_LAYOUT_NODE_OLD:
+    case MENU_LAYOUT_NODE_NEW:
+    case MENU_LAYOUT_NODE_MENUNAME:
+      if (menu_layout_node_get_content (parser->stack_top) == NULL)
+        {
+          set_error (error, context,
+                     G_MARKUP_ERROR, G_MARKUP_ERROR_INVALID_CONTENT,
+                     "Element <%s> is required to contain text and was empty\n",
+                     element_name);
+          goto out;
+        }
+      break;
+
+    case MENU_LAYOUT_NODE_MENU:
+      if (!has_child_of_type (parser->stack_top, MENU_LAYOUT_NODE_NAME))
+        {
+          set_error (error, context,
+                     G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     "<Menu> elements are required to contain a <Name> element\n");
+          goto out;
+        }
+      break;
+
+    case MENU_LAYOUT_NODE_ROOT:
+    case MENU_LAYOUT_NODE_PASSTHROUGH:
+    case MENU_LAYOUT_NODE_DEFAULT_APP_DIRS:
+    case MENU_LAYOUT_NODE_DEFAULT_DIRECTORY_DIRS:
+    case MENU_LAYOUT_NODE_DEFAULT_MERGE_DIRS:
+    case MENU_LAYOUT_NODE_ONLY_UNALLOCATED:
+    case MENU_LAYOUT_NODE_NOT_ONLY_UNALLOCATED:
+    case MENU_LAYOUT_NODE_INCLUDE:
+    case MENU_LAYOUT_NODE_EXCLUDE:
+    case MENU_LAYOUT_NODE_ALL:
+    case MENU_LAYOUT_NODE_AND:
+    case MENU_LAYOUT_NODE_OR:
+    case MENU_LAYOUT_NODE_NOT:
+    case MENU_LAYOUT_NODE_KDE_LEGACY_DIRS:
+    case MENU_LAYOUT_NODE_DELETED:
+    case MENU_LAYOUT_NODE_NOT_DELETED:
+    case MENU_LAYOUT_NODE_SEPARATOR:
+    case MENU_LAYOUT_NODE_MERGE:
+    case MENU_LAYOUT_NODE_MERGE_FILE:
+      break;
+
+    case MENU_LAYOUT_NODE_LAYOUT:
+    case MENU_LAYOUT_NODE_DEFAULT_LAYOUT:
+      if (!fixup_layout_node (context, parser, parser->stack_top, error))
+        goto out;
+      break;
+
+    case MENU_LAYOUT_NODE_MOVE:
+      if (!fixup_move_node (context, parser, parser->stack_top, error))
+        goto out;
+      break;
+    }
+
+ out:
+  parser->stack_top = parser->stack_top->parent;
+}
+
+static gboolean
+all_whitespace (const char *text,
+                int         text_len)
+{
+  const char *p;
+  const char *end;
+
+  p = text;
+  end = text + text_len;
+
+  while (p != end)
+    {
+      if (!g_ascii_isspace (*p))
+        return FALSE;
+
+      p = g_utf8_next_char (p);
+    }
+
+  return TRUE;
+}
+
+static void
+text_handler (GMarkupParseContext  *context,
+              const char           *text,
+              gsize                 text_len,
+              gpointer              user_data,
+              GError              **error)
+{
+  MenuParser *parser = user_data;
+
+  switch (parser->stack_top->type)
+    {
+    case MENU_LAYOUT_NODE_APP_DIR:
+    case MENU_LAYOUT_NODE_DIRECTORY_DIR:
+    case MENU_LAYOUT_NODE_NAME:
+    case MENU_LAYOUT_NODE_DIRECTORY:
+    case MENU_LAYOUT_NODE_FILENAME:
+    case MENU_LAYOUT_NODE_CATEGORY:
+    case MENU_LAYOUT_NODE_MERGE_FILE:
+    case MENU_LAYOUT_NODE_MERGE_DIR:
+    case MENU_LAYOUT_NODE_LEGACY_DIR:
+    case MENU_LAYOUT_NODE_OLD:
+    case MENU_LAYOUT_NODE_NEW:
+    case MENU_LAYOUT_NODE_MENUNAME:
+      g_assert (menu_layout_node_get_content (parser->stack_top) == NULL);
+
+      menu_layout_node_set_content (parser->stack_top, text);
+      break;
+
+    case MENU_LAYOUT_NODE_ROOT:
+    case MENU_LAYOUT_NODE_PASSTHROUGH:
+    case MENU_LAYOUT_NODE_MENU:
+    case MENU_LAYOUT_NODE_DEFAULT_APP_DIRS:
+    case MENU_LAYOUT_NODE_DEFAULT_DIRECTORY_DIRS:
+    case MENU_LAYOUT_NODE_DEFAULT_MERGE_DIRS:
+    case MENU_LAYOUT_NODE_ONLY_UNALLOCATED:
+    case MENU_LAYOUT_NODE_NOT_ONLY_UNALLOCATED:
+    case MENU_LAYOUT_NODE_INCLUDE:
+    case MENU_LAYOUT_NODE_EXCLUDE:
+    case MENU_LAYOUT_NODE_ALL:
+    case MENU_LAYOUT_NODE_AND:
+    case MENU_LAYOUT_NODE_OR:
+    case MENU_LAYOUT_NODE_NOT:
+    case MENU_LAYOUT_NODE_KDE_LEGACY_DIRS:
+    case MENU_LAYOUT_NODE_MOVE:
+    case MENU_LAYOUT_NODE_DELETED:
+    case MENU_LAYOUT_NODE_NOT_DELETED:
+    case MENU_LAYOUT_NODE_LAYOUT:
+    case MENU_LAYOUT_NODE_DEFAULT_LAYOUT:
+    case MENU_LAYOUT_NODE_SEPARATOR:
+    case MENU_LAYOUT_NODE_MERGE:
+      if (!all_whitespace (text, text_len))
+        {
+          set_error (error, context,
+                     G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                     "No text is allowed inside element <%s>",
+                     g_markup_parse_context_get_element (context));
+        }
+      break;
+    }
+
+  add_context_to_error (error, context);
+}
+
+static void
+passthrough_handler (GMarkupParseContext  *context,
+                     const char           *passthrough_text,
+                     gsize                 text_len,
+                     gpointer              user_data,
+                     GError              **error)
+{
+  MenuParser *parser = user_data;
+  MenuLayoutNode *node;
+
+  /* don't push passthrough on the stack, it's not an element */
+
+  node = menu_layout_node_new (MENU_LAYOUT_NODE_PASSTHROUGH);
+  menu_layout_node_set_content (node, passthrough_text);
+
+  menu_layout_node_append_child (parser->stack_top, node);
+  menu_layout_node_unref (node);
+
+  add_context_to_error (error, context);
+}
+
+static void
+menu_parser_init (MenuParser *parser)
+{
+  parser->root = menu_layout_node_new (MENU_LAYOUT_NODE_ROOT);
+  parser->stack_top = parser->root;
+}
+
+static void
+menu_parser_free (MenuParser *parser)
+{
+  if (parser->root)
+    menu_layout_node_unref (parser->root);
+}
+
+MenuLayoutNode *
+menu_layout_load (const char  *filename,
+                  const char  *non_prefixed_basename,
+                  GError     **err)
+{
+  GMarkupParseContext *context;
+  MenuLayoutNodeRoot  *root;
+  MenuLayoutNode      *retval;
+  MenuParser           parser;
+  GError              *error;
+  GString             *str;
+  char                *text;
+  char                *s;
+  gsize                length;
+
+  text = NULL;
+  length = 0;
+  retval = NULL;
+  context = NULL;
+
+  menu_verbose ("Loading \"%s\" from disk\n", filename);
+
+  if (!g_file_get_contents (filename,
+                            &text,
+                            &length,
+                            err))
+    {
+      menu_verbose ("Failed to load \"%s\"\n",
+                    filename);
+      return NULL;
+    }
+
+  g_assert (text != NULL);
+
+  menu_parser_init (&parser);
+
+  root = (MenuLayoutNodeRoot *) parser.root;
+
+  root->basedir = g_path_get_dirname (filename);
+  menu_verbose ("Set basedir \"%s\"\n", root->basedir);
+
+  if (non_prefixed_basename)
+    s = g_strdup (non_prefixed_basename);
+  else
+    s = g_path_get_basename (filename);
+  str = g_string_new (s);
+  if (g_str_has_suffix (str->str, ".menu"))
+    g_string_truncate (str, str->len - strlen (".menu"));
+
+  root->name = str->str;
+  menu_verbose ("Set menu name \"%s\"\n", root->name);
+
+  g_string_free (str, FALSE);
+  g_free (s);
+
+  context = g_markup_parse_context_new (&menu_funcs, 0, &parser, NULL);
+
+  error = NULL;
+  if (!g_markup_parse_context_parse (context,
+                                     text,
+                                     length,
+                                     &error))
+    goto out;
+
+  error = NULL;
+  g_markup_parse_context_end_parse (context, &error);
+
+ out:
+  if (context)
+    g_markup_parse_context_free (context);
+  g_free (text);
+
+  if (error)
+    {
+      menu_verbose ("Error \"%s\" loading \"%s\"\n",
+                    error->message, filename);
+      g_propagate_error (err, error);
+    }
+  else if (has_child_of_type (parser.root, MENU_LAYOUT_NODE_MENU))
+    {
+      menu_verbose ("File loaded OK\n");
+      retval = parser.root;
+      parser.root = NULL;
+    }
+  else
+    {
+      menu_verbose ("Did not have a root element in file\n");
+      g_set_error (err, G_MARKUP_ERROR, G_MARKUP_ERROR_PARSE,
+                   "Menu file %s did not contain a root <Menu> element",
+                   filename);
+    }
+
+  menu_parser_free (&parser);
+
+  return retval;
+}
diff --git a/libmenu/menu-layout.h b/libmenu/menu-layout.h
new file mode 100644
index 0000000..4b63014
--- /dev/null
+++ b/libmenu/menu-layout.h
@@ -0,0 +1,161 @@
+/* Menu layout in-memory data structure (a custom "DOM tree") */
+
+/*
+ * Copyright (C) 2002 - 2004 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __MENU_LAYOUT_H__
+#define __MENU_LAYOUT_H__
+
+#include <glib.h>
+
+#include "entry-directories.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct MenuLayoutNode MenuLayoutNode;
+
+typedef enum {
+	MENU_LAYOUT_NODE_ROOT,
+	MENU_LAYOUT_NODE_PASSTHROUGH,
+	MENU_LAYOUT_NODE_MENU,
+	MENU_LAYOUT_NODE_APP_DIR,
+	MENU_LAYOUT_NODE_DEFAULT_APP_DIRS,
+	MENU_LAYOUT_NODE_DIRECTORY_DIR,
+	MENU_LAYOUT_NODE_DEFAULT_DIRECTORY_DIRS,
+	MENU_LAYOUT_NODE_DEFAULT_MERGE_DIRS,
+	MENU_LAYOUT_NODE_NAME,
+	MENU_LAYOUT_NODE_DIRECTORY,
+	MENU_LAYOUT_NODE_ONLY_UNALLOCATED,
+	MENU_LAYOUT_NODE_NOT_ONLY_UNALLOCATED,
+	MENU_LAYOUT_NODE_INCLUDE,
+	MENU_LAYOUT_NODE_EXCLUDE,
+	MENU_LAYOUT_NODE_FILENAME,
+	MENU_LAYOUT_NODE_CATEGORY,
+	MENU_LAYOUT_NODE_ALL,
+	MENU_LAYOUT_NODE_AND,
+	MENU_LAYOUT_NODE_OR,
+	MENU_LAYOUT_NODE_NOT,
+	MENU_LAYOUT_NODE_MERGE_FILE,
+	MENU_LAYOUT_NODE_MERGE_DIR,
+	MENU_LAYOUT_NODE_LEGACY_DIR,
+	MENU_LAYOUT_NODE_KDE_LEGACY_DIRS,
+	MENU_LAYOUT_NODE_MOVE,
+	MENU_LAYOUT_NODE_OLD,
+	MENU_LAYOUT_NODE_NEW,
+	MENU_LAYOUT_NODE_DELETED,
+	MENU_LAYOUT_NODE_NOT_DELETED,
+	MENU_LAYOUT_NODE_LAYOUT,
+	MENU_LAYOUT_NODE_DEFAULT_LAYOUT,
+	MENU_LAYOUT_NODE_MENUNAME,
+	MENU_LAYOUT_NODE_SEPARATOR,
+	MENU_LAYOUT_NODE_MERGE
+} MenuLayoutNodeType;
+
+typedef enum {
+	MENU_MERGE_FILE_TYPE_PATH = 0,
+	MENU_MERGE_FILE_TYPE_PARENT
+} MenuMergeFileType;
+
+typedef enum {
+	MENU_LAYOUT_MERGE_NONE,
+	MENU_LAYOUT_MERGE_MENUS,
+	MENU_LAYOUT_MERGE_FILES,
+	MENU_LAYOUT_MERGE_ALL
+} MenuLayoutMergeType;
+
+typedef enum {
+	MENU_LAYOUT_VALUES_NONE          = 0,
+	MENU_LAYOUT_VALUES_SHOW_EMPTY    = 1 << 0,
+	MENU_LAYOUT_VALUES_INLINE_MENUS  = 1 << 1,
+	MENU_LAYOUT_VALUES_INLINE_LIMIT  = 1 << 2,
+	MENU_LAYOUT_VALUES_INLINE_HEADER = 1 << 3,
+	MENU_LAYOUT_VALUES_INLINE_ALIAS  = 1 << 4
+} MenuLayoutValuesMask;
+
+typedef struct {
+	MenuLayoutValuesMask mask;
+
+	guint show_empty: 1;
+	guint inline_menus: 1;
+	guint inline_header: 1;
+	guint inline_alias: 1;
+
+	guint inline_limit;
+} MenuLayoutValues;
+
+
+MenuLayoutNode *menu_layout_load (const char* filename, const char  *non_prefixed_basename, GError** error);
+
+MenuLayoutNode *menu_layout_node_new   (MenuLayoutNodeType  type);
+MenuLayoutNode *menu_layout_node_ref   (MenuLayoutNode     *node);
+void            menu_layout_node_unref (MenuLayoutNode     *node);
+
+MenuLayoutNodeType menu_layout_node_get_type (MenuLayoutNode *node);
+
+MenuLayoutNode *menu_layout_node_get_root     (MenuLayoutNode *node);
+MenuLayoutNode *menu_layout_node_get_parent   (MenuLayoutNode *node);
+MenuLayoutNode *menu_layout_node_get_children (MenuLayoutNode *node);
+MenuLayoutNode *menu_layout_node_get_next     (MenuLayoutNode *node);
+
+void menu_layout_node_insert_before (MenuLayoutNode *node, MenuLayoutNode *new_sibling);
+void menu_layout_node_insert_after  (MenuLayoutNode *node, MenuLayoutNode *new_sibling);
+void menu_layout_node_prepend_child (MenuLayoutNode *parent, MenuLayoutNode *new_child);
+void menu_layout_node_append_child  (MenuLayoutNode *parent, MenuLayoutNode *new_child);
+
+void menu_layout_node_unlink (MenuLayoutNode *node);
+void menu_layout_node_steal  (MenuLayoutNode *node);
+
+const char *menu_layout_node_get_content (MenuLayoutNode *node);
+void        menu_layout_node_set_content (MenuLayoutNode *node, const char     *content);
+
+char *menu_layout_node_get_content_as_path (MenuLayoutNode *node);
+
+const char *menu_layout_node_root_get_name    (MenuLayoutNode *node);
+const char *menu_layout_node_root_get_basedir (MenuLayoutNode *node);
+
+const char         *menu_layout_node_menu_get_name           (MenuLayoutNode *node);
+EntryDirectoryList *menu_layout_node_menu_get_app_dirs       (MenuLayoutNode *node);
+EntryDirectoryList *menu_layout_node_menu_get_directory_dirs (MenuLayoutNode *node);
+
+const char *menu_layout_node_move_get_old (MenuLayoutNode *node);
+const char *menu_layout_node_move_get_new (MenuLayoutNode *node);
+
+const char *menu_layout_node_legacy_dir_get_prefix (MenuLayoutNode *node);
+void        menu_layout_node_legacy_dir_set_prefix (MenuLayoutNode *node, const char     *prefix);
+
+MenuMergeFileType menu_layout_node_merge_file_get_type (MenuLayoutNode    *node);
+void              menu_layout_node_merge_file_set_type (MenuLayoutNode    *node, MenuMergeFileType  type);
+
+MenuLayoutMergeType menu_layout_node_merge_get_type (MenuLayoutNode *node);
+
+void menu_layout_node_default_layout_get_values (MenuLayoutNode   *node, MenuLayoutValues *values);
+void menu_layout_node_menuname_get_values       (MenuLayoutNode   *node, MenuLayoutValues *values);
+
+typedef void (*MenuLayoutNodeEntriesChangedFunc) (MenuLayoutNode* node, gpointer user_data);
+
+void menu_layout_node_root_add_entries_monitor    (MenuLayoutNode* node, MenuLayoutNodeEntriesChangedFunc callback, gpointer user_data);
+void menu_layout_node_root_remove_entries_monitor (MenuLayoutNode* node, MenuLayoutNodeEntriesChangedFunc callback, gpointer user_data);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MENU_LAYOUT_H__ */
diff --git a/libmenu/menu-monitor.c b/libmenu/menu-monitor.c
new file mode 100644
index 0000000..ff36010
--- /dev/null
+++ b/libmenu/menu-monitor.c
@@ -0,0 +1,440 @@
+/*
+ * Copyright (C) 2005 Red Hat, Inc.
+ * Copyright (C) 2006 Mark McLoughlin
+ * Copyright (C) 2007 Sebastian Dröge
+ * Copyright (C) 2008 Vincent Untz
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "menu-monitor.h"
+
+#include <gio/gio.h>
+
+#include "menu-util.h"
+
+struct MenuMonitor {
+	char* path;
+	guint refcount;
+
+	GSList* notifies;
+
+	GFileMonitor* monitor;
+
+	guint is_directory: 1;
+};
+
+typedef struct {
+	MenuMonitor* monitor;
+	MenuMonitorEvent event;
+	char* path;
+} MenuMonitorEventInfo;
+
+typedef struct {
+	MenuMonitorNotifyFunc notify_func;
+	gpointer user_data;
+	guint refcount;
+} MenuMonitorNotify;
+
+static MenuMonitorNotify* mate_menu_monitor_notify_ref(MenuMonitorNotify* notify);
+static void mate_menu_monitor_notify_unref(MenuMonitorNotify* notify);
+
+static GHashTable* monitors_registry = NULL;
+static guint events_idle_handler = 0;
+static GSList* pending_events = NULL;
+
+static void invoke_notifies(MenuMonitor* monitor, MenuMonitorEvent  event, const char* path)
+{
+  GSList *copy;
+  GSList *tmp;
+
+  copy = g_slist_copy (monitor->notifies);
+  g_slist_foreach (copy,
+		   (GFunc) mate_menu_monitor_notify_ref,
+		   NULL);
+
+  tmp = copy;
+  while (tmp != NULL)
+    {
+      MenuMonitorNotify *notify = tmp->data;
+      GSList            *next   = tmp->next;
+
+      if (notify->notify_func)
+	{
+	  notify->notify_func (monitor, event, path, notify->user_data);
+	}
+
+      mate_menu_monitor_notify_unref(notify);
+
+      tmp = next;
+    }
+
+  g_slist_free (copy);
+}
+
+static gboolean emit_events_in_idle(void)
+{
+  GSList *events_to_emit;
+  GSList *tmp;
+
+  events_to_emit = pending_events;
+
+  pending_events = NULL;
+  events_idle_handler = 0;
+
+  tmp = events_to_emit;
+  while (tmp != NULL)
+    {
+      MenuMonitorEventInfo *event_info = tmp->data;
+
+      mate_menu_monitor_ref(event_info->monitor);
+
+      tmp = tmp->next;
+    }
+
+  tmp = events_to_emit;
+  while (tmp != NULL)
+    {
+      MenuMonitorEventInfo *event_info = tmp->data;
+
+      invoke_notifies (event_info->monitor,
+		       event_info->event,
+		       event_info->path);
+
+      menu_monitor_unref (event_info->monitor);
+      event_info->monitor = NULL;
+
+      g_free (event_info->path);
+      event_info->path = NULL;
+
+      event_info->event = MENU_MONITOR_EVENT_INVALID;
+
+      g_free (event_info);
+
+      tmp = tmp->next;
+    }
+
+  g_slist_free (events_to_emit);
+
+  return FALSE;
+}
+
+static void menu_monitor_queue_event(MenuMonitorEventInfo* event_info)
+{
+  pending_events = g_slist_append (pending_events, event_info);
+
+  if (events_idle_handler == 0)
+    {
+      events_idle_handler = g_idle_add ((GSourceFunc) emit_events_in_idle, NULL);
+    }
+}
+
+static inline char* get_registry_key(const char* path, gboolean is_directory)
+{
+  return g_strdup_printf ("%s:%s",
+			  path,
+			  is_directory ? "<dir>" : "<file>");
+}
+
+static gboolean monitor_callback (GFileMonitor* monitor, GFile* child, GFile* other_file, GFileMonitorEvent eflags, gpointer user_data)
+{
+  MenuMonitorEventInfo *event_info;
+  MenuMonitorEvent      event;
+  MenuMonitor          *menu_monitor = (MenuMonitor *) user_data;
+
+  event = MENU_MONITOR_EVENT_INVALID;
+  switch (eflags)
+    {
+    case G_FILE_MONITOR_EVENT_CHANGED:
+      event = MENU_MONITOR_EVENT_CHANGED;
+      break;
+    case G_FILE_MONITOR_EVENT_CREATED:
+      event = MENU_MONITOR_EVENT_CREATED;
+      break;
+    case G_FILE_MONITOR_EVENT_DELETED:
+      event = MENU_MONITOR_EVENT_DELETED;
+      break;
+    default:
+      return TRUE;
+    }
+
+  event_info = g_new0 (MenuMonitorEventInfo, 1);
+
+  event_info->path    = g_file_get_path (child);
+  event_info->event   = event;
+  event_info->monitor = menu_monitor;
+
+  menu_monitor_queue_event (event_info);
+
+  return TRUE;
+}
+
+static MenuMonitor* register_monitor(const char* path, gboolean is_directory)
+{
+  static gboolean  initted = FALSE;
+  MenuMonitor     *retval;
+  GFile           *file;
+
+  if (!initted)
+    {
+      /* This is the only place where we're using GObject and the app can't
+       * know we're using it, so we need to init the type system ourselves. */
+      g_type_init ();
+      initted = TRUE;
+    }
+
+  retval = g_new0 (MenuMonitor, 1);
+
+  retval->path         = g_strdup (path);
+  retval->refcount     = 1;
+  retval->is_directory = is_directory != FALSE;
+
+  file = g_file_new_for_path (retval->path);
+
+  if (file == NULL)
+    {
+      menu_verbose ("Not adding monitor on '%s', failed to create GFile\n",
+                    retval->path);
+      return retval;
+    }
+
+  if (retval->is_directory)
+      retval->monitor = g_file_monitor_directory (file, G_FILE_MONITOR_NONE,
+                                                  NULL, NULL);
+  else
+      retval->monitor = g_file_monitor_file (file, G_FILE_MONITOR_NONE,
+                                             NULL, NULL);
+
+  g_object_unref (G_OBJECT (file));
+
+  if (retval->monitor == NULL)
+    {
+      menu_verbose ("Not adding monitor on '%s', failed to create monitor\n",
+                    retval->path);
+      return retval;
+    }
+
+  g_signal_connect (retval->monitor, "changed",
+                    G_CALLBACK (monitor_callback), retval);
+
+  return retval;
+}
+
+static MenuMonitor* lookup_monitor(const char* path, gboolean is_directory)
+{
+  MenuMonitor *retval;
+  char        *registry_key;
+
+  retval = NULL;
+
+  registry_key = get_registry_key (path, is_directory);
+
+  if (monitors_registry == NULL)
+    {
+      monitors_registry = g_hash_table_new_full (g_str_hash,
+						 g_str_equal,
+						 g_free,
+						 NULL);
+    }
+  else
+    {
+      retval = g_hash_table_lookup (monitors_registry, registry_key);
+    }
+
+  if (retval == NULL)
+    {
+      retval = register_monitor (path, is_directory);
+      g_hash_table_insert (monitors_registry, registry_key, retval);
+
+      return retval;
+    }
+  else
+    {
+      g_free (registry_key);
+
+      return mate_menu_monitor_ref(retval);
+    }
+}
+
+MenuMonitor* mate_menu_monitor_file_get(const char* path)
+{
+	g_return_val_if_fail(path != NULL, NULL);
+
+	return lookup_monitor(path, FALSE);
+}
+
+MenuMonitor* menu_get_directory_monitor(const char* path)
+{
+  g_return_val_if_fail (path != NULL, NULL);
+
+  return lookup_monitor (path, TRUE);
+}
+
+MenuMonitor* mate_menu_monitor_ref(MenuMonitor* monitor)
+{
+	g_return_val_if_fail(monitor != NULL, NULL);
+	g_return_val_if_fail(monitor->refcount > 0, NULL);
+
+	monitor->refcount++;
+
+	return monitor;
+}
+
+static void menu_monitor_clear_pending_events(MenuMonitor* monitor)
+{
+  GSList *tmp;
+
+  tmp = pending_events;
+  while (tmp != NULL)
+    {
+      MenuMonitorEventInfo *event_info = tmp->data;
+      GSList               *next = tmp->next;
+
+      if (event_info->monitor == monitor)
+	{
+	  pending_events = g_slist_delete_link (pending_events, tmp);
+
+	  g_free (event_info->path);
+	  event_info->path = NULL;
+
+	  event_info->monitor = NULL;
+	  event_info->event   = MENU_MONITOR_EVENT_INVALID;
+
+	  g_free (event_info);
+	}
+
+      tmp = next;
+    }
+}
+
+void menu_monitor_unref(MenuMonitor* monitor)
+{
+  char *registry_key;
+
+  g_return_if_fail (monitor != NULL);
+  g_return_if_fail (monitor->refcount > 0);
+
+  if (--monitor->refcount > 0)
+    return;
+
+  registry_key = get_registry_key (monitor->path, monitor->is_directory);
+  g_hash_table_remove (monitors_registry, registry_key);
+  g_free (registry_key);
+
+  if (g_hash_table_size (monitors_registry) == 0)
+    {
+      g_hash_table_destroy (monitors_registry);
+      monitors_registry = NULL;
+    }
+
+  if (monitor->monitor)
+    {
+      g_file_monitor_cancel (monitor->monitor);
+      g_object_unref (monitor->monitor);
+      monitor->monitor = NULL;
+    }
+
+  g_slist_foreach (monitor->notifies, (GFunc) mate_menu_monitor_notify_unref, NULL);
+  g_slist_free (monitor->notifies);
+  monitor->notifies = NULL;
+
+  menu_monitor_clear_pending_events (monitor);
+
+  g_free (monitor->path);
+  monitor->path = NULL;
+
+  g_free (monitor);
+}
+
+static MenuMonitorNotify* mate_menu_monitor_notify_ref(MenuMonitorNotify* notify)
+{
+	g_return_val_if_fail(notify != NULL, NULL);
+	g_return_val_if_fail(notify->refcount > 0, NULL);
+
+	notify->refcount++;
+
+	return notify;
+}
+
+static void mate_menu_monitor_notify_unref(MenuMonitorNotify* notify)
+{
+	g_return_if_fail(notify != NULL);
+	g_return_if_fail(notify->refcount > 0);
+
+	if (--notify->refcount > 0)
+	{
+		return;
+	}
+
+	g_free(notify);
+}
+
+void menu_monitor_add_notify(MenuMonitor* monitor, MenuMonitorNotifyFunc notify_func, gpointer user_data)
+{
+	MenuMonitorNotify* notify;
+
+	g_return_if_fail(monitor != NULL);
+	g_return_if_fail(notify_func != NULL);
+
+	GSList* tmp = monitor->notifies;
+
+	while (tmp != NULL)
+	{
+		notify = tmp->data;
+
+		if (notify->notify_func == notify_func && notify->user_data == user_data)
+		{
+			break;
+		}
+
+		tmp = tmp->next;
+	}
+
+	if (tmp == NULL)
+	{
+		notify = g_new0(MenuMonitorNotify, 1);
+		notify->notify_func = notify_func;
+		notify->user_data = user_data;
+		notify->refcount = 1;
+
+		monitor->notifies = g_slist_append(monitor->notifies, notify);
+	}
+}
+
+void mate_menu_monitor_notify_remove(MenuMonitor* monitor, MenuMonitorNotifyFunc notify_func, gpointer user_data)
+{
+	GSList* tmp = monitor->notifies;
+
+	while (tmp != NULL)
+	{
+		MenuMonitorNotify* notify = tmp->data;
+		GSList* next = tmp->next;
+
+		if (notify->notify_func == notify_func && notify->user_data == user_data)
+		{
+			notify->notify_func = NULL;
+			notify->user_data = NULL;
+
+			mate_menu_monitor_notify_unref(notify);
+
+			monitor->notifies = g_slist_delete_link(monitor->notifies, tmp);
+		}
+
+		tmp = next;
+	}
+}
diff --git a/libmenu/menu-monitor.h b/libmenu/menu-monitor.h
new file mode 100644
index 0000000..1dbf6ba
--- /dev/null
+++ b/libmenu/menu-monitor.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2005 Red Hat, Inc.
+ * Copyright (C) 2011 Perberos
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __MENU_MONITOR_H__
+#define __MENU_MONITOR_H__
+
+#include <glib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+typedef struct MenuMonitor MenuMonitor;
+
+typedef enum {
+	MENU_MONITOR_EVENT_INVALID = 0,
+	MENU_MONITOR_EVENT_CREATED = 1,
+	MENU_MONITOR_EVENT_DELETED = 2,
+	MENU_MONITOR_EVENT_CHANGED = 3
+} MenuMonitorEvent;
+
+typedef void (*MenuMonitorNotifyFunc) (MenuMonitor* monitor, MenuMonitorEvent event, const char* path, gpointer user_data);
+
+
+MenuMonitor* menu_get_file_monitor(const char* path);
+MenuMonitor* menu_get_directory_monitor(const char* path);
+
+MenuMonitor* menu_monitor_ref(MenuMonitor* monitor);
+void menu_monitor_unref(MenuMonitor* monitor);
+
+void menu_monitor_add_notify(MenuMonitor* monitor, MenuMonitorNotifyFunc notify_func, gpointer user_data);
+void menu_monitor_remove_notify(MenuMonitor* monitor, MenuMonitorNotifyFunc notify_func, gpointer user_data);
+
+
+/* Izquierda a derecha
+ */
+
+#define mate_menu_monitor_file_get       menu_get_file_monitor
+#define mate_menu_monitor_directory_get  menu_get_directory_monitor
+
+#define mate_menu_monitor_ref    menu_monitor_ref
+#define mate_menu_monitor_unref  menu_monitor_unref
+
+#define mate_menu_monitor_notify_add     menu_monitor_add_notify
+#define mate_menu_monitor_notify_remove  menu_monitor_remove_notify
+#define mate_menu_monitor_notify_ref     menu_monitor_notify_ref /* private */
+#define mate_menu_monitor_notify_unref   menu_monitor_notify_unref /* private */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MENU_MONITOR_H__ */
diff --git a/libmenu/menu-util.c b/libmenu/menu-util.c
new file mode 100644
index 0000000..2f992b0
--- /dev/null
+++ b/libmenu/menu-util.c
@@ -0,0 +1,436 @@
+/* Random utility functions for menu code */
+
+/*
+ * Copyright (C) 2003 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#include <config.h>
+
+#include "menu-util.h"
+
+#include <stdio.h>
+#include <stdarg.h>
+
+
+#ifdef G_ENABLE_DEBUG
+
+static gboolean verbose = FALSE;
+static gboolean initted = FALSE;
+
+static inline gboolean menu_verbose_enabled(void)
+{
+	if (!initted)
+	{
+		verbose = g_getenv("MENU_VERBOSE") != NULL;
+		initted = TRUE;
+	}
+
+	return verbose;
+}
+
+static int utf8_fputs(const char* str, FILE* f)
+{
+	char* l;
+	int ret;
+
+	l = g_locale_from_utf8(str, -1, NULL, NULL, NULL);
+
+	if (l == NULL)
+	{
+		ret = fputs(str, f); /* just print it anyway, better than nothing */
+	}
+	else
+	{
+		ret = fputs(l, f);
+	}
+
+	g_free(l);
+
+	return ret;
+}
+
+void menu_verbose(const char* format, ...)
+{
+	va_list args;
+	char* str;
+
+	if (!menu_verbose_enabled())
+	{
+		return;
+	}
+
+	va_start(args, format);
+	str = g_strdup_vprintf(format, args);
+	va_end(args);
+
+	utf8_fputs(str, stderr);
+	fflush(stderr);
+
+	g_free(str);
+}
+
+static void append_to_string(MenuLayoutNode* node, gboolean onelevel, int depth, GString* str);
+
+static void append_spaces(GString* str, int depth)
+{
+	while (depth > 0)
+	{
+		g_string_append_c(str, ' ');
+		--depth;
+	}
+}
+
+static void append_children(MenuLayoutNode* node, int depth, GString* str)
+{
+	MenuLayoutNode* iter;
+
+	iter = menu_layout_node_get_children(node);
+
+	while (iter != NULL)
+	{
+		append_to_string(iter, FALSE, depth, str);
+
+		iter = menu_layout_node_get_next(iter);
+	}
+}
+
+static void append_simple_with_attr(MenuLayoutNode* node, int depth, const char* node_name, const char* attr_name, const char* attr_value, GString* str)
+{
+	const char* content;
+
+	append_spaces(str, depth);
+
+	if ((content = menu_layout_node_get_content(node)))
+	{
+		char* escaped;
+
+		escaped = g_markup_escape_text(content, -1);
+
+		if (attr_name && attr_value)
+		{
+			char* attr_escaped;
+
+			attr_escaped = g_markup_escape_text(attr_value, -1);
+
+			g_string_append_printf(str, "<%s %s=\"%s\">%s</%s>\n", node_name, attr_name, attr_escaped, escaped, node_name);
+
+			g_free(attr_escaped);
+		}
+		else
+		{
+			g_string_append_printf(str, "<%s>%s</%s>\n", node_name, escaped, node_name);
+		}
+
+		g_free(escaped);
+	}
+	else
+	{
+		if (attr_name && attr_value)
+		{
+			char* attr_escaped;
+
+			attr_escaped = g_markup_escape_text(attr_value, -1);
+
+			g_string_append_printf(str, "<%s %s=\"%s\"/>\n", node_name, attr_name, attr_escaped);
+
+			g_free(attr_escaped);
+		}
+		else
+		{
+			g_string_append_printf(str, "<%s/>\n", node_name);
+		}
+	}
+}
+
+static void append_layout(MenuLayoutNode* node, int depth, const char* node_name, MenuLayoutValues* layout_values, GString* str)
+{
+	const char* content;
+
+	append_spaces(str, depth);
+
+	if ((content = menu_layout_node_get_content(node)))
+	{
+		char* escaped;
+
+		escaped = g_markup_escape_text(content, -1);
+
+		g_string_append_printf(str,
+			"<%s show_empty=\"%s\" inline=\"%s\" inline_header=\"%s\""
+			" inline_alias=\"%s\" inline_limit=\"%d\">%s</%s>\n",
+			node_name,
+			layout_values->show_empty    ? "true" : "false",
+			layout_values->inline_menus  ? "true" : "false",
+			layout_values->inline_header ? "true" : "false",
+			layout_values->inline_alias  ? "true" : "false",
+			layout_values->inline_limit,
+			escaped,
+			node_name);
+
+		g_free(escaped);
+	}
+	else
+	{
+	  g_string_append_printf(str,
+		"<%s show_empty=\"%s\" inline=\"%s\" inline_header=\"%s\""
+		" inline_alias=\"%s\" inline_limit=\"%d\"/>\n",
+		node_name,
+		layout_values->show_empty    ? "true" : "false",
+		layout_values->inline_menus  ? "true" : "false",
+		layout_values->inline_header ? "true" : "false",
+		layout_values->inline_alias  ? "true" : "false",
+		layout_values->inline_limit);
+	}
+}
+
+static void append_merge(MenuLayoutNode* node, int depth, const char* node_name, MenuLayoutMergeType merge_type, GString* str)
+{
+	const char* merge_type_str;
+
+	merge_type_str = NULL;
+
+	switch (merge_type)
+	{
+		case MENU_LAYOUT_MERGE_NONE:
+			merge_type_str = "none";
+			break;
+
+		case MENU_LAYOUT_MERGE_MENUS:
+			merge_type_str = "menus";
+			break;
+
+		case MENU_LAYOUT_MERGE_FILES:
+			merge_type_str = "files";
+			break;
+
+		case MENU_LAYOUT_MERGE_ALL:
+			merge_type_str = "all";
+			break;
+
+		default:
+			g_assert_not_reached();
+			break;
+	}
+
+	append_simple_with_attr(node, depth, node_name, "type", merge_type_str, str);
+}
+
+static void append_simple(MenuLayoutNode* node, int depth, const char* node_name, GString* str)
+{
+	append_simple_with_attr(node, depth, node_name, NULL, NULL, str);
+}
+
+static void append_start(MenuLayoutNode* node, int depth, const char* node_name, GString* str)
+{
+	append_spaces(str, depth);
+
+	g_string_append_printf(str, "<%s>\n", node_name);
+}
+
+static void append_end(MenuLayoutNode* node, int depth, const char* node_name, GString* str)
+{
+	append_spaces(str, depth);
+
+	g_string_append_printf(str, "</%s>\n", node_name);
+}
+
+static void append_container(MenuLayoutNode* node, gboolean onelevel, int depth, const char* node_name, GString* str)
+{
+	append_start(node, depth, node_name, str);
+
+	if (!onelevel)
+	{
+		append_children(node, depth + 2, str);
+		append_end(node, depth, node_name, str);
+	}
+}
+
+static void append_to_string(MenuLayoutNode* node, gboolean onelevel, int depth, GString* str)
+{
+	MenuLayoutValues layout_values;
+
+	switch (menu_layout_node_get_type(node))
+	{
+		case MENU_LAYOUT_NODE_ROOT:
+			if (!onelevel)
+				append_children(node, depth - 1, str); /* -1 to ignore depth of root */
+			else
+			append_start(node, depth - 1, "Root", str);
+			break;
+
+		case MENU_LAYOUT_NODE_PASSTHROUGH:
+			g_string_append(str, menu_layout_node_get_content(node));
+			g_string_append_c(str, '\n');
+			break;
+
+		case MENU_LAYOUT_NODE_MENU:
+			append_container(node, onelevel, depth, "Menu", str);
+			break;
+
+		case MENU_LAYOUT_NODE_APP_DIR:
+			append_simple(node, depth, "AppDir", str);
+			break;
+
+		case MENU_LAYOUT_NODE_DEFAULT_APP_DIRS:
+			append_simple(node, depth, "DefaultAppDirs", str);
+			break;
+
+		case MENU_LAYOUT_NODE_DIRECTORY_DIR:
+			append_simple(node, depth, "DirectoryDir", str);
+			break;
+
+		case MENU_LAYOUT_NODE_DEFAULT_DIRECTORY_DIRS:
+			append_simple(node, depth, "DefaultDirectoryDirs", str);
+			break;
+
+		case MENU_LAYOUT_NODE_DEFAULT_MERGE_DIRS:
+			append_simple(node, depth, "DefaultMergeDirs", str);
+			break;
+
+		case MENU_LAYOUT_NODE_NAME:
+			append_simple(node, depth, "Name", str);
+			break;
+
+		case MENU_LAYOUT_NODE_DIRECTORY:
+			append_simple(node, depth, "Directory", str);
+			break;
+
+		case MENU_LAYOUT_NODE_ONLY_UNALLOCATED:
+			append_simple(node, depth, "OnlyUnallocated", str);
+			break;
+
+		case MENU_LAYOUT_NODE_NOT_ONLY_UNALLOCATED:
+			append_simple(node, depth, "NotOnlyUnallocated", str);
+			break;
+
+		case MENU_LAYOUT_NODE_INCLUDE:
+			append_container(node, onelevel, depth, "Include", str);
+			break;
+
+		case MENU_LAYOUT_NODE_EXCLUDE:
+			append_container(node, onelevel, depth, "Exclude", str);
+			break;
+
+		case MENU_LAYOUT_NODE_FILENAME:
+			append_simple(node, depth, "Filename", str);
+			break;
+
+		case MENU_LAYOUT_NODE_CATEGORY:
+			append_simple(node, depth, "Category", str);
+			break;
+
+		case MENU_LAYOUT_NODE_ALL:
+			append_simple(node, depth, "All", str);
+			break;
+
+		case MENU_LAYOUT_NODE_AND:
+			append_container(node, onelevel, depth, "And", str);
+			break;
+
+		case MENU_LAYOUT_NODE_OR:
+			append_container(node, onelevel, depth, "Or", str);
+			break;
+
+		case MENU_LAYOUT_NODE_NOT:
+			append_container(node, onelevel, depth, "Not", str);
+			break;
+
+		case MENU_LAYOUT_NODE_MERGE_FILE:
+		{
+			MenuMergeFileType type;
+
+			type = menu_layout_node_merge_file_get_type(node);
+
+			append_simple_with_attr(node, depth, "MergeFile", "type", type == MENU_MERGE_FILE_TYPE_PARENT ? "parent" : "path", str);
+			break;
+		}
+
+		case MENU_LAYOUT_NODE_MERGE_DIR:
+			append_simple(node, depth, "MergeDir", str);
+			break;
+
+		case MENU_LAYOUT_NODE_LEGACY_DIR:
+			append_simple_with_attr(node, depth, "LegacyDir", "prefix", menu_layout_node_legacy_dir_get_prefix (node), str);
+			break;
+
+		case MENU_LAYOUT_NODE_KDE_LEGACY_DIRS:
+			append_simple(node, depth, "KDELegacyDirs", str);
+			break;
+
+		case MENU_LAYOUT_NODE_MOVE:
+			append_container(node, onelevel, depth, "Move", str);
+			break;
+
+		case MENU_LAYOUT_NODE_OLD:
+			append_simple(node, depth, "Old", str);
+			break;
+
+		case MENU_LAYOUT_NODE_NEW:
+			append_simple(node, depth, "New", str);
+			break;
+
+		case MENU_LAYOUT_NODE_DELETED:
+			append_simple(node, depth, "Deleted", str);
+			break;
+
+		case MENU_LAYOUT_NODE_NOT_DELETED:
+			append_simple(node, depth, "NotDeleted", str);
+			break;
+
+		case MENU_LAYOUT_NODE_LAYOUT:
+			append_container(node, onelevel, depth, "Layout", str);
+			break;
+
+		case MENU_LAYOUT_NODE_DEFAULT_LAYOUT:
+			menu_layout_node_default_layout_get_values(node, &layout_values);
+			append_layout(node, depth, "DefaultLayout", &layout_values, str);
+			break;
+
+		case MENU_LAYOUT_NODE_MENUNAME:
+			menu_layout_node_menuname_get_values(node, &layout_values);
+			append_layout(node, depth, "MenuName", &layout_values, str);
+			break;
+
+		case MENU_LAYOUT_NODE_SEPARATOR:
+			append_simple(node, depth, "Name", str);
+			break;
+
+		case MENU_LAYOUT_NODE_MERGE:
+			append_merge(node, depth, "Merge", menu_layout_node_merge_get_type(node), str);
+			break;
+
+		default:
+			g_assert_not_reached();
+			break;
+	}
+}
+
+void menu_debug_print_layout(MenuLayoutNode* node, gboolean onelevel)
+{
+	if (menu_verbose_enabled())
+	{
+		GString* str = g_string_new(NULL);
+		append_to_string(node, onelevel, 0, str);
+
+		utf8_fputs(str->str, stderr);
+		fflush(stderr);
+
+		g_string_free(str, TRUE);
+	}
+}
+
+#endif /* G_ENABLE_DEBUG */
diff --git a/libmenu/menu-util.h b/libmenu/menu-util.h
new file mode 100644
index 0000000..035f0e9
--- /dev/null
+++ b/libmenu/menu-util.h
@@ -0,0 +1,59 @@
+/* Random utility functions for menu code */
+
+/*
+ * Copyright (C) 2003 Red Hat, Inc.
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU Lesser General Public
+ * License as published by the Free Software Foundation; either
+ * version 2 of the License, or (at your option) any later version.
+ *
+ * This library is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public
+ * License along with this library; if not, write to the
+ * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+ * Boston, MA 02111-1307, USA.
+ */
+
+#ifndef __MENU_UTIL_H__
+#define __MENU_UTIL_H__
+
+#include <glib.h>
+
+#include "menu-layout.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+
+
+#ifdef G_ENABLE_DEBUG
+
+	void menu_verbose(const char* format, ...) G_GNUC_PRINTF(1, 2);
+
+	void menu_debug_print_layout(MenuLayoutNode* node, gboolean onelevel);
+
+#else /* !defined(G_ENABLE_DEBUG) */
+
+	#ifdef G_HAVE_ISO_VARARGS
+		#define menu_verbose(...)
+	#elif defined(G_HAVE_GNUC_VARARGS)
+		#define menu_verbose(format...)
+	#else
+		#error "Cannot disable verbose mode due to lack of varargs macros"
+	#endif
+
+	#define menu_debug_print_layout(n, o)
+
+#endif /* G_ENABLE_DEBUG */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MENU_UTIL_H__ */