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

author: Perberos <[email protected]> 2011-12-01 22:24:23 -0300
committer: Perberos <[email protected]> 2011-12-01 22:24:23 -0300
commit: 0e004c696b0e68b2cff37a4c3315b022a35eaf43 (patch)
tree: 43261e815529cb9518ed7be37af13b846af8b26b /libcaja-private/caja-directory.c
download: caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.bz2
caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.xz
1 files changed, 2004 insertions, 0 deletions
diff --git a/libcaja-private/caja-directory.c b/libcaja-private/caja-directory.c
new file mode 100644
index 00000000..5c1aa80d
--- /dev/null
+++ b/libcaja-private/caja-directory.c
@@ -0,0 +1,2004 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*-
+
+ caja-directory.c: Caja directory 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-directory-private.h"
+
+#include "caja-directory-notify.h"
+#include "caja-file-attributes.h"
+#include "caja-file-private.h"
+#include "caja-file-utilities.h"
+#include "caja-search-directory.h"
+#include "caja-global-preferences.h"
+#include "caja-lib-self-check-functions.h"
+#include "caja-marshal.h"
+#include "caja-metadata.h"
+#include "caja-desktop-directory.h"
+#include "caja-vfs-directory.h"
+#include <eel/eel-glib-extensions.h>
+#include <eel/eel-gtk-macros.h>
+#include <eel/eel-string.h>
+#include <gtk/gtk.h>
+
+enum
+{
+ FILES_ADDED,
+ FILES_CHANGED,
+ DONE_LOADING,
+ LOAD_ERROR,
+ LAST_SIGNAL
+};
+
+static guint signals[LAST_SIGNAL];
+
+static GHashTable *directories;
+
+static void caja_directory_finalize (GObject *object);
+static void caja_directory_init (gpointer object,
+ gpointer klass);
+static void caja_directory_class_init (CajaDirectoryClass *klass);
+static CajaDirectory *caja_directory_new (GFile *location);
+static char * real_get_name_for_self_as_new_file (CajaDirectory *directory);
+static GList * real_get_file_list (CajaDirectory *directory);
+static gboolean real_is_editable (CajaDirectory *directory);
+static void set_directory_location (CajaDirectory *directory,
+ GFile *location);
+
+EEL_CLASS_BOILERPLATE (CajaDirectory,
+ caja_directory,
+ G_TYPE_OBJECT)
+
+static void
+caja_directory_class_init (CajaDirectoryClass *klass)
+{
+ GObjectClass *object_class;
+
+ object_class = G_OBJECT_CLASS (klass);
+
+ object_class->finalize = caja_directory_finalize;
+
+ signals[FILES_ADDED] =
+ g_signal_new ("files_added",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaDirectoryClass, files_added),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1, G_TYPE_POINTER);
+ signals[FILES_CHANGED] =
+ g_signal_new ("files_changed",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaDirectoryClass, files_changed),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1, G_TYPE_POINTER);
+ signals[DONE_LOADING] =
+ g_signal_new ("done_loading",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaDirectoryClass, done_loading),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__VOID,
+ G_TYPE_NONE, 0);
+ signals[LOAD_ERROR] =
+ g_signal_new ("load_error",
+ G_TYPE_FROM_CLASS (object_class),
+ G_SIGNAL_RUN_LAST,
+ G_STRUCT_OFFSET (CajaDirectoryClass, load_error),
+ NULL, NULL,
+ g_cclosure_marshal_VOID__POINTER,
+ G_TYPE_NONE, 1, G_TYPE_POINTER);
+
+ klass->get_name_for_self_as_new_file = real_get_name_for_self_as_new_file;
+ klass->get_file_list = real_get_file_list;
+ klass->is_editable = real_is_editable;
+
+ g_type_class_add_private (klass, sizeof (CajaDirectoryDetails));
+}
+
+static void
+caja_directory_init (gpointer object, gpointer klass)
+{
+ CajaDirectory *directory;
+
+ directory = CAJA_DIRECTORY(object);
+
+ directory->details = G_TYPE_INSTANCE_GET_PRIVATE ((directory), CAJA_TYPE_DIRECTORY, CajaDirectoryDetails);
+ directory->details->file_hash = g_hash_table_new (g_str_hash, g_str_equal);
+ directory->details->high_priority_queue = caja_file_queue_new ();
+ directory->details->low_priority_queue = caja_file_queue_new ();
+ directory->details->extension_queue = caja_file_queue_new ();
+ directory->details->free_space = (guint64)-1;
+}
+
+CajaDirectory *
+caja_directory_ref (CajaDirectory *directory)
+{
+ if (directory == NULL)
+ {
+ return directory;
+ }
+
+ g_return_val_if_fail (CAJA_IS_DIRECTORY (directory), NULL);
+
+ g_object_ref (directory);
+ return directory;
+}
+
+void
+caja_directory_unref (CajaDirectory *directory)
+{
+ if (directory == NULL)
+ {
+ return;
+ }
+
+ g_return_if_fail (CAJA_IS_DIRECTORY (directory));
+
+ g_object_unref (directory);
+}
+
+static void
+caja_directory_finalize (GObject *object)
+{
+ CajaDirectory *directory;
+
+ directory = CAJA_DIRECTORY (object);
+
+ g_hash_table_remove (directories, directory->details->location);
+
+ caja_directory_cancel (directory);
+ g_assert (directory->details->count_in_progress == NULL);
+ g_assert (directory->details->top_left_read_state == NULL);
+
+ if (directory->details->monitor_list != NULL)
+ {
+ g_warning ("destroying a CajaDirectory while it's being monitored");
+ eel_g_list_free_deep (directory->details->monitor_list);
+ }
+
+ if (directory->details->monitor != NULL)
+ {
+ caja_monitor_cancel (directory->details->monitor);
+ }
+
+ if (directory->details->dequeue_pending_idle_id != 0)
+ {
+ g_source_remove (directory->details->dequeue_pending_idle_id);
+ }
+
+ if (directory->details->call_ready_idle_id != 0)
+ {
+ g_source_remove (directory->details->call_ready_idle_id);
+ }
+
+ if (directory->details->location)
+ {
+ g_object_unref (directory->details->location);
+ }
+
+ g_assert (directory->details->file_list == NULL);
+ g_hash_table_destroy (directory->details->file_hash);
+
+ if (directory->details->hidden_file_hash)
+ {
+ g_hash_table_destroy (directory->details->hidden_file_hash);
+ }
+
+ caja_file_queue_destroy (directory->details->high_priority_queue);
+ caja_file_queue_destroy (directory->details->low_priority_queue);
+ caja_file_queue_destroy (directory->details->extension_queue);
+ g_assert (directory->details->directory_load_in_progress == NULL);
+ g_assert (directory->details->count_in_progress == NULL);
+ g_assert (directory->details->dequeue_pending_idle_id == 0);
+ eel_g_object_list_free (directory->details->pending_file_info);
+
+ EEL_CALL_PARENT (G_OBJECT_CLASS, finalize, (object));
+}
+
+static void
+invalidate_one_count (gpointer key, gpointer value, gpointer user_data)
+{
+ CajaDirectory *directory;
+
+ g_assert (key != NULL);
+ g_assert (CAJA_IS_DIRECTORY (value));
+ g_assert (user_data == NULL);
+
+ directory = CAJA_DIRECTORY (value);
+
+ caja_directory_invalidate_count_and_mime_list (directory);
+}
+
+static void
+filtering_changed_callback (gpointer callback_data)
+{
+ g_assert (callback_data == NULL);
+
+ /* Preference about which items to show has changed, so we
+ * can't trust any of our precomputed directory counts.
+ */
+ g_hash_table_foreach (directories, invalidate_one_count, NULL);
+}
+
+void
+emit_change_signals_for_all_files (CajaDirectory *directory)
+{
+ GList *files;
+
+ files = g_list_copy (directory->details->file_list);
+ if (directory->details->as_file != NULL)
+ {
+ files = g_list_prepend (files, directory->details->as_file);
+ }
+
+ caja_file_list_ref (files);
+ caja_directory_emit_change_signals (directory, files);
+
+ caja_file_list_free (files);
+}
+
+static void
+collect_all_directories (gpointer key, gpointer value, gpointer callback_data)
+{
+ CajaDirectory *directory;
+ GList **dirs;
+ GFile *location;
+
+ location = (GFile *) key;
+ directory = CAJA_DIRECTORY (value);
+ dirs = callback_data;
+
+ *dirs = g_list_prepend (*dirs, caja_directory_ref (directory));
+}
+
+void
+emit_change_signals_for_all_files_in_all_directories (void)
+{
+ GList *dirs, *l;
+ CajaDirectory *directory;
+
+ dirs = NULL;
+ g_hash_table_foreach (directories,
+ collect_all_directories,
+ &dirs);
+
+ for (l = dirs; l != NULL; l = l->next)
+ {
+ directory = CAJA_DIRECTORY (l->data);
+ emit_change_signals_for_all_files (directory);
+ caja_directory_unref (directory);
+ }
+
+ g_list_free (dirs);
+}
+
+static void
+async_state_changed_one (gpointer key, gpointer value, gpointer user_data)
+{
+ CajaDirectory *directory;
+
+ g_assert (key != NULL);
+ g_assert (CAJA_IS_DIRECTORY (value));
+ g_assert (user_data == NULL);
+
+ directory = CAJA_DIRECTORY (value);
+
+ caja_directory_async_state_changed (directory);
+ emit_change_signals_for_all_files (directory);
+}
+
+static void
+async_data_preference_changed_callback (gpointer callback_data)
+{
+ g_assert (callback_data == NULL);
+
+ /* Preference involving fetched async data has changed, so
+ * we have to kick off refetching all async data, and tell
+ * each file that it (might have) changed.
+ */
+ g_hash_table_foreach (directories, async_state_changed_one, NULL);
+}
+
+static void
+add_preferences_callbacks (void)
+{
+ caja_global_preferences_init ();
+
+ eel_preferences_add_callback (CAJA_PREFERENCES_SHOW_HIDDEN_FILES,
+ filtering_changed_callback,
+ NULL);
+ eel_preferences_add_callback (CAJA_PREFERENCES_SHOW_BACKUP_FILES,
+ filtering_changed_callback,
+ NULL);
+ eel_preferences_add_callback (CAJA_PREFERENCES_SHOW_TEXT_IN_ICONS,
+ async_data_preference_changed_callback,
+ NULL);
+ eel_preferences_add_callback (CAJA_PREFERENCES_SHOW_DIRECTORY_ITEM_COUNTS,
+ async_data_preference_changed_callback,
+ NULL);
+ eel_preferences_add_callback (CAJA_PREFERENCES_DATE_FORMAT,
+ async_data_preference_changed_callback,
+ NULL);
+}
+
+/**
+ * caja_directory_get_by_uri:
+ * @uri: URI of directory to get.
+ *
+ * Get a directory given a uri.
+ * Creates the appropriate subclass given the uri mappings.
+ * Returns a referenced object, not a floating one. Unref when finished.
+ * If two windows are viewing the same uri, the directory object is shared.
+ */
+CajaDirectory *
+caja_directory_get_internal (GFile *location, gboolean create)
+{
+ CajaDirectory *directory;
+
+ /* Create the hash table first time through. */
+ if (directories == NULL)
+ {
+ directories = eel_g_hash_table_new_free_at_exit
+ (g_file_hash, (GCompareFunc)g_file_equal, "caja-directory.c: directories");
+
+ add_preferences_callbacks ();
+ }
+
+ /* If the object is already in the hash table, look it up. */
+
+ directory = g_hash_table_lookup (directories,
+ location);
+ if (directory != NULL)
+ {
+ caja_directory_ref (directory);
+ }
+ else if (create)
+ {
+ /* Create a new directory object instead. */
+ directory = caja_directory_new (location);
+ if (directory == NULL)
+ {
+ return NULL;
+ }
+
+ /* Put it in the hash table. */
+ g_hash_table_insert (directories,
+ directory->details->location,
+ directory);
+ }
+
+ return directory;
+}
+
+CajaDirectory *
+caja_directory_get (GFile *location)
+{
+ if (location == NULL)
+ {
+ return NULL;
+ }
+
+ return caja_directory_get_internal (location, TRUE);
+}
+
+CajaDirectory *
+caja_directory_get_existing (GFile *location)
+{
+ if (location == NULL)
+ {
+ return NULL;
+ }
+
+ return caja_directory_get_internal (location, FALSE);
+}
+
+
+CajaDirectory *
+caja_directory_get_by_uri (const char *uri)
+{
+ CajaDirectory *directory;
+ GFile *location;
+
+ if (uri == NULL)
+ {
+ return NULL;
+ }
+
+ location = g_file_new_for_uri (uri);
+
+ directory = caja_directory_get_internal (location, TRUE);
+ g_object_unref (location);
+ return directory;
+}
+
+CajaDirectory *
+caja_directory_get_for_file (CajaFile *file)
+{
+ char *uri;
+ CajaDirectory *directory;
+
+ g_return_val_if_fail (CAJA_IS_FILE (file), NULL);
+
+ uri = caja_file_get_uri (file);
+ directory = caja_directory_get_by_uri (uri);
+ g_free (uri);
+ return directory;
+}
+
+/* Returns a reffed CajaFile object for this directory.
+ */
+CajaFile *
+caja_directory_get_corresponding_file (CajaDirectory *directory)
+{
+ CajaFile *file;
+ char *uri;
+
+ file = caja_directory_get_existing_corresponding_file (directory);
+ if (file == NULL)
+ {
+ uri = caja_directory_get_uri (directory);
+ file = caja_file_get_by_uri (uri);
+ g_free (uri);
+ }
+
+ return file;
+}
+
+/* Returns a reffed CajaFile object for this directory, but only if the
+ * CajaFile object has already been created.
+ */
+CajaFile *
+caja_directory_get_existing_corresponding_file (CajaDirectory *directory)
+{
+ CajaFile *file;
+ char *uri;
+
+ file = directory->details->as_file;
+ if (file != NULL)
+ {
+ caja_file_ref (file);
+ return file;
+ }
+
+ uri = caja_directory_get_uri (directory);
+ file = caja_file_get_existing_by_uri (uri);
+ g_free (uri);
+ return file;
+}
+
+/* caja_directory_get_name_for_self_as_new_file:
+ *
+ * Get a name to display for the file representing this
+ * directory. This is called only when there's no VFS
+ * directory for this CajaDirectory.
+ */
+char *
+caja_directory_get_name_for_self_as_new_file (CajaDirectory *directory)
+{
+ g_return_val_if_fail (CAJA_IS_DIRECTORY (directory), NULL);
+
+ return EEL_CALL_METHOD_WITH_RETURN_VALUE
+ (CAJA_DIRECTORY_CLASS, directory,
+ get_name_for_self_as_new_file, (directory));
+}
+
+static char *
+real_get_name_for_self_as_new_file (CajaDirectory *directory)
+{
+ char *directory_uri;
+ char *name, *colon;
+
+ directory_uri = caja_directory_get_uri (directory);
+
+ colon = strchr (directory_uri, ':');
+ if (colon == NULL || colon == directory_uri)
+ {
+ name = g_strdup (directory_uri);
+ }
+ else
+ {
+ name = g_strndup (directory_uri, colon - directory_uri);
+ }
+ g_free (directory_uri);
+
+ return name;
+}
+
+char *
+caja_directory_get_uri (CajaDirectory *directory)
+{
+ g_return_val_if_fail (CAJA_IS_DIRECTORY (directory), NULL);
+
+ return g_file_get_uri (directory->details->location);
+}
+
+GFile *
+caja_directory_get_location (CajaDirectory *directory)
+{
+ g_return_val_if_fail (CAJA_IS_DIRECTORY (directory), NULL);
+
+ return g_object_ref (directory->details->location);
+}
+
+static CajaDirectory *
+caja_directory_new (GFile *location)
+{
+ CajaDirectory *directory;
+ char *uri;
+
+ uri = g_file_get_uri (location);
+
+ if (eel_uri_is_desktop (uri))
+ {
+ directory = CAJA_DIRECTORY (g_object_new (CAJA_TYPE_DESKTOP_DIRECTORY, NULL));
+ }
+ else if (eel_uri_is_search (uri))
+ {
+ directory = CAJA_DIRECTORY (g_object_new (CAJA_TYPE_SEARCH_DIRECTORY, NULL));
+ }
+ else if (g_str_has_suffix (uri, CAJA_SAVED_SEARCH_EXTENSION))
+ {
+ directory = CAJA_DIRECTORY (caja_search_directory_new_from_saved_search (uri));
+ }
+ else
+ {
+ directory = CAJA_DIRECTORY (g_object_new (CAJA_TYPE_VFS_DIRECTORY, NULL));
+ }
+
+ set_directory_location (directory, location);
+
+ g_free (uri);
+
+ return directory;
+}
+
+gboolean
+caja_directory_is_local (CajaDirectory *directory)
+{
+ g_return_val_if_fail (CAJA_IS_DIRECTORY (directory), FALSE);
+
+ if (directory->details->location == NULL)
+ {
+ return TRUE;
+ }
+
+ return caja_directory_is_in_trash (directory) ||
+ g_file_is_native (directory->details->location);
+}
+
+gboolean
+caja_directory_is_in_trash (CajaDirectory *directory)
+{
+ g_assert (CAJA_IS_DIRECTORY (directory));
+
+ if (directory->details->location == NULL)
+ {
+ return FALSE;
+ }
+
+ return g_file_has_uri_scheme (directory->details->location, "trash");
+}
+
+gboolean
+caja_directory_are_all_files_seen (CajaDirectory *directory)
+{
+ g_return_val_if_fail (CAJA_IS_DIRECTORY (directory), FALSE);
+
+ return EEL_CALL_METHOD_WITH_RETURN_VALUE
+ (CAJA_DIRECTORY_CLASS, directory,
+ are_all_files_seen, (directory));
+}
+
+static void
+add_to_hash_table (CajaDirectory *directory, CajaFile *file, GList *node)
+{
+ const char *name;
+
+ name = eel_ref_str_peek (file->details->name);
+
+ g_assert (node != NULL);
+ g_assert (g_hash_table_lookup (directory->details->file_hash,
+ name) == NULL);
+ g_hash_table_insert (directory->details->file_hash, (char *) name, node);
+}
+
+static GList *
+extract_from_hash_table (CajaDirectory *directory, CajaFile *file)
+{
+ const char *name;
+ GList *node;
+
+ name = eel_ref_str_peek (file->details->name);
+ if (name == NULL)
+ {
+ return NULL;
+ }
+
+ /* Find the list node in the hash table. */
+ node = g_hash_table_lookup (directory->details->file_hash, name);
+ g_hash_table_remove (directory->details->file_hash, name);
+
+ return node;
+}
+
+void
+caja_directory_add_file (CajaDirectory *directory, CajaFile *file)
+{
+ GList *node;
+ gboolean add_to_work_queue;
+
+ g_assert (CAJA_IS_DIRECTORY (directory));
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->name != NULL);
+
+ /* Add to list. */
+ node = g_list_prepend (directory->details->file_list, file);
+ directory->details->file_list = node;
+
+ /* Add to hash table. */
+ add_to_hash_table (directory, file, node);
+
+ directory->details->confirmed_file_count++;
+
+ add_to_work_queue = FALSE;
+ if (caja_directory_is_file_list_monitored (directory))
+ {
+ /* Ref if we are monitoring, since monitoring owns the file list. */
+ caja_file_ref (file);
+ add_to_work_queue = TRUE;
+ }
+ else if (caja_directory_has_active_request_for_file (directory, file))
+ {
+ /* We're waiting for the file in a call_when_ready. Make sure
+ we add the file to the work queue so that said waiter won't
+ wait forever for e.g. all files in the directory to be done */
+ add_to_work_queue = TRUE;
+ }
+
+ if (add_to_work_queue)
+ {
+ caja_directory_add_file_to_work_queue (directory, file);
+ }
+}
+
+void
+caja_directory_remove_file (CajaDirectory *directory, CajaFile *file)
+{
+ GList *node;
+
+ g_assert (CAJA_IS_DIRECTORY (directory));
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->name != NULL);
+
+ /* Find the list node in the hash table. */
+ node = extract_from_hash_table (directory, file);
+ g_assert (node != NULL);
+ g_assert (node->data == file);
+
+ /* Remove the item from the list. */
+ directory->details->file_list = g_list_remove_link
+ (directory->details->file_list, node);
+ g_list_free_1 (node);
+
+ caja_directory_remove_file_from_work_queue (directory, file);
+
+ if (!file->details->unconfirmed)
+ {
+ directory->details->confirmed_file_count--;
+ }
+
+ /* Unref if we are monitoring. */
+ if (caja_directory_is_file_list_monitored (directory))
+ {
+ caja_file_unref (file);
+ }
+}
+
+#define CAJA_DIRECTORY_FILE_LIST_DEFAULT_LIMIT 4000
+
+gboolean
+caja_directory_file_list_length_reached (CajaDirectory *directory)
+{
+ static gboolean inited = FALSE;
+ static int directory_limit = 0;
+
+ if (!inited)
+ {
+ eel_preferences_add_auto_integer
+ ("/apps/caja/preferences/directory_limit",
+ &directory_limit);
+ inited = TRUE;
+ }
+ if (directory_limit < 0) /* unlimited */
+ {
+ return FALSE;
+ }
+ if (directory_limit == 0) /* dead mateconfd */
+ {
+ directory_limit = CAJA_DIRECTORY_FILE_LIST_DEFAULT_LIMIT;
+ }
+
+ return directory->details->confirmed_file_count >= directory_limit;
+}
+
+GList *
+caja_directory_begin_file_name_change (CajaDirectory *directory,
+ CajaFile *file)
+{
+ /* Find the list node in the hash table. */
+ return extract_from_hash_table (directory, file);
+}
+
+void
+caja_directory_end_file_name_change (CajaDirectory *directory,
+ CajaFile *file,
+ GList *node)
+{
+ /* Add the list node to the hash table. */
+ if (node != NULL)
+ {
+ add_to_hash_table (directory, file, node);
+ }
+}
+
+CajaFile *
+caja_directory_find_file_by_name (CajaDirectory *directory,
+ const char *name)
+{
+ GList *node;
+
+ g_return_val_if_fail (CAJA_IS_DIRECTORY (directory), NULL);
+ g_return_val_if_fail (name != NULL, NULL);
+
+ node = g_hash_table_lookup (directory->details->file_hash,
+ name);
+ return node == NULL ? NULL : CAJA_FILE (node->data);
+}
+
+/* "." for the directory-as-file, otherwise the filename */
+CajaFile *
+caja_directory_find_file_by_internal_filename (CajaDirectory *directory,
+ const char *internal_filename)
+{
+ CajaFile *result;
+
+ if (eel_strcmp (internal_filename, ".") == 0)
+ {
+ result = caja_directory_get_existing_corresponding_file (directory);
+ if (result != NULL)
+ {
+ caja_file_unref (result);
+ }
+ }
+ else
+ {
+ result = caja_directory_find_file_by_name (directory, internal_filename);
+ }
+
+ return result;
+}
+
+void
+caja_directory_emit_files_added (CajaDirectory *directory,
+ GList *added_files)
+{
+ if (added_files != NULL)
+ {
+ g_signal_emit (directory,
+ signals[FILES_ADDED], 0,
+ added_files);
+ }
+}
+
+void
+caja_directory_emit_files_changed (CajaDirectory *directory,
+ GList *changed_files)
+{
+ if (changed_files != NULL)
+ {
+ g_signal_emit (directory,
+ signals[FILES_CHANGED], 0,
+ changed_files);
+ }
+}
+
+void
+caja_directory_emit_change_signals (CajaDirectory *directory,
+ GList *changed_files)
+{
+ GList *p;
+
+ for (p = changed_files; p != NULL; p = p->next)
+ {
+ caja_file_emit_changed (p->data);
+ }
+ caja_directory_emit_files_changed (directory, changed_files);
+}
+
+void
+caja_directory_emit_done_loading (CajaDirectory *directory)
+{
+ g_signal_emit (directory,
+ signals[DONE_LOADING], 0);
+}
+
+void
+caja_directory_emit_load_error (CajaDirectory *directory,
+ GError *error)
+{
+ g_signal_emit (directory,
+ signals[LOAD_ERROR], 0,
+ error);
+}
+
+/* Return a directory object for this one's parent. */
+static CajaDirectory *
+get_parent_directory (GFile *location)
+{
+ CajaDirectory *directory;
+ GFile *parent;
+
+ parent = g_file_get_parent (location);
+ if (parent)
+ {
+ directory = caja_directory_get_internal (parent, TRUE);
+ g_object_unref (parent);
+ return directory;
+ }
+ return NULL;
+}
+
+/* If a directory object exists for this one's parent, then
+ * return it, otherwise return NULL.
+ */
+static CajaDirectory *
+get_parent_directory_if_exists (GFile *location)
+{
+ CajaDirectory *directory;
+ GFile *parent;
+
+ parent = g_file_get_parent (location);
+ if (parent)
+ {
+ directory = caja_directory_get_internal (parent, FALSE);
+ g_object_unref (parent);
+ return directory;
+ }
+ return NULL;
+}
+
+static void
+hash_table_list_prepend (GHashTable *table, gconstpointer key, gpointer data)
+{
+ GList *list;
+
+ list = g_hash_table_lookup (table, key);
+ list = g_list_prepend (list, data);
+ g_hash_table_insert (table, (gpointer) key, list);
+}
+
+static void
+call_files_added_free_list (gpointer key, gpointer value, gpointer user_data)
+{
+ g_assert (CAJA_IS_DIRECTORY (key));
+ g_assert (value != NULL);
+ g_assert (user_data == NULL);
+
+ g_signal_emit (key,
+ signals[FILES_ADDED], 0,
+ value);
+ g_list_free (value);
+}
+
+static void
+call_files_changed_common (CajaDirectory *directory, GList *file_list)
+{
+ GList *node;
+ CajaFile *file;
+
+ for (node = file_list; node != NULL; node = node->next)
+ {
+ file = node->data;
+ if (file->details->directory == directory)
+ {
+ caja_directory_add_file_to_work_queue (directory,
+ file);
+ }
+ }
+ caja_directory_async_state_changed (directory);
+ caja_directory_emit_change_signals (directory, file_list);
+}
+
+static void
+call_files_changed_free_list (gpointer key, gpointer value, gpointer user_data)
+{
+ g_assert (value != NULL);
+ g_assert (user_data == NULL);
+
+ call_files_changed_common (CAJA_DIRECTORY (key), value);
+ g_list_free (value);
+}
+
+static void
+call_files_changed_unref_free_list (gpointer key, gpointer value, gpointer user_data)
+{
+ g_assert (value != NULL);
+ g_assert (user_data == NULL);
+
+ call_files_changed_common (CAJA_DIRECTORY (key), value);
+ caja_file_list_free (value);
+}
+
+static void
+call_get_file_info_free_list (gpointer key, gpointer value, gpointer user_data)
+{
+ CajaDirectory *directory;
+ GList *files;
+
+ g_assert (CAJA_IS_DIRECTORY (key));
+ g_assert (value != NULL);
+ g_assert (user_data == NULL);
+
+ directory = key;
+ files = value;
+
+ caja_directory_get_info_for_new_files (directory, files);
+ g_list_foreach (files, (GFunc) g_object_unref, NULL);
+ g_list_free (files);
+}
+
+static void
+invalidate_count_and_unref (gpointer key, gpointer value, gpointer user_data)
+{
+ g_assert (CAJA_IS_DIRECTORY (key));
+ g_assert (value == key);
+ g_assert (user_data == NULL);
+
+ caja_directory_invalidate_count_and_mime_list (key);
+ caja_directory_unref (key);
+}
+
+static void
+collect_parent_directories (GHashTable *hash_table, CajaDirectory *directory)
+{
+ g_assert (hash_table != NULL);
+ g_assert (CAJA_IS_DIRECTORY (directory));
+
+ if (g_hash_table_lookup (hash_table, directory) == NULL)
+ {
+ caja_directory_ref (directory);
+ g_hash_table_insert (hash_table, directory, directory);
+ }
+}
+
+void
+caja_directory_notify_files_added (GList *files)
+{
+ GHashTable *added_lists;
+ GList *p;
+ CajaDirectory *directory;
+ GHashTable *parent_directories;
+ CajaFile *file;
+ GFile *location, *parent;
+
+ /* Make a list of added files in each directory. */
+ added_lists = g_hash_table_new (NULL, NULL);
+
+ /* Make a list of parent directories that will need their counts updated. */
+ parent_directories = g_hash_table_new (NULL, NULL);
+
+ for (p = files; p != NULL; p = p->next)
+ {
+ location = p->data;
+
+ /* See if the directory is already known. */
+ directory = get_parent_directory_if_exists (location);
+ if (directory == NULL)
+ {
+ /* In case the directory is not being
+ * monitored, but the corresponding file is,
+ * we must invalidate it's item count.
+ */
+
+
+ file = NULL;
+ parent = g_file_get_parent (location);
+ if (parent)
+ {
+ file = caja_file_get_existing (parent);
+ g_object_unref (parent);
+ }
+
+ if (file != NULL)
+ {
+ caja_file_invalidate_count_and_mime_list (file);
+ caja_file_unref (file);
+ }
+
+ continue;
+ }
+
+ collect_parent_directories (parent_directories, directory);
+
+ /* If no one is monitoring files in the directory, nothing to do. */
+ if (!caja_directory_is_file_list_monitored (directory))
+ {
+ caja_directory_unref (directory);
+ continue;
+ }
+
+ file = caja_file_get_existing (location);
+ /* We check is_added here, because the file could have been added
+ * to the directory by a caja_file_get() but not gotten
+ * files_added emitted
+ */
+ if (file && file->details->is_added)
+ {
+ /* A file already exists, it was probably renamed.
+ * If it was renamed this could be ignored, but
+ * queue a change just in case */
+ caja_file_changed (file);
+ caja_file_unref (file);
+ }
+ else
+ {
+ hash_table_list_prepend (added_lists,
+ directory,
+ g_object_ref (location));
+ }
+ caja_directory_unref (directory);
+ }
+
+ /* Now get file info for the new files. This creates CajaFile
+ * objects for the new files, and sends out a files_added signal.
+ */
+ g_hash_table_foreach (added_lists, call_get_file_info_free_list, NULL);
+ g_hash_table_destroy (added_lists);
+
+ /* Invalidate count for each parent directory. */
+ g_hash_table_foreach (parent_directories, invalidate_count_and_unref, NULL);
+ g_hash_table_destroy (parent_directories);
+}
+
+static void
+g_file_pair_free (GFilePair *pair)
+{
+ g_object_unref (pair->to);
+ g_object_unref (pair->from);
+ g_free (pair);
+}
+
+static GList *
+uri_pairs_to_file_pairs (GList *uri_pairs)
+{
+ GList *l, *file_pair_list;
+ GFilePair *file_pair;
+ URIPair *uri_pair;
+
+ file_pair_list = NULL;
+
+ for (l = uri_pairs; l != NULL; l = l->next)
+ {
+ uri_pair = l->data;
+ file_pair = g_new (GFilePair, 1);
+ file_pair->from = g_file_new_for_uri (uri_pair->from_uri);
+ file_pair->to = g_file_new_for_uri (uri_pair->to_uri);
+
+ file_pair_list = g_list_prepend (file_pair_list, file_pair);
+ }
+ return g_list_reverse (file_pair_list);
+}
+
+void
+caja_directory_notify_files_added_by_uri (GList *uris)
+{
+ GList *files;
+
+ files = caja_file_list_from_uris (uris);
+ caja_directory_notify_files_added (files);
+ eel_g_object_list_free (files);
+}
+
+void
+caja_directory_notify_files_changed (GList *files)
+{
+ GHashTable *changed_lists;
+ GList *node;
+ GFile *location;
+ CajaFile *file;
+
+ /* Make a list of changed files in each directory. */
+ changed_lists = g_hash_table_new (NULL, NULL);
+
+ /* Go through all the notifications. */
+ for (node = files; node != NULL; node = node->next)
+ {
+ location = node->data;
+
+ /* Find the file. */
+ file = caja_file_get_existing (location);
+ if (file != NULL)
+ {
+ /* Tell it to re-get info now, and later emit
+ * a changed signal.
+ */
+ file->details->file_info_is_up_to_date = FALSE;
+ file->details->top_left_text_is_up_to_date = FALSE;
+ file->details->link_info_is_up_to_date = FALSE;
+ caja_file_invalidate_extension_info_internal (file);
+
+ hash_table_list_prepend (changed_lists,
+ file->details->directory,
+ file);
+ }
+ }
+
+ /* Now send out the changed signals. */
+ g_hash_table_foreach (changed_lists, call_files_changed_unref_free_list, NULL);
+ g_hash_table_destroy (changed_lists);
+}
+
+void
+caja_directory_notify_files_changed_by_uri (GList *uris)
+{
+ GList *files;
+
+ files = caja_file_list_from_uris (uris);
+ caja_directory_notify_files_changed (files);
+ eel_g_object_list_free (files);
+}
+
+void
+caja_directory_notify_files_removed (GList *files)
+{
+ GHashTable *changed_lists;
+ GList *p;
+ CajaDirectory *directory;
+ GHashTable *parent_directories;
+ CajaFile *file;
+ GFile *location;
+
+ /* Make a list of changed files in each directory. */
+ changed_lists = g_hash_table_new (NULL, NULL);
+
+ /* Make a list of parent directories that will need their counts updated. */
+ parent_directories = g_hash_table_new (NULL, NULL);
+
+ /* Go through all the notifications. */
+ for (p = files; p != NULL; p = p->next)
+ {
+ location = p->data;
+
+ /* Update file count for parent directory if anyone might care. */
+ directory = get_parent_directory_if_exists (location);
+ if (directory != NULL)
+ {
+ collect_parent_directories (parent_directories, directory);
+ caja_directory_unref (directory);
+ }
+
+ /* Find the file. */
+ file = caja_file_get_existing (location);
+ if (file != NULL && !caja_file_rename_in_progress (file))
+ {
+ /* Mark it gone and prepare to send the changed signal. */
+ caja_file_mark_gone (file);
+ hash_table_list_prepend (changed_lists,
+ file->details->directory,
+ caja_file_ref (file));
+ }
+ caja_file_unref (file);
+ }
+
+ /* Now send out the changed signals. */
+ g_hash_table_foreach (changed_lists, call_files_changed_unref_free_list, NULL);
+ g_hash_table_destroy (changed_lists);
+
+ /* Invalidate count for each parent directory. */
+ g_hash_table_foreach (parent_directories, invalidate_count_and_unref, NULL);
+ g_hash_table_destroy (parent_directories);
+}
+
+void
+caja_directory_notify_files_removed_by_uri (GList *uris)
+{
+ GList *files;
+
+ files = caja_file_list_from_uris (uris);
+ caja_directory_notify_files_changed (files);
+ eel_g_object_list_free (files);
+}
+
+static void
+set_directory_location (CajaDirectory *directory,
+ GFile *location)
+{
+ if (directory->details->location)
+ {
+ g_object_unref (directory->details->location);
+ }
+ directory->details->location = g_object_ref (location);
+
+}
+
+static void
+change_directory_location (CajaDirectory *directory,
+ GFile *new_location)
+{
+ /* I believe it's impossible for a self-owned file/directory
+ * to be moved. But if that did somehow happen, this function
+ * wouldn't do enough to handle it.
+ */
+ g_assert (directory->details->as_file == NULL);
+
+ g_hash_table_remove (directories,
+ directory->details->location);
+
+ set_directory_location (directory, new_location);
+
+ g_hash_table_insert (directories,
+ directory->details->location,
+ directory);
+}
+
+typedef struct
+{
+ GFile *container;
+ GList *directories;
+} CollectData;
+
+static void
+collect_directories_by_container (gpointer key, gpointer value, gpointer callback_data)
+{
+ CajaDirectory *directory;
+ CollectData *collect_data;
+ GFile *location;
+
+ location = (GFile *) key;
+ directory = CAJA_DIRECTORY (value);
+ collect_data = (CollectData *) callback_data;
+
+ if (g_file_has_prefix (location, collect_data->container) ||
+ g_file_equal (collect_data->container, location))
+ {
+ caja_directory_ref (directory);
+ collect_data->directories =
+ g_list_prepend (collect_data->directories,
+ directory);
+ }
+}
+
+static GList *
+caja_directory_moved_internal (GFile *old_location,
+ GFile *new_location)
+{
+ CollectData collection;
+ CajaDirectory *directory;
+ GList *node, *affected_files;
+ GFile *new_directory_location;
+ char *relative_path;
+
+ collection.container = old_location;
+ collection.directories = NULL;
+
+ g_hash_table_foreach (directories,
+ collect_directories_by_container,
+ &collection);
+
+ affected_files = NULL;
+
+ for (node = collection.directories; node != NULL; node = node->next)
+ {
+ directory = CAJA_DIRECTORY (node->data);
+ new_directory_location = NULL;
+
+ if (g_file_equal (directory->details->location, old_location))
+ {
+ new_directory_location = g_object_ref (new_location);
+ }
+ else
+ {
+ relative_path = g_file_get_relative_path (old_location,
+ directory->details->location);
+ if (relative_path != NULL)
+ {
+ new_directory_location = g_file_resolve_relative_path (new_location, relative_path);
+ g_free (relative_path);
+
+ }
+ }
+
+ if (new_directory_location)
+ {
+ change_directory_location (directory, new_directory_location);
+ g_object_unref (new_directory_location);
+
+ /* Collect affected files. */
+ if (directory->details->as_file != NULL)
+ {
+ affected_files = g_list_prepend
+ (affected_files,
+ caja_file_ref (directory->details->as_file));
+ }
+ affected_files = g_list_concat
+ (affected_files,
+ caja_file_list_copy (directory->details->file_list));
+ }
+
+ caja_directory_unref (directory);
+ }
+
+ g_list_free (collection.directories);
+
+ return affected_files;
+}
+
+void
+caja_directory_moved (const char *old_uri,
+ const char *new_uri)
+{
+ GList *list, *node;
+ GHashTable *hash;
+ CajaFile *file;
+ GFile *old_location;
+ GFile *new_location;
+
+ hash = g_hash_table_new (NULL, NULL);
+
+ old_location = g_file_new_for_uri (old_uri);
+ new_location = g_file_new_for_uri (new_uri);
+
+ list = caja_directory_moved_internal (old_location, new_location);
+ for (node = list; node != NULL; node = node->next)
+ {
+ file = CAJA_FILE (node->data);
+ hash_table_list_prepend (hash,
+ file->details->directory,
+ caja_file_ref (file));
+ }
+ caja_file_list_free (list);
+
+ g_object_unref (old_location);
+ g_object_unref (new_location);
+
+ g_hash_table_foreach (hash, call_files_changed_unref_free_list, NULL);
+ g_hash_table_destroy (hash);
+}
+
+void
+caja_directory_notify_files_moved (GList *file_pairs)
+{
+ GList *p, *affected_files, *node;
+ GFilePair *pair;
+ CajaFile *file;
+ CajaDirectory *old_directory, *new_directory;
+ GHashTable *parent_directories;
+ GList *new_files_list, *unref_list;
+ GHashTable *added_lists, *changed_lists;
+ char *name;
+ CajaFileAttributes cancel_attributes;
+ GFile *to_location, *from_location;
+
+ /* Make a list of added and changed files in each directory. */
+ new_files_list = NULL;
+ added_lists = g_hash_table_new (NULL, NULL);
+ changed_lists = g_hash_table_new (NULL, NULL);
+ unref_list = NULL;
+
+ /* Make a list of parent directories that will need their counts updated. */
+ parent_directories = g_hash_table_new (NULL, NULL);
+
+ cancel_attributes = caja_file_get_all_attributes ();
+
+ for (p = file_pairs; p != NULL; p = p->next)
+ {
+ pair = p->data;
+ from_location = pair->from;
+ to_location = pair->to;
+
+ /* Handle overwriting a file. */
+ file = caja_file_get_existing (to_location);
+ if (file != NULL)
+ {
+ /* Mark it gone and prepare to send the changed signal. */
+ caja_file_mark_gone (file);
+ new_directory = file->details->directory;
+ hash_table_list_prepend (changed_lists,
+ new_directory,
+ file);
+ collect_parent_directories (parent_directories,
+ new_directory);
+ }
+
+ /* Update any directory objects that are affected. */
+ affected_files = caja_directory_moved_internal (from_location,
+ to_location);
+ for (node = affected_files; node != NULL; node = node->next)
+ {
+ file = CAJA_FILE (node->data);
+ hash_table_list_prepend (changed_lists,
+ file->details->directory,
+ file);
+ }
+ unref_list = g_list_concat (unref_list, affected_files);
+
+ /* Move an existing file. */
+ file = caja_file_get_existing (from_location);
+ if (file == NULL)
+ {
+ /* Handle this as if it was a new file. */
+ new_files_list = g_list_prepend (new_files_list,
+ to_location);
+ }
+ else
+ {
+ /* Handle notification in the old directory. */
+ old_directory = file->details->directory;
+ collect_parent_directories (parent_directories, old_directory);
+
+ /* Cancel loading of attributes in the old directory */
+ caja_directory_cancel_loading_file_attributes
+ (old_directory, file, cancel_attributes);
+
+ /* Locate the new directory. */
+ new_directory = get_parent_directory (to_location);
+ collect_parent_directories (parent_directories, new_directory);
+ /* We can unref now -- new_directory is in the
+ * parent directories list so it will be
+ * around until the end of this function
+ * anyway.
+ */
+ caja_directory_unref (new_directory);
+
+ /* Update the file's name and directory. */
+ name = g_file_get_basename (to_location);
+ caja_file_update_name_and_directory
+ (file, name, new_directory);
+ g_free (name);
+
+ /* Update file attributes */
+ caja_file_invalidate_attributes (file, CAJA_FILE_ATTRIBUTE_INFO);
+
+ hash_table_list_prepend (changed_lists,
+ old_directory,
+ file);
+ if (old_directory != new_directory)
+ {
+ hash_table_list_prepend (added_lists,
+ new_directory,
+ file);
+ }
+
+ /* Unref each file once to balance out caja_file_get_by_uri. */
+ unref_list = g_list_prepend (unref_list, file);
+ }
+ }
+
+ /* Now send out the changed and added signals for existing file objects. */
+ g_hash_table_foreach (changed_lists, call_files_changed_free_list, NULL);
+ g_hash_table_destroy (changed_lists);
+ g_hash_table_foreach (added_lists, call_files_added_free_list, NULL);
+ g_hash_table_destroy (added_lists);
+
+ /* Let the file objects go. */
+ caja_file_list_free (unref_list);
+
+ /* Invalidate count for each parent directory. */
+ g_hash_table_foreach (parent_directories, invalidate_count_and_unref, NULL);
+ g_hash_table_destroy (parent_directories);
+
+ /* Separate handling for brand new file objects. */
+ caja_directory_notify_files_added (new_files_list);
+ g_list_free (new_files_list);
+}
+
+void
+caja_directory_notify_files_moved_by_uri (GList *uri_pairs)
+{
+ GList *file_pairs;
+
+ file_pairs = uri_pairs_to_file_pairs (uri_pairs);
+ caja_directory_notify_files_moved (file_pairs);
+ g_list_foreach (file_pairs, (GFunc)g_file_pair_free, NULL);
+ g_list_free (file_pairs);
+}
+
+void
+caja_directory_schedule_position_set (GList *position_setting_list)
+{
+ GList *p;
+ const CajaFileChangesQueuePosition *item;
+ CajaFile *file;
+ char str[64];
+ time_t now;
+
+ time (&now);
+
+ for (p = position_setting_list; p != NULL; p = p->next)
+ {
+ item = (CajaFileChangesQueuePosition *) p->data;
+
+ file = caja_file_get (item->location);
+
+ if (item->set)
+ {
+ g_snprintf (str, sizeof (str), "%d,%d", item->point.x, item->point.y);
+ }
+ else
+ {
+ str[0] = 0;
+ }
+ caja_file_set_metadata
+ (file,
+ CAJA_METADATA_KEY_ICON_POSITION,
+ NULL,
+ str);
+
+ if (item->set)
+ {
+ caja_file_set_time_metadata
+ (file,
+ CAJA_METADATA_KEY_ICON_POSITION_TIMESTAMP,
+ now);
+ }
+ else
+ {
+ caja_file_set_time_metadata
+ (file,
+ CAJA_METADATA_KEY_ICON_POSITION_TIMESTAMP,
+ UNDEFINED_TIME);
+ }
+
+ if (item->set)
+ {
+ g_snprintf (str, sizeof (str), "%d", item->screen);
+ }
+ else
+ {
+ str[0] = 0;
+ }
+ caja_file_set_metadata
+ (file,
+ CAJA_METADATA_KEY_SCREEN,
+ NULL,
+ str);
+
+ caja_file_unref (file);
+ }
+}
+
+gboolean
+caja_directory_contains_file (CajaDirectory *directory,
+ CajaFile *file)
+{
+ g_return_val_if_fail (CAJA_IS_DIRECTORY (directory), FALSE);
+ g_return_val_if_fail (CAJA_IS_FILE (file), FALSE);
+
+ if (caja_file_is_gone (file))
+ {
+ return FALSE;
+ }
+
+ return EEL_CALL_METHOD_WITH_RETURN_VALUE
+ (CAJA_DIRECTORY_CLASS, directory,
+ contains_file, (directory, file));
+}
+
+char *
+caja_directory_get_file_uri (CajaDirectory *directory,
+ const char *file_name)
+{
+ GFile *child;
+ char *result;
+
+ g_return_val_if_fail (CAJA_IS_DIRECTORY (directory), NULL);
+ g_return_val_if_fail (file_name != NULL, NULL);
+
+ result = NULL;
+
+ child = g_file_get_child (directory->details->location, file_name);
+ result = g_file_get_uri (child);
+ g_object_unref (child);
+
+ return result;
+}
+
+void
+caja_directory_call_when_ready (CajaDirectory *directory,
+ CajaFileAttributes file_attributes,
+ gboolean wait_for_all_files,
+ CajaDirectoryCallback callback,
+ gpointer callback_data)
+{
+ g_return_if_fail (CAJA_IS_DIRECTORY (directory));
+ g_return_if_fail (callback != NULL);
+
+ EEL_CALL_METHOD
+ (CAJA_DIRECTORY_CLASS, directory,
+ call_when_ready, (directory, file_attributes, wait_for_all_files,
+ callback, callback_data));
+}
+
+void
+caja_directory_cancel_callback (CajaDirectory *directory,
+ CajaDirectoryCallback callback,
+ gpointer callback_data)
+{
+ g_return_if_fail (CAJA_IS_DIRECTORY (directory));
+ g_return_if_fail (callback != NULL);
+
+ EEL_CALL_METHOD
+ (CAJA_DIRECTORY_CLASS, directory,
+ cancel_callback, (directory, callback, callback_data));
+}
+
+void
+caja_directory_file_monitor_add (CajaDirectory *directory,
+ gconstpointer client,
+ gboolean monitor_hidden_files,
+ gboolean monitor_backup_files,
+ CajaFileAttributes file_attributes,
+ CajaDirectoryCallback callback,
+ gpointer callback_data)
+{
+ g_return_if_fail (CAJA_IS_DIRECTORY (directory));
+ g_return_if_fail (client != NULL);
+
+ EEL_CALL_METHOD
+ (CAJA_DIRECTORY_CLASS, directory,
+ file_monitor_add, (directory, client,
+ monitor_hidden_files,
+ monitor_backup_files,
+ file_attributes,
+ callback, callback_data));
+}
+
+void
+caja_directory_file_monitor_remove (CajaDirectory *directory,
+ gconstpointer client)
+{
+ g_return_if_fail (CAJA_IS_DIRECTORY (directory));
+ g_return_if_fail (client != NULL);
+
+ EEL_CALL_METHOD
+ (CAJA_DIRECTORY_CLASS, directory,
+ file_monitor_remove, (directory, client));
+}
+
+void
+caja_directory_force_reload (CajaDirectory *directory)
+{
+ g_return_if_fail (CAJA_IS_DIRECTORY (directory));
+
+ EEL_CALL_METHOD
+ (CAJA_DIRECTORY_CLASS, directory,
+ force_reload, (directory));
+}
+
+gboolean
+caja_directory_is_not_empty (CajaDirectory *directory)
+{
+ g_return_val_if_fail (CAJA_IS_DIRECTORY (directory), FALSE);
+
+ return EEL_CALL_METHOD_WITH_RETURN_VALUE
+ (CAJA_DIRECTORY_CLASS, directory,
+ is_not_empty, (directory));
+}
+
+static gboolean
+is_tentative (gpointer data, gpointer callback_data)
+{
+ CajaFile *file;
+
+ g_assert (callback_data == NULL);
+
+ file = CAJA_FILE (data);
+ /* Avoid returning files with !is_added, because these
+ * will later be sent with the files_added signal, and a
+ * user doing get_file_list + files_added monitoring will
+ * then see the file twice */
+ return !file->details->got_file_info || !file->details->is_added;
+}
+
+GList *
+caja_directory_get_file_list (CajaDirectory *directory)
+{
+ return EEL_CALL_METHOD_WITH_RETURN_VALUE
+ (CAJA_DIRECTORY_CLASS, directory,
+ get_file_list, (directory));
+}
+
+static GList *
+real_get_file_list (CajaDirectory *directory)
+{
+ GList *tentative_files, *non_tentative_files;
+
+ tentative_files = eel_g_list_partition
+ (g_list_copy (directory->details->file_list),
+ is_tentative, NULL, &non_tentative_files);
+ g_list_free (tentative_files);
+
+ caja_file_list_ref (non_tentative_files);
+ return non_tentative_files;
+}
+
+static gboolean
+real_is_editable (CajaDirectory *directory)
+{
+ return TRUE;
+}
+
+gboolean
+caja_directory_is_editable (CajaDirectory *directory)
+{
+ return EEL_CALL_METHOD_WITH_RETURN_VALUE
+ (CAJA_DIRECTORY_CLASS, directory,
+ is_editable, (directory));
+}
+
+GList *
+caja_directory_match_pattern (CajaDirectory *directory, const char *pattern)
+{
+ GList *files, *l, *ret;
+ GPatternSpec *spec;
+
+
+ ret = NULL;
+ spec = g_pattern_spec_new (pattern);
+
+ files = caja_directory_get_file_list (directory);
+ for (l = files; l; l = l->next)
+ {
+ CajaFile *file;
+ char *name;
+
+ file = CAJA_FILE (l->data);
+ name = caja_file_get_display_name (file);
+
+ if (g_pattern_match_string (spec, name))
+ {
+ ret = g_list_prepend(ret, caja_file_ref (file));
+ }
+
+ g_free (name);
+ }
+
+ g_pattern_spec_free (spec);
+ caja_file_list_free (files);
+
+ return ret;
+}
+
+/**
+ * caja_directory_list_ref
+ *
+ * Ref all the directories in a list.
+ * @list: GList of directories.
+ **/
+GList *
+caja_directory_list_ref (GList *list)
+{
+ g_list_foreach (list, (GFunc) caja_directory_ref, NULL);
+ return list;
+}
+
+/**
+ * caja_directory_list_unref
+ *
+ * Unref all the directories in a list.
+ * @list: GList of directories.
+ **/
+void
+caja_directory_list_unref (GList *list)
+{
+ g_list_foreach (list, (GFunc) caja_directory_unref, NULL);
+}
+
+/**
+ * caja_directory_list_free
+ *
+ * Free a list of directories after unrefing them.
+ * @list: GList of directories.
+ **/
+void
+caja_directory_list_free (GList *list)
+{
+ caja_directory_list_unref (list);
+ g_list_free (list);
+}
+
+/**
+ * caja_directory_list_copy
+ *
+ * Copy the list of directories, making a new ref of each,
+ * @list: GList of directories.
+ **/
+GList *
+caja_directory_list_copy (GList *list)
+{
+ return g_list_copy (caja_directory_list_ref (list));
+}
+
+static int
+compare_by_uri (CajaDirectory *a, CajaDirectory *b)
+{
+ char *uri_a, *uri_b;
+ int res;
+
+ uri_a = g_file_get_uri (a->details->location);
+ uri_b = g_file_get_uri (b->details->location);
+
+ res = strcmp (uri_a, uri_b);
+
+ g_free (uri_a);
+ g_free (uri_b);
+
+ return res;
+}
+
+static int
+compare_by_uri_cover (gconstpointer a, gconstpointer b)
+{
+ return compare_by_uri (CAJA_DIRECTORY (a), CAJA_DIRECTORY (b));
+}
+
+/**
+ * caja_directory_list_sort_by_uri
+ *
+ * Sort the list of directories by directory uri.
+ * @list: GList of directories.
+ **/
+GList *
+caja_directory_list_sort_by_uri (GList *list)
+{
+ return g_list_sort (list, compare_by_uri_cover);
+}
+
+gboolean
+caja_directory_is_desktop_directory (CajaDirectory *directory)
+{
+ if (directory->details->location == NULL)
+ {
+ return FALSE;
+ }
+
+ return caja_is_desktop_directory (directory->details->location);
+}
+
+#if !defined (CAJA_OMIT_SELF_CHECK)
+
+#include <eel/eel-debug.h>
+#include "caja-file-attributes.h"
+
+static int data_dummy;
+static gboolean got_files_flag;
+
+static void
+got_files_callback (CajaDirectory *directory, GList *files, gpointer callback_data)
+{
+ g_assert (CAJA_IS_DIRECTORY (directory));
+ g_assert (g_list_length (files) > 10);
+ g_assert (callback_data == &data_dummy);
+
+ got_files_flag = TRUE;
+}
+
+/* Return the number of extant CajaDirectories */
+int
+caja_directory_number_outstanding (void)
+{
+ return directories ? g_hash_table_size (directories) : 0;
+}
+
+void
+caja_self_check_directory (void)
+{
+ CajaDirectory *directory;
+ CajaFile *file;
+
+ directory = caja_directory_get_by_uri ("file:///etc");
+ file = caja_file_get_by_uri ("file:///etc/passwd");
+
+ EEL_CHECK_INTEGER_RESULT (g_hash_table_size (directories), 1);
+
+ caja_directory_file_monitor_add
+ (directory, &data_dummy,
+ TRUE, TRUE, 0, NULL, NULL);
+
+ /* FIXME: these need to be updated to the new metadata infrastructure
+ * as make check doesn't pass.
+ caja_file_set_metadata (file, "test", "default", "value");
+ EEL_CHECK_STRING_RESULT (caja_file_get_metadata (file, "test", "default"), "value");
+
+ caja_file_set_boolean_metadata (file, "test_boolean", TRUE, TRUE);
+ EEL_CHECK_BOOLEAN_RESULT (caja_file_get_boolean_metadata (file, "test_boolean", TRUE), TRUE);
+ caja_file_set_boolean_metadata (file, "test_boolean", TRUE, FALSE);
+ EEL_CHECK_BOOLEAN_RESULT (caja_file_get_boolean_metadata (file, "test_boolean", TRUE), FALSE);
+ EEL_CHECK_BOOLEAN_RESULT (caja_file_get_boolean_metadata (NULL, "test_boolean", TRUE), TRUE);
+
+ caja_file_set_integer_metadata (file, "test_integer", 0, 17);
+ EEL_CHECK_INTEGER_RESULT (caja_file_get_integer_metadata (file, "test_integer", 0), 17);
+ caja_file_set_integer_metadata (file, "test_integer", 0, -1);
+ EEL_CHECK_INTEGER_RESULT (caja_file_get_integer_metadata (file, "test_integer", 0), -1);
+ caja_file_set_integer_metadata (file, "test_integer", 42, 42);
+ EEL_CHECK_INTEGER_RESULT (caja_file_get_integer_metadata (file, "test_integer", 42), 42);
+ EEL_CHECK_INTEGER_RESULT (caja_file_get_integer_metadata (NULL, "test_integer", 42), 42);
+ EEL_CHECK_INTEGER_RESULT (caja_file_get_integer_metadata (file, "nonexistent_key", 42), 42);
+ */
+
+ EEL_CHECK_BOOLEAN_RESULT (caja_directory_get_by_uri ("file:///etc") == directory, TRUE);
+ caja_directory_unref (directory);
+
+ EEL_CHECK_BOOLEAN_RESULT (caja_directory_get_by_uri ("file:///etc/") == directory, TRUE);
+ caja_directory_unref (directory);
+
+ EEL_CHECK_BOOLEAN_RESULT (caja_directory_get_by_uri ("file:///etc////") == directory, TRUE);
+ caja_directory_unref (directory);
+
+ caja_file_unref (file);
+
+ caja_directory_file_monitor_remove (directory, &data_dummy);
+
+ caja_directory_unref (directory);
+
+ while (g_hash_table_size (directories) != 0)
+ {
+ gtk_main_iteration ();
+ }
+
+ EEL_CHECK_INTEGER_RESULT (g_hash_table_size (directories), 0);
+
+ directory = caja_directory_get_by_uri ("file:///etc");
+
+ got_files_flag = FALSE;
+
+ caja_directory_call_when_ready (directory,
+ CAJA_FILE_ATTRIBUTE_INFO |
+ CAJA_FILE_ATTRIBUTE_DEEP_COUNTS,
+ TRUE,
+ got_files_callback, &data_dummy);
+
+ while (!got_files_flag)
+ {
+ gtk_main_iteration ();
+ }
+
+ EEL_CHECK_BOOLEAN_RESULT (directory->details->file_list == NULL, TRUE);
+
+ EEL_CHECK_INTEGER_RESULT (g_hash_table_size (directories), 1);
+
+ file = caja_file_get_by_uri ("file:///etc/passwd");
+
+ /* EEL_CHECK_STRING_RESULT (caja_file_get_metadata (file, "test", "default"), "value"); */
+
+ caja_file_unref (file);
+
+ caja_directory_unref (directory);
+
+ EEL_CHECK_INTEGER_RESULT (g_hash_table_size (directories), 0);
+}
+
+#endif /* !CAJA_OMIT_SELF_CHECK */
author	Perberos <[email protected]>	2011-12-01 22:24:23 -0300
committer	Perberos <[email protected]>	2011-12-01 22:24:23 -0300
commit	0e004c696b0e68b2cff37a4c3315b022a35eaf43 (patch)
tree	43261e815529cb9518ed7be37af13b846af8b26b /libcaja-private/caja-directory.c
download	caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.bz2 caja-0e004c696b0e68b2cff37a4c3315b022a35eaf43.tar.xz