static void
sync_search_directory (NautilusWindowSlot *slot)
{
NautilusDirectory *directory;
NautilusQuery *query;
gchar *text;
GFile *location;
g_assert (NAUTILUS_IS_FILE (slot->viewed_file));
directory = nautilus_directory_get_for_file (slot->viewed_file);
g_assert (NAUTILUS_IS_SEARCH_DIRECTORY (directory));
query = nautilus_query_editor_get_query (slot->query_editor);
text = nautilus_query_get_text (query);
if (!strlen (text)) {
location = nautilus_query_editor_get_location (slot->query_editor);
slot->load_with_search = TRUE;
nautilus_window_slot_open_location (slot, location, 0);
g_object_unref (location);
} else {
nautilus_search_directory_set_query (NAUTILUS_SEARCH_DIRECTORY (directory),
query);
nautilus_window_slot_reload (slot);
}
g_free (text);
g_object_unref (query);
nautilus_directory_unref (directory);
}
static void
nautilus_desktop_directory_file_init (NautilusDesktopDirectoryFile *desktop_file)
{
NautilusDesktopDirectory *desktop_directory;
NautilusDirectory *real_dir;
NautilusFile *real_dir_file;
desktop_file->details = G_TYPE_INSTANCE_GET_PRIVATE (desktop_file,
NAUTILUS_TYPE_DESKTOP_DIRECTORY_FILE,
NautilusDesktopDirectoryFileDetails);
desktop_directory = NAUTILUS_DESKTOP_DIRECTORY (nautilus_directory_get_by_uri (EEL_DESKTOP_URI));
desktop_file->details->desktop_directory = desktop_directory;
desktop_file->details->callbacks = g_hash_table_new
(desktop_callback_hash, desktop_callback_equal);
desktop_file->details->monitors = g_hash_table_new_full (NULL, NULL,
NULL, monitor_destroy);
real_dir = nautilus_desktop_directory_get_real_directory (desktop_directory);
real_dir_file = nautilus_directory_get_corresponding_file (real_dir);
nautilus_directory_unref (real_dir);
desktop_file->details->real_dir_file = real_dir_file;
nautilus_desktop_update_metadata_from_keyfile (NAUTILUS_FILE (desktop_file), "directory");
g_signal_connect_object (real_dir_file, "changed",
G_CALLBACK (real_file_changed_callback), desktop_file, 0);
}
static void
update_desktop_directory (NautilusDesktopDirectory *desktop)
{
char *desktop_path;
char *desktop_uri;
NautilusDirectory *real_directory;
real_directory = desktop->details->real_directory;
if (real_directory != NULL) {
g_hash_table_foreach_remove (desktop->details->callbacks, (GHRFunc) gtk_true, NULL);
g_hash_table_foreach_remove (desktop->details->monitors, (GHRFunc) gtk_true, NULL);
g_signal_handlers_disconnect_by_func (real_directory, done_loading_callback, desktop);
g_signal_handlers_disconnect_by_func (real_directory, forward_files_added_cover, desktop);
g_signal_handlers_disconnect_by_func (real_directory, forward_files_changed_cover, desktop);
nautilus_directory_unref (real_directory);
}
desktop_path = nautilus_get_desktop_directory ();
desktop_uri = g_filename_to_uri (desktop_path, NULL, NULL);
real_directory = nautilus_directory_get_by_uri (desktop_uri);
g_free (desktop_uri);
g_free (desktop_path);
g_signal_connect_object (real_directory, "done-loading",
G_CALLBACK (done_loading_callback), desktop, 0);
g_signal_connect_object (real_directory, "files-added",
G_CALLBACK (forward_files_added_cover), desktop, 0);
g_signal_connect_object (real_directory, "files-changed",
G_CALLBACK (forward_files_changed_cover), desktop, 0);
desktop->details->real_directory = real_directory;
}
static void
desktop_finalize (GObject *object)
{
NautilusDesktopDirectoryFile *desktop_file;
NautilusDesktopDirectory *desktop_directory;
desktop_file = NAUTILUS_DESKTOP_DIRECTORY_FILE (object);
desktop_directory = desktop_file->details->desktop_directory;
/* Todo: ghash now safe? */
eel_g_hash_table_safe_for_each
(desktop_file->details->callbacks,
desktop_callback_remove_file_cover,
desktop_file->details->real_dir_file);
if (g_hash_table_size (desktop_file->details->callbacks) != 0) {
g_warning ("call_when_ready still pending when desktop virtual file is destroyed");
}
g_hash_table_destroy (desktop_file->details->callbacks);
g_hash_table_destroy (desktop_file->details->monitors);
nautilus_file_unref (desktop_file->details->real_dir_file);
nautilus_directory_unref (NAUTILUS_DIRECTORY (desktop_directory));
G_OBJECT_CLASS (nautilus_desktop_directory_file_parent_class)->finalize (object);
}
static gboolean
nautilus_drag_can_accept_files (NautilusFile *drop_target_item)
{
NautilusDirectory *directory;
if (nautilus_file_is_directory (drop_target_item)) {
gboolean res;
/* target is a directory, accept if editable */
directory = nautilus_directory_get_for_file (drop_target_item);
res = nautilus_directory_is_editable (directory);
nautilus_directory_unref (directory);
return res;
}
if (NAUTILUS_IS_DESKTOP_ICON_FILE (drop_target_item)) {
return TRUE;
}
/* Launchers are an acceptable drop target */
if (nautilus_file_is_launcher (drop_target_item)) {
return TRUE;
}
if (nautilus_is_file_roller_installed () &&
nautilus_file_is_archive (drop_target_item)) {
return TRUE;
}
return FALSE;
}
static void
real_update_query_editor (NautilusWindowSlot *slot)
{
GtkWidget *query_editor;
NautilusQuery *query;
NautilusDirectory *directory;
NautilusSearchDirectory *search_directory;
directory = nautilus_directory_get (slot->location);
if (NAUTILUS_IS_SEARCH_DIRECTORY (directory)) {
search_directory = NAUTILUS_SEARCH_DIRECTORY (directory);
query_editor = nautilus_query_editor_new (nautilus_search_directory_is_saved_search (search_directory),
nautilus_search_directory_is_indexed (search_directory));
slot->query_editor = NAUTILUS_QUERY_EDITOR (query_editor);
nautilus_window_slot_add_extra_location_widget (slot, query_editor);
gtk_widget_show (query_editor);
g_signal_connect_object (query_editor, "changed",
G_CALLBACK (query_editor_changed_callback), slot, 0);
query = nautilus_search_directory_get_query (search_directory);
if (query != NULL) {
nautilus_query_editor_set_query (NAUTILUS_QUERY_EDITOR (query_editor),
query);
g_object_unref (query);
} else {
nautilus_query_editor_set_default_query (NAUTILUS_QUERY_EDITOR (query_editor));
}
}
nautilus_directory_unref (directory);
}
static GList *
nautilus_directory_moved_internal (GFile *old_location,
GFile *new_location)
{
CollectData collection;
NautilusDirectory *directory;
GList *node, *affected_files;
GFile *new_directory_location;
char *relative_path;
collection.container = old_location;
collection.directories = NULL;
g_hash_table_foreach (directories,
collect_directories_by_container,
&collection);
affected_files = NULL;
for (node = collection.directories; node != NULL; node = node->next) {
directory = NAUTILUS_DIRECTORY (node->data);
new_directory_location = NULL;
if (g_file_equal (directory->details->location, old_location)) {
new_directory_location = g_object_ref (new_location);
} else {
relative_path = g_file_get_relative_path (old_location,
directory->details->location);
if (relative_path != NULL) {
new_directory_location = g_file_resolve_relative_path (new_location, relative_path);
g_free (relative_path);
}
}
if (new_directory_location) {
change_directory_location (directory, new_directory_location);
g_object_unref (new_directory_location);
/* Collect affected files. */
if (directory->details->as_file != NULL) {
affected_files = g_list_prepend
(affected_files,
nautilus_file_ref (directory->details->as_file));
}
affected_files = g_list_concat
(affected_files,
nautilus_file_list_copy (directory->details->file_list));
}
nautilus_directory_unref (directory);
}
g_list_free (collection.directories);
return affected_files;
}
static void
invalidate_count_and_unref (gpointer key, gpointer value, gpointer user_data)
{
g_assert (NAUTILUS_IS_DIRECTORY (key));
g_assert (value == key);
g_assert (user_data == NULL);
nautilus_directory_invalidate_count_and_mime_list (key);
nautilus_directory_unref (key);
}
static void
desktop_link_monitor_finalize (GObject *object)
{
NautilusDesktopLinkMonitor *monitor;
monitor = NAUTILUS_DESKTOP_LINK_MONITOR (object);
g_object_unref (monitor->details->volume_monitor);
/* Default links */
remove_link_and_preference (&monitor->details->home_link,
NAUTILUS_PREFERENCES_DESKTOP_HOME_VISIBLE,
G_CALLBACK (desktop_home_visible_changed),
monitor);
remove_link_and_preference (&monitor->details->trash_link,
NAUTILUS_PREFERENCES_DESKTOP_TRASH_VISIBLE,
G_CALLBACK (desktop_trash_visible_changed),
monitor);
remove_link_and_preference (&monitor->details->network_link,
NAUTILUS_PREFERENCES_DESKTOP_NETWORK_VISIBLE,
G_CALLBACK (desktop_network_visible_changed),
monitor);
/* Mounts */
g_list_foreach (monitor->details->mount_links, (GFunc)g_object_unref, NULL);
g_list_free (monitor->details->mount_links);
monitor->details->mount_links = NULL;
nautilus_directory_unref (monitor->details->desktop_dir);
monitor->details->desktop_dir = NULL;
g_signal_handlers_disconnect_by_func (nautilus_desktop_preferences,
desktop_volumes_visible_changed,
monitor);
if (monitor->details->mount_id != 0) {
g_source_remove (monitor->details->mount_id);
}
if (monitor->details->unmount_id != 0) {
g_source_remove (monitor->details->unmount_id);
}
if (monitor->details->changed_id != 0) {
g_source_remove (monitor->details->changed_id);
}
G_OBJECT_CLASS (nautilus_desktop_link_monitor_parent_class)->finalize (object);
}
static void
remove_all_extra_location_widgets (GtkWidget *widget,
gpointer data)
{
NautilusWindowSlot *slot = data;
NautilusDirectory *directory;
directory = nautilus_directory_get (slot->location);
if (widget != GTK_WIDGET (slot->query_editor)) {
gtk_container_remove (GTK_CONTAINER (slot->extra_location_widgets), widget);
}
nautilus_directory_unref (directory);
}
static void
real_update_query_editor (NautilusWindowSlot *slot)
{
NautilusDirectory *directory;
NautilusSearchDirectory *search_directory;
NautilusQuery *query;
GtkWidget *query_editor;
g_assert (slot->pane->window != NULL);
query_editor = NULL;
directory = nautilus_directory_get (slot->location);
if (NAUTILUS_IS_SEARCH_DIRECTORY (directory)) {
search_directory = NAUTILUS_SEARCH_DIRECTORY (directory);
if (nautilus_search_directory_is_saved_search (search_directory)) {
query_editor = nautilus_query_editor_new (TRUE,
nautilus_search_directory_is_indexed (search_directory));
} else {
query_editor = nautilus_query_editor_new_with_bar (FALSE,
nautilus_search_directory_is_indexed (search_directory),
slot->pane->window->details->active_pane->active_slot == slot,
NAUTILUS_SEARCH_BAR (slot->pane->search_bar),
slot);
}
}
slot->query_editor = NAUTILUS_QUERY_EDITOR (query_editor);
if (query_editor != NULL) {
g_signal_connect_object (query_editor, "changed",
G_CALLBACK (query_editor_changed_callback), slot, 0);
query = nautilus_search_directory_get_query (search_directory);
if (query != NULL) {
nautilus_query_editor_set_query (NAUTILUS_QUERY_EDITOR (query_editor),
query);
g_object_unref (query);
} else {
nautilus_query_editor_set_default_query (NAUTILUS_QUERY_EDITOR (query_editor));
}
nautilus_window_slot_add_extra_location_widget (slot, query_editor);
gtk_widget_show (query_editor);
nautilus_query_editor_grab_focus (NAUTILUS_QUERY_EDITOR (query_editor));
}
nautilus_directory_unref (directory);
}
static void
file_entry_free (FileEntry *file_entry)
{
nautilus_file_unref (file_entry->file);
if (file_entry->reverse_map) {
g_hash_table_destroy (file_entry->reverse_map);
file_entry->reverse_map = NULL;
}
if (file_entry->subdirectory != NULL) {
nautilus_directory_unref (file_entry->subdirectory);
}
if (file_entry->files != NULL) {
g_sequence_free (file_entry->files);
}
g_free (file_entry);
}
void
nautilus_directory_notify_files_removed (GList *files)
{
GHashTable *changed_lists;
GList *p;
NautilusDirectory *directory;
GHashTable *parent_directories;
NautilusFile *file;
GFile *location;
/* Make a list of changed files in each directory. */
changed_lists = g_hash_table_new (NULL, NULL);
/* Make a list of parent directories that will need their counts updated. */
parent_directories = g_hash_table_new (NULL, NULL);
/* Go through all the notifications. */
for (p = files; p != NULL; p = p->next) {
location = p->data;
/* Update file count for parent directory if anyone might care. */
directory = get_parent_directory_if_exists (location);
if (directory != NULL) {
collect_parent_directories (parent_directories, directory);
nautilus_directory_unref (directory);
}
/* Find the file. */
file = nautilus_file_get_existing (location);
if (file != NULL && !nautilus_file_rename_in_progress (file)) {
/* Mark it gone and prepare to send the changed signal. */
nautilus_file_mark_gone (file);
hash_table_list_prepend (changed_lists,
file->details->directory,
nautilus_file_ref (file));
}
nautilus_file_unref (file);
}
/* Now send out the changed signals. */
g_hash_table_foreach (changed_lists, call_files_changed_unref_free_list, NULL);
g_hash_table_destroy (changed_lists);
/* Invalidate count for each parent directory. */
g_hash_table_foreach (parent_directories, invalidate_count_and_unref, NULL);
g_hash_table_destroy (parent_directories);
}
static void
action_search (GSimpleAction *action,
GVariant *parameter,
gpointer user_data)
{
GtkApplication *application = user_data;
const gchar *string, *uri;
NautilusQuery *query;
NautilusDirectory *directory;
gchar *search_uri;
NautilusWindow *window;
GtkWindow *cur_window;
GFile *location;
g_variant_get (parameter, "(ss)", &uri, &string);
if (strlen (string) == 0 ||
strlen (uri) == 0) {
return;
}
query = nautilus_query_new ();
nautilus_query_set_location (query, uri);
nautilus_query_set_text (query, string);
search_uri = nautilus_search_directory_generate_new_uri ();
location = g_file_new_for_uri (search_uri);
g_free (search_uri);
directory = nautilus_directory_get (location);
nautilus_search_directory_set_query (NAUTILUS_SEARCH_DIRECTORY (directory), query);
cur_window = gtk_application_get_active_window (application);
window = nautilus_application_create_window (NAUTILUS_APPLICATION (application),
cur_window ?
gtk_window_get_screen (cur_window) :
gdk_screen_get_default ());
nautilus_window_slot_open_location (nautilus_window_get_active_slot (window), location, 0);
nautilus_directory_unref (directory);
g_object_unref (query);
g_object_unref (location);
}
static void
desktop_finalize (GObject *object)
{
NautilusDesktopDirectory *desktop;
desktop = NAUTILUS_DESKTOP_DIRECTORY (object);
nautilus_directory_unref (desktop->details->real_directory);
g_hash_table_destroy (desktop->details->callbacks);
g_hash_table_destroy (desktop->details->monitors);
g_free (desktop->details);
g_signal_handlers_disconnect_by_func (nautilus_preferences,
desktop_directory_changed_callback,
desktop);
G_OBJECT_CLASS (nautilus_desktop_directory_parent_class)->finalize (object);
}
static void
query_editor_changed_callback (NautilusSearchBar *bar,
NautilusQuery *query,
gboolean reload,
NautilusWindowSlot *slot)
{
NautilusDirectory *directory;
directory = nautilus_directory_get_for_file (slot->viewed_file);
g_assert (NAUTILUS_IS_SEARCH_DIRECTORY (directory));
nautilus_search_directory_set_query (NAUTILUS_SEARCH_DIRECTORY (directory),
query);
if (reload) {
nautilus_window_slot_reload (slot);
}
nautilus_directory_unref (directory);
}
void
emit_change_signals_for_all_files_in_all_directories (void)
{
GList *dirs, *l;
NautilusDirectory *directory;
dirs = NULL;
g_hash_table_foreach (directories,
collect_all_directories,
&dirs);
for (l = dirs; l != NULL; l = l->next) {
directory = NAUTILUS_DIRECTORY (l->data);
emit_change_signals_for_all_files (directory);
nautilus_directory_unref (directory);
}
g_list_free (dirs);
}
static void
create_new_search (NautilusWindowSlot *slot)
{
char *uri;
NautilusDirectory *directory;
GFile *location;
uri = nautilus_search_directory_generate_new_uri ();
location = g_file_new_for_uri (uri);
directory = nautilus_directory_get (location);
g_assert (NAUTILUS_IS_SEARCH_DIRECTORY (directory));
nautilus_window_slot_open_location_full (slot, location, 0, NULL, sync_search_location_cb, slot);
nautilus_directory_unref (directory);
g_object_unref (location);
g_free (uri);
}
static void
query_editor_changed_callback (NautilusQueryEditor *editor,
NautilusQuery *query,
gboolean reload,
NautilusWindowSlot *slot)
{
NautilusDirectory *directory;
g_assert (NAUTILUS_IS_FILE (slot->viewed_file));
directory = nautilus_directory_get_for_file (slot->viewed_file);
if (!NAUTILUS_IS_SEARCH_DIRECTORY (directory)) {
/* this is the first change from the query editor. we
ask for a location change to the search directory,
indicate the directory needs to be sync'd with the
current query. */
create_new_search (slot);
} else {
sync_search_directory (slot);
}
nautilus_directory_unref (directory);
}
static void
update_query_editor (NautilusWindowSlot *slot)
{
NautilusDirectory *directory;
NautilusSearchDirectory *search_directory;
directory = nautilus_directory_get (slot->location);
if (NAUTILUS_IS_SEARCH_DIRECTORY (directory)) {
NautilusQuery *query;
search_directory = NAUTILUS_SEARCH_DIRECTORY (directory);
query = nautilus_search_directory_get_query (search_directory);
if (query != NULL) {
nautilus_query_editor_set_query (slot->query_editor,
query);
g_object_unref (query);
}
} else {
nautilus_query_editor_set_location (slot->query_editor, slot->location);
}
nautilus_directory_unref (directory);
}
static gboolean
nautilus_drag_can_accept_files (NautilusFile *drop_target_item)
{
NautilusDirectory *directory;
if (nautilus_file_is_directory (drop_target_item)) {
gboolean res;
/* target is a directory, accept if editable */
directory = nautilus_directory_get_for_file (drop_target_item);
res = nautilus_directory_is_editable (directory);
nautilus_directory_unref (directory);
return res;
}
if (NAUTILUS_IS_DESKTOP_ICON_FILE (drop_target_item)) {
return TRUE;
}
/* All Nautilus links are assumed to be links to directories.
* Therefore, they all can accept drags, like all other
* directories to. As with other directories, there can be
* errors when the actual copy is attempted due to
* permissions.
*/
if (nautilus_file_is_nautilus_link (drop_target_item)) {
return TRUE;
}
if (nautilus_is_file_roller_installed () &&
nautilus_file_is_archive (drop_target_item)) {
return TRUE;
}
return FALSE;
}
void
nautilus_directory_notify_files_added (GList *files)
{
GHashTable *added_lists;
GList *p;
NautilusDirectory *directory;
GHashTable *parent_directories;
NautilusFile *file;
GFile *location, *parent;
/* Make a list of added files in each directory. */
added_lists = g_hash_table_new (NULL, NULL);
/* Make a list of parent directories that will need their counts updated. */
parent_directories = g_hash_table_new (NULL, NULL);
for (p = files; p != NULL; p = p->next) {
location = p->data;
/* See if the directory is already known. */
directory = get_parent_directory_if_exists (location);
if (directory == NULL) {
/* In case the directory is not being
* monitored, but the corresponding file is,
* we must invalidate it's item count.
*/
file = NULL;
parent = g_file_get_parent (location);
if (parent) {
file = nautilus_file_get_existing (parent);
g_object_unref (parent);
}
if (file != NULL) {
nautilus_file_invalidate_count_and_mime_list (file);
nautilus_file_unref (file);
}
continue;
}
collect_parent_directories (parent_directories, directory);
/* If no one is monitoring files in the directory, nothing to do. */
if (!nautilus_directory_is_file_list_monitored (directory)) {
nautilus_directory_unref (directory);
continue;
}
file = nautilus_file_get_existing (location);
/* We check is_added here, because the file could have been added
* to the directory by a nautilus_file_get() but not gotten
* files_added emitted
*/
if (file && file->details->is_added) {
/* A file already exists, it was probably renamed.
* If it was renamed this could be ignored, but
* queue a change just in case */
nautilus_file_changed (file);
nautilus_file_unref (file);
} else {
hash_table_list_prepend (added_lists,
directory,
g_object_ref (location));
}
nautilus_directory_unref (directory);
}
/* Now get file info for the new files. This creates NautilusFile
* objects for the new files, and sends out a files_added signal.
*/
g_hash_table_foreach (added_lists, call_get_file_info_free_list, NULL);
g_hash_table_destroy (added_lists);
/* Invalidate count for each parent directory. */
g_hash_table_foreach (parent_directories, invalidate_count_and_unref, NULL);
g_hash_table_destroy (parent_directories);
}
void
nautilus_self_check_directory (void)
{
NautilusDirectory *directory;
NautilusFile *file;
directory = nautilus_directory_get_by_uri ("file:///etc");
file = nautilus_file_get_by_uri ("file:///etc/passwd");
EEL_CHECK_INTEGER_RESULT (g_hash_table_size (directories), 1);
nautilus_directory_file_monitor_add
(directory, &data_dummy,
TRUE, 0, NULL, NULL);
/* FIXME: these need to be updated to the new metadata infrastructure
* as make check doesn't pass.
nautilus_file_set_metadata (file, "test", "default", "value");
EEL_CHECK_STRING_RESULT (nautilus_file_get_metadata (file, "test", "default"), "value");
nautilus_file_set_boolean_metadata (file, "test_boolean", TRUE, TRUE);
EEL_CHECK_BOOLEAN_RESULT (nautilus_file_get_boolean_metadata (file, "test_boolean", TRUE), TRUE);
nautilus_file_set_boolean_metadata (file, "test_boolean", TRUE, FALSE);
EEL_CHECK_BOOLEAN_RESULT (nautilus_file_get_boolean_metadata (file, "test_boolean", TRUE), FALSE);
EEL_CHECK_BOOLEAN_RESULT (nautilus_file_get_boolean_metadata (NULL, "test_boolean", TRUE), TRUE);
nautilus_file_set_integer_metadata (file, "test_integer", 0, 17);
EEL_CHECK_INTEGER_RESULT (nautilus_file_get_integer_metadata (file, "test_integer", 0), 17);
nautilus_file_set_integer_metadata (file, "test_integer", 0, -1);
EEL_CHECK_INTEGER_RESULT (nautilus_file_get_integer_metadata (file, "test_integer", 0), -1);
nautilus_file_set_integer_metadata (file, "test_integer", 42, 42);
EEL_CHECK_INTEGER_RESULT (nautilus_file_get_integer_metadata (file, "test_integer", 42), 42);
EEL_CHECK_INTEGER_RESULT (nautilus_file_get_integer_metadata (NULL, "test_integer", 42), 42);
EEL_CHECK_INTEGER_RESULT (nautilus_file_get_integer_metadata (file, "nonexistent_key", 42), 42);
*/
EEL_CHECK_BOOLEAN_RESULT (nautilus_directory_get_by_uri ("file:///etc") == directory, TRUE);
nautilus_directory_unref (directory);
EEL_CHECK_BOOLEAN_RESULT (nautilus_directory_get_by_uri ("file:///etc/") == directory, TRUE);
nautilus_directory_unref (directory);
EEL_CHECK_BOOLEAN_RESULT (nautilus_directory_get_by_uri ("file:///etc////") == directory, TRUE);
nautilus_directory_unref (directory);
nautilus_file_unref (file);
nautilus_directory_file_monitor_remove (directory, &data_dummy);
nautilus_directory_unref (directory);
while (g_hash_table_size (directories) != 0) {
gtk_main_iteration ();
}
EEL_CHECK_INTEGER_RESULT (g_hash_table_size (directories), 0);
directory = nautilus_directory_get_by_uri ("file:///etc");
got_files_flag = FALSE;
nautilus_directory_call_when_ready (directory,
NAUTILUS_FILE_ATTRIBUTE_INFO |
NAUTILUS_FILE_ATTRIBUTE_DEEP_COUNTS,
TRUE,
got_files_callback, &data_dummy);
while (!got_files_flag) {
gtk_main_iteration ();
}
EEL_CHECK_BOOLEAN_RESULT (directory->details->file_list == NULL, TRUE);
EEL_CHECK_INTEGER_RESULT (g_hash_table_size (directories), 1);
file = nautilus_file_get_by_uri ("file:///etc/passwd");
/* EEL_CHECK_STRING_RESULT (nautilus_file_get_metadata (file, "test", "default"), "value"); */
nautilus_file_unref (file);
nautilus_directory_unref (directory);
EEL_CHECK_INTEGER_RESULT (g_hash_table_size (directories), 0);
}
void
nautilus_directory_notify_files_moved (GList *file_pairs)
{
GList *p, *affected_files, *node;
GFilePair *pair;
NautilusFile *file;
NautilusDirectory *old_directory, *new_directory;
GHashTable *parent_directories;
GList *new_files_list, *unref_list;
GHashTable *added_lists, *changed_lists;
char *name;
NautilusFileAttributes cancel_attributes;
GFile *to_location, *from_location;
/* Make a list of added and changed files in each directory. */
new_files_list = NULL;
added_lists = g_hash_table_new (NULL, NULL);
changed_lists = g_hash_table_new (NULL, NULL);
unref_list = NULL;
/* Make a list of parent directories that will need their counts updated. */
parent_directories = g_hash_table_new (NULL, NULL);
cancel_attributes = nautilus_file_get_all_attributes ();
for (p = file_pairs; p != NULL; p = p->next) {
pair = p->data;
from_location = pair->from;
to_location = pair->to;
/* Handle overwriting a file. */
file = nautilus_file_get_existing (to_location);
if (file != NULL) {
/* Mark it gone and prepare to send the changed signal. */
nautilus_file_mark_gone (file);
new_directory = file->details->directory;
hash_table_list_prepend (changed_lists,
new_directory,
file);
collect_parent_directories (parent_directories,
new_directory);
}
/* Update any directory objects that are affected. */
affected_files = nautilus_directory_moved_internal (from_location,
to_location);
for (node = affected_files; node != NULL; node = node->next) {
file = NAUTILUS_FILE (node->data);
hash_table_list_prepend (changed_lists,
file->details->directory,
file);
}
unref_list = g_list_concat (unref_list, affected_files);
/* Move an existing file. */
file = nautilus_file_get_existing (from_location);
if (file == NULL) {
/* Handle this as if it was a new file. */
new_files_list = g_list_prepend (new_files_list,
to_location);
} else {
/* Handle notification in the old directory. */
old_directory = file->details->directory;
collect_parent_directories (parent_directories, old_directory);
/* Cancel loading of attributes in the old directory */
nautilus_directory_cancel_loading_file_attributes
(old_directory, file, cancel_attributes);
/* Locate the new directory. */
new_directory = get_parent_directory (to_location);
collect_parent_directories (parent_directories, new_directory);
/* We can unref now -- new_directory is in the
* parent directories list so it will be
* around until the end of this function
* anyway.
*/
nautilus_directory_unref (new_directory);
/* Update the file's name and directory. */
name = g_file_get_basename (to_location);
nautilus_file_update_name_and_directory
(file, name, new_directory);
g_free (name);
/* Update file attributes */
nautilus_file_invalidate_attributes (file, NAUTILUS_FILE_ATTRIBUTE_INFO);
hash_table_list_prepend (changed_lists,
old_directory,
file);
if (old_directory != new_directory) {
hash_table_list_prepend (added_lists,
new_directory,
file);
}
/* Unref each file once to balance out nautilus_file_get_by_uri. */
unref_list = g_list_prepend (unref_list, file);
}
}
/* Now send out the changed and added signals for existing file objects. */
g_hash_table_foreach (changed_lists, call_files_changed_free_list, NULL);
g_hash_table_destroy (changed_lists);
g_hash_table_foreach (added_lists, call_files_added_free_list, NULL);
g_hash_table_destroy (added_lists);
/* Let the file objects go. */
nautilus_file_list_free (unref_list);
/* Invalidate count for each parent directory. */
g_hash_table_foreach (parent_directories, invalidate_count_and_unref, NULL);
g_hash_table_destroy (parent_directories);
/* Separate handling for brand new file objects. */
nautilus_directory_notify_files_added (new_files_list);
g_list_free (new_files_list);
}