diff options
Diffstat (limited to '')
| -rw-r--r-- | src/nautilus-directory-async.c | 4755 |
1 files changed, 4755 insertions, 0 deletions
diff --git a/src/nautilus-directory-async.c b/src/nautilus-directory-async.c new file mode 100644 index 0000000..3e7f421 --- /dev/null +++ b/src/nautilus-directory-async.c @@ -0,0 +1,4755 @@ +/* + * nautilus-directory-async.c: Nautilus 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, see <http://www.gnu.org/licenses/>. + * + * Author: Darin Adler <darin@bentspoon.com> + */ + +#include <libxml/parser.h> +#include <stdio.h> +#include <stdlib.h> + +#define DEBUG_FLAG NAUTILUS_DEBUG_ASYNC_JOBS + +#include "nautilus-debug.h" +#include "nautilus-directory-notify.h" +#include "nautilus-directory-private.h" +#include "nautilus-enums.h" +#include "nautilus-file-private.h" +#include "nautilus-file-queue.h" +#include "nautilus-global-preferences.h" +#include "nautilus-metadata.h" +#include "nautilus-profile.h" +#include "nautilus-signaller.h" + +/* turn this on to check if async. job calls are balanced */ +#if 0 +#define DEBUG_ASYNC_JOBS +#endif + +#define DIRECTORY_LOAD_ITEMS_PER_CALLBACK 100 + +/* Keep async. jobs down to this number for all directories. */ +#define MAX_ASYNC_JOBS 10 + +struct ThumbnailState +{ + NautilusDirectory *directory; + GCancellable *cancellable; + NautilusFile *file; +}; + +struct MountState +{ + NautilusDirectory *directory; + GCancellable *cancellable; + NautilusFile *file; +}; + +struct FilesystemInfoState +{ + NautilusDirectory *directory; + GCancellable *cancellable; + NautilusFile *file; +}; + +struct DirectoryLoadState +{ + NautilusDirectory *directory; + GCancellable *cancellable; + GFileEnumerator *enumerator; + GHashTable *load_mime_list_hash; + NautilusFile *load_directory_file; + int load_file_count; +}; + +struct MimeListState +{ + NautilusDirectory *directory; + NautilusFile *mime_list_file; + GCancellable *cancellable; + GFileEnumerator *enumerator; + GHashTable *mime_list_hash; +}; + +struct GetInfoState +{ + NautilusDirectory *directory; + GCancellable *cancellable; +}; + +struct NewFilesState +{ + NautilusDirectory *directory; + GCancellable *cancellable; + int count; +}; + +struct DirectoryCountState +{ + NautilusDirectory *directory; + NautilusFile *count_file; + GCancellable *cancellable; + GFileEnumerator *enumerator; + int file_count; +}; + +struct DeepCountState +{ + NautilusDirectory *directory; + GCancellable *cancellable; + GFileEnumerator *enumerator; + GFile *deep_count_location; + GList *deep_count_subdirectories; + GArray *seen_deep_count_inodes; + char *fs_id; +}; + + + +typedef struct +{ + NautilusFile *file; /* Which file, NULL means all. */ + union + { + NautilusDirectoryCallback directory; + NautilusFileCallback 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 +{ + NautilusFile *file; /* Which file, NULL means all. */ + gboolean monitor_hidden_files; /* defines whether "all" includes hidden files */ + gconstpointer client; + Request request; +} Monitor; + +typedef struct +{ + NautilusDirectory *directory; + NautilusInfoProvider *provider; + NautilusOperationHandle *handle; + NautilusOperationResult result; +} InfoProviderResponse; + +typedef gboolean (*RequestCheck) (Request); +typedef gboolean (*FileCheck) (NautilusFile *); + +/* Current number of async. jobs. */ +static int async_job_count; +static GHashTable *waiting_directories; +#ifdef DEBUG_ASYNC_JOBS +static GHashTable *async_jobs; +#endif + +/* Forward declarations for functions that need them. */ +static void deep_count_load (DeepCountState *state, + GFile *location); +static gboolean request_is_satisfied (NautilusDirectory *directory, + NautilusFile *file, + Request request); +static void cancel_loading_attributes (NautilusDirectory *directory, + NautilusFileAttributes file_attributes); +static void add_all_files_to_work_queue (NautilusDirectory *directory); +static void move_file_to_low_priority_queue (NautilusDirectory *directory, + NautilusFile *file); +static void move_file_to_extension_queue (NautilusDirectory *directory, + NautilusFile *file); +static void nautilus_directory_invalidate_file_attributes (NautilusDirectory *directory, + NautilusFileAttributes file_attributes); + +/* Some helpers for case-insensitive strings. + * Move to nautilus-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 +nautilus_directory_verify_request_counts (NautilusDirectory *directory) +{ + GList *l; + RequestCounter counters; + int i; + gboolean fail; + GHashTableIter monitor_iter; + gpointer value; + + fail = FALSE; + for (i = 0; i < REQUEST_TYPE_LAST; i++) + { + counters[i] = 0; + } + g_hash_table_iter_init (&monitor_iter, directory->details->monitor_table); + while (g_hash_table_iter_next (&monitor_iter, NULL, &value)) + { + for (l = value; l; 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 (NautilusDirectory *directory, + const char *job) +{ +#ifdef DEBUG_ASYNC_JOBS + char *key; +#endif + + DEBUG ("starting %s in %p", job, directory->details->location); + + 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 = g_hash_table_new (NULL, NULL); + } + + g_hash_table_insert (waiting_directories, + directory, + directory); + + return FALSE; + } + +#ifdef DEBUG_ASYNC_JOBS + { + char *uri; + if (async_jobs == NULL) + { + async_jobs = g_hash_table_new (g_str_hash, g_str_equal); + } + uri = nautilus_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 (NautilusDirectory *directory, + const char *job) +{ +#ifdef DEBUG_ASYNC_JOBS + char *key; + gpointer table_key, value; +#endif + + DEBUG ("stopping %s in %p", job, directory->details->location); + + g_assert (async_job_count > 0); + +#ifdef DEBUG_ASYNC_JOBS + { + char *uri; + uri = nautilus_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); + nautilus_directory_async_state_changed + (NAUTILUS_DIRECTORY (value)); + } + already_waking_up = FALSE; +} + +static void +directory_count_cancel (NautilusDirectory *directory) +{ + if (directory->details->count_in_progress != NULL) + { + g_cancellable_cancel (directory->details->count_in_progress->cancellable); + directory->details->count_in_progress = NULL; + } +} + +static void +deep_count_cancel (NautilusDirectory *directory) +{ + if (directory->details->deep_count_in_progress != NULL) + { + g_assert (NAUTILUS_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 = NAUTILUS_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 (NautilusDirectory *directory) +{ + if (directory->details->mime_list_in_progress != NULL) + { + g_cancellable_cancel (directory->details->mime_list_in_progress->cancellable); + } +} + +static void +thumbnail_cancel (NautilusDirectory *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 (NautilusDirectory *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 (NautilusDirectory *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 (NautilusDirectory *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 Monitor * +find_monitor (NautilusDirectory *directory, + NautilusFile *file, + gconstpointer client) +{ + GList *l; + + l = g_hash_table_lookup (directory->details->monitor_table, file); + + if (l) + { + Monitor key = {}; + key.client = client; + key.file = file; + + l = g_list_find_custom (l, &key, monitor_key_compare); + return l ? l->data : NULL; + } + + return NULL; +} + +static gboolean +insert_new_monitor (NautilusDirectory *directory, + Monitor *monitor) +{ + GList *list; + + if (find_monitor (directory, monitor->file, monitor->client) != NULL) + { + return FALSE; + } + + list = g_hash_table_lookup (directory->details->monitor_table, monitor->file); + if (list == NULL) + { + list = g_list_append (list, monitor); + g_hash_table_insert (directory->details->monitor_table, + monitor->file, + list); + } + else + { + list = g_list_append (list, monitor); + } + + request_counter_add_request (directory->details->monitor_counters, + monitor->request); + return TRUE; +} + +static Monitor * +remove_monitor_from_table (NautilusDirectory *directory, + NautilusFile *file, + gconstpointer client) +{ + GList *list, *l, *new_list; + Monitor *monitor = NULL; + + list = g_hash_table_lookup (directory->details->monitor_table, file); + if (list) + { + Monitor key = {}; + key.client = client; + key.file = file; + + l = g_list_find_custom (list, &key, monitor_key_compare); + monitor = l ? l->data : NULL; + } + + if (monitor != NULL) + { + new_list = g_list_delete_link (list, l); + if (new_list == NULL) + { + g_hash_table_remove (directory->details->monitor_table, file); + } + else + { + g_hash_table_replace (directory->details->monitor_table, file, new_list); + } + } + + return monitor; +} + +static void +remove_monitor (NautilusDirectory *directory, + NautilusFile *file, + gconstpointer client) +{ + Monitor *monitor; + + monitor = remove_monitor_from_table (directory, file, client); + + if (monitor != NULL) + { + request_counter_remove_request (directory->details->monitor_counters, + monitor->request); + g_free (monitor); + } +} + +Request +nautilus_directory_set_up_request (NautilusFileAttributes file_attributes) +{ + Request request; + + request = 0; + + if ((file_attributes & NAUTILUS_FILE_ATTRIBUTE_DIRECTORY_ITEM_COUNT) != 0) + { + REQUEST_SET_TYPE (request, REQUEST_DIRECTORY_COUNT); + } + + if ((file_attributes & NAUTILUS_FILE_ATTRIBUTE_DEEP_COUNTS) != 0) + { + REQUEST_SET_TYPE (request, REQUEST_DEEP_COUNT); + } + + if ((file_attributes & NAUTILUS_FILE_ATTRIBUTE_DIRECTORY_ITEM_MIME_TYPES) != 0) + { + REQUEST_SET_TYPE (request, REQUEST_MIME_LIST); + } + if ((file_attributes & NAUTILUS_FILE_ATTRIBUTE_INFO) != 0) + { + REQUEST_SET_TYPE (request, REQUEST_FILE_INFO); + } + + if ((file_attributes & NAUTILUS_FILE_ATTRIBUTE_EXTENSION_INFO) != 0) + { + REQUEST_SET_TYPE (request, REQUEST_EXTENSION_INFO); + } + + if (file_attributes & NAUTILUS_FILE_ATTRIBUTE_THUMBNAIL) + { + REQUEST_SET_TYPE (request, REQUEST_THUMBNAIL); + REQUEST_SET_TYPE (request, REQUEST_FILE_INFO); + } + + if (file_attributes & NAUTILUS_FILE_ATTRIBUTE_MOUNT) + { + REQUEST_SET_TYPE (request, REQUEST_MOUNT); + REQUEST_SET_TYPE (request, REQUEST_FILE_INFO); + } + + if (file_attributes & NAUTILUS_FILE_ATTRIBUTE_FILESYSTEM_INFO) + { + REQUEST_SET_TYPE (request, REQUEST_FILESYSTEM_INFO); + } + + return request; +} + +static void +mime_db_changed_callback (GObject *ignore, + NautilusDirectory *dir) +{ + NautilusFileAttributes attrs; + + g_assert (dir != NULL); + g_assert (dir->details != NULL); + + attrs = NAUTILUS_FILE_ATTRIBUTE_INFO | + NAUTILUS_FILE_ATTRIBUTE_DIRECTORY_ITEM_MIME_TYPES; + + nautilus_directory_force_reload_internal (dir, attrs); +} + +void +nautilus_directory_monitor_add_internal (NautilusDirectory *directory, + NautilusFile *file, + gconstpointer client, + gboolean monitor_hidden_files, + NautilusFileAttributes file_attributes, + NautilusDirectoryCallback callback, + gpointer callback_data) +{ + Monitor *monitor; + GList *file_list; + char *file_uri = NULL; + char *dir_uri = NULL; + + g_assert (NAUTILUS_IS_DIRECTORY (directory)); + + if (file != NULL) + { + file_uri = nautilus_file_get_uri (file); + } + if (directory != NULL) + { + dir_uri = nautilus_directory_get_uri (directory); + } + nautilus_profile_start ("uri %s file-uri %s client %p", dir_uri, file_uri, client); + g_free (dir_uri); + g_free (file_uri); + + /* 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->client = client; + monitor->request = nautilus_directory_set_up_request (file_attributes); + + if (file == NULL) + { + REQUEST_SET_TYPE (monitor->request, REQUEST_FILE_LIST); + } + + insert_new_monitor (directory, monitor); + + if (callback != NULL) + { + file_list = nautilus_directory_get_file_list (directory); + (*callback)(directory, file_list, callback_data); + nautilus_file_list_free (file_list); + } + + /* Start the "real" monitoring (FAM or whatever). */ + /* We always monitor the whole directory since in practice + * nautilus 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 = nautilus_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 (nautilus_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) + { + nautilus_directory_add_file_to_work_queue (directory, file); + } + else + { + add_all_files_to_work_queue (directory); + } + + /* Kick off I/O. */ + nautilus_directory_async_state_changed (directory); + nautilus_profile_end (NULL); +} + +static void +set_file_unconfirmed (NautilusFile *file, + gboolean unconfirmed) +{ + NautilusDirectory *directory; + + g_assert (NAUTILUS_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 void +show_hidden_files_changed_callback (gpointer callback_data) +{ + show_hidden_files = g_settings_get_boolean (gtk_filechooser_preferences, NAUTILUS_PREFERENCES_SHOW_HIDDEN_FILES); +} + +static gboolean +should_skip_file (NautilusDirectory *directory, + GFileInfo *info) +{ + static gboolean show_hidden_files_changed_callback_installed = FALSE; + + /* Add the callback once for the life of our process */ + if (!show_hidden_files_changed_callback_installed) + { + g_signal_connect_swapped (gtk_filechooser_preferences, + "changed::" NAUTILUS_PREFERENCES_SHOW_HIDDEN_FILES, + G_CALLBACK (show_hidden_files_changed_callback), + NULL); + + show_hidden_files_changed_callback_installed = TRUE; + + /* Peek for the first time */ + show_hidden_files_changed_callback (NULL); + } + + if (!show_hidden_files && + (g_file_info_get_is_hidden (info) || + g_file_info_get_is_backup (info))) + { + return TRUE; + } + + return FALSE; +} + +static void +notify_files_changed_while_being_added (NautilusDirectory *directory) +{ + if (directory->details->files_changed_while_adding == NULL) + { + return; + } + + directory->details->files_changed_while_adding = + g_list_reverse (directory->details->files_changed_while_adding); + + nautilus_directory_notify_files_changed (directory->details->files_changed_while_adding); + + g_clear_list (&directory->details->files_changed_while_adding, g_object_unref); +} + +static gboolean +dequeue_pending_idle_callback (gpointer callback_data) +{ + NautilusDirectory *directory; + GList *pending_file_info; + GList *node, *next; + NautilusFile *file; + GList *changed_files, *added_files; + GFileInfo *file_info; + const char *mimetype, *name; + DirectoryLoadState *dir_load_state; + + directory = NAUTILUS_DIRECTORY (callback_data); + + nautilus_directory_ref (directory); + + nautilus_profile_start ("nitems %d", g_list_length (directory->details->pending_file_info)); + + 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 (!nautilus_directory_is_file_list_monitored (directory)) + { + nautilus_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 NautilusFile 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 = nautilus_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 nautilus_file_get_by_uri() + * on a file in the folder before the add signal was + * emitted */ + nautilus_file_ref (file); + file->details->is_added = TRUE; + added_files = g_list_prepend (added_files, file); + } + else if (nautilus_file_update_info (file, file_info)) + { + /* File changed, notify about the change. */ + nautilus_file_ref (file); + changed_files = g_list_prepend (changed_files, file); + } + } + else + { + /* new file, create a nautilus file object and add it to the list */ + file = nautilus_file_new_from_info (directory, file_info); + nautilus_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 = NAUTILUS_FILE (node->data); + next = node->next; + + if (file->details->unconfirmed) + { + nautilus_file_ref (file); + changed_files = g_list_prepend (changed_files, file); + + nautilus_file_mark_gone (file); + } + } + } + + /* Send the changed and added signals. */ + nautilus_directory_emit_change_signals (directory, changed_files); + nautilus_file_list_free (changed_files); + nautilus_directory_emit_files_added (directory, added_files); + nautilus_file_list_free (added_files); + + if (directory->details->directory_loaded && + !directory->details->directory_loaded_sent_notification) + { + /* Send the done_loading signal. */ + nautilus_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; + g_list_free_full (file->details->mime_list, g_free); + file->details->mime_list = istr_set_get_as_list + (dir_load_state->load_mime_list_hash); + + nautilus_file_changed (file); + } + + nautilus_directory_async_state_changed (directory); + + directory->details->directory_loaded_sent_notification = TRUE; + } + + /* Process changes received for files while they were still being added. + * See Bug 703179 and issue #1576 for a situation this happens. */ + notify_files_changed_while_being_added (directory); + +drain: + g_list_free_full (pending_file_info, g_object_unref); + + /* Get the state machine running again. */ + nautilus_directory_async_state_changed (directory); + + nautilus_profile_end (NULL); + + nautilus_directory_unref (directory); + return FALSE; +} + +void +nautilus_directory_schedule_dequeue_pending (NautilusDirectory *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 (NautilusDirectory *directory, + GFileInfo *info) +{ + if (info == NULL) + { + return; + } + + if (g_file_info_get_name (info) == NULL) + { + char *uri; + + uri = nautilus_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); + nautilus_directory_schedule_dequeue_pending (directory); +} + +static void +directory_load_cancel (NautilusDirectory *directory) +{ + NautilusFile *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) + { + nautilus_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 void +file_list_cancel (NautilusDirectory *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) + { + g_list_free_full (directory->details->pending_file_info, g_object_unref); + directory->details->pending_file_info = NULL; + } +} + +static void +directory_load_done (NautilusDirectory *directory, + GError *error) +{ + GList *node; + + nautilus_profile_start (NULL); + g_object_ref (directory); + + 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 (NAUTILUS_FILE (node->data), FALSE); + } + + nautilus_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); + + g_object_unref (directory); + nautilus_profile_end (NULL); +} + +void +nautilus_directory_monitor_remove_internal (NautilusDirectory *directory, + NautilusFile *file, + gconstpointer client) +{ + g_assert (NAUTILUS_IS_DIRECTORY (directory)); + g_assert (file == NULL || NAUTILUS_IS_FILE (file)); + g_assert (client != NULL); + + remove_monitor (directory, file, client); + + if (directory->details->monitor != NULL + && g_hash_table_size (directory->details->monitor_table) == 0) + { + nautilus_monitor_cancel (directory->details->monitor); + directory->details->monitor = NULL; + } + + /* XXX - do we need to remove anything from the work queue? */ + + nautilus_directory_async_state_changed (directory); +} + +FileMonitors * +nautilus_directory_remove_file_monitors (NautilusDirectory *directory, + NautilusFile *file) +{ + GList *result, *node; + Monitor *monitor; + + g_assert (NAUTILUS_IS_DIRECTORY (directory)); + g_assert (NAUTILUS_IS_FILE (file)); + g_assert (file->details->directory == directory); + + result = g_hash_table_lookup (directory->details->monitor_table, file); + + if (result != NULL) + { + g_hash_table_remove (directory->details->monitor_table, file); + + for (node = result; node; node = node->next) + { + monitor = node->data; + request_counter_remove_request (directory->details->monitor_counters, + monitor->request); + } + result = g_list_reverse (result); + } + + /* XXX - do we need to remove anything from the work queue? */ + + nautilus_directory_async_state_changed (directory); + + return (FileMonitors *) result; +} + +void +nautilus_directory_add_file_monitors (NautilusDirectory *directory, + NautilusFile *file, + FileMonitors *monitors) +{ + GList *l; + Monitor *monitor; + + g_assert (NAUTILUS_IS_DIRECTORY (directory)); + g_assert (NAUTILUS_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; + + remove_monitor (directory, monitor->file, monitor->client); + insert_new_monitor (directory, monitor); + } + + g_list_free ((GList *) monitors); + + nautilus_directory_add_file_to_work_queue (directory, file); + + nautilus_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 (NautilusDirectory *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 = nautilus_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); + + nautilus_file_list_free (file_list); + } +} + +void +nautilus_directory_call_when_ready_internal (NautilusDirectory *directory, + NautilusFile *file, + NautilusFileAttributes file_attributes, + gboolean wait_for_file_list, + NautilusDirectoryCallback directory_callback, + NautilusFileCallback file_callback, + gpointer callback_data) +{ + ReadyCallback callback; + + g_assert (directory == NULL || NAUTILUS_IS_DIRECTORY (directory)); + g_assert (file == NULL || NAUTILUS_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 = nautilus_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) + { + nautilus_directory_add_file_to_work_queue (directory, file); + } + else + { + add_all_files_to_work_queue (directory); + } + + nautilus_directory_async_state_changed (directory); +} + +gboolean +nautilus_directory_check_if_ready_internal (NautilusDirectory *directory, + NautilusFile *file, + NautilusFileAttributes file_attributes) +{ + Request request; + + g_assert (NAUTILUS_IS_DIRECTORY (directory)); + + request = nautilus_directory_set_up_request (file_attributes); + return request_is_satisfied (directory, file, request); +} + +static void +remove_callback_link_keep_data (NautilusDirectory *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 (NautilusDirectory *directory, + GList *link) +{ + ReadyCallback *callback; + + callback = link->data; + remove_callback_link_keep_data (directory, link); + g_free (callback); +} + +void +nautilus_directory_cancel_callback_internal (NautilusDirectory *directory, + NautilusFile *file, + NautilusDirectoryCallback directory_callback, + NautilusFileCallback file_callback, + gpointer callback_data) +{ + ReadyCallback callback; + GList *node; + + if (directory == NULL) + { + return; + } + + g_assert (NAUTILUS_IS_DIRECTORY (directory)); + g_assert (file == NULL || NAUTILUS_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); + + nautilus_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) +{ + NautilusDirectory *directory; + GFileInfo *info; + NewFilesState *state; + + state = user_data; + + if (state->directory == NULL) + { + /* Operation was cancelled. Bail out */ + new_files_state_unref (state); + return; + } + + directory = nautilus_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); + + nautilus_directory_unref (directory); +} + +void +nautilus_directory_get_info_for_new_files (NautilusDirectory *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, + NAUTILUS_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 +nautilus_async_destroying_file (NautilusFile *file) +{ + NautilusDirectory *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. */ + node = g_hash_table_lookup (directory->details->monitor_table, file); + if (node != NULL) + { + /* Client should have removed monitor earlier. */ + g_warning ("destroyed file still being monitored"); + for (; node; node = next) + { + next = node->next; + monitor = node->data; + + remove_monitor (directory, monitor->file, monitor->client); + } + 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->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) + { + nautilus_directory_async_state_changed (directory); + } +} + +static gboolean +lacks_directory_count (NautilusFile *file) +{ + return !file->details->directory_count_is_up_to_date + && nautilus_file_should_show_directory_item_count (file); +} + +static gboolean +should_get_directory_count_now (NautilusFile *file) +{ + return lacks_directory_count (file) + && !file->details->loading_directory; +} + +static gboolean +lacks_info (NautilusFile *file) +{ + return !file->details->file_info_is_up_to_date + && !file->details->is_gone; +} + +static gboolean +lacks_filesystem_info (NautilusFile *file) +{ + return !file->details->filesystem_info_is_up_to_date; +} + +static gboolean +lacks_deep_count (NautilusFile *file) +{ + return file->details->deep_counts_status != NAUTILUS_REQUEST_DONE; +} + +static gboolean +lacks_mime_list (NautilusFile *file) +{ + return !file->details->mime_list_is_up_to_date; +} + +static gboolean +should_get_mime_list (NautilusFile *file) +{ + return lacks_mime_list (file) + && !file->details->loading_directory; +} + +static gboolean +lacks_extension_info (NautilusFile *file) +{ + return file->details->pending_info_providers != NULL; +} + +static gboolean +lacks_thumbnail (NautilusFile *file) +{ + return nautilus_file_should_show_thumbnail (file) && + file->details->thumbnail_path != NULL && + !file->details->thumbnail_is_up_to_date; +} + +static gboolean +lacks_mount (NautilusFile *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 && + nautilus_file_is_self_owned (file)) || + + /* Mountable, could be a mountpoint */ + (file->details->type == G_FILE_TYPE_MOUNTABLE) + + ) + ); +} + +static gboolean +has_problem (NautilusDirectory *directory, + NautilusFile *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 (NautilusDirectory *directory, + NautilusFile *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_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; + } + } + + return TRUE; +} + +static gboolean +call_ready_callbacks_at_idle (gpointer callback_data) +{ + NautilusDirectory *directory; + GList *node, *next; + ReadyCallback *callback; + + directory = NAUTILUS_DIRECTORY (callback_data); + directory->details->call_ready_idle_id = 0; + + nautilus_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); + } + + nautilus_directory_async_state_changed (directory); + + nautilus_directory_unref (directory); + + return FALSE; +} + +static void +schedule_call_ready_callbacks (NautilusDirectory *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 (NautilusDirectory *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; +} + +static GList * +lookup_monitors (GHashTable *monitor_table, + NautilusFile *file) +{ + /* To find monitors monitoring all files, use lookup_all_files_monitors. */ + g_return_val_if_fail (file, NULL); + + return g_hash_table_lookup (monitor_table, file); +} + +static GList * +lookup_all_files_monitors (GHashTable *monitor_table) +{ + /* monitor->file == NULL means monitor all files. */ + return g_hash_table_lookup (monitor_table, NULL); +} + +gboolean +nautilus_directory_has_active_request_for_file (NautilusDirectory *directory, + NautilusFile *file) +{ + GList *node; + ReadyCallback *callback; + + 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; + } + } + + if (lookup_monitors (directory->details->monitor_table, file) != NULL) + { + return TRUE; + } + if (lookup_all_files_monitors (directory->details->monitor_table) != NULL) + { + return TRUE; + } + + return FALSE; +} + + +/* This checks if there's a request for monitoring the file list. */ +gboolean +nautilus_directory_is_anyone_monitoring_file_list (NautilusDirectory *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 +nautilus_directory_is_file_list_monitored (NautilusDirectory *directory) +{ + return directory->details->file_list_monitored; +} + +static void +mark_all_files_unconfirmed (NautilusDirectory *directory) +{ + GList *node; + NautilusFile *file; + + for (node = directory->details->file_list; node != NULL; node = node->next) + { + file = node->data; + set_file_unconfirmed (file, TRUE); + } +} + +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); + } + nautilus_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; + NautilusDirectory *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 = nautilus_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 (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); + } + + nautilus_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 (NautilusDirectory *directory) +{ + DirectoryLoadState *state; + + if (!directory->details->file_list_monitored) + { + g_assert (!directory->details->directory_load_in_progress); + directory->details->file_list_monitored = TRUE; + nautilus_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 = + nautilus_directory_get_corresponding_file (directory); + state->load_directory_file->details->loading_directory = TRUE; + + + DEBUG ("load_directory called to monitor file list of %p", directory->details->location); + + directory->details->directory_load_in_progress = state; + + g_file_enumerate_children_async (directory->details->location, + NAUTILUS_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 +nautilus_directory_stop_monitoring_file_list (NautilusDirectory *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); + nautilus_file_list_unref (directory->details->file_list); + directory->details->directory_loaded = FALSE; +} + +static void +file_list_start_or_stop (NautilusDirectory *directory) +{ + if (nautilus_directory_is_anyone_monitoring_file_list (directory)) + { + start_monitoring_file_list (directory); + } + else + { + nautilus_directory_stop_monitoring_file_list (directory); + } +} + +void +nautilus_file_invalidate_count_and_mime_list (NautilusFile *file) +{ + NautilusFileAttributes attributes; + + attributes = NAUTILUS_FILE_ATTRIBUTE_DIRECTORY_ITEM_COUNT | + NAUTILUS_FILE_ATTRIBUTE_DIRECTORY_ITEM_MIME_TYPES; + + nautilus_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 +nautilus_directory_invalidate_count_and_mime_list (NautilusDirectory *directory) +{ + NautilusFile *file; + + file = nautilus_directory_get_existing_corresponding_file (directory); + if (file != NULL) + { + nautilus_file_invalidate_count_and_mime_list (file); + } + + nautilus_file_unref (file); +} + +static void +nautilus_directory_invalidate_file_attributes (NautilusDirectory *directory, + NautilusFileAttributes file_attributes) +{ + GList *node; + + cancel_loading_attributes (directory, file_attributes); + + for (node = directory->details->file_list; node != NULL; node = node->next) + { + nautilus_file_invalidate_attributes_internal (NAUTILUS_FILE (node->data), + file_attributes); + } + + if (directory->details->as_file != NULL) + { + nautilus_file_invalidate_attributes_internal (directory->details->as_file, + file_attributes); + } +} + +void +nautilus_directory_force_reload_internal (NautilusDirectory *directory, + NautilusFileAttributes file_attributes) +{ + nautilus_profile_start (NULL); + + /* invalidate attributes that are getting reloaded for all files */ + nautilus_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. */ + nautilus_directory_invalidate_count_and_mime_list (directory); + + add_all_files_to_work_queue (directory); + nautilus_directory_async_state_changed (directory); + + nautilus_profile_end (NULL); +} + +static gboolean +monitor_includes_file (const Monitor *monitor, + NautilusFile *file) +{ + if (monitor->file == file) + { + return TRUE; + } + /* monitor->file == NULL means monitor all files. */ + if (monitor->file != NULL) + { + return FALSE; + } + if (file == file->details->directory->details->as_file) + { + return FALSE; + } + return nautilus_file_should_show (file, + monitor->monitor_hidden_files); +} + +static gboolean +is_wanted_by_monitor (NautilusFile *file, + GList *monitors, + RequestType request_type_wanted) +{ + GList *node; + + for (node = monitors; node; node = node->next) + { + Monitor *monitor = node->data; + if (REQUEST_WANTS_TYPE (monitor->request, request_type_wanted)) + { + if (monitor_includes_file (monitor, file)) + { + return TRUE; + } + } + } + + return FALSE; +} + +static gboolean +is_needy (NautilusFile *file, + FileCheck check_missing, + RequestType request_type_wanted) +{ + NautilusDirectory *directory; + GList *node; + ReadyCallback *callback; + + 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) + { + GList *monitors; + + monitors = lookup_monitors (directory->details->monitor_table, file); + if (is_wanted_by_monitor (file, monitors, request_type_wanted)) + { + return TRUE; + } + + monitors = lookup_all_files_monitors (directory->details->monitor_table); + if (is_wanted_by_monitor (file, monitors, request_type_wanted)) + { + return TRUE; + } + } + + return FALSE; +} + +static void +directory_count_stop (NautilusDirectory *directory) +{ + NautilusFile *file; + + if (directory->details->count_in_progress != NULL) + { + file = directory->details->count_in_progress->count_file; + if (file != NULL) + { + g_assert (NAUTILUS_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 (NautilusDirectory *directory, + NautilusFile *count_file, + gboolean succeeded, + int count) +{ + g_assert (NAUTILUS_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. + */ + nautilus_file_changed (count_file); + + /* Start up the next one. */ + async_job_end (directory, "directory count"); + nautilus_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); + nautilus_directory_unref (state->directory); + g_free (state); +} + +static void +count_more_files_callback (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + DirectoryCountState *state; + NautilusDirectory *directory; + GError *error; + GList *files; + + state = user_data; + directory = state->directory; + + if (g_cancellable_is_cancelled (state->cancellable)) + { + /* Operation was cancelled. Bail out */ + + async_job_end (directory, "directory count"); + nautilus_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); + } + + g_list_free_full (files, g_object_unref); + + if (error) + { + g_error_free (error); + } +} + +static void +count_children_callback (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + DirectoryCountState *state; + GFileEnumerator *enumerator; + NautilusDirectory *directory; + GError *error; + + state = user_data; + + if (g_cancellable_is_cancelled (state->cancellable)) + { + /* Operation was cancelled. Bail out */ + directory = state->directory; + + async_job_end (directory, "directory count"); + nautilus_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 (NautilusDirectory *directory, + NautilusFile *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 (!nautilus_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; + + nautilus_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 = nautilus_directory_ref (directory); + state->cancellable = g_cancellable_new (); + + directory->details->count_in_progress = state; + + location = nautilus_file_get_location (file); + + { + g_autofree char *uri = NULL; + uri = g_file_get_uri (location); + DEBUG ("load_directory called to get shallow file count for %s", uri); + } + + 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) +{ + NautilusFile *file; + GFile *subdir; + gboolean is_seen_inode; + const char *fs_id; + + 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. */ + fs_id = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILESYSTEM); + if (g_strcmp0 (fs_id, state->fs_id) == 0) + { + /* only if it is on the same filesystem */ + 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); + } + g_list_free_full (state->deep_count_subdirectories, g_object_unref); + g_array_free (state->seen_deep_count_inodes, TRUE); + g_free (state->fs_id); + g_free (state); +} + +static void +deep_count_next_dir (DeepCountState *state) +{ + GFile *location; + NautilusFile *file; + NautilusDirectory *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 = NAUTILUS_REQUEST_DONE; + directory->details->deep_count_file = NULL; + directory->details->deep_count_in_progress = NULL; + deep_count_state_free (state); + done = TRUE; + } + + nautilus_file_updated_deep_count_in_progress (file); + + if (done) + { + nautilus_file_changed (file); + async_job_end (directory, "deep count"); + nautilus_directory_async_state_changed (directory); + } +} + +static void +deep_count_more_files_callback (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + DeepCountState *state; + NautilusDirectory *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 = nautilus_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); + + nautilus_directory_unref (directory); +} + +static void +deep_count_callback (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + DeepCountState *state; + GFileEnumerator *enumerator; + NautilusFile *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) +{ + state->deep_count_location = g_object_ref (location); + + DEBUG ("load_directory called to get deep file count for %p", location); + 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_ID_FILESYSTEM "," + 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 (NautilusDirectory *directory) +{ + NautilusFile *file; + + if (directory->details->deep_count_in_progress != NULL) + { + file = directory->details->deep_count_file; + if (file != NULL) + { + g_assert (NAUTILUS_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_got_info (GObject *source_object, + GAsyncResult *res, + gpointer user_data) +{ + GFileInfo *info; + const char *id; + GFile *file = (GFile *) source_object; + DeepCountState *state = (DeepCountState *) user_data; + + info = g_file_query_info_finish (file, res, NULL); + if (info != NULL) + { + id = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_ID_FILESYSTEM); + state->fs_id = g_strdup (id); + g_object_unref (info); + } + deep_count_load (state, file); +} + +static void +deep_count_start (NautilusDirectory *directory, + NautilusFile *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 (!nautilus_file_is_directory (file)) + { + file->details->deep_counts_status = NAUTILUS_REQUEST_DONE; + + nautilus_directory_async_state_changed (directory); + return; + } + + if (!async_job_start (directory, "deep count")) + { + return; + } + + /* Start counting. */ + file->details->deep_counts_status = NAUTILUS_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)); + state->fs_id = NULL; + + directory->details->deep_count_in_progress = state; + + location = nautilus_file_get_location (file); + g_file_query_info_async (location, + G_FILE_ATTRIBUTE_ID_FILESYSTEM, + G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, + G_PRIORITY_DEFAULT, + NULL, + deep_count_got_info, + state); + g_object_unref (location); +} + +static void +mime_list_stop (NautilusDirectory *directory) +{ + NautilusFile *file; + + if (directory->details->mime_list_in_progress != NULL) + { + file = directory->details->mime_list_in_progress->mime_list_file; + if (file != NULL) + { + g_assert (NAUTILUS_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); + nautilus_directory_unref (state->directory); + g_free (state); +} + + +static void +mime_list_done (MimeListState *state, + gboolean success) +{ + NautilusFile *file; + NautilusDirectory *directory; + + directory = state->directory; + g_assert (directory != NULL); + + file = state->mime_list_file; + + file->details->mime_list_is_up_to_date = TRUE; + g_list_free_full (file->details->mime_list, g_free); + 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. + */ + nautilus_file_changed (file); + + /* Start up the next one. */ + async_job_end (directory, "MIME list"); + nautilus_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; + NautilusDirectory *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"); + nautilus_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; + NautilusDirectory *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"); + nautilus_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 (NautilusDirectory *directory, + NautilusFile *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 (!nautilus_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; + + nautilus_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 = nautilus_directory_ref (directory); + state->cancellable = g_cancellable_new (); + state->mime_list_hash = istr_set_new (); + + directory->details->mime_list_in_progress = state; + + location = nautilus_file_get_location (file); + + { + g_autofree char *uri = NULL; + uri = g_file_get_uri (location); + DEBUG ("load_directory called to get MIME list of %s", uri); + } + + 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 +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) +{ + NautilusDirectory *directory; + NautilusFile *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 = nautilus_directory_ref (state->directory); + + get_info_file = directory->details->get_info_file; + g_assert (NAUTILUS_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. + */ + nautilus_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 */ + nautilus_file_mark_gone (get_info_file); + } + get_info_file->details->file_info_is_up_to_date = TRUE; + nautilus_file_clear_info (get_info_file); + get_info_file->details->get_info_failed = TRUE; + get_info_file->details->get_info_error = error; + } + else + { + nautilus_file_update_info (get_info_file, info); + g_object_unref (info); + } + + nautilus_file_changed (get_info_file); + nautilus_file_unref (get_info_file); + + async_job_end (directory, "file info"); + nautilus_directory_async_state_changed (directory); + + nautilus_directory_unref (directory); + + get_info_state_free (state); +} + +static void +file_info_stop (NautilusDirectory *directory) +{ + NautilusFile *file; + + if (directory->details->get_info_in_progress != NULL) + { + file = directory->details->get_info_file; + if (file != NULL) + { + g_assert (NAUTILUS_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 (NautilusDirectory *directory, + NautilusFile *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 = nautilus_file_get_location (file); + g_file_query_info_async (location, + NAUTILUS_FILE_DEFAULT_ATTRIBUTES, + 0, + G_PRIORITY_DEFAULT, + state->cancellable, query_info_callback, state); + g_object_unref (location); +} + +static void +thumbnail_done (NautilusDirectory *directory, + NautilusFile *file, + GdkPixbuf *pixbuf) +{ + const char *thumb_mtime_str; + time_t thumb_mtime = 0; + + file->details->thumbnail_is_up_to_date = TRUE; + if (file->details->thumbnail) + { + g_object_unref (file->details->thumbnail); + file->details->thumbnail = NULL; + } + + if (pixbuf) + { + 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; + } + } + + nautilus_directory_async_state_changed (directory); +} + +static void +thumbnail_stop (NautilusDirectory *directory) +{ + NautilusFile *file; + + if (directory->details->thumbnail_state != NULL) + { + file = directory->details->thumbnail_state->file; + + if (file != NULL) + { + g_assert (NAUTILUS_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 (NautilusDirectory *directory, + NautilusFile *file, + GdkPixbuf *pixbuf) +{ + nautilus_directory_ref (directory); + + nautilus_file_ref (file); + thumbnail_done (directory, file, pixbuf); + nautilus_file_changed (file); + nautilus_file_unref (file); + + if (pixbuf) + { + g_object_unref (pixbuf); + } + + nautilus_directory_unref (directory); +} + +static void +thumbnail_state_free (ThumbnailState *state) +{ + g_object_unref (state->cancellable); + g_free (state); +} + +/* 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. nautilus_file_get_icon() */ + max_thumbnail_size = NAUTILUS_GRID_ICON_SIZE_EXTRA_LARGE * NAUTILUS_GRID_ICON_SIZE_MEDIUM / NAUTILUS_GRID_ICON_SIZE_SMALL; + 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, (guchar *) 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; + NautilusDirectory *directory; + GdkPixbuf *pixbuf; + + state = user_data; + + if (state->directory == NULL) + { + /* Operation was cancelled. Bail out */ + thumbnail_state_free (state); + return; + } + + directory = nautilus_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); + } + + state->directory->details->thumbnail_state = NULL; + async_job_end (state->directory, "thumbnail"); + + thumbnail_got_pixbuf (state->directory, state->file, pixbuf); + + thumbnail_state_free (state); + + nautilus_directory_unref (directory); +} + +static void +thumbnail_start (NautilusDirectory *directory, + NautilusFile *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 (); + + 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 (NautilusDirectory *directory) +{ + NautilusFile *file; + + if (directory->details->mount_state != NULL) + { + file = directory->details->mount_state->file; + + if (file != NULL) + { + g_assert (NAUTILUS_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) +{ + NautilusDirectory *directory; + NautilusFile *file; + + directory = nautilus_directory_ref (state->directory); + + state->directory->details->mount_state = NULL; + async_job_end (state->directory, "mount"); + + file = nautilus_file_ref (state->file); + + file->details->mount_is_up_to_date = TRUE; + nautilus_file_set_mount (file, mount); + + nautilus_directory_async_state_changed (directory); + nautilus_file_changed (file); + + nautilus_file_unref (file); + + nautilus_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 = nautilus_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); + } + + g_list_free_full (mounts, g_object_unref); + + g_object_unref (monitor); + + return found; +} + +static void +mount_start (NautilusDirectory *directory, + NautilusFile *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 = nautilus_file_get_location (file); + + directory->details->mount_state = state; + + if (file->details->type == G_FILE_TYPE_MOUNTABLE) + { + GFile *target; + GMount *mount; + + mount = NULL; + target = nautilus_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 (NautilusDirectory *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 (NautilusDirectory *directory) +{ + NautilusFile *file; + + if (directory->details->filesystem_info_state != NULL) + { + file = directory->details->filesystem_info_state->file; + + if (file != NULL) + { + g_assert (NAUTILUS_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) +{ + NautilusDirectory *directory; + NautilusFile *file; + const char *filesystem_type; + + /* careful here, info may be NULL */ + + directory = nautilus_directory_ref (state->directory); + + state->directory->details->filesystem_info_state = NULL; + async_job_end (state->directory, "filesystem info"); + + file = nautilus_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); + filesystem_type = g_file_info_get_attribute_string (info, G_FILE_ATTRIBUTE_FILESYSTEM_TYPE); + file->details->filesystem_remote = g_file_info_get_attribute_boolean (info, G_FILE_ATTRIBUTE_FILESYSTEM_REMOTE); + if (g_strcmp0 (file->details->filesystem_type, filesystem_type) != 0) + { + g_clear_pointer (&file->details->filesystem_type, g_ref_string_release); + file->details->filesystem_type = g_ref_string_new_intern (filesystem_type); + } + } + + nautilus_directory_async_state_changed (directory); + nautilus_file_changed (file); + + nautilus_file_unref (file); + + nautilus_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 (NautilusDirectory *directory, + NautilusFile *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 = nautilus_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_FILE_ATTRIBUTE_FILESYSTEM_TYPE "," + G_FILE_ATTRIBUTE_FILESYSTEM_REMOTE, + G_PRIORITY_DEFAULT, + state->cancellable, + query_filesystem_info_callback, + state); + g_object_unref (location); +} + +static void +extension_info_cancel (NautilusDirectory *directory) +{ + if (directory->details->extension_info_in_progress != NULL) + { + if (directory->details->extension_info_idle) + { + g_source_remove (directory->details->extension_info_idle); + } + else + { + nautilus_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 (NautilusDirectory *directory) +{ + if (directory->details->extension_info_in_progress != NULL) + { + NautilusFile *file; + + file = directory->details->extension_info_file; + if (file != NULL) + { + g_assert (NAUTILUS_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 (NautilusDirectory *directory, + NautilusFile *file, + NautilusInfoProvider *provider) +{ + file->details->pending_info_providers = + g_list_remove (file->details->pending_info_providers, + provider); + g_object_unref (provider); + + nautilus_directory_async_state_changed (directory); + + if (file->details->pending_info_providers == NULL) + { + nautilus_file_info_providers_done (file); + } +} + + +static gboolean +info_provider_idle_callback (gpointer user_data) +{ + InfoProviderResponse *response; + NautilusDirectory *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 Nautilus extension: handle=%p", response->handle); + } + else + { + NautilusFile *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 (NautilusInfoProvider *provider, + NautilusOperationHandle *handle, + NautilusOperationResult result, + gpointer user_data) +{ + InfoProviderResponse *response; + + response = g_new0 (InfoProviderResponse, 1); + response->provider = provider; + response->handle = handle; + response->result = result; + response->directory = NAUTILUS_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 (NautilusDirectory *directory, + NautilusFile *file, + gboolean *doing_io) +{ + NautilusInfoProvider *provider; + NautilusOperationResult result; + NautilusOperationHandle *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, + g_cclosure_marshal_generic); + + result = nautilus_info_provider_update_file_info + (provider, + NAUTILUS_FILE_INFO (file), + update_complete, + &handle); + + g_closure_unref (update_complete); + + if (result == NAUTILUS_OPERATION_COMPLETE || + result == NAUTILUS_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 (NautilusDirectory *directory) +{ + NautilusFile *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); + 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 (!nautilus_file_queue_is_empty (directory->details->high_priority_queue)) + { + file = nautilus_file_queue_head (directory->details->high_priority_queue); + + /* Start getting attributes if possible */ + file_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 (!nautilus_file_queue_is_empty (directory->details->low_priority_queue)) + { + file = nautilus_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); + 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 (!nautilus_file_queue_is_empty (directory->details->extension_queue)) + { + file = nautilus_file_queue_head (directory->details->extension_queue); + + /* Start getting attributes if possible */ + extension_info_start (directory, file, &doing_io); + if (doing_io) + { + return; + } + + nautilus_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 +nautilus_directory_async_state_changed (NautilusDirectory *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; + nautilus_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; + nautilus_directory_unref (directory); + + /* Check if any directories should wake up. */ + async_job_wake_up (); +} + +void +nautilus_directory_cancel (NautilusDirectory *directory) +{ + /* Arbitrary order (kept alphabetical). */ + deep_count_cancel (directory); + directory_count_cancel (directory); + file_info_cancel (directory); + file_list_cancel (directory); + mime_list_cancel (directory); + new_files_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 (NautilusDirectory *directory, + NautilusFile *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 (NautilusDirectory *directory, + NautilusFile *file) +{ + if (directory->details->deep_count_file == file) + { + deep_count_cancel (directory); + } +} + +static void +cancel_mime_list_for_file (NautilusDirectory *directory, + NautilusFile *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_file_info_for_file (NautilusDirectory *directory, + NautilusFile *file) +{ + if (directory->details->get_info_file == file) + { + file_info_cancel (directory); + } +} + +static void +cancel_thumbnail_for_file (NautilusDirectory *directory, + NautilusFile *file) +{ + if (directory->details->thumbnail_state != NULL && + directory->details->thumbnail_state->file == file) + { + thumbnail_cancel (directory); + } +} + +static void +cancel_mount_for_file (NautilusDirectory *directory, + NautilusFile *file) +{ + if (directory->details->mount_state != NULL && + directory->details->mount_state->file == file) + { + mount_cancel (directory); + } +} + +static void +cancel_filesystem_info_for_file (NautilusDirectory *directory, + NautilusFile *file) +{ + if (directory->details->filesystem_info_state != NULL && + directory->details->filesystem_info_state->file == file) + { + filesystem_info_cancel (directory); + } +} + +static void +cancel_loading_attributes (NautilusDirectory *directory, + NautilusFileAttributes file_attributes) +{ + Request request; + + request = nautilus_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_FILE_INFO)) + { + file_info_cancel (directory); + } + if (REQUEST_WANTS_TYPE (request, REQUEST_FILESYSTEM_INFO)) + { + filesystem_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); + } + + nautilus_directory_async_state_changed (directory); +} + +void +nautilus_directory_cancel_loading_file_attributes (NautilusDirectory *directory, + NautilusFile *file, + NautilusFileAttributes file_attributes) +{ + Request request; + + nautilus_directory_remove_file_from_work_queue (directory, file); + + request = nautilus_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_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_THUMBNAIL)) + { + cancel_thumbnail_for_file (directory, file); + } + if (REQUEST_WANTS_TYPE (request, REQUEST_MOUNT)) + { + cancel_mount_for_file (directory, file); + } + + nautilus_directory_async_state_changed (directory); +} + +void +nautilus_directory_add_file_to_work_queue (NautilusDirectory *directory, + NautilusFile *file) +{ + g_return_if_fail (file->details->directory == directory); + + nautilus_file_queue_enqueue (directory->details->high_priority_queue, + file); +} + + +static void +add_all_files_to_work_queue (NautilusDirectory *directory) +{ + GList *node; + NautilusFile *file; + + for (node = directory->details->file_list; node != NULL; node = node->next) + { + file = NAUTILUS_FILE (node->data); + + nautilus_directory_add_file_to_work_queue (directory, file); + } +} + +void +nautilus_directory_remove_file_from_work_queue (NautilusDirectory *directory, + NautilusFile *file) +{ + nautilus_file_queue_remove (directory->details->high_priority_queue, + file); + nautilus_file_queue_remove (directory->details->low_priority_queue, + file); + nautilus_file_queue_remove (directory->details->extension_queue, + file); +} + + +static void +move_file_to_low_priority_queue (NautilusDirectory *directory, + NautilusFile *file) +{ + /* Must add before removing to avoid ref underflow */ + nautilus_file_queue_enqueue (directory->details->low_priority_queue, + file); + nautilus_file_queue_remove (directory->details->high_priority_queue, + file); +} + +static void +move_file_to_extension_queue (NautilusDirectory *directory, + NautilusFile *file) +{ + /* Must add before removing to avoid ref underflow */ + nautilus_file_queue_enqueue (directory->details->extension_queue, + file); + nautilus_file_queue_remove (directory->details->low_priority_queue, + file); +} |