diff options
author | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-27 15:59:36 +0000 |
---|---|---|
committer | Daniel Baumann <daniel.baumann@progress-linux.org> | 2024-04-27 15:59:36 +0000 |
commit | ec52555862913a23417735f9f7f5402f5230da13 (patch) | |
tree | 5e43a30d289a3daa69dddfbb060216ff6332f197 /src/nautilus-operations-ui-manager.c | |
parent | Initial commit. (diff) | |
download | nautilus-ec52555862913a23417735f9f7f5402f5230da13.tar.xz nautilus-ec52555862913a23417735f9f7f5402f5230da13.zip |
Adding upstream version 3.38.2.upstream/3.38.2upstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to '')
-rw-r--r-- | src/nautilus-operations-ui-manager.c | 576 |
1 files changed, 576 insertions, 0 deletions
diff --git a/src/nautilus-operations-ui-manager.c b/src/nautilus-operations-ui-manager.c new file mode 100644 index 0000000..a932a2d --- /dev/null +++ b/src/nautilus-operations-ui-manager.c @@ -0,0 +1,576 @@ +#include <glib/gi18n.h> + +#include "nautilus-operations-ui-manager.h" + +#include "nautilus-file.h" +#include "nautilus-file-operations.h" +#include "nautilus-file-conflict-dialog.h" +#include "nautilus-mime-actions.h" +#include "nautilus-program-choosing.h" + +typedef struct +{ + GSourceFunc source_func; + gpointer user_data; + GMutex mutex; + GCond cond; + gboolean completed; +} ContextInvokeData; + +G_LOCK_DEFINE_STATIC (main_context_sync); + +static gboolean +invoke_main_context_source_func_wrapper (gpointer user_data) +{ + ContextInvokeData *data = user_data; + + g_mutex_lock (&data->mutex); + + while (data->source_func (data->user_data)) + { + } + + data->completed = TRUE; + + g_cond_signal (&data->cond); + g_mutex_unlock (&data->mutex); + + return G_SOURCE_REMOVE; +} + +/* This function is used to run UI on the main thread in order to ask the user + * for an action during an operation. Since the operation cannot progress until + * an action is provided by the user, the current thread needs to be blocked. + * For this we wait on a condition on the shared data. We proceed further + * unblocking the thread when the condition is set in the UI thread. + */ +static void +invoke_main_context_sync (GMainContext *main_context, + GSourceFunc source_func, + gpointer user_data) +{ + ContextInvokeData data; + /* Allow only one thread at a time to invoke the main context so we + * don't get race conditions which could lead to multiple dialogs being + * displayed at the same time + */ + G_LOCK (main_context_sync); + + data.source_func = source_func; + data.user_data = user_data; + + g_mutex_init (&data.mutex); + g_cond_init (&data.cond); + data.completed = FALSE; + + g_mutex_lock (&data.mutex); + + g_main_context_invoke (main_context, + invoke_main_context_source_func_wrapper, + &data); + + while (!data.completed) + { + g_cond_wait (&data.cond, &data.mutex); + } + + g_mutex_unlock (&data.mutex); + + G_UNLOCK (main_context_sync); + + g_mutex_clear (&data.mutex); + g_cond_clear (&data.cond); +} + +typedef struct +{ + GFile *source_name; + GFile *destination_name; + GFile *destination_directory_name; + + GtkWindow *parent; + + FileConflictResponse *response; + + NautilusFile *source; + NautilusFile *destination; + NautilusFile *destination_directory; + + NautilusFileConflictDialog *dialog; + + NautilusFileListCallback on_file_list_ready; + NautilusFileListHandle *handle; + gulong source_handler_id; + gulong destination_handler_id; +} FileConflictDialogData; + +void +file_conflict_response_free (FileConflictResponse *response) +{ + g_free (response->new_name); + g_slice_free (FileConflictResponse, response); +} + +static void +set_copy_move_dialog_text (FileConflictDialogData *data) +{ + g_autofree gchar *primary_text = NULL; + g_autofree gchar *secondary_text = NULL; + const gchar *message_extra; + time_t source_mtime; + time_t destination_mtime; + g_autofree gchar *message = NULL; + g_autofree gchar *destination_name = NULL; + g_autofree gchar *destination_directory_name = NULL; + gboolean source_is_directory; + gboolean destination_is_directory; + + source_mtime = nautilus_file_get_mtime (data->source); + destination_mtime = nautilus_file_get_mtime (data->destination); + + destination_name = nautilus_file_get_display_name (data->destination); + destination_directory_name = nautilus_file_get_display_name (data->destination_directory); + + source_is_directory = nautilus_file_is_directory (data->source); + destination_is_directory = nautilus_file_is_directory (data->destination); + + if (destination_is_directory) + { + if (nautilus_file_is_symbolic_link (data->source) + && !nautilus_file_is_symbolic_link (data->destination)) + { + primary_text = g_strdup_printf (_("You are trying to replace the destination folder “%s” with a symbolic link."), + destination_name); + message = g_strdup_printf (_("This is not allowed in order to avoid the deletion of the destination folder’s contents.")); + message_extra = _("Please rename the symbolic link or press the skip button."); + } + else if (source_is_directory) + { + primary_text = g_strdup_printf (_("Merge folder “%s”?"), + destination_name); + + message_extra = _("Merging will ask for confirmation before replacing any files in " + "the folder that conflict with the files being copied."); + + if (source_mtime > destination_mtime) + { + message = g_strdup_printf (_("An older folder with the same name already exists in “%s”."), + destination_directory_name); + } + else if (source_mtime < destination_mtime) + { + message = g_strdup_printf (_("A newer folder with the same name already exists in “%s”."), + destination_directory_name); + } + else + { + message = g_strdup_printf (_("Another folder with the same name already exists in “%s”."), + destination_directory_name); + } + } + else + { + primary_text = g_strdup_printf (_("Replace folder “%s”?"), + destination_name); + message_extra = _("Replacing it will remove all files in the folder."); + message = g_strdup_printf (_("A folder with the same name already exists in “%s”."), + destination_directory_name); + } + } + else + { + primary_text = g_strdup_printf (_("Replace file “%s”?"), + destination_name); + + message_extra = _("Replacing it will overwrite its content."); + + if (source_mtime > destination_mtime) + { + message = g_strdup_printf (_("An older file with the same name already exists in “%s”."), + destination_directory_name); + } + else if (source_mtime < destination_mtime) + { + message = g_strdup_printf (_("A newer file with the same name already exists in “%s”."), + destination_directory_name); + } + else + { + message = g_strdup_printf (_("Another file with the same name already exists in “%s”."), + destination_directory_name); + } + } + + secondary_text = g_strdup_printf ("%s\n%s", message, message_extra); + + nautilus_file_conflict_dialog_set_text (data->dialog, + primary_text, + secondary_text); +} + +static void +set_images (FileConflictDialogData *data) +{ + GdkPixbuf *source_pixbuf; + GdkPixbuf *destination_pixbuf; + + destination_pixbuf = nautilus_file_get_icon_pixbuf (data->destination, + NAUTILUS_CANVAS_ICON_SIZE_SMALL, + TRUE, + 1, + NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS); + + source_pixbuf = nautilus_file_get_icon_pixbuf (data->source, + NAUTILUS_CANVAS_ICON_SIZE_SMALL, + TRUE, + 1, + NAUTILUS_FILE_ICON_FLAGS_USE_THUMBNAILS); + + nautilus_file_conflict_dialog_set_images (data->dialog, + destination_pixbuf, + source_pixbuf); + + g_object_unref (destination_pixbuf); + g_object_unref (source_pixbuf); +} + +static void +set_file_labels (FileConflictDialogData *data) +{ + GString *destination_label; + GString *source_label; + gboolean source_is_directory; + gboolean destination_is_directory; + gboolean should_show_type; + g_autofree char *destination_mime_type = NULL; + g_autofree char *destination_date = NULL; + g_autofree char *destination_size = NULL; + g_autofree char *destination_type = NULL; + g_autofree char *source_date = NULL; + g_autofree char *source_size = NULL; + g_autofree char *source_type = NULL; + + source_is_directory = nautilus_file_is_directory (data->source); + destination_is_directory = nautilus_file_is_directory (data->destination); + + destination_mime_type = nautilus_file_get_mime_type (data->destination); + should_show_type = !nautilus_file_is_mime_type (data->source, + destination_mime_type); + + destination_date = nautilus_file_get_string_attribute_with_default (data->destination, + "date_modified"); + destination_size = nautilus_file_get_string_attribute_with_default (data->destination, + "size"); + + if (should_show_type) + { + destination_type = nautilus_file_get_string_attribute_with_default (data->destination, + "type"); + } + + destination_label = g_string_new (NULL); + if (destination_is_directory) + { + g_string_append_printf (destination_label, "<b>%s</b>\n", _("Original folder")); + g_string_append_printf (destination_label, "%s %s\n", _("Contents:"), destination_size); + } + else + { + g_string_append_printf (destination_label, "<b>%s</b>\n", _("Original file")); + g_string_append_printf (destination_label, "%s %s\n", _("Size:"), destination_size); + } + + if (should_show_type) + { + g_string_append_printf (destination_label, "%s %s\n", _("Type:"), destination_type); + } + + g_string_append_printf (destination_label, "%s %s", _("Last modified:"), destination_date); + + source_date = nautilus_file_get_string_attribute_with_default (data->source, + "date_modified"); + source_size = nautilus_file_get_string_attribute_with_default (data->source, + "size"); + + if (should_show_type) + { + source_type = nautilus_file_get_string_attribute_with_default (data->source, + "type"); + } + + source_label = g_string_new (NULL); + if (source_is_directory) + { + g_string_append_printf (source_label, "<b>%s</b>\n", + destination_is_directory ? + _("Merge with") : _("Replace with")); + g_string_append_printf (source_label, "%s %s\n", _("Contents:"), source_size); + } + else + { + g_string_append_printf (source_label, "<b>%s</b>\n", _("Replace with")); + g_string_append_printf (source_label, "%s %s\n", _("Size:"), source_size); + } + + if (should_show_type) + { + g_string_append_printf (source_label, "%s %s\n", _("Type:"), source_type); + } + + g_string_append_printf (source_label, "%s %s", _("Last modified:"), source_date); + + nautilus_file_conflict_dialog_set_file_labels (data->dialog, + destination_label->str, + source_label->str); + + g_string_free (destination_label, TRUE); + g_string_free (source_label, TRUE); +} + +static void +set_conflict_name (FileConflictDialogData *data) +{ + g_autofree gchar *edit_name = NULL; + + edit_name = nautilus_file_get_edit_name (data->destination); + + nautilus_file_conflict_dialog_set_conflict_name (data->dialog, + edit_name); +} + +static void +set_replace_button_label (FileConflictDialogData *data) +{ + gboolean source_is_directory, destination_is_directory; + + source_is_directory = nautilus_file_is_directory (data->source); + destination_is_directory = nautilus_file_is_directory (data->destination); + + if (destination_is_directory) + { + if (nautilus_file_is_symbolic_link (data->source) + && !nautilus_file_is_symbolic_link (data->destination)) + { + nautilus_file_conflict_dialog_disable_replace (data->dialog); + nautilus_file_conflict_dialog_disable_apply_to_all (data->dialog); + } + else if (source_is_directory) + { + nautilus_file_conflict_dialog_set_replace_button_label (data->dialog, + _("Merge")); + } + } +} + +static void +file_icons_changed (NautilusFile *file, + FileConflictDialogData *data) +{ + set_images (data); +} + +static void +copy_move_conflict_on_file_list_ready (GList *files, + gpointer user_data) +{ + FileConflictDialogData *data = user_data; + g_autofree gchar *title = NULL; + + data->handle = NULL; + + if (nautilus_file_is_directory (data->source)) + { + title = g_strdup (nautilus_file_is_directory (data->destination) ? + _("Merge Folder") : + _("File and Folder conflict")); + } + else + { + title = g_strdup (nautilus_file_is_directory (data->destination) ? + _("File and Folder conflict") : + _("File conflict")); + } + + gtk_window_set_title (GTK_WINDOW (data->dialog), title); + + set_copy_move_dialog_text (data); + + set_images (data); + + set_file_labels (data); + + set_conflict_name (data); + + set_replace_button_label (data); + + nautilus_file_monitor_add (data->source, data, NAUTILUS_FILE_ATTRIBUTES_FOR_ICON); + nautilus_file_monitor_add (data->destination, data, NAUTILUS_FILE_ATTRIBUTES_FOR_ICON); + + data->source_handler_id = g_signal_connect (data->source, "changed", + G_CALLBACK (file_icons_changed), data); + data->destination_handler_id = g_signal_connect (data->destination, "changed", + G_CALLBACK (file_icons_changed), data); +} + +static gboolean +run_file_conflict_dialog (gpointer user_data) +{ + FileConflictDialogData *data = user_data; + int response_id; + GList *files = NULL; + + data->source = nautilus_file_get (data->source_name); + data->destination = nautilus_file_get (data->destination_name); + data->destination_directory = nautilus_file_get (data->destination_directory_name); + + data->dialog = nautilus_file_conflict_dialog_new (data->parent); + + files = g_list_prepend (files, data->source); + files = g_list_prepend (files, data->destination); + files = g_list_prepend (files, data->destination_directory); + + nautilus_file_list_call_when_ready (files, + NAUTILUS_FILE_ATTRIBUTES_FOR_ICON | NAUTILUS_FILE_ATTRIBUTE_DIRECTORY_ITEM_COUNT, + &data->handle, + data->on_file_list_ready, + data); + + response_id = gtk_dialog_run (GTK_DIALOG (data->dialog)); + + if (data->handle != NULL) + { + nautilus_file_list_cancel_call_when_ready (data->handle); + } + + if (data->source_handler_id) + { + g_signal_handler_disconnect (data->source, data->source_handler_id); + nautilus_file_monitor_remove (data->source, data); + } + + if (data->destination_handler_id) + { + g_signal_handler_disconnect (data->destination, data->destination_handler_id); + nautilus_file_monitor_remove (data->destination, data); + } + + if (response_id == CONFLICT_RESPONSE_RENAME) + { + data->response->new_name = + nautilus_file_conflict_dialog_get_new_name (data->dialog); + } + else if (response_id != GTK_RESPONSE_CANCEL && + response_id != GTK_RESPONSE_NONE) + { + data->response->apply_to_all = + nautilus_file_conflict_dialog_get_apply_to_all (data->dialog); + } + + data->response->id = response_id; + + gtk_widget_destroy (GTK_WIDGET (data->dialog)); + + nautilus_file_unref (data->source); + nautilus_file_unref (data->destination); + nautilus_file_unref (data->destination_directory); + g_list_free (files); + + return G_SOURCE_REMOVE; +} + +FileConflictResponse * +copy_move_conflict_ask_user_action (GtkWindow *parent_window, + GFile *source_name, + GFile *destination_name, + GFile *destination_directory_name) +{ + FileConflictDialogData *data; + FileConflictResponse *response; + + data = g_slice_new0 (FileConflictDialogData); + data->parent = parent_window; + data->source_name = source_name; + data->destination_name = destination_name; + data->destination_directory_name = destination_directory_name; + + data->response = g_slice_new0 (FileConflictResponse); + data->response->new_name = NULL; + + data->on_file_list_ready = copy_move_conflict_on_file_list_ready; + + invoke_main_context_sync (NULL, + run_file_conflict_dialog, + data); + + response = g_steal_pointer (&data->response); + g_slice_free (FileConflictDialogData, data); + + return response; +} + +typedef struct +{ + GtkWindow *parent_window; + NautilusFile *file; +} HandleUnsupportedFileData; + +static gboolean +open_file_in_application (gpointer user_data) +{ + HandleUnsupportedFileData *data; + g_autofree gchar *mime_type = NULL; + GtkWidget *dialog; + const char *heading; + g_autoptr (GAppInfo) application = NULL; + + data = user_data; + mime_type = nautilus_file_get_mime_type (data->file); + dialog = gtk_app_chooser_dialog_new_for_content_type (data->parent_window, + GTK_DIALOG_MODAL | + GTK_DIALOG_DESTROY_WITH_PARENT | + GTK_DIALOG_USE_HEADER_BAR, + mime_type); + heading = _("Password-protected archives are not yet supported. " + "This list contains applications that can open the archive."); + + gtk_app_chooser_dialog_set_heading (GTK_APP_CHOOSER_DIALOG (dialog), heading); + + if (gtk_dialog_run (GTK_DIALOG (dialog)) == GTK_RESPONSE_OK) + { + application = gtk_app_chooser_get_app_info (GTK_APP_CHOOSER (dialog)); + } + + gtk_widget_destroy (dialog); + + if (application != NULL) + { + g_autoptr (GList) files = NULL; + + files = g_list_append (NULL, data->file); + + nautilus_launch_application (application, files, data->parent_window); + } + + return G_SOURCE_REMOVE; +} + +/* This is used to open compressed files that are not supported by gnome-autoar + * in another application + */ +void +handle_unsupported_compressed_file (GtkWindow *parent_window, + GFile *compressed_file) +{ + HandleUnsupportedFileData *data; + + data = g_slice_new0 (HandleUnsupportedFileData); + data->parent_window = parent_window; + data->file = nautilus_file_get (compressed_file); + + invoke_main_context_sync (NULL, open_file_in_application, data); + + nautilus_file_unref (data->file); + g_slice_free (HandleUnsupportedFileData, data); + + return; +} |