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

1 files changed, 8411 insertions, 0 deletions

diff --git a/libcaja-private/caja-file.c b/libcaja-private/caja-file.c
new file mode 100644
index 00000000..4b229ca6
--- /dev/null
+++ b/libcaja-private/caja-file.c
@@ -0,0 +1,8411 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*-
+
+   caja-file.c: Caja file model.
+
+   Copyright (C) 1999, 2000, 2001 Eazel, Inc.
+
+   This program is free software; you can redistribute it and/or
+   modify it under the terms of the GNU General Public License as
+   published by the Free Software Foundation; either version 2 of the
+   License, or (at your option) any later version.
+
+   This program is distributed in the hope that it will be useful,
+   but WITHOUT ANY WARRANTY; without even the implied warranty of
+   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+   General Public License for more details.
+
+   You should have received a copy of the GNU General Public
+   License along with this program; if not, write to the
+   Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+   Boston, MA 02111-1307, USA.
+
+   Author: Darin Adler <[email protected]>
+*/
+
+#include <config.h>
+#include "caja-file.h"
+
+#include "caja-directory-notify.h"
+#include "caja-directory-private.h"
+#include "caja-signaller.h"
+#include "caja-desktop-directory.h"
+#include "caja-desktop-directory-file.h"
+#include "caja-desktop-icon-file.h"
+#include "caja-file-attributes.h"
+#include "caja-file-private.h"
+#include "caja-file-operations.h"
+#include "caja-file-utilities.h"
+#include "caja-global-preferences.h"
+#include "caja-lib-self-check-functions.h"
+#include "caja-link.h"
+#include "caja-metadata.h"
+#include "caja-module.h"
+#include "caja-search-directory.h"
+#include "caja-search-directory-file.h"
+#include "caja-thumbnails.h"
+#include "caja-users-groups-cache.h"
+#include "caja-vfs-file.h"
+#include "caja-saved-search-file.h"
+#include <eel/eel-debug.h>
+#include <eel/eel-glib-extensions.h>
+#include <eel/eel-gtk-extensions.h>
+#include <eel/eel-vfs-extensions.h>
+#include <eel/eel-gtk-macros.h>
+#include <eel/eel-string.h>
+#include <grp.h>
+#include <gtk/gtk.h>
+#include <glib/gi18n.h>
+#include <glib/gstdio.h>
+#include <gio/gio.h>
+#include <glib.h>
+
+#include <libcaja-extension/caja-file-info.h>
+#include <libcaja-extension/caja-extension-private.h>
+#include <libxml/parser.h>
+#include <pwd.h>
+#include <stdlib.h>
+#include <sys/time.h>
+#include <time.h>
+#include <unistd.h>
+#include <sys/stat.h>
+
+#ifdef HAVE_SELINUX
+#include <selinux/selinux.h>
+#endif
+
+/* Time in seconds to cache getpwuid results */
+#define GETPWUID_CACHE_TIME (5*60)
+
+#define ICON_NAME_THUMBNAIL_LOADING   "image-loading"
+
+#undef CAJA_FILE_DEBUG_REF
+#undef CAJA_FILE_DEBUG_REF_VALGRIND
+
+#ifdef CAJA_FILE_DEBUG_REF_VALGRIND
+#include <valgrind/valgrind.h>
+#define DEBUG_REF_PRINTF VALGRIND_PRINTF_BACKTRACE
+#else
+#define DEBUG_REF_PRINTF printf
+#endif
+
+/* Files that start with these characters sort after files that don't. */
+#define SORT_LAST_CHAR1 '.'
+#define SORT_LAST_CHAR2 '#'
+
+/* Name of Caja trash directories */
+#define TRASH_DIRECTORY_NAME ".Trash"
+
+#define METADATA_ID_IS_LIST_MASK (1<<31)
+
+typedef enum {
+	SHOW_HIDDEN = 1 << 0,
+	SHOW_BACKUP = 1 << 1
+} FilterOptions;
+
+typedef void (* ModifyListFunction) (GList **list, CajaFile *file);
+
+enum {
+	CHANGED,
+	UPDATED_DEEP_COUNT_IN_PROGRESS,
+	LAST_SIGNAL
+};
+
+static int date_format_pref;
+
+static guint signals[LAST_SIGNAL];
+
+static GHashTable *symbolic_links;
+
+static GQuark attribute_name_q,
+	attribute_size_q,
+	attribute_type_q,
+	attribute_modification_date_q,
+	attribute_date_modified_q,
+	attribute_accessed_date_q,
+	attribute_date_accessed_q,
+	attribute_emblems_q,
+	attribute_mime_type_q,
+	attribute_size_detail_q,
+	attribute_deep_size_q,
+	attribute_deep_file_count_q,
+	attribute_deep_directory_count_q,
+	attribute_deep_total_count_q,
+	attribute_date_changed_q,
+	attribute_trashed_on_q,
+	attribute_trash_orig_path_q,
+	attribute_date_permissions_q,
+	attribute_permissions_q,
+	attribute_selinux_context_q,
+	attribute_octal_permissions_q,
+	attribute_owner_q,
+	attribute_group_q,
+	attribute_uri_q,
+	attribute_where_q,
+	attribute_link_target_q,
+	attribute_volume_q,
+	attribute_free_space_q;
+
+static void     caja_file_info_iface_init                (CajaFileInfoIface *iface);
+static char *   caja_file_get_owner_as_string            (CajaFile          *file,
+							      gboolean               include_real_name);
+static char *   caja_file_get_type_as_string             (CajaFile          *file);
+static gboolean update_info_and_name                         (CajaFile          *file,
+							      GFileInfo             *info);
+static const char * caja_file_peek_display_name (CajaFile *file);
+static const char * caja_file_peek_display_name_collation_key (CajaFile *file);
+static void file_mount_unmounted (GMount *mount,  gpointer data);
+static void metadata_hash_free (GHashTable *hash);
+
+G_DEFINE_TYPE_WITH_CODE (CajaFile, caja_file, G_TYPE_OBJECT,
+			 G_IMPLEMENT_INTERFACE (CAJA_TYPE_FILE_INFO,
+						caja_file_info_iface_init));
+
+static void
+caja_file_init (CajaFile *file)
+{
+	file->details = G_TYPE_INSTANCE_GET_PRIVATE ((file), CAJA_TYPE_FILE, CajaFileDetails);
+
+	caja_file_clear_info (file);
+	caja_file_invalidate_extension_info_internal (file);
+}
+
+static GObject*
+caja_file_constructor (GType                  type,
+			   guint                  n_construct_properties,
+			   GObjectConstructParam *construct_params)
+{
+  GObject *object;
+  CajaFile *file;
+
+  object = (* G_OBJECT_CLASS (caja_file_parent_class)->constructor) (type,
+									 n_construct_properties,
+									 construct_params);
+
+  file = CAJA_FILE (object);
+
+  /* Set to default type after full construction */
+  if (CAJA_FILE_GET_CLASS (file)->default_file_type != G_FILE_TYPE_UNKNOWN) {
+	  file->details->type = CAJA_FILE_GET_CLASS (file)->default_file_type;
+  }
+
+  return object;
+}
+
+gboolean
+caja_file_set_display_name (CajaFile *file,
+				const char *display_name,
+				const char *edit_name,
+				gboolean custom)
+{
+	gboolean changed;
+
+	if (custom && display_name == NULL) {
+		/* We're re-setting a custom display name, invalidate it if
+		   we already set it so that the old one is re-read */
+		if (file->details->got_custom_display_name) {
+			file->details->got_custom_display_name = FALSE;
+			caja_file_invalidate_attributes (file,
+							     CAJA_FILE_ATTRIBUTE_INFO);
+		}
+		return FALSE;
+	}
+
+	if (display_name == NULL || *display_name == 0) {
+		return FALSE;
+	}
+
+	if (!custom && file->details->got_custom_display_name) {
+		return FALSE;
+	}
+
+	if (edit_name == NULL) {
+		edit_name = display_name;
+	}
+
+	changed = FALSE;
+
+	if (eel_strcmp (eel_ref_str_peek (file->details->display_name), display_name) != 0) {
+		changed = TRUE;
+
+		eel_ref_str_unref (file->details->display_name);
+
+		if (eel_strcmp (eel_ref_str_peek (file->details->name), display_name) == 0) {
+			file->details->display_name = eel_ref_str_ref (file->details->name);
+		} else {
+			file->details->display_name = eel_ref_str_new (display_name);
+		}
+
+		g_free (file->details->display_name_collation_key);
+		file->details->display_name_collation_key = g_utf8_collate_key_for_filename (display_name, -1);
+	}
+
+	if (eel_strcmp (eel_ref_str_peek (file->details->edit_name), edit_name) != 0) {
+		changed = TRUE;
+
+		eel_ref_str_unref (file->details->edit_name);
+		if (eel_strcmp (eel_ref_str_peek (file->details->display_name), edit_name) == 0) {
+			file->details->edit_name = eel_ref_str_ref (file->details->display_name);
+		} else {
+			file->details->edit_name = eel_ref_str_new (edit_name);
+		}
+	}
+
+	file->details->got_custom_display_name = custom;
+	return changed;
+}
+
+static void
+caja_file_clear_display_name (CajaFile *file)
+{
+	eel_ref_str_unref (file->details->display_name);
+	file->details->display_name = NULL;
+	g_free (file->details->display_name_collation_key);
+	file->details->display_name_collation_key = NULL;
+	eel_ref_str_unref (file->details->edit_name);
+	file->details->edit_name = NULL;
+}
+
+static gboolean
+foreach_metadata_free (gpointer  key,
+		       gpointer  value,
+		       gpointer  user_data)
+{
+	guint id;
+
+	id = GPOINTER_TO_UINT (key);
+
+	if (id & METADATA_ID_IS_LIST_MASK) {
+		g_strfreev ((char **)value);
+	} else {
+		g_free ((char *)value);
+	}
+	return TRUE;
+}
+
+
+static void
+metadata_hash_free (GHashTable *hash)
+{
+	g_hash_table_foreach_remove (hash,
+				     foreach_metadata_free,
+				     NULL);
+	g_hash_table_destroy (hash);
+}
+
+static gboolean
+metadata_hash_equal (GHashTable *hash1,
+		     GHashTable *hash2)
+{
+	GHashTableIter iter;
+	gpointer key1, value1, value2;
+	guint id;
+
+	if (hash1 == NULL && hash2 == NULL) {
+		return TRUE;
+	}
+
+	if (hash1 == NULL || hash2 == NULL) {
+		return FALSE;
+	}
+
+	if (g_hash_table_size (hash1) !=
+	    g_hash_table_size (hash2)) {
+		return FALSE;
+	}
+
+	g_hash_table_iter_init (&iter, hash1);
+	while (g_hash_table_iter_next (&iter, &key1, &value1)) {
+		value2 = g_hash_table_lookup (hash2, key1);
+		if (value2 == NULL) {
+			return FALSE;
+		}
+		id = GPOINTER_TO_UINT (key1);
+		if (id & METADATA_ID_IS_LIST_MASK) {
+			if (!eel_g_strv_equal ((char **)value1, (char **)value2)) {
+				return FALSE;
+			}
+		} else {
+			if (strcmp ((char *)value1, (char *)value2) != 0) {
+				return FALSE;
+			}
+		}
+	}
+
+	return TRUE;
+}
+
+static void
+clear_metadata (CajaFile *file)
+{
+	if (file->details->metadata) {
+		metadata_hash_free (file->details->metadata);
+		file->details->metadata = NULL;
+	}
+}
+
+static GHashTable *
+get_metadata_from_info (GFileInfo *info)
+{
+	GHashTable *metadata;
+	char **attrs;
+	guint id;
+	int i;
+	GFileAttributeType type;
+	gpointer value;
+
+	attrs = g_file_info_list_attributes (info, "metadata");
+
+	metadata = g_hash_table_new (NULL, NULL);
+
+	for (i = 0; attrs[i] != NULL; i++) {
+		id = caja_metadata_get_id (attrs[i] + strlen ("metadata::"));
+		if (id == 0) {
+			continue;
+		}
+
+		if (!g_file_info_get_attribute_data (info, attrs[i],
+						     &type, &value, NULL)) {
+			continue;
+		}
+
+		if (type == G_FILE_ATTRIBUTE_TYPE_STRING) {
+			g_hash_table_insert (metadata, GUINT_TO_POINTER (id),
+					     g_strdup ((char *)value));
+		} else if (type == G_FILE_ATTRIBUTE_TYPE_STRINGV) {
+			id |= METADATA_ID_IS_LIST_MASK;
+			g_hash_table_insert (metadata, GUINT_TO_POINTER (id),
+					     g_strdupv ((char **)value));
+		}
+	}
+
+	g_strfreev (attrs);
+
+	return metadata;
+}
+
+gboolean
+caja_file_update_metadata_from_info (CajaFile *file,
+					 GFileInfo *info)
+{
+	gboolean changed = FALSE;
+
+	if (g_file_info_has_namespace (info, "metadata")) {
+		GHashTable *metadata;
+
+		metadata = get_metadata_from_info (info);
+		if (!metadata_hash_equal (metadata,
+					  file->details->metadata)) {
+			changed = TRUE;
+			clear_metadata (file);
+			file->details->metadata = metadata;
+		} else {
+			metadata_hash_free (metadata);
+		}
+	} else if (file->details->metadata) {
+		changed = TRUE;
+		clear_metadata (file);
+	}
+	return changed;
+}
+
+void
+caja_file_clear_info (CajaFile *file)
+{
+	file->details->got_file_info = FALSE;
+	if (file->details->get_info_error) {
+		g_error_free (file->details->get_info_error);
+		file->details->get_info_error = NULL;
+	}
+	/* Reset to default type, which might be other than unknown for
+	   special kinds of files like the desktop or a search directory */
+	file->details->type = CAJA_FILE_GET_CLASS (file)->default_file_type;
+
+	if (!file->details->got_custom_display_name) {
+		caja_file_clear_display_name (file);
+	}
+
+	if (!file->details->got_custom_activation_uri &&
+	    file->details->activation_uri != NULL) {
+		g_free (file->details->activation_uri);
+		file->details->activation_uri = NULL;
+	}
+
+	if (file->details->icon != NULL) {
+		g_object_unref (file->details->icon);
+		file->details->icon = NULL;
+	}
+
+	g_free (file->details->thumbnail_path);
+	file->details->thumbnail_path = NULL;
+	file->details->thumbnailing_failed = FALSE;
+
+	file->details->is_launcher = FALSE;
+	file->details->is_foreign_link = FALSE;
+	file->details->is_trusted_link = FALSE;
+	file->details->is_symlink = FALSE;
+	file->details->is_hidden = FALSE;
+	file->details->is_backup = FALSE;
+	file->details->is_mountpoint = FALSE;
+	file->details->uid = -1;
+	file->details->gid = -1;
+	file->details->can_read = TRUE;
+	file->details->can_write = TRUE;
+	file->details->can_execute = TRUE;
+	file->details->can_delete = TRUE;
+	file->details->can_trash = TRUE;
+	file->details->can_rename = TRUE;
+	file->details->can_mount = FALSE;
+	file->details->can_unmount = FALSE;
+	file->details->can_eject = FALSE;
+	file->details->can_start = FALSE;
+	file->details->can_start_degraded = FALSE;
+	file->details->can_stop = FALSE;
+	file->details->start_stop_type = G_DRIVE_START_STOP_TYPE_UNKNOWN;
+	file->details->can_poll_for_media = FALSE;
+	file->details->is_media_check_automatic = FALSE;
+	file->details->has_permissions = FALSE;
+	file->details->permissions = 0;
+	file->details->size = -1;
+	file->details->sort_order = 0;
+	file->details->mtime = 0;
+	file->details->atime = 0;
+	file->details->ctime = 0;
+	file->details->trash_time = 0;
+	g_free (file->details->symlink_name);
+	file->details->symlink_name = NULL;
+	eel_ref_str_unref (file->details->mime_type);
+	file->details->mime_type = NULL;
+	g_free (file->details->selinux_context);
+	file->details->selinux_context = NULL;
+	g_free (file->details->description);
+	file->details->description = NULL;
+	eel_ref_str_unref (file->details->owner);
+	file->details->owner = NULL;
+	eel_ref_str_unref (file->details->owner_real);
+	file->details->owner_real = NULL;
+	eel_ref_str_unref (file->details->group);
+	file->details->group = NULL;
+
+	eel_ref_str_unref (file->details->filesystem_id);
+	file->details->filesystem_id = NULL;
+
+	clear_metadata (file);
+}
+
+static CajaFile *
+caja_file_new_from_filename (CajaDirectory *directory,
+				 const char *filename,
+				 gboolean self_owned)
+{
+	CajaFile *file;
+
+	g_assert (CAJA_IS_DIRECTORY (directory));
+	g_assert (filename != NULL);
+	g_assert (filename[0] != '\0');
+
+	if (CAJA_IS_DESKTOP_DIRECTORY (directory)) {
+		if (self_owned) {
+			file = CAJA_FILE (g_object_new (CAJA_TYPE_DESKTOP_DIRECTORY_FILE, NULL));
+		} else {
+			/* This doesn't normally happen, unless the user somehow types in a uri
+			 * that references a file like this. (See #349840) */
+			file = CAJA_FILE (g_object_new (CAJA_TYPE_VFS_FILE, NULL));
+		}
+	} else if (CAJA_IS_SEARCH_DIRECTORY (directory)) {
+		if (self_owned) {
+			file = CAJA_FILE (g_object_new (CAJA_TYPE_SEARCH_DIRECTORY_FILE, NULL));
+		} else {
+			/* This doesn't normally happen, unless the user somehow types in a uri
+			 * that references a file like this. (See #349840) */
+			file = CAJA_FILE (g_object_new (CAJA_TYPE_VFS_FILE, NULL));
+		}
+	} else if (g_str_has_suffix (filename, CAJA_SAVED_SEARCH_EXTENSION)) {
+		file = CAJA_FILE (g_object_new (CAJA_TYPE_SAVED_SEARCH_FILE, NULL));
+	} else {
+		file = CAJA_FILE (g_object_new (CAJA_TYPE_VFS_FILE, NULL));
+	}
+
+	file->details->directory = caja_directory_ref (directory);
+
+	file->details->name = eel_ref_str_new (filename);
+
+#ifdef CAJA_FILE_DEBUG_REF
+	DEBUG_REF_PRINTF("%10p ref'd", file);
+#endif
+
+	return file;
+}
+
+static void
+modify_link_hash_table (CajaFile *file,
+			ModifyListFunction modify_function)
+{
+	char *target_uri;
+	gboolean found;
+	gpointer original_key;
+	GList **list_ptr;
+
+	/* Check if there is a symlink name. If none, we are OK. */
+	if (file->details->symlink_name == NULL) {
+		return;
+	}
+
+	/* Create the hash table first time through. */
+	if (symbolic_links == NULL) {
+		symbolic_links = eel_g_hash_table_new_free_at_exit
+			(g_str_hash, g_str_equal, "caja-file.c: symbolic_links");
+	}
+
+	target_uri = caja_file_get_symbolic_link_target_uri (file);
+
+	/* Find the old contents of the hash table. */
+	found = g_hash_table_lookup_extended
+		(symbolic_links, target_uri,
+		 &original_key, (gpointer *)&list_ptr);
+	if (!found) {
+		list_ptr = g_new0 (GList *, 1);
+		original_key = g_strdup (target_uri);
+		g_hash_table_insert (symbolic_links, original_key, list_ptr);
+	}
+	(* modify_function) (list_ptr, file);
+	if (*list_ptr == NULL) {
+		g_hash_table_remove (symbolic_links, target_uri);
+		g_free (list_ptr);
+		g_free (original_key);
+	}
+	g_free (target_uri);
+}
+
+static void
+symbolic_link_weak_notify (gpointer      data,
+			   GObject      *where_the_object_was)
+{
+	GList **list = data;
+	/* This really shouldn't happen, but we're seeing some strange things in
+	   bug #358172 where the symlink hashtable isn't correctly updated. */
+	*list = g_list_remove (*list, where_the_object_was);
+}
+
+static void
+add_to_link_hash_table_list (GList **list, CajaFile *file)
+{
+	if (g_list_find (*list, file) != NULL) {
+		g_warning ("Adding file to symlink_table multiple times. "
+			   "Please add feedback of what you were doing at http://bugzilla.gnome.org/show_bug.cgi?id=358172\n");
+		return;
+	}
+	g_object_weak_ref (G_OBJECT (file), symbolic_link_weak_notify, list);
+	*list = g_list_prepend (*list, file);
+}
+
+static void
+add_to_link_hash_table (CajaFile *file)
+{
+	modify_link_hash_table (file, add_to_link_hash_table_list);
+}
+
+static void
+remove_from_link_hash_table_list (GList **list, CajaFile *file)
+{
+	if (g_list_find (*list, file) != NULL) {
+		g_object_weak_unref (G_OBJECT (file), symbolic_link_weak_notify, list);
+		*list = g_list_remove (*list, file);
+	}
+}
+
+static void
+remove_from_link_hash_table (CajaFile *file)
+{
+	modify_link_hash_table (file, remove_from_link_hash_table_list);
+}
+
+CajaFile *
+caja_file_new_from_info (CajaDirectory *directory,
+			     GFileInfo *info)
+{
+	CajaFile *file;
+	const char *mime_type;
+
+	g_return_val_if_fail (CAJA_IS_DIRECTORY (directory), NULL);
+	g_return_val_if_fail (info != NULL, NULL);
+
+	mime_type = g_file_info_get_content_type (info);
+	if (mime_type &&
+	    strcmp (mime_type, CAJA_SAVED_SEARCH_MIMETYPE) == 0) {
+		g_file_info_set_file_type (info, G_FILE_TYPE_DIRECTORY);
+		file = CAJA_FILE (g_object_new (CAJA_TYPE_SAVED_SEARCH_FILE, NULL));
+	} else {
+		file = CAJA_FILE (g_object_new (CAJA_TYPE_VFS_FILE, NULL));
+	}
+
+	file->details->directory = caja_directory_ref (directory);
+
+	update_info_and_name (file, info);
+
+#ifdef CAJA_FILE_DEBUG_REF
+	DEBUG_REF_PRINTF("%10p ref'd", file);
+#endif
+
+	return file;
+}
+
+static CajaFile *
+caja_file_get_internal (GFile *location, gboolean create)
+{
+	gboolean self_owned;
+	CajaDirectory *directory;
+	CajaFile *file;
+	GFile *parent;
+	char *basename;
+
+	g_assert (location != NULL);
+
+	parent = g_file_get_parent (location);
+
+	self_owned = FALSE;
+	if (parent == NULL) {
+		self_owned = TRUE;
+		parent = g_object_ref (location);
+	}
+
+	/* Get object that represents the directory. */
+	directory = caja_directory_get_internal (parent, create);
+
+	g_object_unref (parent);
+
+	/* Get the name for the file. */
+	if (self_owned && directory != NULL) {
+		basename = caja_directory_get_name_for_self_as_new_file (directory);
+	} else {
+		basename = g_file_get_basename (location);
+	}
+	/* Check to see if it's a file that's already known. */
+	if (directory == NULL) {
+		file = NULL;
+	} else if (self_owned) {
+		file = directory->details->as_file;
+	} else {
+		file = caja_directory_find_file_by_name (directory, basename);
+	}
+
+	/* Ref or create the file. */
+	if (file != NULL) {
+		caja_file_ref (file);
+	} else if (create) {
+		file = caja_file_new_from_filename (directory, basename, self_owned);
+		if (self_owned) {
+			g_assert (directory->details->as_file == NULL);
+			directory->details->as_file = file;
+		} else {
+			caja_directory_add_file (directory, file);
+		}
+	}
+
+	g_free (basename);
+	caja_directory_unref (directory);
+
+	return file;
+}
+
+CajaFile *
+caja_file_get (GFile *location)
+{
+	return caja_file_get_internal (location, TRUE);
+}
+
+CajaFile *
+caja_file_get_existing (GFile *location)
+{
+	return caja_file_get_internal (location, FALSE);
+}
+
+CajaFile *
+caja_file_get_existing_by_uri (const char *uri)
+{
+	GFile *location;
+	CajaFile *file;
+
+	location = g_file_new_for_uri (uri);
+	file = caja_file_get_internal (location, FALSE);
+	g_object_unref (location);
+
+	return file;
+}
+
+CajaFile *
+caja_file_get_by_uri (const char *uri)
+{
+	GFile *location;
+	CajaFile *file;
+
+	location = g_file_new_for_uri (uri);
+	file = caja_file_get_internal (location, TRUE);
+	g_object_unref (location);
+
+	return file;
+}
+
+gboolean
+caja_file_is_self_owned (CajaFile *file)
+{
+	return file->details->directory->details->as_file == file;
+}
+
+static void
+finalize (GObject *object)
+{
+	CajaDirectory *directory;
+	CajaFile *file;
+	char *uri;
+
+	file = CAJA_FILE (object);
+
+	g_assert (file->details->operations_in_progress == NULL);
+
+	if (file->details->is_thumbnailing) {
+		uri = caja_file_get_uri (file);
+		caja_thumbnail_remove_from_queue (uri);
+		g_free (uri);
+	}
+
+	caja_async_destroying_file (file);
+
+	remove_from_link_hash_table (file);
+
+	directory = file->details->directory;
+
+	if (caja_file_is_self_owned (file)) {
+		directory->details->as_file = NULL;
+	} else {
+		if (!file->details->is_gone) {
+			caja_directory_remove_file (directory, file);
+		}
+	}
+
+	if (file->details->get_info_error) {
+		g_error_free (file->details->get_info_error);
+	}
+
+	caja_directory_unref (directory);
+	eel_ref_str_unref (file->details->name);
+	eel_ref_str_unref (file->details->display_name);
+	g_free (file->details->display_name_collation_key);
+	eel_ref_str_unref (file->details->edit_name);
+	if (file->details->icon) {
+		g_object_unref (file->details->icon);
+	}
+	g_free (file->details->thumbnail_path);
+	g_free (file->details->symlink_name);
+	eel_ref_str_unref (file->details->mime_type);
+	eel_ref_str_unref (file->details->owner);
+	eel_ref_str_unref (file->details->owner_real);
+	eel_ref_str_unref (file->details->group);
+	g_free (file->details->selinux_context);
+	g_free (file->details->description);
+	g_free (file->details->top_left_text);
+	g_free (file->details->custom_icon);
+	g_free (file->details->activation_uri);
+	g_free (file->details->compare_by_emblem_cache);
+
+	if (file->details->thumbnail) {
+		g_object_unref (file->details->thumbnail);
+	}
+	if (file->details->mount) {
+		g_signal_handlers_disconnect_by_func (file->details->mount, file_mount_unmounted, file);
+		g_object_unref (file->details->mount);
+	}
+
+	eel_ref_str_unref (file->details->filesystem_id);
+
+	eel_g_list_free_deep (file->details->mime_list);
+
+	eel_g_list_free_deep (file->details->pending_extension_emblems);
+	eel_g_list_free_deep (file->details->extension_emblems);
+	eel_g_object_list_free (file->details->pending_info_providers);
+
+	if (file->details->pending_extension_attributes) {
+		g_hash_table_destroy (file->details->pending_extension_attributes);
+	}
+
+	if (file->details->extension_attributes) {
+		g_hash_table_destroy (file->details->extension_attributes);
+	}
+
+	if (file->details->metadata) {
+		metadata_hash_free (file->details->metadata);
+	}
+
+	G_OBJECT_CLASS (caja_file_parent_class)->finalize (object);
+}
+
+CajaFile *
+caja_file_ref (CajaFile *file)
+{
+	if (file == NULL) {
+		return NULL;
+	}
+	g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+#ifdef CAJA_FILE_DEBUG_REF
+	DEBUG_REF_PRINTF("%10p ref'd", file);
+#endif
+
+	return g_object_ref (file);
+}
+
+void
+caja_file_unref (CajaFile *file)
+{
+	if (file == NULL) {
+		return;
+	}
+
+	g_return_if_fail (CAJA_IS_FILE (file));
+
+#ifdef CAJA_FILE_DEBUG_REF
+	DEBUG_REF_PRINTF("%10p unref'd", file);
+#endif
+
+	g_object_unref (file);
+}
+
+/**
+ * caja_file_get_parent_uri_for_display:
+ *
+ * Get the uri for the parent directory.
+ *
+ * @file: The file in question.
+ *
+ * Return value: A string representing the parent's location,
+ * formatted for user display (including stripping "file://").
+ * If the parent is NULL, returns the empty string.
+ */
+char *
+caja_file_get_parent_uri_for_display (CajaFile *file)
+{
+	GFile *parent;
+	char *result;
+
+	g_assert (CAJA_IS_FILE (file));
+
+	parent = caja_file_get_parent_location (file);
+	if (parent) {
+		result = g_file_get_parse_name (parent);
+		g_object_unref (parent);
+	} else {
+		result = g_strdup ("");
+	}
+
+	return result;
+}
+
+/**
+ * caja_file_get_parent_uri:
+ *
+ * Get the uri for the parent directory.
+ *
+ * @file: The file in question.
+ *
+ * Return value: A string for the parent's location, in "raw URI" form.
+ * Use caja_file_get_parent_uri_for_display instead if the
+ * result is to be displayed on-screen.
+ * If the parent is NULL, returns the empty string.
+ */
+char *
+caja_file_get_parent_uri (CajaFile *file)
+{
+	g_assert (CAJA_IS_FILE (file));
+
+	if (caja_file_is_self_owned (file)) {
+		/* Callers expect an empty string, not a NULL. */
+		return g_strdup ("");
+	}
+
+	return caja_directory_get_uri (file->details->directory);
+}
+
+GFile *
+caja_file_get_parent_location (CajaFile *file)
+{
+	g_assert (CAJA_IS_FILE (file));
+
+	if (caja_file_is_self_owned (file)) {
+		/* Callers expect an empty string, not a NULL. */
+		return NULL;
+	}
+
+	return caja_directory_get_location (file->details->directory);
+}
+
+CajaFile *
+caja_file_get_parent (CajaFile *file)
+{
+	g_assert (CAJA_IS_FILE (file));
+
+	if (caja_file_is_self_owned (file)) {
+		return NULL;
+	}
+
+	return caja_directory_get_corresponding_file (file->details->directory);
+}
+
+/**
+ * caja_file_can_read:
+ *
+ * Check whether the user is allowed to read the contents of this file.
+ *
+ * @file: The file to check.
+ *
+ * Return value: FALSE if the user is definitely not allowed to read
+ * the contents of the file. If the user has read permission, or
+ * the code can't tell whether the user has read permission,
+ * returns TRUE (so failures must always be handled).
+ */
+gboolean
+caja_file_can_read (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	return file->details->can_read;
+}
+
+/**
+ * caja_file_can_write:
+ *
+ * Check whether the user is allowed to write to this file.
+ *
+ * @file: The file to check.
+ *
+ * Return value: FALSE if the user is definitely not allowed to write
+ * to the file. If the user has write permission, or
+ * the code can't tell whether the user has write permission,
+ * returns TRUE (so failures must always be handled).
+ */
+gboolean
+caja_file_can_write (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	return file->details->can_write;
+}
+
+/**
+ * caja_file_can_execute:
+ *
+ * Check whether the user is allowed to execute this file.
+ *
+ * @file: The file to check.
+ *
+ * Return value: FALSE if the user is definitely not allowed to execute
+ * the file. If the user has execute permission, or
+ * the code can't tell whether the user has execute permission,
+ * returns TRUE (so failures must always be handled).
+ */
+gboolean
+caja_file_can_execute (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	return file->details->can_execute;
+}
+
+gboolean
+caja_file_can_mount (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	return file->details->can_mount;
+}
+
+gboolean
+caja_file_can_unmount (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	return file->details->can_unmount ||
+		(file->details->mount != NULL &&
+		 g_mount_can_unmount (file->details->mount));
+}
+
+gboolean
+caja_file_can_eject (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	return file->details->can_eject ||
+		(file->details->mount != NULL &&
+		 g_mount_can_eject (file->details->mount));
+}
+
+gboolean
+caja_file_can_start (CajaFile *file)
+{
+	gboolean ret;
+	GDrive *drive;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	ret = FALSE;
+
+	if (file->details->can_start) {
+		ret = TRUE;
+		goto out;
+	}
+
+	if (file->details->mount != NULL) {
+		drive = g_mount_get_drive (file->details->mount);
+		if (drive != NULL) {
+			ret = g_drive_can_start (drive);
+			g_object_unref (drive);
+		}
+	}
+
+ out:
+	return ret;
+}
+
+gboolean
+caja_file_can_start_degraded (CajaFile *file)
+{
+	gboolean ret;
+	GDrive *drive;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	ret = FALSE;
+
+	if (file->details->can_start_degraded) {
+		ret = TRUE;
+		goto out;
+	}
+
+	if (file->details->mount != NULL) {
+		drive = g_mount_get_drive (file->details->mount);
+		if (drive != NULL) {
+			ret = g_drive_can_start_degraded (drive);
+			g_object_unref (drive);
+		}
+	}
+
+ out:
+	return ret;
+}
+
+gboolean
+caja_file_can_poll_for_media (CajaFile *file)
+{
+	gboolean ret;
+	GDrive *drive;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	ret = FALSE;
+
+	if (file->details->can_poll_for_media) {
+		ret = TRUE;
+		goto out;
+	}
+
+	if (file->details->mount != NULL) {
+		drive = g_mount_get_drive (file->details->mount);
+		if (drive != NULL) {
+			ret = g_drive_can_poll_for_media (drive);
+			g_object_unref (drive);
+		}
+	}
+
+ out:
+	return ret;
+}
+
+gboolean
+caja_file_is_media_check_automatic (CajaFile *file)
+{
+	gboolean ret;
+	GDrive *drive;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	ret = FALSE;
+
+	if (file->details->is_media_check_automatic) {
+		ret = TRUE;
+		goto out;
+	}
+
+	if (file->details->mount != NULL) {
+		drive = g_mount_get_drive (file->details->mount);
+		if (drive != NULL) {
+			ret = g_drive_is_media_check_automatic (drive);
+			g_object_unref (drive);
+		}
+	}
+
+ out:
+	return ret;
+}
+
+
+gboolean
+caja_file_can_stop (CajaFile *file)
+{
+	gboolean ret;
+	GDrive *drive;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	ret = FALSE;
+
+	if (file->details->can_stop) {
+		ret = TRUE;
+		goto out;
+	}
+
+	if (file->details->mount != NULL) {
+		drive = g_mount_get_drive (file->details->mount);
+		if (drive != NULL) {
+			ret = g_drive_can_stop (drive);
+			g_object_unref (drive);
+		}
+	}
+
+ out:
+	return ret;
+}
+
+GDriveStartStopType
+caja_file_get_start_stop_type (CajaFile *file)
+{
+	GDriveStartStopType ret;
+	GDrive *drive;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	ret = G_DRIVE_START_STOP_TYPE_UNKNOWN;
+
+	ret = file->details->start_stop_type;
+	if (ret != G_DRIVE_START_STOP_TYPE_UNKNOWN)
+		goto out;
+
+	if (file->details->mount != NULL) {
+		drive = g_mount_get_drive (file->details->mount);
+		if (drive != NULL) {
+			ret = g_drive_get_start_stop_type (drive);
+			g_object_unref (drive);
+		}
+	}
+
+ out:
+	return ret;
+}
+
+void
+caja_file_mount (CajaFile                   *file,
+		     GMountOperation                *mount_op,
+		     GCancellable                   *cancellable,
+		     CajaFileOperationCallback   callback,
+		     gpointer                        callback_data)
+{
+	GError *error;
+
+	if (CAJA_FILE_GET_CLASS (file)->mount == NULL) {
+		if (callback) {
+			error = NULL;
+			g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+                                             _("This file cannot be mounted"));
+			callback (file, NULL, error, callback_data);
+			g_error_free (error);
+		}
+	} else {
+		CAJA_FILE_GET_CLASS (file)->mount (file, mount_op, cancellable, callback, callback_data);
+	}
+}
+
+typedef struct {
+	CajaFile *file;
+	CajaFileOperationCallback callback;
+	gpointer callback_data;
+} UnmountData;
+
+static void
+unmount_done (void *callback_data)
+{
+	UnmountData *data;
+
+	data = (UnmountData *)callback_data;
+	if (data->callback) {
+		data->callback (data->file, NULL, NULL, data->callback_data);
+	}
+	caja_file_unref (data->file);
+	g_free (data);
+}
+
+void
+caja_file_unmount (CajaFile                   *file,
+		       GMountOperation                *mount_op,
+		       GCancellable                   *cancellable,
+		       CajaFileOperationCallback   callback,
+		       gpointer                        callback_data)
+{
+	GError *error;
+	UnmountData *data;
+
+	if (file->details->can_unmount) {
+		if (CAJA_FILE_GET_CLASS (file)->unmount != NULL) {
+			CAJA_FILE_GET_CLASS (file)->unmount (file, mount_op, cancellable, callback, callback_data);
+		} else {
+			if (callback) {
+				error = NULL;
+				g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+						     _("This file cannot be unmounted"));
+				callback (file, NULL, error, callback_data);
+				g_error_free (error);
+			}
+		}
+	} else if (file->details->mount != NULL &&
+		   g_mount_can_unmount (file->details->mount)) {
+		data = g_new0 (UnmountData, 1);
+		data->file = caja_file_ref (file);
+		data->callback = callback;
+		data->callback_data = callback_data;
+		caja_file_operations_unmount_mount_full (NULL, file->details->mount, FALSE, TRUE, unmount_done, data);
+	} else if (callback) {
+		callback (file, NULL, NULL, callback_data);
+	}
+}
+
+void
+caja_file_eject (CajaFile                   *file,
+		     GMountOperation                *mount_op,
+		     GCancellable                   *cancellable,
+		     CajaFileOperationCallback   callback,
+		     gpointer                        callback_data)
+{
+	GError *error;
+	UnmountData *data;
+
+	if (file->details->can_eject) {
+		if (CAJA_FILE_GET_CLASS (file)->eject != NULL) {
+			CAJA_FILE_GET_CLASS (file)->eject (file, mount_op, cancellable, callback, callback_data);
+		} else {
+			if (callback) {
+				error = NULL;
+				g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+						     _("This file cannot be ejected"));
+				callback (file, NULL, error, callback_data);
+				g_error_free (error);
+			}
+		}
+	} else if (file->details->mount != NULL &&
+		   g_mount_can_eject (file->details->mount)) {
+		data = g_new0 (UnmountData, 1);
+		data->file = caja_file_ref (file);
+		data->callback = callback;
+		data->callback_data = callback_data;
+		caja_file_operations_unmount_mount_full (NULL, file->details->mount, TRUE, TRUE, unmount_done, data);
+	} else if (callback) {
+		callback (file, NULL, NULL, callback_data);
+	}
+}
+
+void
+caja_file_start (CajaFile                   *file,
+		     GMountOperation                *start_op,
+		     GCancellable                   *cancellable,
+		     CajaFileOperationCallback   callback,
+		     gpointer                        callback_data)
+{
+	GError *error;
+
+	if ((file->details->can_start || file->details->can_start_degraded) &&
+	    CAJA_FILE_GET_CLASS (file)->start != NULL) {
+		CAJA_FILE_GET_CLASS (file)->start (file, start_op, cancellable, callback, callback_data);
+	} else {
+		if (callback) {
+			error = NULL;
+			g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+                                             _("This file cannot be started"));
+			callback (file, NULL, error, callback_data);
+			g_error_free (error);
+		}
+	}
+}
+
+static void
+file_stop_callback (GObject *source_object,
+		    GAsyncResult *res,
+		    gpointer callback_data)
+{
+	CajaFileOperation *op;
+	gboolean stopped;
+	GError *error;
+
+	op = callback_data;
+
+	error = NULL;
+	stopped = g_drive_stop_finish (G_DRIVE (source_object),
+				       res, &error);
+
+	if (!stopped &&
+	    error->domain == G_IO_ERROR &&
+	    (error->code == G_IO_ERROR_FAILED_HANDLED ||
+	     error->code == G_IO_ERROR_CANCELLED)) {
+		g_error_free (error);
+		error = NULL;
+	}
+
+	caja_file_operation_complete (op, NULL, error);
+	if (error) {
+		g_error_free (error);
+	}
+}
+
+void
+caja_file_stop (CajaFile                   *file,
+		    GMountOperation                *mount_op,
+		    GCancellable                   *cancellable,
+		    CajaFileOperationCallback   callback,
+		    gpointer                        callback_data)
+{
+	GError *error;
+
+	if (CAJA_FILE_GET_CLASS (file)->stop != NULL) {
+		if (file->details->can_stop) {
+			CAJA_FILE_GET_CLASS (file)->stop (file, mount_op, cancellable, callback, callback_data);
+		} else {
+			if (callback) {
+				error = NULL;
+				g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+						     _("This file cannot be stopped"));
+				callback (file, NULL, error, callback_data);
+				g_error_free (error);
+			}
+		}
+	} else {
+		GDrive *drive;
+
+		drive = NULL;
+		if (file->details->mount != NULL)
+			drive = g_mount_get_drive (file->details->mount);
+
+		if (drive != NULL && g_drive_can_stop (drive)) {
+			CajaFileOperation *op;
+
+			op = caja_file_operation_new (file, callback, callback_data);
+			if (cancellable) {
+				g_object_unref (op->cancellable);
+				op->cancellable = g_object_ref (cancellable);
+			}
+
+			g_drive_stop (drive,
+				      G_MOUNT_UNMOUNT_NONE,
+				      mount_op,
+				      op->cancellable,
+				      file_stop_callback,
+				      op);
+		} else {
+			if (callback) {
+				error = NULL;
+				g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+						     _("This file cannot be stopped"));
+				callback (file, NULL, error, callback_data);
+				g_error_free (error);
+			}
+		}
+
+		if (drive != NULL) {
+			g_object_unref (drive);
+		}
+	}
+}
+
+void
+caja_file_poll_for_media (CajaFile *file)
+{
+	if (file->details->can_poll_for_media) {
+		if (CAJA_FILE_GET_CLASS (file)->stop != NULL) {
+			CAJA_FILE_GET_CLASS (file)->poll_for_media (file);
+		}
+	} else if (file->details->mount != NULL) {
+		GDrive *drive;
+		drive = g_mount_get_drive (file->details->mount);
+		if (drive != NULL) {
+			g_drive_poll_for_media (drive,
+						NULL,  /* cancellable */
+						NULL,  /* GAsyncReadyCallback */
+						NULL); /* user_data */
+			g_object_unref (drive);
+		}
+	}
+}
+
+/**
+ * caja_file_is_desktop_directory:
+ *
+ * Check whether this file is the desktop directory.
+ *
+ * @file: The file to check.
+ *
+ * Return value: TRUE if this is the physical desktop directory.
+ */
+gboolean
+caja_file_is_desktop_directory (CajaFile *file)
+{
+	GFile *dir;
+
+	dir = file->details->directory->details->location;
+
+	if (dir == NULL) {
+		return FALSE;
+	}
+
+	return caja_is_desktop_directory_file (dir, eel_ref_str_peek (file->details->name));
+}
+
+static gboolean
+is_desktop_file (CajaFile *file)
+{
+	return caja_file_is_mime_type (file, "application/x-desktop");
+}
+
+static gboolean
+can_rename_desktop_file (CajaFile *file)
+{
+	GFile *location;
+	gboolean res;
+
+	location = caja_file_get_location (file);
+	res = g_file_is_native (location);
+	g_object_unref (location);
+	return res;
+}
+
+/**
+ * caja_file_can_rename:
+ *
+ * Check whether the user is allowed to change the name of the file.
+ *
+ * @file: The file to check.
+ *
+ * Return value: FALSE if the user is definitely not allowed to change
+ * the name of the file. If the user is allowed to change the name, or
+ * the code can't tell whether the user is allowed to change the name,
+ * returns TRUE (so rename failures must always be handled).
+ */
+gboolean
+caja_file_can_rename (CajaFile *file)
+{
+	gboolean can_rename;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	/* Nonexistent files can't be renamed. */
+	if (caja_file_is_gone (file)) {
+		return FALSE;
+	}
+
+	/* Self-owned files can't be renamed */
+	if (caja_file_is_self_owned (file)) {
+		return FALSE;
+	}
+
+	if ((is_desktop_file (file) && !can_rename_desktop_file (file)) ||
+	     caja_file_is_home (file)) {
+		return FALSE;
+	}
+
+	can_rename = TRUE;
+
+	/* Certain types of links can't be renamed */
+	if (CAJA_IS_DESKTOP_ICON_FILE (file)) {
+		CajaDesktopLink *link;
+
+		link = caja_desktop_icon_file_get_link (CAJA_DESKTOP_ICON_FILE (file));
+
+		if (link != NULL) {
+			can_rename = caja_desktop_link_can_rename (link);
+			g_object_unref (link);
+		}
+	}
+
+	if (!can_rename) {
+		return FALSE;
+	}
+
+	return file->details->can_rename;
+}
+
+gboolean
+caja_file_can_delete (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	/* Nonexistent files can't be deleted. */
+	if (caja_file_is_gone (file)) {
+		return FALSE;
+	}
+
+	/* Self-owned files can't be deleted */
+	if (caja_file_is_self_owned (file)) {
+		return FALSE;
+	}
+
+	return file->details->can_delete;
+}
+
+gboolean
+caja_file_can_trash (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	/* Nonexistent files can't be deleted. */
+	if (caja_file_is_gone (file)) {
+		return FALSE;
+	}
+
+	/* Self-owned files can't be deleted */
+	if (caja_file_is_self_owned (file)) {
+		return FALSE;
+	}
+
+	return file->details->can_trash;
+}
+
+GFile *
+caja_file_get_location (CajaFile *file)
+{
+	GFile *dir;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+	dir = file->details->directory->details->location;
+
+	if (caja_file_is_self_owned (file)) {
+		return g_object_ref (dir);
+	}
+
+	return g_file_get_child (dir, eel_ref_str_peek (file->details->name));
+}
+
+/* Return the actual uri associated with the passed-in file. */
+char *
+caja_file_get_uri (CajaFile *file)
+{
+	char *uri;
+	GFile *loc;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+	loc = caja_file_get_location (file);
+	uri = g_file_get_uri (loc);
+	g_object_unref (loc);
+
+	return uri;
+}
+
+char *
+caja_file_get_uri_scheme (CajaFile *file)
+{
+	GFile *loc;
+	char *scheme;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+	if (file->details->directory == NULL ||
+	    file->details->directory->details->location == NULL) {
+		return NULL;
+	}
+
+	loc = caja_directory_get_location (file->details->directory);
+	scheme = g_file_get_uri_scheme (loc);
+	g_object_unref (loc);
+
+	return scheme;
+}
+
+CajaFileOperation *
+caja_file_operation_new (CajaFile *file,
+			     CajaFileOperationCallback callback,
+			     gpointer callback_data)
+{
+	CajaFileOperation *op;
+
+	op = g_new0 (CajaFileOperation, 1);
+	op->file = caja_file_ref (file);
+	op->callback = callback;
+	op->callback_data = callback_data;
+	op->cancellable = g_cancellable_new ();
+
+	op->file->details->operations_in_progress = g_list_prepend
+		(op->file->details->operations_in_progress, op);
+
+	return op;
+}
+
+static void
+caja_file_operation_remove (CajaFileOperation *op)
+{
+	op->file->details->operations_in_progress = g_list_remove
+		(op->file->details->operations_in_progress, op);
+}
+
+void
+caja_file_operation_free (CajaFileOperation *op)
+{
+	caja_file_operation_remove (op);
+	caja_file_unref (op->file);
+	g_object_unref (op->cancellable);
+	if (op->free_data) {
+		op->free_data (op->data);
+	}
+	g_free (op);
+}
+
+void
+caja_file_operation_complete (CajaFileOperation *op, GFile *result_file, GError *error)
+{
+	/* Claim that something changed even if the operation failed.
+	 * This makes it easier for some clients who see the "reverting"
+	 * as "changing back".
+	 */
+	caja_file_operation_remove (op);
+	caja_file_changed (op->file);
+	if (op->callback) {
+		(* op->callback) (op->file, result_file, error, op->callback_data);
+	}
+	caja_file_operation_free (op);
+}
+
+void
+caja_file_operation_cancel (CajaFileOperation *op)
+{
+	/* Cancel the operation if it's still in progress. */
+	g_cancellable_cancel (op->cancellable);
+}
+
+static void
+rename_get_info_callback (GObject *source_object,
+			  GAsyncResult *res,
+			  gpointer callback_data)
+{
+	CajaFileOperation *op;
+	CajaDirectory *directory;
+	CajaFile *existing_file;
+	char *old_name;
+	char *old_uri;
+	char *new_uri;
+	const char *new_name;
+	GFileInfo *new_info;
+	GError *error;
+
+	op = callback_data;
+
+	error = NULL;
+	new_info = g_file_query_info_finish (G_FILE (source_object), res, &error);
+	if (new_info != NULL) {
+		directory = op->file->details->directory;
+
+		new_name = g_file_info_get_name (new_info);
+
+		/* If there was another file by the same name in this
+		 * directory, mark it gone.
+		 */
+		existing_file = caja_directory_find_file_by_name (directory, new_name);
+		if (existing_file != NULL) {
+			caja_file_mark_gone (existing_file);
+			caja_file_changed (existing_file);
+		}
+
+		old_uri = caja_file_get_uri (op->file);
+		old_name = g_strdup (eel_ref_str_peek (op->file->details->name));
+
+		update_info_and_name (op->file, new_info);
+
+		g_free (old_name);
+
+		new_uri = caja_file_get_uri (op->file);
+		caja_directory_moved (old_uri, new_uri);
+		g_free (new_uri);
+		g_free (old_uri);
+
+		/* the rename could have affected the display name if e.g.
+		 * we're in a vfolder where the name comes from a desktop file
+		 * and a rename affects the contents of the desktop file.
+		 */
+		if (op->file->details->got_custom_display_name) {
+			caja_file_invalidate_attributes (op->file,
+							     CAJA_FILE_ATTRIBUTE_INFO |
+							     CAJA_FILE_ATTRIBUTE_LINK_INFO);
+		}
+
+		g_object_unref (new_info);
+	}
+	caja_file_operation_complete (op, NULL, error);
+	if (error) {
+		g_error_free (error);
+	}
+}
+
+static void
+rename_callback (GObject *source_object,
+		 GAsyncResult *res,
+		 gpointer callback_data)
+{
+	CajaFileOperation *op;
+	GFile *new_file;
+	GError *error;
+
+	op = callback_data;
+
+	error = NULL;
+	new_file = g_file_set_display_name_finish (G_FILE (source_object),
+						   res, &error);
+
+	if (new_file != NULL) {
+		g_file_query_info_async (new_file,
+					 CAJA_FILE_DEFAULT_ATTRIBUTES,
+					 0,
+					 G_PRIORITY_DEFAULT,
+					 op->cancellable,
+					 rename_get_info_callback, op);
+	} else {
+		caja_file_operation_complete (op, NULL, error);
+		g_error_free (error);
+	}
+}
+
+static gboolean
+name_is (CajaFile *file, const char *new_name)
+{
+	const char *old_name;
+	old_name = eel_ref_str_peek (file->details->name);
+	return strcmp (new_name, old_name) == 0;
+}
+
+void
+caja_file_rename (CajaFile *file,
+		      const char *new_name,
+		      CajaFileOperationCallback callback,
+		      gpointer callback_data)
+{
+	CajaFileOperation *op;
+	char *uri;
+	char *old_name;
+	char *new_file_name;
+	gboolean success, name_changed;
+	gboolean is_renameable_desktop_file;
+	GFile *location;
+	GError *error;
+
+	g_return_if_fail (CAJA_IS_FILE (file));
+	g_return_if_fail (new_name != NULL);
+	g_return_if_fail (callback != NULL);
+
+	is_renameable_desktop_file =
+		is_desktop_file (file) && can_rename_desktop_file (file);
+
+	/* Return an error for incoming names containing path separators.
+	 * But not for .desktop files as '/' are allowed for them */
+	if (strstr (new_name, "/") != NULL && !is_renameable_desktop_file) {
+		error = g_error_new (G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
+				     _("Slashes are not allowed in filenames"));
+		(* callback) (file, NULL, error, callback_data);
+		g_error_free (error);
+		return;
+	}
+
+	/* Can't rename a file that's already gone.
+	 * We need to check this here because there may be a new
+	 * file with the same name.
+	 */
+	if (caja_file_is_gone (file)) {
+	       	/* Claim that something changed even if the rename
+		 * failed. This makes it easier for some clients who
+		 * see the "reverting" to the old name as "changing
+		 * back".
+		 */
+		caja_file_changed (file);
+		error = g_error_new (G_IO_ERROR, G_IO_ERROR_NOT_FOUND,
+				     _("File not found"));
+		(* callback) (file, NULL, error, callback_data);
+		g_error_free (error);
+		return;
+	}
+
+	/* Test the name-hasn't-changed case explicitly, for two reasons.
+	 * (1) rename returns an error if new & old are same.
+	 * (2) We don't want to send file-changed signal if nothing changed.
+	 */
+	if (!CAJA_IS_DESKTOP_ICON_FILE (file) &&
+	    !is_renameable_desktop_file &&
+	    name_is (file, new_name)) {
+		(* callback) (file, NULL, NULL, callback_data);
+		return;
+	}
+
+	/* Self-owned files can't be renamed. Test the name-not-actually-changing
+	 * case before this case.
+	 */
+	if (caja_file_is_self_owned (file)) {
+	       	/* Claim that something changed even if the rename
+		 * failed. This makes it easier for some clients who
+		 * see the "reverting" to the old name as "changing
+		 * back".
+		 */
+		caja_file_changed (file);
+		error = g_error_new (G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED,
+				     _("Toplevel files cannot be renamed"));
+
+		(* callback) (file, NULL, error, callback_data);
+		g_error_free (error);
+		return;
+	}
+
+	if (CAJA_IS_DESKTOP_ICON_FILE (file)) {
+		CajaDesktopLink *link;
+
+		link = caja_desktop_icon_file_get_link (CAJA_DESKTOP_ICON_FILE (file));
+		old_name = caja_file_get_display_name (file);
+
+		if ((old_name != NULL && strcmp (new_name, old_name) == 0)) {
+			success = TRUE;
+		} else {
+			success = (link != NULL && caja_desktop_link_rename (link, new_name));
+		}
+
+		if (success) {
+			(* callback) (file, NULL, NULL, callback_data);
+		} else {
+			error = g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED,
+					     _("Unable to rename desktop icon"));
+			(* callback) (file, NULL, error, callback_data);
+			g_error_free (error);
+		}
+
+		g_free (old_name);
+		g_object_unref (link);
+		return;
+	}
+
+	if (is_renameable_desktop_file) {
+		/* Don't actually change the name if the new name is the same.
+		 * This helps for the vfolder method where this can happen and
+		 * we want to minimize actual changes
+		 */
+		uri = caja_file_get_uri (file);
+		old_name = caja_link_local_get_text (uri);
+		if (old_name != NULL && strcmp (new_name, old_name) == 0) {
+			success = TRUE;
+			name_changed = FALSE;
+		} else {
+			success = caja_link_local_set_text (uri, new_name);
+			name_changed = TRUE;
+		}
+		g_free (old_name);
+		g_free (uri);
+
+		if (!success) {
+			error = g_error_new (G_IO_ERROR, G_IO_ERROR_FAILED,
+					     _("Unable to rename desktop file"));
+			(* callback) (file, NULL, error, callback_data);
+			g_error_free (error);
+			return;
+		}
+		new_file_name = g_strdup_printf ("%s.desktop", new_name);
+		new_file_name = g_strdelimit (new_file_name, "/", '-');
+
+		if (name_is (file, new_file_name)) {
+			if (name_changed) {
+				caja_file_invalidate_attributes (file,
+								     CAJA_FILE_ATTRIBUTE_INFO |
+								     CAJA_FILE_ATTRIBUTE_LINK_INFO);
+			}
+
+			(* callback) (file, NULL, NULL, callback_data);
+			g_free (new_file_name);
+			return;
+		}
+	} else {
+		new_file_name = g_strdup (new_name);
+	}
+
+	/* Set up a renaming operation. */
+	op = caja_file_operation_new (file, callback, callback_data);
+	op->is_rename = TRUE;
+
+	/* Do the renaming. */
+
+	location = caja_file_get_location (file);
+	g_file_set_display_name_async (location,
+				       new_file_name,
+				       G_PRIORITY_DEFAULT,
+				       op->cancellable,
+				       rename_callback,
+				       op);
+	g_free (new_file_name);
+	g_object_unref (location);
+}
+
+gboolean
+caja_file_rename_in_progress (CajaFile *file)
+{
+	GList *node;
+	CajaFileOperation *op;
+
+	for (node = file->details->operations_in_progress; node != NULL; node = node->next) {
+		op = node->data;
+		if (op->is_rename) {
+			return TRUE;
+		}
+	}
+	return FALSE;
+}
+
+void
+caja_file_cancel (CajaFile *file,
+		      CajaFileOperationCallback callback,
+		      gpointer callback_data)
+{
+	GList *node, *next;
+	CajaFileOperation *op;
+
+	for (node = file->details->operations_in_progress; node != NULL; node = next) {
+		next = node->next;
+		op = node->data;
+
+		g_assert (op->file == file);
+		if (op->callback == callback && op->callback_data == callback_data) {
+			caja_file_operation_cancel (op);
+		}
+	}
+}
+
+gboolean
+caja_file_matches_uri (CajaFile *file, const char *match_uri)
+{
+	GFile *match_file, *location;
+	gboolean result;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+	g_return_val_if_fail (match_uri != NULL, FALSE);
+
+	location = caja_file_get_location (file);
+	match_file = g_file_new_for_uri (match_uri);
+	result = g_file_equal (location, match_file);
+	g_object_unref (location);
+	g_object_unref (match_file);
+
+	return result;
+}
+
+int
+caja_file_compare_location (CajaFile *file_1,
+                                CajaFile *file_2)
+{
+	GFile *loc_a, *loc_b;
+	gboolean res;
+
+	loc_a = caja_file_get_location (file_1);
+	loc_b = caja_file_get_location (file_2);
+
+	res = !g_file_equal (loc_a, loc_b);
+
+	g_object_unref (loc_a);
+	g_object_unref (loc_b);
+
+	return (gint) res;
+}
+
+gboolean
+caja_file_is_local (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	return caja_directory_is_local (file->details->directory);
+}
+
+static void
+update_link (CajaFile *link_file, CajaFile *target_file)
+{
+	g_assert (CAJA_IS_FILE (link_file));
+	g_assert (CAJA_IS_FILE (target_file));
+
+	/* FIXME bugzilla.gnome.org 42044: If we don't put any code
+	 * here then the hash table is a waste of time.
+	 */
+}
+
+static GList *
+get_link_files (CajaFile *target_file)
+{
+	char *uri;
+	GList **link_files;
+
+	if (symbolic_links == NULL) {
+		link_files = NULL;
+	} else {
+		uri = caja_file_get_uri (target_file);
+		link_files = g_hash_table_lookup (symbolic_links, uri);
+		g_free (uri);
+	}
+	if (link_files) {
+		return caja_file_list_copy (*link_files);
+	}
+	return NULL;
+}
+
+static void
+update_links_if_target (CajaFile *target_file)
+{
+	GList *link_files, *p;
+
+	link_files = get_link_files (target_file);
+	for (p = link_files; p != NULL; p = p->next) {
+		update_link (CAJA_FILE (p->data), target_file);
+	}
+	caja_file_list_free (link_files);
+}
+
+static gboolean
+update_info_internal (CajaFile *file,
+		      GFileInfo *info,
+		      gboolean update_name)
+{
+	GList *node;
+	gboolean changed;
+	gboolean is_symlink, is_hidden, is_backup, is_mountpoint;
+	gboolean has_permissions;
+	guint32 permissions;
+	gboolean can_read, can_write, can_execute, can_delete, can_trash, can_rename, can_mount, can_unmount, can_eject;
+	gboolean can_start, can_start_degraded, can_stop, can_poll_for_media, is_media_check_automatic;
+	GDriveStartStopType start_stop_type;
+	gboolean thumbnailing_failed;
+	int uid, gid;
+	goffset size;
+	int sort_order;
+	time_t atime, mtime, ctime;
+	time_t trash_time;
+	GTimeVal g_trash_time;
+	const char * time_string;
+	const char *symlink_name, *mime_type, *selinux_context, *name, *thumbnail_path;
+	GFileType file_type;
+	GIcon *icon;
+	char *old_activation_uri;
+	const char *activation_uri;
+	const char *description;
+	const char *filesystem_id;
+	const char *trash_orig_path;
+	const char *group, *owner, *owner_real;
+	gboolean free_owner, free_group;
+
+	if (file->details->is_gone) {
+		return FALSE;
+	}
+
+	if (info == NULL) {
+		caja_file_mark_gone (file);
+		return TRUE;
+	}
+
+	file->details->file_info_is_up_to_date = TRUE;
+
+	/* FIXME bugzilla.gnome.org 42044: Need to let links that
+	 * point to the old name know that the file has been renamed.
+	 */
+
+	remove_from_link_hash_table (file);
+
+	changed = FALSE;
+
+	if (!file->details->got_file_info) {
+		changed = TRUE;
+	}
+	file->details->got_file_info = TRUE;
+
+	changed |= caja_file_set_display_name (file,
+						  g_file_info_get_display_name (info),
+						  g_file_info_get_edit_name (info),
+						  FALSE);
+
+	file_type = g_file_info_get_file_type (info);
+	if (file->details->type != file_type) {
+		changed = TRUE;
+	}
+	file->details->type = file_type;
+
+	if (!file->details->got_custom_activation_uri) {
+		activation_uri = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_TARGET_URI);
+		if (activation_uri == NULL) {
+			if (file->details->activation_uri) {
+				g_free (file->details->activation_uri);
+				file->details->activation_uri = NULL;
+				changed = TRUE;
+			}
+		} else {
+			old_activation_uri = file->details->activation_uri;
+			file->details->activation_uri = g_strdup (activation_uri);
+
+			if (old_activation_uri) {
+				if (strcmp (old_activation_uri,
+					    file->details->activation_uri) != 0) {
+					changed = TRUE;
+				}
+				g_free (old_activation_uri);
+			} else {
+				changed = TRUE;
+			}
+		}
+	}
+
+	is_symlink = g_file_info_get_is_symlink (info);
+	if (file->details->is_symlink != is_symlink) {
+		changed = TRUE;
+	}
+	file->details->is_symlink = is_symlink;
+
+	is_hidden = g_file_info_get_is_hidden (info);
+	if (file->details->is_hidden != is_hidden) {
+		changed = TRUE;
+	}
+	file->details->is_hidden = is_hidden;
+
+	is_backup = g_file_info_get_is_backup (info);
+	if (file->details->is_backup != is_backup) {
+		changed = TRUE;
+	}
+	file->details->is_backup = is_backup;
+
+	is_mountpoint = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_UNIX_IS_MOUNTPOINT);
+	if (file->details->is_mountpoint != is_mountpoint) {
+		changed = TRUE;
+	}
+	file->details->is_mountpoint = is_mountpoint;
+
+	has_permissions = g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_UNIX_MODE);
+	permissions = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE);;
+	if (file->details->has_permissions != has_permissions ||
+	    file->details->permissions != permissions) {
+		changed = TRUE;
+	}
+	file->details->has_permissions = has_permissions;
+	file->details->permissions = permissions;
+
+	/* We default to TRUE for this if we can't know */
+	can_read = TRUE;
+	can_write = TRUE;
+	can_execute = TRUE;
+	can_delete = TRUE;
+	can_trash = TRUE;
+	can_rename = TRUE;
+	can_mount = FALSE;
+	can_unmount = FALSE;
+	can_eject = FALSE;
+	can_start = FALSE;
+	can_start_degraded = FALSE;
+	can_stop = FALSE;
+	can_poll_for_media = FALSE;
+	is_media_check_automatic = FALSE;
+	start_stop_type = G_DRIVE_START_STOP_TYPE_UNKNOWN;
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_READ)) {
+		can_read = g_file_info_get_attribute_boolean (info,
+							      G_FILE_ATTRIBUTE_ACCESS_CAN_READ);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE)) {
+		can_write = g_file_info_get_attribute_boolean (info,
+							       G_FILE_ATTRIBUTE_ACCESS_CAN_WRITE);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE)) {
+		can_execute = g_file_info_get_attribute_boolean (info,
+								G_FILE_ATTRIBUTE_ACCESS_CAN_EXECUTE);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE)) {
+		can_delete = g_file_info_get_attribute_boolean (info,
+								G_FILE_ATTRIBUTE_ACCESS_CAN_DELETE);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH)) {
+		can_trash = g_file_info_get_attribute_boolean (info,
+							       G_FILE_ATTRIBUTE_ACCESS_CAN_TRASH);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME)) {
+		can_rename = g_file_info_get_attribute_boolean (info,
+								G_FILE_ATTRIBUTE_ACCESS_CAN_RENAME);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT)) {
+		can_mount = g_file_info_get_attribute_boolean (info,
+							       G_FILE_ATTRIBUTE_MOUNTABLE_CAN_MOUNT);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT)) {
+		can_unmount = g_file_info_get_attribute_boolean (info,
+								 G_FILE_ATTRIBUTE_MOUNTABLE_CAN_UNMOUNT);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT)) {
+		can_eject = g_file_info_get_attribute_boolean (info,
+							       G_FILE_ATTRIBUTE_MOUNTABLE_CAN_EJECT);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START)) {
+		can_start = g_file_info_get_attribute_boolean (info,
+							       G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED)) {
+		can_start_degraded = g_file_info_get_attribute_boolean (info,
+							       G_FILE_ATTRIBUTE_MOUNTABLE_CAN_START_DEGRADED);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP)) {
+		can_stop = g_file_info_get_attribute_boolean (info,
+							      G_FILE_ATTRIBUTE_MOUNTABLE_CAN_STOP);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE)) {
+		start_stop_type = g_file_info_get_attribute_uint32 (info,
+								    G_FILE_ATTRIBUTE_MOUNTABLE_START_STOP_TYPE);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL)) {
+		can_poll_for_media = g_file_info_get_attribute_boolean (info,
+									G_FILE_ATTRIBUTE_MOUNTABLE_CAN_POLL);
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC)) {
+		is_media_check_automatic = g_file_info_get_attribute_boolean (info,
+									      G_FILE_ATTRIBUTE_MOUNTABLE_IS_MEDIA_CHECK_AUTOMATIC);
+	}
+	if (file->details->can_read != can_read ||
+	    file->details->can_write != can_write ||
+	    file->details->can_execute != can_execute ||
+	    file->details->can_delete != can_delete ||
+	    file->details->can_trash != can_trash ||
+	    file->details->can_rename != can_rename ||
+	    file->details->can_mount != can_mount ||
+	    file->details->can_unmount != can_unmount ||
+	    file->details->can_eject != can_eject ||
+	    file->details->can_start != can_start ||
+	    file->details->can_start_degraded != can_start_degraded ||
+	    file->details->can_stop != can_stop ||
+	    file->details->start_stop_type != start_stop_type ||
+	    file->details->can_poll_for_media != can_poll_for_media ||
+	    file->details->is_media_check_automatic != is_media_check_automatic) {
+		changed = TRUE;
+	}
+
+	file->details->can_read = can_read;
+	file->details->can_write = can_write;
+	file->details->can_execute = can_execute;
+	file->details->can_delete = can_delete;
+	file->details->can_trash = can_trash;
+	file->details->can_rename = can_rename;
+	file->details->can_mount = can_mount;
+	file->details->can_unmount = can_unmount;
+	file->details->can_eject = can_eject;
+	file->details->can_start = can_start;
+	file->details->can_start_degraded = can_start_degraded;
+	file->details->can_stop = can_stop;
+	file->details->start_stop_type = start_stop_type;
+	file->details->can_poll_for_media = can_poll_for_media;
+	file->details->is_media_check_automatic = is_media_check_automatic;
+
+	free_owner = FALSE;
+	owner = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_OWNER_USER);
+	owner_real = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_OWNER_USER_REAL);
+	free_group = FALSE;
+	group = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_OWNER_GROUP);
+
+	uid = -1;
+	gid = -1;
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_UNIX_UID)) {
+		uid = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_UID);
+		if (owner == NULL) {
+			free_owner = TRUE;
+			owner = g_strdup_printf ("%d", uid);
+		}
+	}
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_UNIX_GID)) {
+		gid = g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_GID);
+		if (group == NULL) {
+			free_group = TRUE;
+			group = g_strdup_printf ("%d", gid);
+		}
+	}
+	if (file->details->uid != uid ||
+	    file->details->gid != gid) {
+		changed = TRUE;
+	}
+	file->details->uid = uid;
+	file->details->gid = gid;
+
+	if (eel_strcmp (eel_ref_str_peek (file->details->owner), owner) != 0) {
+		changed = TRUE;
+		eel_ref_str_unref (file->details->owner);
+		file->details->owner = eel_ref_str_get_unique (owner);
+	}
+
+	if (eel_strcmp (eel_ref_str_peek (file->details->owner_real), owner_real) != 0) {
+		changed = TRUE;
+		eel_ref_str_unref (file->details->owner_real);
+		file->details->owner_real = eel_ref_str_get_unique (owner_real);
+	}
+
+	if (eel_strcmp (eel_ref_str_peek (file->details->group), group) != 0) {
+		changed = TRUE;
+		eel_ref_str_unref (file->details->group);
+		file->details->group = eel_ref_str_get_unique (group);
+	}
+
+	if (free_owner) {
+		g_free ((char *)owner);
+	}
+	if (free_group) {
+		g_free ((char *)group);
+	}
+
+	size = -1;
+	if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SIZE)) {
+		size = g_file_info_get_size (info);
+	}
+	if (file->details->size != size) {
+		changed = TRUE;
+	}
+	file->details->size = size;
+
+	sort_order = g_file_info_get_sort_order (info);
+	if (file->details->sort_order != sort_order) {
+		changed = TRUE;
+	}
+	file->details->sort_order = sort_order;
+
+	atime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_ACCESS);
+	ctime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_CHANGED);
+	mtime = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_TIME_MODIFIED);
+	if (file->details->atime != atime ||
+	    file->details->mtime != mtime ||
+	    file->details->ctime != ctime) {
+		if (file->details->thumbnail == NULL) {
+			file->details->thumbnail_is_up_to_date = FALSE;
+		}
+
+		changed = TRUE;
+	}
+	file->details->atime = atime;
+	file->details->ctime = ctime;
+	file->details->mtime = mtime;
+
+	if (file->details->thumbnail != NULL &&
+	    file->details->thumbnail_mtime != 0 &&
+	    file->details->thumbnail_mtime != mtime) {
+		file->details->thumbnail_is_up_to_date = FALSE;
+		changed = TRUE;
+	}
+
+	icon = g_file_info_get_icon (info);
+	if (!g_icon_equal (icon, file->details->icon)) {
+		changed = TRUE;
+
+		if (file->details->icon) {
+			g_object_unref (file->details->icon);
+		}
+		file->details->icon = g_object_ref (icon);
+	}
+
+	thumbnail_path =  g_file_info_get_attribute_byte_string (info, G_FILE_ATTRIBUTE_THUMBNAIL_PATH);
+	if (eel_strcmp (file->details->thumbnail_path, thumbnail_path) != 0) {
+		changed = TRUE;
+		g_free (file->details->thumbnail_path);
+		file->details->thumbnail_path = g_strdup (thumbnail_path);
+	}
+
+	thumbnailing_failed =  g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_THUMBNAILING_FAILED);
+	if (file->details->thumbnailing_failed != thumbnailing_failed) {
+		changed = TRUE;
+		file->details->thumbnailing_failed = thumbnailing_failed;
+	}
+
+	symlink_name = g_file_info_get_symlink_target (info);
+	if (eel_strcmp (file->details->symlink_name, symlink_name) != 0) {
+		changed = TRUE;
+		g_free (file->details->symlink_name);
+		file->details->symlink_name = g_strdup (symlink_name);
+	}
+
+	mime_type = g_file_info_get_content_type (info);
+	if (eel_strcmp (eel_ref_str_peek (file->details->mime_type), mime_type) != 0) {
+		changed = TRUE;
+		eel_ref_str_unref (file->details->mime_type);
+		file->details->mime_type = eel_ref_str_get_unique (mime_type);
+	}
+
+	selinux_context = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_SELINUX_CONTEXT);
+	if (eel_strcmp (file->details->selinux_context, selinux_context) != 0) {
+		changed = TRUE;
+		g_free (file->details->selinux_context);
+		file->details->selinux_context = g_strdup (selinux_context);
+	}
+
+	description = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_STANDARD_DESCRIPTION);
+	if (eel_strcmp (file->details->description, description) != 0) {
+		changed = TRUE;
+		g_free (file->details->description);
+		file->details->description = g_strdup (description);
+	}
+
+	filesystem_id = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILESYSTEM);
+	if (eel_strcmp (eel_ref_str_peek (file->details->filesystem_id), filesystem_id) != 0) {
+		changed = TRUE;
+		eel_ref_str_unref (file->details->filesystem_id);
+		file->details->filesystem_id = eel_ref_str_get_unique (filesystem_id);
+	}
+
+	trash_time = 0;
+	time_string = g_file_info_get_attribute_string (info, "trash::deletion-date");
+	if (time_string != NULL) {
+		g_time_val_from_iso8601 (time_string, &g_trash_time);
+		trash_time = g_trash_time.tv_sec;
+	}
+	if (file->details->trash_time != trash_time) {
+		changed = TRUE;
+		file->details->trash_time = trash_time;
+	}
+
+	trash_orig_path = g_file_info_get_attribute_byte_string (info, "trash::orig-path");
+	if (eel_strcmp (file->details->trash_orig_path, trash_orig_path) != 0) {
+		changed = TRUE;
+		g_free (file->details->trash_orig_path);
+		file->details->trash_orig_path = g_strdup (trash_orig_path);
+	}
+
+	changed |=
+		caja_file_update_metadata_from_info (file, info);
+
+	if (update_name) {
+		name = g_file_info_get_name (info);
+		if (file->details->name == NULL ||
+		    strcmp (eel_ref_str_peek (file->details->name), name) != 0) {
+			changed = TRUE;
+
+			node = caja_directory_begin_file_name_change
+				(file->details->directory, file);
+
+			eel_ref_str_unref (file->details->name);
+			if (eel_strcmp (eel_ref_str_peek (file->details->display_name),
+					name) == 0) {
+				file->details->name = eel_ref_str_ref (file->details->display_name);
+			} else {
+				file->details->name = eel_ref_str_new (name);
+			}
+
+			if (!file->details->got_custom_display_name &&
+			    g_file_info_get_display_name (info) == NULL) {
+				/* If the file info's display name is NULL,
+				 * caja_file_set_display_name() did
+				 * not unset the display name.
+				 */
+				caja_file_clear_display_name (file);
+			}
+
+			caja_directory_end_file_name_change
+				(file->details->directory, file, node);
+		}
+	}
+
+	if (changed) {
+		add_to_link_hash_table (file);
+
+		update_links_if_target (file);
+	}
+
+	return changed;
+}
+
+static gboolean
+update_info_and_name (CajaFile *file,
+		      GFileInfo *info)
+{
+	return update_info_internal (file, info, TRUE);
+}
+
+gboolean
+caja_file_update_info (CajaFile *file,
+			   GFileInfo *info)
+{
+	return update_info_internal (file, info, FALSE);
+}
+
+static gboolean
+update_name_internal (CajaFile *file,
+		      const char *name,
+		      gboolean in_directory)
+{
+	GList *node;
+
+	g_assert (name != NULL);
+
+	if (file->details->is_gone) {
+		return FALSE;
+	}
+
+	if (name_is (file, name)) {
+		return FALSE;
+	}
+
+	node = NULL;
+	if (in_directory) {
+		node = caja_directory_begin_file_name_change
+			(file->details->directory, file);
+	}
+
+	eel_ref_str_unref (file->details->name);
+	file->details->name = eel_ref_str_new (name);
+
+	if (!file->details->got_custom_display_name) {
+		caja_file_clear_display_name (file);
+	}
+
+	if (in_directory) {
+		caja_directory_end_file_name_change
+			(file->details->directory, file, node);
+	}
+
+	return TRUE;
+}
+
+gboolean
+caja_file_update_name (CajaFile *file, const char *name)
+{
+	gboolean ret;
+
+	ret = update_name_internal (file, name, TRUE);
+
+	if (ret) {
+		update_links_if_target (file);
+	}
+
+	return ret;
+}
+
+gboolean
+caja_file_update_name_and_directory (CajaFile *file,
+					 const char *name,
+					 CajaDirectory *new_directory)
+{
+	CajaDirectory *old_directory;
+	FileMonitors *monitors;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+	g_return_val_if_fail (CAJA_IS_DIRECTORY (file->details->directory), FALSE);
+	g_return_val_if_fail (!file->details->is_gone, FALSE);
+	g_return_val_if_fail (!caja_file_is_self_owned (file), FALSE);
+	g_return_val_if_fail (CAJA_IS_DIRECTORY (new_directory), FALSE);
+
+	old_directory = file->details->directory;
+	if (old_directory == new_directory) {
+		if (name) {
+			return update_name_internal (file, name, TRUE);
+		} else {
+			return FALSE;
+		}
+	}
+
+	caja_file_ref (file);
+
+	/* FIXME bugzilla.gnome.org 42044: Need to let links that
+	 * point to the old name know that the file has been moved.
+	 */
+
+	remove_from_link_hash_table (file);
+
+	monitors = caja_directory_remove_file_monitors (old_directory, file);
+	caja_directory_remove_file (old_directory, file);
+
+	file->details->directory = caja_directory_ref (new_directory);
+	caja_directory_unref (old_directory);
+
+	if (name) {
+		update_name_internal (file, name, FALSE);
+	}
+
+	caja_directory_add_file (new_directory, file);
+	caja_directory_add_file_monitors (new_directory, file, monitors);
+
+	add_to_link_hash_table (file);
+
+	update_links_if_target (file);
+
+	caja_file_unref (file);
+
+	return TRUE;
+}
+
+void
+caja_file_set_directory (CajaFile *file,
+			     CajaDirectory *new_directory)
+{
+	caja_file_update_name_and_directory (file, NULL, new_directory);
+}
+
+static Knowledge
+get_item_count (CajaFile *file,
+		guint *count)
+{
+	gboolean known, unreadable;
+
+	known = caja_file_get_directory_item_count
+		(file, count, &unreadable);
+	if (!known) {
+		return UNKNOWN;
+	}
+	if (unreadable) {
+		return UNKNOWABLE;
+	}
+	return KNOWN;
+}
+
+static Knowledge
+get_size (CajaFile *file,
+	  goffset *size)
+{
+	/* If we tried and failed, then treat it like there is no size
+	 * to know.
+	 */
+	if (file->details->get_info_failed) {
+		return UNKNOWABLE;
+	}
+
+	/* If the info is NULL that means we haven't even tried yet,
+	 * so it's just unknown, not unknowable.
+	 */
+	if (!file->details->got_file_info) {
+		return UNKNOWN;
+	}
+
+	/* If we got info with no size in it, it means there is no
+	 * such thing as a size as far as mate-vfs is concerned,
+	 * so "unknowable".
+	 */
+	if (file->details->size == -1) {
+		return UNKNOWABLE;
+	}
+
+	/* We have a size! */
+	*size = file->details->size;
+	return KNOWN;
+}
+
+static Knowledge
+get_time (CajaFile *file,
+	  time_t *time_out,
+	  CajaDateType type)
+{
+	time_t time;
+
+	/* If we tried and failed, then treat it like there is no size
+	 * to know.
+	 */
+	if (file->details->get_info_failed) {
+		return UNKNOWABLE;
+	}
+
+	/* If the info is NULL that means we haven't even tried yet,
+	 * so it's just unknown, not unknowable.
+	 */
+	if (!file->details->got_file_info) {
+		return UNKNOWN;
+	}
+
+	time = 0;
+	switch (type) {
+	case CAJA_DATE_TYPE_MODIFIED:
+		time = file->details->mtime;
+		break;
+	case CAJA_DATE_TYPE_ACCESSED:
+		time = file->details->atime;
+		break;
+	case CAJA_DATE_TYPE_TRASHED:
+		time = file->details->trash_time;
+		break;
+	default:
+		g_assert_not_reached ();
+		break;
+	}
+
+	*time_out = time;
+
+	/* If we got info with no modification time in it, it means
+	 * there is no such thing as a modification time as far as
+	 * mate-vfs is concerned, so "unknowable".
+	 */
+	if (time == 0) {
+		return UNKNOWABLE;
+	}
+	return KNOWN;
+}
+
+static int
+compare_directories_by_count (CajaFile *file_1, CajaFile *file_2)
+{
+	/* Sort order:
+	 *   Directories with unknown # of items
+	 *   Directories with "unknowable" # of items
+	 *   Directories with 0 items
+	 *   Directories with n items
+	 */
+
+	Knowledge count_known_1, count_known_2;
+	guint count_1, count_2;
+
+	count_known_1 = get_item_count (file_1, &count_1);
+	count_known_2 = get_item_count (file_2, &count_2);
+
+	if (count_known_1 > count_known_2) {
+		return -1;
+	}
+	if (count_known_1 < count_known_2) {
+		return +1;
+	}
+
+	/* count_known_1 and count_known_2 are equal now. Check if count
+	 * details are UNKNOWABLE or UNKNOWN.
+	 */
+	if (count_known_1 == UNKNOWABLE || count_known_1 == UNKNOWN) {
+		return 0;
+	}
+
+	if (count_1 < count_2) {
+		return -1;
+	}
+	if (count_1 > count_2) {
+		return +1;
+	}
+
+	return 0;
+}
+
+static int
+compare_files_by_size (CajaFile *file_1, CajaFile *file_2)
+{
+	/* Sort order:
+	 *   Files with unknown size.
+	 *   Files with "unknowable" size.
+	 *   Files with smaller sizes.
+	 *   Files with large sizes.
+	 */
+
+	Knowledge size_known_1, size_known_2;
+	goffset size_1, size_2;
+
+	size_known_1 = get_size (file_1, &size_1);
+	size_known_2 = get_size (file_2, &size_2);
+
+	if (size_known_1 > size_known_2) {
+		return -1;
+	}
+	if (size_known_1 < size_known_2) {
+		return +1;
+	}
+
+	/* size_known_1 and size_known_2 are equal now. Check if size
+	 * details are UNKNOWABLE or UNKNOWN
+	 */
+	if (size_known_1 == UNKNOWABLE || size_known_1 == UNKNOWN) {
+		return 0;
+	}
+
+	if (size_1 < size_2) {
+		return -1;
+	}
+	if (size_1 > size_2) {
+		return +1;
+	}
+
+	return 0;
+}
+
+static int
+compare_by_size (CajaFile *file_1, CajaFile *file_2)
+{
+	/* Sort order:
+	 *   Directories with n items
+	 *   Directories with 0 items
+	 *   Directories with "unknowable" # of items
+	 *   Directories with unknown # of items
+	 *   Files with large sizes.
+	 *   Files with smaller sizes.
+	 *   Files with "unknowable" size.
+	 *   Files with unknown size.
+	 */
+
+	gboolean is_directory_1, is_directory_2;
+
+	is_directory_1 = caja_file_is_directory (file_1);
+	is_directory_2 = caja_file_is_directory (file_2);
+
+	if (is_directory_1 && !is_directory_2) {
+		return -1;
+	}
+	if (is_directory_2 && !is_directory_1) {
+		return +1;
+	}
+
+	if (is_directory_1) {
+		return compare_directories_by_count (file_1, file_2);
+	} else {
+		return compare_files_by_size (file_1, file_2);
+	}
+}
+
+static int
+compare_by_display_name (CajaFile *file_1, CajaFile *file_2)
+{
+	const char *name_1, *name_2;
+	const char *key_1, *key_2;
+	gboolean sort_last_1, sort_last_2;
+	int compare;
+
+	name_1 = caja_file_peek_display_name (file_1);
+	name_2 = caja_file_peek_display_name (file_2);
+
+	sort_last_1 = name_1[0] == SORT_LAST_CHAR1 || name_1[0] == SORT_LAST_CHAR2;
+	sort_last_2 = name_2[0] == SORT_LAST_CHAR1 || name_2[0] == SORT_LAST_CHAR2;
+
+	if (sort_last_1 && !sort_last_2) {
+		compare = +1;
+	} else if (!sort_last_1 && sort_last_2) {
+		compare = -1;
+	} else {
+		key_1 = caja_file_peek_display_name_collation_key (file_1);
+		key_2 = caja_file_peek_display_name_collation_key (file_2);
+		compare = strcmp (key_1, key_2);
+	}
+
+	return compare;
+}
+
+static int
+compare_by_directory_name (CajaFile *file_1, CajaFile *file_2)
+{
+	char *directory_1, *directory_2;
+	int compare;
+
+	if (file_1->details->directory == file_2->details->directory) {
+		return 0;
+	}
+
+	directory_1 = caja_file_get_parent_uri_for_display (file_1);
+	directory_2 = caja_file_get_parent_uri_for_display (file_2);
+
+	compare = g_utf8_collate (directory_1, directory_2);
+
+	g_free (directory_1);
+	g_free (directory_2);
+
+	return compare;
+}
+
+static gboolean
+file_has_note (CajaFile *file)
+{
+	char *note;
+	gboolean res;
+
+	note = caja_file_get_metadata (file, CAJA_METADATA_KEY_ANNOTATION, NULL);
+	res = note != NULL && note[0] != 0;
+	g_free (note);
+
+	return res;
+}
+
+static GList *
+prepend_automatic_keywords (CajaFile *file,
+			    GList *names)
+{
+	/* Prepend in reverse order. */
+	CajaFile *parent;
+
+	parent = caja_file_get_parent (file);
+
+#ifdef TRASH_IS_FAST_ENOUGH
+	if (caja_file_is_in_trash (file)) {
+		names = g_list_prepend
+			(names, g_strdup (CAJA_FILE_EMBLEM_NAME_TRASH));
+	}
+#endif
+	if (file_has_note (file)) {
+		names = g_list_prepend
+			(names, g_strdup (CAJA_FILE_EMBLEM_NAME_NOTE));
+	}
+
+	/* Trash files are assumed to be read-only,
+	 * so we want to ignore them here. */
+	if (!caja_file_can_write (file) &&
+	    !caja_file_is_in_trash (file) &&
+	    (parent == NULL || caja_file_can_write (parent))) {
+		names = g_list_prepend
+			(names, g_strdup (CAJA_FILE_EMBLEM_NAME_CANT_WRITE));
+	}
+	if (!caja_file_can_read (file)) {
+		names = g_list_prepend
+			(names, g_strdup (CAJA_FILE_EMBLEM_NAME_CANT_READ));
+	}
+	if (caja_file_is_symbolic_link (file)) {
+		names = g_list_prepend
+			(names, g_strdup (CAJA_FILE_EMBLEM_NAME_SYMBOLIC_LINK));
+	}
+
+	if (parent) {
+		caja_file_unref (parent);
+	}
+
+
+	return names;
+}
+
+static void
+fill_emblem_cache_if_needed (CajaFile *file)
+{
+	GList *node, *keywords;
+	char *scanner;
+	size_t length;
+
+	if (file->details->compare_by_emblem_cache != NULL) {
+		/* Got a cache already. */
+		return;
+	}
+
+	keywords = caja_file_get_keywords (file);
+
+	/* Add up the keyword string lengths */
+	length = 1;
+	for (node = keywords; node != NULL; node = node->next) {
+		length += strlen ((const char *) node->data) + 1;
+	}
+
+	/* Now that we know how large the cache struct needs to be, allocate it. */
+	file->details->compare_by_emblem_cache = g_malloc (sizeof(CajaFileSortByEmblemCache) + length);
+
+	/* Copy them into the cache. */
+	scanner = file->details->compare_by_emblem_cache->emblem_keywords;
+	for (node = keywords; node != NULL; node = node->next) {
+		length = strlen ((const char *) node->data) + 1;
+		memcpy (scanner, (const char *) node->data, length);
+		scanner += length;
+	}
+
+	/* Zero-terminate so we can tell where the list ends. */
+	*scanner = 0;
+
+	eel_g_list_free_deep (keywords);
+}
+
+static int
+compare_by_emblems (CajaFile *file_1, CajaFile *file_2)
+{
+	const char *keyword_cache_1, *keyword_cache_2;
+	size_t length;
+	int compare_result;
+
+	fill_emblem_cache_if_needed (file_1);
+	fill_emblem_cache_if_needed (file_2);
+
+	/* We ignore automatic emblems, and only sort by user-added keywords. */
+	compare_result = 0;
+	keyword_cache_1 = file_1->details->compare_by_emblem_cache->emblem_keywords;
+	keyword_cache_2 = file_2->details->compare_by_emblem_cache->emblem_keywords;
+	for (; *keyword_cache_1 != '\0' && *keyword_cache_2 != '\0';) {
+		compare_result = g_utf8_collate (keyword_cache_1, keyword_cache_2);
+		if (compare_result != 0) {
+			return compare_result;
+		}
+
+		/* Advance to the next keyword */
+		length = strlen (keyword_cache_1);
+		keyword_cache_1 += length + 1;
+		keyword_cache_2 += length + 1;
+	}
+
+
+	/* One or both is now NULL. */
+	if (*keyword_cache_1 != '\0') {
+		g_assert (*keyword_cache_2 == '\0');
+		return -1;
+	} else if (*keyword_cache_2 != '\0') {
+		return +1;
+	}
+
+	return 0;
+}
+
+static int
+compare_by_type (CajaFile *file_1, CajaFile *file_2)
+{
+	gboolean is_directory_1;
+	gboolean is_directory_2;
+	char *type_string_1;
+	char *type_string_2;
+	int result;
+
+	/* Directories go first. Then, if mime types are identical,
+	 * don't bother getting strings (for speed). This assumes
+	 * that the string is dependent entirely on the mime type,
+	 * which is true now but might not be later.
+	 */
+	is_directory_1 = caja_file_is_directory (file_1);
+	is_directory_2 = caja_file_is_directory (file_2);
+
+	if (is_directory_1 && is_directory_2) {
+		return 0;
+	}
+
+	if (is_directory_1) {
+		return -1;
+	}
+
+	if (is_directory_2) {
+		return +1;
+	}
+
+	if (file_1->details->mime_type != NULL &&
+	    file_2->details->mime_type != NULL &&
+	    strcmp (eel_ref_str_peek (file_1->details->mime_type),
+		    eel_ref_str_peek (file_2->details->mime_type)) == 0) {
+		return 0;
+	}
+
+	type_string_1 = caja_file_get_type_as_string (file_1);
+	type_string_2 = caja_file_get_type_as_string (file_2);
+
+	result = g_utf8_collate (type_string_1, type_string_2);
+
+	g_free (type_string_1);
+	g_free (type_string_2);
+
+	return result;
+}
+
+static int
+compare_by_time (CajaFile *file_1, CajaFile *file_2, CajaDateType type)
+{
+	/* Sort order:
+	 *   Files with unknown times.
+	 *   Files with "unknowable" times.
+	 *   Files with older times.
+	 *   Files with newer times.
+	 */
+
+	Knowledge time_known_1, time_known_2;
+	time_t time_1, time_2;
+
+	time_1 = 0;
+	time_2 = 0;
+
+	time_known_1 = get_time (file_1, &time_1, type);
+	time_known_2 = get_time (file_2, &time_2, type);
+
+	if (time_known_1 > time_known_2) {
+		return -1;
+	}
+	if (time_known_1 < time_known_2) {
+		return +1;
+	}
+
+	/* Now time_known_1 is equal to time_known_2. Check whether
+	 * we failed to get modification times for files
+	 */
+	if(time_known_1 == UNKNOWABLE || time_known_1 == UNKNOWN) {
+		return 0;
+	}
+
+	if (time_1 < time_2) {
+		return -1;
+	}
+	if (time_1 > time_2) {
+		return +1;
+	}
+
+	return 0;
+}
+
+static int
+compare_by_full_path (CajaFile *file_1, CajaFile *file_2)
+{
+	int compare;
+
+	compare = compare_by_directory_name (file_1, file_2);
+	if (compare != 0) {
+		return compare;
+	}
+	return compare_by_display_name (file_1, file_2);
+}
+
+static int
+caja_file_compare_for_sort_internal (CajaFile *file_1,
+					 CajaFile *file_2,
+					 gboolean directories_first,
+					 gboolean reversed)
+{
+	gboolean is_directory_1, is_directory_2;
+
+	if (directories_first) {
+		is_directory_1 = caja_file_is_directory (file_1);
+		is_directory_2 = caja_file_is_directory (file_2);
+
+		if (is_directory_1 && !is_directory_2) {
+			return -1;
+		}
+
+		if (is_directory_2 && !is_directory_1) {
+			return +1;
+		}
+	}
+
+	if (file_1->details->sort_order < file_2->details->sort_order) {
+		return reversed ? 1 : -1;
+	} else if (file_1->details->sort_order > file_2->details->sort_order) {
+		return reversed ? -1 : 1;
+	}
+
+	return 0;
+}
+
+/**
+ * caja_file_compare_for_sort:
+ * @file_1: A file object
+ * @file_2: Another file object
+ * @sort_type: Sort criterion
+ * @directories_first: Put all directories before any non-directories
+ * @reversed: Reverse the order of the items, except that
+ * the directories_first flag is still respected.
+ *
+ * Return value: int < 0 if @file_1 should come before file_2 in a
+ * sorted list; int > 0 if @file_2 should come before file_1 in a
+ * sorted list; 0 if @file_1 and @file_2 are equal for this sort criterion. Note
+ * that each named sort type may actually break ties several ways, with the name
+ * of the sort criterion being the primary but not only differentiator.
+ **/
+int
+caja_file_compare_for_sort (CajaFile *file_1,
+				CajaFile *file_2,
+				CajaFileSortType sort_type,
+				gboolean directories_first,
+				gboolean reversed)
+{
+	int result;
+
+	if (file_1 == file_2) {
+		return 0;
+	}
+
+	result = caja_file_compare_for_sort_internal (file_1, file_2, directories_first, reversed);
+
+	if (result == 0) {
+		switch (sort_type) {
+		case CAJA_FILE_SORT_BY_DISPLAY_NAME:
+			result = compare_by_display_name (file_1, file_2);
+			if (result == 0) {
+				result = compare_by_directory_name (file_1, file_2);
+			}
+			break;
+		case CAJA_FILE_SORT_BY_DIRECTORY:
+			result = compare_by_full_path (file_1, file_2);
+			break;
+		case CAJA_FILE_SORT_BY_SIZE:
+			/* Compare directory sizes ourselves, then if necessary
+			 * use MateVFS to compare file sizes.
+			 */
+			result = compare_by_size (file_1, file_2);
+			if (result == 0) {
+				result = compare_by_full_path (file_1, file_2);
+			}
+			break;
+		case CAJA_FILE_SORT_BY_TYPE:
+			/* MateVFS doesn't know about our special text for certain
+			 * mime types, so we handle the mime-type sorting ourselves.
+			 */
+			result = compare_by_type (file_1, file_2);
+			if (result == 0) {
+				result = compare_by_full_path (file_1, file_2);
+			}
+			break;
+		case CAJA_FILE_SORT_BY_MTIME:
+			result = compare_by_time (file_1, file_2, CAJA_DATE_TYPE_MODIFIED);
+			if (result == 0) {
+				result = compare_by_full_path (file_1, file_2);
+			}
+			break;
+		case CAJA_FILE_SORT_BY_ATIME:
+			result = compare_by_time (file_1, file_2, CAJA_DATE_TYPE_ACCESSED);
+			if (result == 0) {
+				result = compare_by_full_path (file_1, file_2);
+			}
+			break;
+		case CAJA_FILE_SORT_BY_TRASHED_TIME:
+			result = compare_by_time (file_1, file_2, CAJA_DATE_TYPE_TRASHED);
+			if (result == 0) {
+				result = compare_by_full_path (file_1, file_2);
+			}
+			break;
+		case CAJA_FILE_SORT_BY_EMBLEMS:
+			/* MateVFS doesn't know squat about our emblems, so
+			 * we handle comparing them here, before falling back
+			 * to tie-breakers.
+			 */
+			result = compare_by_emblems (file_1, file_2);
+			if (result == 0) {
+				result = compare_by_full_path (file_1, file_2);
+			}
+			break;
+		default:
+			g_return_val_if_reached (0);
+		}
+
+		if (reversed) {
+			result = -result;
+		}
+	}
+
+	return result;
+}
+
+int
+caja_file_compare_for_sort_by_attribute_q   (CajaFile                   *file_1,
+						 CajaFile                   *file_2,
+						 GQuark                          attribute,
+						 gboolean                        directories_first,
+						 gboolean                        reversed)
+{
+	int result;
+
+	if (file_1 == file_2) {
+		return 0;
+	}
+
+	/* Convert certain attributes into CajaFileSortTypes and use
+	 * caja_file_compare_for_sort()
+	 */
+	if (attribute == 0 || attribute == attribute_name_q) {
+		return caja_file_compare_for_sort (file_1, file_2,
+						       CAJA_FILE_SORT_BY_DISPLAY_NAME,
+						       directories_first,
+						       reversed);
+	} else if (attribute == attribute_size_q) {
+		return caja_file_compare_for_sort (file_1, file_2,
+						       CAJA_FILE_SORT_BY_SIZE,
+						       directories_first,
+						       reversed);
+	} else if (attribute == attribute_type_q) {
+		return caja_file_compare_for_sort (file_1, file_2,
+						       CAJA_FILE_SORT_BY_TYPE,
+						       directories_first,
+						       reversed);
+	} else if (attribute == attribute_modification_date_q || attribute == attribute_date_modified_q) {
+		return caja_file_compare_for_sort (file_1, file_2,
+						       CAJA_FILE_SORT_BY_MTIME,
+						       directories_first,
+						       reversed);
+        } else if (attribute == attribute_accessed_date_q || attribute == attribute_date_accessed_q) {
+		return caja_file_compare_for_sort (file_1, file_2,
+						       CAJA_FILE_SORT_BY_ATIME,
+						       directories_first,
+						       reversed);
+        } else if (attribute == attribute_trashed_on_q) {
+		return caja_file_compare_for_sort (file_1, file_2,
+						       CAJA_FILE_SORT_BY_TRASHED_TIME,
+						       directories_first,
+						       reversed);
+	} else if (attribute == attribute_emblems_q) {
+		return caja_file_compare_for_sort (file_1, file_2,
+						       CAJA_FILE_SORT_BY_EMBLEMS,
+						       directories_first,
+						       reversed);
+	}
+
+	/* it is a normal attribute, compare by strings */
+
+	result = caja_file_compare_for_sort_internal (file_1, file_2, directories_first, reversed);
+
+	if (result == 0) {
+		char *value_1;
+		char *value_2;
+
+		value_1 = caja_file_get_string_attribute_q (file_1,
+								attribute);
+		value_2 = caja_file_get_string_attribute_q (file_2,
+								attribute);
+
+		if (value_1 != NULL && value_2 != NULL) {
+			result = strcmp (value_1, value_2);
+		}
+
+		g_free (value_1);
+		g_free (value_2);
+
+		if (reversed) {
+			result = -result;
+		}
+	}
+
+	return result;
+}
+
+int
+caja_file_compare_for_sort_by_attribute     (CajaFile                   *file_1,
+						 CajaFile                   *file_2,
+						 const char                     *attribute,
+						 gboolean                        directories_first,
+						 gboolean                        reversed)
+{
+	return caja_file_compare_for_sort_by_attribute_q (file_1, file_2,
+							      g_quark_from_string (attribute),
+							      directories_first,
+							      reversed);
+}
+
+
+/**
+ * caja_file_compare_name:
+ * @file: A file object
+ * @pattern: A string we are comparing it with
+ *
+ * Return value: result of a comparison of the file name and the given pattern,
+ * using the same sorting order as sort by name.
+ **/
+int
+caja_file_compare_display_name (CajaFile *file,
+				    const char *pattern)
+{
+	const char *name;
+	int result;
+
+	g_return_val_if_fail (pattern != NULL, -1);
+
+	name = caja_file_peek_display_name (file);
+	result = g_utf8_collate (name, pattern);
+	return result;
+}
+
+
+gboolean
+caja_file_is_hidden_file (CajaFile *file)
+{
+	return file->details->is_hidden;
+}
+
+gboolean
+caja_file_is_backup_file (CajaFile *file)
+{
+	return file->details->is_backup;
+}
+
+static gboolean
+is_file_hidden (CajaFile *file)
+{
+	return file->details->directory->details->hidden_file_hash != NULL &&
+		g_hash_table_lookup (file->details->directory->details->hidden_file_hash,
+				     eel_ref_str_peek (file->details->name)) != NULL;
+
+}
+
+/**
+ * caja_file_should_show:
+ * @file: the file to check.
+ * @show_hidden: whether we want to show hidden files or not.
+ * @show_backup: whether we want to show backup files or not.
+ *
+ * Determines if a #CajaFile should be shown. Note that when browsing
+ * a trash directory, this function will always return %TRUE.
+ *
+ * Returns: %TRUE if the file should be shown, %FALSE if it shouldn't.
+ */
+gboolean
+caja_file_should_show (CajaFile *file,
+			   gboolean show_hidden,
+			   gboolean show_backup,
+			   gboolean show_foreign)
+{
+	/* Never hide any files in trash. */
+	if (caja_file_is_in_trash (file)) {
+		return TRUE;
+	} else {
+		return (show_hidden || (!caja_file_is_hidden_file (file) && !is_file_hidden (file))) &&
+			(show_backup || !caja_file_is_backup_file (file)) &&
+			(show_foreign || !(caja_file_is_in_desktop (file) && caja_file_is_foreign_link (file)));
+	}
+}
+
+gboolean
+caja_file_is_home (CajaFile *file)
+{
+	GFile *dir;
+
+	dir = file->details->directory->details->location;
+	if (dir == NULL) {
+		return FALSE;
+	}
+
+	return caja_is_home_directory_file (dir,
+						eel_ref_str_peek (file->details->name));
+}
+
+gboolean
+caja_file_is_in_desktop (CajaFile *file)
+{
+	if (file->details->directory->details->location) {
+		return caja_is_desktop_directory (file->details->directory->details->location);
+	}
+	return FALSE;
+
+}
+
+static gboolean
+filter_hidden_and_backup_partition_callback (gpointer data,
+					     gpointer callback_data)
+{
+	CajaFile *file;
+	FilterOptions options;
+
+	file = CAJA_FILE (data);
+	options = GPOINTER_TO_INT (callback_data);
+
+	return caja_file_should_show (file,
+					  options & SHOW_HIDDEN,
+					  options & SHOW_BACKUP,
+					  TRUE);
+}
+
+GList *
+caja_file_list_filter_hidden_and_backup (GList    *files,
+					     gboolean  show_hidden,
+					     gboolean  show_backup)
+{
+	GList *filtered_files;
+	GList *removed_files;
+
+	/* FIXME bugzilla.gnome.org 40653:
+	 * Eventually this should become a generic filtering thingy.
+	 */
+
+	filtered_files = caja_file_list_copy (files);
+	filtered_files = eel_g_list_partition (filtered_files,
+					       filter_hidden_and_backup_partition_callback,
+					       GINT_TO_POINTER ((show_hidden ? SHOW_HIDDEN : 0) |
+								(show_backup ? SHOW_BACKUP : 0)),
+					       &removed_files);
+	caja_file_list_free (removed_files);
+
+	return filtered_files;
+}
+
+char *
+caja_file_get_metadata (CajaFile *file,
+			    const char *key,
+			    const char *default_metadata)
+{
+	guint id;
+	char *value;
+
+	g_return_val_if_fail (key != NULL, g_strdup (default_metadata));
+	g_return_val_if_fail (key[0] != '\0', g_strdup (default_metadata));
+
+	if (file == NULL ||
+	    file->details->metadata == NULL) {
+		return g_strdup (default_metadata);
+	}
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), g_strdup (default_metadata));
+
+	id = caja_metadata_get_id (key);
+	value = g_hash_table_lookup (file->details->metadata, GUINT_TO_POINTER (id));
+
+	if (value) {
+		return g_strdup (value);
+	}
+	return g_strdup (default_metadata);
+}
+
+GList *
+caja_file_get_metadata_list (CajaFile *file,
+				 const char *key)
+{
+	GList *res;
+	guint id;
+	char **value;
+	int i;
+
+	g_return_val_if_fail (key != NULL, NULL);
+	g_return_val_if_fail (key[0] != '\0', NULL);
+
+	if (file == NULL ||
+	    file->details->metadata == NULL) {
+		return NULL;
+	}
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+	id = caja_metadata_get_id (key);
+	id |= METADATA_ID_IS_LIST_MASK;
+
+	value = g_hash_table_lookup (file->details->metadata, GUINT_TO_POINTER (id));
+
+	if (value) {
+		res = NULL;
+		for (i = 0; value[i] != NULL; i++) {
+			res = g_list_prepend (res, g_strdup (value[i]));
+		}
+		return g_list_reverse (res);
+	}
+
+	return NULL;
+}
+
+void
+caja_file_set_metadata (CajaFile *file,
+			    const char *key,
+			    const char *default_metadata,
+			    const char *metadata)
+{
+	const char *val;
+
+	g_return_if_fail (CAJA_IS_FILE (file));
+	g_return_if_fail (key != NULL);
+	g_return_if_fail (key[0] != '\0');
+
+	val = metadata;
+	if (val == NULL) {
+		val = default_metadata;
+	}
+
+	EEL_CALL_METHOD
+		(CAJA_FILE_CLASS, file,
+		 set_metadata, (file, key, val));
+}
+
+void
+caja_file_set_metadata_list (CajaFile *file,
+				 const char *key,
+				 GList *list)
+{
+	char **val;
+	int len, i;
+	GList *l;
+
+	g_return_if_fail (CAJA_IS_FILE (file));
+	g_return_if_fail (key != NULL);
+	g_return_if_fail (key[0] != '\0');
+
+	len = g_list_length (list);
+	val = g_new (char *, len + 1);
+	for (l = list, i = 0; l != NULL; l = l->next, i++) {
+		val[i] = l->data;
+	}
+	val[i] = NULL;
+
+	EEL_CALL_METHOD
+		(CAJA_FILE_CLASS, file,
+		 set_metadata_as_list, (file, key, val));
+
+	g_free (val);
+}
+
+
+gboolean
+caja_file_get_boolean_metadata (CajaFile *file,
+				    const char   *key,
+				    gboolean      default_metadata)
+{
+	char *result_as_string;
+	gboolean result;
+
+	g_return_val_if_fail (key != NULL, default_metadata);
+	g_return_val_if_fail (key[0] != '\0', default_metadata);
+
+	if (file == NULL) {
+		return default_metadata;
+	}
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), default_metadata);
+
+	result_as_string = caja_file_get_metadata
+		(file, key, default_metadata ? "true" : "false");
+	g_assert (result_as_string != NULL);
+
+	if (g_ascii_strcasecmp (result_as_string, "true") == 0) {
+		result = TRUE;
+	} else if (g_ascii_strcasecmp (result_as_string, "false") == 0) {
+		result = FALSE;
+	} else {
+		g_error ("boolean metadata with value other than true or false");
+		result = default_metadata;
+	}
+
+	g_free (result_as_string);
+	return result;
+}
+
+int
+caja_file_get_integer_metadata (CajaFile *file,
+				    const char   *key,
+				    int           default_metadata)
+{
+	char *result_as_string;
+	char default_as_string[32];
+	int result;
+	char c;
+
+	g_return_val_if_fail (key != NULL, default_metadata);
+	g_return_val_if_fail (key[0] != '\0', default_metadata);
+
+	if (file == NULL) {
+		return default_metadata;
+	}
+	g_return_val_if_fail (CAJA_IS_FILE (file), default_metadata);
+
+	g_snprintf (default_as_string, sizeof (default_as_string), "%d", default_metadata);
+	result_as_string = caja_file_get_metadata
+		(file, key, default_as_string);
+
+	/* Normally we can't get a a NULL, but we check for it here to
+	 * handle the oddball case of a non-existent directory.
+	 */
+	if (result_as_string == NULL) {
+		result = default_metadata;
+	} else {
+		if (sscanf (result_as_string, " %d %c", &result, &c) != 1) {
+			result = default_metadata;
+		}
+		g_free (result_as_string);
+	}
+
+	return result;
+}
+
+static gboolean
+get_time_from_time_string (const char *time_string,
+			   time_t *time)
+{
+	long scanned_time;
+	char c;
+
+	g_assert (time != NULL);
+
+	/* Only accept string if it has one integer with nothing
+	 * afterwards.
+	 */
+	if (time_string == NULL ||
+	    sscanf (time_string, "%ld%c", &scanned_time, &c) != 1) {
+		return FALSE;
+	}
+	*time = (time_t) scanned_time;
+	return TRUE;
+}
+
+time_t
+caja_file_get_time_metadata (CajaFile *file,
+				 const char   *key)
+{
+	time_t time;
+	char *time_string;
+
+	time_string = caja_file_get_metadata (file, key, NULL);
+	if (!get_time_from_time_string (time_string, &time)) {
+		time = UNDEFINED_TIME;
+	}
+	g_free (time_string);
+
+	return time;
+}
+
+void
+caja_file_set_time_metadata (CajaFile *file,
+				 const char   *key,
+				 time_t        time)
+{
+	char time_str[21];
+	char *metadata;
+
+	if (time != UNDEFINED_TIME) {
+		/* 2^64 turns out to be 20 characters */
+		g_snprintf (time_str, 20, "%ld", (long int)time);
+		time_str[20] = '\0';
+		metadata = time_str;
+	} else {
+		metadata = NULL;
+	}
+
+	caja_file_set_metadata (file, key, NULL, metadata);
+}
+
+
+void
+caja_file_set_boolean_metadata (CajaFile *file,
+				    const char   *key,
+				    gboolean      default_metadata,
+				    gboolean      metadata)
+{
+	g_return_if_fail (CAJA_IS_FILE (file));
+	g_return_if_fail (key != NULL);
+	g_return_if_fail (key[0] != '\0');
+
+	caja_file_set_metadata (file, key,
+				    default_metadata ? "true" : "false",
+				    metadata ? "true" : "false");
+}
+
+void
+caja_file_set_integer_metadata (CajaFile *file,
+				    const char   *key,
+				    int           default_metadata,
+				    int           metadata)
+{
+	char value_as_string[32];
+	char default_as_string[32];
+
+	g_return_if_fail (CAJA_IS_FILE (file));
+	g_return_if_fail (key != NULL);
+	g_return_if_fail (key[0] != '\0');
+
+	g_snprintf (value_as_string, sizeof (value_as_string), "%d", metadata);
+	g_snprintf (default_as_string, sizeof (default_as_string), "%d", default_metadata);
+
+	caja_file_set_metadata (file, key,
+				    default_as_string, value_as_string);
+}
+
+static const char *
+caja_file_peek_display_name_collation_key (CajaFile *file)
+{
+	const char *res;
+
+	res = file->details->display_name_collation_key;
+	if (res == NULL)
+		res = "";
+
+	return res;
+}
+
+static const char *
+caja_file_peek_display_name (CajaFile *file)
+{
+	const char *name;
+	char *escaped_name;
+
+	/* Default to display name based on filename if its not set yet */
+
+	if (file->details->display_name == NULL) {
+		name = eel_ref_str_peek (file->details->name);
+		if (g_utf8_validate (name, -1, NULL)) {
+			caja_file_set_display_name (file,
+							name,
+							NULL,
+							FALSE);
+		} else {
+			escaped_name = g_uri_escape_string (name, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH, TRUE);
+			caja_file_set_display_name (file,
+							escaped_name,
+							NULL,
+							FALSE);
+			g_free (escaped_name);
+		}
+	}
+
+	return eel_ref_str_peek (file->details->display_name);
+}
+
+char *
+caja_file_get_display_name (CajaFile *file)
+{
+	return g_strdup (caja_file_peek_display_name (file));
+}
+
+char *
+caja_file_get_edit_name (CajaFile *file)
+{
+	const char *res;
+
+	res = eel_ref_str_peek (file->details->edit_name);
+	if (res == NULL)
+		res = "";
+
+	return g_strdup (res);
+}
+
+char *
+caja_file_get_name (CajaFile *file)
+{
+	return g_strdup (eel_ref_str_peek (file->details->name));
+}
+
+/**
+ * caja_file_get_description:
+ * @file: a #CajaFile.
+ *
+ * Gets the standard::description key from @file, if
+ * it has been cached.
+ *
+ * Returns: a string containing the value of the standard::description
+ * 	key, or %NULL.
+ */
+char *
+caja_file_get_description (CajaFile *file)
+{
+	return g_strdup (file->details->description);
+}
+
+void
+caja_file_monitor_add (CajaFile *file,
+			   gconstpointer client,
+			   CajaFileAttributes attributes)
+{
+	g_return_if_fail (CAJA_IS_FILE (file));
+	g_return_if_fail (client != NULL);
+
+	EEL_CALL_METHOD
+		(CAJA_FILE_CLASS, file,
+		 monitor_add, (file, client, attributes));
+}
+
+void
+caja_file_monitor_remove (CajaFile *file,
+			      gconstpointer client)
+{
+	g_return_if_fail (CAJA_IS_FILE (file));
+	g_return_if_fail (client != NULL);
+
+	EEL_CALL_METHOD
+		(CAJA_FILE_CLASS, file,
+		 monitor_remove, (file, client));
+}
+
+gboolean
+caja_file_is_launcher (CajaFile *file)
+{
+	return file->details->is_launcher;
+}
+
+gboolean
+caja_file_is_foreign_link (CajaFile *file)
+{
+	return file->details->is_foreign_link;
+}
+
+gboolean
+caja_file_is_trusted_link (CajaFile *file)
+{
+	return file->details->is_trusted_link;
+}
+
+gboolean
+caja_file_has_activation_uri (CajaFile *file)
+{
+	return file->details->activation_uri != NULL;
+}
+
+
+/* Return the uri associated with the passed-in file, which may not be
+ * the actual uri if the file is an desktop file or a caja
+ * xml link file.
+ */
+char *
+caja_file_get_activation_uri (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+	if (file->details->activation_uri != NULL) {
+		return g_strdup (file->details->activation_uri);
+	}
+
+	return caja_file_get_uri (file);
+}
+
+GFile *
+caja_file_get_activation_location (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+	if (file->details->activation_uri != NULL) {
+		return g_file_new_for_uri (file->details->activation_uri);
+	}
+
+	return caja_file_get_location (file);
+}
+
+
+char *
+caja_file_get_drop_target_uri (CajaFile *file)
+{
+	char *uri, *target_uri;
+	GFile *location;
+	CajaDesktopLink *link;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+	if (CAJA_IS_DESKTOP_ICON_FILE (file)) {
+		link = caja_desktop_icon_file_get_link (CAJA_DESKTOP_ICON_FILE (file));
+
+		if (link != NULL) {
+			location = caja_desktop_link_get_activation_location (link);
+			g_object_unref (link);
+			if (location != NULL) {
+				uri = g_file_get_uri (location);
+				g_object_unref (location);
+				return uri;
+			}
+		}
+	}
+
+	uri = caja_file_get_uri (file);
+
+	/* Check for Caja link */
+	if (caja_file_is_caja_link (file)) {
+		location = caja_file_get_location (file);
+		/* FIXME bugzilla.gnome.org 43020: This does sync. I/O and works only locally. */
+		if (g_file_is_native (location)) {
+			target_uri = caja_link_local_get_link_uri (uri);
+			if (target_uri != NULL) {
+				g_free (uri);
+				uri = target_uri;
+			}
+		}
+		g_object_unref (location);
+	}
+
+	return uri;
+}
+
+static gboolean
+is_uri_relative (const char *uri)
+{
+	char *scheme;
+	gboolean ret;
+
+	scheme = g_uri_parse_scheme (uri);
+	ret = (scheme == NULL);
+	g_free (scheme);
+	return ret;
+}
+
+static char *
+get_custom_icon_metadata_uri (CajaFile *file)
+{
+	char *custom_icon_uri;
+	char *uri;
+	char *dir_uri;
+
+	uri = caja_file_get_metadata (file, CAJA_METADATA_KEY_CUSTOM_ICON, NULL);
+	if (uri != NULL &&
+	    caja_file_is_directory (file) &&
+	    is_uri_relative (uri)) {
+		dir_uri = caja_file_get_uri (file);
+		custom_icon_uri = g_build_filename (dir_uri, uri, NULL);
+		g_free (dir_uri);
+		g_free (uri);
+	} else {
+		custom_icon_uri = uri;
+	}
+	return custom_icon_uri;
+}
+
+static GIcon *
+get_custom_icon (CajaFile *file)
+{
+	char *custom_icon_uri;
+	GFile *icon_file;
+	GIcon *icon;
+
+	if (file == NULL) {
+		return NULL;
+	}
+
+	icon = NULL;
+
+	/* Metadata takes precedence */
+	custom_icon_uri = get_custom_icon_metadata_uri (file);
+
+	if (custom_icon_uri) {
+		icon_file = g_file_new_for_uri (custom_icon_uri);
+		icon = g_file_icon_new (icon_file);
+		g_object_unref (icon_file);
+		g_free (custom_icon_uri);
+	}
+
+	if (icon == NULL && file->details->got_link_info && file->details->custom_icon != NULL) {
+		if (g_path_is_absolute (file->details->custom_icon)) {
+			icon_file = g_file_new_for_path (file->details->custom_icon);
+			icon = g_file_icon_new (icon_file);
+			g_object_unref (icon_file);
+		} else {
+			icon = g_themed_icon_new (file->details->custom_icon);
+		}
+ 	}
+
+	return icon;
+}
+
+
+static guint cached_thumbnail_limit;
+int cached_thumbnail_size;
+static int show_image_thumbs;
+
+GFilesystemPreviewType
+caja_file_get_filesystem_use_preview (CajaFile *file)
+{
+	GFilesystemPreviewType use_preview;
+	CajaFile *parent;
+
+	parent = caja_file_get_parent (file);
+	if (parent != NULL) {
+		use_preview = parent->details->filesystem_use_preview;
+		g_object_unref (parent);
+	} else {
+		use_preview = 0;
+	}
+
+	return use_preview;
+}
+
+gboolean
+caja_file_should_show_thumbnail (CajaFile *file)
+{
+	const char *mime_type;
+	GFilesystemPreviewType use_preview;
+
+	use_preview = caja_file_get_filesystem_use_preview (file);
+
+	mime_type = eel_ref_str_peek (file->details->mime_type);
+	if (mime_type == NULL) {
+		mime_type = "application/octet-stream";
+	}
+
+	/* If the thumbnail has already been created, don't care about the size
+	 * of the original file.
+	 */
+	if (caja_thumbnail_is_mimetype_limited_by_size (mime_type) &&
+	    file->details->thumbnail_path == NULL &&
+	    caja_file_get_size (file) > cached_thumbnail_limit) {
+		return FALSE;
+	}
+
+	if (show_image_thumbs == CAJA_SPEED_TRADEOFF_ALWAYS) {
+		if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_NEVER) {
+			return FALSE;
+		} else {
+			return TRUE;
+		}
+	} else if (show_image_thumbs == CAJA_SPEED_TRADEOFF_NEVER) {
+		return FALSE;
+	} else {
+		if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_NEVER) {
+			/* file system says to never thumbnail anything */
+			return FALSE;
+		} else if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL) {
+			/* file system says we should treat file as if it's local */
+			return TRUE;
+		} else {
+			/* only local files */
+			return caja_file_is_local (file);
+		}
+	}
+
+	return FALSE;
+}
+
+static void
+prepend_icon_name (const char *name,
+		   GThemedIcon *icon)
+{
+	g_themed_icon_prepend_name(icon, name);
+}
+
+GIcon *
+caja_file_get_gicon (CajaFile *file,
+			 CajaFileIconFlags flags)
+{
+	const char * const * names;
+	const char *name;
+	GPtrArray *prepend_array;
+	GMount *mount;
+	GIcon *icon, *mount_icon = NULL, *emblemed_icon;
+	GEmblem *emblem;
+	int i;
+	gboolean is_folder = FALSE, is_preview = FALSE, is_inode_directory = FALSE;
+
+	if (file == NULL) {
+		return NULL;
+	}
+
+	if (file->details->icon) {
+		icon = NULL;
+
+		/* fetch the mount icon here, we'll use it later */
+		if (flags & CAJA_FILE_ICON_FLAGS_USE_MOUNT_ICON ||
+		    flags & CAJA_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM) {
+			mount = caja_file_get_mount (file);
+
+			if (mount != NULL) {
+				mount_icon = g_mount_get_icon (mount);
+				g_object_unref (mount);
+			}
+		}
+
+		if (((flags & CAJA_FILE_ICON_FLAGS_EMBEDDING_TEXT) ||
+		     (flags & CAJA_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT) ||
+		     (flags & CAJA_FILE_ICON_FLAGS_FOR_OPEN_FOLDER) ||
+		     (flags & CAJA_FILE_ICON_FLAGS_USE_MOUNT_ICON) ||
+		     (flags & CAJA_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM) ||
+		     ((flags & CAJA_FILE_ICON_FLAGS_IGNORE_VISITING) == 0 &&
+		      caja_file_has_open_window (file))) &&
+		    G_IS_THEMED_ICON (file->details->icon)) {
+			names = g_themed_icon_get_names (G_THEMED_ICON (file->details->icon));
+			prepend_array = g_ptr_array_new ();
+
+			for (i = 0; names[i] != NULL; i++) {
+				name = names[i];
+
+				if (strcmp (name, "folder") == 0) {
+					is_folder = TRUE;
+				}
+				if (strcmp (name, "inode-directory") == 0) {
+					is_inode_directory = TRUE;
+				}
+				if (strcmp (name, "text-x-generic") == 0 &&
+				    (flags & CAJA_FILE_ICON_FLAGS_EMBEDDING_TEXT)) {
+					is_preview = TRUE;
+				}
+			}
+
+			/* Here, we add icons in reverse order of precedence,
+			 * because they are later prepended */
+			if (is_preview) {
+				g_ptr_array_add (prepend_array, "text-x-preview");
+			}
+
+			/* "folder" should override "inode-directory", not the other way around */
+			if (is_inode_directory) {
+				g_ptr_array_add (prepend_array, "folder");
+			}
+			if (is_folder && (flags & CAJA_FILE_ICON_FLAGS_FOR_OPEN_FOLDER)) {
+				g_ptr_array_add (prepend_array, "folder-open");
+			}
+			if (is_folder &&
+			    (flags & CAJA_FILE_ICON_FLAGS_IGNORE_VISITING) == 0 &&
+			    caja_file_has_open_window (file)) {
+				g_ptr_array_add (prepend_array, "folder-visiting");
+			}
+			if (is_folder &&
+			    (flags & CAJA_FILE_ICON_FLAGS_FOR_DRAG_ACCEPT)) {
+				g_ptr_array_add (prepend_array, "folder-drag-accept");
+			}
+
+			if (prepend_array->len) {
+				/* When constructing GThemed Icon, pointers from the array
+				 * are reused, but not the array itself, so the cast is safe */
+				icon = g_themed_icon_new_from_names ((char**) names, -1);
+				g_ptr_array_foreach (prepend_array, (GFunc) prepend_icon_name, icon);
+			}
+
+			g_ptr_array_free (prepend_array, TRUE);
+		}
+
+		if (icon == NULL) {
+			icon = g_object_ref (file->details->icon);
+		}
+
+		if ((flags & CAJA_FILE_ICON_FLAGS_USE_MOUNT_ICON) &&
+		    mount_icon != NULL) {
+			g_object_unref (icon);
+			icon = mount_icon;
+		} else if ((flags & CAJA_FILE_ICON_FLAGS_USE_MOUNT_ICON_AS_EMBLEM) &&
+			     mount_icon != NULL && !g_icon_equal (mount_icon, icon)) {
+
+			emblem = g_emblem_new (mount_icon);
+			emblemed_icon = g_emblemed_icon_new (icon, emblem);
+
+			g_object_unref (emblem);
+			g_object_unref (icon);
+			g_object_unref (mount_icon);
+
+			icon = emblemed_icon;
+		} else if (mount_icon != NULL) {
+			g_object_unref (mount_icon);
+		}
+
+		return icon;
+	}
+
+	return g_themed_icon_new ("text-x-generic");
+}
+
+static GIcon *
+get_default_file_icon (CajaFileIconFlags flags)
+{
+	static GIcon *fallback_icon = NULL;
+	static GIcon *fallback_icon_preview = NULL;
+	if (fallback_icon == NULL) {
+		fallback_icon = g_themed_icon_new ("text-x-generic");
+		fallback_icon_preview = g_themed_icon_new ("text-x-preview");
+		g_themed_icon_append_name (G_THEMED_ICON (fallback_icon_preview), "text-x-generic");
+	}
+	if (flags & CAJA_FILE_ICON_FLAGS_EMBEDDING_TEXT) {
+		return fallback_icon_preview;
+	} else {
+		return fallback_icon;
+	}
+}
+
+CajaIconInfo *
+caja_file_get_icon (CajaFile *file,
+			int size,
+			CajaFileIconFlags flags)
+{
+	CajaIconInfo *icon;
+	GIcon *gicon;
+	GdkPixbuf *raw_pixbuf, *scaled_pixbuf;
+	int modified_size;
+
+	if (file == NULL) {
+		return NULL;
+	}
+
+	gicon = get_custom_icon (file);
+	if (gicon) {
+		icon = caja_icon_info_lookup (gicon, size);
+		g_object_unref (gicon);
+		return icon;
+	}
+
+	if (flags & CAJA_FILE_ICON_FLAGS_FORCE_THUMBNAIL_SIZE) {
+		modified_size = size;
+	} else {
+		modified_size = size * cached_thumbnail_size / CAJA_ICON_SIZE_STANDARD;
+	}
+	if (flags & CAJA_FILE_ICON_FLAGS_USE_THUMBNAILS &&
+	    caja_file_should_show_thumbnail (file)) {
+		if (file->details->thumbnail) {
+			int w, h, s;
+			double scale;
+
+			raw_pixbuf = g_object_ref (file->details->thumbnail);
+
+			w = gdk_pixbuf_get_width (raw_pixbuf);
+			h = gdk_pixbuf_get_height (raw_pixbuf);
+
+			s = MAX (w, h);
+			/* Don't scale up small thumbnails in the standard view */
+			if (s <= cached_thumbnail_size) {
+				scale = (double)size / CAJA_ICON_SIZE_STANDARD;
+			}
+			else {
+				scale = (double)modified_size / s;
+			}
+			/* Make sure that icons don't get smaller than CAJA_ICON_SIZE_SMALLEST */
+			if (s*scale <= CAJA_ICON_SIZE_SMALLEST) {
+				scale = (double) CAJA_ICON_SIZE_SMALLEST / s;
+			}
+
+			scaled_pixbuf = gdk_pixbuf_scale_simple (raw_pixbuf,
+								 w * scale, h * scale,
+								 GDK_INTERP_BILINEAR);
+
+			/* We don't want frames around small icons */
+			if (!gdk_pixbuf_get_has_alpha(raw_pixbuf) || s >= 128) {
+				caja_thumbnail_frame_image (&scaled_pixbuf);
+			}
+			g_object_unref (raw_pixbuf);
+
+			/* Don't scale up if more than 25%, then read the original
+			   image instead. We don't want to compare to exactly 100%,
+			   since the zoom level 150% gives thumbnails at 144, which is
+			   ok to scale up from 128. */
+			if (modified_size > 128*1.25 &&
+			    !file->details->thumbnail_wants_original &&
+			    caja_can_thumbnail_internally (file)) {
+				/* Invalidate if we resize upward */
+				file->details->thumbnail_wants_original = TRUE;
+				caja_file_invalidate_attributes (file, CAJA_FILE_ATTRIBUTE_THUMBNAIL);
+			}
+
+			icon = caja_icon_info_new_for_pixbuf (scaled_pixbuf);
+			g_object_unref (scaled_pixbuf);
+			return icon;
+		} else if (file->details->thumbnail_path == NULL &&
+			   file->details->can_read &&
+			   !file->details->is_thumbnailing &&
+			   !file->details->thumbnailing_failed) {
+			if (caja_can_thumbnail (file)) {
+				caja_create_thumbnail (file);
+			}
+		}
+	}
+
+	if (file->details->is_thumbnailing &&
+	    flags & CAJA_FILE_ICON_FLAGS_USE_THUMBNAILS)
+		gicon = g_themed_icon_new (ICON_NAME_THUMBNAIL_LOADING);
+	else
+		gicon = caja_file_get_gicon (file, flags);
+
+	if (gicon) {
+		icon = caja_icon_info_lookup (gicon, size);
+		if (caja_icon_info_is_fallback (icon)) {
+			g_object_unref (icon);
+			icon = caja_icon_info_lookup (get_default_file_icon (flags), size);
+		}
+		g_object_unref (gicon);
+		return icon;
+	} else {
+		return caja_icon_info_lookup (get_default_file_icon (flags), size);
+	}
+}
+
+GdkPixbuf *
+caja_file_get_icon_pixbuf (CajaFile *file,
+			       int size,
+			       gboolean force_size,
+			       CajaFileIconFlags flags)
+{
+	CajaIconInfo *info;
+	GdkPixbuf *pixbuf;
+
+	info = caja_file_get_icon (file, size, flags);
+	if (force_size) {
+		pixbuf =  caja_icon_info_get_pixbuf_at_size (info, size);
+	} else {
+		pixbuf = caja_icon_info_get_pixbuf (info);
+	}
+	g_object_unref (info);
+
+	return pixbuf;
+}
+
+char *
+caja_file_get_custom_icon (CajaFile *file)
+{
+	char *custom_icon;
+
+	if (file == NULL) {
+		return NULL;
+	}
+
+	/* Metadata takes precedence */
+	custom_icon = get_custom_icon_metadata_uri (file);
+
+	if (custom_icon == NULL && file->details->got_link_info) {
+		custom_icon = g_strdup (file->details->custom_icon);
+ 	}
+
+	return custom_icon;
+}
+
+
+gboolean
+caja_file_get_date (CajaFile *file,
+			CajaDateType date_type,
+			time_t *date)
+{
+	if (date != NULL) {
+		*date = 0;
+	}
+
+	g_return_val_if_fail (date_type == CAJA_DATE_TYPE_CHANGED
+			      || date_type == CAJA_DATE_TYPE_ACCESSED
+			      || date_type == CAJA_DATE_TYPE_MODIFIED
+			      || date_type == CAJA_DATE_TYPE_TRASHED
+			      || date_type == CAJA_DATE_TYPE_PERMISSIONS_CHANGED, FALSE);
+
+	if (file == NULL) {
+		return FALSE;
+	}
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	return EEL_CALL_METHOD_WITH_RETURN_VALUE
+		(CAJA_FILE_CLASS, file,
+		 get_date, (file, date_type, date));
+}
+
+static char *
+caja_file_get_where_string (CajaFile *file)
+{
+	if (file == NULL) {
+		return NULL;
+	}
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+	return EEL_CALL_METHOD_WITH_RETURN_VALUE
+		(CAJA_FILE_CLASS, file,
+		 get_where_string, (file));
+}
+
+static const char *TODAY_TIME_FORMATS [] = {
+	/* Today, use special word.
+	 * strftime patterns preceeded with the widest
+	 * possible resulting string for that pattern.
+	 *
+	 * Note to localizers: You can look at man strftime
+	 * for details on the format, but you should only use
+	 * the specifiers from the C standard, not extensions.
+	 * These include "%" followed by one of
+	 * "aAbBcdHIjmMpSUwWxXyYZ". There are two extensions
+	 * in the Caja version of strftime that can be
+	 * used (and match GNU extensions). Putting a "-"
+	 * between the "%" and any numeric directive will turn
+	 * off zero padding, and putting a "_" there will use
+	 * space padding instead of zero padding.
+	 */
+	N_("today at 00:00:00 PM"),
+	N_("today at %-I:%M:%S %p"),
+
+	N_("today at 00:00 PM"),
+	N_("today at %-I:%M %p"),
+
+	N_("today, 00:00 PM"),
+	N_("today, %-I:%M %p"),
+
+	N_("today"),
+	N_("today"),
+
+	NULL
+};
+
+static const char *YESTERDAY_TIME_FORMATS [] = {
+	/* Yesterday, use special word.
+	 * Note to localizers: Same issues as "today" string.
+	 */
+	N_("yesterday at 00:00:00 PM"),
+	N_("yesterday at %-I:%M:%S %p"),
+
+	N_("yesterday at 00:00 PM"),
+	N_("yesterday at %-I:%M %p"),
+
+	N_("yesterday, 00:00 PM"),
+	N_("yesterday, %-I:%M %p"),
+
+	N_("yesterday"),
+	N_("yesterday"),
+
+	NULL
+};
+
+static const char *CURRENT_WEEK_TIME_FORMATS [] = {
+	/* Current week, include day of week.
+	 * Note to localizers: Same issues as "today" string.
+	 * The width measurement templates correspond to
+	 * the day/month name with the most letters.
+	 */
+	N_("Wednesday, September 00 0000 at 00:00:00 PM"),
+	N_("%A, %B %-d %Y at %-I:%M:%S %p"),
+
+	N_("Mon, Oct 00 0000 at 00:00:00 PM"),
+	N_("%a, %b %-d %Y at %-I:%M:%S %p"),
+
+	N_("Mon, Oct 00 0000 at 00:00 PM"),
+	N_("%a, %b %-d %Y at %-I:%M %p"),
+
+	N_("Oct 00 0000 at 00:00 PM"),
+	N_("%b %-d %Y at %-I:%M %p"),
+
+	N_("Oct 00 0000, 00:00 PM"),
+	N_("%b %-d %Y, %-I:%M %p"),
+
+	N_("00/00/00, 00:00 PM"),
+	N_("%m/%-d/%y, %-I:%M %p"),
+
+	N_("00/00/00"),
+	N_("%m/%d/%y"),
+
+	NULL
+};
+
+static char *
+caja_file_fit_date_as_string (CajaFile *file,
+				  CajaDateType date_type,
+				  int width,
+				  CajaWidthMeasureCallback measure_callback,
+				  CajaTruncateCallback truncate_callback,
+				  void *measure_context)
+{
+	time_t file_time_raw;
+	struct tm *file_time;
+	const char **formats;
+	const char *width_template;
+	const char *format;
+	char *date_string;
+	char *result;
+	GDate *today;
+	GDate *file_date;
+	guint32 file_date_age;
+	int i;
+
+	if (!caja_file_get_date (file, date_type, &file_time_raw)) {
+		return NULL;
+	}
+
+	file_time = localtime (&file_time_raw);
+
+	if (date_format_pref == CAJA_DATE_FORMAT_LOCALE) {
+		return eel_strdup_strftime ("%c", file_time);
+	} else if (date_format_pref == CAJA_DATE_FORMAT_ISO) {
+		return eel_strdup_strftime ("%Y-%m-%d %H:%M:%S", file_time);
+	}
+
+	file_date = eel_g_date_new_tm (file_time);
+
+	today = g_date_new ();
+	g_date_set_time_t (today, time (NULL));
+
+	/* Overflow results in a large number; fine for our purposes. */
+	file_date_age = (g_date_get_julian (today) -
+			 g_date_get_julian (file_date));
+
+	g_date_free (file_date);
+	g_date_free (today);
+
+	/* Format varies depending on how old the date is. This minimizes
+	 * the length (and thus clutter & complication) of typical dates
+	 * while providing sufficient detail for recent dates to make
+	 * them maximally understandable at a glance. Keep all format
+	 * strings separate rather than combining bits & pieces for
+	 * internationalization's sake.
+	 */
+
+	if (file_date_age == 0)	{
+		formats = TODAY_TIME_FORMATS;
+	} else if (file_date_age == 1) {
+		formats = YESTERDAY_TIME_FORMATS;
+	} else if (file_date_age < 7) {
+		formats = CURRENT_WEEK_TIME_FORMATS;
+	} else {
+		formats = CURRENT_WEEK_TIME_FORMATS;
+	}
+
+	/* Find the date format that just fits the required width. Instead of measuring
+	 * the resulting string width directly, measure the width of a template that represents
+	 * the widest possible version of a date in a given format. This is done by using M, m
+	 * and 0 for the variable letters/digits respectively.
+	 */
+	format = NULL;
+
+	for (i = 0; ; i += 2) {
+		width_template = (formats [i] ? _(formats [i]) : NULL);
+		if (width_template == NULL) {
+			/* no more formats left */
+			g_assert (format != NULL);
+
+			/* Can't fit even the shortest format -- return an ellipsized form in the
+			 * shortest format
+			 */
+
+			date_string = eel_strdup_strftime (format, file_time);
+
+			if (truncate_callback == NULL) {
+				return date_string;
+			}
+
+			result = (* truncate_callback) (date_string, width, measure_context);
+			g_free (date_string);
+			return result;
+		}
+
+		format = _(formats [i + 1]);
+
+		if (measure_callback == NULL) {
+			/* don't care about fitting the width */
+			break;
+		}
+
+		if ((* measure_callback) (width_template, measure_context) <= width) {
+			/* The template fits, this is the format we can fit. */
+			break;
+		}
+	}
+
+	return eel_strdup_strftime (format, file_time);
+
+}
+
+/**
+ * caja_file_fit_modified_date_as_string:
+ *
+ * Get a user-displayable string representing a file modification date,
+ * truncated to @width using the measuring and truncating callbacks.
+ * @file: CajaFile representing the file in question.
+ * @width: The desired resulting string width.
+ * @measure_callback: The callback used to measure the string width.
+ * @truncate_callback: The callback used to truncate the string to a desired width.
+ * @measure_context: Data neede when measuring and truncating.
+ *
+ * Returns: Newly allocated string ready to display to the user.
+ *
+ **/
+char *
+caja_file_fit_modified_date_as_string (CajaFile *file,
+					   int width,
+					   CajaWidthMeasureCallback measure_callback,
+					   CajaTruncateCallback truncate_callback,
+					   void *measure_context)
+{
+	return caja_file_fit_date_as_string (file, CAJA_DATE_TYPE_MODIFIED,
+		width, measure_callback, truncate_callback, measure_context);
+}
+
+static char *
+caja_file_get_trash_original_file_parent_as_string (CajaFile *file)
+{
+	CajaFile *orig_file, *parent;
+	GFile *location;
+	char *filename;
+
+	if (file->details->trash_orig_path != NULL) {
+		orig_file = caja_file_get_trash_original_file (file);
+		parent = caja_file_get_parent (orig_file);
+		location = caja_file_get_location (parent);
+
+		filename = g_file_get_parse_name (location);
+
+		g_object_unref (location);
+		caja_file_unref (parent);
+		caja_file_unref (orig_file);
+
+		return filename;
+	}
+
+	return NULL;
+}
+
+/**
+ * caja_file_get_date_as_string:
+ *
+ * Get a user-displayable string representing a file modification date.
+ * The caller is responsible for g_free-ing this string.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: Newly allocated string ready to display to the user.
+ *
+ **/
+static char *
+caja_file_get_date_as_string (CajaFile *file, CajaDateType date_type)
+{
+	return caja_file_fit_date_as_string (file, date_type,
+		0, NULL, NULL, NULL);
+}
+
+static CajaSpeedTradeoffValue show_directory_item_count;
+static CajaSpeedTradeoffValue show_text_in_icons;
+
+static void
+show_text_in_icons_changed_callback (gpointer callback_data)
+{
+	show_text_in_icons = eel_preferences_get_enum (CAJA_PREFERENCES_SHOW_TEXT_IN_ICONS);
+}
+
+static void
+show_directory_item_count_changed_callback (gpointer callback_data)
+{
+	show_directory_item_count = eel_preferences_get_enum (CAJA_PREFERENCES_SHOW_DIRECTORY_ITEM_COUNTS);
+}
+
+static gboolean
+get_speed_tradeoff_preference_for_file (CajaFile *file, CajaSpeedTradeoffValue value)
+{
+	GFilesystemPreviewType use_preview;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	use_preview = caja_file_get_filesystem_use_preview (file);
+
+	if (value == CAJA_SPEED_TRADEOFF_ALWAYS) {
+		if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_NEVER) {
+			return FALSE;
+		} else {
+			return TRUE;
+		}
+	}
+
+	if (value == CAJA_SPEED_TRADEOFF_NEVER) {
+		return FALSE;
+	}
+
+	g_assert (value == CAJA_SPEED_TRADEOFF_LOCAL_ONLY);
+
+	if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_NEVER) {
+		/* file system says to never preview anything */
+		return FALSE;
+	} else if (use_preview == G_FILESYSTEM_PREVIEW_TYPE_IF_LOCAL) {
+		/* file system says we should treat file as if it's local */
+		return TRUE;
+	} else {
+		/* only local files */
+		return caja_file_is_local (file);
+	}
+}
+
+gboolean
+caja_file_should_show_directory_item_count (CajaFile *file)
+{
+	static gboolean show_directory_item_count_callback_added = FALSE;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	if (file->details->mime_type &&
+	    strcmp (eel_ref_str_peek (file->details->mime_type), "x-directory/smb-share") == 0) {
+		return FALSE;
+	}
+
+	/* Add the callback once for the life of our process */
+	if (!show_directory_item_count_callback_added) {
+		eel_preferences_add_callback (CAJA_PREFERENCES_SHOW_DIRECTORY_ITEM_COUNTS,
+						   show_directory_item_count_changed_callback,
+						   NULL);
+		show_directory_item_count_callback_added = TRUE;
+
+		/* Peek for the first time */
+		show_directory_item_count_changed_callback (NULL);
+	}
+
+	return get_speed_tradeoff_preference_for_file (file, show_directory_item_count);
+}
+
+gboolean
+caja_file_should_show_type (CajaFile *file)
+{
+	char *uri;
+	gboolean ret;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	uri = caja_file_get_uri (file);
+	ret = ((strcmp (uri, "computer:///") != 0) &&
+	       (strcmp (uri, "network:///") != 0) &&
+	       (strcmp (uri, "smb:///") != 0));
+	g_free (uri);
+
+	return ret;
+}
+
+gboolean
+caja_file_should_get_top_left_text (CajaFile *file)
+{
+	static gboolean show_text_in_icons_callback_added = FALSE;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	/* Add the callback once for the life of our process */
+	if (!show_text_in_icons_callback_added) {
+		eel_preferences_add_callback (CAJA_PREFERENCES_SHOW_TEXT_IN_ICONS,
+						   show_text_in_icons_changed_callback,
+						   NULL);
+		show_text_in_icons_callback_added = TRUE;
+
+		/* Peek for the first time */
+		show_text_in_icons_changed_callback (NULL);
+	}
+
+	if (show_text_in_icons == CAJA_SPEED_TRADEOFF_ALWAYS) {
+		return TRUE;
+	}
+
+	if (show_text_in_icons == CAJA_SPEED_TRADEOFF_NEVER) {
+		return FALSE;
+	}
+
+	return get_speed_tradeoff_preference_for_file (file, show_text_in_icons);
+}
+
+/**
+ * caja_file_get_directory_item_count
+ *
+ * Get the number of items in a directory.
+ * @file: CajaFile representing a directory.
+ * @count: Place to put count.
+ * @count_unreadable: Set to TRUE (if non-NULL) if permissions prevent
+ * the item count from being read on this directory. Otherwise set to FALSE.
+ *
+ * Returns: TRUE if count is available.
+ *
+ **/
+gboolean
+caja_file_get_directory_item_count (CajaFile *file,
+					guint *count,
+					gboolean *count_unreadable)
+{
+	if (count != NULL) {
+		*count = 0;
+	}
+	if (count_unreadable != NULL) {
+		*count_unreadable = FALSE;
+	}
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	if (!caja_file_is_directory (file)) {
+		return FALSE;
+	}
+
+	if (!caja_file_should_show_directory_item_count (file)) {
+		return FALSE;
+	}
+
+	return EEL_CALL_METHOD_WITH_RETURN_VALUE
+		(CAJA_FILE_CLASS, file,
+		 get_item_count, (file, count, count_unreadable));
+}
+
+/**
+ * caja_file_get_deep_counts
+ *
+ * Get the statistics about items inside a directory.
+ * @file: CajaFile representing a directory or file.
+ * @directory_count: Place to put count of directories inside.
+ * @files_count: Place to put count of files inside.
+ * @unreadable_directory_count: Number of directories encountered
+ * that were unreadable.
+ * @total_size: Total size of all files and directories visited.
+ * @force: Whether the deep counts should even be collected if
+ * caja_file_should_show_directory_item_count returns FALSE
+ * for this file.
+ *
+ * Returns: Status to indicate whether sizes are available.
+ *
+ **/
+CajaRequestStatus
+caja_file_get_deep_counts (CajaFile *file,
+			       guint *directory_count,
+			       guint *file_count,
+			       guint *unreadable_directory_count,
+			       goffset *total_size,
+			       gboolean force)
+{
+	if (directory_count != NULL) {
+		*directory_count = 0;
+	}
+	if (file_count != NULL) {
+		*file_count = 0;
+	}
+	if (unreadable_directory_count != NULL) {
+		*unreadable_directory_count = 0;
+	}
+	if (total_size != NULL) {
+		*total_size = 0;
+	}
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), CAJA_REQUEST_DONE);
+
+	if (!force && !caja_file_should_show_directory_item_count (file)) {
+		/* Set field so an existing value isn't treated as up-to-date
+		 * when preference changes later.
+		 */
+		file->details->deep_counts_status = CAJA_REQUEST_NOT_STARTED;
+		return file->details->deep_counts_status;
+	}
+
+	return EEL_CALL_METHOD_WITH_RETURN_VALUE
+		(CAJA_FILE_CLASS, file,
+		 get_deep_counts, (file,
+				   directory_count,
+				   file_count,
+				   unreadable_directory_count,
+				   total_size));
+}
+
+void
+caja_file_recompute_deep_counts (CajaFile *file)
+{
+	if (file->details->deep_counts_status != CAJA_REQUEST_IN_PROGRESS) {
+		file->details->deep_counts_status = CAJA_REQUEST_NOT_STARTED;
+		if (file->details->directory != NULL) {
+			caja_directory_add_file_to_work_queue (file->details->directory, file);
+			caja_directory_async_state_changed (file->details->directory);
+		}
+	}
+}
+
+
+/**
+ * caja_file_get_directory_item_mime_types
+ *
+ * Get the list of mime-types present in a directory.
+ * @file: CajaFile representing a directory. It is an error to
+ * call this function on a file that is not a directory.
+ * @mime_list: Place to put the list of mime-types.
+ *
+ * Returns: TRUE if mime-type list is available.
+ *
+ **/
+gboolean
+caja_file_get_directory_item_mime_types (CajaFile *file,
+					     GList **mime_list)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+	g_return_val_if_fail (mime_list != NULL, FALSE);
+
+	if (!caja_file_is_directory (file)
+	    || !file->details->got_mime_list) {
+		*mime_list = NULL;
+		return FALSE;
+	}
+
+	*mime_list = eel_g_str_list_copy (file->details->mime_list);
+	return TRUE;
+}
+
+gboolean
+caja_file_can_get_size (CajaFile *file)
+{
+	return file->details->size == -1;
+}
+
+
+/**
+ * caja_file_get_size
+ *
+ * Get the file size.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: Size in bytes.
+ *
+ **/
+goffset
+caja_file_get_size (CajaFile *file)
+{
+	/* Before we have info on the file, we don't know the size. */
+	if (file->details->size == -1)
+		return 0;
+	return file->details->size;
+}
+
+time_t
+caja_file_get_mtime (CajaFile *file)
+{
+	return file->details->mtime;
+}
+
+
+static void
+set_attributes_get_info_callback (GObject *source_object,
+				  GAsyncResult *res,
+				  gpointer callback_data)
+{
+	CajaFileOperation *op;
+	GFileInfo *new_info;
+	GError *error;
+
+	op = callback_data;
+
+	error = NULL;
+	new_info = g_file_query_info_finish (G_FILE (source_object), res, &error);
+	if (new_info != NULL) {
+		if (caja_file_update_info (op->file, new_info)) {
+			caja_file_changed (op->file);
+		}
+		g_object_unref (new_info);
+	}
+	caja_file_operation_complete (op, NULL, error);
+	if (error) {
+		g_error_free (error);
+	}
+}
+
+
+static void
+set_attributes_callback (GObject *source_object,
+			 GAsyncResult *result,
+			 gpointer callback_data)
+{
+	CajaFileOperation *op;
+	GError *error;
+	gboolean res;
+
+	op = callback_data;
+
+	error = NULL;
+	res = g_file_set_attributes_finish (G_FILE (source_object),
+					    result,
+					    NULL,
+					    &error);
+
+	if (res) {
+		g_file_query_info_async (G_FILE (source_object),
+					 CAJA_FILE_DEFAULT_ATTRIBUTES,
+					 0,
+					 G_PRIORITY_DEFAULT,
+					 op->cancellable,
+					 set_attributes_get_info_callback, op);
+	} else {
+		caja_file_operation_complete (op, NULL, error);
+		g_error_free (error);
+	}
+}
+
+void
+caja_file_set_attributes (CajaFile *file,
+			      GFileInfo *attributes,
+			      CajaFileOperationCallback callback,
+			      gpointer callback_data)
+{
+	CajaFileOperation *op;
+	GFile *location;
+
+	op = caja_file_operation_new (file, callback, callback_data);
+
+	location = caja_file_get_location (file);
+	g_file_set_attributes_async (location,
+				     attributes,
+				     0,
+				     G_PRIORITY_DEFAULT,
+				     op->cancellable,
+				     set_attributes_callback,
+				     op);
+	g_object_unref (location);
+}
+
+
+/**
+ * caja_file_can_get_permissions:
+ *
+ * Check whether the permissions for a file are determinable.
+ * This might not be the case for files on non-UNIX file systems.
+ *
+ * @file: The file in question.
+ *
+ * Return value: TRUE if the permissions are valid.
+ */
+gboolean
+caja_file_can_get_permissions (CajaFile *file)
+{
+	return file->details->has_permissions;
+}
+
+/**
+ * caja_file_can_set_permissions:
+ *
+ * Check whether the current user is allowed to change
+ * the permissions of a file.
+ *
+ * @file: The file in question.
+ *
+ * Return value: TRUE if the current user can change the
+ * permissions of @file, FALSE otherwise. It's always possible
+ * that when you actually try to do it, you will fail.
+ */
+gboolean
+caja_file_can_set_permissions (CajaFile *file)
+{
+	uid_t user_id;
+
+	if (file->details->uid != -1 &&
+	    caja_file_is_local (file)) {
+		/* Check the user. */
+		user_id = geteuid();
+
+		/* Owner is allowed to set permissions. */
+		if (user_id == (uid_t) file->details->uid) {
+			return TRUE;
+		}
+
+		/* Root is also allowed to set permissions. */
+		if (user_id == 0) {
+			return TRUE;
+		}
+
+		/* Nobody else is allowed. */
+		return FALSE;
+	}
+
+	/* pretend to have full chmod rights when no info is available, relevant when
+	 * the FS can't provide ownership info, for instance for FTP */
+	return TRUE;
+}
+
+guint
+caja_file_get_permissions (CajaFile *file)
+{
+	g_return_val_if_fail (caja_file_can_get_permissions (file), 0);
+
+	return file->details->permissions;
+}
+
+/**
+ * caja_file_set_permissions:
+ *
+ * Change a file's permissions. This should only be called if
+ * caja_file_can_set_permissions returned TRUE.
+ *
+ * @file: CajaFile representing the file in question.
+ * @new_permissions: New permissions value. This is the whole
+ * set of permissions, not a delta.
+ **/
+void
+caja_file_set_permissions (CajaFile *file,
+			       guint32 new_permissions,
+			       CajaFileOperationCallback callback,
+			       gpointer callback_data)
+{
+	GFileInfo *info;
+	GError *error;
+
+	if (!caja_file_can_set_permissions (file)) {
+		/* Claim that something changed even if the permission change failed.
+		 * This makes it easier for some clients who see the "reverting"
+		 * to the old permissions as "changing back".
+		 */
+		caja_file_changed (file);
+		error = g_error_new (G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
+				     _("Not allowed to set permissions"));
+		(* callback) (file, NULL, error, callback_data);
+		g_error_free (error);
+		return;
+	}
+
+	/* Test the permissions-haven't-changed case explicitly
+	 * because we don't want to send the file-changed signal if
+	 * nothing changed.
+	 */
+	if (new_permissions == file->details->permissions) {
+		(* callback) (file, NULL, NULL, callback_data);
+		return;
+	}
+
+	info = g_file_info_new ();
+	g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_MODE, new_permissions);
+	caja_file_set_attributes (file, info, callback, callback_data);
+	g_object_unref (info);
+}
+
+/**
+ * caja_file_can_get_selinux_context:
+ *
+ * Check whether the selinux context for a file are determinable.
+ * This might not be the case for files on non-UNIX file systems,
+ * files without a context or systems that don't support selinux.
+ *
+ * @file: The file in question.
+ *
+ * Return value: TRUE if the permissions are valid.
+ */
+gboolean
+caja_file_can_get_selinux_context (CajaFile *file)
+{
+	return file->details->selinux_context != NULL;
+}
+
+
+/**
+ * caja_file_get_selinux_context:
+ *
+ * Get a user-displayable string representing a file's selinux
+ * context
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: Newly allocated string ready to display to the user.
+ *
+ **/
+char *
+caja_file_get_selinux_context (CajaFile *file)
+{
+	char *translated;
+	char *raw;
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+	if (!caja_file_can_get_selinux_context (file)) {
+		return NULL;
+	}
+
+	raw = file->details->selinux_context;
+
+#ifdef HAVE_SELINUX
+	if (selinux_raw_to_trans_context (raw, &translated) == 0) {
+		char *tmp;
+		tmp = g_strdup (translated);
+		freecon (translated);
+		translated = tmp;
+	}
+	else
+#endif
+	{
+		translated = g_strdup (raw);
+	}
+
+	return translated;
+}
+
+static char *
+get_real_name (const char *name, const char *gecos)
+{
+	char *locale_string, *part_before_comma, *capitalized_login_name, *real_name;
+
+	if (gecos == NULL) {
+		return NULL;
+	}
+
+	locale_string = eel_str_strip_substring_and_after (gecos, ",");
+	if (!g_utf8_validate (locale_string, -1, NULL)) {
+		part_before_comma = g_locale_to_utf8 (locale_string, -1, NULL, NULL, NULL);
+		g_free (locale_string);
+	} else {
+		part_before_comma = locale_string;
+	}
+
+	if (!g_utf8_validate (name, -1, NULL)) {
+		locale_string = g_locale_to_utf8 (name, -1, NULL, NULL, NULL);
+	} else {
+		locale_string = g_strdup (name);
+	}
+
+	capitalized_login_name = eel_str_capitalize (locale_string);
+	g_free (locale_string);
+
+	if (capitalized_login_name == NULL) {
+		real_name = part_before_comma;
+	} else {
+		real_name = eel_str_replace_substring
+			(part_before_comma, "&", capitalized_login_name);
+		g_free (part_before_comma);
+	}
+
+
+	if (eel_str_is_empty (real_name)
+	    || eel_strcmp (name, real_name) == 0
+	    || eel_strcmp (capitalized_login_name, real_name) == 0) {
+		g_free (real_name);
+		real_name = NULL;
+	}
+
+	g_free (capitalized_login_name);
+
+	return real_name;
+}
+
+static gboolean
+get_group_id_from_group_name (const char *group_name, uid_t *gid)
+{
+	struct group *group;
+
+	g_assert (gid != NULL);
+
+	group = getgrnam (group_name);
+
+	if (group == NULL) {
+		return FALSE;
+	}
+
+	*gid = group->gr_gid;
+
+	return TRUE;
+}
+
+static gboolean
+get_ids_from_user_name (const char *user_name, uid_t *uid, uid_t *gid)
+{
+	struct passwd *password_info;
+
+	g_assert (uid != NULL || gid != NULL);
+
+	password_info = getpwnam (user_name);
+
+	if (password_info == NULL) {
+		return FALSE;
+	}
+
+	if (uid != NULL) {
+		*uid = password_info->pw_uid;
+	}
+
+	if (gid != NULL) {
+		*gid = password_info->pw_gid;
+	}
+
+	return TRUE;
+}
+
+static gboolean
+get_user_id_from_user_name (const char *user_name, uid_t *id)
+{
+	return get_ids_from_user_name (user_name, id, NULL);
+}
+
+static gboolean
+get_id_from_digit_string (const char *digit_string, uid_t *id)
+{
+	long scanned_id;
+	char c;
+
+	g_assert (id != NULL);
+
+	/* Only accept string if it has one integer with nothing
+	 * afterwards.
+	 */
+	if (sscanf (digit_string, "%ld%c", &scanned_id, &c) != 1) {
+		return FALSE;
+	}
+	*id = scanned_id;
+	return TRUE;
+}
+
+/**
+ * caja_file_can_get_owner:
+ *
+ * Check whether the owner a file is determinable.
+ * This might not be the case for files on non-UNIX file systems.
+ *
+ * @file: The file in question.
+ *
+ * Return value: TRUE if the owner is valid.
+ */
+gboolean
+caja_file_can_get_owner (CajaFile *file)
+{
+	/* Before we have info on a file, the owner is unknown. */
+	return file->details->uid != -1;
+}
+
+/**
+ * caja_file_get_owner_name:
+ *
+ * Get the user name of the file's owner. If the owner has no
+ * name, returns the userid as a string. The caller is responsible
+ * for g_free-ing this string.
+ *
+ * @file: The file in question.
+ *
+ * Return value: A newly-allocated string.
+ */
+char *
+caja_file_get_owner_name (CajaFile *file)
+{
+	return caja_file_get_owner_as_string (file, FALSE);
+}
+
+/**
+ * caja_file_can_set_owner:
+ *
+ * Check whether the current user is allowed to change
+ * the owner of a file.
+ *
+ * @file: The file in question.
+ *
+ * Return value: TRUE if the current user can change the
+ * owner of @file, FALSE otherwise. It's always possible
+ * that when you actually try to do it, you will fail.
+ */
+gboolean
+caja_file_can_set_owner (CajaFile *file)
+{
+	/* Not allowed to set the owner if we can't
+	 * even read it. This can happen on non-UNIX file
+	 * systems.
+	 */
+	if (!caja_file_can_get_owner (file)) {
+		return FALSE;
+	}
+
+	/* Only root is also allowed to set the owner. */
+	return geteuid() == 0;
+}
+
+/**
+ * caja_file_set_owner:
+ *
+ * Set the owner of a file. This will only have any effect if
+ * caja_file_can_set_owner returns TRUE.
+ *
+ * @file: The file in question.
+ * @user_name_or_id: The user name to set the owner to.
+ * If the string does not match any user name, and the
+ * string is an integer, the owner will be set to the
+ * userid represented by that integer.
+ * @callback: Function called when asynch owner change succeeds or fails.
+ * @callback_data: Parameter passed back with callback function.
+ */
+void
+caja_file_set_owner (CajaFile *file,
+			 const char *user_name_or_id,
+			 CajaFileOperationCallback callback,
+			 gpointer callback_data)
+{
+	GError *error;
+	GFileInfo *info;
+	uid_t new_id;
+
+	if (!caja_file_can_set_owner (file)) {
+		/* Claim that something changed even if the permission
+		 * change failed. This makes it easier for some
+		 * clients who see the "reverting" to the old owner as
+		 * "changing back".
+		 */
+		caja_file_changed (file);
+		error = g_error_new (G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
+				     _("Not allowed to set owner"));
+		(* callback) (file, NULL, error, callback_data);
+		g_error_free (error);
+		return;
+	}
+
+	/* If no match treating user_name_or_id as name, try treating
+	 * it as id.
+	 */
+	if (!get_user_id_from_user_name (user_name_or_id, &new_id)
+	    && !get_id_from_digit_string (user_name_or_id, &new_id)) {
+		/* Claim that something changed even if the permission
+		 * change failed. This makes it easier for some
+		 * clients who see the "reverting" to the old owner as
+		 * "changing back".
+		 */
+		caja_file_changed (file);
+		error = g_error_new (G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
+				     _("Specified owner '%s' doesn't exist"), user_name_or_id);
+		(* callback) (file, NULL, error, callback_data);
+		g_error_free (error);
+		return;
+	}
+
+	/* Test the owner-hasn't-changed case explicitly because we
+	 * don't want to send the file-changed signal if nothing
+	 * changed.
+	 */
+	if (new_id == (uid_t) file->details->uid) {
+		(* callback) (file, NULL, NULL, callback_data);
+		return;
+	}
+
+	info = g_file_info_new ();
+	g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_UID, new_id);
+	caja_file_set_attributes (file, info, callback, callback_data);
+	g_object_unref (info);
+}
+
+/**
+ * caja_get_user_names:
+ *
+ * Get a list of user names. For users with a different associated
+ * "real name", the real name follows the standard user name, separated
+ * by a carriage return. The caller is responsible for freeing this list
+ * and its contents.
+ */
+GList *
+caja_get_user_names (void)
+{
+	GList *list;
+	char *real_name, *name;
+	struct passwd *user;
+
+	list = NULL;
+
+	setpwent ();
+
+	while ((user = getpwent ()) != NULL) {
+		real_name = get_real_name (user->pw_name, user->pw_gecos);
+		if (real_name != NULL) {
+			name = g_strconcat (user->pw_name, "\n", real_name, NULL);
+		} else {
+			name = g_strdup (user->pw_name);
+		}
+		g_free (real_name);
+		list = g_list_prepend (list, name);
+	}
+
+	endpwent ();
+
+	return eel_g_str_list_alphabetize (list);
+}
+
+/**
+ * caja_file_can_get_group:
+ *
+ * Check whether the group a file is determinable.
+ * This might not be the case for files on non-UNIX file systems.
+ *
+ * @file: The file in question.
+ *
+ * Return value: TRUE if the group is valid.
+ */
+gboolean
+caja_file_can_get_group (CajaFile *file)
+{
+	/* Before we have info on a file, the group is unknown. */
+	return file->details->gid != -1;
+}
+
+/**
+ * caja_file_get_group_name:
+ *
+ * Get the name of the file's group. If the group has no
+ * name, returns the groupid as a string. The caller is responsible
+ * for g_free-ing this string.
+ *
+ * @file: The file in question.
+ *
+ * Return value: A newly-allocated string.
+ **/
+char *
+caja_file_get_group_name (CajaFile *file)
+{
+	return g_strdup (eel_ref_str_peek (file->details->group));
+}
+
+/**
+ * caja_file_can_set_group:
+ *
+ * Check whether the current user is allowed to change
+ * the group of a file.
+ *
+ * @file: The file in question.
+ *
+ * Return value: TRUE if the current user can change the
+ * group of @file, FALSE otherwise. It's always possible
+ * that when you actually try to do it, you will fail.
+ */
+gboolean
+caja_file_can_set_group (CajaFile *file)
+{
+	uid_t user_id;
+
+	/* Not allowed to set the permissions if we can't
+	 * even read them. This can happen on non-UNIX file
+	 * systems.
+	 */
+	if (!caja_file_can_get_group (file)) {
+		return FALSE;
+	}
+
+	/* Check the user. */
+	user_id = geteuid();
+
+	/* Owner is allowed to set group (with restrictions). */
+	if (user_id == (uid_t) file->details->uid) {
+		return TRUE;
+	}
+
+	/* Root is also allowed to set group. */
+	if (user_id == 0) {
+		return TRUE;
+	}
+
+	/* Nobody else is allowed. */
+	return FALSE;
+}
+
+/* Get a list of group names, filtered to only the ones
+ * that contain the given username. If the username is
+ * NULL, returns a list of all group names.
+ */
+static GList *
+caja_get_group_names_for_user (void)
+{
+	GList *list;
+	struct group *group;
+	int count, i;
+	gid_t gid_list[NGROUPS_MAX + 1];
+
+
+	list = NULL;
+
+	count = getgroups (NGROUPS_MAX + 1, gid_list);
+	for (i = 0; i < count; i++) {
+		group = getgrgid (gid_list[i]);
+		if (group == NULL)
+			break;
+
+		list = g_list_prepend (list, g_strdup (group->gr_name));
+	}
+
+	return eel_g_str_list_alphabetize (list);
+}
+
+/**
+ * caja_get_group_names:
+ *
+ * Get a list of all group names.
+ */
+GList *
+caja_get_all_group_names (void)
+{
+	GList *list;
+	struct group *group;
+
+	list = NULL;
+
+	setgrent ();
+
+	while ((group = getgrent ()) != NULL)
+		list = g_list_prepend (list, g_strdup (group->gr_name));
+
+	endgrent ();
+
+	return eel_g_str_list_alphabetize (list);
+}
+
+/**
+ * caja_file_get_settable_group_names:
+ *
+ * Get a list of all group names that the current user
+ * can set the group of a specific file to.
+ *
+ * @file: The CajaFile in question.
+ */
+GList *
+caja_file_get_settable_group_names (CajaFile *file)
+{
+	uid_t user_id;
+	GList *result;
+
+	if (!caja_file_can_set_group (file)) {
+		return NULL;
+	}
+
+	/* Check the user. */
+	user_id = geteuid();
+
+	if (user_id == 0) {
+		/* Root is allowed to set group to anything. */
+		result = caja_get_all_group_names ();
+	} else if (user_id == (uid_t) file->details->uid) {
+		/* Owner is allowed to set group to any that owner is member of. */
+		result = caja_get_group_names_for_user ();
+	} else {
+		g_warning ("unhandled case in caja_get_settable_group_names");
+		result = NULL;
+	}
+
+	return result;
+}
+
+/**
+ * caja_file_set_group:
+ *
+ * Set the group of a file. This will only have any effect if
+ * caja_file_can_set_group returns TRUE.
+ *
+ * @file: The file in question.
+ * @group_name_or_id: The group name to set the owner to.
+ * If the string does not match any group name, and the
+ * string is an integer, the group will be set to the
+ * group id represented by that integer.
+ * @callback: Function called when asynch group change succeeds or fails.
+ * @callback_data: Parameter passed back with callback function.
+ */
+void
+caja_file_set_group (CajaFile *file,
+			 const char *group_name_or_id,
+			 CajaFileOperationCallback callback,
+			 gpointer callback_data)
+{
+	GError *error;
+	GFileInfo *info;
+	uid_t new_id;
+
+	if (!caja_file_can_set_group (file)) {
+		/* Claim that something changed even if the group
+		 * change failed. This makes it easier for some
+		 * clients who see the "reverting" to the old group as
+		 * "changing back".
+		 */
+		caja_file_changed (file);
+		error = g_error_new (G_IO_ERROR, G_IO_ERROR_PERMISSION_DENIED,
+				     _("Not allowed to set group"));
+		(* callback) (file, NULL, error, callback_data);
+		g_error_free (error);
+		return;
+	}
+
+	/* If no match treating group_name_or_id as name, try treating
+	 * it as id.
+	 */
+	if (!get_group_id_from_group_name (group_name_or_id, &new_id)
+	    && !get_id_from_digit_string (group_name_or_id, &new_id)) {
+		/* Claim that something changed even if the group
+		 * change failed. This makes it easier for some
+		 * clients who see the "reverting" to the old group as
+		 * "changing back".
+		 */
+		caja_file_changed (file);
+		error = g_error_new (G_IO_ERROR, G_IO_ERROR_INVALID_ARGUMENT,
+				     _("Specified group '%s' doesn't exist"), group_name_or_id);
+		(* callback) (file, NULL, error, callback_data);
+		g_error_free (error);
+		return;
+	}
+
+	if (new_id == (gid_t) file->details->gid) {
+		(* callback) (file, NULL, NULL, callback_data);
+		return;
+	}
+
+
+	info = g_file_info_new ();
+	g_file_info_set_attribute_uint32 (info, G_FILE_ATTRIBUTE_UNIX_GID, new_id);
+	caja_file_set_attributes (file, info, callback, callback_data);
+	g_object_unref (info);
+}
+
+/**
+ * caja_file_get_octal_permissions_as_string:
+ *
+ * Get a user-displayable string representing a file's permissions
+ * as an octal number. The caller
+ * is responsible for g_free-ing this string.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: Newly allocated string ready to display to the user.
+ *
+ **/
+static char *
+caja_file_get_octal_permissions_as_string (CajaFile *file)
+{
+	guint32 permissions;
+
+	g_assert (CAJA_IS_FILE (file));
+
+	if (!caja_file_can_get_permissions (file)) {
+		return NULL;
+	}
+
+	permissions = file->details->permissions;
+	return g_strdup_printf ("%03o", permissions);
+}
+
+/**
+ * caja_file_get_permissions_as_string:
+ *
+ * Get a user-displayable string representing a file's permissions. The caller
+ * is responsible for g_free-ing this string.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: Newly allocated string ready to display to the user.
+ *
+ **/
+static char *
+caja_file_get_permissions_as_string (CajaFile *file)
+{
+	guint32 permissions;
+	gboolean is_directory;
+	gboolean is_link;
+	gboolean suid, sgid, sticky;
+
+	if (!caja_file_can_get_permissions (file)) {
+		return NULL;
+	}
+
+	g_assert (CAJA_IS_FILE (file));
+
+	permissions = file->details->permissions;
+	is_directory = caja_file_is_directory (file);
+	is_link = caja_file_is_symbolic_link (file);
+
+	/* We use ls conventions for displaying these three obscure flags */
+	suid = permissions & S_ISUID;
+	sgid = permissions & S_ISGID;
+	sticky = permissions & S_ISVTX;
+
+	return g_strdup_printf ("%c%c%c%c%c%c%c%c%c%c",
+				 is_link ? 'l' : is_directory ? 'd' : '-',
+		 		 permissions & S_IRUSR ? 'r' : '-',
+				 permissions & S_IWUSR ? 'w' : '-',
+				 permissions & S_IXUSR
+				 	? (suid ? 's' : 'x')
+				 	: (suid ? 'S' : '-'),
+				 permissions & S_IRGRP ? 'r' : '-',
+				 permissions & S_IWGRP ? 'w' : '-',
+				 permissions & S_IXGRP
+				 	? (sgid ? 's' : 'x')
+				 	: (sgid ? 'S' : '-'),
+				 permissions & S_IROTH ? 'r' : '-',
+				 permissions & S_IWOTH ? 'w' : '-',
+				 permissions & S_IXOTH
+				 	? (sticky ? 't' : 'x')
+				 	: (sticky ? 'T' : '-'));
+}
+
+/**
+ * caja_file_get_owner_as_string:
+ *
+ * Get a user-displayable string representing a file's owner. The caller
+ * is responsible for g_free-ing this string.
+ * @file: CajaFile representing the file in question.
+ * @include_real_name: Whether or not to append the real name (if any)
+ * for this user after the user name.
+ *
+ * Returns: Newly allocated string ready to display to the user.
+ *
+ **/
+static char *
+caja_file_get_owner_as_string (CajaFile *file, gboolean include_real_name)
+{
+	char *user_name;
+
+	/* Before we have info on a file, the owner is unknown. */
+	if (file->details->owner == NULL &&
+	    file->details->owner_real == NULL) {
+		return NULL;
+	}
+
+	if (file->details->owner_real == NULL) {
+		user_name = g_strdup (eel_ref_str_peek (file->details->owner));
+	} else if (file->details->owner == NULL) {
+		user_name = g_strdup (eel_ref_str_peek (file->details->owner_real));
+	} else if (include_real_name &&
+		   strcmp (eel_ref_str_peek (file->details->owner), eel_ref_str_peek (file->details->owner_real)) != 0) {
+		user_name = g_strdup_printf ("%s - %s",
+					     eel_ref_str_peek (file->details->owner),
+					     eel_ref_str_peek (file->details->owner_real));
+	} else {
+		user_name = g_strdup (eel_ref_str_peek (file->details->owner));
+	}
+
+	return user_name;
+}
+
+static char *
+format_item_count_for_display (guint item_count,
+			       gboolean includes_directories,
+			       gboolean includes_files)
+{
+	g_assert (includes_directories || includes_files);
+
+	return g_strdup_printf (includes_directories
+			? (includes_files
+			   ? ngettext ("%'u item", "%'u items", item_count)
+			   : ngettext ("%'u folder", "%'u folders", item_count))
+			: ngettext ("%'u file", "%'u files", item_count), item_count);
+}
+
+/**
+ * caja_file_get_size_as_string:
+ *
+ * Get a user-displayable string representing a file size. The caller
+ * is responsible for g_free-ing this string. The string is an item
+ * count for directories.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: Newly allocated string ready to display to the user.
+ *
+ **/
+static char *
+caja_file_get_size_as_string (CajaFile *file)
+{
+	guint item_count;
+	gboolean count_unreadable;
+
+	if (file == NULL) {
+		return NULL;
+	}
+
+	g_assert (CAJA_IS_FILE (file));
+
+	if (caja_file_is_directory (file)) {
+		if (!caja_file_get_directory_item_count (file, &item_count, &count_unreadable)) {
+			return NULL;
+		}
+		return format_item_count_for_display (item_count, TRUE, TRUE);
+	}
+
+	if (file->details->size == -1) {
+		return NULL;
+	}
+
+	#if GLIB_CHECK_VERSION(2, 30, 0)
+		return g_format_size(file->details->size);
+	#else  // Since 2.16
+		return g_format_size_for_display(file->details->size);
+	#endif
+}
+
+/**
+ * caja_file_get_size_as_string_with_real_size:
+ *
+ * Get a user-displayable string representing a file size. The caller
+ * is responsible for g_free-ing this string. The string is an item
+ * count for directories.
+ * This function adds the real size in the string.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: Newly allocated string ready to display to the user.
+ *
+ **/
+static char *
+caja_file_get_size_as_string_with_real_size (CajaFile *file)
+{
+	guint item_count;
+	gboolean count_unreadable;
+	char * formated;
+	char * formated_plus_real;
+	char * real_size;
+
+	if (file == NULL) {
+		return NULL;
+	}
+
+	g_assert (CAJA_IS_FILE (file));
+
+	if (caja_file_is_directory (file)) {
+		if (!caja_file_get_directory_item_count (file, &item_count, &count_unreadable)) {
+			return NULL;
+		}
+		return format_item_count_for_display (item_count, TRUE, TRUE);
+	}
+
+	if (file->details->size == -1) {
+		return NULL;
+	}
+
+	#if GLIB_CHECK_VERSION(2, 30, 0)
+		formated = g_format_size(file->details->size);
+	#else
+		formated = g_format_size_for_display(file->details->size);
+	#endif
+
+	/* Do this in a separate stage so that we don't have to put G_GUINT64_FORMAT in the translated string */
+	real_size = g_strdup_printf (_("%"G_GUINT64_FORMAT), (guint64) file->details->size);
+	formated_plus_real = g_strdup_printf (_("%s (%s bytes)"), formated, real_size);
+	g_free (real_size);
+	g_free (formated);
+	return formated_plus_real;
+}
+
+
+static char *
+caja_file_get_deep_count_as_string_internal (CajaFile *file,
+						 gboolean report_size,
+						 gboolean report_directory_count,
+						 gboolean report_file_count)
+{
+	CajaRequestStatus status;
+	guint directory_count;
+	guint file_count;
+	guint unreadable_count;
+	guint total_count;
+	goffset total_size;
+
+	/* Must ask for size or some kind of count, but not both. */
+	g_assert (!report_size || (!report_directory_count && !report_file_count));
+	g_assert (report_size || report_directory_count || report_file_count);
+
+	if (file == NULL) {
+		return NULL;
+	}
+
+	g_assert (CAJA_IS_FILE (file));
+	g_assert (caja_file_is_directory (file));
+
+	status = caja_file_get_deep_counts
+		(file, &directory_count, &file_count, &unreadable_count, &total_size, FALSE);
+
+	/* Check whether any info is available. */
+	if (status == CAJA_REQUEST_NOT_STARTED) {
+		return NULL;
+	}
+
+	total_count = file_count + directory_count;
+
+	if (total_count == 0) {
+		switch (status) {
+		case CAJA_REQUEST_IN_PROGRESS:
+			/* Don't return confident "zero" until we're finished looking,
+			 * because of next case.
+			 */
+			return NULL;
+		case CAJA_REQUEST_DONE:
+			/* Don't return "zero" if we there were contents but we couldn't read them. */
+			if (unreadable_count != 0) {
+				return NULL;
+			}
+		default: break;
+		}
+	}
+
+	/* Note that we don't distinguish the "everything was readable" case
+	 * from the "some things but not everything was readable" case here.
+	 * Callers can distinguish them using caja_file_get_deep_counts
+	 * directly if desired.
+	 */
+	if (report_size)
+	{
+		#if GLIB_CHECK_VERSION(2, 30, 0)
+			return g_format_size(total_size);
+		#else
+			return g_format_size_for_display(total_size);
+		#endif
+	}
+
+	return format_item_count_for_display (report_directory_count
+		? (report_file_count ? total_count : directory_count)
+		: file_count,
+		report_directory_count, report_file_count);
+}
+
+/**
+ * caja_file_get_deep_size_as_string:
+ *
+ * Get a user-displayable string representing the size of all contained
+ * items (only makes sense for directories). The caller
+ * is responsible for g_free-ing this string.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: Newly allocated string ready to display to the user.
+ *
+ **/
+static char *
+caja_file_get_deep_size_as_string (CajaFile *file)
+{
+	return caja_file_get_deep_count_as_string_internal (file, TRUE, FALSE, FALSE);
+}
+
+/**
+ * caja_file_get_deep_total_count_as_string:
+ *
+ * Get a user-displayable string representing the count of all contained
+ * items (only makes sense for directories). The caller
+ * is responsible for g_free-ing this string.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: Newly allocated string ready to display to the user.
+ *
+ **/
+static char *
+caja_file_get_deep_total_count_as_string (CajaFile *file)
+{
+	return caja_file_get_deep_count_as_string_internal (file, FALSE, TRUE, TRUE);
+}
+
+/**
+ * caja_file_get_deep_file_count_as_string:
+ *
+ * Get a user-displayable string representing the count of all contained
+ * items, not including directories. It only makes sense to call this
+ * function on a directory. The caller
+ * is responsible for g_free-ing this string.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: Newly allocated string ready to display to the user.
+ *
+ **/
+static char *
+caja_file_get_deep_file_count_as_string (CajaFile *file)
+{
+	return caja_file_get_deep_count_as_string_internal (file, FALSE, FALSE, TRUE);
+}
+
+/**
+ * caja_file_get_deep_directory_count_as_string:
+ *
+ * Get a user-displayable string representing the count of all contained
+ * directories. It only makes sense to call this
+ * function on a directory. The caller
+ * is responsible for g_free-ing this string.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: Newly allocated string ready to display to the user.
+ *
+ **/
+static char *
+caja_file_get_deep_directory_count_as_string (CajaFile *file)
+{
+	return caja_file_get_deep_count_as_string_internal (file, FALSE, TRUE, FALSE);
+}
+
+/**
+ * caja_file_get_string_attribute:
+ *
+ * Get a user-displayable string from a named attribute. Use g_free to
+ * free this string. If the value is unknown, returns NULL. You can call
+ * caja_file_get_string_attribute_with_default if you want a non-NULL
+ * default.
+ *
+ * @file: CajaFile representing the file in question.
+ * @attribute_name: The name of the desired attribute. The currently supported
+ * set includes "name", "type", "mime_type", "size", "deep_size", "deep_directory_count",
+ * "deep_file_count", "deep_total_count", "date_modified", "date_changed", "date_accessed",
+ * "date_permissions", "owner", "group", "permissions", "octal_permissions", "uri", "where",
+ * "link_target", "volume", "free_space", "selinux_context", "trashed_on", "trashed_orig_path"
+ *
+ * Returns: Newly allocated string ready to display to the user, or NULL
+ * if the value is unknown or @attribute_name is not supported.
+ *
+ **/
+char *
+caja_file_get_string_attribute_q (CajaFile *file, GQuark attribute_q)
+{
+	char *extension_attribute;
+
+	if (attribute_q == attribute_name_q) {
+		return caja_file_get_display_name (file);
+	}
+	if (attribute_q == attribute_type_q) {
+		return caja_file_get_type_as_string (file);
+	}
+	if (attribute_q == attribute_mime_type_q) {
+		return caja_file_get_mime_type (file);
+	}
+	if (attribute_q == attribute_size_q) {
+		return caja_file_get_size_as_string (file);
+	}
+	if (attribute_q == attribute_size_detail_q) {
+		return caja_file_get_size_as_string_with_real_size (file);
+	}
+	if (attribute_q == attribute_deep_size_q) {
+		return caja_file_get_deep_size_as_string (file);
+	}
+	if (attribute_q == attribute_deep_file_count_q) {
+		return caja_file_get_deep_file_count_as_string (file);
+	}
+	if (attribute_q == attribute_deep_directory_count_q) {
+		return caja_file_get_deep_directory_count_as_string (file);
+	}
+	if (attribute_q == attribute_deep_total_count_q) {
+		return caja_file_get_deep_total_count_as_string (file);
+	}
+	if (attribute_q == attribute_trash_orig_path_q) {
+		return caja_file_get_trash_original_file_parent_as_string (file);
+	}
+	if (attribute_q == attribute_date_modified_q) {
+		return caja_file_get_date_as_string (file,
+							 CAJA_DATE_TYPE_MODIFIED);
+	}
+	if (attribute_q == attribute_date_changed_q) {
+		return caja_file_get_date_as_string (file,
+							 CAJA_DATE_TYPE_CHANGED);
+	}
+	if (attribute_q == attribute_date_accessed_q) {
+		return caja_file_get_date_as_string (file,
+							 CAJA_DATE_TYPE_ACCESSED);
+	}
+	if (attribute_q == attribute_trashed_on_q) {
+		return caja_file_get_date_as_string (file,
+							 CAJA_DATE_TYPE_TRASHED);
+	}
+	if (attribute_q == attribute_date_permissions_q) {
+		return caja_file_get_date_as_string (file,
+							 CAJA_DATE_TYPE_PERMISSIONS_CHANGED);
+	}
+	if (attribute_q == attribute_permissions_q) {
+		return caja_file_get_permissions_as_string (file);
+	}
+	if (attribute_q == attribute_selinux_context_q) {
+		return caja_file_get_selinux_context (file);
+	}
+	if (attribute_q == attribute_octal_permissions_q) {
+		return caja_file_get_octal_permissions_as_string (file);
+	}
+	if (attribute_q == attribute_owner_q) {
+		return caja_file_get_owner_as_string (file, TRUE);
+	}
+	if (attribute_q == attribute_group_q) {
+		return caja_file_get_group_name (file);
+	}
+	if (attribute_q == attribute_uri_q) {
+		return caja_file_get_uri (file);
+	}
+	if (attribute_q == attribute_where_q) {
+		return caja_file_get_where_string (file);
+	}
+	if (attribute_q == attribute_link_target_q) {
+		return caja_file_get_symbolic_link_target_path (file);
+	}
+	if (attribute_q == attribute_volume_q) {
+		return caja_file_get_volume_name (file);
+	}
+	if (attribute_q == attribute_free_space_q) {
+		return caja_file_get_volume_free_space (file);
+	}
+
+	extension_attribute = NULL;
+
+	if (file->details->pending_extension_attributes) {
+		extension_attribute = g_hash_table_lookup (file->details->pending_extension_attributes,
+							   GINT_TO_POINTER (attribute_q));
+	}
+
+	if (extension_attribute == NULL && file->details->extension_attributes) {
+		extension_attribute = g_hash_table_lookup (file->details->extension_attributes,
+							   GINT_TO_POINTER (attribute_q));
+	}
+
+	return g_strdup (extension_attribute);
+}
+
+char *
+caja_file_get_string_attribute (CajaFile *file, const char *attribute_name)
+{
+	return caja_file_get_string_attribute_q (file, g_quark_from_string (attribute_name));
+}
+
+
+/**
+ * caja_file_get_string_attribute_with_default:
+ *
+ * Get a user-displayable string from a named attribute. Use g_free to
+ * free this string. If the value is unknown, returns a string representing
+ * the unknown value, which varies with attribute. You can call
+ * caja_file_get_string_attribute if you want NULL instead of a default
+ * result.
+ *
+ * @file: CajaFile representing the file in question.
+ * @attribute_name: The name of the desired attribute. See the description of
+ * caja_file_get_string for the set of available attributes.
+ *
+ * Returns: Newly allocated string ready to display to the user, or a string
+ * such as "unknown" if the value is unknown or @attribute_name is not supported.
+ *
+ **/
+char *
+caja_file_get_string_attribute_with_default_q (CajaFile *file, GQuark attribute_q)
+{
+	char *result;
+	guint item_count;
+	gboolean count_unreadable;
+	CajaRequestStatus status;
+
+	result = caja_file_get_string_attribute_q (file, attribute_q);
+	if (result != NULL) {
+		return result;
+	}
+
+	/* Supply default values for the ones we know about. */
+	/* FIXME bugzilla.gnome.org 40646:
+	 * Use hash table and switch statement or function pointers for speed?
+	 */
+	if (attribute_q == attribute_size_q) {
+		if (!caja_file_should_show_directory_item_count (file)) {
+			return g_strdup ("--");
+		}
+		count_unreadable = FALSE;
+		if (caja_file_is_directory (file)) {
+			caja_file_get_directory_item_count (file, &item_count, &count_unreadable);
+		}
+		return g_strdup (count_unreadable ? _("? items") : "...");
+	}
+	if (attribute_q == attribute_deep_size_q) {
+		status = caja_file_get_deep_counts (file, NULL, NULL, NULL, NULL, FALSE);
+		if (status == CAJA_REQUEST_DONE) {
+			/* This means no contents at all were readable */
+			return g_strdup (_("? bytes"));
+		}
+		return g_strdup ("...");
+	}
+	if (attribute_q == attribute_deep_file_count_q
+	    || attribute_q == attribute_deep_directory_count_q
+	    || attribute_q == attribute_deep_total_count_q) {
+		status = caja_file_get_deep_counts (file, NULL, NULL, NULL, NULL, FALSE);
+		if (status == CAJA_REQUEST_DONE) {
+			/* This means no contents at all were readable */
+			return g_strdup (_("? items"));
+		}
+		return g_strdup ("...");
+	}
+	if (attribute_q == attribute_type_q) {
+		return g_strdup (_("unknown type"));
+	}
+	if (attribute_q == attribute_mime_type_q) {
+		return g_strdup (_("unknown MIME type"));
+	}
+	if (attribute_q == attribute_trashed_on_q) {
+		/* If n/a */
+		return g_strdup ("");
+	}
+	if (attribute_q == attribute_trash_orig_path_q) {
+		/* If n/a */
+		return g_strdup ("");
+	}
+
+	/* Fallback, use for both unknown attributes and attributes
+	 * for which we have no more appropriate default.
+	 */
+	return g_strdup (_("unknown"));
+}
+
+char *
+caja_file_get_string_attribute_with_default (CajaFile *file, const char *attribute_name)
+{
+	return caja_file_get_string_attribute_with_default_q (file, g_quark_from_string (attribute_name));
+}
+
+gboolean
+caja_file_is_date_sort_attribute_q (GQuark attribute_q)
+{
+	if (attribute_q == attribute_modification_date_q ||
+	    attribute_q == attribute_date_modified_q ||
+	    attribute_q == attribute_accessed_date_q ||
+	    attribute_q == attribute_date_accessed_q ||
+	    attribute_q == attribute_date_changed_q ||
+	    attribute_q == attribute_trashed_on_q ||
+	    attribute_q == attribute_date_permissions_q) {
+		return TRUE;
+	}
+
+	return FALSE;
+}
+
+/**
+ * get_description:
+ *
+ * Get a user-displayable string representing a file type. The caller
+ * is responsible for g_free-ing this string.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: Newly allocated string ready to display to the user.
+ *
+ **/
+static char *
+get_description (CajaFile *file)
+{
+	const char *mime_type;
+	char *description;
+
+	g_assert (CAJA_IS_FILE (file));
+
+	mime_type = eel_ref_str_peek (file->details->mime_type);
+	if (eel_str_is_empty (mime_type)) {
+		return NULL;
+	}
+
+	if (g_content_type_is_unknown (mime_type) &&
+	    caja_file_is_executable (file)) {
+		return g_strdup (_("program"));
+	}
+
+	description = g_content_type_get_description (mime_type);
+	if (!eel_str_is_empty (description)) {
+		return description;
+	}
+
+	return g_strdup (mime_type);
+}
+
+/* Takes ownership of string */
+static char *
+update_description_for_link (CajaFile *file, char *string)
+{
+	char *res;
+
+	if (caja_file_is_symbolic_link (file)) {
+		g_assert (!caja_file_is_broken_symbolic_link (file));
+		if (string == NULL) {
+			return g_strdup (_("link"));
+		}
+		/* Note to localizers: convert file type string for file
+		 * (e.g. "folder", "plain text") to file type for symbolic link
+		 * to that kind of file (e.g. "link to folder").
+		 */
+		res = g_strdup_printf (_("Link to %s"), string);
+		g_free (string);
+		return res;
+	}
+
+	return string;
+}
+
+static char *
+caja_file_get_type_as_string (CajaFile *file)
+{
+	if (file == NULL) {
+		return NULL;
+	}
+
+	if (caja_file_is_broken_symbolic_link (file)) {
+		return g_strdup (_("link (broken)"));
+	}
+
+	return update_description_for_link (file, get_description (file));
+}
+
+/**
+ * caja_file_get_file_type
+ *
+ * Return this file's type.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: The type.
+ *
+ **/
+GFileType
+caja_file_get_file_type (CajaFile *file)
+{
+	if (file == NULL) {
+		return G_FILE_TYPE_UNKNOWN;
+	}
+
+	return file->details->type;
+}
+
+/**
+ * caja_file_get_mime_type
+ *
+ * Return this file's default mime type.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: The mime type.
+ *
+ **/
+char *
+caja_file_get_mime_type (CajaFile *file)
+{
+	if (file != NULL) {
+		g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+		if (file->details->mime_type != NULL) {
+			return g_strdup (eel_ref_str_peek (file->details->mime_type));
+		}
+	}
+	return g_strdup ("application/octet-stream");
+}
+
+/**
+ * caja_file_is_mime_type
+ *
+ * Check whether a file is of a particular MIME type, or inherited
+ * from it.
+ * @file: CajaFile representing the file in question.
+ * @mime_type: The MIME-type string to test (e.g. "text/plain")
+ *
+ * Return value: TRUE if @mime_type exactly matches the
+ * file's MIME type.
+ *
+ **/
+gboolean
+caja_file_is_mime_type (CajaFile *file, const char *mime_type)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+	g_return_val_if_fail (mime_type != NULL, FALSE);
+
+	if (file->details->mime_type == NULL) {
+		return FALSE;
+	}
+	return g_content_type_is_a (eel_ref_str_peek (file->details->mime_type),
+				    mime_type);
+}
+
+gboolean
+caja_file_is_launchable (CajaFile *file)
+{
+	gboolean type_can_be_executable;
+
+	type_can_be_executable = FALSE;
+	if (file->details->mime_type != NULL) {
+		type_can_be_executable =
+			g_content_type_can_be_executable (eel_ref_str_peek (file->details->mime_type));
+	}
+
+	return type_can_be_executable &&
+		caja_file_can_get_permissions (file) &&
+		caja_file_can_execute (file) &&
+		caja_file_is_executable (file) &&
+		!caja_file_is_directory (file);
+}
+
+
+/**
+ * caja_file_get_emblem_icons
+ *
+ * Return the list of names of emblems that this file should display,
+ * in canonical order.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: A list of emblem names.
+ *
+ **/
+GList *
+caja_file_get_emblem_icons (CajaFile *file,
+				char **exclude)
+{
+	GList *keywords, *l;
+	GList *icons;
+	char *icon_names[2];
+	char *keyword;
+	int i;
+	GIcon *icon;
+
+	if (file == NULL) {
+		return NULL;
+	}
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+	keywords = caja_file_get_keywords (file);
+	keywords = prepend_automatic_keywords (file, keywords);
+
+	icons = NULL;
+	for (l = keywords; l != NULL; l = l->next) {
+		keyword = l->data;
+
+#ifdef TRASH_IS_FAST_ENOUGH
+		if (strcmp (keyword, CAJA_FILE_EMBLEM_NAME_TRASH) == 0) {
+			char *uri;
+			gboolean file_is_trash;
+			/* Leave out the trash emblem for the trash itself, since
+			 * putting a trash emblem on a trash icon is gilding the
+			 * lily.
+			 */
+			uri = caja_file_get_uri (file);
+			file_is_trash = strcmp (uri, EEL_TRASH_URI) == 0;
+			g_free (uri);
+			if (file_is_trash) {
+				continue;
+			}
+		}
+#endif
+		if (exclude) {
+			for (i = 0; exclude[i] != NULL; i++) {
+				if (strcmp (exclude[i], keyword) == 0) {
+					continue;
+				}
+			}
+		}
+
+
+		icon_names[0] = g_strconcat ("emblem-", keyword, NULL);
+		icon_names[1] = keyword;
+		icon = g_themed_icon_new_from_names (icon_names, 2);
+		g_free (icon_names[0]);
+
+		icons = g_list_prepend (icons, icon);
+	}
+
+	eel_g_list_free_deep (keywords);
+
+	return icons;
+}
+
+GList *
+caja_file_get_emblem_pixbufs (CajaFile *file,
+				  int size,
+				  gboolean force_size,
+				  char **exclude)
+{
+	GList *icons, *l;
+	GList *pixbufs;
+	GIcon *icon;
+	GdkPixbuf *pixbuf;
+	CajaIconInfo *icon_info;
+
+	icons = caja_file_get_emblem_icons (file, exclude);
+	pixbufs = NULL;
+
+	for (l = icons; l != NULL; l = l->next) {
+		icon = l->data;
+
+		icon_info = caja_icon_info_lookup (icon, size);
+		if (force_size) {
+			pixbuf = caja_icon_info_get_pixbuf_nodefault_at_size (icon_info, size);
+		} else {
+			pixbuf = caja_icon_info_get_pixbuf_nodefault (icon_info);
+		}
+
+		if (pixbuf) {
+			pixbufs = g_list_prepend (pixbufs, pixbuf);
+		}
+
+
+		g_object_unref (icon_info);
+		g_object_unref (icon);
+	}
+	g_list_free (icons);
+
+	return g_list_reverse (pixbufs);
+
+
+}
+
+static GList *
+sort_keyword_list_and_remove_duplicates (GList *keywords)
+{
+	GList *p;
+	GList *duplicate_link;
+
+	if (keywords != NULL) {
+		keywords = eel_g_str_list_alphabetize (keywords);
+
+		p = keywords;
+		while (p->next != NULL) {
+			if (strcmp ((const char *) p->data, (const char *) p->next->data) == 0) {
+				duplicate_link = p->next;
+				keywords = g_list_remove_link (keywords, duplicate_link);
+				eel_g_list_free_deep (duplicate_link);
+			} else {
+				p = p->next;
+			}
+		}
+	}
+
+	return keywords;
+}
+
+/**
+ * caja_file_get_keywords
+ *
+ * Return this file's keywords.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: A list of keywords.
+ *
+ **/
+GList *
+caja_file_get_keywords (CajaFile *file)
+{
+	GList *keywords;
+
+	if (file == NULL) {
+		return NULL;
+	}
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+	/* Put all the keywords into a list. */
+	keywords = caja_file_get_metadata_list
+		(file, CAJA_METADATA_KEY_EMBLEMS);
+
+	keywords = g_list_concat (keywords, eel_g_str_list_copy (file->details->extension_emblems));
+	keywords = g_list_concat (keywords, eel_g_str_list_copy (file->details->pending_extension_emblems));
+
+	return sort_keyword_list_and_remove_duplicates (keywords);
+}
+
+/**
+ * caja_file_set_keywords
+ *
+ * Change this file's keywords.
+ * @file: CajaFile representing the file in question.
+ * @keywords: New set of keywords (a GList of strings).
+ *
+ **/
+void
+caja_file_set_keywords (CajaFile *file, GList *keywords)
+{
+	GList *canonical_keywords;
+
+	/* Invalidate the emblem compare cache */
+	g_free (file->details->compare_by_emblem_cache);
+	file->details->compare_by_emblem_cache = NULL;
+
+	g_return_if_fail (CAJA_IS_FILE (file));
+
+	canonical_keywords = sort_keyword_list_and_remove_duplicates
+		(g_list_copy (keywords));
+	caja_file_set_metadata_list
+		(file, CAJA_METADATA_KEY_EMBLEMS, canonical_keywords);
+	g_list_free (canonical_keywords);
+}
+
+/**
+ * caja_file_is_symbolic_link
+ *
+ * Check if this file is a symbolic link.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: True if the file is a symbolic link.
+ *
+ **/
+gboolean
+caja_file_is_symbolic_link (CajaFile *file)
+{
+	return file->details->is_symlink;
+}
+
+gboolean
+caja_file_is_mountpoint (CajaFile *file)
+{
+	return file->details->is_mountpoint;
+}
+
+GMount *
+caja_file_get_mount (CajaFile *file)
+{
+	if (file->details->mount) {
+		return g_object_ref (file->details->mount);
+	}
+	return NULL;
+}
+
+static void
+file_mount_unmounted (GMount *mount,
+		      gpointer data)
+{
+	CajaFile *file;
+
+	file = CAJA_FILE (data);
+
+	caja_file_invalidate_attributes (file, CAJA_FILE_ATTRIBUTE_MOUNT);
+}
+
+void
+caja_file_set_mount (CajaFile *file,
+			 GMount *mount)
+{
+	if (file->details->mount) {
+		g_signal_handlers_disconnect_by_func (file->details->mount, file_mount_unmounted, file);
+		g_object_unref (file->details->mount);
+		file->details->mount = NULL;
+	}
+
+	if (mount) {
+		file->details->mount = g_object_ref (mount);
+		g_signal_connect (mount, "unmounted",
+				  G_CALLBACK (file_mount_unmounted), file);
+	}
+}
+
+/**
+ * caja_file_is_broken_symbolic_link
+ *
+ * Check if this file is a symbolic link with a missing target.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: True if the file is a symbolic link with a missing target.
+ *
+ **/
+gboolean
+caja_file_is_broken_symbolic_link (CajaFile *file)
+{
+	if (file == NULL) {
+		return FALSE;
+	}
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	/* Non-broken symbolic links return the target's type for get_file_type. */
+	return caja_file_get_file_type (file) == G_FILE_TYPE_SYMBOLIC_LINK;
+}
+
+static void
+get_fs_free_cb (GObject *source_object,
+		GAsyncResult *res,
+		gpointer user_data)
+{
+	CajaDirectory *directory;
+	CajaFile *file;
+	guint64 free_space;
+	GFileInfo *info;
+
+	directory = CAJA_DIRECTORY (user_data);
+
+	free_space = (guint64)-1;
+	info = g_file_query_filesystem_info_finish (G_FILE (source_object),
+						    res, NULL);
+	if (info) {
+		if (g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE)) {
+			free_space = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_FILESYSTEM_FREE);
+		}
+		g_object_unref (info);
+	}
+
+	if (directory->details->free_space != free_space) {
+		directory->details->free_space = free_space;
+		file = caja_directory_get_existing_corresponding_file (directory);
+		if (file) {
+			caja_file_emit_changed (file);
+			caja_file_unref (file);
+		}
+	}
+	caja_directory_unref (directory);
+}
+
+/**
+ * caja_file_get_volume_free_space
+ * Get a nicely formatted char with free space on the file's volume
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: newly-allocated copy of file size in a formatted string
+ */
+char *
+caja_file_get_volume_free_space (CajaFile *file)
+{
+	CajaDirectory *directory;
+	GFile *location;
+	char *res;
+	time_t now;
+
+	directory = caja_directory_get_for_file (file);
+
+	now = time (NULL);
+	/* Update first time and then every 2 seconds */
+	if (directory->details->free_space_read == 0 ||
+	    (now - directory->details->free_space_read) > 2)  {
+		directory->details->free_space_read = now;
+		location = caja_file_get_location (file);
+		g_file_query_filesystem_info_async (location,
+						    G_FILE_ATTRIBUTE_FILESYSTEM_FREE,
+						    0, NULL,
+						    get_fs_free_cb,
+						    directory); /* Inherits ref */
+		g_object_unref (location);
+	} else {
+		caja_directory_unref (directory);
+	}
+
+
+	res = NULL;
+
+	if (directory->details->free_space != (guint64) -1)
+	{
+		#if GLIB_CHECK_VERSION(2, 30, 0)
+			res = g_format_size(directory->details->free_space);
+		#else
+			res = g_format_size_for_display(directory->details->free_space);
+		#endif
+	}
+
+	return res;
+}
+
+/**
+ * caja_file_get_volume_name
+ * Get the path of the volume the file resides on
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: newly-allocated copy of the volume name of the target file,
+ * if the volume name isn't set, it returns the mount path of the volume
+ */
+char *
+caja_file_get_volume_name (CajaFile *file)
+{
+	GFile *location;
+	char *res;
+	GMount *mount;
+
+	res = NULL;
+
+	location = caja_file_get_location (file);
+	mount = g_file_find_enclosing_mount (location, NULL, NULL);
+	if (mount) {
+		res = g_strdup (g_mount_get_name (mount));
+		g_object_unref (mount);
+	}
+	g_object_unref (location);
+
+	return res;
+}
+
+/**
+ * caja_file_get_symbolic_link_target_path
+ *
+ * Get the file path of the target of a symbolic link. It is an error
+ * to call this function on a file that isn't a symbolic link.
+ * @file: CajaFile representing the symbolic link in question.
+ *
+ * Returns: newly-allocated copy of the file path of the target of the symbolic link.
+ */
+char *
+caja_file_get_symbolic_link_target_path (CajaFile *file)
+{
+	if (!caja_file_is_symbolic_link (file)) {
+		g_warning ("File has symlink target, but  is not marked as symlink");
+	}
+
+	return g_strdup (file->details->symlink_name);
+}
+
+/**
+ * caja_file_get_symbolic_link_target_uri
+ *
+ * Get the uri of the target of a symbolic link. It is an error
+ * to call this function on a file that isn't a symbolic link.
+ * @file: CajaFile representing the symbolic link in question.
+ *
+ * Returns: newly-allocated copy of the uri of the target of the symbolic link.
+ */
+char *
+caja_file_get_symbolic_link_target_uri (CajaFile *file)
+{
+	GFile *location, *parent, *target;
+	char *target_uri;
+
+	if (!caja_file_is_symbolic_link (file)) {
+		g_warning ("File has symlink target, but  is not marked as symlink");
+	}
+
+	if (file->details->symlink_name == NULL) {
+		return NULL;
+	} else {
+		target = NULL;
+
+		location = caja_file_get_location (file);
+		parent = g_file_get_parent (location);
+		g_object_unref (location);
+		if (parent) {
+			target = g_file_resolve_relative_path (parent, file->details->symlink_name);
+			g_object_unref (parent);
+		}
+
+		target_uri = NULL;
+		if (target) {
+			target_uri = g_file_get_uri (target);
+			g_object_unref (target);
+		}
+		return target_uri;
+	}
+}
+
+/**
+ * caja_file_is_caja_link
+ *
+ * Check if this file is a "caja link", meaning a historical
+ * caja xml link file or a desktop file.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: True if the file is a caja link.
+ *
+ **/
+gboolean
+caja_file_is_caja_link (CajaFile *file)
+{
+	/* NOTE: I removed the historical link here, because i don't think we
+	   even detect that mimetype anymore */
+	return caja_file_is_mime_type (file, "application/x-desktop");
+}
+
+/**
+ * caja_file_is_directory
+ *
+ * Check if this file is a directory.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: TRUE if @file is a directory.
+ *
+ **/
+gboolean
+caja_file_is_directory (CajaFile *file)
+{
+	return caja_file_get_file_type (file) == G_FILE_TYPE_DIRECTORY;
+}
+
+/**
+ * caja_file_is_user_special_directory
+ *
+ * Check if this file is a special platform directory.
+ * @file: CajaFile representing the file in question.
+ * @special_directory: GUserDirectory representing the type to test for
+ *
+ * Returns: TRUE if @file is a special directory of the given kind.
+ */
+gboolean
+caja_file_is_user_special_directory (CajaFile *file,
+					 GUserDirectory special_directory)
+{
+	gboolean is_special_dir;
+	const gchar *special_dir;
+
+	special_dir = g_get_user_special_dir (special_directory);
+	is_special_dir = FALSE;
+
+	if (special_dir) {
+		GFile *loc;
+		GFile *special_gfile;
+
+		loc = caja_file_get_location (file);
+		special_gfile = g_file_new_for_path (special_dir);
+		is_special_dir = g_file_equal (loc, special_gfile);
+		g_object_unref (special_gfile);
+		g_object_unref (loc);
+	}
+
+	return is_special_dir;
+}
+
+gboolean
+caja_file_is_archive (CajaFile *file)
+{
+	char *mime_type;
+	int i;
+	static const char * archive_mime_types[] = { "application/x-gtar",
+						     "application/x-zip",
+						     "application/x-zip-compressed",
+						     "application/zip",
+						     "application/x-zip",
+						     "application/x-tar",
+						     "application/x-7z-compressed",
+						     "application/x-rar",
+						     "application/x-rar-compressed",
+						     "application/x-jar",
+						     "application/x-java-archive",
+						     "application/x-war",
+						     "application/x-ear",
+						     "application/x-arj",
+						     "application/x-gzip",
+						     "application/x-bzip-compressed-tar",
+						     "application/x-compressed-tar" };
+
+	g_return_val_if_fail (file != NULL, FALSE);
+
+	mime_type = caja_file_get_mime_type (file);
+	for (i = 0; i < G_N_ELEMENTS (archive_mime_types); i++) {
+		if (!strcmp (mime_type, archive_mime_types[i])) {
+			g_free (mime_type);
+			return TRUE;
+		}
+	}
+	g_free (mime_type);
+
+	return FALSE;
+}
+
+
+/**
+ * caja_file_is_in_trash
+ *
+ * Check if this file is a file in trash.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: TRUE if @file is in a trash.
+ *
+ **/
+gboolean
+caja_file_is_in_trash (CajaFile *file)
+{
+	g_assert (CAJA_IS_FILE (file));
+
+	return caja_directory_is_in_trash (file->details->directory);
+}
+
+GError *
+caja_file_get_file_info_error (CajaFile *file)
+{
+	if (!file->details->get_info_failed) {
+		return NULL;
+	}
+
+	return file->details->get_info_error;
+}
+
+/**
+ * caja_file_contains_text
+ *
+ * Check if this file contains text.
+ * This is private and is used to decide whether or not to read the top left text.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: TRUE if @file has a text MIME type.
+ *
+ **/
+gboolean
+caja_file_contains_text (CajaFile *file)
+{
+	if (file == NULL) {
+		return FALSE;
+	}
+
+	/* All text files inherit from text/plain */
+	return caja_file_is_mime_type (file, "text/plain");
+}
+
+/**
+ * caja_file_is_executable
+ *
+ * Check if this file is executable at all.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: TRUE if any of the execute bits are set. FALSE if
+ * not, or if the permissions are unknown.
+ *
+ **/
+gboolean
+caja_file_is_executable (CajaFile *file)
+{
+	if (!file->details->has_permissions) {
+		/* File's permissions field is not valid.
+		 * Can't access specific permissions, so return FALSE.
+		 */
+		return FALSE;
+	}
+
+	return file->details->can_execute;
+}
+
+/**
+ * caja_file_peek_top_left_text
+ *
+ * Peek at the text from the top left of the file.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: NULL if there is no text readable, otherwise, the text.
+ *          This string is owned by the file object and should not
+ *          be kept around or freed.
+ *
+ **/
+char *
+caja_file_peek_top_left_text (CajaFile *file,
+				  gboolean  need_large_text,
+				  gboolean *needs_loading)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+	if (!caja_file_should_get_top_left_text (file)) {
+		if (needs_loading) {
+			*needs_loading = FALSE;
+		}
+		return NULL;
+	}
+
+	if (needs_loading) {
+		*needs_loading = !file->details->top_left_text_is_up_to_date;
+		if (need_large_text) {
+			*needs_loading |= file->details->got_top_left_text != file->details->got_large_top_left_text;
+		}
+	}
+
+	/* Show " ..." in the file until we read the contents in. */
+	if (!file->details->got_top_left_text) {
+
+		if (caja_file_contains_text (file)) {
+			return " ...";
+		}
+		return NULL;
+	}
+
+	/* Show what we read in. */
+	return file->details->top_left_text;
+}
+
+/**
+ * caja_file_get_top_left_text
+ *
+ * Get the text from the top left of the file.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: NULL if there is no text readable, otherwise, the text.
+ *
+ **/
+char *
+caja_file_get_top_left_text (CajaFile *file)
+{
+	return g_strdup (caja_file_peek_top_left_text (file, FALSE, NULL));
+}
+
+char *
+caja_file_get_filesystem_id (CajaFile *file)
+{
+	return g_strdup (eel_ref_str_peek (file->details->filesystem_id));
+}
+
+CajaFile *
+caja_file_get_trash_original_file (CajaFile *file)
+{
+	GFile *location;
+	CajaFile *original_file;
+	char *filename;
+
+	original_file = NULL;
+
+	if (file->details->trash_orig_path != NULL) {
+		/* file name is stored in URL encoding */
+		filename = g_uri_unescape_string (file->details->trash_orig_path, "");
+		location = g_file_new_for_path (filename);
+		original_file = caja_file_get (location);
+		g_object_unref (G_OBJECT (location));
+		g_free (filename);
+	}
+
+	return original_file;
+
+}
+
+void
+caja_file_mark_gone (CajaFile *file)
+{
+	CajaDirectory *directory;
+
+	if (file->details->is_gone)
+		return;
+
+	file->details->is_gone = TRUE;
+
+	update_links_if_target (file);
+
+	/* Drop it from the symlink hash ! */
+	remove_from_link_hash_table (file);
+
+	/* Let the directory know it's gone. */
+	directory = file->details->directory;
+	if (!caja_file_is_self_owned (file)) {
+		caja_directory_remove_file (directory, file);
+	}
+
+	caja_file_clear_info (file);
+
+	/* FIXME bugzilla.gnome.org 42429:
+	 * Maybe we can get rid of the name too eventually, but
+	 * for now that would probably require too many if statements
+	 * everywhere anyone deals with the name. Maybe we can give it
+	 * a hard-coded "<deleted>" name or something.
+	 */
+}
+
+/**
+ * caja_file_changed
+ *
+ * Notify the user that this file has changed.
+ * @file: CajaFile representing the file in question.
+ **/
+void
+caja_file_changed (CajaFile *file)
+{
+	GList fake_list;
+
+	g_return_if_fail (CAJA_IS_FILE (file));
+
+	if (caja_file_is_self_owned (file)) {
+		caja_file_emit_changed (file);
+	} else {
+		fake_list.data = file;
+		fake_list.next = NULL;
+		fake_list.prev = NULL;
+		caja_directory_emit_change_signals
+			(file->details->directory, &fake_list);
+	}
+}
+
+/**
+ * caja_file_updated_deep_count_in_progress
+ *
+ * Notify clients that a newer deep count is available for
+ * the directory in question.
+ */
+void
+caja_file_updated_deep_count_in_progress (CajaFile *file) {
+	GList *link_files, *node;
+
+	g_assert (CAJA_IS_FILE (file));
+	g_assert (caja_file_is_directory (file));
+
+	/* Send out a signal. */
+	g_signal_emit (file, signals[UPDATED_DEEP_COUNT_IN_PROGRESS], 0, file);
+
+	/* Tell link files pointing to this object about the change. */
+	link_files = get_link_files (file);
+	for (node = link_files; node != NULL; node = node->next) {
+		caja_file_updated_deep_count_in_progress (CAJA_FILE (node->data));
+	}
+	caja_file_list_free (link_files);
+}
+
+/**
+ * caja_file_emit_changed
+ *
+ * Emit a file changed signal.
+ * This can only be called by the directory, since the directory
+ * also has to emit a files_changed signal.
+ *
+ * @file: CajaFile representing the file in question.
+ **/
+void
+caja_file_emit_changed (CajaFile *file)
+{
+	GList *link_files, *p;
+
+	g_assert (CAJA_IS_FILE (file));
+
+
+	/* Invalidate the emblem compare cache. -- This is not the cleanest
+	 * place to do it but it is the one guaranteed bottleneck through
+	 * which all change notifications pass.
+	 */
+	g_free (file->details->compare_by_emblem_cache);
+	file->details->compare_by_emblem_cache = NULL;
+
+	/* Send out a signal. */
+	g_signal_emit (file, signals[CHANGED], 0, file);
+
+	/* Tell link files pointing to this object about the change. */
+	link_files = get_link_files (file);
+	for (p = link_files; p != NULL; p = p->next) {
+		if (p->data != file) {
+			caja_file_changed (CAJA_FILE (p->data));
+		}
+	}
+	caja_file_list_free (link_files);
+}
+
+/**
+ * caja_file_is_gone
+ *
+ * Check if a file has already been deleted.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: TRUE if the file is already gone.
+ **/
+gboolean
+caja_file_is_gone (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	return file->details->is_gone;
+}
+
+/**
+ * caja_file_is_not_yet_confirmed
+ *
+ * Check if we're in a state where we don't know if a file really
+ * exists or not, before the initial I/O is complete.
+ * @file: CajaFile representing the file in question.
+ *
+ * Returns: TRUE if the file is already gone.
+ **/
+gboolean
+caja_file_is_not_yet_confirmed (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	return !file->details->got_file_info;
+}
+
+/**
+ * caja_file_check_if_ready
+ *
+ * Check whether the values for a set of file attributes are
+ * currently available, without doing any additional work. This
+ * is useful for callers that want to reflect updated information
+ * when it is ready but don't want to force the work required to
+ * obtain the information, which might be slow network calls, e.g.
+ *
+ * @file: The file being queried.
+ * @file_attributes: A bit-mask with the desired information.
+ *
+ * Return value: TRUE if all of the specified attributes are currently readable.
+ */
+gboolean
+caja_file_check_if_ready (CajaFile *file,
+			      CajaFileAttributes file_attributes)
+{
+	/* To be parallel with call_when_ready, return
+	 * TRUE for NULL file.
+	 */
+	if (file == NULL) {
+		return TRUE;
+	}
+
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	return EEL_CALL_METHOD_WITH_RETURN_VALUE
+		(CAJA_FILE_CLASS, file,
+		 check_if_ready, (file, file_attributes));
+}
+
+void
+caja_file_call_when_ready (CajaFile *file,
+			       CajaFileAttributes file_attributes,
+			       CajaFileCallback callback,
+			       gpointer callback_data)
+
+{
+	if (file == NULL) {
+		(* callback) (file, callback_data);
+		return;
+	}
+
+	g_return_if_fail (CAJA_IS_FILE (file));
+
+	EEL_CALL_METHOD
+		(CAJA_FILE_CLASS, file,
+		 call_when_ready, (file, file_attributes,
+				   callback, callback_data));
+}
+
+void
+caja_file_cancel_call_when_ready (CajaFile *file,
+				      CajaFileCallback callback,
+				      gpointer callback_data)
+{
+	g_return_if_fail (callback != NULL);
+
+	if (file == NULL) {
+		return;
+	}
+
+	g_return_if_fail (CAJA_IS_FILE (file));
+
+	EEL_CALL_METHOD
+		(CAJA_FILE_CLASS, file,
+		 cancel_call_when_ready, (file, callback, callback_data));
+}
+
+static void
+invalidate_directory_count (CajaFile *file)
+{
+	file->details->directory_count_is_up_to_date = FALSE;
+}
+
+static void
+invalidate_deep_counts (CajaFile *file)
+{
+	file->details->deep_counts_status = CAJA_REQUEST_NOT_STARTED;
+}
+
+static void
+invalidate_mime_list (CajaFile *file)
+{
+	file->details->mime_list_is_up_to_date = FALSE;
+}
+
+static void
+invalidate_top_left_text (CajaFile *file)
+{
+	file->details->top_left_text_is_up_to_date = FALSE;
+}
+
+static void
+invalidate_file_info (CajaFile *file)
+{
+	file->details->file_info_is_up_to_date = FALSE;
+}
+
+static void
+invalidate_link_info (CajaFile *file)
+{
+	file->details->link_info_is_up_to_date = FALSE;
+}
+
+static void
+invalidate_thumbnail (CajaFile *file)
+{
+	file->details->thumbnail_is_up_to_date = FALSE;
+}
+
+static void
+invalidate_mount (CajaFile *file)
+{
+	file->details->mount_is_up_to_date = FALSE;
+}
+
+void
+caja_file_invalidate_extension_info_internal (CajaFile *file)
+{
+	if (file->details->pending_info_providers)
+		eel_g_object_list_free (file->details->pending_info_providers);
+
+	file->details->pending_info_providers =
+		caja_module_get_extensions_for_type (CAJA_TYPE_INFO_PROVIDER);
+}
+
+void
+caja_file_invalidate_attributes_internal (CajaFile *file,
+					      CajaFileAttributes file_attributes)
+{
+	Request request;
+
+	if (file == NULL) {
+		return;
+	}
+
+	if (CAJA_IS_DESKTOP_ICON_FILE (file)) {
+		/* Desktop icon files are always up to date.
+		 * If we invalidate their attributes they
+		 * will lose data, so we just ignore them.
+		 */
+		return;
+	}
+
+	request = caja_directory_set_up_request (file_attributes);
+
+	if (REQUEST_WANTS_TYPE (request, REQUEST_DIRECTORY_COUNT)) {
+		invalidate_directory_count (file);
+	}
+	if (REQUEST_WANTS_TYPE (request, REQUEST_DEEP_COUNT)) {
+		invalidate_deep_counts (file);
+	}
+	if (REQUEST_WANTS_TYPE (request, REQUEST_MIME_LIST)) {
+		invalidate_mime_list (file);
+	}
+	if (REQUEST_WANTS_TYPE (request, REQUEST_FILE_INFO)) {
+		invalidate_file_info (file);
+	}
+	if (REQUEST_WANTS_TYPE (request, REQUEST_TOP_LEFT_TEXT)) {
+		invalidate_top_left_text (file);
+	}
+	if (REQUEST_WANTS_TYPE (request, REQUEST_LINK_INFO)) {
+		invalidate_link_info (file);
+	}
+	if (REQUEST_WANTS_TYPE (request, REQUEST_EXTENSION_INFO)) {
+		caja_file_invalidate_extension_info_internal (file);
+	}
+	if (REQUEST_WANTS_TYPE (request, REQUEST_THUMBNAIL)) {
+		invalidate_thumbnail (file);
+	}
+	if (REQUEST_WANTS_TYPE (request, REQUEST_MOUNT)) {
+		invalidate_mount (file);
+	}
+
+	/* FIXME bugzilla.gnome.org 45075: implement invalidating metadata */
+}
+
+gboolean
+caja_file_has_open_window (CajaFile *file)
+{
+	return file->details->has_open_window;
+}
+
+void
+caja_file_set_has_open_window (CajaFile *file,
+				   gboolean has_open_window)
+{
+	has_open_window = (has_open_window != FALSE);
+
+	if (file->details->has_open_window != has_open_window) {
+		file->details->has_open_window = has_open_window;
+		caja_file_changed (file);
+	}
+}
+
+
+gboolean
+caja_file_is_thumbnailing (CajaFile *file)
+{
+	g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+	return file->details->is_thumbnailing;
+}
+
+void
+caja_file_set_is_thumbnailing (CajaFile *file,
+				   gboolean is_thumbnailing)
+{
+	g_return_if_fail (CAJA_IS_FILE (file));
+
+	file->details->is_thumbnailing = is_thumbnailing;
+}
+
+
+/**
+ * caja_file_invalidate_attributes
+ *
+ * Invalidate the specified attributes and force a reload.
+ * @file: CajaFile representing the file in question.
+ * @file_attributes: attributes to froget.
+ **/
+
+void
+caja_file_invalidate_attributes (CajaFile *file,
+				     CajaFileAttributes file_attributes)
+{
+	/* Cancel possible in-progress loads of any of these attributes */
+	caja_directory_cancel_loading_file_attributes (file->details->directory,
+							   file,
+							   file_attributes);
+
+	/* Actually invalidate the values */
+	caja_file_invalidate_attributes_internal (file, file_attributes);
+
+	caja_directory_add_file_to_work_queue (file->details->directory, file);
+
+	/* Kick off I/O if necessary */
+	caja_directory_async_state_changed (file->details->directory);
+}
+
+CajaFileAttributes
+caja_file_get_all_attributes (void)
+{
+	return  CAJA_FILE_ATTRIBUTE_INFO |
+		CAJA_FILE_ATTRIBUTE_LINK_INFO |
+		CAJA_FILE_ATTRIBUTE_DEEP_COUNTS |
+		CAJA_FILE_ATTRIBUTE_DIRECTORY_ITEM_COUNT |
+		CAJA_FILE_ATTRIBUTE_DIRECTORY_ITEM_MIME_TYPES |
+		CAJA_FILE_ATTRIBUTE_TOP_LEFT_TEXT |
+		CAJA_FILE_ATTRIBUTE_LARGE_TOP_LEFT_TEXT |
+		CAJA_FILE_ATTRIBUTE_EXTENSION_INFO |
+		CAJA_FILE_ATTRIBUTE_THUMBNAIL |
+		CAJA_FILE_ATTRIBUTE_MOUNT;
+}
+
+void
+caja_file_invalidate_all_attributes (CajaFile *file)
+{
+	CajaFileAttributes all_attributes;
+
+	all_attributes = caja_file_get_all_attributes ();
+	caja_file_invalidate_attributes (file, all_attributes);
+}
+
+
+/**
+ * caja_file_dump
+ *
+ * Debugging call, prints out the contents of the file
+ * fields.
+ *
+ * @file: file to dump.
+ **/
+void
+caja_file_dump (CajaFile *file)
+{
+	long size = file->details->deep_size;
+	char *uri;
+	const char *file_kind;
+
+	uri = caja_file_get_uri (file);
+	g_print ("uri: %s \n", uri);
+	if (!file->details->got_file_info) {
+		g_print ("no file info \n");
+	} else if (file->details->get_info_failed) {
+		g_print ("failed to get file info \n");
+	} else {
+		g_print ("size: %ld \n", size);
+		switch (file->details->type) {
+		case G_FILE_TYPE_REGULAR:
+			file_kind = "regular file";
+			break;
+		case G_FILE_TYPE_DIRECTORY:
+			file_kind = "folder";
+			break;
+		case G_FILE_TYPE_SPECIAL:
+			file_kind = "special";
+			break;
+		case G_FILE_TYPE_SYMBOLIC_LINK:
+			file_kind = "symbolic link";
+			break;
+		case G_FILE_TYPE_UNKNOWN:
+		default:
+			file_kind = "unknown";
+			break;
+		}
+		g_print ("kind: %s \n", file_kind);
+		if (file->details->type == G_FILE_TYPE_SYMBOLIC_LINK) {
+			g_print ("link to %s \n", file->details->symlink_name);
+			/* FIXME bugzilla.gnome.org 42430: add following of symlinks here */
+		}
+		/* FIXME bugzilla.gnome.org 42431: add permissions and other useful stuff here */
+	}
+	g_free (uri);
+}
+
+/**
+ * caja_file_list_ref
+ *
+ * Ref all the files in a list.
+ * @list: GList of files.
+ **/
+GList *
+caja_file_list_ref (GList *list)
+{
+	g_list_foreach (list, (GFunc) caja_file_ref, NULL);
+	return list;
+}
+
+/**
+ * caja_file_list_unref
+ *
+ * Unref all the files in a list.
+ * @list: GList of files.
+ **/
+void
+caja_file_list_unref (GList *list)
+{
+	g_list_foreach (list, (GFunc) caja_file_unref, NULL);
+}
+
+/**
+ * caja_file_list_free
+ *
+ * Free a list of files after unrefing them.
+ * @list: GList of files.
+ **/
+void
+caja_file_list_free (GList *list)
+{
+	caja_file_list_unref (list);
+	g_list_free (list);
+}
+
+/**
+ * caja_file_list_copy
+ *
+ * Copy the list of files, making a new ref of each,
+ * @list: GList of files.
+ **/
+GList *
+caja_file_list_copy (GList *list)
+{
+	return g_list_copy (caja_file_list_ref (list));
+}
+
+GList *
+caja_file_list_from_uris (GList *uri_list)
+{
+	GList *l, *file_list;
+	const char *uri;
+	GFile *file;
+
+	file_list = NULL;
+
+	for (l = uri_list; l != NULL; l = l->next) {
+		uri = l->data;
+		file = g_file_new_for_uri (uri);
+		file_list = g_list_prepend (file_list, file);
+	}
+	return g_list_reverse (file_list);
+}
+
+static gboolean
+get_attributes_for_default_sort_type (CajaFile *file,
+				      gboolean *is_download,
+				      gboolean *is_trash)
+{
+	gboolean is_download_dir, is_desktop_dir, is_trash_dir, retval;
+
+	*is_download = FALSE;
+	*is_trash = FALSE;
+	retval = FALSE;
+
+	/* special handling for certain directories */
+	if (file && caja_file_is_directory (file)) {
+		is_download_dir =
+			caja_file_is_user_special_directory (file, G_USER_DIRECTORY_DOWNLOAD);
+		is_desktop_dir =
+			caja_file_is_user_special_directory (file, G_USER_DIRECTORY_DESKTOP);
+		is_trash_dir =
+			caja_file_is_in_trash (file);
+
+		if (is_download_dir && !is_desktop_dir) {
+			*is_download = TRUE;
+			retval = TRUE;
+		} else if (is_trash_dir) {
+			*is_trash = TRUE;
+			retval = TRUE;
+		}
+	}
+
+	return retval;
+}
+
+CajaFileSortType
+caja_file_get_default_sort_type (CajaFile *file,
+				     gboolean *reversed)
+{
+	CajaFileSortType retval;
+	gboolean is_download, is_trash, res;
+
+	retval = CAJA_FILE_SORT_NONE;
+	is_download = is_trash = FALSE;
+	res = get_attributes_for_default_sort_type (file, &is_download, &is_trash);
+
+	if (res) {
+		if (is_download) {
+			retval = CAJA_FILE_SORT_BY_MTIME;
+		} else if (is_trash) {
+			retval = CAJA_FILE_SORT_BY_TRASHED_TIME;
+		}
+
+		if (reversed != NULL) {
+			*reversed = res;
+		}
+	}
+
+	return retval;
+}
+
+const gchar *
+caja_file_get_default_sort_attribute (CajaFile *file,
+					  gboolean *reversed)
+{
+	const gchar *retval;
+	gboolean is_download, is_trash, res;
+
+	retval = NULL;
+	is_download = is_trash = FALSE;
+	res = get_attributes_for_default_sort_type (file, &is_download, &is_trash);
+
+	if (res) {
+		if (is_download) {
+			retval = g_quark_to_string (attribute_date_modified_q);
+		} else if (is_trash) {
+			retval = g_quark_to_string (attribute_trashed_on_q);
+		}
+
+		if (reversed != NULL) {
+			*reversed = res;
+		}
+	}
+
+	return retval;
+}
+
+static int
+compare_by_display_name_cover (gconstpointer a, gconstpointer b)
+{
+	return compare_by_display_name (CAJA_FILE (a), CAJA_FILE (b));
+}
+
+/**
+ * caja_file_list_sort_by_display_name
+ *
+ * Sort the list of files by file name.
+ * @list: GList of files.
+ **/
+GList *
+caja_file_list_sort_by_display_name (GList *list)
+{
+	return g_list_sort (list, compare_by_display_name_cover);
+}
+
+static GList *ready_data_list = NULL;
+
+typedef struct
+{
+	GList *file_list;
+	GList *remaining_files;
+	CajaFileListCallback callback;
+	gpointer callback_data;
+} FileListReadyData;
+
+static void
+file_list_ready_data_free (FileListReadyData *data)
+{
+	GList *l;
+
+	l = g_list_find (ready_data_list, data);
+	if (l != NULL) {
+		ready_data_list = g_list_delete_link (ready_data_list, l);
+
+		caja_file_list_free (data->file_list);
+		g_list_free (data->remaining_files);
+		g_free (data);
+	}
+}
+
+static FileListReadyData *
+file_list_ready_data_new (GList *file_list,
+			  CajaFileListCallback callback,
+			  gpointer callback_data)
+{
+	FileListReadyData *data;
+
+	data = g_new0 (FileListReadyData, 1);
+	data->file_list = caja_file_list_copy (file_list);
+	data->remaining_files = g_list_copy (file_list);
+	data->callback = callback;
+	data->callback_data = callback_data;
+
+	ready_data_list = g_list_prepend (ready_data_list, data);
+
+	return data;
+}
+
+static void
+file_list_file_ready_callback (CajaFile *file,
+			       gpointer user_data)
+{
+	FileListReadyData *data;
+
+	data = user_data;
+	data->remaining_files = g_list_remove (data->remaining_files, file);
+
+	if (data->remaining_files == NULL) {
+		if (data->callback) {
+			(*data->callback) (data->file_list, data->callback_data);
+		}
+
+		file_list_ready_data_free (data);
+	}
+}
+
+void
+caja_file_list_call_when_ready (GList *file_list,
+				    CajaFileAttributes attributes,
+				    CajaFileListHandle **handle,
+				    CajaFileListCallback callback,
+				    gpointer callback_data)
+{
+	GList *l;
+	FileListReadyData *data;
+	CajaFile *file;
+
+	g_return_if_fail (file_list != NULL);
+
+	data = file_list_ready_data_new
+		(file_list, callback, callback_data);
+
+	if (handle) {
+		*handle = (CajaFileListHandle *) data;
+	}
+
+
+	l = file_list;
+	while (l != NULL) {
+		file = CAJA_FILE (l->data);
+		/* Need to do this here, as the list can be modified by this call */
+		l = l->next;
+		caja_file_call_when_ready (file,
+					       attributes,
+					       file_list_file_ready_callback,
+					       data);
+	}
+}
+
+void
+caja_file_list_cancel_call_when_ready (CajaFileListHandle *handle)
+{
+	GList *l;
+	CajaFile *file;
+	FileListReadyData *data;
+
+	g_return_if_fail (handle != NULL);
+
+	data = (FileListReadyData *) handle;
+
+	l = g_list_find (ready_data_list, data);
+	if (l != NULL) {
+		for (l = data->remaining_files; l != NULL; l = l->next) {
+			file = CAJA_FILE (l->data);
+
+			EEL_CALL_METHOD
+				(CAJA_FILE_CLASS, file,
+				 cancel_call_when_ready, (file, file_list_file_ready_callback, data));
+		}
+
+		file_list_ready_data_free (data);
+	}
+}
+
+static char *
+try_to_make_utf8 (const char *text, int *length)
+{
+	static const char *encodings_to_try[2];
+	static int n_encodings_to_try = 0;
+        gsize converted_length;
+        GError *conversion_error;
+	char *utf8_text;
+	int i;
+
+	if (n_encodings_to_try == 0) {
+		const char *charset;
+		gboolean charset_is_utf8;
+
+		charset_is_utf8 = g_get_charset (&charset);
+		if (!charset_is_utf8) {
+			encodings_to_try[n_encodings_to_try++] = charset;
+		}
+
+		if (g_ascii_strcasecmp (charset, "ISO-8859-1") != 0) {
+			encodings_to_try[n_encodings_to_try++] = "ISO-8859-1";
+		}
+	}
+
+        utf8_text = NULL;
+	for (i = 0; i < n_encodings_to_try; i++) {
+		conversion_error = NULL;
+		utf8_text = g_convert (text, *length,
+					   "UTF-8", encodings_to_try[i],
+					   NULL, &converted_length, &conversion_error);
+		if (utf8_text != NULL) {
+			*length = converted_length;
+			break;
+		}
+		g_error_free (conversion_error);
+	}
+
+	return utf8_text;
+}
+
+
+
+/* Extract the top left part of the read-in text. */
+char *
+caja_extract_top_left_text (const char *text,
+				gboolean large,
+				int length)
+{
+        GString* buffer;
+	const gchar *in;
+	const gchar *end;
+	int line, i;
+	gunichar c;
+	char *text_copy;
+	const char *utf8_end;
+	gboolean validated;
+	int max_bytes, max_lines, max_cols;
+
+	if (large) {
+		max_bytes = CAJA_FILE_LARGE_TOP_LEFT_TEXT_MAXIMUM_BYTES;
+		max_lines = CAJA_FILE_LARGE_TOP_LEFT_TEXT_MAXIMUM_LINES;
+		max_cols = CAJA_FILE_LARGE_TOP_LEFT_TEXT_MAXIMUM_CHARACTERS_PER_LINE;
+	} else {
+		max_bytes = CAJA_FILE_TOP_LEFT_TEXT_MAXIMUM_BYTES;
+		max_lines = CAJA_FILE_TOP_LEFT_TEXT_MAXIMUM_LINES;
+		max_cols = CAJA_FILE_TOP_LEFT_TEXT_MAXIMUM_CHARACTERS_PER_LINE;
+	}
+
+
+
+        text_copy = NULL;
+        if (text != NULL) {
+		/* Might be a partial utf8 character at the end if we didn't read whole file */
+		validated = g_utf8_validate (text, length, &utf8_end);
+		if (!validated &&
+		    !(length >= max_bytes &&
+		      text + length - utf8_end < 6)) {
+			text_copy = try_to_make_utf8 (text, &length);
+			text = text_copy;
+		} else if (!validated) {
+			length = utf8_end - text;
+		}
+        }
+
+	if (text == NULL || length == 0) {
+		return NULL;
+	}
+
+	buffer = g_string_new ("");
+	end = text + length; in = text;
+
+	for (line = 0; line < max_lines; line++) {
+		/* Extract one line. */
+		for (i = 0; i < max_cols; ) {
+			if (*in == '\n') {
+				break;
+			}
+
+			c = g_utf8_get_char (in);
+
+			if (g_unichar_isprint (c)) {
+				g_string_append_unichar (buffer, c);
+				i++;
+			}
+
+			in = g_utf8_next_char (in);
+			if (in == end) {
+				goto done;
+			}
+		}
+
+		/* Skip the rest of the line. */
+		while (*in != '\n') {
+			if (++in == end) {
+				goto done;
+			}
+		}
+		if (++in == end) {
+			goto done;
+		}
+
+		/* Put a new-line separator in. */
+		g_string_append_c(buffer, '\n');
+	}
+ done:
+	g_free (text_copy);
+
+	return g_string_free(buffer, FALSE);
+}
+
+static void
+thumbnail_limit_changed_callback (gpointer user_data)
+{
+	cached_thumbnail_limit = eel_preferences_get_uint (CAJA_PREFERENCES_IMAGE_FILE_THUMBNAIL_LIMIT);
+
+	/* Tell the world that icons might have changed. We could invent a narrower-scope
+	 * signal to mean only "thumbnails might have changed" if this ends up being slow
+	 * for some reason.
+	 */
+	emit_change_signals_for_all_files_in_all_directories ();
+}
+
+static void
+thumbnail_size_changed_callback (gpointer user_data)
+{
+	cached_thumbnail_size = eel_preferences_get_integer (CAJA_PREFERENCES_ICON_VIEW_THUMBNAIL_SIZE);
+
+	/* Tell the world that icons might have changed. We could invent a narrower-scope
+	 * signal to mean only "thumbnails might have changed" if this ends up being slow
+	 * for some reason.
+	 */
+	emit_change_signals_for_all_files_in_all_directories ();
+}
+
+static void
+show_thumbnails_changed_callback (gpointer user_data)
+{
+	show_image_thumbs = eel_preferences_get_enum (CAJA_PREFERENCES_SHOW_IMAGE_FILE_THUMBNAILS);
+
+	/* Tell the world that icons might have changed. We could invent a narrower-scope
+	 * signal to mean only "thumbnails might have changed" if this ends up being slow
+	 * for some reason.
+	 */
+	emit_change_signals_for_all_files_in_all_directories ();
+}
+
+static void
+mime_type_data_changed_callback (GObject *signaller, gpointer user_data)
+{
+	/* Tell the world that icons might have changed. We could invent a narrower-scope
+	 * signal to mean only "thumbnails might have changed" if this ends up being slow
+	 * for some reason.
+	 */
+	emit_change_signals_for_all_files_in_all_directories ();
+}
+
+static void
+icon_theme_changed_callback (GtkIconTheme *icon_theme,
+			     gpointer user_data)
+{
+	/* Clear all pixmap caches as the icon => pixmap lookup changed */
+	caja_icon_info_clear_caches ();
+
+	/* Tell the world that icons might have changed. We could invent a narrower-scope
+	 * signal to mean only "thumbnails might have changed" if this ends up being slow
+	 * for some reason.
+	 */
+	emit_change_signals_for_all_files_in_all_directories ();
+}
+
+static void
+caja_file_class_init (CajaFileClass *class)
+{
+	GtkIconTheme *icon_theme;
+
+	caja_file_info_getter = caja_file_get_internal;
+
+	attribute_name_q = g_quark_from_static_string ("name");
+	attribute_size_q = g_quark_from_static_string ("size");
+	attribute_type_q = g_quark_from_static_string ("type");
+	attribute_modification_date_q = g_quark_from_static_string ("modification_date");
+	attribute_date_modified_q = g_quark_from_static_string ("date_modified");
+	attribute_accessed_date_q = g_quark_from_static_string ("accessed_date");
+	attribute_date_accessed_q = g_quark_from_static_string ("date_accessed");
+	attribute_emblems_q = g_quark_from_static_string ("emblems");
+	attribute_mime_type_q = g_quark_from_static_string ("mime_type");
+	attribute_size_detail_q = g_quark_from_static_string ("size_detail");
+	attribute_deep_size_q = g_quark_from_static_string ("deep_size");
+	attribute_deep_file_count_q = g_quark_from_static_string ("deep_file_count");
+	attribute_deep_directory_count_q = g_quark_from_static_string ("deep_directory_count");
+	attribute_deep_total_count_q = g_quark_from_static_string ("deep_total_count");
+	attribute_date_changed_q = g_quark_from_static_string ("date_changed");
+	attribute_trashed_on_q = g_quark_from_static_string ("trashed_on");
+	attribute_trash_orig_path_q = g_quark_from_static_string ("trash_orig_path");
+	attribute_date_permissions_q = g_quark_from_static_string ("date_permissions");
+	attribute_permissions_q = g_quark_from_static_string ("permissions");
+	attribute_selinux_context_q = g_quark_from_static_string ("selinux_context");
+	attribute_octal_permissions_q = g_quark_from_static_string ("octal_permissions");
+	attribute_owner_q = g_quark_from_static_string ("owner");
+	attribute_group_q = g_quark_from_static_string ("group");
+	attribute_uri_q = g_quark_from_static_string ("uri");
+	attribute_where_q = g_quark_from_static_string ("where");
+	attribute_link_target_q = g_quark_from_static_string ("link_target");
+	attribute_volume_q = g_quark_from_static_string ("volume");
+	attribute_free_space_q = g_quark_from_static_string ("free_space");
+
+	G_OBJECT_CLASS (class)->finalize = finalize;
+	G_OBJECT_CLASS (class)->constructor = caja_file_constructor;
+
+	signals[CHANGED] =
+		g_signal_new ("changed",
+		              G_TYPE_FROM_CLASS (class),
+		              G_SIGNAL_RUN_LAST,
+		              G_STRUCT_OFFSET (CajaFileClass, changed),
+		              NULL, NULL,
+		              g_cclosure_marshal_VOID__VOID,
+		              G_TYPE_NONE, 0);
+
+	signals[UPDATED_DEEP_COUNT_IN_PROGRESS] =
+		g_signal_new ("updated_deep_count_in_progress",
+		              G_TYPE_FROM_CLASS (class),
+		              G_SIGNAL_RUN_LAST,
+		              G_STRUCT_OFFSET (CajaFileClass, updated_deep_count_in_progress),
+		              NULL, NULL,
+			      g_cclosure_marshal_VOID__VOID,
+		              G_TYPE_NONE, 0);
+
+	g_type_class_add_private (class, sizeof (CajaFileDetails));
+
+
+	eel_preferences_add_auto_enum (CAJA_PREFERENCES_DATE_FORMAT,
+				       &date_format_pref);
+
+	thumbnail_limit_changed_callback (NULL);
+	eel_preferences_add_callback (CAJA_PREFERENCES_IMAGE_FILE_THUMBNAIL_LIMIT,
+				      thumbnail_limit_changed_callback,
+				      NULL);
+	thumbnail_size_changed_callback (NULL);
+	eel_preferences_add_callback (CAJA_PREFERENCES_ICON_VIEW_THUMBNAIL_SIZE,
+				      thumbnail_size_changed_callback,
+				      NULL);
+	show_thumbnails_changed_callback (NULL);
+	eel_preferences_add_callback (CAJA_PREFERENCES_SHOW_IMAGE_FILE_THUMBNAILS,
+				      show_thumbnails_changed_callback,
+				      NULL);
+
+	icon_theme = gtk_icon_theme_get_default ();
+	g_signal_connect_object (icon_theme,
+				 "changed",
+				 G_CALLBACK (icon_theme_changed_callback),
+				 NULL, 0);
+
+	g_signal_connect (caja_signaller_get_current (),
+			  "mime_data_changed",
+			  G_CALLBACK (mime_type_data_changed_callback),
+			  NULL);
+}
+
+static void
+caja_file_add_emblem (CajaFile *file,
+			  const char *emblem_name)
+{
+	if (file->details->pending_info_providers) {
+		file->details->pending_extension_emblems = g_list_prepend (file->details->pending_extension_emblems,
+									   g_strdup (emblem_name));
+	} else {
+		file->details->extension_emblems = g_list_prepend (file->details->extension_emblems,
+								   g_strdup (emblem_name));
+	}
+
+	caja_file_changed (file);
+}
+
+static void
+caja_file_add_string_attribute (CajaFile *file,
+				    const char *attribute_name,
+				    const char *value)
+{
+	if (file->details->pending_info_providers) {
+		/* Lazily create hashtable */
+		if (!file->details->pending_extension_attributes) {
+			file->details->pending_extension_attributes =
+				g_hash_table_new_full (g_direct_hash, g_direct_equal,
+						       NULL,
+						       (GDestroyNotify)g_free);
+		}
+		g_hash_table_insert (file->details->pending_extension_attributes,
+				     GINT_TO_POINTER (g_quark_from_string (attribute_name)),
+				     g_strdup (value));
+	} else {
+		if (!file->details->extension_attributes) {
+			file->details->extension_attributes =
+				g_hash_table_new_full (g_direct_hash, g_direct_equal,
+						       NULL,
+						       (GDestroyNotify)g_free);
+		}
+		g_hash_table_insert (file->details->extension_attributes,
+				     GINT_TO_POINTER (g_quark_from_string (attribute_name)),
+				     g_strdup (value));
+	}
+
+	caja_file_changed (file);
+}
+
+static void
+caja_file_invalidate_extension_info (CajaFile *file)
+{
+	caja_file_invalidate_attributes (file, CAJA_FILE_ATTRIBUTE_EXTENSION_INFO);
+}
+
+void
+caja_file_info_providers_done (CajaFile *file)
+{
+	eel_g_list_free_deep (file->details->extension_emblems);
+	file->details->extension_emblems = file->details->pending_extension_emblems;
+	file->details->pending_extension_emblems = NULL;
+
+	if (file->details->extension_attributes) {
+		g_hash_table_destroy (file->details->extension_attributes);
+	}
+
+	file->details->extension_attributes = file->details->pending_extension_attributes;
+	file->details->pending_extension_attributes = NULL;
+
+	caja_file_changed (file);
+}
+
+static void
+caja_file_info_iface_init (CajaFileInfoIface *iface)
+{
+	iface->is_gone = caja_file_is_gone;
+	iface->get_name = caja_file_get_name;
+	iface->get_file_type = caja_file_get_file_type;
+	iface->get_location = caja_file_get_location;
+	iface->get_uri = caja_file_get_uri;
+	iface->get_parent_location = caja_file_get_parent_location;
+	iface->get_parent_uri = caja_file_get_parent_uri;
+	iface->get_parent_info = caja_file_get_parent;
+	iface->get_mount = caja_file_get_mount;
+	iface->get_uri_scheme = caja_file_get_uri_scheme;
+	iface->get_activation_uri = caja_file_get_activation_uri;
+	iface->get_mime_type = caja_file_get_mime_type;
+	iface->is_mime_type = caja_file_is_mime_type;
+	iface->is_directory = caja_file_is_directory;
+	iface->can_write = caja_file_can_write;
+	iface->add_emblem = caja_file_add_emblem;
+	iface->get_string_attribute = caja_file_get_string_attribute;
+	iface->add_string_attribute = caja_file_add_string_attribute;
+	iface->invalidate_extension_info = caja_file_invalidate_extension_info;
+}
+
+#if !defined (CAJA_OMIT_SELF_CHECK)
+
+void
+caja_self_check_file (void)
+{
+	CajaFile *file_1;
+	CajaFile *file_2;
+	GList *list;
+
+        /* refcount checks */
+
+        EEL_CHECK_INTEGER_RESULT (caja_directory_number_outstanding (), 0);
+
+	file_1 = caja_file_get_by_uri ("file:///home/");
+
+	EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1)->ref_count, 1);
+	EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1->details->directory)->ref_count, 1);
+        EEL_CHECK_INTEGER_RESULT (caja_directory_number_outstanding (), 1);
+
+	caja_file_unref (file_1);
+
+        EEL_CHECK_INTEGER_RESULT (caja_directory_number_outstanding (), 0);
+
+	file_1 = caja_file_get_by_uri ("file:///etc");
+	file_2 = caja_file_get_by_uri ("file:///usr");
+
+        list = NULL;
+        list = g_list_prepend (list, file_1);
+        list = g_list_prepend (list, file_2);
+
+        caja_file_list_ref (list);
+
+	EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1)->ref_count, 2);
+	EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_2)->ref_count, 2);
+
+	caja_file_list_unref (list);
+
+	EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1)->ref_count, 1);
+	EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_2)->ref_count, 1);
+
+	caja_file_list_free (list);
+
+        EEL_CHECK_INTEGER_RESULT (caja_directory_number_outstanding (), 0);
+
+
+        /* name checks */
+	file_1 = caja_file_get_by_uri ("file:///home/");
+
+	EEL_CHECK_STRING_RESULT (caja_file_get_name (file_1), "home");
+
+	EEL_CHECK_BOOLEAN_RESULT (caja_file_get_by_uri ("file:///home/") == file_1, TRUE);
+	caja_file_unref (file_1);
+
+	EEL_CHECK_BOOLEAN_RESULT (caja_file_get_by_uri ("file:///home") == file_1, TRUE);
+	caja_file_unref (file_1);
+
+	caja_file_unref (file_1);
+
+	file_1 = caja_file_get_by_uri ("file:///home");
+	EEL_CHECK_STRING_RESULT (caja_file_get_name (file_1), "home");
+	caja_file_unref (file_1);
+
+#if 0
+	/* ALEX: I removed this, because it was breaking distchecks.
+	 * It used to work, but when canonical uris changed from
+	 * foo: to foo:/// it broke. I don't expect it to matter
+	 * in real life */
+	file_1 = caja_file_get_by_uri (":");
+	EEL_CHECK_STRING_RESULT (caja_file_get_name (file_1), ":");
+	caja_file_unref (file_1);
+#endif
+
+	file_1 = caja_file_get_by_uri ("eazel:");
+	EEL_CHECK_STRING_RESULT (caja_file_get_name (file_1), "eazel");
+	caja_file_unref (file_1);
+
+	/* sorting */
+	file_1 = caja_file_get_by_uri ("file:///etc");
+	file_2 = caja_file_get_by_uri ("file:///usr");
+
+	EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_1)->ref_count, 1);
+	EEL_CHECK_INTEGER_RESULT (G_OBJECT (file_2)->ref_count, 1);
+
+	EEL_CHECK_BOOLEAN_RESULT (caja_file_compare_for_sort (file_1, file_2, CAJA_FILE_SORT_BY_DISPLAY_NAME, FALSE, FALSE) < 0, TRUE);
+	EEL_CHECK_BOOLEAN_RESULT (caja_file_compare_for_sort (file_1, file_2, CAJA_FILE_SORT_BY_DISPLAY_NAME, FALSE, TRUE) > 0, TRUE);
+	EEL_CHECK_BOOLEAN_RESULT (caja_file_compare_for_sort (file_1, file_1, CAJA_FILE_SORT_BY_DISPLAY_NAME, FALSE, FALSE) == 0, TRUE);
+	EEL_CHECK_BOOLEAN_RESULT (caja_file_compare_for_sort (file_1, file_1, CAJA_FILE_SORT_BY_DISPLAY_NAME, TRUE, FALSE) == 0, TRUE);
+	EEL_CHECK_BOOLEAN_RESULT (caja_file_compare_for_sort (file_1, file_1, CAJA_FILE_SORT_BY_DISPLAY_NAME, FALSE, TRUE) == 0, TRUE);
+	EEL_CHECK_BOOLEAN_RESULT (caja_file_compare_for_sort (file_1, file_1, CAJA_FILE_SORT_BY_DISPLAY_NAME, TRUE, TRUE) == 0, TRUE);
+
+	caja_file_unref (file_1);
+	caja_file_unref (file_2);
+}
+
+#endif /* !CAJA_OMIT_SELF_CHECK */