1 /* GTK - The GIMP Toolkit
2 * Copyright (C) 2000 Red Hat, Inc.
3 * Copyright (C) 2004 Nokia Corporation
4 * Copyright (C) 2006-2008 Imendio AB
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library. If not, see <http://www.gnu.org/licenses/>.
24 #import <Cocoa/Cocoa.h>
26 #include "gtkclipboard.h"
27 #include "gtkinvisible.h"
29 #include "gtkmarshalers.h"
31 #include "gtktextbuffer.h"
32 #include "gtkselectionprivate.h"
33 #include "gtkquartz.h"
34 #include "../gdk/quartz/gdkquartz.h"
41 @interface GtkClipboardOwner : NSObject {
42 GtkClipboard *clipboard;
44 gboolean setting_same_owner;
49 typedef struct _GtkClipboardClass GtkClipboardClass;
53 GObject parent_instance;
55 NSPasteboard *pasteboard;
56 GtkClipboardOwner *owner;
57 NSInteger change_count;
61 GtkClipboardGetFunc get_func;
62 GtkClipboardClearFunc clear_func;
65 GtkTargetList *target_list;
67 gboolean have_selection;
70 GdkAtom *cached_targets;
71 gint n_cached_targets;
73 guint notify_signal_id;
74 gboolean storing_selection;
75 GMainLoop *store_loop;
77 gint n_storable_targets;
78 GdkAtom *storable_targets;
81 struct _GtkClipboardClass
83 GObjectClass parent_class;
85 void (*owner_change) (GtkClipboard *clipboard,
86 GdkEventOwnerChange *event);
89 static void gtk_clipboard_class_init (GtkClipboardClass *class);
90 static void gtk_clipboard_finalize (GObject *object);
91 static void gtk_clipboard_owner_change (GtkClipboard *clipboard,
92 GdkEventOwnerChange *event);
94 static void clipboard_unset (GtkClipboard *clipboard);
95 static GtkClipboard *clipboard_peek (GdkDisplay *display,
97 gboolean only_if_exists);
99 @implementation GtkClipboardOwner
100 -(void)pasteboard:(NSPasteboard *)sender provideDataForType:(NSString *)type
102 GtkSelectionData selection_data;
105 if (!clipboard->target_list)
108 memset (&selection_data, 0, sizeof (GtkSelectionData));
110 selection_data.selection = clipboard->selection;
111 selection_data.target = _gtk_quartz_pasteboard_type_to_atom (type);
112 selection_data.display = gdk_display_get_default ();
113 selection_data.length = -1;
115 if (gtk_target_list_find (clipboard->target_list, selection_data.target, &info))
117 clipboard->get_func (clipboard, &selection_data,
119 clipboard->user_data);
121 if (selection_data.length >= 0)
122 _gtk_quartz_set_selection_data_for_pasteboard (clipboard->pasteboard,
125 g_free (selection_data.data);
129 /* pasteboardChangedOwner is not called immediately, and it's not called
130 * reliably. It is somehow documented in the apple api docs, but the docs
131 * suck and don't really give clear instructions. Therefore we track
132 * changeCount in several places below and clear the clipboard if it
135 - (void)pasteboardChangedOwner:(NSPasteboard *)sender
137 if (! setting_same_owner)
138 clipboard_unset (clipboard);
141 - (id)initWithClipboard:(GtkClipboard *)aClipboard
147 clipboard = aClipboard;
148 setting_same_owner = FALSE;
157 static const gchar clipboards_owned_key[] = "gtk-clipboards-owned";
158 static GQuark clipboards_owned_key_id = 0;
160 static GObjectClass *parent_class;
161 static guint clipboard_signals[LAST_SIGNAL] = { 0 };
164 gtk_clipboard_get_type (void)
166 static GType clipboard_type = 0;
170 const GTypeInfo clipboard_info =
172 sizeof (GtkClipboardClass),
173 NULL, /* base_init */
174 NULL, /* base_finalize */
175 (GClassInitFunc) gtk_clipboard_class_init,
176 NULL, /* class_finalize */
177 NULL, /* class_data */
178 sizeof (GtkClipboard),
180 (GInstanceInitFunc) NULL,
183 clipboard_type = g_type_register_static (G_TYPE_OBJECT, I_("GtkClipboard"),
187 return clipboard_type;
191 gtk_clipboard_class_init (GtkClipboardClass *class)
193 GObjectClass *gobject_class = G_OBJECT_CLASS (class);
195 parent_class = g_type_class_peek_parent (class);
197 gobject_class->finalize = gtk_clipboard_finalize;
199 class->owner_change = gtk_clipboard_owner_change;
201 clipboard_signals[OWNER_CHANGE] =
202 g_signal_new (I_("owner-change"),
203 G_TYPE_FROM_CLASS (gobject_class),
205 G_STRUCT_OFFSET (GtkClipboardClass, owner_change),
207 _gtk_marshal_VOID__BOXED,
209 GDK_TYPE_EVENT | G_SIGNAL_TYPE_STATIC_SCOPE);
213 gtk_clipboard_finalize (GObject *object)
215 GtkClipboard *clipboard;
218 clipboard = GTK_CLIPBOARD (object);
220 clipboards = g_object_get_data (G_OBJECT (clipboard->display), "gtk-clipboard-list");
221 if (g_slist_index (clipboards, clipboard) >= 0)
222 g_warning ("GtkClipboard prematurely finalized");
224 clipboard_unset (clipboard);
226 clipboards = g_object_get_data (G_OBJECT (clipboard->display), "gtk-clipboard-list");
227 clipboards = g_slist_remove (clipboards, clipboard);
228 g_object_set_data (G_OBJECT (clipboard->display), I_("gtk-clipboard-list"), clipboards);
230 if (clipboard->store_loop && g_main_loop_is_running (clipboard->store_loop))
231 g_main_loop_quit (clipboard->store_loop);
233 if (clipboard->store_timeout != 0)
234 g_source_remove (clipboard->store_timeout);
236 g_free (clipboard->storable_targets);
238 G_OBJECT_CLASS (parent_class)->finalize (object);
242 clipboard_display_closed (GdkDisplay *display,
244 GtkClipboard *clipboard)
248 clipboards = g_object_get_data (G_OBJECT (display), "gtk-clipboard-list");
249 g_object_run_dispose (G_OBJECT (clipboard));
250 clipboards = g_slist_remove (clipboards, clipboard);
251 g_object_set_data (G_OBJECT (display), I_("gtk-clipboard-list"), clipboards);
252 g_object_unref (clipboard);
256 gtk_clipboard_get_for_display (GdkDisplay *display,
259 g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
260 g_return_val_if_fail (!gdk_display_is_closed (display), NULL);
262 return clipboard_peek (display, selection, FALSE);
266 gtk_clipboard_get (GdkAtom selection)
268 return gtk_clipboard_get_for_display (gdk_display_get_default (), selection);
272 clipboard_owner_destroyed (gpointer data)
274 GSList *clipboards = data;
277 tmp_list = clipboards;
280 GtkClipboard *clipboard = tmp_list->data;
282 clipboard->get_func = NULL;
283 clipboard->clear_func = NULL;
284 clipboard->user_data = NULL;
285 clipboard->have_owner = FALSE;
287 if (clipboard->target_list)
289 gtk_target_list_unref (clipboard->target_list);
290 clipboard->target_list = NULL;
293 gtk_clipboard_clear (clipboard);
295 tmp_list = tmp_list->next;
298 g_slist_free (clipboards);
302 clipboard_add_owner_notify (GtkClipboard *clipboard)
304 if (!clipboards_owned_key_id)
305 clipboards_owned_key_id = g_quark_from_static_string (clipboards_owned_key);
307 if (clipboard->have_owner)
308 g_object_set_qdata_full (clipboard->user_data, clipboards_owned_key_id,
309 g_slist_prepend (g_object_steal_qdata (clipboard->user_data,
310 clipboards_owned_key_id),
312 clipboard_owner_destroyed);
316 clipboard_remove_owner_notify (GtkClipboard *clipboard)
318 if (clipboard->have_owner)
319 g_object_set_qdata_full (clipboard->user_data, clipboards_owned_key_id,
320 g_slist_remove (g_object_steal_qdata (clipboard->user_data,
321 clipboards_owned_key_id),
323 clipboard_owner_destroyed);
327 gtk_clipboard_set_contents (GtkClipboard *clipboard,
328 const GtkTargetEntry *targets,
330 GtkClipboardGetFunc get_func,
331 GtkClipboardClearFunc clear_func,
335 GtkClipboardOwner *owner;
337 NSAutoreleasePool *pool;
339 if (!(clipboard->have_owner && have_owner) ||
340 clipboard->user_data != user_data)
342 clipboard_unset (clipboard);
344 if (clipboard->get_func)
346 /* Calling unset() caused the clipboard contents to be reset!
347 * Avoid leaking and return
349 if (!(clipboard->have_owner && have_owner) ||
350 clipboard->user_data != user_data)
352 (*clear_func) (clipboard, user_data);
362 pool = [[NSAutoreleasePool alloc] init];
364 types = _gtk_quartz_target_entries_to_pasteboard_types (targets, n_targets);
366 /* call declareTypes before setting the clipboard members because
367 * declareTypes might clear the clipboard
369 if (user_data && user_data == clipboard->user_data)
371 owner = [clipboard->owner retain];
373 owner->setting_same_owner = TRUE;
374 clipboard->change_count = [clipboard->pasteboard declareTypes: [types allObjects]
376 owner->setting_same_owner = FALSE;
380 owner = [[GtkClipboardOwner alloc] initWithClipboard:clipboard];
382 clipboard->change_count = [clipboard->pasteboard declareTypes: [types allObjects]
390 clipboard->owner = owner;
391 clipboard->user_data = user_data;
392 clipboard->have_owner = have_owner;
394 clipboard_add_owner_notify (clipboard);
395 clipboard->get_func = get_func;
396 clipboard->clear_func = clear_func;
398 if (clipboard->target_list)
399 gtk_target_list_unref (clipboard->target_list);
400 clipboard->target_list = gtk_target_list_new (targets, n_targets);
406 gtk_clipboard_set_with_data (GtkClipboard *clipboard,
407 const GtkTargetEntry *targets,
409 GtkClipboardGetFunc get_func,
410 GtkClipboardClearFunc clear_func,
413 g_return_val_if_fail (clipboard != NULL, FALSE);
414 g_return_val_if_fail (targets != NULL, FALSE);
415 g_return_val_if_fail (get_func != NULL, FALSE);
417 return gtk_clipboard_set_contents (clipboard, targets, n_targets,
418 get_func, clear_func, user_data,
423 gtk_clipboard_set_with_owner (GtkClipboard *clipboard,
424 const GtkTargetEntry *targets,
426 GtkClipboardGetFunc get_func,
427 GtkClipboardClearFunc clear_func,
430 g_return_val_if_fail (clipboard != NULL, FALSE);
431 g_return_val_if_fail (targets != NULL, FALSE);
432 g_return_val_if_fail (get_func != NULL, FALSE);
433 g_return_val_if_fail (G_IS_OBJECT (owner), FALSE);
435 return gtk_clipboard_set_contents (clipboard, targets, n_targets,
436 get_func, clear_func, owner,
441 gtk_clipboard_get_owner (GtkClipboard *clipboard)
443 g_return_val_if_fail (clipboard != NULL, NULL);
445 if (clipboard->change_count < [clipboard->pasteboard changeCount])
447 clipboard_unset (clipboard);
448 clipboard->change_count = [clipboard->pasteboard changeCount];
451 if (clipboard->have_owner)
452 return clipboard->user_data;
458 clipboard_unset (GtkClipboard *clipboard)
460 GtkClipboardClearFunc old_clear_func;
462 gboolean old_have_owner;
463 gint old_n_storable_targets;
465 old_clear_func = clipboard->clear_func;
466 old_data = clipboard->user_data;
467 old_have_owner = clipboard->have_owner;
468 old_n_storable_targets = clipboard->n_storable_targets;
472 clipboard_remove_owner_notify (clipboard);
473 clipboard->have_owner = FALSE;
476 clipboard->n_storable_targets = -1;
477 g_free (clipboard->storable_targets);
478 clipboard->storable_targets = NULL;
480 clipboard->owner = NULL;
481 clipboard->get_func = NULL;
482 clipboard->clear_func = NULL;
483 clipboard->user_data = NULL;
486 old_clear_func (clipboard, old_data);
488 if (clipboard->target_list)
490 gtk_target_list_unref (clipboard->target_list);
491 clipboard->target_list = NULL;
494 /* If we've transferred the clipboard data to the manager,
497 if (old_have_owner &&
498 old_n_storable_targets != -1)
499 g_object_unref (old_data);
503 gtk_clipboard_clear (GtkClipboard *clipboard)
505 clipboard_unset (clipboard);
507 [clipboard->pasteboard declareTypes:nil owner:nil];
511 text_get_func (GtkClipboard *clipboard,
512 GtkSelectionData *selection_data,
516 gtk_selection_data_set_text (selection_data, data, -1);
520 text_clear_func (GtkClipboard *clipboard,
527 gtk_clipboard_set_text (GtkClipboard *clipboard,
531 GtkTargetEntry target = { "UTF8_STRING", 0, 0 };
533 g_return_if_fail (clipboard != NULL);
534 g_return_if_fail (text != NULL);
539 gtk_clipboard_set_with_data (clipboard,
541 text_get_func, text_clear_func,
542 g_strndup (text, len));
543 gtk_clipboard_set_can_store (clipboard, NULL, 0);
548 pixbuf_get_func (GtkClipboard *clipboard,
549 GtkSelectionData *selection_data,
553 gtk_selection_data_set_pixbuf (selection_data, data);
557 pixbuf_clear_func (GtkClipboard *clipboard,
560 g_object_unref (data);
564 gtk_clipboard_set_image (GtkClipboard *clipboard,
569 GtkTargetEntry *targets;
572 g_return_if_fail (clipboard != NULL);
573 g_return_if_fail (GDK_IS_PIXBUF (pixbuf));
575 list = gtk_target_list_new (NULL, 0);
576 gtk_target_list_add_image_targets (list, 0, TRUE);
578 n_targets = g_list_length (list->list);
579 targets = g_new0 (GtkTargetEntry, n_targets);
580 for (l = list->list, i = 0; l; l = l->next, i++)
582 GtkTargetPair *pair = (GtkTargetPair *)l->data;
583 targets[i].target = gdk_atom_name (pair->target);
586 gtk_clipboard_set_with_data (clipboard,
588 pixbuf_get_func, pixbuf_clear_func,
589 g_object_ref (pixbuf));
590 gtk_clipboard_set_can_store (clipboard, NULL, 0);
592 for (i = 0; i < n_targets; i++)
593 g_free (targets[i].target);
595 gtk_target_list_unref (list);
599 gtk_clipboard_request_contents (GtkClipboard *clipboard,
601 GtkClipboardReceivedFunc callback,
604 GtkSelectionData *data;
606 data = gtk_clipboard_wait_for_contents (clipboard, target);
608 callback (clipboard, data, user_data);
610 gtk_selection_data_free (data);
614 gtk_clipboard_request_text (GtkClipboard *clipboard,
615 GtkClipboardTextReceivedFunc callback,
618 gchar *data = gtk_clipboard_wait_for_text (clipboard);
620 callback (clipboard, data, user_data);
626 gtk_clipboard_request_rich_text (GtkClipboard *clipboard,
627 GtkTextBuffer *buffer,
628 GtkClipboardRichTextReceivedFunc callback,
631 /* FIXME: Implement */
636 gtk_clipboard_wait_for_rich_text (GtkClipboard *clipboard,
637 GtkTextBuffer *buffer,
641 /* FIXME: Implement */
646 gtk_clipboard_request_image (GtkClipboard *clipboard,
647 GtkClipboardImageReceivedFunc callback,
650 GdkPixbuf *pixbuf = gtk_clipboard_wait_for_image (clipboard);
652 callback (clipboard, pixbuf, user_data);
655 g_object_unref (pixbuf);
659 gtk_clipboard_request_uris (GtkClipboard *clipboard,
660 GtkClipboardURIReceivedFunc callback,
663 gchar **uris = gtk_clipboard_wait_for_uris (clipboard);
665 callback (clipboard, uris, user_data);
671 gtk_clipboard_request_targets (GtkClipboard *clipboard,
672 GtkClipboardTargetsReceivedFunc callback,
678 gtk_clipboard_wait_for_targets (clipboard, &targets, &n_targets);
680 callback (clipboard, targets, n_targets, user_data);
684 gtk_clipboard_wait_for_contents (GtkClipboard *clipboard,
687 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
688 GtkSelectionData *selection_data = NULL;
690 if (clipboard->change_count < [clipboard->pasteboard changeCount])
692 clipboard_unset (clipboard);
693 clipboard->change_count = [clipboard->pasteboard changeCount];
696 if (target == gdk_atom_intern_static_string ("TARGETS"))
698 NSArray *types = [clipboard->pasteboard types];
700 GList *atom_list, *l;
703 length = [types count] * sizeof (GdkAtom);
705 selection_data = g_slice_new0 (GtkSelectionData);
706 selection_data->selection = clipboard->selection;
707 selection_data->target = target;
709 atoms = g_malloc (length);
711 atom_list = _gtk_quartz_pasteboard_types_to_atom_list (types);
712 for (l = atom_list, i = 0; l ; l = l->next, i++)
713 atoms[i] = GDK_POINTER_TO_ATOM (l->data);
714 g_list_free (atom_list);
716 gtk_selection_data_set (selection_data,
717 GDK_SELECTION_TYPE_ATOM, 32,
718 (guchar *)atoms, length);
722 return selection_data;
725 selection_data = _gtk_quartz_get_selection_data_from_pasteboard (clipboard->pasteboard,
727 clipboard->selection);
731 return selection_data;
735 gtk_clipboard_wait_for_text (GtkClipboard *clipboard)
737 GtkSelectionData *data;
740 data = gtk_clipboard_wait_for_contents (clipboard,
741 gdk_atom_intern_static_string ("UTF8_STRING"));
743 result = (gchar *)gtk_selection_data_get_text (data);
745 gtk_selection_data_free (data);
751 gtk_clipboard_wait_for_image (GtkClipboard *clipboard)
753 const gchar *priority[] = { "image/png", "image/tiff", "image/jpeg", "image/gif", "image/bmp" };
755 GtkSelectionData *data;
757 for (i = 0; i < G_N_ELEMENTS (priority); i++)
759 data = gtk_clipboard_wait_for_contents (clipboard, gdk_atom_intern_static_string (priority[i]));
763 GdkPixbuf *pixbuf = gtk_selection_data_get_pixbuf (data);
765 gtk_selection_data_free (data);
775 gtk_clipboard_wait_for_uris (GtkClipboard *clipboard)
777 GtkSelectionData *data;
779 data = gtk_clipboard_wait_for_contents (clipboard, gdk_atom_intern_static_string ("text/uri-list"));
784 uris = gtk_selection_data_get_uris (data);
785 gtk_selection_data_free (data);
794 gtk_clipboard_get_display (GtkClipboard *clipboard)
796 g_return_val_if_fail (clipboard != NULL, NULL);
798 return clipboard->display;
802 gtk_clipboard_wait_is_text_available (GtkClipboard *clipboard)
804 GtkSelectionData *data;
805 gboolean result = FALSE;
807 data = gtk_clipboard_wait_for_contents (clipboard, gdk_atom_intern_static_string ("TARGETS"));
810 result = gtk_selection_data_targets_include_text (data);
811 gtk_selection_data_free (data);
818 gtk_clipboard_wait_is_rich_text_available (GtkClipboard *clipboard,
819 GtkTextBuffer *buffer)
821 GtkSelectionData *data;
822 gboolean result = FALSE;
824 g_return_val_if_fail (GTK_IS_CLIPBOARD (clipboard), FALSE);
825 g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
827 data = gtk_clipboard_wait_for_contents (clipboard, gdk_atom_intern_static_string ("TARGETS"));
830 result = gtk_selection_data_targets_include_rich_text (data, buffer);
831 gtk_selection_data_free (data);
838 gtk_clipboard_wait_is_image_available (GtkClipboard *clipboard)
840 GtkSelectionData *data;
841 gboolean result = FALSE;
843 data = gtk_clipboard_wait_for_contents (clipboard,
844 gdk_atom_intern_static_string ("TARGETS"));
847 result = gtk_selection_data_targets_include_image (data, FALSE);
848 gtk_selection_data_free (data);
855 gtk_clipboard_wait_is_uris_available (GtkClipboard *clipboard)
857 GtkSelectionData *data;
858 gboolean result = FALSE;
860 data = gtk_clipboard_wait_for_contents (clipboard,
861 gdk_atom_intern_static_string ("TARGETS"));
864 result = gtk_selection_data_targets_include_uri (data);
865 gtk_selection_data_free (data);
872 gtk_clipboard_wait_for_targets (GtkClipboard *clipboard,
876 GtkSelectionData *data;
877 gboolean result = FALSE;
879 g_return_val_if_fail (clipboard != NULL, FALSE);
881 /* If the display supports change notification we cache targets */
882 if (gdk_display_supports_selection_notification (gtk_clipboard_get_display (clipboard)) &&
883 clipboard->n_cached_targets != -1)
886 *n_targets = clipboard->n_cached_targets;
889 *targets = g_memdup (clipboard->cached_targets,
890 clipboard->n_cached_targets * sizeof (GdkAtom));
901 data = gtk_clipboard_wait_for_contents (clipboard, gdk_atom_intern_static_string ("TARGETS"));
905 GdkAtom *tmp_targets;
908 result = gtk_selection_data_get_targets (data, &tmp_targets, &tmp_n_targets);
910 if (gdk_display_supports_selection_notification (gtk_clipboard_get_display (clipboard)))
912 clipboard->n_cached_targets = tmp_n_targets;
913 clipboard->cached_targets = g_memdup (tmp_targets,
914 tmp_n_targets * sizeof (GdkAtom));
918 *n_targets = tmp_n_targets;
921 *targets = tmp_targets;
923 g_free (tmp_targets);
925 gtk_selection_data_free (data);
931 static GtkClipboard *
932 clipboard_peek (GdkDisplay *display,
934 gboolean only_if_exists)
936 GtkClipboard *clipboard = NULL;
940 if (selection == GDK_NONE)
941 selection = GDK_SELECTION_CLIPBOARD;
943 clipboards = g_object_get_data (G_OBJECT (display), "gtk-clipboard-list");
945 tmp_list = clipboards;
948 clipboard = tmp_list->data;
949 if (clipboard->selection == selection)
952 tmp_list = tmp_list->next;
955 if (!tmp_list && !only_if_exists)
957 NSAutoreleasePool *pool = [[NSAutoreleasePool alloc] init];
958 NSString *pasteboard_name;
959 clipboard = g_object_new (GTK_TYPE_CLIPBOARD, NULL);
961 if (selection == GDK_SELECTION_CLIPBOARD)
962 pasteboard_name = NSGeneralPboard;
965 char *atom_string = gdk_atom_name (selection);
967 pasteboard_name = [NSString stringWithFormat:@"_GTK_%@",
968 [NSString stringWithUTF8String:atom_string]];
969 g_free (atom_string);
972 clipboard->pasteboard = [NSPasteboard pasteboardWithName:pasteboard_name];
976 clipboard->selection = selection;
977 clipboard->display = display;
978 clipboard->n_cached_targets = -1;
979 clipboard->n_storable_targets = -1;
980 clipboards = g_slist_prepend (clipboards, clipboard);
981 g_object_set_data (G_OBJECT (display), I_("gtk-clipboard-list"), clipboards);
982 g_signal_connect (display, "closed",
983 G_CALLBACK (clipboard_display_closed), clipboard);
984 gdk_display_request_selection_notification (display, selection);
991 gtk_clipboard_owner_change (GtkClipboard *clipboard,
992 GdkEventOwnerChange *event)
994 if (clipboard->n_cached_targets != -1)
996 clipboard->n_cached_targets = -1;
997 g_free (clipboard->cached_targets);
1002 gtk_clipboard_wait_is_target_available (GtkClipboard *clipboard,
1007 gboolean retval = FALSE;
1009 if (!gtk_clipboard_wait_for_targets (clipboard, &targets, &n_targets))
1012 for (i = 0; i < n_targets; i++)
1014 if (targets[i] == target)
1027 _gtk_clipboard_handle_event (GdkEventOwnerChange *event)
1032 gtk_clipboard_set_can_store (GtkClipboard *clipboard,
1033 const GtkTargetEntry *targets,
1036 /* FIXME: Implement */
1040 gtk_clipboard_store (GtkClipboard *clipboard)
1042 /* FIXME: Implement */
1046 _gtk_clipboard_store_all (void)
1048 /* FIXME: Implement */