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;
}