1 /*
2  * This file is part of gtkD.
3  *
4  * gtkD is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU Lesser General Public License
6  * as published by the Free Software Foundation; either version 3
7  * of the License, or (at your option) any later version, with
8  * some exceptions, please read the COPYING file.
9  *
10  * gtkD is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU Lesser General Public License for more details.
14  *
15  * You should have received a copy of the GNU Lesser General Public License
16  * along with gtkD; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110, USA
18  */
19 
20 // generated automatically - do not change
21 // find conversion definition on APILookup.txt
22 // implement new conversion functionalities on the wrap.utils pakage
23 
24 
25 module gtk.Clipboard;
26 
27 private import gdk.Display;
28 private import gdk.Event;
29 private import gdkpixbuf.Pixbuf;
30 private import glib.Str;
31 private import gobject.ObjectG;
32 private import gobject.Signals;
33 private import gtk.SelectionData;
34 private import gtk.TargetEntry;
35 private import gtk.TextBuffer;
36 public  import gtkc.gdktypes;
37 private import gtkc.gtk;
38 public  import gtkc.gtktypes;
39 
40 
41 /**
42  * The #GtkClipboard object represents a clipboard of data shared
43  * between different processes or between different widgets in
44  * the same process. Each clipboard is identified by a name encoded as a
45  * #GdkAtom. (Conversion to and from strings can be done with
46  * gdk_atom_intern() and gdk_atom_name().) The default clipboard
47  * corresponds to the “CLIPBOARD” atom; another commonly used clipboard
48  * is the “PRIMARY” clipboard, which, in X, traditionally contains
49  * the currently selected text.
50  * 
51  * To support having a number of different formats on the clipboard
52  * at the same time, the clipboard mechanism allows providing
53  * callbacks instead of the actual data.  When you set the contents
54  * of the clipboard, you can either supply the data directly (via
55  * functions like gtk_clipboard_set_text()), or you can supply a
56  * callback to be called at a later time when the data is needed (via
57  * gtk_clipboard_set_with_data() or gtk_clipboard_set_with_owner().)
58  * Providing a callback also avoids having to make copies of the data
59  * when it is not needed.
60  * 
61  * gtk_clipboard_set_with_data() and gtk_clipboard_set_with_owner()
62  * are quite similar; the choice between the two depends mostly on
63  * which is more convenient in a particular situation.
64  * The former is most useful when you want to have a blob of data
65  * with callbacks to convert it into the various data types that you
66  * advertise. When the @clear_func you provided is called, you
67  * simply free the data blob. The latter is more useful when the
68  * contents of clipboard reflect the internal state of a #GObject
69  * (As an example, for the PRIMARY clipboard, when an entry widget
70  * provides the clipboard’s contents the contents are simply the
71  * text within the selected region.) If the contents change, the
72  * entry widget can call gtk_clipboard_set_with_owner() to update
73  * the timestamp for clipboard ownership, without having to worry
74  * about @clear_func being called.
75  * 
76  * Requesting the data from the clipboard is essentially
77  * asynchronous. If the contents of the clipboard are provided within
78  * the same process, then a direct function call will be made to
79  * retrieve the data, but if they are provided by another process,
80  * then the data needs to be retrieved from the other process, which
81  * may take some time. To avoid blocking the user interface, the call
82  * to request the selection, gtk_clipboard_request_contents() takes a
83  * callback that will be called when the contents are received (or
84  * when the request fails.) If you don’t want to deal with providing
85  * a separate callback, you can also use gtk_clipboard_wait_for_contents().
86  * What this does is run the GLib main loop recursively waiting for
87  * the contents. This can simplify the code flow, but you still have
88  * to be aware that other callbacks in your program can be called
89  * while this recursive mainloop is running.
90  * 
91  * Along with the functions to get the clipboard contents as an
92  * arbitrary data chunk, there are also functions to retrieve
93  * it as text, gtk_clipboard_request_text() and
94  * gtk_clipboard_wait_for_text(). These functions take care of
95  * determining which formats are advertised by the clipboard
96  * provider, asking for the clipboard in the best available format
97  * and converting the results into the UTF-8 encoding. (The standard
98  * form for representing strings in GTK+.)
99  */
100 public class Clipboard : ObjectG
101 {
102 	/** the main Gtk struct */
103 	protected GtkClipboard* gtkClipboard;
104 
105 	/** Get the main Gtk struct */
106 	public GtkClipboard* getClipboardStruct()
107 	{
108 		return gtkClipboard;
109 	}
110 
111 	/** the main Gtk struct as a void* */
112 	protected override void* getStruct()
113 	{
114 		return cast(void*)gtkClipboard;
115 	}
116 
117 	protected override void setStruct(GObject* obj)
118 	{
119 		gtkClipboard = cast(GtkClipboard*)obj;
120 		super.setStruct(obj);
121 	}
122 
123 	/**
124 	 * Sets our main struct and passes it to the parent class.
125 	 */
126 	public this (GtkClipboard* gtkClipboard, bool ownedRef = false)
127 	{
128 		this.gtkClipboard = gtkClipboard;
129 		super(cast(GObject*)gtkClipboard, ownedRef);
130 	}
131 
132 
133 	/** */
134 	public static GType getType()
135 	{
136 		return gtk_clipboard_get_type();
137 	}
138 
139 	/**
140 	 * Returns the clipboard object for the given selection.
141 	 * See gtk_clipboard_get_for_display() for complete details.
142 	 *
143 	 * Params:
144 	 *     selection = a #GdkAtom which identifies the clipboard to use
145 	 *
146 	 * Return: the appropriate clipboard object. If no clipboard
147 	 *     already exists, a new one will be created. Once a clipboard
148 	 *     object has been created, it is persistent and, since it is
149 	 *     owned by GTK+, must not be freed or unreffed.
150 	 */
151 	public static Clipboard get(GdkAtom selection)
152 	{
153 		auto p = gtk_clipboard_get(selection);
154 		
155 		if(p is null)
156 		{
157 			return null;
158 		}
159 		
160 		return ObjectG.getDObject!(Clipboard)(cast(GtkClipboard*) p);
161 	}
162 
163 	/**
164 	 * Returns the default clipboard object for use with cut/copy/paste menu items
165 	 * and keyboard shortcuts.
166 	 *
167 	 * Params:
168 	 *     display = the #GdkDisplay for which the clipboard is to be retrieved.
169 	 *
170 	 * Return: the default clipboard object.
171 	 *
172 	 * Since: 3.16
173 	 */
174 	public static Clipboard getDefault(Display display)
175 	{
176 		auto p = gtk_clipboard_get_default((display is null) ? null : display.getDisplayStruct());
177 		
178 		if(p is null)
179 		{
180 			return null;
181 		}
182 		
183 		return ObjectG.getDObject!(Clipboard)(cast(GtkClipboard*) p);
184 	}
185 
186 	/**
187 	 * Returns the clipboard object for the given selection.
188 	 * Cut/copy/paste menu items and keyboard shortcuts should use
189 	 * the default clipboard, returned by passing %GDK_SELECTION_CLIPBOARD for @selection.
190 	 * (%GDK_NONE is supported as a synonym for GDK_SELECTION_CLIPBOARD
191 	 * for backwards compatibility reasons.)
192 	 * The currently-selected object or text should be provided on the clipboard
193 	 * identified by #GDK_SELECTION_PRIMARY. Cut/copy/paste menu items
194 	 * conceptually copy the contents of the #GDK_SELECTION_PRIMARY clipboard
195 	 * to the default clipboard, i.e. they copy the selection to what the
196 	 * user sees as the clipboard.
197 	 *
198 	 * (Passing #GDK_NONE is the same as using `gdk_atom_intern
199 	 * ("CLIPBOARD", FALSE)`.
200 	 *
201 	 * See the
202 	 * [FreeDesktop Clipboard Specification](http://www.freedesktop.org/Standards/clipboards-spec)
203 	 * for a detailed discussion of the “CLIPBOARD” vs. “PRIMARY”
204 	 * selections under the X window system. On Win32 the
205 	 * #GDK_SELECTION_PRIMARY clipboard is essentially ignored.)
206 	 *
207 	 * It’s possible to have arbitrary named clipboards; if you do invent
208 	 * new clipboards, you should prefix the selection name with an
209 	 * underscore (because the ICCCM requires that nonstandard atoms are
210 	 * underscore-prefixed), and namespace it as well. For example,
211 	 * if your application called “Foo” has a special-purpose
212 	 * clipboard, you might call it “_FOO_SPECIAL_CLIPBOARD”.
213 	 *
214 	 * Params:
215 	 *     display = the #GdkDisplay for which the clipboard is to be retrieved or created.
216 	 *     selection = a #GdkAtom which identifies the clipboard to use.
217 	 *
218 	 * Return: the appropriate clipboard object. If no
219 	 *     clipboard already exists, a new one will be created. Once a clipboard
220 	 *     object has been created, it is persistent and, since it is owned by
221 	 *     GTK+, must not be freed or unrefd.
222 	 *
223 	 * Since: 2.2
224 	 */
225 	public static Clipboard getForDisplay(Display display, GdkAtom selection)
226 	{
227 		auto p = gtk_clipboard_get_for_display((display is null) ? null : display.getDisplayStruct(), selection);
228 		
229 		if(p is null)
230 		{
231 			return null;
232 		}
233 		
234 		return ObjectG.getDObject!(Clipboard)(cast(GtkClipboard*) p);
235 	}
236 
237 	/**
238 	 * Clears the contents of the clipboard. Generally this should only
239 	 * be called between the time you call gtk_clipboard_set_with_owner()
240 	 * or gtk_clipboard_set_with_data(),
241 	 * and when the @clear_func you supplied is called. Otherwise, the
242 	 * clipboard may be owned by someone else.
243 	 */
244 	public void clear()
245 	{
246 		gtk_clipboard_clear(gtkClipboard);
247 	}
248 
249 	/**
250 	 * Gets the #GdkDisplay associated with @clipboard
251 	 *
252 	 * Return: the #GdkDisplay associated with @clipboard
253 	 *
254 	 * Since: 2.2
255 	 */
256 	public Display getDisplay()
257 	{
258 		auto p = gtk_clipboard_get_display(gtkClipboard);
259 		
260 		if(p is null)
261 		{
262 			return null;
263 		}
264 		
265 		return ObjectG.getDObject!(Display)(cast(GdkDisplay*) p);
266 	}
267 
268 	/**
269 	 * If the clipboard contents callbacks were set with
270 	 * gtk_clipboard_set_with_owner(), and the gtk_clipboard_set_with_data() or
271 	 * gtk_clipboard_clear() has not subsequently called, returns the owner set
272 	 * by gtk_clipboard_set_with_owner().
273 	 *
274 	 * Return: the owner of the clipboard, if any;
275 	 *     otherwise %NULL.
276 	 */
277 	public ObjectG getOwner()
278 	{
279 		auto p = gtk_clipboard_get_owner(gtkClipboard);
280 		
281 		if(p is null)
282 		{
283 			return null;
284 		}
285 		
286 		return ObjectG.getDObject!(ObjectG)(cast(GObject*) p);
287 	}
288 
289 	/**
290 	 * Requests the contents of clipboard as the given target.
291 	 * When the results of the result are later received the supplied callback
292 	 * will be called.
293 	 *
294 	 * Params:
295 	 *     target = an atom representing the form into which the clipboard
296 	 *         owner should convert the selection.
297 	 *     callback = A function to call when the results are received
298 	 *         (or the retrieval fails). If the retrieval fails the length field of
299 	 *         @selection_data will be negative.
300 	 *     userData = user data to pass to @callback
301 	 */
302 	public void requestContents(GdkAtom target, GtkClipboardReceivedFunc callback, void* userData)
303 	{
304 		gtk_clipboard_request_contents(gtkClipboard, target, callback, userData);
305 	}
306 
307 	/**
308 	 * Requests the contents of the clipboard as image. When the image is
309 	 * later received, it will be converted to a #GdkPixbuf, and
310 	 * @callback will be called.
311 	 *
312 	 * The @pixbuf parameter to @callback will contain the resulting
313 	 * #GdkPixbuf if the request succeeded, or %NULL if it failed. This
314 	 * could happen for various reasons, in particular if the clipboard
315 	 * was empty or if the contents of the clipboard could not be
316 	 * converted into an image.
317 	 *
318 	 * Params:
319 	 *     callback = a function to call when the image is received,
320 	 *         or the retrieval fails. (It will always be called one way or the other.)
321 	 *     userData = user data to pass to @callback.
322 	 *
323 	 * Since: 2.6
324 	 */
325 	public void requestImage(GtkClipboardImageReceivedFunc callback, void* userData)
326 	{
327 		gtk_clipboard_request_image(gtkClipboard, callback, userData);
328 	}
329 
330 	/**
331 	 * Requests the contents of the clipboard as rich text. When the rich
332 	 * text is later received, @callback will be called.
333 	 *
334 	 * The @text parameter to @callback will contain the resulting rich
335 	 * text if the request succeeded, or %NULL if it failed. The @length
336 	 * parameter will contain @text’s length. This function can fail for
337 	 * various reasons, in particular if the clipboard was empty or if the
338 	 * contents of the clipboard could not be converted into rich text form.
339 	 *
340 	 * Params:
341 	 *     buffer = a #GtkTextBuffer
342 	 *     callback = a function to call when the text is received,
343 	 *         or the retrieval fails. (It will always be called one way or the other.)
344 	 *     userData = user data to pass to @callback.
345 	 *
346 	 * Since: 2.10
347 	 */
348 	public void requestRichText(TextBuffer buffer, GtkClipboardRichTextReceivedFunc callback, void* userData)
349 	{
350 		gtk_clipboard_request_rich_text(gtkClipboard, (buffer is null) ? null : buffer.getTextBufferStruct(), callback, userData);
351 	}
352 
353 	/**
354 	 * Requests the contents of the clipboard as list of supported targets.
355 	 * When the list is later received, @callback will be called.
356 	 *
357 	 * The @targets parameter to @callback will contain the resulting targets if
358 	 * the request succeeded, or %NULL if it failed.
359 	 *
360 	 * Params:
361 	 *     callback = a function to call when the targets are
362 	 *         received, or the retrieval fails. (It will always be called
363 	 *         one way or the other.)
364 	 *     userData = user data to pass to @callback.
365 	 *
366 	 * Since: 2.4
367 	 */
368 	public void requestTargets(GtkClipboardTargetsReceivedFunc callback, void* userData)
369 	{
370 		gtk_clipboard_request_targets(gtkClipboard, callback, userData);
371 	}
372 
373 	/**
374 	 * Requests the contents of the clipboard as text. When the text is
375 	 * later received, it will be converted to UTF-8 if necessary, and
376 	 * @callback will be called.
377 	 *
378 	 * The @text parameter to @callback will contain the resulting text if
379 	 * the request succeeded, or %NULL if it failed. This could happen for
380 	 * various reasons, in particular if the clipboard was empty or if the
381 	 * contents of the clipboard could not be converted into text form.
382 	 *
383 	 * Params:
384 	 *     callback = a function to call when the text is received,
385 	 *         or the retrieval fails. (It will always be called one way or the other.)
386 	 *     userData = user data to pass to @callback.
387 	 */
388 	public void requestText(GtkClipboardTextReceivedFunc callback, void* userData)
389 	{
390 		gtk_clipboard_request_text(gtkClipboard, callback, userData);
391 	}
392 
393 	/**
394 	 * Requests the contents of the clipboard as URIs. When the URIs are
395 	 * later received @callback will be called.
396 	 *
397 	 * The @uris parameter to @callback will contain the resulting array of
398 	 * URIs if the request succeeded, or %NULL if it failed. This could happen
399 	 * for various reasons, in particular if the clipboard was empty or if the
400 	 * contents of the clipboard could not be converted into URI form.
401 	 *
402 	 * Params:
403 	 *     callback = a function to call when the URIs are received,
404 	 *         or the retrieval fails. (It will always be called one way or the other.)
405 	 *     userData = user data to pass to @callback.
406 	 *
407 	 * Since: 2.14
408 	 */
409 	public void requestUris(GtkClipboardURIReceivedFunc callback, void* userData)
410 	{
411 		gtk_clipboard_request_uris(gtkClipboard, callback, userData);
412 	}
413 
414 	/**
415 	 * Hints that the clipboard data should be stored somewhere when the
416 	 * application exits or when gtk_clipboard_store () is called.
417 	 *
418 	 * This value is reset when the clipboard owner changes.
419 	 * Where the clipboard data is stored is platform dependent,
420 	 * see gdk_display_store_clipboard () for more information.
421 	 *
422 	 * Params:
423 	 *     targets = array containing
424 	 *         information about which forms should be stored or %NULL
425 	 *         to indicate that all forms should be stored.
426 	 *     nTargets = number of elements in @targets
427 	 *
428 	 * Since: 2.6
429 	 */
430 	public void setCanStore(TargetEntry[] targets)
431 	{
432 		GtkTargetEntry[] targetsArray = new GtkTargetEntry[targets.length];
433 		for ( int i = 0; i < targets.length; i++ )
434 		{
435 			targetsArray[i] = *(targets[i].getTargetEntryStruct());
436 		}
437 		
438 		gtk_clipboard_set_can_store(gtkClipboard, targetsArray.ptr, cast(int)targets.length);
439 	}
440 
441 	/**
442 	 * Sets the contents of the clipboard to the given #GdkPixbuf.
443 	 * GTK+ will take responsibility for responding for requests
444 	 * for the image, and for converting the image into the
445 	 * requested format.
446 	 *
447 	 * Params:
448 	 *     pixbuf = a #GdkPixbuf
449 	 *
450 	 * Since: 2.6
451 	 */
452 	public void setImage(Pixbuf pixbuf)
453 	{
454 		gtk_clipboard_set_image(gtkClipboard, (pixbuf is null) ? null : pixbuf.getPixbufStruct());
455 	}
456 
457 	/**
458 	 * Sets the contents of the clipboard to the given UTF-8 string. GTK+ will
459 	 * make a copy of the text and take responsibility for responding
460 	 * for requests for the text, and for converting the text into
461 	 * the requested format.
462 	 *
463 	 * Params:
464 	 *     text = a UTF-8 string.
465 	 *     len = length of @text, in bytes, or -1, in which case
466 	 *         the length will be determined with strlen().
467 	 */
468 	public void setText(string text, int len)
469 	{
470 		gtk_clipboard_set_text(gtkClipboard, Str.toStringz(text), len);
471 	}
472 
473 	/**
474 	 * Virtually sets the contents of the specified clipboard by providing
475 	 * a list of supported formats for the clipboard data and a function
476 	 * to call to get the actual data when it is requested.
477 	 *
478 	 * Params:
479 	 *     targets = array containing information
480 	 *         about the available forms for the clipboard data
481 	 *     nTargets = number of elements in @targets
482 	 *     getFunc = function to call to get the actual clipboard data
483 	 *     clearFunc = when the clipboard contents are set again,
484 	 *         this function will be called, and @get_func will not be subsequently
485 	 *         called.
486 	 *     userData = user data to pass to @get_func and @clear_func.
487 	 *
488 	 * Return: %TRUE if setting the clipboard data succeeded.
489 	 *     If setting the clipboard data failed the provided callback
490 	 *     functions will be ignored.
491 	 */
492 	public bool setWithData(TargetEntry[] targets, GtkClipboardGetFunc getFunc, GtkClipboardClearFunc clearFunc, void* userData)
493 	{
494 		GtkTargetEntry[] targetsArray = new GtkTargetEntry[targets.length];
495 		for ( int i = 0; i < targets.length; i++ )
496 		{
497 			targetsArray[i] = *(targets[i].getTargetEntryStruct());
498 		}
499 		
500 		return gtk_clipboard_set_with_data(gtkClipboard, targetsArray.ptr, cast(uint)targets.length, getFunc, clearFunc, userData) != 0;
501 	}
502 
503 	/**
504 	 * Virtually sets the contents of the specified clipboard by providing
505 	 * a list of supported formats for the clipboard data and a function
506 	 * to call to get the actual data when it is requested.
507 	 *
508 	 * The difference between this function and gtk_clipboard_set_with_data()
509 	 * is that instead of an generic @user_data pointer, a #GObject is passed
510 	 * in.
511 	 *
512 	 * Params:
513 	 *     targets = array containing information
514 	 *         about the available forms for the clipboard data
515 	 *     nTargets = number of elements in @targets
516 	 *     getFunc = function to call to get the actual clipboard data
517 	 *     clearFunc = when the clipboard contents are set again,
518 	 *         this function will be called, and @get_func will not be subsequently
519 	 *         called
520 	 *     owner = an object that “owns” the data. This object will be passed
521 	 *         to the callbacks when called
522 	 *
523 	 * Return: %TRUE if setting the clipboard data succeeded.
524 	 *     If setting the clipboard data failed the provided callback
525 	 *     functions will be ignored.
526 	 */
527 	public bool setWithOwner(TargetEntry[] targets, GtkClipboardGetFunc getFunc, GtkClipboardClearFunc clearFunc, ObjectG owner)
528 	{
529 		GtkTargetEntry[] targetsArray = new GtkTargetEntry[targets.length];
530 		for ( int i = 0; i < targets.length; i++ )
531 		{
532 			targetsArray[i] = *(targets[i].getTargetEntryStruct());
533 		}
534 		
535 		return gtk_clipboard_set_with_owner(gtkClipboard, targetsArray.ptr, cast(uint)targets.length, getFunc, clearFunc, (owner is null) ? null : owner.getObjectGStruct()) != 0;
536 	}
537 
538 	/**
539 	 * Stores the current clipboard data somewhere so that it will stay
540 	 * around after the application has quit.
541 	 *
542 	 * Since: 2.6
543 	 */
544 	public void store()
545 	{
546 		gtk_clipboard_store(gtkClipboard);
547 	}
548 
549 	/**
550 	 * Requests the contents of the clipboard using the given target.
551 	 * This function waits for the data to be received using the main
552 	 * loop, so events, timeouts, etc, may be dispatched during the wait.
553 	 *
554 	 * Params:
555 	 *     target = an atom representing the form into which the clipboard
556 	 *         owner should convert the selection.
557 	 *
558 	 * Return: a newly-allocated #GtkSelectionData object or %NULL
559 	 *     if retrieving the given target failed. If non-%NULL,
560 	 *     this value must be freed with gtk_selection_data_free()
561 	 *     when you are finished with it.
562 	 */
563 	public SelectionData waitForContents(GdkAtom target)
564 	{
565 		auto p = gtk_clipboard_wait_for_contents(gtkClipboard, target);
566 		
567 		if(p is null)
568 		{
569 			return null;
570 		}
571 		
572 		return ObjectG.getDObject!(SelectionData)(cast(GtkSelectionData*) p, true);
573 	}
574 
575 	/**
576 	 * Requests the contents of the clipboard as image and converts
577 	 * the result to a #GdkPixbuf. This function waits for
578 	 * the data to be received using the main loop, so events,
579 	 * timeouts, etc, may be dispatched during the wait.
580 	 *
581 	 * Return: a newly-allocated #GdkPixbuf
582 	 *     object which must be disposed with g_object_unref(), or
583 	 *     %NULL if retrieving the selection data failed. (This could
584 	 *     happen for various reasons, in particular if the clipboard
585 	 *     was empty or if the contents of the clipboard could not be
586 	 *     converted into an image.)
587 	 *
588 	 * Since: 2.6
589 	 */
590 	public Pixbuf waitForImage()
591 	{
592 		auto p = gtk_clipboard_wait_for_image(gtkClipboard);
593 		
594 		if(p is null)
595 		{
596 			return null;
597 		}
598 		
599 		return ObjectG.getDObject!(Pixbuf)(cast(GdkPixbuf*) p, true);
600 	}
601 
602 	/**
603 	 * Requests the contents of the clipboard as rich text.  This function
604 	 * waits for the data to be received using the main loop, so events,
605 	 * timeouts, etc, may be dispatched during the wait.
606 	 *
607 	 * Params:
608 	 *     buffer = a #GtkTextBuffer
609 	 *     format = return location for the format of the returned data
610 	 *
611 	 * Return: a
612 	 *     newly-allocated binary block of data which must be
613 	 *     freed with g_free(), or %NULL if retrieving the
614 	 *     selection data failed. (This could happen for various
615 	 *     reasons, in particular if the clipboard was empty or
616 	 *     if the contents of the clipboard could not be
617 	 *     converted into text form.)
618 	 *
619 	 * Since: 2.10
620 	 */
621 	public ubyte[] waitForRichText(TextBuffer buffer, out GdkAtom format)
622 	{
623 		size_t length;
624 		
625 		auto p = gtk_clipboard_wait_for_rich_text(gtkClipboard, (buffer is null) ? null : buffer.getTextBufferStruct(), &format, &length);
626 		
627 		return p[0 .. length];
628 	}
629 
630 	/**
631 	 * Returns a list of targets that are present on the clipboard, or %NULL
632 	 * if there aren’t any targets available. The returned list must be
633 	 * freed with g_free().
634 	 * This function waits for the data to be received using the main
635 	 * loop, so events, timeouts, etc, may be dispatched during the wait.
636 	 *
637 	 * Params:
638 	 *     targets = location
639 	 *         to store an array of targets. The result stored here must
640 	 *         be freed with g_free().
641 	 *     nTargets = location to store number of items in @targets.
642 	 *
643 	 * Return: %TRUE if any targets are present on the clipboard,
644 	 *     otherwise %FALSE.
645 	 *
646 	 * Since: 2.4
647 	 */
648 	public bool waitForTargets(out GdkAtom[] targets)
649 	{
650 		GdkAtom* outtargets = null;
651 		int nTargets;
652 		
653 		auto p = gtk_clipboard_wait_for_targets(gtkClipboard, &outtargets, &nTargets) != 0;
654 		
655 		targets = outtargets[0 .. nTargets];
656 		
657 		return p;
658 	}
659 
660 	/**
661 	 * Requests the contents of the clipboard as text and converts
662 	 * the result to UTF-8 if necessary. This function waits for
663 	 * the data to be received using the main loop, so events,
664 	 * timeouts, etc, may be dispatched during the wait.
665 	 *
666 	 * Return: a newly-allocated UTF-8 string which must
667 	 *     be freed with g_free(), or %NULL if retrieving
668 	 *     the selection data failed. (This could happen
669 	 *     for various reasons, in particular if the
670 	 *     clipboard was empty or if the contents of the
671 	 *     clipboard could not be converted into text form.)
672 	 */
673 	public string waitForText()
674 	{
675 		auto retStr = gtk_clipboard_wait_for_text(gtkClipboard);
676 		
677 		scope(exit) Str.freeString(retStr);
678 		return Str.toString(retStr);
679 	}
680 
681 	/**
682 	 * Requests the contents of the clipboard as URIs. This function waits
683 	 * for the data to be received using the main loop, so events,
684 	 * timeouts, etc, may be dispatched during the wait.
685 	 *
686 	 * Return: a newly-allocated %NULL-terminated array of strings which must
687 	 *     be freed with g_strfreev(), or %NULL if retrieving the
688 	 *     selection data failed. (This could happen for various reasons,
689 	 *     in particular if the clipboard was empty or if the contents of
690 	 *     the clipboard could not be converted into URI form.)
691 	 *
692 	 * Since: 2.14
693 	 */
694 	public string[] waitForUris()
695 	{
696 		auto retStr = gtk_clipboard_wait_for_uris(gtkClipboard);
697 		
698 		scope(exit) Str.freeStringArray(retStr);
699 		return Str.toStringArray(retStr);
700 	}
701 
702 	/**
703 	 * Test to see if there is an image available to be pasted
704 	 * This is done by requesting the TARGETS atom and checking
705 	 * if it contains any of the supported image targets. This function
706 	 * waits for the data to be received using the main loop, so events,
707 	 * timeouts, etc, may be dispatched during the wait.
708 	 *
709 	 * This function is a little faster than calling
710 	 * gtk_clipboard_wait_for_image() since it doesn’t need to retrieve
711 	 * the actual image data.
712 	 *
713 	 * Return: %TRUE is there is an image available, %FALSE otherwise.
714 	 *
715 	 * Since: 2.6
716 	 */
717 	public bool waitIsImageAvailable()
718 	{
719 		return gtk_clipboard_wait_is_image_available(gtkClipboard) != 0;
720 	}
721 
722 	/**
723 	 * Test to see if there is rich text available to be pasted
724 	 * This is done by requesting the TARGETS atom and checking
725 	 * if it contains any of the supported rich text targets. This function
726 	 * waits for the data to be received using the main loop, so events,
727 	 * timeouts, etc, may be dispatched during the wait.
728 	 *
729 	 * This function is a little faster than calling
730 	 * gtk_clipboard_wait_for_rich_text() since it doesn’t need to retrieve
731 	 * the actual text.
732 	 *
733 	 * Params:
734 	 *     buffer = a #GtkTextBuffer
735 	 *
736 	 * Return: %TRUE is there is rich text available, %FALSE otherwise.
737 	 *
738 	 * Since: 2.10
739 	 */
740 	public bool waitIsRichTextAvailable(TextBuffer buffer)
741 	{
742 		return gtk_clipboard_wait_is_rich_text_available(gtkClipboard, (buffer is null) ? null : buffer.getTextBufferStruct()) != 0;
743 	}
744 
745 	/**
746 	 * Checks if a clipboard supports pasting data of a given type. This
747 	 * function can be used to determine if a “Paste” menu item should be
748 	 * insensitive or not.
749 	 *
750 	 * If you want to see if there’s text available on the clipboard, use
751 	 * gtk_clipboard_wait_is_text_available () instead.
752 	 *
753 	 * Params:
754 	 *     target = A #GdkAtom indicating which target to look for.
755 	 *
756 	 * Return: %TRUE if the target is available, %FALSE otherwise.
757 	 *
758 	 * Since: 2.6
759 	 */
760 	public bool waitIsTargetAvailable(GdkAtom target)
761 	{
762 		return gtk_clipboard_wait_is_target_available(gtkClipboard, target) != 0;
763 	}
764 
765 	/**
766 	 * Test to see if there is text available to be pasted
767 	 * This is done by requesting the TARGETS atom and checking
768 	 * if it contains any of the supported text targets. This function
769 	 * waits for the data to be received using the main loop, so events,
770 	 * timeouts, etc, may be dispatched during the wait.
771 	 *
772 	 * This function is a little faster than calling
773 	 * gtk_clipboard_wait_for_text() since it doesn’t need to retrieve
774 	 * the actual text.
775 	 *
776 	 * Return: %TRUE is there is text available, %FALSE otherwise.
777 	 */
778 	public bool waitIsTextAvailable()
779 	{
780 		return gtk_clipboard_wait_is_text_available(gtkClipboard) != 0;
781 	}
782 
783 	/**
784 	 * Test to see if there is a list of URIs available to be pasted
785 	 * This is done by requesting the TARGETS atom and checking
786 	 * if it contains the URI targets. This function
787 	 * waits for the data to be received using the main loop, so events,
788 	 * timeouts, etc, may be dispatched during the wait.
789 	 *
790 	 * This function is a little faster than calling
791 	 * gtk_clipboard_wait_for_uris() since it doesn’t need to retrieve
792 	 * the actual URI data.
793 	 *
794 	 * Return: %TRUE is there is an URI list available, %FALSE otherwise.
795 	 *
796 	 * Since: 2.14
797 	 */
798 	public bool waitIsUrisAvailable()
799 	{
800 		return gtk_clipboard_wait_is_uris_available(gtkClipboard) != 0;
801 	}
802 
803 	int[string] connectedSignals;
804 
805 	void delegate(GdkEventOwnerChange*, Clipboard)[] onOwnerChangeListeners;
806 	/**
807 	 * The ::owner-change signal is emitted when GTK+ receives an
808 	 * event that indicates that the ownership of the selection
809 	 * associated with @clipboard has changed.
810 	 *
811 	 * Params:
812 	 *     event = the @GdkEventOwnerChange event
813 	 *
814 	 * Since: 2.6
815 	 */
816 	void addOnOwnerChange(void delegate(GdkEventOwnerChange*, Clipboard) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
817 	{
818 		if ( "owner-change" !in connectedSignals )
819 		{
820 			Signals.connectData(
821 				this,
822 				"owner-change",
823 				cast(GCallback)&callBackOwnerChange,
824 				cast(void*)this,
825 				null,
826 				connectFlags);
827 			connectedSignals["owner-change"] = 1;
828 		}
829 		onOwnerChangeListeners ~= dlg;
830 	}
831 	extern(C) static void callBackOwnerChange(GtkClipboard* clipboardStruct, GdkEventOwnerChange* event, Clipboard _clipboard)
832 	{
833 		foreach ( void delegate(GdkEventOwnerChange*, Clipboard) dlg; _clipboard.onOwnerChangeListeners )
834 		{
835 			dlg(event, _clipboard);
836 		}
837 	}
838 
839 	void delegate(Event, Clipboard)[] onOwnerChangeGenericListeners;
840 	/**
841 	 * The ::owner-change signal is emitted when GTK+ receives an
842 	 * event that indicates that the ownership of the selection
843 	 * associated with @clipboard has changed.
844 	 *
845 	 * Params:
846 	 *     event = the @GdkEventOwnerChange event
847 	 *
848 	 * Since: 2.6
849 	 */
850 	void addOnOwnerChange(void delegate(Event, Clipboard) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0)
851 	{
852 		if ( "owner-change-generic-event" !in connectedSignals )
853 		{
854 			Signals.connectData(
855 				this,
856 				"owner-change",
857 				cast(GCallback)&callBackOwnerChangeGeneric,
858 				cast(void*)this,
859 				null,
860 				connectFlags);
861 			connectedSignals["owner-change-generic-event"] = 1;
862 		}
863 		onOwnerChangeGenericListeners ~= dlg;
864 	}
865 	extern(C) static void callBackOwnerChangeGeneric(GtkClipboard* clipboardStruct, GdkEvent* event, Clipboard _clipboard)
866 	{
867 		foreach ( void delegate(Event, Clipboard) dlg; _clipboard.onOwnerChangeGenericListeners )
868 		{
869 			dlg(ObjectG.getDObject!(Event)(event), _clipboard);
870 		}
871 	}
872 }