From ec52555862913a23417735f9f7f5402f5230da13 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sat, 27 Apr 2024 17:59:36 +0200 Subject: Adding upstream version 3.38.2. Signed-off-by: Daniel Baumann --- src/nautilus-clipboard.c | 329 +++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 329 insertions(+) create mode 100644 src/nautilus-clipboard.c (limited to 'src/nautilus-clipboard.c') diff --git a/src/nautilus-clipboard.c b/src/nautilus-clipboard.c new file mode 100644 index 0000000..fb7e96d --- /dev/null +++ b/src/nautilus-clipboard.c @@ -0,0 +1,329 @@ +/* nautilus-clipboard.c + * + * Nautilus Clipboard support. For now, routines to support component cut + * and paste. + * + * Copyright (C) 1999, 2000 Free Software Foundaton + * Copyright (C) 2000, 2001 Eazel, Inc. + * Copyright (C) 2016 Carlos Soriano + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU Library 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 + * Library General Public License for more details. + * + * You should have received a copy of the GNU Library General Public + * License along with this program; if not, see . + * + * Authors: Rebecca Schulman , + * Darin Adler + */ + +#include +#include "nautilus-clipboard.h" +#include "nautilus-file-utilities.h" +#include "nautilus-file.h" + +#include +#include +#include + +typedef struct +{ + gboolean cut; + GList *files; +} ClipboardInfo; + +static GList * +convert_selection_data_to_str_list (const gchar *data) +{ + g_auto (GStrv) lines = NULL; + guint number_of_lines; + GList *result; + + lines = g_strsplit (data, "\n", 0); + number_of_lines = g_strv_length (lines); + if (number_of_lines == 0) + { + /* An empty string will result in g_strsplit() returning an empty + * array, so, naturally, 0 - 1 = UINT_MAX and we read all sorts + * of invalid memory. + */ + return NULL; + } + result = NULL; + + /* Also, this skips the last line, since it would be an + * empty string from the split */ + for (guint i = 0; i < number_of_lines - 1; i++) + { + result = g_list_prepend (result, g_strdup (lines[i])); + } + + return g_list_reverse (result); +} + +static char * +convert_file_list_to_string (ClipboardInfo *info, + gboolean format_for_text, + gsize *len) +{ + GString *uris; + char *uri, *tmp; + GFile *f; + guint i; + GList *l; + + if (format_for_text) + { + uris = g_string_new (NULL); + } + else + { + uris = g_string_new ("x-special/nautilus-clipboard\n"); + g_string_append (uris, info->cut ? "cut\n" : "copy\n"); + } + + for (i = 0, l = info->files; l != NULL; l = l->next, i++) + { + uri = nautilus_file_get_uri (l->data); + + if (format_for_text) + { + f = g_file_new_for_uri (uri); + tmp = g_file_get_parse_name (f); + g_object_unref (f); + + if (tmp != NULL) + { + g_string_append (uris, tmp); + g_free (tmp); + } + else + { + g_string_append (uris, uri); + } + + g_string_append_c (uris, '\n'); + } + else + { + g_string_append (uris, uri); + g_string_append_c (uris, '\n'); + } + + g_free (uri); + } + + *len = uris->len; + return g_string_free (uris, FALSE); +} + +static GList * +get_item_list_from_selection_data (const gchar *selection_data) +{ + GList *items = NULL; + + if (selection_data != NULL) + { + gboolean valid_data = TRUE; + /* Not sure why it's legal to assume there's an extra byte + * past the end of the selection data that it's safe to write + * to. But gtk_editable_selection_received does this, so I + * think it is OK. + */ + items = convert_selection_data_to_str_list (selection_data); + if (items == NULL || g_strcmp0 (items->data, "x-special/nautilus-clipboard") != 0) + { + valid_data = FALSE; + } + else if (items->next == NULL) + { + valid_data = FALSE; + } + else if (g_strcmp0 (items->next->data, "cut") != 0 && + g_strcmp0 (items->next->data, "copy") != 0) + { + valid_data = FALSE; + } + + if (!valid_data) + { + g_list_free_full (items, g_free); + items = NULL; + } + } + + return items; +} + +gboolean +nautilus_clipboard_is_data_valid_from_selection_data (const gchar *selection_data) +{ + return nautilus_clipboard_get_uri_list_from_selection_data (selection_data) != NULL; +} + +GList * +nautilus_clipboard_get_uri_list_from_selection_data (const gchar *selection_data) +{ + GList *items; + + items = get_item_list_from_selection_data (selection_data); + if (items) + { + /* Line 0 is x-special/nautilus-clipboard. */ + items = g_list_remove (items, items->data); + /* Line 1 is "cut" or "copy", so uris start at line 2. */ + items = g_list_remove (items, items->data); + } + + return items; +} + +GtkClipboard * +nautilus_clipboard_get (GtkWidget *widget) +{ + return gtk_clipboard_get_for_display (gtk_widget_get_display (GTK_WIDGET (widget)), + GDK_SELECTION_CLIPBOARD); +} + +void +nautilus_clipboard_clear_if_colliding_uris (GtkWidget *widget, + const GList *item_uris) +{ + g_autofree gchar *data = NULL; + GList *clipboard_item_uris, *l; + gboolean collision; + + collision = FALSE; + data = gtk_clipboard_wait_for_text (nautilus_clipboard_get (widget)); + if (data == NULL) + { + return; + } + + clipboard_item_uris = nautilus_clipboard_get_uri_list_from_selection_data (data); + + for (l = (GList *) item_uris; l; l = l->next) + { + if (g_list_find_custom ((GList *) clipboard_item_uris, l->data, + (GCompareFunc) g_strcmp0)) + { + collision = TRUE; + break; + } + } + + if (collision) + { + gtk_clipboard_clear (nautilus_clipboard_get (widget)); + } + + if (clipboard_item_uris) + { + g_list_free_full (clipboard_item_uris, g_free); + } +} + +gboolean +nautilus_clipboard_is_cut_from_selection_data (const gchar *selection_data) +{ + GList *items; + gboolean is_cut_from_selection_data; + + items = get_item_list_from_selection_data (selection_data); + is_cut_from_selection_data = items != NULL && + g_strcmp0 ((gchar *) items->next->data, "cut") == 0; + + g_list_free_full (items, g_free); + + return is_cut_from_selection_data; +} + +static void +on_get_clipboard (GtkClipboard *clipboard, + GtkSelectionData *selection_data, + guint info, + gpointer user_data) +{ + char **uris; + GList *l; + int i; + ClipboardInfo *clipboard_info; + GdkAtom target; + + clipboard_info = (ClipboardInfo *) user_data; + + target = gtk_selection_data_get_target (selection_data); + + if (gtk_targets_include_uri (&target, 1)) + { + uris = g_malloc ((g_list_length (clipboard_info->files) + 1) * sizeof (char *)); + i = 0; + + for (l = clipboard_info->files; l != NULL; l = l->next) + { + uris[i] = nautilus_file_get_uri (l->data); + i++; + } + + uris[i] = NULL; + + gtk_selection_data_set_uris (selection_data, uris); + + g_strfreev (uris); + } + else if (gtk_targets_include_text (&target, 1)) + { + char *str; + gsize len; + + str = convert_file_list_to_string (clipboard_info, FALSE, &len); + gtk_selection_data_set_text (selection_data, str, len); + g_free (str); + } +} + +static void +on_clear_clipboard (GtkClipboard *clipboard, + gpointer user_data) +{ + ClipboardInfo *clipboard_info = (ClipboardInfo *) user_data; + + nautilus_file_list_free (clipboard_info->files); + + g_free (clipboard_info); +} + +void +nautilus_clipboard_prepare_for_files (GtkClipboard *clipboard, + GList *files, + gboolean cut) +{ + GtkTargetList *target_list; + GtkTargetEntry *targets; + int n_targets; + ClipboardInfo *clipboard_info; + + clipboard_info = g_new (ClipboardInfo, 1); + clipboard_info->cut = cut; + clipboard_info->files = nautilus_file_list_copy (files); + + target_list = gtk_target_list_new (NULL, 0); + gtk_target_list_add_uri_targets (target_list, 0); + gtk_target_list_add_text_targets (target_list, 0); + + targets = gtk_target_table_new_from_list (target_list, &n_targets); + gtk_target_list_unref (target_list); + + gtk_clipboard_set_with_data (clipboard, + targets, n_targets, + on_get_clipboard, on_clear_clipboard, + clipboard_info); + gtk_target_table_free (targets, n_targets); +} -- cgit v1.2.3