/* * 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 . * * Author: Darin Adler */ #include #include #include #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); }