summaryrefslogtreecommitdiff
path: root/libcaja-private/caja-directory-async.c
diff options
context:
space:
mode:
Diffstat (limited to 'libcaja-private/caja-directory-async.c')
-rw-r--r--libcaja-private/caja-directory-async.c5410
1 files changed, 5410 insertions, 0 deletions
diff --git a/libcaja-private/caja-directory-async.c b/libcaja-private/caja-directory-async.c
new file mode 100644
index 00000000..4451efc1
--- /dev/null
+++ b/libcaja-private/caja-directory-async.c
@@ -0,0 +1,5410 @@
+/* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*-
+
+ caja-directory-async.c: Caja directory model state machine.
+
+ 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-notify.h"
+#include "caja-directory-private.h"
+#include "caja-file-attributes.h"
+#include "caja-file-private.h"
+#include "caja-file-utilities.h"
+#include "caja-signaller.h"
+#include "caja-global-preferences.h"
+#include "caja-link.h"
+#include "caja-marshal.h"
+#include <eel/eel-glib-extensions.h>
+#include <eel/eel-string.h>
+#include <gtk/gtk.h>
+#include <libxml/parser.h>
+#include <stdio.h>
+#include <stdlib.h>
+
+/* turn this on to see messages about each load_directory call: */
+#if 0
+#define DEBUG_LOAD_DIRECTORY
+#endif
+
+/* turn this on to check if async. job calls are balanced */
+#if 0
+#define DEBUG_ASYNC_JOBS
+#endif
+
+/* turn this on to log things starting and stopping */
+#if 0
+#define DEBUG_START_STOP
+#endif
+
+#define DIRECTORY_LOAD_ITEMS_PER_CALLBACK 100
+
+/* Keep async. jobs down to this number for all directories. */
+#define MAX_ASYNC_JOBS 10
+
+struct TopLeftTextReadState
+{
+ CajaDirectory *directory;
+ CajaFile *file;
+ gboolean large;
+ GCancellable *cancellable;
+};
+
+struct LinkInfoReadState
+{
+ CajaDirectory *directory;
+ GCancellable *cancellable;
+ CajaFile *file;
+};
+
+struct ThumbnailState
+{
+ CajaDirectory *directory;
+ GCancellable *cancellable;
+ CajaFile *file;
+ gboolean trying_original;
+ gboolean tried_original;
+};
+
+struct MountState
+{
+ CajaDirectory *directory;
+ GCancellable *cancellable;
+ CajaFile *file;
+};
+
+struct FilesystemInfoState
+{
+ CajaDirectory *directory;
+ GCancellable *cancellable;
+ CajaFile *file;
+};
+
+struct DirectoryLoadState
+{
+ CajaDirectory *directory;
+ GCancellable *cancellable;
+ GFileEnumerator *enumerator;
+ GHashTable *load_mime_list_hash;
+ CajaFile *load_directory_file;
+ int load_file_count;
+};
+
+struct MimeListState
+{
+ CajaDirectory *directory;
+ CajaFile *mime_list_file;
+ GCancellable *cancellable;
+ GFileEnumerator *enumerator;
+ GHashTable *mime_list_hash;
+};
+
+struct GetInfoState
+{
+ CajaDirectory *directory;
+ GCancellable *cancellable;
+};
+
+struct NewFilesState
+{
+ CajaDirectory *directory;
+ GCancellable *cancellable;
+ int count;
+};
+
+struct DirectoryCountState
+{
+ CajaDirectory *directory;
+ CajaFile *count_file;
+ GCancellable *cancellable;
+ GFileEnumerator *enumerator;
+ int file_count;
+};
+
+struct DeepCountState
+{
+ CajaDirectory *directory;
+ GCancellable *cancellable;
+ GFileEnumerator *enumerator;
+ GFile *deep_count_location;
+ GList *deep_count_subdirectories;
+ GArray *seen_deep_count_inodes;
+};
+
+
+
+typedef struct
+{
+ CajaFile *file; /* Which file, NULL means all. */
+ union
+ {
+ CajaDirectoryCallback directory;
+ CajaFileCallback file;
+ } callback;
+ gpointer callback_data;
+ Request request;
+ gboolean active; /* Set to FALSE when the callback is triggered and
+ * scheduled to be called at idle, its still kept
+ * in the list so we can kill it when the file
+ * goes away.
+ */
+} ReadyCallback;
+
+typedef struct
+{
+ CajaFile *file; /* Which file, NULL means all. */
+ gboolean monitor_hidden_files; /* defines whether "all" includes hidden files */
+ gboolean monitor_backup_files; /* defines whether "all" includes backup files */
+ gconstpointer client;
+ Request request;
+} Monitor;
+
+typedef struct
+{
+ CajaDirectory *directory;
+ CajaInfoProvider *provider;
+ CajaOperationHandle *handle;
+ CajaOperationResult result;
+} InfoProviderResponse;
+
+typedef gboolean (* RequestCheck) (Request);
+typedef gboolean (* FileCheck) (CajaFile *);
+
+/* Current number of async. jobs. */
+static int async_job_count;
+static GHashTable *waiting_directories;
+#ifdef DEBUG_ASYNC_JOBS
+static GHashTable *async_jobs;
+#endif
+
+/* Hide kde trashcan directory */
+static char *kde_trash_dir_name = NULL;
+
+/* Forward declarations for functions that need them. */
+static void deep_count_load (DeepCountState *state,
+ GFile *location);
+static gboolean request_is_satisfied (CajaDirectory *directory,
+ CajaFile *file,
+ Request request);
+static void cancel_loading_attributes (CajaDirectory *directory,
+ CajaFileAttributes file_attributes);
+static void add_all_files_to_work_queue (CajaDirectory *directory);
+static void link_info_done (CajaDirectory *directory,
+ CajaFile *file,
+ const char *uri,
+ const char *name,
+ const char *icon,
+ gboolean is_launcher,
+ gboolean is_foreign);
+static void move_file_to_low_priority_queue (CajaDirectory *directory,
+ CajaFile *file);
+static void move_file_to_extension_queue (CajaDirectory *directory,
+ CajaFile *file);
+static void caja_directory_invalidate_file_attributes (CajaDirectory *directory,
+ CajaFileAttributes file_attributes);
+
+void
+caja_set_kde_trash_name (const char *trash_dir)
+{
+ g_free (kde_trash_dir_name);
+ kde_trash_dir_name = g_strdup (trash_dir);
+}
+
+/* Some helpers for case-insensitive strings.
+ * Move to caja-glib-extensions?
+ */
+
+static gboolean
+istr_equal (gconstpointer v, gconstpointer v2)
+{
+ return g_ascii_strcasecmp (v, v2) == 0;
+}
+
+static guint
+istr_hash (gconstpointer key)
+{
+ const char *p;
+ guint h;
+
+ h = 0;
+ for (p = key; *p != '\0'; p++)
+ {
+ h = (h << 5) - h + g_ascii_tolower (*p);
+ }
+
+ return h;
+}
+
+static GHashTable *
+istr_set_new (void)
+{
+ return g_hash_table_new_full (istr_hash, istr_equal, g_free, NULL);
+}
+
+static void
+istr_set_insert (GHashTable *table, const char *istr)
+{
+ char *key;
+
+ key = g_strdup (istr);
+ g_hash_table_replace (table, key, key);
+}
+
+static void
+add_istr_to_list (gpointer key, gpointer value, gpointer callback_data)
+{
+ GList **list;
+
+ list = callback_data;
+ *list = g_list_prepend (*list, g_strdup (key));
+}
+
+static GList *
+istr_set_get_as_list (GHashTable *table)
+{
+ GList *list;
+
+ list = NULL;
+ g_hash_table_foreach (table, add_istr_to_list, &list);
+ return list;
+}
+
+static void
+istr_set_destroy (GHashTable *table)
+{
+ g_hash_table_destroy (table);
+}
+
+static void
+request_counter_add_request (RequestCounter counter,
+ Request request)
+{
+ guint i;
+
+ for (i = 0; i < REQUEST_TYPE_LAST; i++)
+ {
+ if (REQUEST_WANTS_TYPE (request, i))
+ {
+ counter[i]++;
+ }
+ }
+}
+
+static void
+request_counter_remove_request (RequestCounter counter,
+ Request request)
+{
+ guint i;
+
+ for (i = 0; i < REQUEST_TYPE_LAST; i++)
+ {
+ if (REQUEST_WANTS_TYPE (request, i))
+ {
+ counter[i]--;
+ }
+ }
+}
+
+#if 0
+static void
+caja_directory_verify_request_counts (CajaDirectory *directory)
+{
+ GList *l;
+ RequestCounter counters;
+ int i;
+ gboolean fail;
+
+ fail = FALSE;
+ for (i = 0; i < REQUEST_TYPE_LAST; i ++)
+ {
+ counters[i] = 0;
+ }
+ for (l = directory->details->monitor_list; l != NULL; l = l->next)
+ {
+ Monitor *monitor = l->data;
+ request_counter_add_request (counters, monitor->request);
+ }
+ for (i = 0; i < REQUEST_TYPE_LAST; i ++)
+ {
+ if (counters[i] != directory->details->monitor_counters[i])
+ {
+ g_warning ("monitor counter for %i is wrong, expecting %d but found %d",
+ i, counters[i], directory->details->monitor_counters[i]);
+ fail = TRUE;
+ }
+ }
+ for (i = 0; i < REQUEST_TYPE_LAST; i ++)
+ {
+ counters[i] = 0;
+ }
+ for (l = directory->details->call_when_ready_list; l != NULL; l = l->next)
+ {
+ ReadyCallback *callback = l->data;
+ request_counter_add_request (counters, callback->request);
+ }
+ for (i = 0; i < REQUEST_TYPE_LAST; i ++)
+ {
+ if (counters[i] != directory->details->call_when_ready_counters[i])
+ {
+ g_warning ("call when ready counter for %i is wrong, expecting %d but found %d",
+ i, counters[i], directory->details->call_when_ready_counters[i]);
+ fail = TRUE;
+ }
+ }
+ g_assert (!fail);
+}
+#endif
+
+/* Start a job. This is really just a way of limiting the number of
+ * async. requests that we issue at any given time. Without this, the
+ * number of requests is unbounded.
+ */
+static gboolean
+async_job_start (CajaDirectory *directory,
+ const char *job)
+{
+#ifdef DEBUG_ASYNC_JOBS
+ char *key;
+#endif
+
+#ifdef DEBUG_START_STOP
+ g_message ("starting %s in %p", job, directory->details->location);
+#endif
+
+ g_assert (async_job_count >= 0);
+ g_assert (async_job_count <= MAX_ASYNC_JOBS);
+
+ if (async_job_count >= MAX_ASYNC_JOBS)
+ {
+ if (waiting_directories == NULL)
+ {
+ waiting_directories = eel_g_hash_table_new_free_at_exit
+ (NULL, NULL,
+ "caja-directory-async.c: waiting_directories");
+ }
+
+ g_hash_table_insert (waiting_directories,
+ directory,
+ directory);
+
+ return FALSE;
+ }
+
+#ifdef DEBUG_ASYNC_JOBS
+ {
+ char *uri;
+ if (async_jobs == NULL)
+ {
+ async_jobs = eel_g_hash_table_new_free_at_exit
+ (g_str_hash, g_str_equal,
+ "caja-directory-async.c: async_jobs");
+ }
+ uri = caja_directory_get_uri (directory);
+ key = g_strconcat (uri, ": ", job, NULL);
+ if (g_hash_table_lookup (async_jobs, key) != NULL)
+ {
+ g_warning ("same job twice: %s in %s",
+ job, uri);
+ }
+ g_free (uri);
+ g_hash_table_insert (async_jobs, key, directory);
+ }
+#endif
+
+ async_job_count += 1;
+ return TRUE;
+}
+
+/* End a job. */
+static void
+async_job_end (CajaDirectory *directory,
+ const char *job)
+{
+#ifdef DEBUG_ASYNC_JOBS
+ char *key;
+ gpointer table_key, value;
+#endif
+
+#ifdef DEBUG_START_STOP
+ g_message ("stopping %s in %p", job, directory->details->location);
+#endif
+
+ g_assert (async_job_count > 0);
+
+#ifdef DEBUG_ASYNC_JOBS
+ {
+ char *uri;
+ uri = caja_directory_get_uri (directory);
+ g_assert (async_jobs != NULL);
+ key = g_strconcat (uri, ": ", job, NULL);
+ if (!g_hash_table_lookup_extended (async_jobs, key, &table_key, &value))
+ {
+ g_warning ("ending job we didn't start: %s in %s",
+ job, uri);
+ }
+ else
+ {
+ g_hash_table_remove (async_jobs, key);
+ g_free (table_key);
+ }
+ g_free (uri);
+ g_free (key);
+ }
+#endif
+
+ async_job_count -= 1;
+}
+
+/* Helper to get one value from a hash table. */
+static void
+get_one_value_callback (gpointer key, gpointer value, gpointer callback_data)
+{
+ gpointer *returned_value;
+
+ returned_value = callback_data;
+ *returned_value = value;
+}
+
+/* return a single value from a hash table. */
+static gpointer
+get_one_value (GHashTable *table)
+{
+ gpointer value;
+
+ value = NULL;
+ if (table != NULL)
+ {
+ g_hash_table_foreach (table, get_one_value_callback, &value);
+ }
+ return value;
+}
+
+/* Wake up directories that are "blocked" as long as there are job
+ * slots available.
+ */
+static void
+async_job_wake_up (void)
+{
+ static gboolean already_waking_up = FALSE;
+ gpointer value;
+
+ g_assert (async_job_count >= 0);
+ g_assert (async_job_count <= MAX_ASYNC_JOBS);
+
+ if (already_waking_up)
+ {
+ return;
+ }
+
+ already_waking_up = TRUE;
+ while (async_job_count < MAX_ASYNC_JOBS)
+ {
+ value = get_one_value (waiting_directories);
+ if (value == NULL)
+ {
+ break;
+ }
+ g_hash_table_remove (waiting_directories, value);
+ caja_directory_async_state_changed
+ (CAJA_DIRECTORY (value));
+ }
+ already_waking_up = FALSE;
+}
+
+static void
+directory_count_cancel (CajaDirectory *directory)
+{
+ if (directory->details->count_in_progress != NULL)
+ {
+ g_cancellable_cancel (directory->details->count_in_progress->cancellable);
+ }
+}
+
+static void
+deep_count_cancel (CajaDirectory *directory)
+{
+ if (directory->details->deep_count_in_progress != NULL)
+ {
+ g_assert (CAJA_IS_FILE (directory->details->deep_count_file));
+
+ g_cancellable_cancel (directory->details->deep_count_in_progress->cancellable);
+
+ directory->details->deep_count_file->details->deep_counts_status = CAJA_REQUEST_NOT_STARTED;
+
+ directory->details->deep_count_in_progress->directory = NULL;
+ directory->details->deep_count_in_progress = NULL;
+ directory->details->deep_count_file = NULL;
+
+ async_job_end (directory, "deep count");
+ }
+}
+
+static void
+mime_list_cancel (CajaDirectory *directory)
+{
+ if (directory->details->mime_list_in_progress != NULL)
+ {
+ g_cancellable_cancel (directory->details->mime_list_in_progress->cancellable);
+ }
+}
+
+static void
+top_left_cancel (CajaDirectory *directory)
+{
+ if (directory->details->top_left_read_state != NULL)
+ {
+ g_cancellable_cancel (directory->details->top_left_read_state->cancellable);
+ directory->details->top_left_read_state->directory = NULL;
+ directory->details->top_left_read_state = NULL;
+
+ async_job_end (directory, "top left");
+ }
+}
+
+static void
+link_info_cancel (CajaDirectory *directory)
+{
+ if (directory->details->link_info_read_state != NULL)
+ {
+ g_cancellable_cancel (directory->details->link_info_read_state->cancellable);
+ directory->details->link_info_read_state->directory = NULL;
+ directory->details->link_info_read_state = NULL;
+ async_job_end (directory, "link info");
+ }
+}
+
+static void
+thumbnail_cancel (CajaDirectory *directory)
+{
+ if (directory->details->thumbnail_state != NULL)
+ {
+ g_cancellable_cancel (directory->details->thumbnail_state->cancellable);
+ directory->details->thumbnail_state->directory = NULL;
+ directory->details->thumbnail_state = NULL;
+ async_job_end (directory, "thumbnail");
+ }
+}
+
+static void
+mount_cancel (CajaDirectory *directory)
+{
+ if (directory->details->mount_state != NULL)
+ {
+ g_cancellable_cancel (directory->details->mount_state->cancellable);
+ directory->details->mount_state->directory = NULL;
+ directory->details->mount_state = NULL;
+ async_job_end (directory, "mount");
+ }
+}
+
+static void
+file_info_cancel (CajaDirectory *directory)
+{
+ if (directory->details->get_info_in_progress != NULL)
+ {
+ g_cancellable_cancel (directory->details->get_info_in_progress->cancellable);
+ directory->details->get_info_in_progress->directory = NULL;
+ directory->details->get_info_in_progress = NULL;
+ directory->details->get_info_file = NULL;
+
+ async_job_end (directory, "file info");
+ }
+}
+
+static void
+new_files_cancel (CajaDirectory *directory)
+{
+ GList *l;
+ NewFilesState *state;
+
+ if (directory->details->new_files_in_progress != NULL)
+ {
+ for (l = directory->details->new_files_in_progress; l != NULL; l = l->next)
+ {
+ state = l->data;
+ g_cancellable_cancel (state->cancellable);
+ state->directory = NULL;
+ }
+ g_list_free (directory->details->new_files_in_progress);
+ directory->details->new_files_in_progress = NULL;
+ }
+}
+
+static int
+monitor_key_compare (gconstpointer a,
+ gconstpointer data)
+{
+ const Monitor *monitor;
+ const Monitor *compare_monitor;
+
+ monitor = a;
+ compare_monitor = data;
+
+ if (monitor->client < compare_monitor->client)
+ {
+ return -1;
+ }
+ if (monitor->client > compare_monitor->client)
+ {
+ return +1;
+ }
+
+ if (monitor->file < compare_monitor->file)
+ {
+ return -1;
+ }
+ if (monitor->file > compare_monitor->file)
+ {
+ return +1;
+ }
+
+ return 0;
+}
+
+static GList *
+find_monitor (CajaDirectory *directory,
+ CajaFile *file,
+ gconstpointer client)
+{
+ Monitor monitor;
+
+ monitor.client = client;
+ monitor.file = file;
+
+ return g_list_find_custom (directory->details->monitor_list,
+ &monitor,
+ monitor_key_compare);
+}
+
+static void
+remove_monitor_link (CajaDirectory *directory,
+ GList *link)
+{
+ Monitor *monitor;
+
+ if (link != NULL)
+ {
+ monitor = link->data;
+ request_counter_remove_request (directory->details->monitor_counters,
+ monitor->request);
+ directory->details->monitor_list =
+ g_list_remove_link (directory->details->monitor_list, link);
+ g_free (monitor);
+ g_list_free_1 (link);
+ }
+}
+
+static void
+remove_monitor (CajaDirectory *directory,
+ CajaFile *file,
+ gconstpointer client)
+{
+ remove_monitor_link (directory, find_monitor (directory, file, client));
+}
+
+Request
+caja_directory_set_up_request (CajaFileAttributes file_attributes)
+{
+ Request request;
+
+ request = 0;
+
+ if ((file_attributes & CAJA_FILE_ATTRIBUTE_DIRECTORY_ITEM_COUNT) != 0)
+ {
+ REQUEST_SET_TYPE (request, REQUEST_DIRECTORY_COUNT);
+ }
+
+ if ((file_attributes & CAJA_FILE_ATTRIBUTE_DEEP_COUNTS) != 0)
+ {
+ REQUEST_SET_TYPE (request, REQUEST_DEEP_COUNT);
+ }
+
+ if ((file_attributes & CAJA_FILE_ATTRIBUTE_DIRECTORY_ITEM_MIME_TYPES) != 0)
+ {
+ REQUEST_SET_TYPE (request, REQUEST_MIME_LIST);
+ }
+ if ((file_attributes & CAJA_FILE_ATTRIBUTE_INFO) != 0)
+ {
+ REQUEST_SET_TYPE (request, REQUEST_FILE_INFO);
+ }
+
+ if (file_attributes & CAJA_FILE_ATTRIBUTE_LINK_INFO)
+ {
+ REQUEST_SET_TYPE (request, REQUEST_FILE_INFO);
+ REQUEST_SET_TYPE (request, REQUEST_LINK_INFO);
+ }
+
+ if (file_attributes & CAJA_FILE_ATTRIBUTE_TOP_LEFT_TEXT)
+ {
+ REQUEST_SET_TYPE (request, REQUEST_TOP_LEFT_TEXT);
+ REQUEST_SET_TYPE (request, REQUEST_FILE_INFO);
+ }
+
+ if (file_attributes & CAJA_FILE_ATTRIBUTE_LARGE_TOP_LEFT_TEXT)
+ {
+ REQUEST_SET_TYPE (request, REQUEST_LARGE_TOP_LEFT_TEXT);
+ REQUEST_SET_TYPE (request, REQUEST_FILE_INFO);
+ }
+
+ if ((file_attributes & CAJA_FILE_ATTRIBUTE_EXTENSION_INFO) != 0)
+ {
+ REQUEST_SET_TYPE (request, REQUEST_EXTENSION_INFO);
+ }
+
+ if (file_attributes & CAJA_FILE_ATTRIBUTE_THUMBNAIL)
+ {
+ REQUEST_SET_TYPE (request, REQUEST_THUMBNAIL);
+ REQUEST_SET_TYPE (request, REQUEST_FILE_INFO);
+ }
+
+ if (file_attributes & CAJA_FILE_ATTRIBUTE_MOUNT)
+ {
+ REQUEST_SET_TYPE (request, REQUEST_MOUNT);
+ REQUEST_SET_TYPE (request, REQUEST_FILE_INFO);
+ }
+
+ if (file_attributes & CAJA_FILE_ATTRIBUTE_FILESYSTEM_INFO)
+ {
+ REQUEST_SET_TYPE (request, REQUEST_FILESYSTEM_INFO);
+ }
+
+ return request;
+}
+
+static void
+mime_db_changed_callback (GObject *ignore, CajaDirectory *dir)
+{
+ CajaFileAttributes attrs;
+
+ g_assert (dir != NULL);
+ g_assert (dir->details != NULL);
+
+ attrs = CAJA_FILE_ATTRIBUTE_INFO |
+ CAJA_FILE_ATTRIBUTE_LINK_INFO |
+ CAJA_FILE_ATTRIBUTE_DIRECTORY_ITEM_MIME_TYPES;
+
+ caja_directory_force_reload_internal (dir, attrs);
+}
+
+void
+caja_directory_monitor_add_internal (CajaDirectory *directory,
+ CajaFile *file,
+ gconstpointer client,
+ gboolean monitor_hidden_files,
+ gboolean monitor_backup_files,
+ CajaFileAttributes file_attributes,
+ CajaDirectoryCallback callback,
+ gpointer callback_data)
+{
+ Monitor *monitor;
+ GList *file_list;
+
+ g_assert (CAJA_IS_DIRECTORY (directory));
+
+ /* Replace any current monitor for this client/file pair. */
+ remove_monitor (directory, file, client);
+
+ /* Add the new monitor. */
+ monitor = g_new (Monitor, 1);
+ monitor->file = file;
+ monitor->monitor_hidden_files = monitor_hidden_files;
+ monitor->monitor_backup_files = monitor_backup_files;
+ monitor->client = client;
+ monitor->request = caja_directory_set_up_request (file_attributes);
+
+ if (file == NULL)
+ {
+ REQUEST_SET_TYPE (monitor->request, REQUEST_FILE_LIST);
+ }
+ directory->details->monitor_list =
+ g_list_prepend (directory->details->monitor_list, monitor);
+ request_counter_add_request (directory->details->monitor_counters,
+ monitor->request);
+
+ if (callback != NULL)
+ {
+ file_list = caja_directory_get_file_list (directory);
+ (* callback) (directory, file_list, callback_data);
+ caja_file_list_free (file_list);
+ }
+
+ /* Start the "real" monitoring (FAM or whatever). */
+ /* We always monitor the whole directory since in practice
+ * caja almost always shows the whole directory anyway, and
+ * it allows us to avoid one file monitor per file in a directory.
+ */
+ if (directory->details->monitor == NULL)
+ {
+ directory->details->monitor = caja_monitor_directory (directory->details->location);
+ }
+
+
+ if (REQUEST_WANTS_TYPE (monitor->request, REQUEST_FILE_INFO) &&
+ directory->details->mime_db_monitor == 0)
+ {
+ directory->details->mime_db_monitor =
+ g_signal_connect_object (caja_signaller_get_current (),
+ "mime_data_changed",
+ G_CALLBACK (mime_db_changed_callback), directory, 0);
+ }
+
+ /* Put the monitor file or all the files on the work queue. */
+ if (file != NULL)
+ {
+ caja_directory_add_file_to_work_queue (directory, file);
+ }
+ else
+ {
+ add_all_files_to_work_queue (directory);
+ }
+
+ /* Kick off I/O. */
+ caja_directory_async_state_changed (directory);
+}
+
+static void
+set_file_unconfirmed (CajaFile *file, gboolean unconfirmed)
+{
+ CajaDirectory *directory;
+
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (unconfirmed == FALSE || unconfirmed == TRUE);
+
+ if (file->details->unconfirmed == unconfirmed)
+ {
+ return;
+ }
+ file->details->unconfirmed = unconfirmed;
+
+ directory = file->details->directory;
+ if (unconfirmed)
+ {
+ directory->details->confirmed_file_count--;
+ }
+ else
+ {
+ directory->details->confirmed_file_count++;
+ }
+}
+
+static gboolean show_hidden_files = TRUE;
+static gboolean show_backup_files = TRUE;
+
+static void
+show_hidden_files_changed_callback (gpointer callback_data)
+{
+ show_hidden_files = eel_preferences_get_boolean (CAJA_PREFERENCES_SHOW_HIDDEN_FILES);
+}
+
+static void
+show_backup_files_changed_callback (gpointer callback_data)
+{
+ show_backup_files = eel_preferences_get_boolean (CAJA_PREFERENCES_SHOW_BACKUP_FILES);
+}
+
+static gboolean
+should_skip_file (CajaDirectory *directory, GFileInfo *info)
+{
+ static gboolean show_hidden_files_changed_callback_installed = FALSE;
+ static gboolean show_backup_files_changed_callback_installed = FALSE;
+
+ /* Add the callback once for the life of our process */
+ if (!show_hidden_files_changed_callback_installed)
+ {
+ eel_preferences_add_callback (CAJA_PREFERENCES_SHOW_HIDDEN_FILES,
+ show_hidden_files_changed_callback,
+ NULL);
+ show_hidden_files_changed_callback_installed = TRUE;
+
+ /* Peek for the first time */
+ show_hidden_files_changed_callback (NULL);
+ }
+
+ /* Add the callback once for the life of our process */
+ if (!show_backup_files_changed_callback_installed)
+ {
+ eel_preferences_add_callback (CAJA_PREFERENCES_SHOW_BACKUP_FILES,
+ show_backup_files_changed_callback,
+ NULL);
+ show_backup_files_changed_callback_installed = TRUE;
+
+ /* Peek for the first time */
+ show_backup_files_changed_callback (NULL);
+ }
+
+ if (!show_hidden_files &&
+ (g_file_info_get_is_hidden (info) ||
+ (directory != NULL && directory->details->hidden_file_hash != NULL &&
+ g_hash_table_lookup (directory->details->hidden_file_hash,
+ g_file_info_get_name (info)) != NULL)))
+ {
+ return TRUE;
+ }
+
+ if (!show_backup_files && g_file_info_get_is_backup (info))
+ {
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+static gboolean
+dequeue_pending_idle_callback (gpointer callback_data)
+{
+ CajaDirectory *directory;
+ GList *pending_file_info;
+ GList *node, *next;
+ CajaFile *file;
+ GList *changed_files, *added_files;
+ GFileInfo *file_info;
+ const char *mimetype, *name;
+ DirectoryLoadState *dir_load_state;
+
+ directory = CAJA_DIRECTORY (callback_data);
+
+ caja_directory_ref (directory);
+
+ directory->details->dequeue_pending_idle_id = 0;
+
+ /* Handle the files in the order we saw them. */
+ pending_file_info = g_list_reverse (directory->details->pending_file_info);
+ directory->details->pending_file_info = NULL;
+
+ /* If we are no longer monitoring, then throw away these. */
+ if (!caja_directory_is_file_list_monitored (directory))
+ {
+ caja_directory_async_state_changed (directory);
+ goto drain;
+ }
+
+ added_files = NULL;
+ changed_files = NULL;
+
+ dir_load_state = directory->details->directory_load_in_progress;
+
+ /* Build a list of CajaFile objects. */
+ for (node = pending_file_info; node != NULL; node = node->next)
+ {
+ file_info = node->data;
+
+ name = g_file_info_get_name (file_info);
+
+ /* Update the file count. */
+ /* FIXME bugzilla.gnome.org 45063: This could count a
+ * file twice if we get it from both load_directory
+ * and from new_files_callback. Not too hard to fix by
+ * moving this into the actual callback instead of
+ * waiting for the idle function.
+ */
+ if (dir_load_state &&
+ !should_skip_file (directory, file_info))
+ {
+ dir_load_state->load_file_count += 1;
+
+ /* Add the MIME type to the set. */
+ mimetype = g_file_info_get_content_type (file_info);
+ if (mimetype != NULL)
+ {
+ istr_set_insert (dir_load_state->load_mime_list_hash,
+ mimetype);
+ }
+ }
+
+ /* check if the file already exists */
+ file = caja_directory_find_file_by_name (directory, name);
+ if (file != NULL)
+ {
+ /* file already exists in dir, check if we still need to
+ * emit file_added or if it changed */
+ set_file_unconfirmed (file, FALSE);
+ if (!file->details->is_added)
+ {
+ /* We consider this newly added even if its in the list.
+ * This can happen if someone called caja_file_get_by_uri()
+ * on a file in the folder before the add signal was
+ * emitted */
+ caja_file_ref (file);
+ file->details->is_added = TRUE;
+ added_files = g_list_prepend (added_files, file);
+ }
+ else if (caja_file_update_info (file, file_info))
+ {
+ /* File changed, notify about the change. */
+ caja_file_ref (file);
+ changed_files = g_list_prepend (changed_files, file);
+ }
+ }
+ else
+ {
+ /* new file, create a caja file object and add it to the list */
+ file = caja_file_new_from_info (directory, file_info);
+ caja_directory_add_file (directory, file);
+ file->details->is_added = TRUE;
+ added_files = g_list_prepend (added_files, file);
+ }
+ }
+
+ /* If we are done loading, then we assume that any unconfirmed
+ * files are gone.
+ */
+ if (directory->details->directory_loaded)
+ {
+ for (node = directory->details->file_list;
+ node != NULL; node = next)
+ {
+ file = CAJA_FILE (node->data);
+ next = node->next;
+
+ if (file->details->unconfirmed)
+ {
+ caja_file_ref (file);
+ changed_files = g_list_prepend (changed_files, file);
+
+ caja_file_mark_gone (file);
+ }
+ }
+ }
+
+ /* Send the changed and added signals. */
+ caja_directory_emit_change_signals (directory, changed_files);
+ caja_file_list_free (changed_files);
+ caja_directory_emit_files_added (directory, added_files);
+ caja_file_list_free (added_files);
+
+ if (directory->details->directory_loaded &&
+ !directory->details->directory_loaded_sent_notification)
+ {
+ /* Send the done_loading signal. */
+ caja_directory_emit_done_loading (directory);
+
+ if (dir_load_state)
+ {
+ file = dir_load_state->load_directory_file;
+
+ file->details->directory_count = dir_load_state->load_file_count;
+ file->details->directory_count_is_up_to_date = TRUE;
+ file->details->got_directory_count = TRUE;
+
+ file->details->got_mime_list = TRUE;
+ file->details->mime_list_is_up_to_date = TRUE;
+ eel_g_list_free_deep (file->details->mime_list);
+ file->details->mime_list = istr_set_get_as_list
+ (dir_load_state->load_mime_list_hash);
+
+ caja_file_changed (file);
+ }
+
+ caja_directory_async_state_changed (directory);
+
+ directory->details->directory_loaded_sent_notification = TRUE;
+ }
+
+drain:
+ eel_g_object_list_free (pending_file_info);
+
+ /* Get the state machine running again. */
+ caja_directory_async_state_changed (directory);
+
+ caja_directory_unref (directory);
+ return FALSE;
+}
+
+void
+caja_directory_schedule_dequeue_pending (CajaDirectory *directory)
+{
+ if (directory->details->dequeue_pending_idle_id == 0)
+ {
+ directory->details->dequeue_pending_idle_id
+ = g_idle_add (dequeue_pending_idle_callback, directory);
+ }
+}
+
+static void
+directory_load_one (CajaDirectory *directory,
+ GFileInfo *info)
+{
+ if (info == NULL)
+ {
+ return;
+ }
+
+ if (g_file_info_get_name (info) == NULL)
+ {
+ char *uri;
+
+ uri = caja_directory_get_uri (directory);
+ g_warning ("Got GFileInfo with NULL name in %s, ignoring. This shouldn't happen unless the gvfs backend is broken.\n", uri);
+ g_free (uri);
+
+ return;
+ }
+
+ /* Arrange for the "loading" part of the work. */
+ g_object_ref (info);
+ directory->details->pending_file_info
+ = g_list_prepend (directory->details->pending_file_info, info);
+ caja_directory_schedule_dequeue_pending (directory);
+}
+
+static void
+directory_load_cancel (CajaDirectory *directory)
+{
+ CajaFile *file;
+ DirectoryLoadState *state;
+
+ state = directory->details->directory_load_in_progress;
+ if (state != NULL)
+ {
+ file = state->load_directory_file;
+ file->details->loading_directory = FALSE;
+ if (file->details->directory != directory)
+ {
+ caja_directory_async_state_changed (file->details->directory);
+ }
+
+ g_cancellable_cancel (state->cancellable);
+ state->directory = NULL;
+ directory->details->directory_load_in_progress = NULL;
+ async_job_end (directory, "file list");
+ }
+}
+
+static gboolean
+remove_callback (gpointer key, gpointer value, gpointer user_data)
+{
+ return TRUE;
+}
+
+static void
+file_list_cancel (CajaDirectory *directory)
+{
+ directory_load_cancel (directory);
+
+ if (directory->details->dequeue_pending_idle_id != 0)
+ {
+ g_source_remove (directory->details->dequeue_pending_idle_id);
+ directory->details->dequeue_pending_idle_id = 0;
+ }
+
+ if (directory->details->pending_file_info != NULL)
+ {
+ eel_g_object_list_free (directory->details->pending_file_info);
+ directory->details->pending_file_info = NULL;
+ }
+
+ if (directory->details->hidden_file_hash)
+ {
+ g_hash_table_foreach_remove (directory->details->hidden_file_hash, remove_callback, NULL);
+ }
+}
+
+static void
+directory_load_done (CajaDirectory *directory,
+ GError *error)
+{
+ GList *node;
+
+ directory->details->directory_loaded = TRUE;
+ directory->details->directory_loaded_sent_notification = FALSE;
+
+ if (error != NULL)
+ {
+ /* The load did not complete successfully. This means
+ * we don't know the status of the files in this directory.
+ * We clear the unconfirmed bit on each file here so that
+ * they won't be marked "gone" later -- we don't know enough
+ * about them to know whether they are really gone.
+ */
+ for (node = directory->details->file_list;
+ node != NULL; node = node->next)
+ {
+ set_file_unconfirmed (CAJA_FILE (node->data), FALSE);
+ }
+
+ caja_directory_emit_load_error (directory, error);
+ }
+
+ /* Call the idle function right away. */
+ if (directory->details->dequeue_pending_idle_id != 0)
+ {
+ g_source_remove (directory->details->dequeue_pending_idle_id);
+ }
+ dequeue_pending_idle_callback (directory);
+
+ directory_load_cancel (directory);
+}
+
+void
+caja_directory_monitor_remove_internal (CajaDirectory *directory,
+ CajaFile *file,
+ gconstpointer client)
+{
+ g_assert (CAJA_IS_DIRECTORY (directory));
+ g_assert (file == NULL || CAJA_IS_FILE (file));
+ g_assert (client != NULL);
+
+ remove_monitor (directory, file, client);
+
+ if (directory->details->monitor != NULL
+ && directory->details->monitor_list == NULL)
+ {
+ caja_monitor_cancel (directory->details->monitor);
+ directory->details->monitor = NULL;
+ }
+
+ /* XXX - do we need to remove anything from the work queue? */
+
+ caja_directory_async_state_changed (directory);
+}
+
+FileMonitors *
+caja_directory_remove_file_monitors (CajaDirectory *directory,
+ CajaFile *file)
+{
+ GList *result, **list, *node, *next;
+ Monitor *monitor;
+
+ g_assert (CAJA_IS_DIRECTORY (directory));
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->directory == directory);
+
+ result = NULL;
+
+ list = &directory->details->monitor_list;
+ for (node = directory->details->monitor_list; node != NULL; node = next)
+ {
+ next = node->next;
+ monitor = node->data;
+
+ if (monitor->file == file)
+ {
+ *list = g_list_remove_link (*list, node);
+ result = g_list_concat (node, result);
+ request_counter_remove_request (directory->details->monitor_counters,
+ monitor->request);
+ }
+ }
+
+ /* XXX - do we need to remove anything from the work queue? */
+
+ caja_directory_async_state_changed (directory);
+
+ return (FileMonitors *) result;
+}
+
+void
+caja_directory_add_file_monitors (CajaDirectory *directory,
+ CajaFile *file,
+ FileMonitors *monitors)
+{
+ GList **list;
+ GList *l;
+ Monitor *monitor;
+
+ g_assert (CAJA_IS_DIRECTORY (directory));
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->directory == directory);
+
+ if (monitors == NULL)
+ {
+ return;
+ }
+
+ for (l = (GList *)monitors; l != NULL; l = l->next)
+ {
+ monitor = l->data;
+ request_counter_add_request (directory->details->monitor_counters,
+ monitor->request);
+ }
+
+ list = &directory->details->monitor_list;
+ *list = g_list_concat (*list, (GList *) monitors);
+
+ caja_directory_add_file_to_work_queue (directory, file);
+
+ caja_directory_async_state_changed (directory);
+}
+
+static int
+ready_callback_key_compare (gconstpointer a, gconstpointer b)
+{
+ const ReadyCallback *callback_a, *callback_b;
+
+ callback_a = a;
+ callback_b = b;
+
+ if (callback_a->file < callback_b->file)
+ {
+ return -1;
+ }
+ if (callback_a->file > callback_b->file)
+ {
+ return 1;
+ }
+ if (callback_a->file == NULL)
+ {
+ /* ANSI C doesn't allow ordered compares of function pointers, so we cast them to
+ * normal pointers to make some overly pedantic compilers (*cough* HP-UX *cough*)
+ * compile this. Of course, on any compiler where ordered function pointers actually
+ * break this probably won't work, but at least it will compile on platforms where it
+ * works, but stupid compilers won't let you use it.
+ */
+ if ((void *)callback_a->callback.directory < (void *)callback_b->callback.directory)
+ {
+ return -1;
+ }
+ if ((void *)callback_a->callback.directory > (void *)callback_b->callback.directory)
+ {
+ return 1;
+ }
+ }
+ else
+ {
+ if ((void *)callback_a->callback.file < (void *)callback_b->callback.file)
+ {
+ return -1;
+ }
+ if ((void *)callback_a->callback.file > (void *)callback_b->callback.file)
+ {
+ return 1;
+ }
+ }
+ if (callback_a->callback_data < callback_b->callback_data)
+ {
+ return -1;
+ }
+ if (callback_a->callback_data > callback_b->callback_data)
+ {
+ return 1;
+ }
+ return 0;
+}
+
+static int
+ready_callback_key_compare_only_active (gconstpointer a, gconstpointer b)
+{
+ const ReadyCallback *callback_a;
+
+ callback_a = a;
+
+ /* Non active callbacks never match */
+ if (!callback_a->active)
+ {
+ return -1;
+ }
+
+ return ready_callback_key_compare (a, b);
+}
+
+static void
+ready_callback_call (CajaDirectory *directory,
+ const ReadyCallback *callback)
+{
+ GList *file_list;
+
+ /* Call the callback. */
+ if (callback->file != NULL)
+ {
+ if (callback->callback.file)
+ {
+ (* callback->callback.file) (callback->file,
+ callback->callback_data);
+ }
+ }
+ else if (callback->callback.directory != NULL)
+ {
+ if (directory == NULL ||
+ !REQUEST_WANTS_TYPE (callback->request, REQUEST_FILE_LIST))
+ {
+ file_list = NULL;
+ }
+ else
+ {
+ file_list = caja_directory_get_file_list (directory);
+ }
+
+ /* Pass back the file list if the user was waiting for it. */
+ (* callback->callback.directory) (directory,
+ file_list,
+ callback->callback_data);
+
+ caja_file_list_free (file_list);
+ }
+}
+
+void
+caja_directory_call_when_ready_internal (CajaDirectory *directory,
+ CajaFile *file,
+ CajaFileAttributes file_attributes,
+ gboolean wait_for_file_list,
+ CajaDirectoryCallback directory_callback,
+ CajaFileCallback file_callback,
+ gpointer callback_data)
+{
+ ReadyCallback callback;
+
+ g_assert (directory == NULL || CAJA_IS_DIRECTORY (directory));
+ g_assert (file == NULL || CAJA_IS_FILE (file));
+ g_assert (file != NULL || directory_callback != NULL);
+
+ /* Construct a callback object. */
+ callback.active = TRUE;
+ callback.file = file;
+ if (file == NULL)
+ {
+ callback.callback.directory = directory_callback;
+ }
+ else
+ {
+ callback.callback.file = file_callback;
+ }
+ callback.callback_data = callback_data;
+ callback.request = caja_directory_set_up_request (file_attributes);
+ if (wait_for_file_list)
+ {
+ REQUEST_SET_TYPE (callback.request, REQUEST_FILE_LIST);
+ }
+
+ /* Handle the NULL case. */
+ if (directory == NULL)
+ {
+ ready_callback_call (NULL, &callback);
+ return;
+ }
+
+ /* Check if the callback is already there. */
+ if (g_list_find_custom (directory->details->call_when_ready_list,
+ &callback,
+ ready_callback_key_compare_only_active) != NULL)
+ {
+ if (file_callback != NULL && directory_callback != NULL)
+ {
+ g_warning ("tried to add a new callback while an old one was pending");
+ }
+ /* NULL callback means, just read it. Conflicts are ok. */
+ return;
+ }
+
+ /* Add the new callback to the list. */
+ directory->details->call_when_ready_list = g_list_prepend
+ (directory->details->call_when_ready_list,
+ g_memdup (&callback, sizeof (callback)));
+ request_counter_add_request (directory->details->call_when_ready_counters,
+ callback.request);
+
+ /* Put the callback file or all the files on the work queue. */
+ if (file != NULL)
+ {
+ caja_directory_add_file_to_work_queue (directory, file);
+ }
+ else
+ {
+ add_all_files_to_work_queue (directory);
+ }
+
+ caja_directory_async_state_changed (directory);
+}
+
+gboolean
+caja_directory_check_if_ready_internal (CajaDirectory *directory,
+ CajaFile *file,
+ CajaFileAttributes file_attributes)
+{
+ Request request;
+
+ g_assert (CAJA_IS_DIRECTORY (directory));
+
+ request = caja_directory_set_up_request (file_attributes);
+ return request_is_satisfied (directory, file, request);
+}
+
+static void
+remove_callback_link_keep_data (CajaDirectory *directory,
+ GList *link)
+{
+ ReadyCallback *callback;
+
+ callback = link->data;
+
+ directory->details->call_when_ready_list = g_list_remove_link
+ (directory->details->call_when_ready_list, link);
+
+ request_counter_remove_request (directory->details->call_when_ready_counters,
+ callback->request);
+ g_list_free_1 (link);
+}
+
+static void
+remove_callback_link (CajaDirectory *directory,
+ GList *link)
+{
+ ReadyCallback *callback;
+
+ callback = link->data;
+ remove_callback_link_keep_data (directory, link);
+ g_free (callback);
+}
+
+void
+caja_directory_cancel_callback_internal (CajaDirectory *directory,
+ CajaFile *file,
+ CajaDirectoryCallback directory_callback,
+ CajaFileCallback file_callback,
+ gpointer callback_data)
+{
+ ReadyCallback callback;
+ GList *node;
+
+ if (directory == NULL)
+ {
+ return;
+ }
+
+ g_assert (CAJA_IS_DIRECTORY (directory));
+ g_assert (file == NULL || CAJA_IS_FILE (file));
+ g_assert (file != NULL || directory_callback != NULL);
+ g_assert (file == NULL || file_callback != NULL);
+
+ /* Construct a callback object. */
+ callback.file = file;
+ if (file == NULL)
+ {
+ callback.callback.directory = directory_callback;
+ }
+ else
+ {
+ callback.callback.file = file_callback;
+ }
+ callback.callback_data = callback_data;
+
+ /* Remove all queued callback from the list (including non-active). */
+ do
+ {
+ node = g_list_find_custom (directory->details->call_when_ready_list,
+ &callback,
+ ready_callback_key_compare);
+ if (node != NULL)
+ {
+ remove_callback_link (directory, node);
+
+ caja_directory_async_state_changed (directory);
+ }
+ }
+ while (node != NULL);
+}
+
+static void
+new_files_state_unref (NewFilesState *state)
+{
+ state->count--;
+
+ if (state->count == 0)
+ {
+ if (state->directory)
+ {
+ state->directory->details->new_files_in_progress =
+ g_list_remove (state->directory->details->new_files_in_progress,
+ state);
+ }
+
+ g_object_unref (state->cancellable);
+ g_free (state);
+ }
+}
+
+static void
+new_files_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ CajaDirectory *directory;
+ GFileInfo *info;
+ NewFilesState *state;
+
+ state = user_data;
+
+ if (state->directory == NULL)
+ {
+ /* Operation was cancelled. Bail out */
+ new_files_state_unref (state);
+ return;
+ }
+
+ directory = caja_directory_ref (state->directory);
+
+ /* Queue up the new file. */
+ info = g_file_query_info_finish (G_FILE (source_object), res, NULL);
+ if (info != NULL)
+ {
+ directory_load_one (directory, info);
+ g_object_unref (info);
+ }
+
+ new_files_state_unref (state);
+
+ caja_directory_unref (directory);
+}
+
+void
+caja_directory_get_info_for_new_files (CajaDirectory *directory,
+ GList *location_list)
+{
+ NewFilesState *state;
+ GFile *location;
+ GList *l;
+
+ if (location_list == NULL)
+ {
+ return;
+ }
+
+ state = g_new (NewFilesState, 1);
+ state->directory = directory;
+ state->cancellable = g_cancellable_new ();
+ state->count = 0;
+
+ for (l = location_list; l != NULL; l = l->next)
+ {
+ location = l->data;
+
+ state->count++;
+
+ g_file_query_info_async (location,
+ CAJA_FILE_DEFAULT_ATTRIBUTES,
+ 0,
+ G_PRIORITY_DEFAULT,
+ state->cancellable,
+ new_files_callback, state);
+ }
+
+ directory->details->new_files_in_progress
+ = g_list_prepend (directory->details->new_files_in_progress,
+ state);
+}
+
+void
+caja_async_destroying_file (CajaFile *file)
+{
+ CajaDirectory *directory;
+ gboolean changed;
+ GList *node, *next;
+ ReadyCallback *callback;
+ Monitor *monitor;
+
+ directory = file->details->directory;
+ changed = FALSE;
+
+ /* Check for callbacks. */
+ for (node = directory->details->call_when_ready_list; node != NULL; node = next)
+ {
+ next = node->next;
+ callback = node->data;
+
+ if (callback->file == file)
+ {
+ /* Client should have cancelled callback. */
+ if (callback->active)
+ {
+ g_warning ("destroyed file has call_when_ready pending");
+ }
+ remove_callback_link (directory, node);
+ changed = TRUE;
+ }
+ }
+
+ /* Check for monitors. */
+ for (node = directory->details->monitor_list; node != NULL; node = next)
+ {
+ next = node->next;
+ monitor = node->data;
+
+ if (monitor->file == file)
+ {
+ /* Client should have removed monitor earlier. */
+ g_warning ("destroyed file still being monitored");
+ remove_monitor_link (directory, node);
+ changed = TRUE;
+ }
+ }
+
+ /* Check if it's a file that's currently being worked on.
+ * If so, make that NULL so it gets canceled right away.
+ */
+ if (directory->details->count_in_progress != NULL &&
+ directory->details->count_in_progress->count_file == file)
+ {
+ directory->details->count_in_progress->count_file = NULL;
+ changed = TRUE;
+ }
+ if (directory->details->deep_count_file == file)
+ {
+ directory->details->deep_count_file = NULL;
+ changed = TRUE;
+ }
+ if (directory->details->mime_list_in_progress != NULL &&
+ directory->details->mime_list_in_progress->mime_list_file == file)
+ {
+ directory->details->mime_list_in_progress->mime_list_file = NULL;
+ changed = TRUE;
+ }
+ if (directory->details->get_info_file == file)
+ {
+ directory->details->get_info_file = NULL;
+ changed = TRUE;
+ }
+ if (directory->details->top_left_read_state != NULL
+ && directory->details->top_left_read_state->file == file)
+ {
+ directory->details->top_left_read_state->file = NULL;
+ changed = TRUE;
+ }
+ if (directory->details->link_info_read_state != NULL &&
+ directory->details->link_info_read_state->file == file)
+ {
+ directory->details->link_info_read_state->file = NULL;
+ changed = TRUE;
+ }
+ if (directory->details->extension_info_file == file)
+ {
+ directory->details->extension_info_file = NULL;
+ changed = TRUE;
+ }
+
+ if (directory->details->thumbnail_state != NULL &&
+ directory->details->thumbnail_state->file == file)
+ {
+ directory->details->thumbnail_state->file = NULL;
+ changed = TRUE;
+ }
+
+ if (directory->details->mount_state != NULL &&
+ directory->details->mount_state->file == file)
+ {
+ directory->details->mount_state->file = NULL;
+ changed = TRUE;
+ }
+
+ if (directory->details->filesystem_info_state != NULL &&
+ directory->details->filesystem_info_state->file == file)
+ {
+ directory->details->filesystem_info_state->file = NULL;
+ changed = TRUE;
+ }
+
+ /* Let the directory take care of the rest. */
+ if (changed)
+ {
+ caja_directory_async_state_changed (directory);
+ }
+}
+
+static gboolean
+lacks_directory_count (CajaFile *file)
+{
+ return !file->details->directory_count_is_up_to_date
+ && caja_file_should_show_directory_item_count (file);
+}
+
+static gboolean
+should_get_directory_count_now (CajaFile *file)
+{
+ return lacks_directory_count (file)
+ && !file->details->loading_directory;
+}
+
+static gboolean
+lacks_top_left (CajaFile *file)
+{
+ return file->details->file_info_is_up_to_date &&
+ !file->details->top_left_text_is_up_to_date
+ && caja_file_should_get_top_left_text (file);
+}
+
+static gboolean
+lacks_large_top_left (CajaFile *file)
+{
+ return file->details->file_info_is_up_to_date &&
+ (!file->details->top_left_text_is_up_to_date ||
+ file->details->got_large_top_left_text != file->details->got_top_left_text)
+ && caja_file_should_get_top_left_text (file);
+}
+static gboolean
+lacks_info (CajaFile *file)
+{
+ return !file->details->file_info_is_up_to_date
+ && !file->details->is_gone;
+}
+
+static gboolean
+lacks_filesystem_info (CajaFile *file)
+{
+ return !file->details->filesystem_info_is_up_to_date;
+}
+
+static gboolean
+lacks_deep_count (CajaFile *file)
+{
+ return file->details->deep_counts_status != CAJA_REQUEST_DONE;
+}
+
+static gboolean
+lacks_mime_list (CajaFile *file)
+{
+ return !file->details->mime_list_is_up_to_date;
+}
+
+static gboolean
+should_get_mime_list (CajaFile *file)
+{
+ return lacks_mime_list (file)
+ && !file->details->loading_directory;
+}
+
+static gboolean
+lacks_link_info (CajaFile *file)
+{
+ if (file->details->file_info_is_up_to_date &&
+ !file->details->link_info_is_up_to_date)
+ {
+ if (caja_file_is_caja_link (file))
+ {
+ return TRUE;
+ }
+ else
+ {
+ link_info_done (file->details->directory, file, NULL, NULL, NULL, FALSE, FALSE);
+ return FALSE;
+ }
+ }
+ else
+ {
+ return FALSE;
+ }
+}
+
+static gboolean
+lacks_extension_info (CajaFile *file)
+{
+ return file->details->pending_info_providers != NULL;
+}
+
+static gboolean
+lacks_thumbnail (CajaFile *file)
+{
+ return caja_file_should_show_thumbnail (file) &&
+ file->details->thumbnail_path != NULL &&
+ !file->details->thumbnail_is_up_to_date;
+}
+
+static gboolean
+lacks_mount (CajaFile *file)
+{
+ return (!file->details->mount_is_up_to_date &&
+ (
+ /* Unix mountpoint, could be a GMount */
+ file->details->is_mountpoint ||
+
+ /* The toplevel directory of something */
+ (file->details->type == G_FILE_TYPE_DIRECTORY &&
+ caja_file_is_self_owned (file)) ||
+
+ /* Mountable, could be a mountpoint */
+ (file->details->type == G_FILE_TYPE_MOUNTABLE)
+
+ )
+ );
+}
+
+static gboolean
+has_problem (CajaDirectory *directory, CajaFile *file, FileCheck problem)
+{
+ GList *node;
+
+ if (file != NULL)
+ {
+ return (* problem) (file);
+ }
+
+ for (node = directory->details->file_list; node != NULL; node = node->next)
+ {
+ if ((* problem) (node->data))
+ {
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+static gboolean
+request_is_satisfied (CajaDirectory *directory,
+ CajaFile *file,
+ Request request)
+{
+ if (REQUEST_WANTS_TYPE (request, REQUEST_FILE_LIST) &&
+ !(directory->details->directory_loaded &&
+ directory->details->directory_loaded_sent_notification))
+ {
+ return FALSE;
+ }
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_DIRECTORY_COUNT))
+ {
+ if (has_problem (directory, file, lacks_directory_count))
+ {
+ return FALSE;
+ }
+ }
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_FILE_INFO))
+ {
+ if (has_problem (directory, file, lacks_info))
+ {
+ return FALSE;
+ }
+ }
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_FILESYSTEM_INFO))
+ {
+ if (has_problem (directory, file, lacks_filesystem_info))
+ {
+ return FALSE;
+ }
+ }
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_TOP_LEFT_TEXT))
+ {
+ if (has_problem (directory, file, lacks_top_left))
+ {
+ return FALSE;
+ }
+ }
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_LARGE_TOP_LEFT_TEXT))
+ {
+ if (has_problem (directory, file, lacks_large_top_left))
+ {
+ return FALSE;
+ }
+ }
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_DEEP_COUNT))
+ {
+ if (has_problem (directory, file, lacks_deep_count))
+ {
+ return FALSE;
+ }
+ }
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_THUMBNAIL))
+ {
+ if (has_problem (directory, file, lacks_thumbnail))
+ {
+ return FALSE;
+ }
+ }
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_MOUNT))
+ {
+ if (has_problem (directory, file, lacks_mount))
+ {
+ return FALSE;
+ }
+ }
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_MIME_LIST))
+ {
+ if (has_problem (directory, file, lacks_mime_list))
+ {
+ return FALSE;
+ }
+ }
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_LINK_INFO))
+ {
+ if (has_problem (directory, file, lacks_link_info))
+ {
+ return FALSE;
+ }
+ }
+
+ return TRUE;
+}
+
+static gboolean
+call_ready_callbacks_at_idle (gpointer callback_data)
+{
+ CajaDirectory *directory;
+ GList *node, *next;
+ ReadyCallback *callback;
+
+ directory = CAJA_DIRECTORY (callback_data);
+ directory->details->call_ready_idle_id = 0;
+
+ caja_directory_ref (directory);
+
+ callback = NULL;
+ while (1)
+ {
+ /* Check if any callbacks are non-active and call them if they are. */
+ for (node = directory->details->call_when_ready_list;
+ node != NULL; node = next)
+ {
+ next = node->next;
+ callback = node->data;
+ if (!callback->active)
+ {
+ /* Non-active, remove and call */
+ break;
+ }
+ }
+ if (node == NULL)
+ {
+ break;
+ }
+
+ /* Callbacks are one-shots, so remove it now. */
+ remove_callback_link_keep_data (directory, node);
+
+ /* Call the callback. */
+ ready_callback_call (directory, callback);
+ g_free (callback);
+ }
+
+ caja_directory_async_state_changed (directory);
+
+ caja_directory_unref (directory);
+
+ return FALSE;
+}
+
+static void
+schedule_call_ready_callbacks (CajaDirectory *directory)
+{
+ if (directory->details->call_ready_idle_id == 0)
+ {
+ directory->details->call_ready_idle_id
+ = g_idle_add (call_ready_callbacks_at_idle, directory);
+ }
+}
+
+/* Marks all callbacks that are ready as non-active and
+ * calls them at idle time, unless they are removed
+ * before then */
+static gboolean
+call_ready_callbacks (CajaDirectory *directory)
+{
+ gboolean found_any;
+ GList *node, *next;
+ ReadyCallback *callback;
+
+ found_any = FALSE;
+
+ /* Check if any callbacks are satisifed and mark them for call them if they are. */
+ for (node = directory->details->call_when_ready_list;
+ node != NULL; node = next)
+ {
+ next = node->next;
+ callback = node->data;
+ if (callback->active &&
+ request_is_satisfied (directory, callback->file, callback->request))
+ {
+ callback->active = FALSE;
+ found_any = TRUE;
+ }
+ }
+
+ if (found_any)
+ {
+ schedule_call_ready_callbacks (directory);
+ }
+
+ return found_any;
+}
+
+gboolean
+caja_directory_has_active_request_for_file (CajaDirectory *directory,
+ CajaFile *file)
+{
+ GList *node;
+ ReadyCallback *callback;
+ Monitor *monitor;
+
+ for (node = directory->details->call_when_ready_list;
+ node != NULL; node = node->next)
+ {
+ callback = node->data;
+ if (callback->file == file ||
+ callback->file == NULL)
+ {
+ return TRUE;
+ }
+ }
+
+ for (node = directory->details->monitor_list;
+ node != NULL; node = node->next)
+ {
+ monitor = node->data;
+ if (monitor->file == file ||
+ monitor->file == NULL)
+ {
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+
+/* This checks if there's a request for monitoring the file list. */
+gboolean
+caja_directory_is_anyone_monitoring_file_list (CajaDirectory *directory)
+{
+ if (directory->details->call_when_ready_counters[REQUEST_FILE_LIST] > 0)
+ {
+ return TRUE;
+ }
+
+ if (directory->details->monitor_counters[REQUEST_FILE_LIST] > 0)
+ {
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+/* This checks if the file list being monitored. */
+gboolean
+caja_directory_is_file_list_monitored (CajaDirectory *directory)
+{
+ return directory->details->file_list_monitored;
+}
+
+static void
+mark_all_files_unconfirmed (CajaDirectory *directory)
+{
+ GList *node;
+ CajaFile *file;
+
+ for (node = directory->details->file_list; node != NULL; node = node->next)
+ {
+ file = node->data;
+ set_file_unconfirmed (file, TRUE);
+ }
+}
+
+static void
+read_dot_hidden_file (CajaDirectory *directory)
+{
+ gsize file_size;
+ char *file_contents;
+ GFile *child;
+ GFileInfo *info;
+ GFileType type;
+ int i;
+
+
+ /* FIXME: We only support .hidden on file: uri's for the moment.
+ * Need to figure out if we should do this async or sync to extend
+ * it to all types of uris.
+ */
+ if (directory->details->location == NULL ||
+ !g_file_is_native (directory->details->location))
+ {
+ return;
+ }
+
+ child = g_file_get_child (directory->details->location, ".hidden");
+
+ type = G_FILE_TYPE_UNKNOWN;
+
+ info = g_file_query_info (child, G_FILE_ATTRIBUTE_STANDARD_TYPE, 0, NULL, NULL);
+ if (info != NULL)
+ {
+ type = g_file_info_get_file_type (info);
+ g_object_unref (info);
+ }
+
+ if (type != G_FILE_TYPE_REGULAR)
+ {
+ g_object_unref (child);
+ return;
+ }
+
+ if (!g_file_load_contents (child, NULL, &file_contents, &file_size, NULL, NULL))
+ {
+ g_object_unref (child);
+ return;
+ }
+
+ g_object_unref (child);
+
+ if (directory->details->hidden_file_hash == NULL)
+ {
+ directory->details->hidden_file_hash =
+ g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+ }
+
+ /* Now parse the data */
+ i = 0;
+ while (i < file_size)
+ {
+ int start;
+
+ start = i;
+ while (i < file_size && file_contents[i] != '\n')
+ {
+ i++;
+ }
+
+ if (i > start)
+ {
+ char *hidden_filename;
+
+ hidden_filename = g_strndup (file_contents + start, i - start);
+ g_hash_table_insert (directory->details->hidden_file_hash,
+ hidden_filename, hidden_filename);
+ }
+
+ i++;
+
+ }
+
+ g_free (file_contents);
+}
+
+static void
+directory_load_state_free (DirectoryLoadState *state)
+{
+ if (state->enumerator)
+ {
+ if (!g_file_enumerator_is_closed (state->enumerator))
+ {
+ g_file_enumerator_close_async (state->enumerator,
+ 0, NULL, NULL, NULL);
+ }
+ g_object_unref (state->enumerator);
+ }
+
+ if (state->load_mime_list_hash != NULL)
+ {
+ istr_set_destroy (state->load_mime_list_hash);
+ }
+ caja_file_unref (state->load_directory_file);
+ g_object_unref (state->cancellable);
+ g_free (state);
+}
+
+static void
+more_files_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ DirectoryLoadState *state;
+ CajaDirectory *directory;
+ GError *error;
+ GList *files, *l;
+ GFileInfo *info;
+
+ state = user_data;
+
+ if (state->directory == NULL)
+ {
+ /* Operation was cancelled. Bail out */
+ directory_load_state_free (state);
+ return;
+ }
+
+ directory = caja_directory_ref (state->directory);
+
+ g_assert (directory->details->directory_load_in_progress != NULL);
+ g_assert (directory->details->directory_load_in_progress == state);
+
+ error = NULL;
+ files = g_file_enumerator_next_files_finish (state->enumerator,
+ res, &error);
+
+ for (l = files; l != NULL; l = l->next)
+ {
+ info = l->data;
+ directory_load_one (directory, info);
+ g_object_unref (info);
+ }
+
+ if (caja_directory_file_list_length_reached (directory) ||
+ files == NULL)
+ {
+ directory_load_done (directory, error);
+ directory_load_state_free (state);
+ }
+ else
+ {
+ g_file_enumerator_next_files_async (state->enumerator,
+ DIRECTORY_LOAD_ITEMS_PER_CALLBACK,
+ G_PRIORITY_DEFAULT,
+ state->cancellable,
+ more_files_callback,
+ state);
+ }
+
+ caja_directory_unref (directory);
+
+ if (error)
+ {
+ g_error_free (error);
+ }
+
+ g_list_free (files);
+}
+
+static void
+enumerate_children_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ DirectoryLoadState *state;
+ GFileEnumerator *enumerator;
+ GError *error;
+
+ state = user_data;
+
+ if (state->directory == NULL)
+ {
+ /* Operation was cancelled. Bail out */
+ directory_load_state_free (state);
+ return;
+ }
+
+ error = NULL;
+ enumerator = g_file_enumerate_children_finish (G_FILE (source_object),
+ res, &error);
+
+ if (enumerator == NULL)
+ {
+ directory_load_done (state->directory, error);
+ g_error_free (error);
+ directory_load_state_free (state);
+ return;
+ }
+ else
+ {
+ state->enumerator = enumerator;
+ g_file_enumerator_next_files_async (state->enumerator,
+ DIRECTORY_LOAD_ITEMS_PER_CALLBACK,
+ G_PRIORITY_DEFAULT,
+ state->cancellable,
+ more_files_callback,
+ state);
+ }
+}
+
+
+/* Start monitoring the file list if it isn't already. */
+static void
+start_monitoring_file_list (CajaDirectory *directory)
+{
+ DirectoryLoadState *state;
+
+ if (!directory->details->file_list_monitored)
+ {
+ g_assert (!directory->details->directory_load_in_progress);
+ directory->details->file_list_monitored = TRUE;
+ caja_file_list_ref (directory->details->file_list);
+ }
+
+ if (directory->details->directory_loaded ||
+ directory->details->directory_load_in_progress != NULL)
+ {
+ return;
+ }
+
+ if (!async_job_start (directory, "file list"))
+ {
+ return;
+ }
+
+ mark_all_files_unconfirmed (directory);
+
+ state = g_new0 (DirectoryLoadState, 1);
+ state->directory = directory;
+ state->cancellable = g_cancellable_new ();
+ state->load_mime_list_hash = istr_set_new ();
+ state->load_file_count = 0;
+
+ g_assert (directory->details->location != NULL);
+ state->load_directory_file =
+ caja_directory_get_corresponding_file (directory);
+ state->load_directory_file->details->loading_directory = TRUE;
+
+ read_dot_hidden_file (directory);
+
+ /* Hack to work around kde trash dir */
+ if (kde_trash_dir_name != NULL && caja_directory_is_desktop_directory (directory))
+ {
+ char *fn;
+
+ if (directory->details->hidden_file_hash == NULL)
+ {
+ directory->details->hidden_file_hash =
+ g_hash_table_new_full (g_str_hash, g_str_equal, g_free, NULL);
+ }
+
+ fn = g_strdup (kde_trash_dir_name);
+ g_hash_table_insert (directory->details->hidden_file_hash,
+ fn, fn);
+ }
+
+
+#ifdef DEBUG_LOAD_DIRECTORY
+ g_message ("load_directory called to monitor file list of %p", directory->details->location);
+#endif
+
+ directory->details->directory_load_in_progress = state;
+
+ g_file_enumerate_children_async (directory->details->location,
+ CAJA_FILE_DEFAULT_ATTRIBUTES,
+ 0, /* flags */
+ G_PRIORITY_DEFAULT, /* prio */
+ state->cancellable,
+ enumerate_children_callback,
+ state);
+}
+
+/* Stop monitoring the file list if it is being monitored. */
+void
+caja_directory_stop_monitoring_file_list (CajaDirectory *directory)
+{
+ if (!directory->details->file_list_monitored)
+ {
+ g_assert (directory->details->directory_load_in_progress == NULL);
+ return;
+ }
+
+ directory->details->file_list_monitored = FALSE;
+ file_list_cancel (directory);
+ caja_file_list_unref (directory->details->file_list);
+ directory->details->directory_loaded = FALSE;
+}
+
+static void
+file_list_start_or_stop (CajaDirectory *directory)
+{
+ if (caja_directory_is_anyone_monitoring_file_list (directory))
+ {
+ start_monitoring_file_list (directory);
+ }
+ else
+ {
+ caja_directory_stop_monitoring_file_list (directory);
+ }
+}
+
+void
+caja_file_invalidate_count_and_mime_list (CajaFile *file)
+{
+ CajaFileAttributes attributes;
+
+ attributes = CAJA_FILE_ATTRIBUTE_DIRECTORY_ITEM_COUNT |
+ CAJA_FILE_ATTRIBUTE_DIRECTORY_ITEM_MIME_TYPES;
+
+ caja_file_invalidate_attributes (file, attributes);
+}
+
+
+/* Reset count and mime list. Invalidating deep counts is handled by
+ * itself elsewhere because it's a relatively heavyweight and
+ * special-purpose operation (see bug 5863). Also, the shallow count
+ * needs to be refreshed when filtering changes, but the deep count
+ * deliberately does not take filtering into account.
+ */
+void
+caja_directory_invalidate_count_and_mime_list (CajaDirectory *directory)
+{
+ CajaFile *file;
+
+ file = caja_directory_get_existing_corresponding_file (directory);
+ if (file != NULL)
+ {
+ caja_file_invalidate_count_and_mime_list (file);
+ }
+
+ caja_file_unref (file);
+}
+
+static void
+caja_directory_invalidate_file_attributes (CajaDirectory *directory,
+ CajaFileAttributes file_attributes)
+{
+ GList *node;
+
+ cancel_loading_attributes (directory, file_attributes);
+
+ for (node = directory->details->file_list; node != NULL; node = node->next)
+ {
+ caja_file_invalidate_attributes_internal (CAJA_FILE (node->data),
+ file_attributes);
+ }
+
+ if (directory->details->as_file != NULL)
+ {
+ caja_file_invalidate_attributes_internal (directory->details->as_file,
+ file_attributes);
+ }
+}
+
+void
+caja_directory_force_reload_internal (CajaDirectory *directory,
+ CajaFileAttributes file_attributes)
+{
+ /* invalidate attributes that are getting reloaded for all files */
+ caja_directory_invalidate_file_attributes (directory, file_attributes);
+
+ /* Start a new directory load. */
+ file_list_cancel (directory);
+ directory->details->directory_loaded = FALSE;
+
+ /* Start a new directory count. */
+ caja_directory_invalidate_count_and_mime_list (directory);
+
+ add_all_files_to_work_queue (directory);
+ caja_directory_async_state_changed (directory);
+}
+
+static gboolean
+monitor_includes_file (const Monitor *monitor,
+ CajaFile *file)
+{
+ if (monitor->file == file)
+ {
+ return TRUE;
+ }
+ if (monitor->file != NULL)
+ {
+ return FALSE;
+ }
+ if (file == file->details->directory->details->as_file)
+ {
+ return FALSE;
+ }
+ return caja_file_should_show (file,
+ monitor->monitor_hidden_files,
+ monitor->monitor_backup_files,
+ TRUE);
+}
+
+static gboolean
+is_needy (CajaFile *file,
+ FileCheck check_missing,
+ RequestType request_type_wanted)
+{
+ CajaDirectory *directory;
+ GList *node;
+ ReadyCallback *callback;
+ Monitor *monitor;
+
+ if (!(* check_missing) (file))
+ {
+ return FALSE;
+ }
+
+ directory = file->details->directory;
+ if (directory->details->call_when_ready_counters[request_type_wanted] > 0)
+ {
+ for (node = directory->details->call_when_ready_list;
+ node != NULL; node = node->next)
+ {
+ callback = node->data;
+ if (callback->active &&
+ REQUEST_WANTS_TYPE (callback->request, request_type_wanted))
+ {
+ if (callback->file == file)
+ {
+ return TRUE;
+ }
+ if (callback->file == NULL
+ && file != directory->details->as_file)
+ {
+ return TRUE;
+ }
+ }
+ }
+ }
+
+ if (directory->details->monitor_counters[request_type_wanted] > 0)
+ {
+ for (node = directory->details->monitor_list;
+ node != NULL; node = node->next)
+ {
+ monitor = node->data;
+ if (REQUEST_WANTS_TYPE (monitor->request, request_type_wanted))
+ {
+ if (monitor_includes_file (monitor, file))
+ {
+ return TRUE;
+ }
+ }
+ }
+ }
+ return FALSE;
+}
+
+static void
+directory_count_stop (CajaDirectory *directory)
+{
+ CajaFile *file;
+
+ if (directory->details->count_in_progress != NULL)
+ {
+ file = directory->details->count_in_progress->count_file;
+ if (file != NULL)
+ {
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->directory == directory);
+ if (is_needy (file,
+ should_get_directory_count_now,
+ REQUEST_DIRECTORY_COUNT))
+ {
+ return;
+ }
+ }
+
+ /* The count is not wanted, so stop it. */
+ directory_count_cancel (directory);
+ }
+}
+
+static guint
+count_non_skipped_files (GList *list)
+{
+ guint count;
+ GList *node;
+ GFileInfo *info;
+
+ count = 0;
+ for (node = list; node != NULL; node = node->next)
+ {
+ info = node->data;
+ if (!should_skip_file (NULL, info))
+ {
+ count += 1;
+ }
+ }
+ return count;
+}
+
+static void
+count_children_done (CajaDirectory *directory,
+ CajaFile *count_file,
+ gboolean succeeded,
+ int count)
+{
+ g_assert (CAJA_IS_FILE (count_file));
+
+ count_file->details->directory_count_is_up_to_date = TRUE;
+
+ /* Record either a failure or success. */
+ if (!succeeded)
+ {
+ count_file->details->directory_count_failed = TRUE;
+ count_file->details->got_directory_count = FALSE;
+ count_file->details->directory_count = 0;
+ }
+ else
+ {
+ count_file->details->directory_count_failed = FALSE;
+ count_file->details->got_directory_count = TRUE;
+ count_file->details->directory_count = count;
+ }
+ directory->details->count_in_progress = NULL;
+
+ /* Send file-changed even if count failed, so interested parties can
+ * distinguish between unknowable and not-yet-known cases.
+ */
+ caja_file_changed (count_file);
+
+ /* Start up the next one. */
+ async_job_end (directory, "directory count");
+ caja_directory_async_state_changed (directory);
+}
+
+static void
+directory_count_state_free (DirectoryCountState *state)
+{
+ if (state->enumerator)
+ {
+ if (!g_file_enumerator_is_closed (state->enumerator))
+ {
+ g_file_enumerator_close_async (state->enumerator,
+ 0, NULL, NULL, NULL);
+ }
+ g_object_unref (state->enumerator);
+ }
+ g_object_unref (state->cancellable);
+ caja_directory_unref (state->directory);
+ g_free (state);
+}
+
+static void
+count_more_files_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ DirectoryCountState *state;
+ CajaDirectory *directory;
+ GError *error;
+ GList *files;
+
+ state = user_data;
+ directory = state->directory;
+
+ if (g_cancellable_is_cancelled (state->cancellable))
+ {
+ /* Operation was cancelled. Bail out */
+ directory->details->count_in_progress = NULL;
+
+ async_job_end (directory, "directory count");
+ caja_directory_async_state_changed (directory);
+
+ directory_count_state_free (state);
+
+ return;
+ }
+
+ g_assert (directory->details->count_in_progress != NULL);
+ g_assert (directory->details->count_in_progress == state);
+
+ error = NULL;
+ files = g_file_enumerator_next_files_finish (state->enumerator,
+ res, &error);
+
+ state->file_count += count_non_skipped_files (files);
+
+ if (files == NULL)
+ {
+ count_children_done (directory, state->count_file,
+ TRUE, state->file_count);
+ directory_count_state_free (state);
+ }
+ else
+ {
+ g_file_enumerator_next_files_async (state->enumerator,
+ DIRECTORY_LOAD_ITEMS_PER_CALLBACK,
+ G_PRIORITY_DEFAULT,
+ state->cancellable,
+ count_more_files_callback,
+ state);
+ }
+
+ eel_g_object_list_free (files);
+
+ if (error)
+ {
+ g_error_free (error);
+ }
+}
+
+static void
+count_children_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ DirectoryCountState *state;
+ GFileEnumerator *enumerator;
+ CajaDirectory *directory;
+ GError *error;
+
+ state = user_data;
+
+ if (g_cancellable_is_cancelled (state->cancellable))
+ {
+ /* Operation was cancelled. Bail out */
+ directory = state->directory;
+ directory->details->count_in_progress = NULL;
+
+ async_job_end (directory, "directory count");
+ caja_directory_async_state_changed (directory);
+
+ directory_count_state_free (state);
+
+ return;
+ }
+
+ error = NULL;
+ enumerator = g_file_enumerate_children_finish (G_FILE (source_object),
+ res, &error);
+
+ if (enumerator == NULL)
+ {
+ count_children_done (state->directory,
+ state->count_file,
+ FALSE, 0);
+ g_error_free (error);
+ directory_count_state_free (state);
+ return;
+ }
+ else
+ {
+ state->enumerator = enumerator;
+ g_file_enumerator_next_files_async (state->enumerator,
+ DIRECTORY_LOAD_ITEMS_PER_CALLBACK,
+ G_PRIORITY_DEFAULT,
+ state->cancellable,
+ count_more_files_callback,
+ state);
+ }
+}
+
+static void
+directory_count_start (CajaDirectory *directory,
+ CajaFile *file,
+ gboolean *doing_io)
+{
+ DirectoryCountState *state;
+ GFile *location;
+
+ if (directory->details->count_in_progress != NULL)
+ {
+ *doing_io = TRUE;
+ return;
+ }
+
+ if (!is_needy (file,
+ should_get_directory_count_now,
+ REQUEST_DIRECTORY_COUNT))
+ {
+ return;
+ }
+ *doing_io = TRUE;
+
+ if (!caja_file_is_directory (file))
+ {
+ file->details->directory_count_is_up_to_date = TRUE;
+ file->details->directory_count_failed = FALSE;
+ file->details->got_directory_count = FALSE;
+
+ caja_directory_async_state_changed (directory);
+ return;
+ }
+
+ if (!async_job_start (directory, "directory count"))
+ {
+ return;
+ }
+
+ /* Start counting. */
+ state = g_new0 (DirectoryCountState, 1);
+ state->count_file = file;
+ state->directory = caja_directory_ref (directory);
+ state->cancellable = g_cancellable_new ();
+
+ directory->details->count_in_progress = state;
+
+ location = caja_file_get_location (file);
+#ifdef DEBUG_LOAD_DIRECTORY
+ {
+ char *uri;
+ uri = g_file_get_uri (location);
+ g_message ("load_directory called to get shallow file count for %s", uri);
+ g_free (uri);
+ }
+#endif
+
+ g_file_enumerate_children_async (location,
+ G_FILE_ATTRIBUTE_STANDARD_NAME ","
+ G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN ","
+ G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP,
+ G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, /* flags */
+ G_PRIORITY_DEFAULT, /* prio */
+ state->cancellable,
+ count_children_callback,
+ state);
+ g_object_unref (location);
+}
+
+static inline gboolean
+seen_inode (DeepCountState *state,
+ GFileInfo *info)
+{
+ guint64 inode, inode2;
+ guint i;
+
+ inode = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_UNIX_INODE);
+
+ if (inode != 0)
+ {
+ for (i = 0; i < state->seen_deep_count_inodes->len; i++)
+ {
+ inode2 = g_array_index (state->seen_deep_count_inodes, guint64, i);
+ if (inode == inode2)
+ {
+ return TRUE;
+ }
+ }
+ }
+
+ return FALSE;
+}
+
+static inline void
+mark_inode_as_seen (DeepCountState *state,
+ GFileInfo *info)
+{
+ guint64 inode;
+
+ inode = g_file_info_get_attribute_uint64 (info, G_FILE_ATTRIBUTE_UNIX_INODE);
+ if (inode != 0)
+ {
+ g_array_append_val (state->seen_deep_count_inodes, inode);
+ }
+}
+
+static void
+deep_count_one (DeepCountState *state,
+ GFileInfo *info)
+{
+ CajaFile *file;
+ GFile *subdir;
+ gboolean is_seen_inode;
+
+ if (should_skip_file (NULL, info))
+ {
+ return;
+ }
+
+ is_seen_inode = seen_inode (state, info);
+ if (!is_seen_inode)
+ {
+ mark_inode_as_seen (state, info);
+ }
+
+ file = state->directory->details->deep_count_file;
+
+ if (g_file_info_get_file_type (info) == G_FILE_TYPE_DIRECTORY)
+ {
+ /* Count the directory. */
+ file->details->deep_directory_count += 1;
+
+ /* Record the fact that we have to descend into this directory. */
+
+ subdir = g_file_get_child (state->deep_count_location, g_file_info_get_name (info));
+ state->deep_count_subdirectories = g_list_prepend
+ (state->deep_count_subdirectories, subdir);
+ }
+ else
+ {
+ /* Even non-regular files count as files. */
+ file->details->deep_file_count += 1;
+ }
+
+ /* Count the size. */
+ if (!is_seen_inode && g_file_info_has_attribute (info, G_FILE_ATTRIBUTE_STANDARD_SIZE))
+ {
+ file->details->deep_size += g_file_info_get_size (info);
+ }
+}
+
+static void
+deep_count_state_free (DeepCountState *state)
+{
+ if (state->enumerator)
+ {
+ if (!g_file_enumerator_is_closed (state->enumerator))
+ {
+ g_file_enumerator_close_async (state->enumerator,
+ 0, NULL, NULL, NULL);
+ }
+ g_object_unref (state->enumerator);
+ }
+ g_object_unref (state->cancellable);
+ if (state->deep_count_location)
+ {
+ g_object_unref (state->deep_count_location);
+ }
+ eel_g_object_list_free (state->deep_count_subdirectories);
+ g_array_free (state->seen_deep_count_inodes, TRUE);
+ g_free (state);
+}
+
+static void
+deep_count_next_dir (DeepCountState *state)
+{
+ GFile *location;
+ CajaFile *file;
+ CajaDirectory *directory;
+ gboolean done;
+
+ directory = state->directory;
+
+ g_object_unref (state->deep_count_location);
+ state->deep_count_location = NULL;
+
+ done = FALSE;
+ file = directory->details->deep_count_file;
+
+ if (state->deep_count_subdirectories != NULL)
+ {
+ /* Work on a new directory. */
+ location = state->deep_count_subdirectories->data;
+ state->deep_count_subdirectories = g_list_remove
+ (state->deep_count_subdirectories, location);
+ deep_count_load (state, location);
+ g_object_unref (location);
+ }
+ else
+ {
+ file->details->deep_counts_status = CAJA_REQUEST_DONE;
+ directory->details->deep_count_file = NULL;
+ directory->details->deep_count_in_progress = NULL;
+ deep_count_state_free (state);
+ done = TRUE;
+ }
+
+ caja_file_updated_deep_count_in_progress (file);
+
+ if (done)
+ {
+ caja_file_changed (file);
+ async_job_end (directory, "deep count");
+ caja_directory_async_state_changed (directory);
+ }
+}
+
+static void
+deep_count_more_files_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ DeepCountState *state;
+ CajaDirectory *directory;
+ GList *files, *l;
+ GFileInfo *info;
+
+ state = user_data;
+
+ if (state->directory == NULL)
+ {
+ /* Operation was cancelled. Bail out */
+ deep_count_state_free (state);
+ return;
+ }
+
+ directory = caja_directory_ref (state->directory);
+
+ g_assert (directory->details->deep_count_in_progress != NULL);
+ g_assert (directory->details->deep_count_in_progress == state);
+
+ files = g_file_enumerator_next_files_finish (state->enumerator,
+ res, NULL);
+
+ for (l = files; l != NULL; l = l->next)
+ {
+ info = l->data;
+ deep_count_one (state, info);
+ g_object_unref (info);
+ }
+
+ if (files == NULL)
+ {
+ g_file_enumerator_close_async (state->enumerator, 0, NULL, NULL, NULL);
+ g_object_unref (state->enumerator);
+ state->enumerator = NULL;
+
+ deep_count_next_dir (state);
+ }
+ else
+ {
+ g_file_enumerator_next_files_async (state->enumerator,
+ DIRECTORY_LOAD_ITEMS_PER_CALLBACK,
+ G_PRIORITY_LOW,
+ state->cancellable,
+ deep_count_more_files_callback,
+ state);
+ }
+
+ g_list_free (files);
+
+ caja_directory_unref (directory);
+}
+
+static void
+deep_count_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ DeepCountState *state;
+ GFileEnumerator *enumerator;
+ CajaFile *file;
+
+ state = user_data;
+
+ if (state->directory == NULL)
+ {
+ /* Operation was cancelled. Bail out */
+ deep_count_state_free (state);
+ return;
+ }
+
+ file = state->directory->details->deep_count_file;
+
+ enumerator = g_file_enumerate_children_finish (G_FILE (source_object), res, NULL);
+
+ if (enumerator == NULL)
+ {
+ file->details->deep_unreadable_count += 1;
+
+ deep_count_next_dir (state);
+ }
+ else
+ {
+ state->enumerator = enumerator;
+ g_file_enumerator_next_files_async (state->enumerator,
+ DIRECTORY_LOAD_ITEMS_PER_CALLBACK,
+ G_PRIORITY_LOW,
+ state->cancellable,
+ deep_count_more_files_callback,
+ state);
+ }
+}
+
+
+static void
+deep_count_load (DeepCountState *state, GFile *location)
+{
+ CajaDirectory *directory;
+
+ directory = state->directory;
+ state->deep_count_location = g_object_ref (location);
+
+#ifdef DEBUG_LOAD_DIRECTORY
+ g_message ("load_directory called to get deep file count for %p", location);
+#endif
+ g_file_enumerate_children_async (state->deep_count_location,
+ G_FILE_ATTRIBUTE_STANDARD_NAME ","
+ G_FILE_ATTRIBUTE_STANDARD_TYPE ","
+ G_FILE_ATTRIBUTE_STANDARD_SIZE ","
+ G_FILE_ATTRIBUTE_STANDARD_IS_HIDDEN ","
+ G_FILE_ATTRIBUTE_STANDARD_IS_BACKUP ","
+ G_FILE_ATTRIBUTE_UNIX_INODE,
+ G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, /* flags */
+ G_PRIORITY_LOW, /* prio */
+ state->cancellable,
+ deep_count_callback,
+ state);
+}
+
+static void
+deep_count_stop (CajaDirectory *directory)
+{
+ CajaFile *file;
+
+ if (directory->details->deep_count_in_progress != NULL)
+ {
+ file = directory->details->deep_count_file;
+ if (file != NULL)
+ {
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->directory == directory);
+ if (is_needy (file,
+ lacks_deep_count,
+ REQUEST_DEEP_COUNT))
+ {
+ return;
+ }
+ }
+
+ /* The count is not wanted, so stop it. */
+ deep_count_cancel (directory);
+ }
+}
+
+static void
+deep_count_start (CajaDirectory *directory,
+ CajaFile *file,
+ gboolean *doing_io)
+{
+ GFile *location;
+ DeepCountState *state;
+
+ if (directory->details->deep_count_in_progress != NULL)
+ {
+ *doing_io = TRUE;
+ return;
+ }
+
+ if (!is_needy (file,
+ lacks_deep_count,
+ REQUEST_DEEP_COUNT))
+ {
+ return;
+ }
+ *doing_io = TRUE;
+
+ if (!caja_file_is_directory (file))
+ {
+ file->details->deep_counts_status = CAJA_REQUEST_DONE;
+
+ caja_directory_async_state_changed (directory);
+ return;
+ }
+
+ if (!async_job_start (directory, "deep count"))
+ {
+ return;
+ }
+
+ /* Start counting. */
+ file->details->deep_counts_status = CAJA_REQUEST_IN_PROGRESS;
+ file->details->deep_directory_count = 0;
+ file->details->deep_file_count = 0;
+ file->details->deep_unreadable_count = 0;
+ file->details->deep_size = 0;
+ directory->details->deep_count_file = file;
+
+ state = g_new0 (DeepCountState, 1);
+ state->directory = directory;
+ state->cancellable = g_cancellable_new ();
+ state->seen_deep_count_inodes = g_array_new (FALSE, TRUE, sizeof (guint64));
+
+ directory->details->deep_count_in_progress = state;
+
+ location = caja_file_get_location (file);
+ deep_count_load (state, location);
+ g_object_unref (location);
+}
+
+static void
+mime_list_stop (CajaDirectory *directory)
+{
+ CajaFile *file;
+
+ if (directory->details->mime_list_in_progress != NULL)
+ {
+ file = directory->details->mime_list_in_progress->mime_list_file;
+ if (file != NULL)
+ {
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->directory == directory);
+ if (is_needy (file,
+ should_get_mime_list,
+ REQUEST_MIME_LIST))
+ {
+ return;
+ }
+ }
+
+ /* The count is not wanted, so stop it. */
+ mime_list_cancel (directory);
+ }
+}
+
+static void
+mime_list_state_free (MimeListState *state)
+{
+ if (state->enumerator)
+ {
+ if (!g_file_enumerator_is_closed (state->enumerator))
+ {
+ g_file_enumerator_close_async (state->enumerator,
+ 0, NULL, NULL, NULL);
+ }
+ g_object_unref (state->enumerator);
+ }
+ g_object_unref (state->cancellable);
+ istr_set_destroy (state->mime_list_hash);
+ caja_directory_unref (state->directory);
+ g_free (state);
+}
+
+
+static void
+mime_list_done (MimeListState *state, gboolean success)
+{
+ CajaFile *file;
+ CajaDirectory *directory;
+
+ directory = state->directory;
+ g_assert (directory != NULL);
+
+ file = state->mime_list_file;
+
+ file->details->mime_list_is_up_to_date = TRUE;
+ eel_g_list_free_deep (file->details->mime_list);
+ if (success)
+ {
+ file->details->mime_list_failed = TRUE;
+ file->details->mime_list = NULL;
+ }
+ else
+ {
+ file->details->got_mime_list = TRUE;
+ file->details->mime_list = istr_set_get_as_list (state->mime_list_hash);
+ }
+ directory->details->mime_list_in_progress = NULL;
+
+ /* Send file-changed even if getting the item type list
+ * failed, so interested parties can distinguish between
+ * unknowable and not-yet-known cases.
+ */
+ caja_file_changed (file);
+
+ /* Start up the next one. */
+ async_job_end (directory, "MIME list");
+ caja_directory_async_state_changed (directory);
+}
+
+static void
+mime_list_one (MimeListState *state,
+ GFileInfo *info)
+{
+ const char *mime_type;
+
+ if (should_skip_file (NULL, info))
+ {
+ g_object_unref (info);
+ return;
+ }
+
+ mime_type = g_file_info_get_content_type (info);
+ if (mime_type != NULL)
+ {
+ istr_set_insert (state->mime_list_hash, mime_type);
+ }
+}
+
+static void
+mime_list_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ MimeListState *state;
+ CajaDirectory *directory;
+ GError *error;
+ GList *files, *l;
+ GFileInfo *info;
+
+ state = user_data;
+ directory = state->directory;
+
+ if (g_cancellable_is_cancelled (state->cancellable))
+ {
+ /* Operation was cancelled. Bail out */
+ directory->details->mime_list_in_progress = NULL;
+
+ async_job_end (directory, "MIME list");
+ caja_directory_async_state_changed (directory);
+
+ mime_list_state_free (state);
+
+ return;
+ }
+
+ g_assert (directory->details->mime_list_in_progress != NULL);
+ g_assert (directory->details->mime_list_in_progress == state);
+
+ error = NULL;
+ files = g_file_enumerator_next_files_finish (state->enumerator,
+ res, &error);
+
+ for (l = files; l != NULL; l = l->next)
+ {
+ info = l->data;
+ mime_list_one (state, info);
+ g_object_unref (info);
+ }
+
+ if (files == NULL)
+ {
+ mime_list_done (state, error != NULL);
+ mime_list_state_free (state);
+ }
+ else
+ {
+ g_file_enumerator_next_files_async (state->enumerator,
+ DIRECTORY_LOAD_ITEMS_PER_CALLBACK,
+ G_PRIORITY_DEFAULT,
+ state->cancellable,
+ mime_list_callback,
+ state);
+ }
+
+ g_list_free (files);
+
+ if (error)
+ {
+ g_error_free (error);
+ }
+}
+
+static void
+list_mime_enum_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ MimeListState *state;
+ GFileEnumerator *enumerator;
+ CajaDirectory *directory;
+ GError *error;
+
+ state = user_data;
+
+ if (g_cancellable_is_cancelled (state->cancellable))
+ {
+ /* Operation was cancelled. Bail out */
+ directory = state->directory;
+ directory->details->mime_list_in_progress = NULL;
+
+ async_job_end (directory, "MIME list");
+ caja_directory_async_state_changed (directory);
+
+ mime_list_state_free (state);
+
+ return;
+ }
+
+ error = NULL;
+ enumerator = g_file_enumerate_children_finish (G_FILE (source_object),
+ res, &error);
+
+ if (enumerator == NULL)
+ {
+ mime_list_done (state, FALSE);
+ g_error_free (error);
+ mime_list_state_free (state);
+ return;
+ }
+ else
+ {
+ state->enumerator = enumerator;
+ g_file_enumerator_next_files_async (state->enumerator,
+ DIRECTORY_LOAD_ITEMS_PER_CALLBACK,
+ G_PRIORITY_DEFAULT,
+ state->cancellable,
+ mime_list_callback,
+ state);
+ }
+}
+
+static void
+mime_list_start (CajaDirectory *directory,
+ CajaFile *file,
+ gboolean *doing_io)
+{
+ MimeListState *state;
+ GFile *location;
+
+ mime_list_stop (directory);
+
+ if (directory->details->mime_list_in_progress != NULL)
+ {
+ *doing_io = TRUE;
+ return;
+ }
+
+ /* Figure out which file to get a mime list for. */
+ if (!is_needy (file,
+ should_get_mime_list,
+ REQUEST_MIME_LIST))
+ {
+ return;
+ }
+ *doing_io = TRUE;
+
+ if (!caja_file_is_directory (file))
+ {
+ g_list_free (file->details->mime_list);
+ file->details->mime_list_failed = FALSE;
+ file->details->got_mime_list = FALSE;
+ file->details->mime_list_is_up_to_date = TRUE;
+
+ caja_directory_async_state_changed (directory);
+ return;
+ }
+
+ if (!async_job_start (directory, "MIME list"))
+ {
+ return;
+ }
+
+
+ state = g_new0 (MimeListState, 1);
+ state->mime_list_file = file;
+ state->directory = caja_directory_ref (directory);
+ state->cancellable = g_cancellable_new ();
+ state->mime_list_hash = istr_set_new ();
+
+ directory->details->mime_list_in_progress = state;
+
+ location = caja_file_get_location (file);
+#ifdef DEBUG_LOAD_DIRECTORY
+ {
+ char *uri;
+ uri = g_file_get_uri (location);
+ g_message ("load_directory called to get MIME list of %s", uri);
+ g_free (uri);
+ }
+#endif
+
+ g_file_enumerate_children_async (location,
+ G_FILE_ATTRIBUTE_STANDARD_CONTENT_TYPE,
+ 0, /* flags */
+ G_PRIORITY_LOW, /* prio */
+ state->cancellable,
+ list_mime_enum_callback,
+ state);
+ g_object_unref (location);
+}
+
+static void
+top_left_stop (CajaDirectory *directory)
+{
+ CajaFile *file;
+
+ if (directory->details->top_left_read_state != NULL)
+ {
+ file = directory->details->top_left_read_state->file;
+ if (file != NULL)
+ {
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->directory == directory);
+ if (is_needy (file,
+ lacks_top_left,
+ REQUEST_TOP_LEFT_TEXT) ||
+ is_needy (file,
+ lacks_large_top_left,
+ REQUEST_LARGE_TOP_LEFT_TEXT))
+ {
+ return;
+ }
+ }
+
+ /* The top left is not wanted, so stop it. */
+ top_left_cancel (directory);
+ }
+}
+
+static void
+top_left_read_state_free (TopLeftTextReadState *state)
+{
+ g_object_unref (state->cancellable);
+ g_free (state);
+}
+
+static void
+top_left_read_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer callback_data)
+{
+ TopLeftTextReadState *state;
+ CajaDirectory *directory;
+ CajaFileDetails *file_details;
+ gsize file_size;
+ char *file_contents;
+
+ state = callback_data;
+
+ if (state->directory == NULL)
+ {
+ /* Operation was cancelled. Bail out */
+ top_left_read_state_free (state);
+ return;
+ }
+
+ directory = caja_directory_ref (state->directory);
+
+ file_details = state->file->details;
+
+ file_details->top_left_text_is_up_to_date = TRUE;
+ g_free (file_details->top_left_text);
+
+ if (g_file_load_partial_contents_finish (G_FILE (source_object),
+ res,
+ &file_contents, &file_size,
+ NULL, NULL))
+ {
+ file_details->top_left_text = caja_extract_top_left_text (file_contents, state->large, file_size);
+ file_details->got_top_left_text = TRUE;
+ file_details->got_large_top_left_text = state->large;
+ g_free (file_contents);
+ }
+ else
+ {
+ file_details->top_left_text = NULL;
+ file_details->got_top_left_text = FALSE;
+ file_details->got_large_top_left_text = FALSE;
+ }
+
+ caja_file_changed (state->file);
+
+ directory->details->top_left_read_state = NULL;
+ async_job_end (directory, "top left");
+
+ top_left_read_state_free (state);
+
+ caja_directory_async_state_changed (directory);
+
+ caja_directory_unref (directory);
+}
+
+static int
+count_lines (const char *text, int length)
+{
+ int count, i;
+
+ count = 0;
+ for (i = 0; i < length; i++)
+ {
+ count += *text++ == '\n';
+ }
+ return count;
+}
+
+static gboolean
+top_left_read_more_callback (const char *file_contents,
+ goffset bytes_read,
+ gpointer callback_data)
+{
+ TopLeftTextReadState *state;
+
+ state = callback_data;
+
+ /* Stop reading when we have enough. */
+ if (state->large)
+ {
+ return bytes_read < CAJA_FILE_LARGE_TOP_LEFT_TEXT_MAXIMUM_BYTES &&
+ count_lines (file_contents, bytes_read) <= CAJA_FILE_LARGE_TOP_LEFT_TEXT_MAXIMUM_LINES;
+ }
+ else
+ {
+ return bytes_read < CAJA_FILE_TOP_LEFT_TEXT_MAXIMUM_BYTES &&
+ count_lines (file_contents, bytes_read) <= CAJA_FILE_TOP_LEFT_TEXT_MAXIMUM_LINES;
+ }
+}
+
+static void
+top_left_start (CajaDirectory *directory,
+ CajaFile *file,
+ gboolean *doing_io)
+{
+ GFile *location;
+ gboolean needs_large;
+ TopLeftTextReadState *state;
+
+ if (directory->details->top_left_read_state != NULL)
+ {
+ *doing_io = TRUE;
+ return;
+ }
+
+ needs_large = FALSE;
+
+ if (is_needy (file,
+ lacks_large_top_left,
+ REQUEST_LARGE_TOP_LEFT_TEXT))
+ {
+ needs_large = TRUE;
+ }
+
+ /* Figure out which file to read the top left for. */
+ if (!(needs_large ||
+ is_needy (file,
+ lacks_top_left,
+ REQUEST_TOP_LEFT_TEXT)))
+ {
+ return;
+ }
+ *doing_io = TRUE;
+
+ if (!caja_file_contains_text (file))
+ {
+ g_free (file->details->top_left_text);
+ file->details->top_left_text = NULL;
+ file->details->got_top_left_text = FALSE;
+ file->details->got_large_top_left_text = FALSE;
+ file->details->top_left_text_is_up_to_date = TRUE;
+
+ caja_directory_async_state_changed (directory);
+ return;
+ }
+
+ if (!async_job_start (directory, "top left"))
+ {
+ return;
+ }
+
+ /* Start reading. */
+ state = g_new0 (TopLeftTextReadState, 1);
+ state->directory = directory;
+ state->cancellable = g_cancellable_new ();
+ state->large = needs_large;
+ state->file = file;
+
+ directory->details->top_left_read_state = state;
+
+ location = caja_file_get_location (file);
+ g_file_load_partial_contents_async (location,
+ state->cancellable,
+ top_left_read_more_callback,
+ top_left_read_callback,
+ state);
+ g_object_unref (location);
+}
+
+static void
+get_info_state_free (GetInfoState *state)
+{
+ g_object_unref (state->cancellable);
+ g_free (state);
+}
+
+static void
+query_info_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ CajaDirectory *directory;
+ CajaFile *get_info_file;
+ GFileInfo *info;
+ GetInfoState *state;
+ GError *error;
+
+ state = user_data;
+
+ if (state->directory == NULL)
+ {
+ /* Operation was cancelled. Bail out */
+ get_info_state_free (state);
+ return;
+ }
+
+ directory = caja_directory_ref (state->directory);
+
+ get_info_file = directory->details->get_info_file;
+ g_assert (CAJA_IS_FILE (get_info_file));
+
+ directory->details->get_info_file = NULL;
+ directory->details->get_info_in_progress = NULL;
+
+ /* ref here because we might be removing the last ref when we
+ * mark the file gone below, but we need to keep a ref at
+ * least long enough to send the change notification.
+ */
+ caja_file_ref (get_info_file);
+
+ error = NULL;
+ info = g_file_query_info_finish (G_FILE (source_object), res, &error);
+
+ if (info == NULL)
+ {
+ if (error->domain == G_IO_ERROR && error->code == G_IO_ERROR_NOT_FOUND)
+ {
+ /* mark file as gone */
+ caja_file_mark_gone (get_info_file);
+ }
+ get_info_file->details->file_info_is_up_to_date = TRUE;
+ caja_file_clear_info (get_info_file);
+ get_info_file->details->get_info_failed = TRUE;
+ get_info_file->details->get_info_error = error;
+ }
+ else
+ {
+ caja_file_update_info (get_info_file, info);
+ g_object_unref (info);
+ }
+
+ caja_file_changed (get_info_file);
+ caja_file_unref (get_info_file);
+
+ async_job_end (directory, "file info");
+ caja_directory_async_state_changed (directory);
+
+ caja_directory_unref (directory);
+
+ get_info_state_free (state);
+}
+
+static void
+file_info_stop (CajaDirectory *directory)
+{
+ CajaFile *file;
+
+ if (directory->details->get_info_in_progress != NULL)
+ {
+ file = directory->details->get_info_file;
+ if (file != NULL)
+ {
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->directory == directory);
+ if (is_needy (file, lacks_info, REQUEST_FILE_INFO))
+ {
+ return;
+ }
+ }
+
+ /* The info is not wanted, so stop it. */
+ file_info_cancel (directory);
+ }
+}
+
+static void
+file_info_start (CajaDirectory *directory,
+ CajaFile *file,
+ gboolean *doing_io)
+{
+ GFile *location;
+ GetInfoState *state;
+
+ file_info_stop (directory);
+
+ if (directory->details->get_info_in_progress != NULL)
+ {
+ *doing_io = TRUE;
+ return;
+ }
+
+ if (!is_needy (file, lacks_info, REQUEST_FILE_INFO))
+ {
+ return;
+ }
+ *doing_io = TRUE;
+
+ if (!async_job_start (directory, "file info"))
+ {
+ return;
+ }
+
+ directory->details->get_info_file = file;
+ file->details->get_info_failed = FALSE;
+ if (file->details->get_info_error)
+ {
+ g_error_free (file->details->get_info_error);
+ file->details->get_info_error = NULL;
+ }
+
+ state = g_new (GetInfoState, 1);
+ state->directory = directory;
+ state->cancellable = g_cancellable_new ();
+
+ directory->details->get_info_in_progress = state;
+
+ location = caja_file_get_location (file);
+ g_file_query_info_async (location,
+ CAJA_FILE_DEFAULT_ATTRIBUTES,
+ 0,
+ G_PRIORITY_DEFAULT,
+ state->cancellable, query_info_callback, state);
+ g_object_unref (location);
+}
+
+static gboolean
+is_link_trusted (CajaFile *file,
+ gboolean is_launcher)
+{
+ GFile *location;
+ gboolean res;
+
+ if (!is_launcher)
+ {
+ return TRUE;
+ }
+
+ if (caja_file_can_execute (file))
+ {
+ return TRUE;
+ }
+
+ res = FALSE;
+
+ if (caja_file_is_local (file))
+ {
+ location = caja_file_get_location (file);
+ res = caja_is_in_system_dir (location);
+ g_object_unref (location);
+ }
+
+ return res;
+}
+
+static void
+link_info_done (CajaDirectory *directory,
+ CajaFile *file,
+ const char *uri,
+ const char *name,
+ const char *icon,
+ gboolean is_launcher,
+ gboolean is_foreign)
+{
+ gboolean is_trusted;
+
+ file->details->link_info_is_up_to_date = TRUE;
+
+ is_trusted = is_link_trusted (file, is_launcher);
+
+ if (is_trusted)
+ {
+ caja_file_set_display_name (file, name, name, TRUE);
+ }
+ else
+ {
+ caja_file_set_display_name (file, NULL, NULL, TRUE);
+ }
+
+ file->details->got_link_info = TRUE;
+ g_free (file->details->custom_icon);
+ file->details->custom_icon = NULL;
+ if (uri)
+ {
+ g_free (file->details->activation_uri);
+ file->details->activation_uri = NULL;
+ file->details->got_custom_activation_uri = TRUE;
+ file->details->activation_uri = g_strdup (uri);
+ }
+ if (is_trusted)
+ {
+ file->details->custom_icon = g_strdup (icon);
+ }
+ file->details->is_launcher = is_launcher;
+ file->details->is_foreign_link = is_foreign;
+ file->details->is_trusted_link = is_trusted;
+
+ caja_directory_async_state_changed (directory);
+}
+
+static gboolean
+should_read_link_info_sync (CajaFile *file)
+{
+#ifdef READ_LOCAL_LINKS_SYNC
+ return (caja_file_is_local (file) && !caja_file_is_directory (file));
+#else
+ return FALSE;
+#endif
+}
+
+static void
+link_info_stop (CajaDirectory *directory)
+{
+ CajaFile *file;
+
+ if (directory->details->link_info_read_state != NULL)
+ {
+ file = directory->details->link_info_read_state->file;
+
+ if (file != NULL)
+ {
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->directory == directory);
+ if (is_needy (file,
+ lacks_link_info,
+ REQUEST_LINK_INFO))
+ {
+ return;
+ }
+ }
+
+ /* The link info is not wanted, so stop it. */
+ link_info_cancel (directory);
+ }
+}
+
+static void
+link_info_got_data (CajaDirectory *directory,
+ CajaFile *file,
+ gboolean result,
+ goffset bytes_read,
+ char *file_contents)
+{
+ char *link_uri, *uri, *name, *icon;
+ gboolean is_launcher;
+ gboolean is_foreign;
+
+ caja_directory_ref (directory);
+
+ uri = NULL;
+ name = NULL;
+ icon = NULL;
+ is_launcher = FALSE;
+ is_foreign = FALSE;
+
+ /* Handle the case where we read the Caja link. */
+ if (result)
+ {
+ link_uri = caja_file_get_uri (file);
+ caja_link_get_link_info_given_file_contents (file_contents, bytes_read, link_uri,
+ &uri, &name, &icon, &is_launcher, &is_foreign);
+ g_free (link_uri);
+ }
+ else
+ {
+ /* FIXME bugzilla.gnome.org 42433: We should report this error to the user. */
+ }
+
+ caja_file_ref (file);
+ link_info_done (directory, file, uri, name, icon, is_launcher, is_foreign);
+ caja_file_changed (file);
+ caja_file_unref (file);
+
+ g_free (uri);
+ g_free (name);
+ g_free (icon);
+
+ caja_directory_unref (directory);
+}
+
+static void
+link_info_read_state_free (LinkInfoReadState *state)
+{
+ g_object_unref (state->cancellable);
+ g_free (state);
+}
+
+static void
+link_info_caja_link_read_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ LinkInfoReadState *state;
+ gsize file_size;
+ char *file_contents;
+ gboolean result;
+ CajaDirectory *directory;
+
+ state = user_data;
+
+ if (state->directory == NULL)
+ {
+ /* Operation was cancelled. Bail out */
+ link_info_read_state_free (state);
+ return;
+ }
+
+ directory = caja_directory_ref (state->directory);
+
+ result = g_file_load_contents_finish (G_FILE (source_object),
+ res,
+ &file_contents, &file_size,
+ NULL, NULL);
+
+ state->directory->details->link_info_read_state = NULL;
+ async_job_end (state->directory, "link info");
+
+ link_info_got_data (state->directory, state->file, result, file_size, file_contents);
+
+ if (result)
+ {
+ g_free (file_contents);
+ }
+
+ link_info_read_state_free (state);
+
+ caja_directory_unref (directory);
+}
+
+static void
+link_info_start (CajaDirectory *directory,
+ CajaFile *file,
+ gboolean *doing_io)
+{
+ GFile *location;
+ gboolean caja_style_link;
+ gsize file_size;
+ char *file_contents;
+ gboolean result;
+ LinkInfoReadState *state;
+
+ if (directory->details->link_info_read_state != NULL)
+ {
+ *doing_io = TRUE;
+ return;
+ }
+
+ if (!is_needy (file,
+ lacks_link_info,
+ REQUEST_LINK_INFO))
+ {
+ return;
+ }
+ *doing_io = TRUE;
+
+ /* Figure out if it is a link. */
+ caja_style_link = caja_file_is_caja_link (file);
+ location = caja_file_get_location (file);
+
+ /* If it's not a link we are done. If it is, we need to read it. */
+ if (!caja_style_link)
+ {
+ link_info_done (directory, file, NULL, NULL, NULL, FALSE, FALSE);
+ }
+ else if (should_read_link_info_sync (file))
+ {
+ result = g_file_load_contents (location, NULL, &file_contents, &file_size, NULL, NULL);
+ link_info_got_data (directory, file, result, file_size, file_contents);
+ g_free (file_contents);
+ }
+ else
+ {
+ if (!async_job_start (directory, "link info"))
+ {
+ g_object_unref (location);
+ return;
+ }
+
+ state = g_new0 (LinkInfoReadState, 1);
+ state->directory = directory;
+ state->file = file;
+ state->cancellable = g_cancellable_new ();
+
+ directory->details->link_info_read_state = state;
+
+ g_file_load_contents_async (location,
+ state->cancellable,
+ link_info_caja_link_read_callback,
+ state);
+ }
+ g_object_unref (location);
+}
+
+static void
+thumbnail_done (CajaDirectory *directory,
+ CajaFile *file,
+ GdkPixbuf *pixbuf,
+ gboolean tried_original)
+{
+ const char *thumb_mtime_str;
+ time_t thumb_mtime = 0;
+
+ file->details->thumbnail_is_up_to_date = TRUE;
+ file->details->thumbnail_tried_original = tried_original;
+ if (file->details->thumbnail)
+ {
+ g_object_unref (file->details->thumbnail);
+ file->details->thumbnail = NULL;
+ }
+ if (pixbuf)
+ {
+ if (tried_original)
+ {
+ thumb_mtime = file->details->mtime;
+ }
+ else
+ {
+ thumb_mtime_str = gdk_pixbuf_get_option (pixbuf, "tEXt::Thumb::MTime");
+ if (thumb_mtime_str)
+ {
+ thumb_mtime = atol (thumb_mtime_str);
+ }
+ }
+
+ if (thumb_mtime == 0 ||
+ thumb_mtime == file->details->mtime)
+ {
+ file->details->thumbnail = g_object_ref (pixbuf);
+ file->details->thumbnail_mtime = thumb_mtime;
+ }
+ else
+ {
+ g_free (file->details->thumbnail_path);
+ file->details->thumbnail_path = NULL;
+ }
+ }
+
+ caja_directory_async_state_changed (directory);
+}
+
+static void
+thumbnail_stop (CajaDirectory *directory)
+{
+ CajaFile *file;
+
+ if (directory->details->thumbnail_state != NULL)
+ {
+ file = directory->details->thumbnail_state->file;
+
+ if (file != NULL)
+ {
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->directory == directory);
+ if (is_needy (file,
+ lacks_thumbnail,
+ REQUEST_THUMBNAIL))
+ {
+ return;
+ }
+ }
+
+ /* The link info is not wanted, so stop it. */
+ thumbnail_cancel (directory);
+ }
+}
+
+static void
+thumbnail_got_pixbuf (CajaDirectory *directory,
+ CajaFile *file,
+ GdkPixbuf *pixbuf,
+ gboolean tried_original)
+{
+ caja_directory_ref (directory);
+
+ caja_file_ref (file);
+ thumbnail_done (directory, file, pixbuf, tried_original);
+ caja_file_changed (file);
+ caja_file_unref (file);
+
+ if (pixbuf)
+ {
+ g_object_unref (pixbuf);
+ }
+
+ caja_directory_unref (directory);
+}
+
+static void
+thumbnail_state_free (ThumbnailState *state)
+{
+ g_object_unref (state->cancellable);
+ g_free (state);
+}
+
+extern int cached_thumbnail_size;
+
+/* scale very large images down to the max. size we need */
+static void
+thumbnail_loader_size_prepared (GdkPixbufLoader *loader,
+ int width,
+ int height,
+ gpointer user_data)
+{
+ int max_thumbnail_size;
+ double aspect_ratio;
+
+ aspect_ratio = ((double) width) / height;
+
+ /* cf. caja_file_get_icon() */
+ max_thumbnail_size = CAJA_ICON_SIZE_LARGEST * cached_thumbnail_size / CAJA_ICON_SIZE_STANDARD;
+ if (MAX (width, height) > max_thumbnail_size)
+ {
+ if (width > height)
+ {
+ width = max_thumbnail_size;
+ height = width / aspect_ratio;
+ }
+ else
+ {
+ height = max_thumbnail_size;
+ width = height * aspect_ratio;
+ }
+
+ gdk_pixbuf_loader_set_size (loader, width, height);
+ }
+}
+
+static GdkPixbuf *
+get_pixbuf_for_content (goffset file_len,
+ char *file_contents)
+{
+ gboolean res;
+ GdkPixbuf *pixbuf, *pixbuf2;
+ GdkPixbufLoader *loader;
+ gsize chunk_len;
+ pixbuf = NULL;
+
+ loader = gdk_pixbuf_loader_new ();
+ g_signal_connect (loader, "size-prepared",
+ G_CALLBACK (thumbnail_loader_size_prepared),
+ NULL);
+
+ /* For some reason we have to write in chunks, or gdk-pixbuf fails */
+ res = TRUE;
+ while (res && file_len > 0)
+ {
+ chunk_len = file_len;
+ res = gdk_pixbuf_loader_write (loader, file_contents, chunk_len, NULL);
+ file_contents += chunk_len;
+ file_len -= chunk_len;
+ }
+ if (res)
+ {
+ res = gdk_pixbuf_loader_close (loader, NULL);
+ }
+ if (res)
+ {
+ pixbuf = g_object_ref (gdk_pixbuf_loader_get_pixbuf (loader));
+ }
+ g_object_unref (G_OBJECT (loader));
+
+ if (pixbuf)
+ {
+ pixbuf2 = gdk_pixbuf_apply_embedded_orientation (pixbuf);
+ g_object_unref (pixbuf);
+ pixbuf = pixbuf2;
+ }
+ return pixbuf;
+}
+
+
+static void
+thumbnail_read_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ ThumbnailState *state;
+ gsize file_size;
+ char *file_contents;
+ gboolean result;
+ CajaDirectory *directory;
+ GdkPixbuf *pixbuf;
+ GFile *location;
+
+ state = user_data;
+
+ if (state->directory == NULL)
+ {
+ /* Operation was cancelled. Bail out */
+ thumbnail_state_free (state);
+ return;
+ }
+
+ directory = caja_directory_ref (state->directory);
+
+ result = g_file_load_contents_finish (G_FILE (source_object),
+ res,
+ &file_contents, &file_size,
+ NULL, NULL);
+
+ pixbuf = NULL;
+ if (result)
+ {
+ pixbuf = get_pixbuf_for_content (file_size, file_contents);
+ g_free (file_contents);
+ }
+
+ if (pixbuf == NULL && state->trying_original)
+ {
+ state->trying_original = FALSE;
+
+ location = g_file_new_for_path (state->file->details->thumbnail_path);
+ g_file_load_contents_async (location,
+ state->cancellable,
+ thumbnail_read_callback,
+ state);
+ g_object_unref (location);
+ }
+ else
+ {
+ state->directory->details->thumbnail_state = NULL;
+ async_job_end (state->directory, "thumbnail");
+
+ thumbnail_got_pixbuf (state->directory, state->file, pixbuf, state->tried_original);
+
+ thumbnail_state_free (state);
+ }
+
+ caja_directory_unref (directory);
+}
+
+static void
+thumbnail_start (CajaDirectory *directory,
+ CajaFile *file,
+ gboolean *doing_io)
+{
+ GFile *location;
+ ThumbnailState *state;
+
+ if (directory->details->thumbnail_state != NULL)
+ {
+ *doing_io = TRUE;
+ return;
+ }
+
+ if (!is_needy (file,
+ lacks_thumbnail,
+ REQUEST_THUMBNAIL))
+ {
+ return;
+ }
+ *doing_io = TRUE;
+
+ if (!async_job_start (directory, "thumbnail"))
+ {
+ return;
+ }
+
+ state = g_new0 (ThumbnailState, 1);
+ state->directory = directory;
+ state->file = file;
+ state->cancellable = g_cancellable_new ();
+
+ if (file->details->thumbnail_wants_original)
+ {
+ state->tried_original = TRUE;
+ state->trying_original = TRUE;
+ location = caja_file_get_location (file);
+ }
+ else
+ {
+ location = g_file_new_for_path (file->details->thumbnail_path);
+ }
+
+ directory->details->thumbnail_state = state;
+
+ g_file_load_contents_async (location,
+ state->cancellable,
+ thumbnail_read_callback,
+ state);
+ g_object_unref (location);
+}
+
+static void
+mount_stop (CajaDirectory *directory)
+{
+ CajaFile *file;
+
+ if (directory->details->mount_state != NULL)
+ {
+ file = directory->details->mount_state->file;
+
+ if (file != NULL)
+ {
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->directory == directory);
+ if (is_needy (file,
+ lacks_mount,
+ REQUEST_MOUNT))
+ {
+ return;
+ }
+ }
+
+ /* The link info is not wanted, so stop it. */
+ mount_cancel (directory);
+ }
+}
+
+static void
+mount_state_free (MountState *state)
+{
+ g_object_unref (state->cancellable);
+ g_free (state);
+}
+
+static void
+got_mount (MountState *state, GMount *mount)
+{
+ CajaDirectory *directory;
+ CajaFile *file;
+
+ directory = caja_directory_ref (state->directory);
+
+ state->directory->details->mount_state = NULL;
+ async_job_end (state->directory, "mount");
+
+ file = caja_file_ref (state->file);
+
+ file->details->mount_is_up_to_date = TRUE;
+ caja_file_set_mount (file, mount);
+
+ caja_directory_async_state_changed (directory);
+ caja_file_changed (file);
+
+ caja_file_unref (file);
+
+ caja_directory_unref (directory);
+
+ mount_state_free (state);
+
+}
+
+static void
+find_enclosing_mount_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ GMount *mount;
+ MountState *state;
+ GFile *location, *root;
+
+ state = user_data;
+ if (state->directory == NULL)
+ {
+ /* Operation was cancelled. Bail out */
+ mount_state_free (state);
+ return;
+ }
+
+ mount = g_file_find_enclosing_mount_finish (G_FILE (source_object),
+ res, NULL);
+
+ if (mount)
+ {
+ root = g_mount_get_root (mount);
+ location = caja_file_get_location (state->file);
+ if (!g_file_equal (location, root))
+ {
+ g_object_unref (mount);
+ mount = NULL;
+ }
+ g_object_unref (root);
+ g_object_unref (location);
+ }
+
+ got_mount (state, mount);
+
+ if (mount)
+ {
+ g_object_unref (mount);
+ }
+}
+
+static GMount *
+get_mount_at (GFile *target)
+{
+ GVolumeMonitor *monitor;
+ GFile *root;
+ GList *mounts, *l;
+ GMount *found;
+
+ monitor = g_volume_monitor_get ();
+ mounts = g_volume_monitor_get_mounts (monitor);
+
+ found = NULL;
+ for (l = mounts; l != NULL; l = l->next)
+ {
+ GMount *mount = G_MOUNT (l->data);
+
+ if (g_mount_is_shadowed (mount))
+ continue;
+
+ root = g_mount_get_root (mount);
+
+ if (g_file_equal (target, root))
+ {
+ found = g_object_ref (mount);
+ break;
+ }
+
+ g_object_unref (root);
+ }
+
+ eel_g_object_list_free (mounts);
+
+ g_object_unref (monitor);
+
+ return found;
+}
+
+static void
+mount_start (CajaDirectory *directory,
+ CajaFile *file,
+ gboolean *doing_io)
+{
+ GFile *location;
+ MountState *state;
+
+ if (directory->details->mount_state != NULL)
+ {
+ *doing_io = TRUE;
+ return;
+ }
+
+ if (!is_needy (file,
+ lacks_mount,
+ REQUEST_MOUNT))
+ {
+ return;
+ }
+ *doing_io = TRUE;
+
+ if (!async_job_start (directory, "mount"))
+ {
+ return;
+ }
+
+ state = g_new0 (MountState, 1);
+ state->directory = directory;
+ state->file = file;
+ state->cancellable = g_cancellable_new ();
+
+ location = caja_file_get_location (file);
+
+ directory->details->mount_state = state;
+
+ if (file->details->type == G_FILE_TYPE_MOUNTABLE)
+ {
+ GFile *target;
+ GMount *mount;
+
+ mount = NULL;
+ target = caja_file_get_activation_location (file);
+ if (target != NULL)
+ {
+ mount = get_mount_at (target);
+ g_object_unref (target);
+ }
+
+ got_mount (state, mount);
+
+ if (mount)
+ {
+ g_object_unref (mount);
+ }
+ }
+ else
+ {
+ g_file_find_enclosing_mount_async (location,
+ G_PRIORITY_DEFAULT,
+ state->cancellable,
+ find_enclosing_mount_callback,
+ state);
+ }
+ g_object_unref (location);
+}
+
+static void
+filesystem_info_cancel (CajaDirectory *directory)
+{
+ if (directory->details->filesystem_info_state != NULL)
+ {
+ g_cancellable_cancel (directory->details->filesystem_info_state->cancellable);
+ directory->details->filesystem_info_state->directory = NULL;
+ directory->details->filesystem_info_state = NULL;
+ async_job_end (directory, "filesystem info");
+ }
+}
+
+static void
+filesystem_info_stop (CajaDirectory *directory)
+{
+ CajaFile *file;
+
+ if (directory->details->filesystem_info_state != NULL)
+ {
+ file = directory->details->filesystem_info_state->file;
+
+ if (file != NULL)
+ {
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->directory == directory);
+ if (is_needy (file,
+ lacks_filesystem_info,
+ REQUEST_FILESYSTEM_INFO))
+ {
+ return;
+ }
+ }
+
+ /* The filesystem info is not wanted, so stop it. */
+ filesystem_info_cancel (directory);
+ }
+}
+
+static void
+filesystem_info_state_free (FilesystemInfoState *state)
+{
+ g_object_unref (state->cancellable);
+ g_free (state);
+}
+
+static void
+got_filesystem_info (FilesystemInfoState *state, GFileInfo *info)
+{
+ CajaDirectory *directory;
+ CajaFile *file;
+
+ /* careful here, info may be NULL */
+
+ directory = caja_directory_ref (state->directory);
+
+ state->directory->details->filesystem_info_state = NULL;
+ async_job_end (state->directory, "filesystem info");
+
+ file = caja_file_ref (state->file);
+
+ file->details->filesystem_info_is_up_to_date = TRUE;
+ if (info != NULL)
+ {
+ file->details->filesystem_use_preview =
+ g_file_info_get_attribute_uint32 (info, G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW);
+ file->details->filesystem_readonly =
+ g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_READONLY);
+ }
+
+ caja_directory_async_state_changed (directory);
+ caja_file_changed (file);
+
+ caja_file_unref (file);
+
+ caja_directory_unref (directory);
+
+ filesystem_info_state_free (state);
+}
+
+static void
+query_filesystem_info_callback (GObject *source_object,
+ GAsyncResult *res,
+ gpointer user_data)
+{
+ GFileInfo *info;
+ FilesystemInfoState *state;
+
+ state = user_data;
+ if (state->directory == NULL)
+ {
+ /* Operation was cancelled. Bail out */
+ filesystem_info_state_free (state);
+ return;
+ }
+
+ info = g_file_query_filesystem_info_finish (G_FILE (source_object), res, NULL);
+
+ got_filesystem_info (state, info);
+
+ if (info != NULL)
+ {
+ g_object_unref (info);
+ }
+}
+
+static void
+filesystem_info_start (CajaDirectory *directory,
+ CajaFile *file,
+ gboolean *doing_io)
+{
+ GFile *location;
+ FilesystemInfoState *state;
+
+ if (directory->details->filesystem_info_state != NULL)
+ {
+ *doing_io = TRUE;
+ return;
+ }
+
+ if (!is_needy (file,
+ lacks_filesystem_info,
+ REQUEST_FILESYSTEM_INFO))
+ {
+ return;
+ }
+ *doing_io = TRUE;
+
+ if (!async_job_start (directory, "filesystem info"))
+ {
+ return;
+ }
+
+ state = g_new0 (FilesystemInfoState, 1);
+ state->directory = directory;
+ state->file = file;
+ state->cancellable = g_cancellable_new ();
+
+ location = caja_file_get_location (file);
+
+ directory->details->filesystem_info_state = state;
+
+ g_file_query_filesystem_info_async (location,
+ G_FILE_ATTRIBUTE_FILESYSTEM_READONLY ","
+ G_FILE_ATTRIBUTE_FILESYSTEM_USE_PREVIEW,
+ G_PRIORITY_DEFAULT,
+ state->cancellable,
+ query_filesystem_info_callback,
+ state);
+ g_object_unref (location);
+}
+
+static void
+extension_info_cancel (CajaDirectory *directory)
+{
+ if (directory->details->extension_info_in_progress != NULL)
+ {
+ if (directory->details->extension_info_idle)
+ {
+ g_source_remove (directory->details->extension_info_idle);
+ }
+ else
+ {
+ caja_info_provider_cancel_update
+ (directory->details->extension_info_provider,
+ directory->details->extension_info_in_progress);
+ }
+
+ directory->details->extension_info_in_progress = NULL;
+ directory->details->extension_info_file = NULL;
+ directory->details->extension_info_provider = NULL;
+ directory->details->extension_info_idle = 0;
+
+ async_job_end (directory, "extension info");
+ }
+}
+
+static void
+extension_info_stop (CajaDirectory *directory)
+{
+ if (directory->details->extension_info_in_progress != NULL)
+ {
+ CajaFile *file;
+
+ file = directory->details->extension_info_file;
+ if (file != NULL)
+ {
+ g_assert (CAJA_IS_FILE (file));
+ g_assert (file->details->directory == directory);
+ if (is_needy (file, lacks_extension_info, REQUEST_EXTENSION_INFO))
+ {
+ return;
+ }
+ }
+
+ /* The info is not wanted, so stop it. */
+ extension_info_cancel (directory);
+ }
+}
+
+static void
+finish_info_provider (CajaDirectory *directory,
+ CajaFile *file,
+ CajaInfoProvider *provider)
+{
+ file->details->pending_info_providers =
+ g_list_remove (file->details->pending_info_providers,
+ provider);
+ g_object_unref (provider);
+
+ caja_directory_async_state_changed (directory);
+
+ if (file->details->pending_info_providers == NULL)
+ {
+ caja_file_info_providers_done (file);
+ }
+}
+
+
+static gboolean
+info_provider_idle_callback (gpointer user_data)
+{
+ InfoProviderResponse *response;
+ CajaDirectory *directory;
+
+ response = user_data;
+ directory = response->directory;
+
+ if (response->handle != directory->details->extension_info_in_progress
+ || response->provider != directory->details->extension_info_provider)
+ {
+ g_warning ("Unexpected plugin response. This probably indicates a bug in a Caja extension: handle=%p", response->handle);
+ }
+ else
+ {
+ CajaFile *file;
+ async_job_end (directory, "extension info");
+
+ file = directory->details->extension_info_file;
+
+ directory->details->extension_info_file = NULL;
+ directory->details->extension_info_provider = NULL;
+ directory->details->extension_info_in_progress = NULL;
+ directory->details->extension_info_idle = 0;
+
+ finish_info_provider (directory, file, response->provider);
+ }
+
+ return FALSE;
+}
+
+static void
+info_provider_callback (CajaInfoProvider *provider,
+ CajaOperationHandle *handle,
+ CajaOperationResult result,
+ gpointer user_data)
+{
+ InfoProviderResponse *response;
+
+ response = g_new0 (InfoProviderResponse, 1);
+ response->provider = provider;
+ response->handle = handle;
+ response->result = result;
+ response->directory = CAJA_DIRECTORY (user_data);
+
+ response->directory->details->extension_info_idle =
+ g_idle_add_full (G_PRIORITY_DEFAULT_IDLE,
+ info_provider_idle_callback, response,
+ g_free);
+}
+
+static void
+extension_info_start (CajaDirectory *directory,
+ CajaFile *file,
+ gboolean *doing_io)
+{
+ CajaInfoProvider *provider;
+ CajaOperationResult result;
+ CajaOperationHandle *handle;
+ GClosure *update_complete;
+
+ if (directory->details->extension_info_in_progress != NULL)
+ {
+ *doing_io = TRUE;
+ return;
+ }
+
+ if (!is_needy (file, lacks_extension_info, REQUEST_EXTENSION_INFO))
+ {
+ return;
+ }
+ *doing_io = TRUE;
+
+ if (!async_job_start (directory, "extension info"))
+ {
+ return;
+ }
+
+ provider = file->details->pending_info_providers->data;
+
+ update_complete = g_cclosure_new (G_CALLBACK (info_provider_callback),
+ directory,
+ NULL);
+ g_closure_set_marshal (update_complete,
+ caja_marshal_VOID__POINTER_ENUM);
+
+ result = caja_info_provider_update_file_info
+ (provider,
+ CAJA_FILE_INFO (file),
+ update_complete,
+ &handle);
+
+ g_closure_unref (update_complete);
+
+ if (result == CAJA_OPERATION_COMPLETE ||
+ result == CAJA_OPERATION_FAILED)
+ {
+ finish_info_provider (directory, file, provider);
+ async_job_end (directory, "extension info");
+ }
+ else
+ {
+ directory->details->extension_info_in_progress = handle;
+ directory->details->extension_info_provider = provider;
+ directory->details->extension_info_file = file;
+ }
+}
+
+static void
+start_or_stop_io (CajaDirectory *directory)
+{
+ CajaFile *file;
+ gboolean doing_io;
+
+ /* Start or stop reading files. */
+ file_list_start_or_stop (directory);
+
+ /* Stop any no longer wanted attribute fetches. */
+ file_info_stop (directory);
+ directory_count_stop (directory);
+ deep_count_stop (directory);
+ mime_list_stop (directory);
+ top_left_stop (directory);
+ link_info_stop (directory);
+ extension_info_stop (directory);
+ mount_stop (directory);
+ thumbnail_stop (directory);
+ filesystem_info_stop (directory);
+
+ doing_io = FALSE;
+ /* Take files that are all done off the queue. */
+ while (!caja_file_queue_is_empty (directory->details->high_priority_queue))
+ {
+ file = caja_file_queue_head (directory->details->high_priority_queue);
+
+ /* Start getting attributes if possible */
+ file_info_start (directory, file, &doing_io);
+ link_info_start (directory, file, &doing_io);
+
+ if (doing_io)
+ {
+ return;
+ }
+
+ move_file_to_low_priority_queue (directory, file);
+ }
+
+ /* High priority queue must be empty */
+ while (!caja_file_queue_is_empty (directory->details->low_priority_queue))
+ {
+ file = caja_file_queue_head (directory->details->low_priority_queue);
+
+ /* Start getting attributes if possible */
+ mount_start (directory, file, &doing_io);
+ directory_count_start (directory, file, &doing_io);
+ deep_count_start (directory, file, &doing_io);
+ mime_list_start (directory, file, &doing_io);
+ top_left_start (directory, file, &doing_io);
+ thumbnail_start (directory, file, &doing_io);
+ filesystem_info_start (directory, file, &doing_io);
+
+ if (doing_io)
+ {
+ return;
+ }
+
+ move_file_to_extension_queue (directory, file);
+ }
+
+ /* Low priority queue must be empty */
+ while (!caja_file_queue_is_empty (directory->details->extension_queue))
+ {
+ file = caja_file_queue_head (directory->details->extension_queue);
+
+ /* Start getting attributes if possible */
+ extension_info_start (directory, file, &doing_io);
+ if (doing_io)
+ {
+ return;
+ }
+
+ caja_directory_remove_file_from_work_queue (directory, file);
+ }
+}
+
+/* Call this when the monitor or call when ready list changes,
+ * or when some I/O is completed.
+ */
+void
+caja_directory_async_state_changed (CajaDirectory *directory)
+{
+ /* Check if any callbacks are satisfied and call them if they
+ * are. Do this last so that any changes done in start or stop
+ * I/O functions immediately (not in callbacks) are taken into
+ * consideration. If any callbacks are called, consider the
+ * I/O state again so that we can release or cancel I/O that
+ * is not longer needed once the callbacks are satisfied.
+ */
+
+ if (directory->details->in_async_service_loop)
+ {
+ directory->details->state_changed = TRUE;
+ return;
+ }
+ directory->details->in_async_service_loop = TRUE;
+ caja_directory_ref (directory);
+ do
+ {
+ directory->details->state_changed = FALSE;
+ start_or_stop_io (directory);
+ if (call_ready_callbacks (directory))
+ {
+ directory->details->state_changed = TRUE;
+ }
+ }
+ while (directory->details->state_changed);
+ directory->details->in_async_service_loop = FALSE;
+ caja_directory_unref (directory);
+
+ /* Check if any directories should wake up. */
+ async_job_wake_up ();
+}
+
+void
+caja_directory_cancel (CajaDirectory *directory)
+{
+ /* Arbitrary order (kept alphabetical). */
+ deep_count_cancel (directory);
+ directory_count_cancel (directory);
+ file_info_cancel (directory);
+ file_list_cancel (directory);
+ link_info_cancel (directory);
+ mime_list_cancel (directory);
+ new_files_cancel (directory);
+ top_left_cancel (directory);
+ extension_info_cancel (directory);
+ thumbnail_cancel (directory);
+ mount_cancel (directory);
+ filesystem_info_cancel (directory);
+
+ /* We aren't waiting for anything any more. */
+ if (waiting_directories != NULL)
+ {
+ g_hash_table_remove (waiting_directories, directory);
+ }
+
+ /* Check if any directories should wake up. */
+ async_job_wake_up ();
+}
+
+static void
+cancel_directory_count_for_file (CajaDirectory *directory,
+ CajaFile *file)
+{
+ if (directory->details->count_in_progress != NULL &&
+ directory->details->count_in_progress->count_file == file)
+ {
+ directory_count_cancel (directory);
+ }
+}
+
+static void
+cancel_deep_counts_for_file (CajaDirectory *directory,
+ CajaFile *file)
+{
+ if (directory->details->deep_count_file == file)
+ {
+ deep_count_cancel (directory);
+ }
+}
+
+static void
+cancel_mime_list_for_file (CajaDirectory *directory,
+ CajaFile *file)
+{
+ if (directory->details->mime_list_in_progress != NULL &&
+ directory->details->mime_list_in_progress->mime_list_file == file)
+ {
+ mime_list_cancel (directory);
+ }
+}
+
+static void
+cancel_top_left_text_for_file (CajaDirectory *directory,
+ CajaFile *file)
+{
+ if (directory->details->top_left_read_state != NULL &&
+ directory->details->top_left_read_state->file == file)
+ {
+ top_left_cancel (directory);
+ }
+}
+
+static void
+cancel_file_info_for_file (CajaDirectory *directory,
+ CajaFile *file)
+{
+ if (directory->details->get_info_file == file)
+ {
+ file_info_cancel (directory);
+ }
+}
+
+static void
+cancel_thumbnail_for_file (CajaDirectory *directory,
+ CajaFile *file)
+{
+ if (directory->details->thumbnail_state != NULL &&
+ directory->details->thumbnail_state->file == file)
+ {
+ thumbnail_cancel (directory);
+ }
+}
+
+static void
+cancel_mount_for_file (CajaDirectory *directory,
+ CajaFile *file)
+{
+ if (directory->details->mount_state != NULL &&
+ directory->details->mount_state->file == file)
+ {
+ mount_cancel (directory);
+ }
+}
+
+static void
+cancel_filesystem_info_for_file (CajaDirectory *directory,
+ CajaFile *file)
+{
+ if (directory->details->filesystem_info_state != NULL &&
+ directory->details->filesystem_info_state->file == file)
+ {
+ filesystem_info_cancel (directory);
+ }
+}
+
+static void
+cancel_link_info_for_file (CajaDirectory *directory,
+ CajaFile *file)
+{
+ if (directory->details->link_info_read_state != NULL &&
+ directory->details->link_info_read_state->file == file)
+ {
+ link_info_cancel (directory);
+ }
+}
+
+
+static void
+cancel_loading_attributes (CajaDirectory *directory,
+ CajaFileAttributes file_attributes)
+{
+ Request request;
+
+ request = caja_directory_set_up_request (file_attributes);
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_DIRECTORY_COUNT))
+ {
+ directory_count_cancel (directory);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_DEEP_COUNT))
+ {
+ deep_count_cancel (directory);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_MIME_LIST))
+ {
+ mime_list_cancel (directory);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_TOP_LEFT_TEXT))
+ {
+ top_left_cancel (directory);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_FILE_INFO))
+ {
+ file_info_cancel (directory);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_FILESYSTEM_INFO))
+ {
+ filesystem_info_cancel (directory);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_LINK_INFO))
+ {
+ link_info_cancel (directory);
+ }
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_EXTENSION_INFO))
+ {
+ extension_info_cancel (directory);
+ }
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_THUMBNAIL))
+ {
+ thumbnail_cancel (directory);
+ }
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_MOUNT))
+ {
+ mount_cancel (directory);
+ }
+
+ caja_directory_async_state_changed (directory);
+}
+
+void
+caja_directory_cancel_loading_file_attributes (CajaDirectory *directory,
+ CajaFile *file,
+ CajaFileAttributes file_attributes)
+{
+ Request request;
+
+ caja_directory_remove_file_from_work_queue (directory, file);
+
+ request = caja_directory_set_up_request (file_attributes);
+
+ if (REQUEST_WANTS_TYPE (request, REQUEST_DIRECTORY_COUNT))
+ {
+ cancel_directory_count_for_file (directory, file);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_DEEP_COUNT))
+ {
+ cancel_deep_counts_for_file (directory, file);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_MIME_LIST))
+ {
+ cancel_mime_list_for_file (directory, file);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_TOP_LEFT_TEXT))
+ {
+ cancel_top_left_text_for_file (directory, file);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_FILE_INFO))
+ {
+ cancel_file_info_for_file (directory, file);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_FILESYSTEM_INFO))
+ {
+ cancel_filesystem_info_for_file (directory, file);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_LINK_INFO))
+ {
+ cancel_link_info_for_file (directory, file);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_THUMBNAIL))
+ {
+ cancel_thumbnail_for_file (directory, file);
+ }
+ if (REQUEST_WANTS_TYPE (request, REQUEST_MOUNT))
+ {
+ cancel_mount_for_file (directory, file);
+ }
+
+ caja_directory_async_state_changed (directory);
+}
+
+void
+caja_directory_add_file_to_work_queue (CajaDirectory *directory,
+ CajaFile *file)
+{
+ g_return_if_fail (file->details->directory == directory);
+
+ caja_file_queue_enqueue (directory->details->high_priority_queue,
+ file);
+}
+
+
+static void
+add_all_files_to_work_queue (CajaDirectory *directory)
+{
+ GList *node;
+ CajaFile *file;
+
+ for (node = directory->details->file_list; node != NULL; node = node->next)
+ {
+ file = CAJA_FILE (node->data);
+
+ caja_directory_add_file_to_work_queue (directory, file);
+ }
+}
+
+void
+caja_directory_remove_file_from_work_queue (CajaDirectory *directory,
+ CajaFile *file)
+{
+ caja_file_queue_remove (directory->details->high_priority_queue,
+ file);
+ caja_file_queue_remove (directory->details->low_priority_queue,
+ file);
+ caja_file_queue_remove (directory->details->extension_queue,
+ file);
+}
+
+
+static void
+move_file_to_low_priority_queue (CajaDirectory *directory,
+ CajaFile *file)
+{
+ /* Must add before removing to avoid ref underflow */
+ caja_file_queue_enqueue (directory->details->low_priority_queue,
+ file);
+ caja_file_queue_remove (directory->details->high_priority_queue,
+ file);
+}
+
+static void
+move_file_to_extension_queue (CajaDirectory *directory,
+ CajaFile *file)
+{
+ /* Must add before removing to avoid ref underflow */
+ caja_file_queue_enqueue (directory->details->extension_queue,
+ file);
+ caja_file_queue_remove (directory->details->low_priority_queue,
+ file);
+}