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); 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 return Str.toString(gtk_clipboard_wait_for_text(gtkClipboard)); 676 } 677 678 /** 679 * Requests the contents of the clipboard as URIs. This function waits 680 * for the data to be received using the main loop, so events, 681 * timeouts, etc, may be dispatched during the wait. 682 * 683 * Return: a newly-allocated %NULL-terminated array of strings which must 684 * be freed with g_strfreev(), or %NULL if retrieving the 685 * selection data failed. (This could happen for various reasons, 686 * in particular if the clipboard was empty or if the contents of 687 * the clipboard could not be converted into URI form.) 688 * 689 * Since: 2.14 690 */ 691 public string[] waitForUris() 692 { 693 return Str.toStringArray(gtk_clipboard_wait_for_uris(gtkClipboard)); 694 } 695 696 /** 697 * Test to see if there is an image available to be pasted 698 * This is done by requesting the TARGETS atom and checking 699 * if it contains any of the supported image targets. This function 700 * waits for the data to be received using the main loop, so events, 701 * timeouts, etc, may be dispatched during the wait. 702 * 703 * This function is a little faster than calling 704 * gtk_clipboard_wait_for_image() since it doesn’t need to retrieve 705 * the actual image data. 706 * 707 * Return: %TRUE is there is an image available, %FALSE otherwise. 708 * 709 * Since: 2.6 710 */ 711 public bool waitIsImageAvailable() 712 { 713 return gtk_clipboard_wait_is_image_available(gtkClipboard) != 0; 714 } 715 716 /** 717 * Test to see if there is rich text available to be pasted 718 * This is done by requesting the TARGETS atom and checking 719 * if it contains any of the supported rich text targets. This function 720 * waits for the data to be received using the main loop, so events, 721 * timeouts, etc, may be dispatched during the wait. 722 * 723 * This function is a little faster than calling 724 * gtk_clipboard_wait_for_rich_text() since it doesn’t need to retrieve 725 * the actual text. 726 * 727 * Params: 728 * buffer = a #GtkTextBuffer 729 * 730 * Return: %TRUE is there is rich text available, %FALSE otherwise. 731 * 732 * Since: 2.10 733 */ 734 public bool waitIsRichTextAvailable(TextBuffer buffer) 735 { 736 return gtk_clipboard_wait_is_rich_text_available(gtkClipboard, (buffer is null) ? null : buffer.getTextBufferStruct()) != 0; 737 } 738 739 /** 740 * Checks if a clipboard supports pasting data of a given type. This 741 * function can be used to determine if a “Paste” menu item should be 742 * insensitive or not. 743 * 744 * If you want to see if there’s text available on the clipboard, use 745 * gtk_clipboard_wait_is_text_available () instead. 746 * 747 * Params: 748 * target = A #GdkAtom indicating which target to look for. 749 * 750 * Return: %TRUE if the target is available, %FALSE otherwise. 751 * 752 * Since: 2.6 753 */ 754 public bool waitIsTargetAvailable(GdkAtom target) 755 { 756 return gtk_clipboard_wait_is_target_available(gtkClipboard, target) != 0; 757 } 758 759 /** 760 * Test to see if there is text available to be pasted 761 * This is done by requesting the TARGETS atom and checking 762 * if it contains any of the supported text targets. This function 763 * waits for the data to be received using the main loop, so events, 764 * timeouts, etc, may be dispatched during the wait. 765 * 766 * This function is a little faster than calling 767 * gtk_clipboard_wait_for_text() since it doesn’t need to retrieve 768 * the actual text. 769 * 770 * Return: %TRUE is there is text available, %FALSE otherwise. 771 */ 772 public bool waitIsTextAvailable() 773 { 774 return gtk_clipboard_wait_is_text_available(gtkClipboard) != 0; 775 } 776 777 /** 778 * Test to see if there is a list of URIs available to be pasted 779 * This is done by requesting the TARGETS atom and checking 780 * if it contains the URI targets. This function 781 * waits for the data to be received using the main loop, so events, 782 * timeouts, etc, may be dispatched during the wait. 783 * 784 * This function is a little faster than calling 785 * gtk_clipboard_wait_for_uris() since it doesn’t need to retrieve 786 * the actual URI data. 787 * 788 * Return: %TRUE is there is an URI list available, %FALSE otherwise. 789 * 790 * Since: 2.14 791 */ 792 public bool waitIsUrisAvailable() 793 { 794 return gtk_clipboard_wait_is_uris_available(gtkClipboard) != 0; 795 } 796 797 int[string] connectedSignals; 798 799 void delegate(GdkEventOwnerChange*, Clipboard)[] onOwnerChangeListeners; 800 /** 801 * The ::owner-change signal is emitted when GTK+ receives an 802 * event that indicates that the ownership of the selection 803 * associated with @clipboard has changed. 804 * 805 * Params: 806 * event = the @GdkEventOwnerChange event 807 * 808 * Since: 2.6 809 */ 810 void addOnOwnerChange(void delegate(GdkEventOwnerChange*, Clipboard) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 811 { 812 if ( "owner-change" !in connectedSignals ) 813 { 814 Signals.connectData( 815 this, 816 "owner-change", 817 cast(GCallback)&callBackOwnerChange, 818 cast(void*)this, 819 null, 820 connectFlags); 821 connectedSignals["owner-change"] = 1; 822 } 823 onOwnerChangeListeners ~= dlg; 824 } 825 extern(C) static void callBackOwnerChange(GtkClipboard* clipboardStruct, GdkEventOwnerChange* event, Clipboard _clipboard) 826 { 827 foreach ( void delegate(GdkEventOwnerChange*, Clipboard) dlg; _clipboard.onOwnerChangeListeners ) 828 { 829 dlg(event, _clipboard); 830 } 831 } 832 833 void delegate(Event, Clipboard)[] onOwnerChangeGenericListeners; 834 /** 835 * The ::owner-change signal is emitted when GTK+ receives an 836 * event that indicates that the ownership of the selection 837 * associated with @clipboard has changed. 838 * 839 * Params: 840 * event = the @GdkEventOwnerChange event 841 * 842 * Since: 2.6 843 */ 844 void addOnOwnerChange(void delegate(Event, Clipboard) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 845 { 846 if ( "owner-change-generic-event" !in connectedSignals ) 847 { 848 Signals.connectData( 849 this, 850 "owner-change", 851 cast(GCallback)&callBackOwnerChangeGeneric, 852 cast(void*)this, 853 null, 854 connectFlags); 855 connectedSignals["owner-change-generic-event"] = 1; 856 } 857 onOwnerChangeGenericListeners ~= dlg; 858 } 859 extern(C) static void callBackOwnerChangeGeneric(GtkClipboard* clipboardStruct, GdkEvent* event, Clipboard _clipboard) 860 { 861 foreach ( void delegate(Event, Clipboard) dlg; _clipboard.onOwnerChangeGenericListeners ) 862 { 863 dlg(ObjectG.getDObject!(Event)(event), _clipboard); 864 } 865 } 866 }