void nemo_directory_add_file (NemoDirectory *directory, NemoFile *file) { GList *node; gboolean add_to_work_queue; g_assert (NEMO_IS_DIRECTORY (directory)); g_assert (NEMO_IS_FILE (file)); g_assert (file->details->name != NULL); /* Add to list. */ node = g_list_prepend (directory->details->file_list, file); directory->details->file_list = node; /* Add to hash table. */ add_to_hash_table (directory, file, node); directory->details->confirmed_file_count++; add_to_work_queue = FALSE; if (nemo_directory_is_file_list_monitored (directory)) { /* Ref if we are monitoring, since monitoring owns the file list. */ nemo_file_ref (file); add_to_work_queue = TRUE; } else if (nemo_directory_has_active_request_for_file (directory, file)) { /* We're waiting for the file in a call_when_ready. Make sure we add the file to the work queue so that said waiter won't wait forever for e.g. all files in the directory to be done */ add_to_work_queue = TRUE; } if (add_to_work_queue) { nemo_directory_add_file_to_work_queue (directory, file); } }
GList * nemo_directory_match_pattern (NemoDirectory *directory, const char *pattern) { GList *files, *l, *ret; GPatternSpec *spec; ret = NULL; spec = g_pattern_spec_new (pattern); files = nemo_directory_get_file_list (directory); for (l = files; l; l = l->next) { NemoFile *file; char *name; file = NEMO_FILE (l->data); name = nemo_file_get_display_name (file); if (g_pattern_match_string (spec, name)) { ret = g_list_prepend(ret, nemo_file_ref (file)); } g_free (name); } g_pattern_spec_free (spec); nemo_file_list_free (files); return ret; }
void nemo_directory_moved (const char *old_uri, const char *new_uri) { GList *list, *node; GHashTable *hash; NemoFile *file; GFile *old_location; GFile *new_location; hash = g_hash_table_new (NULL, NULL); old_location = g_file_new_for_uri (old_uri); new_location = g_file_new_for_uri (new_uri); list = nemo_directory_moved_internal (old_location, new_location); for (node = list; node != NULL; node = node->next) { file = NEMO_FILE (node->data); hash_table_list_prepend (hash, file->details->directory, nemo_file_ref (file)); } nemo_file_list_free (list); g_object_unref (old_location); g_object_unref (new_location); g_hash_table_foreach (hash, call_files_changed_unref_free_list, NULL); g_hash_table_destroy (hash); }
static GList * nemo_directory_moved_internal (GFile *old_location, GFile *new_location) { CollectData collection; NemoDirectory *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 = NEMO_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, nemo_file_ref (directory->details->as_file)); } affected_files = g_list_concat (affected_files, nemo_file_list_copy (directory->details->file_list)); } nemo_directory_unref (directory); } g_list_free (collection.directories); return affected_files; }
static TreeNode * tree_node_new (NemoFile *file, FMTreeModelRoot *root) { TreeNode *node; node = g_new0 (TreeNode, 1); node->file = nemo_file_ref (file); node->root = root; return node; }
NemoFile * fm_tree_model_iter_get_file (FMTreeModel *model, GtkTreeIter *iter) { TreeNode *node; g_return_val_if_fail (FM_IS_TREE_MODEL (model), NULL); g_return_val_if_fail (iter_is_valid (FM_TREE_MODEL (model), iter), NULL); node = iter->user_data; return node == NULL ? NULL : nemo_file_ref (node->file); }
void nemo_directory_notify_files_removed (GList *files) { GHashTable *changed_lists; GList *p; NemoDirectory *directory; GHashTable *parent_directories; NemoFile *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); nemo_directory_unref (directory); } /* Find the file. */ file = nemo_file_get_existing (location); if (file != NULL && !nemo_file_rename_in_progress (file)) { /* Mark it gone and prepare to send the changed signal. */ nemo_file_mark_gone (file); hash_table_list_prepend (changed_lists, file->details->directory, nemo_file_ref (file)); } nemo_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); }
/* Returns a reffed NemoFile object for this directory, but only if the * NemoFile object has already been created. */ NemoFile * nemo_directory_get_existing_corresponding_file (NemoDirectory *directory) { NemoFile *file; char *uri; file = directory->details->as_file; if (file != NULL) { nemo_file_ref (file); return file; } uri = nemo_directory_get_uri (directory); file = nemo_file_get_existing_by_uri (uri); g_free (uri); return file; }
void nemo_file_queue_enqueue (NemoFileQueue *queue, NemoFile *file) { if (g_hash_table_lookup (queue->item_to_link_map, file) != NULL) { /* It's already on the queue. */ return; } if (queue->tail == NULL) { queue->head = g_list_append (NULL, file); queue->tail = queue->head; } else { queue->tail = g_list_append (queue->tail, file); queue->tail = queue->tail->next; } nemo_file_ref (file); g_hash_table_insert (queue->item_to_link_map, file, queue->tail); }
gboolean nemo_list_model_add_file (NemoListModel *model, NemoFile *file, NemoDirectory *directory) { GtkTreeIter iter; GtkTreePath *path; FileEntry *file_entry; GSequenceIter *ptr, *parent_ptr; GSequence *files; gboolean replace_dummy; GHashTable *parent_hash; parent_ptr = g_hash_table_lookup (model->details->directory_reverse_map, directory); if (parent_ptr) { file_entry = g_sequence_get (parent_ptr); ptr = g_hash_table_lookup (file_entry->reverse_map, file); } else { file_entry = NULL; ptr = g_hash_table_lookup (model->details->top_reverse_map, file); } if (ptr != NULL) { g_warning ("file already in tree (parent_ptr: %p)!!!\n", parent_ptr); return FALSE; } file_entry = g_new0 (FileEntry, 1); file_entry->file = nemo_file_ref (file); file_entry->parent = NULL; file_entry->subdirectory = NULL; file_entry->files = NULL; files = model->details->files; parent_hash = model->details->top_reverse_map; replace_dummy = FALSE; if (parent_ptr != NULL) { file_entry->parent = g_sequence_get (parent_ptr); /* At this point we set loaded. Either we saw * "done" and ignored it waiting for this, or we do this * earlier, but then we replace the dummy row anyway, * so it doesn't matter */ file_entry->parent->loaded = 1; parent_hash = file_entry->parent->reverse_map; files = file_entry->parent->files; if (g_sequence_get_length (files) == 1) { GSequenceIter *dummy_ptr = g_sequence_get_iter_at_pos (files, 0); FileEntry *dummy_entry = g_sequence_get (dummy_ptr); if (dummy_entry->file == NULL) { /* replace the dummy loading entry */ model->details->stamp++; g_sequence_remove (dummy_ptr); replace_dummy = TRUE; } } } file_entry->ptr = g_sequence_insert_sorted (files, file_entry, nemo_list_model_file_entry_compare_func, model); g_hash_table_insert (parent_hash, file, file_entry->ptr); iter.stamp = model->details->stamp; iter.user_data = file_entry->ptr; path = gtk_tree_model_get_path (GTK_TREE_MODEL (model), &iter); if (replace_dummy) { gtk_tree_model_row_changed (GTK_TREE_MODEL (model), path, &iter); } else { gtk_tree_model_row_inserted (GTK_TREE_MODEL (model), path, &iter); } if (nemo_file_is_directory (file)) { file_entry->files = g_sequence_new ((GDestroyNotify)file_entry_free); add_dummy_row (model, file_entry); gtk_tree_model_row_has_child_toggled (GTK_TREE_MODEL (model), path, &iter); } gtk_tree_path_free (path); return TRUE; }