diff --git a/gdk/gdkcontentformats.c b/gdk/gdkcontentformats.c index d5d071f699..ab97163dcc 100644 --- a/gdk/gdkcontentformats.c +++ b/gdk/gdkcontentformats.c @@ -20,7 +20,7 @@ * @Title: Content Formats * @Short_description: Advertising and negotiating of content * exchange formats - @See_also: #GdkDragContext, #GtkClipboard + * @See_also: #GdkDragContext, #GdkClipboard * * This section describes the #GdkContentFormats structure that is used to * advertise and negotiate the format of content passed between different diff --git a/gtk/gtk.h b/gtk/gtk.h index 9571edf939..3f06cbdff1 100644 --- a/gtk/gtk.h +++ b/gtk/gtk.h @@ -71,7 +71,6 @@ #include #include #include -#include #include #include #include diff --git a/gtk/gtkapplication.c b/gtk/gtkapplication.c index 0954d83bae..50b67de5cd 100644 --- a/gtk/gtkapplication.c +++ b/gtk/gtkapplication.c @@ -29,7 +29,6 @@ #endif #include "gtkapplicationprivate.h" -#include "gtkclipboardprivate.h" #include "gtkmarshalers.h" #include "gtkmain.h" #include "gtkrecentmanager.h" diff --git a/gtk/gtkclipboard-quartz.c b/gtk/gtkclipboard-quartz.c deleted file mode 100644 index 6f0f72d9c0..0000000000 --- a/gtk/gtkclipboard-quartz.c +++ /dev/null @@ -1,1128 +0,0 @@ -/* GTK - The GIMP Toolkit - * Copyright (C) 2000 Red Hat, Inc. - * Copyright (C) 2004 Nokia Corporation - * Copyright (C) 2006-2008 Imendio AB - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - */ - -#include "config.h" -#include - -#import - -#include "gtkclipboard.h" -#include "gtkinvisible.h" -#include "gtkmain.h" -#include "gtkmarshalers.h" -#include "gtkintl.h" -#include "gtktextbuffer.h" -#include "gtkselectionprivate.h" -#include "gtkquartz.h" -#include "../gdk/quartz/gdkquartz.h" - -enum { - OWNER_CHANGE, - LAST_SIGNAL -}; - -@interface GtkClipboardOwner : NSObject { - GtkClipboard *clipboard; - @public - gboolean setting_same_owner; -} - -@end - -typedef struct _GtkClipboardClass GtkClipboardClass; - -struct _GtkClipboard -{ - GObject parent_instance; - - NSPasteboard *pasteboard; - GtkClipboardOwner *owner; - NSInteger change_count; - - GdkAtom selection; - - GtkClipboardGetFunc get_func; - GtkClipboardClearFunc clear_func; - gpointer user_data; - gboolean have_owner; - GtkTargetList *target_list; - - gboolean have_selection; - GdkDisplay *display; - - GdkAtom *cached_targets; - gint n_cached_targets; - - guint notify_signal_id; - gboolean storing_selection; - GMainLoop *store_loop; - guint store_timeout; - gint n_storable_targets; - GdkAtom *storable_targets; -}; - -struct _GtkClipboardClass -{ - GObjectClass parent_class; - - void (*owner_change) (GtkClipboard *clipboard, - GdkEventOwnerChange *event); -}; - -static void gtk_clipboard_class_init (GtkClipboardClass *class); -static void gtk_clipboard_finalize (GObject *object); -static void gtk_clipboard_owner_change (GtkClipboard *clipboard, - GdkEventOwnerChange *event); - -static void clipboard_unset (GtkClipboard *clipboard); -static GtkClipboard *clipboard_peek (GdkDisplay *display, - GdkAtom selection, - gboolean only_if_exists); - -@implementation GtkClipboardOwner --(void)pasteboard:(NSPasteboard *)sender provideDataForType:(NSString *)type -{ - GtkSelectionData selection_data; - guint info; - - if (!clipboard->target_list) - return; - - memset (&selection_data, 0, sizeof (GtkSelectionData)); - - selection_data.selection = clipboard->selection; - selection_data.target = gdk_quartz_pasteboard_type_to_atom_libgtk_only (type); - selection_data.display = gdk_display_get_default (); - selection_data.length = -1; - - if (gtk_target_list_find (clipboard->target_list, selection_data.target, &info)) - { - clipboard->get_func (clipboard, &selection_data, - info, - clipboard->user_data); - - if (selection_data.length >= 0) - _gtk_quartz_set_selection_data_for_pasteboard (clipboard->pasteboard, - &selection_data); - - g_free (selection_data.data); - } -} - -/* pasteboardChangedOwner is not called immediately, and it's not called - * reliably. It is somehow documented in the apple api docs, but the docs - * suck and don’t really give clear instructions. Therefore we track - * changeCount in several places below and clear the clipboard if it - * changed. - */ -- (void)pasteboardChangedOwner:(NSPasteboard *)sender -{ - if (! setting_same_owner) - clipboard_unset (clipboard); -} - -- (id)initWithClipboard:(GtkClipboard *)aClipboard -{ - self = [super init]; - - if (self) - { - clipboard = aClipboard; - setting_same_owner = FALSE; - } - - return self; -} - -@end - - -static const gchar clipboards_owned_key[] = "gtk-clipboards-owned"; -static GQuark clipboards_owned_key_id = 0; - -static GObjectClass *parent_class; -static guint clipboard_signals[LAST_SIGNAL] = { 0 }; - -GType -gtk_clipboard_get_type (void) -{ - static GType clipboard_type = 0; - - if (!clipboard_type) - { - const GTypeInfo clipboard_info = - { - sizeof (GtkClipboardClass), - NULL, /* base_init */ - NULL, /* base_finalize */ - (GClassInitFunc) gtk_clipboard_class_init, - NULL, /* class_finalize */ - NULL, /* class_data */ - sizeof (GtkClipboard), - 0, /* n_preallocs */ - (GInstanceInitFunc) NULL, - }; - - clipboard_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkClipboard"), - &clipboard_info, 0); - } - - return clipboard_type; -} - -static void -gtk_clipboard_class_init (GtkClipboardClass *class) -{ - GObjectClass *gobject_class = G_OBJECT_CLASS (class); - - parent_class = g_type_class_peek_parent (class); - - gobject_class->finalize = gtk_clipboard_finalize; - - class->owner_change = gtk_clipboard_owner_change; - - clipboard_signals[OWNER_CHANGE] = - g_signal_new (I_("owner-change"), - G_TYPE_FROM_CLASS (gobject_class), - G_SIGNAL_RUN_FIRST, - G_STRUCT_OFFSET (GtkClipboardClass, owner_change), - NULL, NULL, - NULL, - G_TYPE_NONE, 1, - GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE); -} - -static void -gtk_clipboard_finalize (GObject *object) -{ - GtkClipboard *clipboard; - GSList *clipboards; - - clipboard = GTK_CLIPBOARD (object); - - clipboards = g_object_get_data (G_OBJECT (clipboard->display), "gtk-clipboard-list"); - if (g_slist_index (clipboards, clipboard) >= 0) - g_warning ("GtkClipboard prematurely finalized"); - - clipboard_unset (clipboard); - - clipboards = g_object_get_data (G_OBJECT (clipboard->display), "gtk-clipboard-list"); - clipboards = g_slist_remove (clipboards, clipboard); - g_object_set_data (G_OBJECT (clipboard->display), I_("gtk-clipboard-list"), clipboards); - - if (clipboard->store_loop && g_main_loop_is_running (clipboard->store_loop)) - g_main_loop_quit (clipboard->store_loop); - - if (clipboard->store_timeout != 0) - g_source_remove (clipboard->store_timeout); - - g_free (clipboard->storable_targets); - - G_OBJECT_CLASS (parent_class)->finalize (object); -} - -static void -clipboard_display_closed (GdkDisplay *display, - gboolean is_error, - GtkClipboard *clipboard) -{ - GSList *clipboards; - - clipboards = g_object_get_data (G_OBJECT (display), "gtk-clipboard-list"); - g_object_run_dispose (G_OBJECT (clipboard)); - clipboards = g_slist_remove (clipboards, clipboard); - g_object_set_data (G_OBJECT (display), I_("gtk-clipboard-list"), clipboards); - g_object_unref (clipboard); -} - -GtkClipboard * -gtk_clipboard_get_for_display (GdkDisplay *display, - GdkAtom selection) -{ - g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); - g_return_val_if_fail (!gdk_display_is_closed (display), NULL); - - return clipboard_peek (display, selection, FALSE); -} - -GtkClipboard * -gtk_clipboard_get (GdkAtom selection) -{ - return gtk_clipboard_get_for_display (gdk_display_get_default (), selection); -} - -GtkClipboard * -gtk_clipboard_get_default (GdkDisplay *display) -{ - g_return_val_if_fail (display != NULL, NULL); - g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); - - return gtk_clipboard_get_for_display (display, GDK_SELECTION_CLIPBOARD); -} - -static void -clipboard_owner_destroyed (gpointer data) -{ - GSList *clipboards = data; - GSList *tmp_list; - - tmp_list = clipboards; - while (tmp_list) - { - GtkClipboard *clipboard = tmp_list->data; - - clipboard->get_func = NULL; - clipboard->clear_func = NULL; - clipboard->user_data = NULL; - clipboard->have_owner = FALSE; - - if (clipboard->target_list) - { - gtk_target_list_unref (clipboard->target_list); - clipboard->target_list = NULL; - } - - gtk_clipboard_clear (clipboard); - - tmp_list = tmp_list->next; - } - - g_slist_free (clipboards); -} - -static void -clipboard_add_owner_notify (GtkClipboard *clipboard) -{ - if (!clipboards_owned_key_id) - clipboards_owned_key_id = g_quark_from_static_string (clipboards_owned_key); - - if (clipboard->have_owner) - g_object_set_qdata_full (clipboard->user_data, clipboards_owned_key_id, - g_slist_prepend (g_object_steal_qdata (clipboard->user_data, - clipboards_owned_key_id), - clipboard), - clipboard_owner_destroyed); -} - -static void -clipboard_remove_owner_notify (GtkClipboard *clipboard) -{ - if (clipboard->have_owner) - g_object_set_qdata_full (clipboard->user_data, clipboards_owned_key_id, - g_slist_remove (g_object_steal_qdata (clipboard->user_data, - clipboards_owned_key_id), - clipboard), - clipboard_owner_destroyed); -} - -static gboolean -gtk_clipboard_set_contents (GtkClipboard *clipboard, - const GtkTargetEntry *targets, - guint n_targets, - GtkClipboardGetFunc get_func, - GtkClipboardClearFunc clear_func, - gpointer user_data, - gboolean have_owner) -{ - GtkClipboardOwner *owner; - NSSet *types; - NSAutoreleasePool *pool; - - if (!(clipboard->have_owner && have_owner) || - clipboard->user_data != user_data) - { - clipboard_unset (clipboard); - - if (clipboard->get_func) - { - /* Calling unset() caused the clipboard contents to be reset! - * Avoid leaking and return - */ - if (!(clipboard->have_owner && have_owner) || - clipboard->user_data != user_data) - { - (*clear_func) (clipboard, user_data); - return FALSE; - } - else - { - return TRUE; - } - } - } - - pool = [[NSAutoreleasePool alloc] init]; - - types = _gtk_quartz_target_entries_to_pasteboard_types (targets, n_targets); - - /* call declareTypes before setting the clipboard members because - * declareTypes might clear the clipboard - */ - if (user_data && user_data == clipboard->user_data) - { - owner = [clipboard->owner retain]; - - owner->setting_same_owner = TRUE; - clipboard->change_count = [clipboard->pasteboard declareTypes: [types allObjects] - owner: owner]; - owner->setting_same_owner = FALSE; - } - else - { - owner = [[GtkClipboardOwner alloc] initWithClipboard:clipboard]; - - clipboard->change_count = [clipboard->pasteboard declareTypes: [types allObjects] - owner: owner]; - } - - [owner release]; - [types release]; - [pool release]; - - clipboard->owner = owner; - clipboard->user_data = user_data; - clipboard->have_owner = have_owner; - if (have_owner) - clipboard_add_owner_notify (clipboard); - clipboard->get_func = get_func; - clipboard->clear_func = clear_func; - - if (clipboard->target_list) - gtk_target_list_unref (clipboard->target_list); - clipboard->target_list = gtk_target_list_new (targets, n_targets); - - return TRUE; -} - -gboolean -gtk_clipboard_set_with_data (GtkClipboard *clipboard, - const GtkTargetEntry *targets, - guint n_targets, - GtkClipboardGetFunc get_func, - GtkClipboardClearFunc clear_func, - gpointer user_data) -{ - g_return_val_if_fail (clipboard != NULL, FALSE); - g_return_val_if_fail (targets != NULL, FALSE); - g_return_val_if_fail (get_func != NULL, FALSE); - - return gtk_clipboard_set_contents (clipboard, targets, n_targets, - get_func, clear_func, user_data, - FALSE); -} - -gboolean -gtk_clipboard_set_with_owner (GtkClipboard *clipboard, - const GtkTargetEntry *targets, - guint n_targets, - GtkClipboardGetFunc get_func, - GtkClipboardClearFunc clear_func, - GObject *owner) -{ - g_return_val_if_fail (clipboard != NULL, FALSE); - g_return_val_if_fail (targets != NULL, FALSE); - g_return_val_if_fail (get_func != NULL, FALSE); - g_return_val_if_fail (G_IS_OBJECT (owner), FALSE); - - return gtk_clipboard_set_contents (clipboard, targets, n_targets, - get_func, clear_func, owner, - TRUE); -} - -GObject * -gtk_clipboard_get_owner (GtkClipboard *clipboard) -{ - g_return_val_if_fail (clipboard != NULL, NULL); - - if (clipboard->change_count < [clipboard->pasteboard changeCount]) - { - clipboard_unset (clipboard); - clipboard->change_count = [clipboard->pasteboard changeCount]; - } - - if (clipboard->have_owner) - return clipboard->user_data; - else - return NULL; -} - -static void -clipboard_unset (GtkClipboard *clipboard) -{ - GtkClipboardClearFunc old_clear_func; - gpointer old_data; - gboolean old_have_owner; - gint old_n_storable_targets; - - old_clear_func = clipboard->clear_func; - old_data = clipboard->user_data; - old_have_owner = clipboard->have_owner; - old_n_storable_targets = clipboard->n_storable_targets; - - if (old_have_owner) - { - clipboard_remove_owner_notify (clipboard); - clipboard->have_owner = FALSE; - } - - clipboard->n_storable_targets = -1; - g_free (clipboard->storable_targets); - clipboard->storable_targets = NULL; - - clipboard->owner = NULL; - clipboard->get_func = NULL; - clipboard->clear_func = NULL; - clipboard->user_data = NULL; - - if (old_clear_func) - old_clear_func (clipboard, old_data); - - if (clipboard->target_list) - { - gtk_target_list_unref (clipboard->target_list); - clipboard->target_list = NULL; - } - - /* If we've transferred the clipboard data to the manager, - * unref the owner - */ - if (old_have_owner && - old_n_storable_targets != -1) - g_object_unref (old_data); -} - -void -gtk_clipboard_clear (GtkClipboard *clipboard) -{ - clipboard_unset (clipboard); -#ifdef AVAILABLE_MAC_OS_X_VERSION_10_6_AND_LATER - [clipboard->pasteboard clearContents]; -#else - [clipboard->pasteboard declareTypes:nil owner:nil]; -#endif -} - -static void -text_get_func (GtkClipboard *clipboard, - GtkSelectionData *selection_data, - guint info, - gpointer data) -{ - gtk_selection_data_set_text (selection_data, data, -1); -} - -static void -text_clear_func (GtkClipboard *clipboard, - gpointer data) -{ - g_free (data); -} - -void -gtk_clipboard_set_text (GtkClipboard *clipboard, - const gchar *text, - gint len) -{ - GtkTargetEntry target = { "UTF8_STRING", 0, 0 }; - - g_return_if_fail (clipboard != NULL); - g_return_if_fail (text != NULL); - - if (len < 0) - len = strlen (text); - - gtk_clipboard_set_with_data (clipboard, - &target, 1, - text_get_func, text_clear_func, - g_strndup (text, len)); - gtk_clipboard_set_can_store (clipboard, NULL, 0); -} - - -static void -pixbuf_get_func (GtkClipboard *clipboard, - GtkSelectionData *selection_data, - guint info, - gpointer data) -{ - gtk_selection_data_set_pixbuf (selection_data, data); -} - -static void -pixbuf_clear_func (GtkClipboard *clipboard, - gpointer data) -{ - g_object_unref (data); -} - -void -gtk_clipboard_set_image (GtkClipboard *clipboard, - GdkPixbuf *pixbuf) -{ - GtkTargetList *list; - GList *l; - GtkTargetEntry *targets; - gint n_targets, i; - - g_return_if_fail (clipboard != NULL); - g_return_if_fail (GDK_IS_PIXBUF (pixbuf)); - - list = gtk_target_list_new (NULL, 0); - gtk_target_list_add_image_targets (list, 0, TRUE); - - n_targets = g_list_length (list->list); - targets = g_new0 (GtkTargetEntry, n_targets); - for (l = list->list, i = 0; l; l = l->next, i++) - { - GtkTargetPair *pair = (GtkTargetPair *)l->data; - targets[i].target = gdk_atom_name (pair->target); - } - - gtk_clipboard_set_with_data (clipboard, - targets, n_targets, - pixbuf_get_func, pixbuf_clear_func, - g_object_ref (pixbuf)); - gtk_clipboard_set_can_store (clipboard, NULL, 0); - - for (i = 0; i < n_targets; i++) - g_free (targets[i].target); - g_free (targets); - gtk_target_list_unref (list); -} - -void -gtk_clipboard_request_contents (GtkClipboard *clipboard, - GdkAtom target, - GtkClipboardReceivedFunc callback, - gpointer user_data) -{ - GtkSelectionData *data; - - data = gtk_clipboard_wait_for_contents (clipboard, target); - - callback (clipboard, data, user_data); - - gtk_selection_data_free (data); -} - -void -gtk_clipboard_request_text (GtkClipboard *clipboard, - GtkClipboardTextReceivedFunc callback, - gpointer user_data) -{ - gchar *data = gtk_clipboard_wait_for_text (clipboard); - - callback (clipboard, data, user_data); - - g_free (data); -} - -void -gtk_clipboard_request_rich_text (GtkClipboard *clipboard, - GtkTextBuffer *buffer, - GtkClipboardRichTextReceivedFunc callback, - gpointer user_data) -{ - /* FIXME: Implement */ -} - - -guint8 * -gtk_clipboard_wait_for_rich_text (GtkClipboard *clipboard, - GtkTextBuffer *buffer, - GdkAtom *format, - gsize *length) -{ - /* FIXME: Implement */ - return NULL; -} - -void -gtk_clipboard_request_image (GtkClipboard *clipboard, - GtkClipboardImageReceivedFunc callback, - gpointer user_data) -{ - GdkPixbuf *pixbuf = gtk_clipboard_wait_for_image (clipboard); - - callback (clipboard, pixbuf, user_data); - - if (pixbuf) - g_object_unref (pixbuf); -} - -void -gtk_clipboard_request_uris (GtkClipboard *clipboard, - GtkClipboardURIReceivedFunc callback, - gpointer user_data) -{ - gchar **uris = gtk_clipboard_wait_for_uris (clipboard); - - callback (clipboard, uris, user_data); - - g_strfreev (uris); -} - -void -gtk_clipboard_request_targets (GtkClipboard *clipboard, - GtkClipboardTargetsReceivedFunc callback, - gpointer user_data) -{ - GdkAtom *targets; - gint n_targets; - - gtk_clipboard_wait_for_targets (clipboard, &targets, &n_targets); - - callback (clipboard, targets, n_targets, user_data); -} - -GtkSelectionData * -gtk_clipboard_wait_for_contents (GtkClipboard *clipboard, - GdkAtom target) -{ - NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; - GtkSelectionData *selection_data = NULL; - - if (clipboard->change_count < [clipboard->pasteboard changeCount]) - { - clipboard_unset (clipboard); - clipboard->change_count = [clipboard->pasteboard changeCount]; - } - - if (target == gdk_atom_intern_static_string ("TARGETS")) - { - NSArray *types = [clipboard->pasteboard types]; - int i, length; - GList *atom_list, *l; - GdkAtom *atoms; - - length = [types count] * sizeof (GdkAtom); - - selection_data = g_slice_new0 (GtkSelectionData); - selection_data->selection = clipboard->selection; - selection_data->target = target; - if (!selection_data->display) - selection_data->display = gdk_display_get_default (); - - atoms = g_malloc (length); - - atom_list = _gtk_quartz_pasteboard_types_to_atom_list (types); - for (l = atom_list, i = 0; l ; l = l->next, i++) - atoms[i] = GDK_POINTER_TO_ATOM (l->data); - g_list_free (atom_list); - - gtk_selection_data_set (selection_data, - GDK_SELECTION_TYPE_ATOM, 32, - (guchar *)atoms, length); - - [pool release]; - - return selection_data; - } - - selection_data = _gtk_quartz_get_selection_data_from_pasteboard (clipboard->pasteboard, - target, - clipboard->selection); - - [pool release]; - - return selection_data; -} - -gchar * -gtk_clipboard_wait_for_text (GtkClipboard *clipboard) -{ - GtkSelectionData *data; - gchar *result; - - data = gtk_clipboard_wait_for_contents (clipboard, - gdk_atom_intern_static_string ("UTF8_STRING")); - - result = (gchar *)gtk_selection_data_get_text (data); - - gtk_selection_data_free (data); - - return result; -} - -GdkPixbuf * -gtk_clipboard_wait_for_image (GtkClipboard *clipboard) -{ - GdkAtom target = gdk_atom_intern_static_string("image/tiff"); - GtkSelectionData *data; - - data = gtk_clipboard_wait_for_contents (clipboard, target); - - if (data && data->data) - { - GdkPixbuf *pixbuf = gtk_selection_data_get_pixbuf (data); - gtk_selection_data_free (data); - return pixbuf; - } - - return NULL; -} - -gchar ** -gtk_clipboard_wait_for_uris (GtkClipboard *clipboard) -{ - GtkSelectionData *data; - - data = gtk_clipboard_wait_for_contents (clipboard, gdk_atom_intern_static_string ("text/uri-list")); - if (data) - { - gchar **uris; - - uris = gtk_selection_data_get_uris (data); - gtk_selection_data_free (data); - - return uris; - } - - return NULL; -} - -GdkDisplay * -gtk_clipboard_get_display (GtkClipboard *clipboard) -{ - g_return_val_if_fail (clipboard != NULL, NULL); - - return clipboard->display; -} - -gboolean -gtk_clipboard_wait_is_text_available (GtkClipboard *clipboard) -{ - GtkSelectionData *data; - gboolean result = FALSE; - - data = gtk_clipboard_wait_for_contents (clipboard, gdk_atom_intern_static_string ("TARGETS")); - if (data) - { - result = gtk_selection_data_targets_include_text (data); - gtk_selection_data_free (data); - } - - return result; -} - -gboolean -gtk_clipboard_wait_is_rich_text_available (GtkClipboard *clipboard, - GtkTextBuffer *buffer) -{ - GtkSelectionData *data; - gboolean result = FALSE; - - g_return_val_if_fail (GTK_IS_CLIPBOARD (clipboard), FALSE); - g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE); - - data = gtk_clipboard_wait_for_contents (clipboard, gdk_atom_intern_static_string ("TARGETS")); - if (data) - { - result = gtk_selection_data_targets_include_rich_text (data, buffer); - gtk_selection_data_free (data); - } - - return result; -} - -gboolean -gtk_clipboard_wait_is_image_available (GtkClipboard *clipboard) -{ - GtkSelectionData *data; - gboolean result = FALSE; - - data = gtk_clipboard_wait_for_contents (clipboard, - gdk_atom_intern_static_string ("TARGETS")); - if (data) - { - result = gtk_selection_data_targets_include_image (data, FALSE); - gtk_selection_data_free (data); - } - - return result; -} - -gboolean -gtk_clipboard_wait_is_uris_available (GtkClipboard *clipboard) -{ - GtkSelectionData *data; - gboolean result = FALSE; - - data = gtk_clipboard_wait_for_contents (clipboard, - gdk_atom_intern_static_string ("TARGETS")); - if (data) - { - result = gtk_selection_data_targets_include_uri (data); - gtk_selection_data_free (data); - } - - return result; -} - -gboolean -gtk_clipboard_wait_for_targets (GtkClipboard *clipboard, - GdkAtom **targets, - gint *n_targets) -{ - GtkSelectionData *data; - gboolean result = FALSE; - - g_return_val_if_fail (clipboard != NULL, FALSE); - - /* If the display supports change notification we cache targets */ - if (gdk_display_supports_selection_notification (gtk_clipboard_get_display (clipboard)) && - clipboard->n_cached_targets != -1) - { - if (n_targets) - *n_targets = clipboard->n_cached_targets; - - if (targets) - *targets = g_memdup (clipboard->cached_targets, - clipboard->n_cached_targets * sizeof (GdkAtom)); - - return TRUE; - } - - if (n_targets) - *n_targets = 0; - - if (targets) - *targets = NULL; - - data = gtk_clipboard_wait_for_contents (clipboard, gdk_atom_intern_static_string ("TARGETS")); - - if (data) - { - GdkAtom *tmp_targets; - gint tmp_n_targets; - - result = gtk_selection_data_get_targets (data, &tmp_targets, &tmp_n_targets); - - if (gdk_display_supports_selection_notification (gtk_clipboard_get_display (clipboard))) - { - clipboard->n_cached_targets = tmp_n_targets; - clipboard->cached_targets = g_memdup (tmp_targets, - tmp_n_targets * sizeof (GdkAtom)); - } - - if (n_targets) - *n_targets = tmp_n_targets; - - if (targets) - *targets = tmp_targets; - else - g_free (tmp_targets); - - gtk_selection_data_free (data); - } - - return result; -} - -static GtkClipboard * -clipboard_peek (GdkDisplay *display, - GdkAtom selection, - gboolean only_if_exists) -{ - GtkClipboard *clipboard = NULL; - GSList *clipboards; - GSList *tmp_list; - - if (selection == NULL) - selection = GDK_SELECTION_CLIPBOARD; - - clipboards = g_object_get_data (G_OBJECT (display), "gtk-clipboard-list"); - - tmp_list = clipboards; - while (tmp_list) - { - clipboard = tmp_list->data; - if (clipboard->selection == selection) - break; - - tmp_list = tmp_list->next; - } - - if (!tmp_list && !only_if_exists) - { - NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init]; - NSString *pasteboard_name; - clipboard = g_object_new (GTK_TYPE_CLIPBOARD, NULL); - - if (selection == GDK_SELECTION_CLIPBOARD) - pasteboard_name = NSGeneralPboard; - else - { - char *atom_string = gdk_atom_name (selection); - - pasteboard_name = [NSString stringWithFormat:@"_GTK_%@", - [NSString stringWithUTF8String:atom_string]]; - g_free (atom_string); - } - - clipboard->pasteboard = [NSPasteboard pasteboardWithName:pasteboard_name]; - - [pool release]; - - clipboard->selection = selection; - clipboard->display = display; - clipboard->n_cached_targets = -1; - clipboard->n_storable_targets = -1; - clipboards = g_slist_prepend (clipboards, clipboard); - g_object_set_data (G_OBJECT (display), I_("gtk-clipboard-list"), clipboards); - g_signal_connect (display, "closed", - G_CALLBACK (clipboard_display_closed), clipboard); - gdk_display_request_selection_notification (display, selection); - } - - return clipboard; -} - -static void -gtk_clipboard_owner_change (GtkClipboard *clipboard, - GdkEventOwnerChange *event) -{ - if (clipboard->n_cached_targets != -1) - { - clipboard->n_cached_targets = -1; - g_free (clipboard->cached_targets); - } -} - -gboolean -gtk_clipboard_wait_is_target_available (GtkClipboard *clipboard, - GdkAtom target) -{ - GdkAtom *targets; - gint i, n_targets; - gboolean retval = FALSE; - - if (!gtk_clipboard_wait_for_targets (clipboard, &targets, &n_targets)) - return FALSE; - - for (i = 0; i < n_targets; i++) - { - if (targets[i] == target) - { - retval = TRUE; - break; - } - } - - g_free (targets); - - return retval; -} - -void -_gtk_clipboard_handle_event (GdkEventOwnerChange *event) -{ -} - -void -gtk_clipboard_set_can_store (GtkClipboard *clipboard, - const GtkTargetEntry *targets, - gint n_targets) -{ - /* FIXME: Implement */ -} - -void -gtk_clipboard_store (GtkClipboard *clipboard) -{ - int i; - int n_targets = 0; - GtkTargetEntry *targets; - - g_return_if_fail (GTK_IS_CLIPBOARD (clipboard)); - - if (!clipboard->target_list || !clipboard->get_func) - return; - - /* We simply store all targets into the OS X clipboard. We should be - * using the functions gdk_display_supports_clipboard_persistence() and - * gdk_display_store_clipboard(), but since for OS X the clipboard support - * was implemented in GTK+ and not through GdkSelections, we do it this - * way. Doing this properly could be worthwhile to implement in the future. - */ - - targets = gtk_target_table_new_from_list (clipboard->target_list, - &n_targets); - for (i = 0; i < n_targets; i++) - { - GtkSelectionData selection_data; - - /* in each loop iteration, check if the content is still - * there, because calling get_func() can do anything to - * the clipboard - */ - if (!clipboard->target_list || !clipboard->get_func) - break; - - memset (&selection_data, 0, sizeof (GtkSelectionData)); - - selection_data.selection = clipboard->selection; - selection_data.target = gdk_atom_intern_static_string (targets[i].target); - selection_data.display = gdk_display_get_default (); - selection_data.length = -1; - - clipboard->get_func (clipboard, &selection_data, - targets[i].info, clipboard->user_data); - - if (selection_data.length >= 0) - _gtk_quartz_set_selection_data_for_pasteboard (clipboard->pasteboard, - &selection_data); - - g_free (selection_data.data); - } - - if (targets) - gtk_target_table_free (targets, n_targets); -} - -void -_gtk_clipboard_store_all (void) -{ - GtkClipboard *clipboard; - GSList *displays, *list; - - displays = gdk_display_manager_list_displays (gdk_display_manager_get ()); - - list = displays; - while (list) - { - GdkDisplay *display = list->data; - - clipboard = clipboard_peek (display, GDK_SELECTION_CLIPBOARD, TRUE); - - if (clipboard) - gtk_clipboard_store (clipboard); - - list = list->next; - } -} - -GdkAtom -gtk_clipboard_get_selection (GtkClipboard *clipboard) -{ - g_return_val_if_fail (GTK_IS_CLIPBOARD (clipboard), NULL); - - return clipboard->selection; -} diff --git a/gtk/gtkclipboard.c b/gtk/gtkclipboard.c deleted file mode 100644 index fcd9776d0d..0000000000 --- a/gtk/gtkclipboard.c +++ /dev/null @@ -1,2073 +0,0 @@ -/* GTK - The GIMP Toolkit - * Copyright (C) 2000 Red Hat, Inc. - * Copyright (C) 2004 Nokia Corporation - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - * Global clipboard abstraction. - */ - -#include "config.h" -#include - -#include "gtkclipboard.h" -#include "gtkclipboardprivate.h" -#include "gtkinvisible.h" -#include "gtkmain.h" -#include "gtkmarshalers.h" -#include "gtkselectionprivate.h" -#include "gtkintl.h" - -#include "gdk/gdk-private.h" -#include "gdk/gdkcontentformatsprivate.h" - -/** - * SECTION:gtkclipboard - * @Short_description: Storing data on clipboards - * @Title: Clipboards - * @See_also: #GtkSelectionData - * - * The #GtkClipboard object represents a clipboard of data shared - * between different processes or between different widgets in - * the same process. Each clipboard is identified by a name encoded as a - * #GdkAtom. (Conversion to and from strings can be done with - * gdk_atom_intern() and gdk_atom_name().) The default clipboard - * corresponds to the “CLIPBOARD” atom; another commonly used clipboard - * is the “PRIMARY” clipboard, which, in X, traditionally contains - * the currently selected text. - * - * To support having a number of different formats on the clipboard - * at the same time, the clipboard mechanism allows providing - * callbacks instead of the actual data. When you set the contents - * of the clipboard, you can either supply the data directly (via - * functions like gtk_clipboard_set_text()), or you can supply a - * callback to be called at a later time when the data is needed (via - * gtk_clipboard_set_with_data() or gtk_clipboard_set_with_owner().) - * Providing a callback also avoids having to make copies of the data - * when it is not needed. - * - * gtk_clipboard_set_with_data() and gtk_clipboard_set_with_owner() - * are quite similar; the choice between the two depends mostly on - * which is more convenient in a particular situation. - * The former is most useful when you want to have a blob of data - * with callbacks to convert it into the various data types that you - * advertise. When the @clear_func you provided is called, you - * simply free the data blob. The latter is more useful when the - * contents of clipboard reflect the internal state of a #GObject - * (As an example, for the PRIMARY clipboard, when an entry widget - * provides the clipboard’s contents the contents are simply the - * text within the selected region.) If the contents change, the - * entry widget can call gtk_clipboard_set_with_owner() to update - * the timestamp for clipboard ownership, without having to worry - * about @clear_func being called. - * - * Requesting the data from the clipboard is essentially - * asynchronous. If the contents of the clipboard are provided within - * the same process, then a direct function call will be made to - * retrieve the data, but if they are provided by another process, - * then the data needs to be retrieved from the other process, which - * may take some time. To avoid blocking the user interface, the call - * to request the selection, gtk_clipboard_request_contents() takes a - * callback that will be called when the contents are received (or - * when the request fails.) If you don’t want to deal with providing - * a separate callback, you can also use gtk_clipboard_wait_for_contents(). - * What this does is run the GLib main loop recursively waiting for - * the contents. This can simplify the code flow, but you still have - * to be aware that other callbacks in your program can be called - * while this recursive mainloop is running. - * - * Along with the functions to get the clipboard contents as an - * arbitrary data chunk, there are also functions to retrieve - * it as text, gtk_clipboard_request_text() and - * gtk_clipboard_wait_for_text(). These functions take care of - * determining which formats are advertised by the clipboard - * provider, asking for the clipboard in the best available format - * and converting the results into the UTF-8 encoding. (The standard - * form for representing strings in GTK+.) - */ - - -enum { - OWNER_CHANGE, - LAST_SIGNAL -}; - -typedef struct _RequestContentsInfo RequestContentsInfo; -typedef struct _RequestTextInfo RequestTextInfo; -typedef struct _RequestRichTextInfo RequestRichTextInfo; -typedef struct _RequestImageInfo RequestImageInfo; -typedef struct _RequestURIInfo RequestURIInfo; -typedef struct _RequestTargetsInfo RequestTargetsInfo; - -struct _RequestContentsInfo -{ - GtkClipboardReceivedFunc callback; - gpointer user_data; -}; - -struct _RequestTextInfo -{ - GtkClipboardTextReceivedFunc callback; - gpointer user_data; -}; - -struct _RequestRichTextInfo -{ - GtkClipboardRichTextReceivedFunc callback; - GdkAtom *atoms; - gint n_atoms; - gint current_atom; - gpointer user_data; -}; - -struct _RequestImageInfo -{ - GtkClipboardImageReceivedFunc callback; - gpointer user_data; -}; - -struct _RequestURIInfo -{ - GtkClipboardURIReceivedFunc callback; - gpointer user_data; -}; - -struct _RequestTargetsInfo -{ - GtkClipboardTargetsReceivedFunc callback; - gpointer user_data; -}; - -static void gtk_clipboard_finalize (GObject *object); -static void gtk_clipboard_owner_change (GtkClipboard *clipboard, - GdkEventOwnerChange *event); -static gboolean gtk_clipboard_set_contents (GtkClipboard *clipboard, - GdkContentFormats *formats, - GtkClipboardGetFunc get_func, - GtkClipboardClearFunc clear_func, - gpointer user_data, - gboolean have_owner); -static void gtk_clipboard_real_clear (GtkClipboard *clipboard); -static void gtk_clipboard_real_request_contents (GtkClipboard *clipboard, - GdkAtom target, - GtkClipboardReceivedFunc callback, - gpointer user_data); -static void gtk_clipboard_real_set_can_store (GtkClipboard *clipboard, - GdkContentFormats *formats); -static void gtk_clipboard_real_store (GtkClipboard *clipboard); - - -static void clipboard_unset (GtkClipboard *clipboard); -static void selection_received (GtkWidget *widget, - GtkSelectionData *selection_data, - guint time); -static GtkClipboard *clipboard_peek (GdkDisplay *display, - GdkAtom selection, - gboolean only_if_exists); -static GtkWidget * get_clipboard_widget (GdkDisplay *display); - - -static const gchar request_contents_key[] = "gtk-request-contents"; -static GQuark request_contents_key_id = 0; - -static const gchar clipboards_owned_key[] = "gtk-clipboards-owned"; -static GQuark clipboards_owned_key_id = 0; - -static guint clipboard_signals[LAST_SIGNAL] = { 0 }; - -G_DEFINE_TYPE (GtkClipboard, gtk_clipboard, G_TYPE_OBJECT) - -static void -gtk_clipboard_init (GtkClipboard *object) -{ -} - -static void -gtk_clipboard_class_init (GtkClipboardClass *class) -{ - GObjectClass *gobject_class = G_OBJECT_CLASS (class); - - gobject_class->finalize = gtk_clipboard_finalize; - - class->set_contents = gtk_clipboard_set_contents; - class->clear = gtk_clipboard_real_clear; - class->request_contents = gtk_clipboard_real_request_contents; - class->set_can_store = gtk_clipboard_real_set_can_store; - class->store = gtk_clipboard_real_store; - class->owner_change = gtk_clipboard_owner_change; - - /** - * GtkClipboard::owner-change: - * @clipboard: the #GtkClipboard on which the signal is emitted - * @event: (type Gdk.EventOwnerChange): the @GdkEventOwnerChange event - * - * The ::owner-change signal is emitted when GTK+ receives an - * event that indicates that the ownership of the selection - * associated with @clipboard has changed. - * - * Since: 2.6 - */ - clipboard_signals[OWNER_CHANGE] = - g_signal_new (I_("owner-change"), - G_TYPE_FROM_CLASS (gobject_class), - G_SIGNAL_RUN_FIRST, - G_STRUCT_OFFSET (GtkClipboardClass, owner_change), - NULL, NULL, - NULL, - G_TYPE_NONE, 1, - GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE); -} - -static void -gtk_clipboard_finalize (GObject *object) -{ - GtkClipboard *clipboard; - GtkWidget *clipboard_widget = NULL; - GSList *clipboards = NULL; - - clipboard = GTK_CLIPBOARD (object); - - if (clipboard->display) - { - clipboards = g_object_get_data (G_OBJECT (clipboard->display), "gtk-clipboard-list"); - - if (g_slist_index (clipboards, clipboard) >= 0) - g_warning ("GtkClipboard prematurely finalized"); - - clipboards = g_slist_remove (clipboards, clipboard); - - g_object_set_data (G_OBJECT (clipboard->display), "gtk-clipboard-list", - clipboards); - - /* don't use get_clipboard_widget() here because it would create the - * widget if it doesn't exist. - */ - clipboard_widget = g_object_get_data (G_OBJECT (clipboard->display), - "gtk-clipboard-widget"); - } - - clipboard_unset (clipboard); - - if (clipboard->store_loop && g_main_loop_is_running (clipboard->store_loop)) - g_main_loop_quit (clipboard->store_loop); - - if (clipboard->store_timeout != 0) - g_source_remove (clipboard->store_timeout); - - if (clipboard_widget != NULL && clipboard->notify_signal_id != 0) - g_signal_handler_disconnect (clipboard_widget, clipboard->notify_signal_id); - - g_free (clipboard->storable_formats); - g_free (clipboard->cached_formats); - - G_OBJECT_CLASS (gtk_clipboard_parent_class)->finalize (object); -} - -static void -clipboard_display_closed (GdkDisplay *display, - gboolean is_error, - GtkClipboard *clipboard) -{ - GSList *clipboards; - - clipboards = g_object_get_data (G_OBJECT (display), "gtk-clipboard-list"); - g_object_run_dispose (G_OBJECT (clipboard)); - clipboards = g_slist_remove (clipboards, clipboard); - g_object_set_data (G_OBJECT (display), I_("gtk-clipboard-list"), clipboards); - g_object_unref (clipboard); -} - -/** - * gtk_clipboard_get_for_display: - * @display: the #GdkDisplay for which the clipboard is to be retrieved or created. - * @selection: a #GdkAtom which identifies the clipboard to use. - * - * Returns the clipboard object for the given selection. - * Cut/copy/paste menu items and keyboard shortcuts should use - * the default clipboard, returned by passing %GDK_SELECTION_CLIPBOARD for @selection. - * (%NULL is supported as a synonym for GDK_SELECTION_CLIPBOARD - * for backwards compatibility reasons.) - * The currently-selected object or text should be provided on the clipboard - * identified by #GDK_SELECTION_PRIMARY. Cut/copy/paste menu items - * conceptually copy the contents of the #GDK_SELECTION_PRIMARY clipboard - * to the default clipboard, i.e. they copy the selection to what the - * user sees as the clipboard. - * - * (Passing %NULL is the same as using `gdk_atom_intern - * ("CLIPBOARD", FALSE)`. - * - * See the - * [FreeDesktop Clipboard Specification](http://www.freedesktop.org/Standards/clipboards-spec) - * for a detailed discussion of the “CLIPBOARD” vs. “PRIMARY” - * selections under the X window system. On Win32 the - * #GDK_SELECTION_PRIMARY clipboard is essentially ignored.) - * - * It’s possible to have arbitrary named clipboards; if you do invent - * new clipboards, you should prefix the selection name with an - * underscore (because the ICCCM requires that nonstandard atoms are - * underscore-prefixed), and namespace it as well. For example, - * if your application called “Foo” has a special-purpose - * clipboard, you might call it “_FOO_SPECIAL_CLIPBOARD”. - * - * Returns: (transfer none): the appropriate clipboard object. If no - * clipboard already exists, a new one will be created. Once a clipboard - * object has been created, it is persistent and, since it is owned by - * GTK+, must not be freed or unrefd. - * - * Since: 2.2 - **/ -GtkClipboard * -gtk_clipboard_get_for_display (GdkDisplay *display, - GdkAtom selection) -{ - g_return_val_if_fail (display != NULL, NULL); /* See bgo#463773; this is needed because Flash Player sucks */ - g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); - g_return_val_if_fail (!gdk_display_is_closed (display), NULL); - - return clipboard_peek (display, selection, FALSE); -} - - -/** - * gtk_clipboard_get: - * @selection: a #GdkAtom which identifies the clipboard to use - * - * Returns the clipboard object for the given selection. - * See gtk_clipboard_get_for_display() for complete details. - * - * Returns: (transfer none): the appropriate clipboard object. If no clipboard - * already exists, a new one will be created. Once a clipboard - * object has been created, it is persistent and, since it is - * owned by GTK+, must not be freed or unreffed. - */ -GtkClipboard * -gtk_clipboard_get (GdkAtom selection) -{ - return gtk_clipboard_get_for_display (gdk_display_get_default (), selection); -} - -/** - * gtk_clipboard_get_default: - * @display: the #GdkDisplay for which the clipboard is to be retrieved. - * - * Returns the default clipboard object for use with cut/copy/paste menu items - * and keyboard shortcuts. - * - * Return value: (transfer none): the default clipboard object. - * - * Since: 3.16 - **/ -GtkClipboard * -gtk_clipboard_get_default (GdkDisplay *display) -{ - g_return_val_if_fail (display != NULL, NULL); - g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL); - - return gtk_clipboard_get_for_display (display, GDK_SELECTION_CLIPBOARD); -} - -static void -selection_get_cb (GtkWidget *widget, - GtkSelectionData *selection_data, - guint time) -{ - GtkClipboard *clipboard; - - clipboard = gtk_widget_get_old_clipboard (widget, - gtk_selection_data_get_selection (selection_data)); - - if (clipboard && clipboard->get_func) - clipboard->get_func (clipboard, selection_data, clipboard->user_data); -} - -static gboolean -selection_clear_event_cb (GtkWidget *widget, - GdkEventSelection *event) -{ - GdkAtom selection; - GtkClipboard *clipboard; - - gdk_event_get_selection ((GdkEvent *)event, &selection); - clipboard = gtk_widget_get_old_clipboard (widget, selection); - - if (clipboard) - { - clipboard_unset (clipboard); - - return TRUE; - } - - return FALSE; -} - -static GtkWidget * -make_clipboard_widget (GdkDisplay *display, - gboolean provider) -{ - GtkWidget *widget = gtk_invisible_new_for_display (display); - - g_signal_connect (widget, "selection-received", - G_CALLBACK (selection_received), NULL); - - if (provider) - { - g_signal_connect (widget, "selection-get", - G_CALLBACK (selection_get_cb), NULL); - g_signal_connect (widget, "selection-clear-event", - G_CALLBACK (selection_clear_event_cb), NULL); - } - - return widget; -} - -static GtkWidget * -get_clipboard_widget (GdkDisplay *display) -{ - GtkWidget *clip_widget = g_object_get_data (G_OBJECT (display), "gtk-clipboard-widget"); - if (!clip_widget) - { - clip_widget = make_clipboard_widget (display, TRUE); - g_object_set_data (G_OBJECT (display), I_("gtk-clipboard-widget"), clip_widget); - } - - return clip_widget; -} - -/* This function makes a very good guess at what the correct - * timestamp for a selection request should be. If there is - * a currently processed event, it uses the timestamp for that - * event, otherwise it uses the current server time. However, - * if the time resulting from that is older than the time used - * last time, it uses the time used last time instead. - * - * In order implement this correctly, we never use CurrentTime, - * but actually retrieve the actual timestamp from the server. - * This is a little slower but allows us to make the guarantee - * that the times used by this application will always ascend - * and we won’t get selections being rejected just because - * we are using a correct timestamp from an event, but used - * CurrentTime previously. - */ -static guint32 -clipboard_get_timestamp (GtkClipboard *clipboard) -{ - guint32 timestamp = gtk_get_current_event_time (); - - if (timestamp == GDK_CURRENT_TIME) - { - timestamp = gdk_display_get_last_seen_time (clipboard->display); - } - else - { - if (clipboard->timestamp != GDK_CURRENT_TIME) - { - /* Check to see if clipboard->timestamp is newer than - * timestamp, accounting for wraparound. - */ - - guint32 max = timestamp + 0x80000000; - - if ((max > timestamp && - (clipboard->timestamp > timestamp && - clipboard->timestamp <= max)) || - (max <= timestamp && - (clipboard->timestamp > timestamp || - clipboard->timestamp <= max))) - { - timestamp = clipboard->timestamp; - } - } - } - - clipboard->timestamp = timestamp; - - return timestamp; -} - -static void -clipboard_owner_destroyed (gpointer data) -{ - GSList *clipboards = data; - GSList *tmp_list; - - tmp_list = clipboards; - while (tmp_list) - { - GtkClipboard *clipboard = tmp_list->data; - - clipboard->get_func = NULL; - clipboard->clear_func = NULL; - clipboard->user_data = NULL; - clipboard->have_owner = FALSE; - - gtk_clipboard_clear (clipboard); - - tmp_list = tmp_list->next; - } - - g_slist_free (clipboards); -} - -static void -clipboard_add_owner_notify (GtkClipboard *clipboard) -{ - if (!clipboards_owned_key_id) - clipboards_owned_key_id = g_quark_from_static_string (clipboards_owned_key); - - if (clipboard->have_owner) - g_object_set_qdata_full (clipboard->user_data, clipboards_owned_key_id, - g_slist_prepend (g_object_steal_qdata (clipboard->user_data, - clipboards_owned_key_id), - clipboard), - clipboard_owner_destroyed); -} - -static void -clipboard_remove_owner_notify (GtkClipboard *clipboard) -{ - if (clipboard->have_owner) - g_object_set_qdata_full (clipboard->user_data, clipboards_owned_key_id, - g_slist_remove (g_object_steal_qdata (clipboard->user_data, - clipboards_owned_key_id), - clipboard), - clipboard_owner_destroyed); -} - -static gboolean -gtk_clipboard_set_contents (GtkClipboard *clipboard, - GdkContentFormats *formats, - GtkClipboardGetFunc get_func, - GtkClipboardClearFunc clear_func, - gpointer user_data, - gboolean have_owner) -{ - GtkWidget *clipboard_widget = get_clipboard_widget (clipboard->display); - - if (gtk_selection_owner_set_for_display (clipboard->display, - clipboard_widget, - clipboard->selection, - clipboard_get_timestamp (clipboard))) - { - clipboard->have_selection = TRUE; - - if (clipboard->n_cached_formats != -1) - { - g_free (clipboard->cached_formats); - clipboard->cached_formats = NULL; - clipboard->n_cached_formats = -1; - } - - if (!(clipboard->have_owner && have_owner) || - clipboard->user_data != user_data) - { - clipboard_unset (clipboard); - - clipboard->user_data = user_data; - clipboard->have_owner = have_owner; - if (have_owner) - clipboard_add_owner_notify (clipboard); - } - - clipboard->get_func = get_func; - clipboard->clear_func = clear_func; - - gtk_selection_clear_targets (clipboard_widget, clipboard->selection); - gtk_selection_add_targets (clipboard_widget, clipboard->selection, formats); - - return TRUE; - } - else - return FALSE; -} - -/** - * gtk_clipboard_set_with_data: (skip) - * @clipboard: a #GtkClipboard - * @formats: The targets (data formats) in which the - * functions can provide the data - * @get_func: (scope async): function to call to get the actual clipboard data - * @clear_func: (scope async): when the clipboard contents are set again, - * this function will be called, and @get_func will not be subsequently - * called. - * @user_data: user data to pass to @get_func and @clear_func. - * - * Virtually sets the contents of the specified clipboard by providing - * a list of supported formats for the clipboard data and a function - * to call to get the actual data when it is requested. - * - * Returns: %TRUE if setting the clipboard data succeeded. - * If setting the clipboard data failed the provided callback - * functions will be ignored. - **/ -gboolean -gtk_clipboard_set_with_data (GtkClipboard *clipboard, - GdkContentFormats *formats, - GtkClipboardGetFunc get_func, - GtkClipboardClearFunc clear_func, - gpointer user_data) -{ - g_return_val_if_fail (clipboard != NULL, FALSE); - g_return_val_if_fail (formats != NULL, FALSE); - g_return_val_if_fail (get_func != NULL, FALSE); - - return GTK_CLIPBOARD_GET_CLASS (clipboard)->set_contents (clipboard, - formats, - get_func, - clear_func, - user_data, - FALSE); -} - -/** - * gtk_clipboard_set_with_owner: (skip) - * @clipboard: a #GtkClipboard - * @formats: The targets (data formats) in which the - * functions can provide the data - * @get_func: (scope async): function to call to get the actual clipboard data - * @clear_func: (scope async): when the clipboard contents are set again, - * this function will be called, and @get_func will not be subsequently - * called - * @owner: an object that “owns” the data. This object will be passed - * to the callbacks when called - * - * Virtually sets the contents of the specified clipboard by providing - * a list of supported formats for the clipboard data and a function - * to call to get the actual data when it is requested. - * - * The difference between this function and gtk_clipboard_set_with_data() - * is that instead of an generic @user_data pointer, a #GObject is passed - * in. - * - * Returns: %TRUE if setting the clipboard data succeeded. - * If setting the clipboard data failed the provided callback - * functions will be ignored. - **/ -gboolean -gtk_clipboard_set_with_owner (GtkClipboard *clipboard, - GdkContentFormats *formats, - GtkClipboardGetFunc get_func, - GtkClipboardClearFunc clear_func, - GObject *owner) -{ - g_return_val_if_fail (clipboard != NULL, FALSE); - g_return_val_if_fail (formats != NULL, FALSE); - g_return_val_if_fail (get_func != NULL, FALSE); - g_return_val_if_fail (G_IS_OBJECT (owner), FALSE); - - return GTK_CLIPBOARD_GET_CLASS (clipboard)->set_contents (clipboard, - formats, - get_func, - clear_func, - owner, - TRUE); -} - -/** - * gtk_clipboard_get_owner: - * @clipboard: a #GtkClipboard - * - * If the clipboard contents callbacks were set with - * gtk_clipboard_set_with_owner(), and the gtk_clipboard_set_with_data() or - * gtk_clipboard_clear() has not subsequently called, returns the owner set - * by gtk_clipboard_set_with_owner(). - * - * Returns: (nullable) (transfer none): the owner of the clipboard, if any; - * otherwise %NULL. - **/ -GObject * -gtk_clipboard_get_owner (GtkClipboard *clipboard) -{ - g_return_val_if_fail (clipboard != NULL, NULL); - - if (clipboard->have_owner) - return clipboard->user_data; - else - return NULL; -} - -static void -clipboard_unset (GtkClipboard *clipboard) -{ - GtkClipboardClearFunc old_clear_func; - gpointer old_data; - gboolean old_have_owner; - gint old_n_storable_formats; - - old_clear_func = clipboard->clear_func; - old_data = clipboard->user_data; - old_have_owner = clipboard->have_owner; - old_n_storable_formats = clipboard->n_storable_formats; - - if (old_have_owner) - { - clipboard_remove_owner_notify (clipboard); - clipboard->have_owner = FALSE; - } - - clipboard->n_storable_formats = -1; - g_free (clipboard->storable_formats); - clipboard->storable_formats = NULL; - - clipboard->get_func = NULL; - clipboard->clear_func = NULL; - clipboard->user_data = NULL; - - if (old_clear_func) - old_clear_func (clipboard, old_data); - - /* If we've transferred the clipboard data to the manager, - * unref the owner - */ - if (old_have_owner && - old_n_storable_formats != -1) - g_object_unref (old_data); -} - -/** - * gtk_clipboard_clear: - * @clipboard: a #GtkClipboard - * - * Clears the contents of the clipboard. Generally this should only - * be called between the time you call gtk_clipboard_set_with_owner() - * or gtk_clipboard_set_with_data(), - * and when the @clear_func you supplied is called. Otherwise, the - * clipboard may be owned by someone else. - **/ -void -gtk_clipboard_clear (GtkClipboard *clipboard) -{ - g_return_if_fail (clipboard != NULL); - - GTK_CLIPBOARD_GET_CLASS (clipboard)->clear (clipboard); -} - -static void -gtk_clipboard_real_clear (GtkClipboard *clipboard) -{ - if (clipboard->have_selection) - gtk_selection_owner_set_for_display (clipboard->display, - NULL, - clipboard->selection, - clipboard_get_timestamp (clipboard)); -} - -static void -text_get_func (GtkClipboard *clipboard, - GtkSelectionData *selection_data, - gpointer data) -{ - gtk_selection_data_set_text (selection_data, data, -1); -} - -static void -text_clear_func (GtkClipboard *clipboard, - gpointer data) -{ - g_free (data); -} - - -/** - * gtk_clipboard_set_text: - * @clipboard: a #GtkClipboard object - * @text: a UTF-8 string. - * @len: length of @text, in bytes, or -1, in which case - * the length will be determined with strlen(). - * - * Sets the contents of the clipboard to the given UTF-8 string. GTK+ will - * make a copy of the text and take responsibility for responding - * for requests for the text, and for converting the text into - * the requested format. - **/ -void -gtk_clipboard_set_text (GtkClipboard *clipboard, - const gchar *text, - gint len) -{ - GdkContentFormats *formats; - - g_return_if_fail (clipboard != NULL); - g_return_if_fail (text != NULL); - - formats = gdk_content_formats_new (NULL, 0); - formats = gtk_content_formats_add_text_targets (formats); - - if (len < 0) - len = strlen (text); - - gtk_clipboard_set_with_data (clipboard, - formats, - text_get_func, text_clear_func, - g_strndup (text, len)); - gtk_clipboard_set_can_store (clipboard, NULL); - - gdk_content_formats_unref (formats); -} - -static void -pixbuf_get_func (GtkClipboard *clipboard, - GtkSelectionData *selection_data, - gpointer data) -{ - gtk_selection_data_set_pixbuf (selection_data, data); -} - -static void -pixbuf_clear_func (GtkClipboard *clipboard, - gpointer data) -{ - g_object_unref (data); -} - -/** - * gtk_clipboard_set_image: - * @clipboard: a #GtkClipboard object - * @pixbuf: a #GdkPixbuf - * - * Sets the contents of the clipboard to the given #GdkPixbuf. - * GTK+ will take responsibility for responding for requests - * for the image, and for converting the image into the - * requested format. - * - * Since: 2.6 - **/ -void -gtk_clipboard_set_image (GtkClipboard *clipboard, - GdkPixbuf *pixbuf) -{ - GdkContentFormats *formats; - - g_return_if_fail (clipboard != NULL); - g_return_if_fail (GDK_IS_PIXBUF (pixbuf)); - - formats = gdk_content_formats_new (NULL, 0); - formats = gtk_content_formats_add_image_targets (formats, TRUE); - - gtk_clipboard_set_with_data (clipboard, - formats, - pixbuf_get_func, pixbuf_clear_func, - g_object_ref (pixbuf)); - gtk_clipboard_set_can_store (clipboard, NULL); - - gdk_content_formats_unref (formats); -} - -/** - * gtk_clipboard_set_surface: - * @clipboard: a #GtkClipboard object - * @surface: a cairo image surface - * - * Sets the contents of the clipboard to the given cairo image surface. - * GTK+ will take responsibility for responding for requests for the - * image, and for converting the image into the requested format. - * - * Since: 3.94 - **/ -void -gtk_clipboard_set_surface (GtkClipboard *clipboard, - cairo_surface_t *surface) -{ - GdkPixbuf *pixbuf; - - pixbuf = gdk_pixbuf_get_from_surface (surface, - 0, 0, - cairo_image_surface_get_width (surface), - cairo_image_surface_get_height (surface)); - gtk_clipboard_set_image (clipboard, pixbuf); - g_object_unref (pixbuf); - -} - -static void -set_request_contents_info (GtkWidget *widget, - RequestContentsInfo *info) -{ - if (!request_contents_key_id) - request_contents_key_id = g_quark_from_static_string (request_contents_key); - - g_object_set_qdata (G_OBJECT (widget), request_contents_key_id, info); -} - -static RequestContentsInfo * -get_request_contents_info (GtkWidget *widget) -{ - if (!request_contents_key_id) - return NULL; - else - return g_object_get_qdata (G_OBJECT (widget), request_contents_key_id); -} - -static void -selection_received (GtkWidget *widget, - GtkSelectionData *selection_data, - guint time) -{ - RequestContentsInfo *request_info = get_request_contents_info (widget); - set_request_contents_info (widget, NULL); - - request_info->callback (gtk_widget_get_old_clipboard (widget, gtk_selection_data_get_selection (selection_data)), - selection_data, - request_info->user_data); - - g_free (request_info); - - if (widget != get_clipboard_widget (gtk_widget_get_display (widget))) - gtk_widget_destroy (widget); -} - -/** - * gtk_clipboard_request_contents: - * @clipboard: a #GtkClipboard - * @target: an atom representing the form into which the clipboard - * owner should convert the selection. - * @callback: (scope async): A function to call when the results are received - * (or the retrieval fails). If the retrieval fails the length field of - * @selection_data will be negative. - * @user_data: user data to pass to @callback - * - * Requests the contents of clipboard as the given target. - * When the results of the result are later received the supplied callback - * will be called. - **/ -void -gtk_clipboard_request_contents (GtkClipboard *clipboard, - GdkAtom target, - GtkClipboardReceivedFunc callback, - gpointer user_data) -{ - g_return_if_fail (clipboard != NULL); - g_return_if_fail (target != NULL); - g_return_if_fail (callback != NULL); - - GTK_CLIPBOARD_GET_CLASS (clipboard)->request_contents (clipboard, - target, - callback, - user_data); -} - -static void -gtk_clipboard_real_request_contents (GtkClipboard *clipboard, - GdkAtom target, - GtkClipboardReceivedFunc callback, - gpointer user_data) -{ - RequestContentsInfo *info; - GtkWidget *widget; - GtkWidget *clipboard_widget; - - clipboard_widget = get_clipboard_widget (clipboard->display); - - if (get_request_contents_info (clipboard_widget)) - widget = make_clipboard_widget (clipboard->display, FALSE); - else - widget = clipboard_widget; - - info = g_new (RequestContentsInfo, 1); - info->callback = callback; - info->user_data = user_data; - - set_request_contents_info (widget, info); - - gtk_selection_convert (widget, clipboard->selection, target, - clipboard_get_timestamp (clipboard)); -} - -static void -request_text_received_func (GtkClipboard *clipboard, - GtkSelectionData *selection_data, - gpointer data) -{ - RequestTextInfo *info = data; - gchar *result = NULL; - - result = (gchar *) gtk_selection_data_get_text (selection_data); - - if (!result) - { - /* If we asked for UTF8 and didn't get it, try compound_text; - * if we asked for compound_text and didn't get it, try string; - * If we asked for anything else and didn't get it, give up. - */ - GdkAtom target = gtk_selection_data_get_target (selection_data); - - if (target == gdk_atom_intern_static_string ("text/plain;charset=utf-8")) - { - gtk_clipboard_request_contents (clipboard, - gdk_atom_intern_static_string ("UTF8_STRING"), - request_text_received_func, info); - return; - } - else if (target == gdk_atom_intern_static_string ("UTF8_STRING")) - { - gtk_clipboard_request_contents (clipboard, - gdk_atom_intern_static_string ("COMPOUND_TEXT"), - request_text_received_func, info); - return; - } - else if (target == gdk_atom_intern_static_string ("COMPOUND_TEXT")) - { - gtk_clipboard_request_contents (clipboard, - GDK_TARGET_STRING, - request_text_received_func, info); - return; - } - } - - info->callback (clipboard, result, info->user_data); - g_free (info); - g_free (result); -} - -/** - * gtk_clipboard_request_text: - * @clipboard: a #GtkClipboard - * @callback: (scope async): a function to call when the text is received, - * or the retrieval fails. (It will always be called one way or the other.) - * @user_data: user data to pass to @callback. - * - * Requests the contents of the clipboard as text. When the text is - * later received, it will be converted to UTF-8 if necessary, and - * @callback will be called. - * - * The @text parameter to @callback will contain the resulting text if - * the request succeeded, or %NULL if it failed. This could happen for - * various reasons, in particular if the clipboard was empty or if the - * contents of the clipboard could not be converted into text form. - **/ -void -gtk_clipboard_request_text (GtkClipboard *clipboard, - GtkClipboardTextReceivedFunc callback, - gpointer user_data) -{ - RequestTextInfo *info; - - g_return_if_fail (clipboard != NULL); - g_return_if_fail (callback != NULL); - - info = g_new (RequestTextInfo, 1); - info->callback = callback; - info->user_data = user_data; - - gtk_clipboard_request_contents (clipboard, gdk_atom_intern_static_string ("text/plain;charset=utf-8"), - request_text_received_func, - info); -} - -static void -request_image_received_func (GtkClipboard *clipboard, - GtkSelectionData *selection_data, - gpointer data) -{ - RequestImageInfo *info = data; - GdkPixbuf *result = NULL; - - result = gtk_selection_data_get_pixbuf (selection_data); - - if (!result) - { - /* If we asked for image/png and didn't get it, try image/jpeg; - * if we asked for image/jpeg and didn't get it, try image/gif; - * if we asked for image/gif and didn't get it, try image/bmp; - * If we asked for anything else and didn't get it, give up. - */ - GdkAtom target = gtk_selection_data_get_target (selection_data); - - if (target == gdk_atom_intern_static_string ("image/png")) - { - gtk_clipboard_request_contents (clipboard, - gdk_atom_intern_static_string ("image/jpeg"), - request_image_received_func, info); - return; - } - else if (target == gdk_atom_intern_static_string ("image/jpeg")) - { - gtk_clipboard_request_contents (clipboard, - gdk_atom_intern_static_string ("image/gif"), - request_image_received_func, info); - return; - } - else if (target == gdk_atom_intern_static_string ("image/gif")) - { - gtk_clipboard_request_contents (clipboard, - gdk_atom_intern_static_string ("image/bmp"), - request_image_received_func, info); - return; - } - } - - info->callback (clipboard, result, info->user_data); - g_free (info); - - if (result) - g_object_unref (result); -} - -/** - * gtk_clipboard_request_image: - * @clipboard: a #GtkClipboard - * @callback: (scope async): a function to call when the image is received, - * or the retrieval fails. (It will always be called one way or the other.) - * @user_data: user data to pass to @callback. - * - * Requests the contents of the clipboard as image. When the image is - * later received, it will be converted to a #GdkPixbuf, and - * @callback will be called. - * - * The @pixbuf parameter to @callback will contain the resulting - * #GdkPixbuf if the request succeeded, or %NULL if it failed. This - * could happen for various reasons, in particular if the clipboard - * was empty or if the contents of the clipboard could not be - * converted into an image. - * - * Since: 2.6 - **/ -void -gtk_clipboard_request_image (GtkClipboard *clipboard, - GtkClipboardImageReceivedFunc callback, - gpointer user_data) -{ - RequestImageInfo *info; - - g_return_if_fail (clipboard != NULL); - g_return_if_fail (callback != NULL); - - info = g_new (RequestImageInfo, 1); - info->callback = callback; - info->user_data = user_data; - - gtk_clipboard_request_contents (clipboard, - gdk_atom_intern_static_string ("image/png"), - request_image_received_func, - info); -} - -static void -request_uris_received_func (GtkClipboard *clipboard, - GtkSelectionData *selection_data, - gpointer data) -{ - RequestURIInfo *info = data; - gchar **uris; - - uris = gtk_selection_data_get_uris (selection_data); - info->callback (clipboard, uris, info->user_data); - g_strfreev (uris); - - g_slice_free (RequestURIInfo, info); -} - -/** - * gtk_clipboard_request_uris: - * @clipboard: a #GtkClipboard - * @callback: (scope async): a function to call when the URIs are received, - * or the retrieval fails. (It will always be called one way or the other.) - * @user_data: user data to pass to @callback. - * - * Requests the contents of the clipboard as URIs. When the URIs are - * later received @callback will be called. - * - * The @uris parameter to @callback will contain the resulting array of - * URIs if the request succeeded, or %NULL if it failed. This could happen - * for various reasons, in particular if the clipboard was empty or if the - * contents of the clipboard could not be converted into URI form. - * - * Since: 2.14 - **/ -void -gtk_clipboard_request_uris (GtkClipboard *clipboard, - GtkClipboardURIReceivedFunc callback, - gpointer user_data) -{ - RequestURIInfo *info; - - g_return_if_fail (clipboard != NULL); - g_return_if_fail (callback != NULL); - - info = g_slice_new (RequestURIInfo); - info->callback = callback; - info->user_data = user_data; - - gtk_clipboard_request_contents (clipboard, gdk_atom_intern_static_string ("text/uri-list"), - request_uris_received_func, - info); -} - -static void -request_formats_received_func (GtkClipboard *clipboard, - GtkSelectionData *selection_data, - gpointer data) -{ - RequestTargetsInfo *info = data; - GdkAtom *formats = NULL; - gint n_formats = 0; - - gtk_selection_data_get_targets (selection_data, &formats, &n_formats); - - info->callback (clipboard, formats, n_formats, info->user_data); - - g_free (info); - g_free (formats); -} - -/** - * gtk_clipboard_request_formats: - * @clipboard: a #GtkClipboard - * @callback: (scope async): a function to call when the formats are - * received, or the retrieval fails. (It will always be called - * one way or the other.) - * @user_data: user data to pass to @callback. - * - * Requests the contents of the clipboard as list of supported formats. - * When the list is later received, @callback will be called. - * - * The @formats parameter to @callback will contain the resulting formats if - * the request succeeded, or %NULL if it failed. - * - * Since: 2.4 - **/ -void -gtk_clipboard_request_targets (GtkClipboard *clipboard, - GtkClipboardTargetsReceivedFunc callback, - gpointer user_data) -{ - RequestTargetsInfo *info; - - g_return_if_fail (clipboard != NULL); - g_return_if_fail (callback != NULL); - - /* If the display supports change notification we cache formats */ - if (gdk_display_supports_selection_notification (gtk_clipboard_get_display (clipboard)) && - clipboard->n_cached_formats != -1) - { - (* callback) (clipboard, clipboard->cached_formats, clipboard->n_cached_formats, user_data); - return; - } - - info = g_new (RequestTargetsInfo, 1); - info->callback = callback; - info->user_data = user_data; - - gtk_clipboard_request_contents (clipboard, gdk_atom_intern_static_string ("TARGETS"), - request_formats_received_func, - info); -} - -typedef struct -{ - GMainLoop *loop; - gpointer data; - GdkAtom format; /* used by rich text */ - gsize length; /* used by rich text */ -} WaitResults; - -static void -clipboard_received_func (GtkClipboard *clipboard, - GtkSelectionData *selection_data, - gpointer data) -{ - WaitResults *results = data; - - if (gtk_selection_data_get_length (selection_data) >= 0) - results->data = gtk_selection_data_copy (selection_data); - - g_main_loop_quit (results->loop); -} - -/** - * gtk_clipboard_wait_for_contents: - * @clipboard: a #GtkClipboard - * @target: an atom representing the form into which the clipboard - * owner should convert the selection. - * - * Requests the contents of the clipboard using the given target. - * This function waits for the data to be received using the main - * loop, so events, timeouts, etc, may be dispatched during the wait. - * - * Returns: (nullable): a newly-allocated #GtkSelectionData object or %NULL - * if retrieving the given target failed. If non-%NULL, - * this value must be freed with gtk_selection_data_free() - * when you are finished with it. - **/ -GtkSelectionData * -gtk_clipboard_wait_for_contents (GtkClipboard *clipboard, - GdkAtom target) -{ - WaitResults results; - - g_return_val_if_fail (clipboard != NULL, NULL); - g_return_val_if_fail (target != NULL, NULL); - - results.data = NULL; - results.loop = g_main_loop_new (NULL, TRUE); - - gtk_clipboard_request_contents (clipboard, target, - clipboard_received_func, - &results); - - if (g_main_loop_is_running (results.loop)) - { - gdk_threads_leave (); - g_main_loop_run (results.loop); - gdk_threads_enter (); - } - - g_main_loop_unref (results.loop); - - return results.data; -} - -static void -clipboard_text_received_func (GtkClipboard *clipboard, - const gchar *text, - gpointer data) -{ - WaitResults *results = data; - - results->data = g_strdup (text); - g_main_loop_quit (results->loop); -} - -/** - * gtk_clipboard_wait_for_text: - * @clipboard: a #GtkClipboard - * - * Requests the contents of the clipboard as text and converts - * the result to UTF-8 if necessary. This function waits for - * the data to be received using the main loop, so events, - * timeouts, etc, may be dispatched during the wait. - * - * Returns: (nullable): a newly-allocated UTF-8 string which must - * be freed with g_free(), or %NULL if retrieving - * the selection data failed. (This could happen - * for various reasons, in particular if the - * clipboard was empty or if the contents of the - * clipboard could not be converted into text form.) - **/ -gchar * -gtk_clipboard_wait_for_text (GtkClipboard *clipboard) -{ - WaitResults results; - - g_return_val_if_fail (clipboard != NULL, NULL); - - results.data = NULL; - results.loop = g_main_loop_new (NULL, TRUE); - - gtk_clipboard_request_text (clipboard, - clipboard_text_received_func, - &results); - - if (g_main_loop_is_running (results.loop)) - { - gdk_threads_leave (); - g_main_loop_run (results.loop); - gdk_threads_enter (); - } - - g_main_loop_unref (results.loop); - - return results.data; -} - -static void -clipboard_image_received_func (GtkClipboard *clipboard, - GdkPixbuf *pixbuf, - gpointer data) -{ - WaitResults *results = data; - - if (pixbuf) - results->data = g_object_ref (pixbuf); - - g_main_loop_quit (results->loop); -} - -static void -clipboard_surface_received_func (GtkClipboard *clipboard, - GdkPixbuf *pixbuf, - gpointer data) -{ - WaitResults *results = data; - - if (pixbuf) - results->data = gdk_cairo_surface_create_from_pixbuf (pixbuf, 1, NULL); - - g_main_loop_quit (results->loop); -} - -/** - * gtk_clipboard_wait_for_image: - * @clipboard: a #GtkClipboard - * - * Requests the contents of the clipboard as image and converts - * the result to a #GdkPixbuf. This function waits for - * the data to be received using the main loop, so events, - * timeouts, etc, may be dispatched during the wait. - * - * Returns: (nullable) (transfer full): a newly-allocated #GdkPixbuf - * object which must be disposed with g_object_unref(), or - * %NULL if retrieving the selection data failed. (This could - * happen for various reasons, in particular if the clipboard - * was empty or if the contents of the clipboard could not be - * converted into an image.) - * - * Since: 2.6 - **/ -GdkPixbuf * -gtk_clipboard_wait_for_image (GtkClipboard *clipboard) -{ - WaitResults results; - - g_return_val_if_fail (clipboard != NULL, NULL); - - results.data = NULL; - results.loop = g_main_loop_new (NULL, TRUE); - - gtk_clipboard_request_image (clipboard, - clipboard_image_received_func, - &results); - - if (g_main_loop_is_running (results.loop)) - { - gdk_threads_leave (); - g_main_loop_run (results.loop); - gdk_threads_enter (); - } - - g_main_loop_unref (results.loop); - - return results.data; -} - -/** - * gtk_clipboard_wait_for_surface: - * @clipboard: a #GtkClipboard - * - * Requests the contents of the clipboard as image and converts - * the result to a cairo surface. This function waits for - * the data to be received using the main loop, so events, - * timeouts, etc, may be dispatched during the wait. - * - * Returns: (nullable) (transfer full): a newly-allocated cairo surface - * object which must be disposed with cairo_surface_destroy(), or - * %NULL if retrieving the selection data failed. (This could - * happen for various reasons, in particular if the clipboard - * was empty or if the contents of the clipboard could not be - * converted into an image.) - * - * Since: 2.6 - **/ -cairo_surface_t * -gtk_clipboard_wait_for_surface (GtkClipboard *clipboard) -{ - WaitResults results; - - g_return_val_if_fail (clipboard != NULL, NULL); - - results.data = NULL; - results.loop = g_main_loop_new (NULL, TRUE); - - gtk_clipboard_request_image (clipboard, - clipboard_surface_received_func, - &results); - - if (g_main_loop_is_running (results.loop)) - { - gdk_threads_leave (); - g_main_loop_run (results.loop); - gdk_threads_enter (); - } - - g_main_loop_unref (results.loop); - - return results.data; -} - -static void -clipboard_uris_received_func (GtkClipboard *clipboard, - gchar **uris, - gpointer data) -{ - WaitResults *results = data; - - results->data = g_strdupv (uris); - g_main_loop_quit (results->loop); -} - -/** - * gtk_clipboard_wait_for_uris: - * @clipboard: a #GtkClipboard - * - * Requests the contents of the clipboard as URIs. This function waits - * for the data to be received using the main loop, so events, - * timeouts, etc, may be dispatched during the wait. - * - * Returns: (nullable) (array zero-terminated=1) (element-type utf8) (transfer full): - * a newly-allocated %NULL-terminated array of strings which must - * be freed with g_strfreev(), or %NULL if retrieving the - * selection data failed. (This could happen for various reasons, - * in particular if the clipboard was empty or if the contents of - * the clipboard could not be converted into URI form.) - * - * Since: 2.14 - **/ -gchar ** -gtk_clipboard_wait_for_uris (GtkClipboard *clipboard) -{ - WaitResults results; - - g_return_val_if_fail (clipboard != NULL, NULL); - - results.data = NULL; - results.loop = g_main_loop_new (NULL, TRUE); - - gtk_clipboard_request_uris (clipboard, - clipboard_uris_received_func, - &results); - - if (g_main_loop_is_running (results.loop)) - { - gdk_threads_leave (); - g_main_loop_run (results.loop); - gdk_threads_enter (); - } - - g_main_loop_unref (results.loop); - - return results.data; -} - -/** - * gtk_clipboard_get_display: - * @clipboard: a #GtkClipboard - * - * Gets the #GdkDisplay associated with @clipboard - * - * Returns: (transfer none): the #GdkDisplay associated with @clipboard - * - * Since: 2.2 - **/ -GdkDisplay * -gtk_clipboard_get_display (GtkClipboard *clipboard) -{ - g_return_val_if_fail (clipboard != NULL, NULL); - - return clipboard->display; -} - -/** - * gtk_clipboard_wait_is_text_available: - * @clipboard: a #GtkClipboard - * - * Test to see if there is text available to be pasted - * This is done by requesting the TARGETS atom and checking - * if it contains any of the supported text formats. This function - * waits for the data to be received using the main loop, so events, - * timeouts, etc, may be dispatched during the wait. - * - * This function is a little faster than calling - * gtk_clipboard_wait_for_text() since it doesn’t need to retrieve - * the actual text. - * - * Returns: %TRUE is there is text available, %FALSE otherwise. - **/ -gboolean -gtk_clipboard_wait_is_text_available (GtkClipboard *clipboard) -{ - GtkSelectionData *data; - gboolean result = FALSE; - - data = gtk_clipboard_wait_for_contents (clipboard, gdk_atom_intern_static_string ("TARGETS")); - if (data) - { - result = gtk_selection_data_targets_include_text (data); - gtk_selection_data_free (data); - } - - return result; -} - -/** - * gtk_clipboard_wait_is_image_available: - * @clipboard: a #GtkClipboard - * - * Test to see if there is an image available to be pasted - * This is done by requesting the TARGETS atom and checking - * if it contains any of the supported image formats. This function - * waits for the data to be received using the main loop, so events, - * timeouts, etc, may be dispatched during the wait. - * - * This function is a little faster than calling - * gtk_clipboard_wait_for_image() since it doesn’t need to retrieve - * the actual image data. - * - * Returns: %TRUE is there is an image available, %FALSE otherwise. - * - * Since: 2.6 - **/ -gboolean -gtk_clipboard_wait_is_image_available (GtkClipboard *clipboard) -{ - GtkSelectionData *data; - gboolean result = FALSE; - - data = gtk_clipboard_wait_for_contents (clipboard, - gdk_atom_intern_static_string ("TARGETS")); - if (data) - { - result = gtk_selection_data_targets_include_image (data, FALSE); - gtk_selection_data_free (data); - } - - return result; -} - -/** - * gtk_clipboard_wait_is_uris_available: - * @clipboard: a #GtkClipboard - * - * Test to see if there is a list of URIs available to be pasted - * This is done by requesting the TARGETS atom and checking - * if it contains the URI formats. This function - * waits for the data to be received using the main loop, so events, - * timeouts, etc, may be dispatched during the wait. - * - * This function is a little faster than calling - * gtk_clipboard_wait_for_uris() since it doesn’t need to retrieve - * the actual URI data. - * - * Returns: %TRUE is there is an URI list available, %FALSE otherwise. - * - * Since: 2.14 - **/ -gboolean -gtk_clipboard_wait_is_uris_available (GtkClipboard *clipboard) -{ - GtkSelectionData *data; - gboolean result = FALSE; - - data = gtk_clipboard_wait_for_contents (clipboard, - gdk_atom_intern_static_string ("TARGETS")); - if (data) - { - result = gtk_selection_data_targets_include_uri (data); - gtk_selection_data_free (data); - } - - return result; -} - -/** - * gtk_clipboard_wait_for_targets: - * @clipboard: a #GtkClipboard - * @formats: (out) (array length=n_formats) (transfer container): location - * to store an array of formats. The result stored here must - * be freed with g_free(). - * @n_formats: (out): location to store number of items in @formats. - * - * Returns a list of formats that are present on the clipboard, or %NULL - * if there aren’t any formats available. The returned list must be - * freed with g_free(). - * This function waits for the data to be received using the main - * loop, so events, timeouts, etc, may be dispatched during the wait. - * - * Returns: %TRUE if any formats are present on the clipboard, - * otherwise %FALSE. - * - * Since: 2.4 - */ -gboolean -gtk_clipboard_wait_for_targets (GtkClipboard *clipboard, - GdkAtom **formats, - gint *n_formats) -{ - GtkSelectionData *data; - gboolean result = FALSE; - - g_return_val_if_fail (clipboard != NULL, FALSE); - - /* If the display supports change notification we cache formats */ - if (gdk_display_supports_selection_notification (gtk_clipboard_get_display (clipboard)) && - clipboard->n_cached_formats != -1) - { - if (n_formats) - *n_formats = clipboard->n_cached_formats; - - if (formats) - *formats = g_memdup (clipboard->cached_formats, - clipboard->n_cached_formats * sizeof (GdkAtom)); - - return TRUE; - } - - if (n_formats) - *n_formats = 0; - - if (formats) - *formats = NULL; - - data = gtk_clipboard_wait_for_contents (clipboard, gdk_atom_intern_static_string ("TARGETS")); - - if (data) - { - GdkAtom *tmp_formats; - gint tmp_n_formats; - - result = gtk_selection_data_get_targets (data, &tmp_formats, &tmp_n_formats); - - if (gdk_display_supports_selection_notification (gtk_clipboard_get_display (clipboard))) - { - clipboard->n_cached_formats = tmp_n_formats; - clipboard->cached_formats = g_memdup (tmp_formats, - tmp_n_formats * sizeof (GdkAtom)); - } - - if (n_formats) - *n_formats = tmp_n_formats; - - if (formats) - *formats = tmp_formats; - else - g_free (tmp_formats); - - gtk_selection_data_free (data); - } - - return result; -} - -static GtkClipboard * -clipboard_peek (GdkDisplay *display, - GdkAtom selection, - gboolean only_if_exists) -{ - GtkClipboard *clipboard = NULL; - GSList *clipboards; - GSList *tmp_list; - - if (selection == NULL) - selection = GDK_SELECTION_CLIPBOARD; - - clipboards = g_object_get_data (G_OBJECT (display), "gtk-clipboard-list"); - - tmp_list = clipboards; - while (tmp_list) - { - clipboard = tmp_list->data; - if (clipboard->selection == selection) - break; - - tmp_list = tmp_list->next; - } - - if (!tmp_list && !only_if_exists) - { - clipboard = g_object_new (GTK_TYPE_CLIPBOARD, NULL); - - clipboard->selection = selection; - clipboard->display = display; - clipboard->n_cached_formats = -1; - clipboard->n_storable_formats = -1; - clipboards = g_slist_prepend (clipboards, clipboard); - g_object_set_data (G_OBJECT (display), I_("gtk-clipboard-list"), clipboards); - g_signal_connect (display, "closed", - G_CALLBACK (clipboard_display_closed), clipboard); - gdk_display_request_selection_notification (display, selection); - } - - return clipboard; -} - -static void -gtk_clipboard_owner_change (GtkClipboard *clipboard, - GdkEventOwnerChange *event) -{ - if (clipboard->n_cached_formats != -1) - { - g_free (clipboard->cached_formats); - clipboard->cached_formats = NULL; - clipboard->n_cached_formats = -1; - } -} - -/** - * gtk_clipboard_wait_is_target_available: - * @clipboard: a #GtkClipboard - * @target: A #GdkAtom indicating which target to look for. - * - * Checks if a clipboard supports pasting data of a given type. This - * function can be used to determine if a “Paste” menu item should be - * insensitive or not. - * - * If you want to see if there’s text available on the clipboard, use - * gtk_clipboard_wait_is_text_available () instead. - * - * Returns: %TRUE if the target is available, %FALSE otherwise. - * - * Since: 2.6 - */ -gboolean -gtk_clipboard_wait_is_target_available (GtkClipboard *clipboard, - GdkAtom target) -{ - GdkAtom *formats; - gint i, n_formats; - gboolean retval = FALSE; - - if (!gtk_clipboard_wait_for_targets (clipboard, &formats, &n_formats)) - return FALSE; - - for (i = 0; i < n_formats; i++) - { - if (formats[i] == target) - { - retval = TRUE; - break; - } - } - - g_free (formats); - - return retval; -} - -/** - * _gtk_clipboard_handle_event: - * @event: a owner change event - * - * Emits the #GtkClipboard::owner-change signal on the appropriate @clipboard. - * - * Since: 2.6 - **/ -void -_gtk_clipboard_handle_event (GdkEventOwnerChange *event) -{ - GdkDisplay *display; - GdkAtom selection; - GtkClipboard *clipboard; - - gdk_event_get_selection ((GdkEvent *)event, &selection); - display = gdk_window_get_display (gdk_event_get_window ((GdkEvent *)event)); - clipboard = clipboard_peek (display, selection, TRUE); - - if (clipboard) - g_signal_emit (clipboard, - clipboard_signals[OWNER_CHANGE], 0, event, NULL); -} - -static gboolean -gtk_clipboard_store_timeout (GtkClipboard *clipboard) -{ - g_main_loop_quit (clipboard->store_loop); - - return G_SOURCE_REMOVE; -} - -/** - * gtk_clipboard_set_can_store: - * @clipboard: a #GtkClipboard - * @formats: (allow-none): The targets (data formats) in which the - * functions can provide the data or %NULL - * to indicate that all forms should be stored. - * - * Hints that the clipboard data should be stored somewhere when the - * application exits or when gtk_clipboard_store () is called. - * - * This value is reset when the clipboard owner changes. - * Where the clipboard data is stored is platform dependent, - * see gdk_display_store_clipboard () for more information. - * - * Since: 2.6 - */ -void -gtk_clipboard_set_can_store (GtkClipboard *clipboard, - GdkContentFormats *formats) -{ - g_return_if_fail (GTK_IS_CLIPBOARD (clipboard)); - - GTK_CLIPBOARD_GET_CLASS (clipboard)->set_can_store (clipboard, formats); -} - -static void -gtk_clipboard_real_set_can_store (GtkClipboard *clipboard, - GdkContentFormats *formats) -{ - GtkWidget *clipboard_widget; - - if (clipboard->selection != GDK_SELECTION_CLIPBOARD) - return; - - g_free (clipboard->storable_formats); - - clipboard_widget = get_clipboard_widget (clipboard->display); - - /* n_storable_formats being -1 means that - * gtk_clipboard_set_can_store hasn't been called since the - * clipboard owner changed. We only want to add SAVE_TARGETS and - * ref the owner once , so we do that here - */ - if (clipboard->n_storable_formats == -1) - { - gtk_selection_add_target (clipboard_widget, - clipboard->selection, - gdk_atom_intern_static_string ("SAVE_TARGETS")); - - /* Ref the owner so it won't go away */ - if (clipboard->have_owner) - g_object_ref (clipboard->user_data); - } - - if (formats) - { - const char * const *mime_types; - gsize n_mime_types; - - mime_types = gdk_content_formats_get_mime_types (formats, &n_mime_types); - clipboard->storable_formats = g_memdup (mime_types, sizeof (char *) * n_mime_types); - clipboard->n_storable_formats = n_mime_types; - } - else - { - clipboard->storable_formats = NULL; - clipboard->n_storable_formats = 0; - } -} - -static gboolean -gtk_clipboard_selection_notify (GtkWidget *widget, - GdkEventSelection *event, - GtkClipboard *clipboard) -{ - GdkAtom selection; - - gdk_event_get_selection ((GdkEvent *)event, &selection); - if (selection == gdk_atom_intern_static_string ("CLIPBOARD_MANAGER") && - clipboard->storing_selection) - g_main_loop_quit (clipboard->store_loop); - - return FALSE; -} - -/** - * gtk_clipboard_store: - * @clipboard: a #GtkClipboard - * - * Stores the current clipboard data somewhere so that it will stay - * around after the application has quit. - * - * Since: 2.6 - */ -void -gtk_clipboard_store (GtkClipboard *clipboard) -{ - g_return_if_fail (GTK_IS_CLIPBOARD (clipboard)); - - GTK_CLIPBOARD_GET_CLASS (clipboard)->store (clipboard); -} - -static void -gtk_clipboard_real_store (GtkClipboard *clipboard) -{ - GtkWidget *clipboard_widget; - - if (clipboard->n_storable_formats < 0) - return; - - if (!gdk_display_supports_clipboard_persistence (clipboard->display)) - return; - - g_object_ref (clipboard); - - clipboard_widget = get_clipboard_widget (clipboard->display); - clipboard->notify_signal_id = g_signal_connect (clipboard_widget, - "selection-notify-event", - G_CALLBACK (gtk_clipboard_selection_notify), - clipboard); - - gdk_display_store_clipboard (clipboard->display, - gtk_widget_get_window (clipboard_widget), - clipboard_get_timestamp (clipboard), - clipboard->storable_formats, - clipboard->n_storable_formats); - - clipboard->storing_selection = TRUE; - - clipboard->store_loop = g_main_loop_new (NULL, TRUE); - clipboard->store_timeout = g_timeout_add_seconds (10, (GSourceFunc) gtk_clipboard_store_timeout, clipboard); - g_source_set_name_by_id (clipboard->store_timeout, "[gtk+] gtk_clipboard_store_timeout"); - - if (g_main_loop_is_running (clipboard->store_loop)) - { - gdk_threads_leave (); - g_main_loop_run (clipboard->store_loop); - gdk_threads_enter (); - } - - g_main_loop_unref (clipboard->store_loop); - clipboard->store_loop = NULL; - - g_source_remove (clipboard->store_timeout); - clipboard->store_timeout = 0; - g_signal_handler_disconnect (clipboard_widget, clipboard->notify_signal_id); - clipboard->notify_signal_id = 0; - - clipboard->storing_selection = FALSE; - - g_object_unref (clipboard); -} - -/* Stores all clipboard selections on all displays, called from - * gtk_main_quit (). - */ -void -_gtk_clipboard_store_all (void) -{ - GtkClipboard *clipboard; - GSList *displays, *list; - - displays = gdk_display_manager_list_displays (gdk_display_manager_get ()); - - list = displays; - while (list) - { - GdkDisplay *display = list->data; - - clipboard = clipboard_peek (display, GDK_SELECTION_CLIPBOARD, TRUE); - - if (clipboard) - gtk_clipboard_store (clipboard); - - list = list->next; - } - g_slist_free (displays); - -} - -/** - * gtk_clipboard_get_selection: - * @clipboard: a #GtkClipboard - * - * Gets the selection that this clipboard is for. - * - * Returns: the selection - * - * Since: 3.22 - */ -GdkAtom -gtk_clipboard_get_selection (GtkClipboard *clipboard) -{ - g_return_val_if_fail (GTK_IS_CLIPBOARD (clipboard), NULL); - - return clipboard->selection; -} diff --git a/gtk/gtkclipboard.h b/gtk/gtkclipboard.h deleted file mode 100644 index d69f41800d..0000000000 --- a/gtk/gtkclipboard.h +++ /dev/null @@ -1,288 +0,0 @@ -/* GTK - The GIMP Toolkit - * Copyright (C) 2000 Red Hat, Inc. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - * Global clipboard abstraction. - */ - -#ifndef __GTK_CLIPBOARD_H__ -#define __GTK_CLIPBOARD_H__ - -#if !defined (__GTK_H_INSIDE__) && !defined (GTK_COMPILATION) -#error "Only can be included directly." -#endif - -#include - -G_BEGIN_DECLS - -#define GTK_TYPE_CLIPBOARD (gtk_clipboard_get_type ()) -#define GTK_CLIPBOARD(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), GTK_TYPE_CLIPBOARD, GtkClipboard)) -#define GTK_IS_CLIPBOARD(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), GTK_TYPE_CLIPBOARD)) - -/** - * GtkClipboardReceivedFunc: - * @clipboard: the #GtkClipboard - * @selection_data: a #GtkSelectionData containing the data was received. - * If retrieving the data failed, then then length field - * of @selection_data will be negative. - * @data: (closure): the @user_data supplied to - * gtk_clipboard_request_contents(). - * - * A function to be called when the results of gtk_clipboard_request_contents() - * are received, or when the request fails. - */ -typedef void (* GtkClipboardReceivedFunc) (GtkClipboard *clipboard, - GtkSelectionData *selection_data, - gpointer data); - -/** - * GtkClipboardTextReceivedFunc: - * @clipboard: the #GtkClipboard - * @text: (nullable): the text received, as a UTF-8 encoded string, or - * %NULL if retrieving the data failed. - * @data: (closure): the @user_data supplied to - * gtk_clipboard_request_text(). - * - * A function to be called when the results of gtk_clipboard_request_text() - * are received, or when the request fails. - */ -typedef void (* GtkClipboardTextReceivedFunc) (GtkClipboard *clipboard, - const gchar *text, - gpointer data); - -/** - * GtkClipboardRichTextReceivedFunc: - * @clipboard: the #GtkClipboard - * @format: The format of the rich text - * @text: (nullable) (type utf8): the rich text received, as - * a UTF-8 encoded string, or %NULL if retrieving the data failed. - * @length: Length of the text. - * @data: (closure): the @user_data supplied to - * gtk_clipboard_request_rich_text(). - * - * A function to be called when the results of - * gtk_clipboard_request_rich_text() are received, or when the request - * fails. - * - * Since: 2.10 - */ -typedef void (* GtkClipboardRichTextReceivedFunc) (GtkClipboard *clipboard, - GdkAtom format, - const guint8 *text, - gsize length, - gpointer data); - -/** - * GtkClipboardImageReceivedFunc: - * @clipboard: the #GtkClipboard - * @pixbuf: the received image - * @data: (closure): the @user_data supplied to - * gtk_clipboard_request_image(). - * - * A function to be called when the results of gtk_clipboard_request_image() - * are received, or when the request fails. - * - * Since: 2.6 - */ -typedef void (* GtkClipboardImageReceivedFunc) (GtkClipboard *clipboard, - GdkPixbuf *pixbuf, - gpointer data); - -/** - * GtkClipboardURIReceivedFunc: - * @clipboard: the #GtkClipboard - * @uris: (array zero-terminated=1): the received URIs - * @data: (closure): the @user_data supplied to - * gtk_clipboard_request_uris(). - * - * A function to be called when the results of - * gtk_clipboard_request_uris() are received, or when the request - * fails. - * - * Since: 2.14 - */ -typedef void (* GtkClipboardURIReceivedFunc) (GtkClipboard *clipboard, - gchar **uris, - gpointer data); - -/** - * GtkClipboardTargetsReceivedFunc: - * @clipboard: the #GtkClipboard - * @atoms: (nullable) (array length=n_atoms): the supported targets, - * as array of #GdkAtom, or %NULL if retrieving the data failed. - * @n_atoms: the length of the @atoms array. - * @data: (closure): the @user_data supplied to - * gtk_clipboard_request_targets(). - * - * A function to be called when the results of gtk_clipboard_request_targets() - * are received, or when the request fails. - * - * Since: 2.4 - */ -typedef void (* GtkClipboardTargetsReceivedFunc) (GtkClipboard *clipboard, - GdkAtom *atoms, - gint n_atoms, - gpointer data); - -/* Should these functions have GtkClipboard *clipboard as the first argument? - * right now for ClearFunc, you may have trouble determining _which_ clipboard - * was cleared, if you reuse your ClearFunc for multiple clipboards. - */ -/** - * GtkClipboardGetFunc: - * @clipboard: the #GtkClipboard - * @selection_data: a #GtkSelectionData argument in which the requested - * data should be stored. - * @user_data_or_owner: the @user_data argument passed to - * gtk_clipboard_set_with_data(), or the @owner argument passed to - * gtk_clipboard_set_with_owner() - * - * A function that will be called to provide the contents of the selection. - * If multiple types of data were advertised, the requested type can - * be determined from the @info parameter or by checking the target field - * of @selection_data. If the data could successfully be converted into - * then it should be stored into the @selection_data object by - * calling gtk_selection_data_set() (or related functions such - * as gtk_selection_data_set_text()). If no data is set, the requestor - * will be informed that the attempt to get the data failed. - */ -typedef void (* GtkClipboardGetFunc) (GtkClipboard *clipboard, - GtkSelectionData *selection_data, - gpointer user_data_or_owner); - -/** - * GtkClipboardClearFunc: - * @clipboard: the #GtkClipboard - * @user_data_or_owner: the @user_data argument passed to gtk_clipboard_set_with_data(), - * or the @owner argument passed to gtk_clipboard_set_with_owner() - * - * A function that will be called when the contents of the clipboard are changed - * or cleared. Once this has called, the @user_data_or_owner argument - * will not be used again. - */ -typedef void (* GtkClipboardClearFunc) (GtkClipboard *clipboard, - gpointer user_data_or_owner); - -GDK_AVAILABLE_IN_ALL -GType gtk_clipboard_get_type (void) G_GNUC_CONST; - -GDK_AVAILABLE_IN_ALL -GtkClipboard *gtk_clipboard_get_for_display (GdkDisplay *display, - GdkAtom selection); -GDK_AVAILABLE_IN_ALL -GtkClipboard *gtk_clipboard_get (GdkAtom selection); - -GDK_AVAILABLE_IN_3_16 -GtkClipboard *gtk_clipboard_get_default (GdkDisplay *display); - -GDK_AVAILABLE_IN_ALL -GdkDisplay *gtk_clipboard_get_display (GtkClipboard *clipboard); - - -GDK_AVAILABLE_IN_ALL -gboolean gtk_clipboard_set_with_data (GtkClipboard *clipboard, - GdkContentFormats *formats, - GtkClipboardGetFunc get_func, - GtkClipboardClearFunc clear_func, - gpointer user_data); -GDK_AVAILABLE_IN_ALL -gboolean gtk_clipboard_set_with_owner (GtkClipboard *clipboard, - GdkContentFormats *formats, - GtkClipboardGetFunc get_func, - GtkClipboardClearFunc clear_func, - GObject *owner); -GDK_AVAILABLE_IN_ALL -GObject *gtk_clipboard_get_owner (GtkClipboard *clipboard); -GDK_AVAILABLE_IN_ALL -void gtk_clipboard_clear (GtkClipboard *clipboard); -GDK_AVAILABLE_IN_ALL -void gtk_clipboard_set_text (GtkClipboard *clipboard, - const gchar *text, - gint len); -GDK_AVAILABLE_IN_ALL -void gtk_clipboard_set_image (GtkClipboard *clipboard, - GdkPixbuf *pixbuf); -GDK_AVAILABLE_IN_3_94 -void gtk_clipboard_set_surface (GtkClipboard *clipboard, - cairo_surface_t *surface); - -GDK_AVAILABLE_IN_ALL -void gtk_clipboard_request_contents (GtkClipboard *clipboard, - GdkAtom target, - GtkClipboardReceivedFunc callback, - gpointer user_data); -GDK_AVAILABLE_IN_ALL -void gtk_clipboard_request_text (GtkClipboard *clipboard, - GtkClipboardTextReceivedFunc callback, - gpointer user_data); -GDK_AVAILABLE_IN_ALL -void gtk_clipboard_request_image (GtkClipboard *clipboard, - GtkClipboardImageReceivedFunc callback, - gpointer user_data); -GDK_AVAILABLE_IN_ALL -void gtk_clipboard_request_uris (GtkClipboard *clipboard, - GtkClipboardURIReceivedFunc callback, - gpointer user_data); -GDK_AVAILABLE_IN_ALL -void gtk_clipboard_request_targets (GtkClipboard *clipboard, - GtkClipboardTargetsReceivedFunc callback, - gpointer user_data); - -GDK_AVAILABLE_IN_ALL -GtkSelectionData *gtk_clipboard_wait_for_contents (GtkClipboard *clipboard, - GdkAtom target); -GDK_AVAILABLE_IN_ALL -gchar * gtk_clipboard_wait_for_text (GtkClipboard *clipboard); -GDK_AVAILABLE_IN_ALL -guint8 * gtk_clipboard_wait_for_rich_text (GtkClipboard *clipboard, - GtkTextBuffer *buffer, - GdkAtom *format, - gsize *length); -GDK_AVAILABLE_IN_ALL -GdkPixbuf * gtk_clipboard_wait_for_image (GtkClipboard *clipboard); -GDK_AVAILABLE_IN_ALL -gchar ** gtk_clipboard_wait_for_uris (GtkClipboard *clipboard); -GDK_AVAILABLE_IN_ALL -gboolean gtk_clipboard_wait_for_targets (GtkClipboard *clipboard, - GdkAtom **formats, - gint *n_formats); - -GDK_AVAILABLE_IN_3_94 -cairo_surface_t * gtk_clipboard_wait_for_surface (GtkClipboard *clipboard); -GDK_AVAILABLE_IN_ALL -gboolean gtk_clipboard_wait_is_text_available (GtkClipboard *clipboard); -GDK_AVAILABLE_IN_ALL -gboolean gtk_clipboard_wait_is_image_available (GtkClipboard *clipboard); -GDK_AVAILABLE_IN_ALL -gboolean gtk_clipboard_wait_is_uris_available (GtkClipboard *clipboard); -GDK_AVAILABLE_IN_ALL -gboolean gtk_clipboard_wait_is_target_available (GtkClipboard *clipboard, - GdkAtom target); - - -GDK_AVAILABLE_IN_ALL -void gtk_clipboard_set_can_store (GtkClipboard *clipboard, - GdkContentFormats *formats); - -GDK_AVAILABLE_IN_ALL -void gtk_clipboard_store (GtkClipboard *clipboard); - -GDK_AVAILABLE_IN_3_22 -GdkAtom gtk_clipboard_get_selection (GtkClipboard *clipboard); - -G_END_DECLS - -#endif /* __GTK_CLIPBOARD_H__ */ diff --git a/gtk/gtkclipboardprivate.h b/gtk/gtkclipboardprivate.h deleted file mode 100644 index c001866c96..0000000000 --- a/gtk/gtkclipboardprivate.h +++ /dev/null @@ -1,91 +0,0 @@ -/* GTK - The GIMP Toolkit - * Copyright (C) 2000 Red Hat, Inc. - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - * - * Global clipboard abstraction. - */ - -#ifndef __GTK_CLIPBOARD_PRIVATE_H__ -#define __GTK_CLIPBOARD_PRIVATE_H__ - -#include - -G_BEGIN_DECLS - -#define GTK_CLIPBOARD_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), GTK_TYPE_CLIPBOARD, GtkClipboardClass)) -#define GTK_IS_CLIPBOARD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), GTK_TYPE_CLIPBOARD)) -#define GTK_CLIPBOARD_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), GTK_TYPE_CLIPBOARD, GtkClipboardClass)) - -typedef struct _GtkClipboardClass GtkClipboardClass; - -struct _GtkClipboard -{ - GObject parent_instance; - - GdkAtom selection; - - GtkClipboardGetFunc get_func; - GtkClipboardClearFunc clear_func; - gpointer user_data; - gboolean have_owner; - - guint32 timestamp; - - gboolean have_selection; - GdkDisplay *display; - - GdkAtom *cached_formats; - gint n_cached_formats; - - gulong notify_signal_id; - gboolean storing_selection; - GMainLoop *store_loop; - guint store_timeout; - gint n_storable_formats; - GdkAtom *storable_formats; -}; - -struct _GtkClipboardClass -{ - GObjectClass parent_class; - - /* vfuncs */ - gboolean (* set_contents) (GtkClipboard *clipboard, - GdkContentFormats *formats, - GtkClipboardGetFunc get_func, - GtkClipboardClearFunc clear_func, - gpointer user_data, - gboolean have_owner); - void (* clear) (GtkClipboard *clipboard); - void (* request_contents) (GtkClipboard *clipboard, - GdkAtom target, - GtkClipboardReceivedFunc callback, - gpointer user_data); - void (* set_can_store) (GtkClipboard *clipboard, - GdkContentFormats *formats); - void (* store) (GtkClipboard *clipboard); - - /* signals */ - void (* owner_change) (GtkClipboard *clipboard, - GdkEventOwnerChange *event); -}; -void _gtk_clipboard_handle_event (GdkEventOwnerChange *event); - -void _gtk_clipboard_store_all (void); - - -G_END_DECLS - -#endif /* __GTK_CLIPBOARD_PRIVATE_H__ */ diff --git a/gtk/gtkmain.c b/gtk/gtkmain.c index d727cbec0d..5cff51e8cc 100644 --- a/gtk/gtkmain.c +++ b/gtk/gtkmain.c @@ -114,7 +114,6 @@ #include "gtkaccelmapprivate.h" #include "gtkbox.h" -#include "gtkclipboardprivate.h" #include "gtkdebug.h" #include "gtkdebugupdatesprivate.h" #include "gtkdndprivate.h" @@ -1071,9 +1070,6 @@ gtk_main_sync (void) g_main_loop_unref (store.store_loop); store.store_loop = NULL; - /* Try storing all clipboard data we have */ - _gtk_clipboard_store_all (); - /* Synchronize the recent manager singleton */ _gtk_recent_manager_sync (); } @@ -1689,10 +1685,7 @@ gtk_main_do_event (GdkEvent *event) GList *tmp_list; if (event->type == GDK_OWNER_CHANGE) - { - _gtk_clipboard_handle_event (&event->owner_change); - return; - } + return; /* Find the widget which got the event. We store the widget * in the user_data field of GdkWindow's. Ignore the event diff --git a/gtk/gtkwidget.c b/gtk/gtkwidget.c index 51b0864c39..9997d5115d 100644 --- a/gtk/gtkwidget.c +++ b/gtk/gtkwidget.c @@ -39,7 +39,6 @@ #include "gtkcontainer.h" #include "gtkaccelmapprivate.h" #include "gtkaccelgroupprivate.h" -#include "gtkclipboard.h" #include "gtkcssfiltervalueprivate.h" #include "gtkcssnumbervalueprivate.h" #include "gtkcssshadowsvalueprivate.h" @@ -12423,36 +12422,6 @@ gtk_widget_get_primary_clipboard (GtkWidget *widget) return gdk_display_get_primary_clipboard (gtk_widget_get_display (widget)); } -/** - * gtk_widget_get_old_clipboard: - * @widget: a #GtkWidget - * @selection: a #GdkAtom which identifies the clipboard - * to use. %GDK_SELECTION_CLIPBOARD gives the - * default clipboard. Another common value - * is %GDK_SELECTION_PRIMARY, which gives - * the primary X selection. - * - * Returns the clipboard object for the given selection to - * be used with @widget. @widget must have a #GdkDisplay - * associated with it, so must be attached to a toplevel - * window. - * - * Returns: (transfer none): the appropriate clipboard object. If no - * clipboard already exists, a new one will - * be created. Once a clipboard object has - * been created, it is persistent for all time. - * - * Since: 2.2 - **/ -GtkClipboard * -gtk_widget_get_old_clipboard (GtkWidget *widget, GdkAtom selection) -{ - g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL); - - return gtk_clipboard_get_for_display (gtk_widget_get_display (widget), - selection); -} - /** * gtk_widget_list_mnemonic_labels: * @widget: a #GtkWidget diff --git a/gtk/gtkwidget.h b/gtk/gtkwidget.h index edb7feac58..ac33083544 100644 --- a/gtk/gtkwidget.h +++ b/gtk/gtkwidget.h @@ -786,9 +786,6 @@ GDK_AVAILABLE_IN_3_94 GdkClipboard *gtk_widget_get_clipboard (GtkWidget *widget); GDK_AVAILABLE_IN_3_94 GdkClipboard *gtk_widget_get_primary_clipboard (GtkWidget *widget); -GDK_AVAILABLE_IN_ALL -GtkClipboard *gtk_widget_get_old_clipboard (GtkWidget *widget, - GdkAtom selection); /* Expand flags and related support */ diff --git a/gtk/meson.build b/gtk/meson.build index 5eb371fa1c..6c27dab9cc 100644 --- a/gtk/meson.build +++ b/gtk/meson.build @@ -413,7 +413,6 @@ gtk_public_headers = files([ 'gtkcellview.h', 'gtkcheckbutton.h', 'gtkcheckmenuitem.h', - 'gtkclipboard.h', 'gtkcolorbutton.h', 'gtkcolorchooser.h', 'gtkcolorchooserdialog.h', @@ -707,12 +706,10 @@ gtk_use_wayland_or_x11_c_sources = files([ if quartz_enabled dnd_sources = files([ - 'gtkclipboard-quartz.c', 'gtkdnd-quartz.c', ]) else dnd_sources = files([ - 'gtkclipboard.c', 'gtkdnd.c', 'gtkdragdest.c', ]) diff --git a/po-properties/POTFILES.in b/po-properties/POTFILES.in index 1c7313d507..907c1e097e 100644 --- a/po-properties/POTFILES.in +++ b/po-properties/POTFILES.in @@ -88,8 +88,6 @@ gtk/gtkcellview.c gtk/gtkcenterbox.c gtk/gtkcheckbutton.c gtk/gtkcheckmenuitem.c -gtk/gtkclipboard.c -gtk/gtkclipboard-quartz.c gtk/gtkcolorbutton.c gtk/gtkcolorchooser.c gtk/gtkcolorchooserdialog.c diff --git a/po/POTFILES.in b/po/POTFILES.in index 2ec85c99fd..0b5364dfac 100644 --- a/po/POTFILES.in +++ b/po/POTFILES.in @@ -88,8 +88,6 @@ gtk/gtkcellview.c gtk/gtkcenterbox.c gtk/gtkcheckbutton.c gtk/gtkcheckmenuitem.c -gtk/gtkclipboard.c -gtk/gtkclipboard-quartz.c gtk/gtkcolorbutton.c gtk/gtkcolorchooser.c gtk/gtkcolorchooserdialog.c diff --git a/tests/meson.build b/tests/meson.build index 69f871b748..5db73a6bde 100644 --- a/tests/meson.build +++ b/tests/meson.build @@ -25,7 +25,6 @@ gtk_tests = [ ['testbuttons'], ['testcairo'], ['testcalendar'], - ['testclipboard'], ['testclipboard2'], ['testcolorchooser'], ['testcolorchooser2'], diff --git a/tests/testclipboard.c b/tests/testclipboard.c deleted file mode 100644 index 80c5ac9474..0000000000 --- a/tests/testclipboard.c +++ /dev/null @@ -1,140 +0,0 @@ -/* - * Copyright (C) 2011 Red Hat, Inc. - * - * This library 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 library 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 library. If not, see . - */ - -#include - -GtkClipboard *clipboard; -GtkWidget *image; -GtkWidget *label; - -#define SIZE 256. - -static void -image_request_cb (GtkClipboard *clipboard, - GdkPixbuf *pixbuf, - gpointer data) -{ - GdkPixbuf *copy; - int height; - int width; - gdouble factor; - char *str; - - if (pixbuf != NULL) - { - height = gdk_pixbuf_get_height (pixbuf); - width = gdk_pixbuf_get_width (pixbuf); - - factor = MAX ((SIZE / height), (SIZE / width)); - - copy = gdk_pixbuf_scale_simple (pixbuf, width * factor, height * factor, GDK_INTERP_BILINEAR); - gtk_image_set_from_pixbuf (GTK_IMAGE (image), copy); - g_object_unref (copy); - str = g_strdup_printf ("Image %d \342\234\225 %d", width, height); - } - else - { - str = g_strdup ("No image data"); - } - gtk_label_set_markup (GTK_LABEL (label), str); - g_free (str); -} - -static void -update_display (void) -{ - gtk_clipboard_request_image (clipboard, image_request_cb, NULL); -} - -static void -on_owner_change (GtkClipboard *clipboard, - GdkEvent *event, - gpointer user_data) -{ - update_display (); -} - -static void -on_response (GtkDialog *dialog, - gint response_id, - gpointer user_data) -{ - switch (response_id) - { - case 0: - /* copy large */ - { - GtkIconTheme *theme; - GdkPixbuf *pixbuf; - theme = gtk_icon_theme_get_default (); - pixbuf = gtk_icon_theme_load_icon (theme, "utilities-terminal", 1600, 0, NULL); - g_assert_nonnull (pixbuf); - gtk_clipboard_set_image (clipboard, pixbuf); - } - break; - case 1: - /* copy small */ - { - GtkIconTheme *theme; - GdkPixbuf *pixbuf; - theme = gtk_icon_theme_get_default (); - pixbuf = gtk_icon_theme_load_icon (theme, "utilities-terminal", 48, 0, NULL); - g_assert_nonnull (pixbuf); - gtk_clipboard_set_image (clipboard, pixbuf); - } - break; - case GTK_RESPONSE_CLOSE: - default: - gtk_main_quit (); - break; - } -} - -int -main (int argc, char **argv) -{ - GtkWidget *window; - - gtk_init (); - - window = gtk_dialog_new_with_buttons ("Clipboard", - NULL, - 0, - "Copy Large", 0, - "Copy Small", 1, - "_Close", GTK_RESPONSE_CLOSE, - NULL); - - image = gtk_image_new (); - gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))), image); - label = gtk_label_new ("No data found"); - gtk_box_pack_start (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (window))), label); - - g_signal_connect (window, "response", G_CALLBACK (on_response), NULL); - - clipboard = gtk_clipboard_get_for_display (gtk_widget_get_display (window), - GDK_SELECTION_CLIPBOARD); - g_signal_connect (clipboard, "owner-change", G_CALLBACK (on_owner_change), NULL); - - update_display (); - - gtk_widget_show (window); - - gtk_main (); - - return 0; -} diff --git a/testsuite/gtk/clipboard.c b/testsuite/gtk/clipboard.c deleted file mode 100644 index 4f4d24058e..0000000000 --- a/testsuite/gtk/clipboard.c +++ /dev/null @@ -1,88 +0,0 @@ -/* GTK - The GIMP Toolkit - * Copyright (C) 2013 Benjamin Otte - * - * This library is free software; you can redistribute it and/or - * modify it under the terms of the GNU Lesser General Public - * License as published by the Free Software Foundation; either - * version 2 of the License, or (at your option) any later version. - * - * This library 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 - * Lesser General Public License for more details. - * - * You should have received a copy of the GNU Lesser General Public - * License along with this library. If not, see . - */ - -#include - -#include - -#define SOME_TEXT "Hello World" -#define TARGET_TEXT "UTF8_STRING" - -static void -test_text (void) -{ - GtkClipboard *clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (), GDK_SELECTION_CLIPBOARD); - char *text; - - gtk_clipboard_set_text (clipboard, SOME_TEXT, -1); - text = gtk_clipboard_wait_for_text (clipboard); - g_assert_cmpstr (text, ==, SOME_TEXT); - g_free (text); - - gtk_clipboard_set_text (clipboard, SOME_TEXT SOME_TEXT, strlen (SOME_TEXT)); - text = gtk_clipboard_wait_for_text (clipboard); - g_assert_cmpstr (text, ==, SOME_TEXT); - g_free (text); -} - -static void -test_with_data_get (GtkClipboard *clipboard, - GtkSelectionData *selection_data, - gpointer user_data_or_owner) -{ - gboolean success; - - success = gtk_selection_data_set_text (selection_data, SOME_TEXT, -1); - g_assert (success); -} - -static void -test_with_data_got (GtkClipboard *clipboard, - GtkSelectionData *selection_data, - gpointer data) -{ - guchar *text; - - text = gtk_selection_data_get_text (selection_data); - g_assert_cmpstr ((char*)text, ==, SOME_TEXT); - g_free (text); -} - -static void -test_with_data (void) -{ - GtkClipboard *clipboard = gtk_clipboard_get_for_display (gdk_display_get_default (), GDK_SELECTION_CLIPBOARD); - const char *entries[] = { TARGET_TEXT }; - GdkContentFormats *targets; - - targets = gdk_content_formats_new (entries, G_N_ELEMENTS(entries)); - gtk_clipboard_set_with_data (clipboard, targets, test_with_data_get, NULL, NULL); - gdk_content_formats_unref (targets); - gtk_clipboard_request_contents (clipboard, gdk_atom_intern (TARGET_TEXT, FALSE), test_with_data_got, NULL); -} - -int -main (int argc, - char *argv[]) -{ - gtk_test_init (&argc, &argv); - - g_test_add_func ("/clipboard/test_text", test_text); - g_test_add_func ("/clipboard/test_with_data", test_with_data); - - return g_test_run(); -} diff --git a/testsuite/gtk/meson.build b/testsuite/gtk/meson.build index bce3b4de92..c5b4ade9fa 100644 --- a/testsuite/gtk/meson.build +++ b/testsuite/gtk/meson.build @@ -16,7 +16,6 @@ tests = [ ['builderparser'], ['cellarea'], ['check-icon-names'], - ['clipboard'], ['cssprovider'], ['entry'], ['firefox-stylecontext'],