diff options
Diffstat (limited to 'src/nautilus-vfs-file.c')
| -rw-r--r-- | src/nautilus-vfs-file.c | 696 |
1 files changed, 696 insertions, 0 deletions
diff --git a/src/nautilus-vfs-file.c b/src/nautilus-vfs-file.c new file mode 100644 index 000000000..0a37be573 --- /dev/null +++ b/src/nautilus-vfs-file.c @@ -0,0 +1,696 @@ +/* + nautilus-vfs-file.c: Subclass of NautilusFile to help implement the + virtual trash directory. + + 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 <http://www.gnu.org/licenses/>. + + Author: Darin Adler <darin@bentspoon.com> +*/ + +#include <config.h> +#include "nautilus-vfs-file.h" + +#include "nautilus-directory-notify.h" +#include "nautilus-directory-private.h" +#include "nautilus-file-private.h" +#include <glib/gi18n.h> + +G_DEFINE_TYPE (NautilusVFSFile, nautilus_vfs_file, NAUTILUS_TYPE_FILE); + +static void +vfs_file_monitor_add (NautilusFile *file, + gconstpointer client, + NautilusFileAttributes attributes) +{ + nautilus_directory_monitor_add_internal + (file->details->directory, file, + client, TRUE, attributes, NULL, NULL); +} + +static void +vfs_file_monitor_remove (NautilusFile *file, + gconstpointer client) +{ + nautilus_directory_monitor_remove_internal + (file->details->directory, file, client); +} + +static void +vfs_file_call_when_ready (NautilusFile *file, + NautilusFileAttributes file_attributes, + NautilusFileCallback callback, + gpointer callback_data) + +{ + nautilus_directory_call_when_ready_internal + (file->details->directory, file, + file_attributes, FALSE, NULL, callback, callback_data); +} + +static void +vfs_file_cancel_call_when_ready (NautilusFile *file, + NautilusFileCallback callback, + gpointer callback_data) +{ + nautilus_directory_cancel_callback_internal + (file->details->directory, file, + NULL, callback, callback_data); +} + +static gboolean +vfs_file_check_if_ready (NautilusFile *file, + NautilusFileAttributes file_attributes) +{ + return nautilus_directory_check_if_ready_internal + (file->details->directory, file, + file_attributes); +} + +static void +set_metadata_get_info_callback (GObject *source_object, + GAsyncResult *res, + gpointer callback_data) +{ + NautilusFile *file; + GFileInfo *new_info; + GError *error; + + file = callback_data; + + error = NULL; + new_info = g_file_query_info_finish (G_FILE (source_object), res, &error); + if (new_info != NULL) { + if (nautilus_file_update_info (file, new_info)) { + nautilus_file_changed (file); + } + g_object_unref (new_info); + } + nautilus_file_unref (file); + if (error) { + g_error_free (error); + } +} + +static void +set_metadata_callback (GObject *source_object, + GAsyncResult *result, + gpointer callback_data) +{ + NautilusFile *file; + GError *error; + gboolean res; + + file = callback_data; + + error = NULL; + res = g_file_set_attributes_finish (G_FILE (source_object), + result, + NULL, + &error); + + if (res) { + g_file_query_info_async (G_FILE (source_object), + NAUTILUS_FILE_DEFAULT_ATTRIBUTES, + 0, + G_PRIORITY_DEFAULT, + NULL, + set_metadata_get_info_callback, file); + } else { + nautilus_file_unref (file); + g_error_free (error); + } +} + +static void +vfs_file_set_metadata (NautilusFile *file, + const char *key, + const char *value) +{ + GFileInfo *info; + GFile *location; + char *gio_key; + + info = g_file_info_new (); + + gio_key = g_strconcat ("metadata::", key, NULL); + if (value != NULL) { + g_file_info_set_attribute_string (info, gio_key, value); + } else { + /* Unset the key */ + g_file_info_set_attribute (info, gio_key, + G_FILE_ATTRIBUTE_TYPE_INVALID, + NULL); + } + g_free (gio_key); + + location = nautilus_file_get_location (file); + g_file_set_attributes_async (location, + info, + 0, + G_PRIORITY_DEFAULT, + NULL, + set_metadata_callback, + nautilus_file_ref (file)); + g_object_unref (location); + g_object_unref (info); +} + +static void +vfs_file_set_metadata_as_list (NautilusFile *file, + const char *key, + char **value) +{ + GFile *location; + GFileInfo *info; + char *gio_key; + + info = g_file_info_new (); + + gio_key = g_strconcat ("metadata::", key, NULL); + g_file_info_set_attribute_stringv (info, gio_key, value); + g_free (gio_key); + + location = nautilus_file_get_location (file); + g_file_set_attributes_async (location, + info, + 0, + G_PRIORITY_DEFAULT, + NULL, + set_metadata_callback, + nautilus_file_ref (file)); + g_object_unref (info); + g_object_unref (location); +} + +static gboolean +vfs_file_get_item_count (NautilusFile *file, + guint *count, + gboolean *count_unreadable) +{ + if (count_unreadable != NULL) { + *count_unreadable = file->details->directory_count_failed; + } + if (!file->details->got_directory_count) { + if (count != NULL) { + *count = 0; + } + return FALSE; + } + if (count != NULL) { + *count = file->details->directory_count; + } + return TRUE; +} + +static NautilusRequestStatus +vfs_file_get_deep_counts (NautilusFile *file, + guint *directory_count, + guint *file_count, + guint *unreadable_directory_count, + goffset *total_size) +{ + GFileType type; + + if (directory_count != NULL) { + *directory_count = 0; + } + if (file_count != NULL) { + *file_count = 0; + } + if (unreadable_directory_count != NULL) { + *unreadable_directory_count = 0; + } + if (total_size != NULL) { + *total_size = 0; + } + + if (!nautilus_file_is_directory (file)) { + return NAUTILUS_REQUEST_DONE; + } + + if (file->details->deep_counts_status != NAUTILUS_REQUEST_NOT_STARTED) { + if (directory_count != NULL) { + *directory_count = file->details->deep_directory_count; + } + if (file_count != NULL) { + *file_count = file->details->deep_file_count; + } + if (unreadable_directory_count != NULL) { + *unreadable_directory_count = file->details->deep_unreadable_count; + } + if (total_size != NULL) { + *total_size = file->details->deep_size; + } + return file->details->deep_counts_status; + } + + /* For directories, or before we know the type, we haven't started. */ + type = nautilus_file_get_file_type (file); + if (type == G_FILE_TYPE_UNKNOWN + || type == G_FILE_TYPE_DIRECTORY) { + return NAUTILUS_REQUEST_NOT_STARTED; + } + + /* For other types, we are done, and the zeros are permanent. */ + return NAUTILUS_REQUEST_DONE; +} + +static gboolean +vfs_file_get_date (NautilusFile *file, + NautilusDateType date_type, + time_t *date) +{ + switch (date_type) { + case NAUTILUS_DATE_TYPE_ACCESSED: + /* Before we have info on a file, the date is unknown. */ + if (file->details->atime == 0) { + return FALSE; + } + if (date != NULL) { + *date = file->details->atime; + } + return TRUE; + case NAUTILUS_DATE_TYPE_MODIFIED: + /* Before we have info on a file, the date is unknown. */ + if (file->details->mtime == 0) { + return FALSE; + } + if (date != NULL) { + *date = file->details->mtime; + } + return TRUE; + case NAUTILUS_DATE_TYPE_TRASHED: + /* Before we have info on a file, the date is unknown. */ + if (file->details->trash_time == 0) { + return FALSE; + } + if (date != NULL) { + *date = file->details->trash_time; + } + return TRUE; + } + return FALSE; +} + +static char * +vfs_file_get_where_string (NautilusFile *file) +{ + GFile *activation_location; + NautilusFile *location; + char *where_string; + + if (!nautilus_file_is_in_recent (file)) { + location = nautilus_file_ref (file); + } else { + activation_location = nautilus_file_get_activation_location (file); + location = nautilus_file_get (activation_location); + g_object_unref (activation_location); + } + + where_string = nautilus_file_get_parent_uri_for_display (location); + + nautilus_file_unref (location); + return where_string; +} + +static void +vfs_file_mount_callback (GObject *source_object, + GAsyncResult *res, + gpointer callback_data) +{ + NautilusFileOperation *op; + GFile *mounted_on; + GError *error; + + op = callback_data; + + error = NULL; + mounted_on = g_file_mount_mountable_finish (G_FILE (source_object), + res, &error); + nautilus_file_operation_complete (op, mounted_on, error); + if (mounted_on) { + g_object_unref (mounted_on); + } + if (error) { + g_error_free (error); + } +} + + +static void +vfs_file_mount (NautilusFile *file, + GMountOperation *mount_op, + GCancellable *cancellable, + NautilusFileOperationCallback callback, + gpointer callback_data) +{ + NautilusFileOperation *op; + GError *error; + GFile *location; + + if (file->details->type != G_FILE_TYPE_MOUNTABLE) { + if (callback) { + error = NULL; + g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, + _("This file cannot be mounted")); + callback (file, NULL, error, callback_data); + g_error_free (error); + } + return; + } + + op = nautilus_file_operation_new (file, callback, callback_data); + if (cancellable) { + g_object_unref (op->cancellable); + op->cancellable = g_object_ref (cancellable); + } + + location = nautilus_file_get_location (file); + g_file_mount_mountable (location, + 0, + mount_op, + op->cancellable, + vfs_file_mount_callback, + op); + g_object_unref (location); +} + +static void +vfs_file_unmount_callback (GObject *source_object, + GAsyncResult *res, + gpointer callback_data) +{ + NautilusFileOperation *op; + gboolean unmounted; + GError *error; + + op = callback_data; + + error = NULL; + unmounted = g_file_unmount_mountable_with_operation_finish (G_FILE (source_object), + res, &error); + + if (!unmounted && + error->domain == G_IO_ERROR && + (error->code == G_IO_ERROR_FAILED_HANDLED || + error->code == G_IO_ERROR_CANCELLED)) { + g_error_free (error); + error = NULL; + } + + nautilus_file_operation_complete (op, G_FILE (source_object), error); + if (error) { + g_error_free (error); + } +} + +static void +vfs_file_unmount (NautilusFile *file, + GMountOperation *mount_op, + GCancellable *cancellable, + NautilusFileOperationCallback callback, + gpointer callback_data) +{ + NautilusFileOperation *op; + GFile *location; + + op = nautilus_file_operation_new (file, callback, callback_data); + if (cancellable) { + g_object_unref (op->cancellable); + op->cancellable = g_object_ref (cancellable); + } + + location = nautilus_file_get_location (file); + g_file_unmount_mountable_with_operation (location, + G_MOUNT_UNMOUNT_NONE, + mount_op, + op->cancellable, + vfs_file_unmount_callback, + op); + g_object_unref (location); +} + +static void +vfs_file_eject_callback (GObject *source_object, + GAsyncResult *res, + gpointer callback_data) +{ + NautilusFileOperation *op; + gboolean ejected; + GError *error; + + op = callback_data; + + error = NULL; + ejected = g_file_eject_mountable_with_operation_finish (G_FILE (source_object), + res, &error); + + if (!ejected && + error->domain == G_IO_ERROR && + (error->code == G_IO_ERROR_FAILED_HANDLED || + error->code == G_IO_ERROR_CANCELLED)) { + g_error_free (error); + error = NULL; + } + + nautilus_file_operation_complete (op, G_FILE (source_object), error); + if (error) { + g_error_free (error); + } +} + +static void +vfs_file_eject (NautilusFile *file, + GMountOperation *mount_op, + GCancellable *cancellable, + NautilusFileOperationCallback callback, + gpointer callback_data) +{ + NautilusFileOperation *op; + GFile *location; + + op = nautilus_file_operation_new (file, callback, callback_data); + if (cancellable) { + g_object_unref (op->cancellable); + op->cancellable = g_object_ref (cancellable); + } + + location = nautilus_file_get_location (file); + g_file_eject_mountable_with_operation (location, + G_MOUNT_UNMOUNT_NONE, + mount_op, + op->cancellable, + vfs_file_eject_callback, + op); + g_object_unref (location); +} + +static void +vfs_file_start_callback (GObject *source_object, + GAsyncResult *res, + gpointer callback_data) +{ + NautilusFileOperation *op; + gboolean started; + GError *error; + + op = callback_data; + + error = NULL; + started = g_file_start_mountable_finish (G_FILE (source_object), + res, &error); + + if (!started && + error->domain == G_IO_ERROR && + (error->code == G_IO_ERROR_FAILED_HANDLED || + error->code == G_IO_ERROR_CANCELLED)) { + g_error_free (error); + error = NULL; + } + + nautilus_file_operation_complete (op, G_FILE (source_object), error); + if (error) { + g_error_free (error); + } +} + + +static void +vfs_file_start (NautilusFile *file, + GMountOperation *mount_op, + GCancellable *cancellable, + NautilusFileOperationCallback callback, + gpointer callback_data) +{ + NautilusFileOperation *op; + GError *error; + GFile *location; + + if (file->details->type != G_FILE_TYPE_MOUNTABLE) { + if (callback) { + error = NULL; + g_set_error_literal (&error, G_IO_ERROR, G_IO_ERROR_NOT_SUPPORTED, + _("This file cannot be started")); + callback (file, NULL, error, callback_data); + g_error_free (error); + } + return; + } + + op = nautilus_file_operation_new (file, callback, callback_data); + if (cancellable) { + g_object_unref (op->cancellable); + op->cancellable = g_object_ref (cancellable); + } + + location = nautilus_file_get_location (file); + g_file_start_mountable (location, + 0, + mount_op, + op->cancellable, + vfs_file_start_callback, + op); + g_object_unref (location); +} + +static void +vfs_file_stop_callback (GObject *source_object, + GAsyncResult *res, + gpointer callback_data) +{ + NautilusFileOperation *op; + gboolean stopped; + GError *error; + + op = callback_data; + + error = NULL; + stopped = g_file_stop_mountable_finish (G_FILE (source_object), + res, &error); + + if (!stopped && + error->domain == G_IO_ERROR && + (error->code == G_IO_ERROR_FAILED_HANDLED || + error->code == G_IO_ERROR_CANCELLED)) { + g_error_free (error); + error = NULL; + } + + nautilus_file_operation_complete (op, G_FILE (source_object), error); + if (error) { + g_error_free (error); + } +} + +static void +vfs_file_stop (NautilusFile *file, + GMountOperation *mount_op, + GCancellable *cancellable, + NautilusFileOperationCallback callback, + gpointer callback_data) +{ + NautilusFileOperation *op; + GFile *location; + + op = nautilus_file_operation_new (file, callback, callback_data); + if (cancellable) { + g_object_unref (op->cancellable); + op->cancellable = g_object_ref (cancellable); + } + + location = nautilus_file_get_location (file); + g_file_stop_mountable (location, + G_MOUNT_UNMOUNT_NONE, + mount_op, + op->cancellable, + vfs_file_stop_callback, + op); + g_object_unref (location); +} + +static void +vfs_file_poll_callback (GObject *source_object, + GAsyncResult *res, + gpointer callback_data) +{ + NautilusFileOperation *op; + gboolean stopped; + GError *error; + + op = callback_data; + + error = NULL; + stopped = g_file_poll_mountable_finish (G_FILE (source_object), + res, &error); + + if (!stopped && + error->domain == G_IO_ERROR && + (error->code == G_IO_ERROR_FAILED_HANDLED || + error->code == G_IO_ERROR_CANCELLED)) { + g_error_free (error); + error = NULL; + } + + nautilus_file_operation_complete (op, G_FILE (source_object), error); + if (error) { + g_error_free (error); + } +} + +static void +vfs_file_poll_for_media (NautilusFile *file) +{ + NautilusFileOperation *op; + GFile *location; + + op = nautilus_file_operation_new (file, NULL, NULL); + + location = nautilus_file_get_location (file); + g_file_poll_mountable (location, + op->cancellable, + vfs_file_poll_callback, + op); + g_object_unref (location); +} + +static void +nautilus_vfs_file_init (NautilusVFSFile *file) +{ +} + +static void +nautilus_vfs_file_class_init (NautilusVFSFileClass *klass) +{ + NautilusFileClass *file_class = NAUTILUS_FILE_CLASS (klass); + + file_class->monitor_add = vfs_file_monitor_add; + file_class->monitor_remove = vfs_file_monitor_remove; + file_class->call_when_ready = vfs_file_call_when_ready; + file_class->cancel_call_when_ready = vfs_file_cancel_call_when_ready; + file_class->check_if_ready = vfs_file_check_if_ready; + file_class->get_item_count = vfs_file_get_item_count; + file_class->get_deep_counts = vfs_file_get_deep_counts; + file_class->get_date = vfs_file_get_date; + file_class->get_where_string = vfs_file_get_where_string; + file_class->set_metadata = vfs_file_set_metadata; + file_class->set_metadata_as_list = vfs_file_set_metadata_as_list; + file_class->mount = vfs_file_mount; + file_class->unmount = vfs_file_unmount; + file_class->eject = vfs_file_eject; + file_class->start = vfs_file_start; + file_class->stop = vfs_file_stop; + file_class->poll_for_media = vfs_file_poll_for_media; +} |