static void
trash_bar_response_cb (GtkInfoBar *infobar,
gint response_id,
gpointer user_data)
{
NautilusTrashBar *bar;
GtkWidget *window;
GList *files;
bar = NAUTILUS_TRASH_BAR (infobar);
window = gtk_widget_get_toplevel (GTK_WIDGET (bar));
switch (response_id) {
case TRASH_BAR_RESPONSE_EMPTY:
nautilus_file_operations_empty_trash (window);
break;
case TRASH_BAR_RESPONSE_RESTORE:
files = nautilus_view_get_selection (bar->priv->view);
nautilus_restore_files_from_trash (files, GTK_WINDOW (window));
nautilus_file_list_free (files);
break;
default:
break;
}
}
static void
reset_file_list (NautilusSearchDirectory *search)
{
GList *list, *monitor_list;
NautilusFile *file;
SearchMonitor *monitor;
/* Remove file connections */
for (list = search->details->files; list != NULL; list = list->next) {
file = list->data;
/* Disconnect change handler */
g_signal_handlers_disconnect_by_func (file, file_changed, search);
/* Remove monitors */
for (monitor_list = search->details->monitor_list; monitor_list;
monitor_list = monitor_list->next) {
monitor = monitor_list->data;
nautilus_file_monitor_remove (file, monitor);
}
}
nautilus_file_list_free (search->details->files);
search->details->files = NULL;
g_hash_table_remove_all (search->details->files_hash);
}
static void
nautilus_clipboard_info_free (NautilusClipboardInfo *info)
{
nautilus_file_list_free (info->files);
g_slice_free (NautilusClipboardInfo, info);
}
void
nautilus_directory_moved (const char *old_uri,
const char *new_uri)
{
GList *list, *node;
GHashTable *hash;
NautilusFile *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 = nautilus_directory_moved_internal (old_location, new_location);
for (node = list; node != NULL; node = node->next) {
file = NAUTILUS_FILE (node->data);
hash_table_list_prepend (hash,
file->details->directory,
nautilus_file_ref (file));
}
nautilus_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);
}
GList *
nautilus_directory_match_pattern (NautilusDirectory *directory, const char *pattern)
{
GList *files, *l, *ret;
GPatternSpec *spec;
ret = NULL;
spec = g_pattern_spec_new (pattern);
files = nautilus_directory_get_file_list (directory);
for (l = files; l; l = l->next) {
NautilusFile *file;
char *name;
file = NAUTILUS_FILE (l->data);
name = nautilus_file_get_display_name (file);
if (g_pattern_match_string (spec, name)) {
ret = g_list_prepend(ret, nautilus_file_ref (file));
}
g_free (name);
}
g_pattern_spec_free (spec);
nautilus_file_list_free (files);
return ret;
}
static gboolean
skeleton_handle_show_item_properties_cb (NautilusFreedesktopFileManager1 *object,
GDBusMethodInvocation *invocation,
const gchar *const *uris,
const gchar *startup_id,
gpointer data)
{
GList *files;
int i;
files = NULL;
for (i = 0; uris[i] != NULL; i++) {
files = g_list_prepend (files, nautilus_file_get_by_uri (uris[i]));
}
files = g_list_reverse (files);
nautilus_properties_window_present (files, NULL, startup_id);
nautilus_file_list_free (files);
nautilus_freedesktop_file_manager1_complete_show_item_properties (object, invocation);
return TRUE;
}
void
nautilus_file_queue_destroy (NautilusFileQueue *queue)
{
g_hash_table_destroy (queue->item_to_link_map);
nautilus_file_list_free (queue->head);
g_free (queue);
}
static void
call_files_changed_unref_free_list (gpointer key, gpointer value, gpointer user_data)
{
g_assert (value != NULL);
g_assert (user_data == NULL);
call_files_changed_common (NAUTILUS_DIRECTORY (key), value);
nautilus_file_list_free (value);
}
static void
merged_callback_destroy (MergedCallback *merged_callback)
{
g_assert (merged_callback != NULL);
g_assert (NAUTILUS_IS_DESKTOP_DIRECTORY (merged_callback->desktop_dir));
g_list_free (merged_callback->non_ready_directories);
nautilus_file_list_free (merged_callback->merged_file_list);
g_free (merged_callback);
}
static GList *
real_get_file_list (NautilusDirectory *directory)
{
GList *tentative_files, *non_tentative_files;
tentative_files = nautilus_file_list_filter (directory->details->file_list,
&non_tentative_files, is_tentative, NULL);
nautilus_file_list_free (tentative_files);
return non_tentative_files;
}
static void
search_callback_destroy (SearchCallback *search_callback)
{
if (search_callback->non_ready_hash) {
g_hash_table_foreach (search_callback->non_ready_hash, cancel_call_when_ready, search_callback);
g_hash_table_destroy (search_callback->non_ready_hash);
}
nautilus_file_list_free (search_callback->file_list);
g_free (search_callback);
}
static void
nautilus_mime_application_chooser_finalize (GObject *object)
{
NautilusMimeApplicationChooser *chooser;
chooser = NAUTILUS_MIME_APPLICATION_CHOOSER (object);
g_free (chooser->details->content_type);
nautilus_file_list_free (chooser->details->files);
G_OBJECT_CLASS (nautilus_mime_application_chooser_parent_class)->finalize (object);
}
static void
desktop_monitor_add (NautilusDirectory *directory,
gconstpointer client,
gboolean monitor_hidden_files,
NautilusFileAttributes file_attributes,
NautilusDirectoryCallback callback,
gpointer callback_data)
{
NautilusDesktopDirectory *desktop;
MergedMonitor *monitor;
GList *merged_callback_list;
desktop = NAUTILUS_DESKTOP_DIRECTORY (directory);
/* Map the client to a unique value so this doesn't interfere
* with direct monitoring of the directory by the same client.
*/
monitor = g_hash_table_lookup (desktop->details->monitors, client);
if (monitor != NULL) {
g_assert (monitor->desktop_dir == desktop);
} else {
monitor = g_new0 (MergedMonitor, 1);
monitor->desktop_dir = desktop;
g_hash_table_insert (desktop->details->monitors,
(gpointer) client, monitor);
}
monitor->monitor_hidden_files = monitor_hidden_files;
monitor->monitor_attributes = file_attributes;
/* Call through to the real directory add calls. */
merged_callback_list = NULL;
/* Call up to real dir */
nautilus_directory_file_monitor_add
(desktop->details->real_directory, monitor,
monitor_hidden_files,
file_attributes,
build_merged_callback_list, &merged_callback_list);
/* Handle the desktop part */
merged_callback_list = g_list_concat (merged_callback_list,
nautilus_file_list_copy (directory->details->file_list));
if (callback != NULL) {
(* callback) (directory, merged_callback_list, callback_data);
}
nautilus_file_list_free (merged_callback_list);
}
void
emit_change_signals_for_all_files (NautilusDirectory *directory)
{
GList *files;
files = g_list_copy (directory->details->file_list);
if (directory->details->as_file != NULL) {
files = g_list_prepend (files, directory->details->as_file);
}
nautilus_file_list_ref (files);
nautilus_directory_emit_change_signals (directory, files);
nautilus_file_list_free (files);
}
static gboolean
search_directory_file_get_item_count (NautilusFile *file,
guint *count,
gboolean *count_unreadable)
{
GList *file_list;
if (count) {
file_list = nautilus_directory_get_file_list (file->details->directory);
*count = g_list_length (file_list);
nautilus_file_list_free (file_list);
}
return TRUE;
}
static NautilusRequestStatus
search_directory_file_get_deep_counts (NautilusFile *file,
guint *directory_count,
guint *file_count,
guint *unreadable_directory_count,
goffset *total_size)
{
NautilusSearchDirectory *search_dir;
NautilusFile *dir_file;
GList *file_list, *l;
guint dirs, files;
GFileType type;
search_dir = NAUTILUS_SEARCH_DIRECTORY (file->details->directory);
file_list = nautilus_directory_get_file_list (file->details->directory);
dirs = files = 0;
for (l = file_list; l != NULL; l = l->next) {
dir_file = NAUTILUS_FILE (l->data);
type = nautilus_file_get_file_type (dir_file);
if (type == G_FILE_TYPE_DIRECTORY) {
dirs++;
} else {
files++;
}
}
if (directory_count != NULL) {
*directory_count = dirs;
}
if (file_count != NULL) {
*file_count = files;
}
if (unreadable_directory_count != NULL) {
*unreadable_directory_count = 0;
}
if (total_size != NULL) {
/* FIXME: Maybe we want to calculate this? */
*total_size = 0;
}
nautilus_file_list_free (file_list);
return NAUTILUS_REQUEST_DONE;
}
static gboolean
search_directory_file_get_item_count (NautilusFile *file,
guint *count,
gboolean *count_unreadable)
{
NautilusSearchDirectory *search_dir;
GList *file_list;
if (count) {
search_dir = NAUTILUS_SEARCH_DIRECTORY (file->details->directory);
file_list = nautilus_directory_get_file_list (file->details->directory);
*count = g_list_length (file_list);
nautilus_file_list_free (file_list);
}
return TRUE;
}
NautilusFile*
nautilus_directory_get_file_by_name (NautilusDirectory *directory,
const gchar *name)
{
GList *files;
GList *l;
NautilusFile *result = NULL;
files = nautilus_directory_get_file_list (directory);
for (l = files; l != NULL; l = l->next) {
if (nautilus_file_compare_display_name (l->data, name) == 0) {
result = nautilus_file_ref (l->data);
break;
}
}
nautilus_file_list_free (files);
return result;
}
void
nautilus_application_open_location (NautilusApplication *application,
GFile *location,
GFile *selection,
const char *startup_id)
{
NautilusWindow *window;
NautilusWindowSlot *slot;
GList *sel_list = NULL;
nautilus_profile_start (NULL);
slot = get_window_slot_for_location (application, location);
if (!slot) {
window = nautilus_application_create_window (application, gdk_screen_get_default ());
slot = nautilus_window_get_active_slot (window);
} else {
window = nautilus_window_slot_get_window (slot);
nautilus_window_set_active_slot (window, slot);
gtk_window_present (GTK_WINDOW (window));
}
if (selection != NULL) {
sel_list = g_list_prepend (sel_list, nautilus_file_get (selection));
}
gtk_window_set_startup_id (GTK_WINDOW (window), startup_id);
nautilus_window_slot_open_location_full (slot, location, 0, sel_list, NULL, NULL);
if (sel_list != NULL) {
nautilus_file_list_free (sel_list);
}
nautilus_profile_end (NULL);
}
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);
}