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 135 public static GType getType() 136 { 137 return gtk_clipboard_get_type(); 138 } 139 140 /** 141 * Returns the clipboard object for the given selection. 142 * See gtk_clipboard_get_for_display() for complete details. 143 * 144 * Params: 145 * selection = a #GdkAtom which identifies the clipboard to use 146 * 147 * Return: the appropriate clipboard object. If no clipboard 148 * already exists, a new one will be created. Once a clipboard 149 * object has been created, it is persistent and, since it is 150 * owned by GTK+, must not be freed or unreffed. 151 */ 152 public static Clipboard get(GdkAtom selection) 153 { 154 auto p = gtk_clipboard_get(selection); 155 156 if(p is null) 157 { 158 return null; 159 } 160 161 return ObjectG.getDObject!(Clipboard)(cast(GtkClipboard*) p); 162 } 163 164 /** 165 * Returns the clipboard object for the given selection. 166 * Cut/copy/paste menu items and keyboard shortcuts should use 167 * the default clipboard, returned by passing %GDK_SELECTION_CLIPBOARD for @selection. 168 * (%GDK_NONE is supported as a synonym for GDK_SELECTION_CLIPBOARD 169 * for backwards compatibility reasons.) 170 * The currently-selected object or text should be provided on the clipboard 171 * identified by #GDK_SELECTION_PRIMARY. Cut/copy/paste menu items 172 * conceptually copy the contents of the #GDK_SELECTION_PRIMARY clipboard 173 * to the default clipboard, i.e. they copy the selection to what the 174 * user sees as the clipboard. 175 * 176 * (Passing #GDK_NONE is the same as using `gdk_atom_intern 177 * ("CLIPBOARD", FALSE)`. 178 * 179 * See the 180 * [FreeDesktop Clipboard Specification](http://www.freedesktop.org/Standards/clipboards-spec) 181 * for a detailed discussion of the “CLIPBOARD” vs. “PRIMARY” 182 * selections under the X window system. On Win32 the 183 * #GDK_SELECTION_PRIMARY clipboard is essentially ignored.) 184 * 185 * It’s possible to have arbitrary named clipboards; if you do invent 186 * new clipboards, you should prefix the selection name with an 187 * underscore (because the ICCCM requires that nonstandard atoms are 188 * underscore-prefixed), and namespace it as well. For example, 189 * if your application called “Foo” has a special-purpose 190 * clipboard, you might call it “_FOO_SPECIAL_CLIPBOARD”. 191 * 192 * Params: 193 * display = the #GdkDisplay for which the clipboard is to be retrieved or created. 194 * selection = a #GdkAtom which identifies the clipboard to use. 195 * 196 * Return: the appropriate clipboard object. If no 197 * clipboard already exists, a new one will be created. Once a clipboard 198 * object has been created, it is persistent and, since it is owned by 199 * GTK+, must not be freed or unrefd. 200 * 201 * Since: 2.2 202 */ 203 public static Clipboard getForDisplay(Display display, GdkAtom selection) 204 { 205 auto p = gtk_clipboard_get_for_display((display is null) ? null : display.getDisplayStruct(), selection); 206 207 if(p is null) 208 { 209 return null; 210 } 211 212 return ObjectG.getDObject!(Clipboard)(cast(GtkClipboard*) p); 213 } 214 215 /** 216 * Clears the contents of the clipboard. Generally this should only 217 * be called between the time you call gtk_clipboard_set_with_owner() 218 * or gtk_clipboard_set_with_data(), 219 * and when the @clear_func you supplied is called. Otherwise, the 220 * clipboard may be owned by someone else. 221 */ 222 public void clear() 223 { 224 gtk_clipboard_clear(gtkClipboard); 225 } 226 227 /** 228 * Gets the #GdkDisplay associated with @clipboard 229 * 230 * Return: the #GdkDisplay associated with @clipboard 231 * 232 * Since: 2.2 233 */ 234 public Display getDisplay() 235 { 236 auto p = gtk_clipboard_get_display(gtkClipboard); 237 238 if(p is null) 239 { 240 return null; 241 } 242 243 return ObjectG.getDObject!(Display)(cast(GdkDisplay*) p); 244 } 245 246 /** 247 * If the clipboard contents callbacks were set with 248 * gtk_clipboard_set_with_owner(), and the gtk_clipboard_set_with_data() or 249 * gtk_clipboard_clear() has not subsequently called, returns the owner set 250 * by gtk_clipboard_set_with_owner(). 251 * 252 * Return: the owner of the clipboard, if any; 253 * otherwise %NULL. 254 */ 255 public ObjectG getOwner() 256 { 257 auto p = gtk_clipboard_get_owner(gtkClipboard); 258 259 if(p is null) 260 { 261 return null; 262 } 263 264 return ObjectG.getDObject!(ObjectG)(cast(GObject*) p); 265 } 266 267 /** 268 * Requests the contents of clipboard as the given target. 269 * When the results of the result are later received the supplied callback 270 * will be called. 271 * 272 * Params: 273 * target = an atom representing the form into which the clipboard 274 * owner should convert the selection. 275 * callback = A function to call when the results are received 276 * (or the retrieval fails). If the retrieval fails the length field of 277 * @selection_data will be negative. 278 * userData = user data to pass to @callback 279 */ 280 public void requestContents(GdkAtom target, GtkClipboardReceivedFunc callback, void* userData) 281 { 282 gtk_clipboard_request_contents(gtkClipboard, target, callback, userData); 283 } 284 285 /** 286 * Requests the contents of the clipboard as image. When the image is 287 * later received, it will be converted to a #GdkPixbuf, and 288 * @callback will be called. 289 * 290 * The @pixbuf parameter to @callback will contain the resulting 291 * #GdkPixbuf if the request succeeded, or %NULL if it failed. This 292 * could happen for various reasons, in particular if the clipboard 293 * was empty or if the contents of the clipboard could not be 294 * converted into an image. 295 * 296 * Params: 297 * callback = a function to call when the image is received, 298 * or the retrieval fails. (It will always be called one way or the other.) 299 * userData = user data to pass to @callback. 300 * 301 * Since: 2.6 302 */ 303 public void requestImage(GtkClipboardImageReceivedFunc callback, void* userData) 304 { 305 gtk_clipboard_request_image(gtkClipboard, callback, userData); 306 } 307 308 /** 309 * Requests the contents of the clipboard as rich text. When the rich 310 * text is later received, @callback will be called. 311 * 312 * The @text parameter to @callback will contain the resulting rich 313 * text if the request succeeded, or %NULL if it failed. The @length 314 * parameter will contain @text’s length. This function can fail for 315 * various reasons, in particular if the clipboard was empty or if the 316 * contents of the clipboard could not be converted into rich text form. 317 * 318 * Params: 319 * buffer = a #GtkTextBuffer 320 * callback = a function to call when the text is received, 321 * or the retrieval fails. (It will always be called one way or the other.) 322 * userData = user data to pass to @callback. 323 * 324 * Since: 2.10 325 */ 326 public void requestRichText(TextBuffer buffer, GtkClipboardRichTextReceivedFunc callback, void* userData) 327 { 328 gtk_clipboard_request_rich_text(gtkClipboard, (buffer is null) ? null : buffer.getTextBufferStruct(), callback, userData); 329 } 330 331 /** 332 * Requests the contents of the clipboard as list of supported targets. 333 * When the list is later received, @callback will be called. 334 * 335 * The @targets parameter to @callback will contain the resulting targets if 336 * the request succeeded, or %NULL if it failed. 337 * 338 * Params: 339 * callback = a function to call when the targets are 340 * received, or the retrieval fails. (It will always be called 341 * one way or the other.) 342 * userData = user data to pass to @callback. 343 * 344 * Since: 2.4 345 */ 346 public void requestTargets(GtkClipboardTargetsReceivedFunc callback, void* userData) 347 { 348 gtk_clipboard_request_targets(gtkClipboard, callback, userData); 349 } 350 351 /** 352 * Requests the contents of the clipboard as text. When the text is 353 * later received, it will be converted to UTF-8 if necessary, and 354 * @callback will be called. 355 * 356 * The @text parameter to @callback will contain the resulting text if 357 * the request succeeded, or %NULL if it failed. This could happen for 358 * various reasons, in particular if the clipboard was empty or if the 359 * contents of the clipboard could not be converted into text form. 360 * 361 * Params: 362 * callback = a function to call when the text is received, 363 * or the retrieval fails. (It will always be called one way or the other.) 364 * userData = user data to pass to @callback. 365 */ 366 public void requestText(GtkClipboardTextReceivedFunc callback, void* userData) 367 { 368 gtk_clipboard_request_text(gtkClipboard, callback, userData); 369 } 370 371 /** 372 * Requests the contents of the clipboard as URIs. When the URIs are 373 * later received @callback will be called. 374 * 375 * The @uris parameter to @callback will contain the resulting array of 376 * URIs if the request succeeded, or %NULL if it failed. This could happen 377 * for various reasons, in particular if the clipboard was empty or if the 378 * contents of the clipboard could not be converted into URI form. 379 * 380 * Params: 381 * callback = a function to call when the URIs are received, 382 * or the retrieval fails. (It will always be called one way or the other.) 383 * userData = user data to pass to @callback. 384 * 385 * Since: 2.14 386 */ 387 public void requestUris(GtkClipboardURIReceivedFunc callback, void* userData) 388 { 389 gtk_clipboard_request_uris(gtkClipboard, callback, userData); 390 } 391 392 /** 393 * Hints that the clipboard data should be stored somewhere when the 394 * application exits or when gtk_clipboard_store () is called. 395 * 396 * This value is reset when the clipboard owner changes. 397 * Where the clipboard data is stored is platform dependent, 398 * see gdk_display_store_clipboard () for more information. 399 * 400 * Params: 401 * targets = array containing 402 * information about which forms should be stored or %NULL 403 * to indicate that all forms should be stored. 404 * nTargets = number of elements in @targets 405 * 406 * Since: 2.6 407 */ 408 public void setCanStore(TargetEntry[] targets) 409 { 410 GtkTargetEntry[] targetsArray = new GtkTargetEntry[targets.length]; 411 for ( int i = 0; i < targets.length; i++ ) 412 { 413 targetsArray[i] = *(targets[i].getTargetEntryStruct()); 414 } 415 416 gtk_clipboard_set_can_store(gtkClipboard, targetsArray.ptr, cast(int)targets.length); 417 } 418 419 /** 420 * Sets the contents of the clipboard to the given #GdkPixbuf. 421 * GTK+ will take responsibility for responding for requests 422 * for the image, and for converting the image into the 423 * requested format. 424 * 425 * Params: 426 * pixbuf = a #GdkPixbuf 427 * 428 * Since: 2.6 429 */ 430 public void setImage(Pixbuf pixbuf) 431 { 432 gtk_clipboard_set_image(gtkClipboard, (pixbuf is null) ? null : pixbuf.getPixbufStruct()); 433 } 434 435 /** 436 * Sets the contents of the clipboard to the given UTF-8 string. GTK+ will 437 * make a copy of the text and take responsibility for responding 438 * for requests for the text, and for converting the text into 439 * the requested format. 440 * 441 * Params: 442 * text = a UTF-8 string. 443 * len = length of @text, in bytes, or -1, in which case 444 * the length will be determined with strlen(). 445 */ 446 public void setText(string text, int len) 447 { 448 gtk_clipboard_set_text(gtkClipboard, Str.toStringz(text), len); 449 } 450 451 /** 452 * Virtually sets the contents of the specified clipboard by providing 453 * a list of supported formats for the clipboard data and a function 454 * to call to get the actual data when it is requested. 455 * 456 * Params: 457 * targets = array containing information 458 * about the available forms for the clipboard data 459 * nTargets = number of elements in @targets 460 * getFunc = function to call to get the actual clipboard data 461 * clearFunc = when the clipboard contents are set again, 462 * this function will be called, and @get_func will not be subsequently 463 * called. 464 * userData = user data to pass to @get_func and @clear_func. 465 * 466 * Return: %TRUE if setting the clipboard data succeeded. 467 * If setting the clipboard data failed the provided callback 468 * functions will be ignored. 469 */ 470 public bool setWithData(TargetEntry[] targets, GtkClipboardGetFunc getFunc, GtkClipboardClearFunc clearFunc, void* userData) 471 { 472 GtkTargetEntry[] targetsArray = new GtkTargetEntry[targets.length]; 473 for ( int i = 0; i < targets.length; i++ ) 474 { 475 targetsArray[i] = *(targets[i].getTargetEntryStruct()); 476 } 477 478 return gtk_clipboard_set_with_data(gtkClipboard, targetsArray.ptr, cast(uint)targets.length, getFunc, clearFunc, userData) != 0; 479 } 480 481 /** 482 * Virtually sets the contents of the specified clipboard by providing 483 * a list of supported formats for the clipboard data and a function 484 * to call to get the actual data when it is requested. 485 * 486 * The difference between this function and gtk_clipboard_set_with_data() 487 * is that instead of an generic @user_data pointer, a #GObject is passed 488 * in. 489 * 490 * Params: 491 * targets = array containing information 492 * about the available forms for the clipboard data 493 * nTargets = number of elements in @targets 494 * getFunc = function to call to get the actual clipboard data 495 * clearFunc = when the clipboard contents are set again, 496 * this function will be called, and @get_func will not be subsequently 497 * called 498 * owner = an object that “owns” the data. This object will be passed 499 * to the callbacks when called 500 * 501 * Return: %TRUE if setting the clipboard data succeeded. 502 * If setting the clipboard data failed the provided callback 503 * functions will be ignored. 504 */ 505 public bool setWithOwner(TargetEntry[] targets, GtkClipboardGetFunc getFunc, GtkClipboardClearFunc clearFunc, ObjectG owner) 506 { 507 GtkTargetEntry[] targetsArray = new GtkTargetEntry[targets.length]; 508 for ( int i = 0; i < targets.length; i++ ) 509 { 510 targetsArray[i] = *(targets[i].getTargetEntryStruct()); 511 } 512 513 return gtk_clipboard_set_with_owner(gtkClipboard, targetsArray.ptr, cast(uint)targets.length, getFunc, clearFunc, (owner is null) ? null : owner.getObjectGStruct()) != 0; 514 } 515 516 /** 517 * Stores the current clipboard data somewhere so that it will stay 518 * around after the application has quit. 519 * 520 * Since: 2.6 521 */ 522 public void store() 523 { 524 gtk_clipboard_store(gtkClipboard); 525 } 526 527 /** 528 * Requests the contents of the clipboard using the given target. 529 * This function waits for the data to be received using the main 530 * loop, so events, timeouts, etc, may be dispatched during the wait. 531 * 532 * Params: 533 * target = an atom representing the form into which the clipboard 534 * owner should convert the selection. 535 * 536 * Return: a newly-allocated #GtkSelectionData object or %NULL 537 * if retrieving the given target failed. If non-%NULL, 538 * this value must be freed with gtk_selection_data_free() 539 * when you are finished with it. 540 */ 541 public SelectionData waitForContents(GdkAtom target) 542 { 543 auto p = gtk_clipboard_wait_for_contents(gtkClipboard, target); 544 545 if(p is null) 546 { 547 return null; 548 } 549 550 return ObjectG.getDObject!(SelectionData)(cast(GtkSelectionData*) p); 551 } 552 553 /** 554 * Requests the contents of the clipboard as image and converts 555 * the result to a #GdkPixbuf. This function waits for 556 * the data to be received using the main loop, so events, 557 * timeouts, etc, may be dispatched during the wait. 558 * 559 * Return: a newly-allocated #GdkPixbuf 560 * object which must be disposed with g_object_unref(), or 561 * %NULL if retrieving the selection data failed. (This could 562 * happen for various reasons, in particular if the clipboard 563 * was empty or if the contents of the clipboard could not be 564 * converted into an image.) 565 * 566 * Since: 2.6 567 */ 568 public Pixbuf waitForImage() 569 { 570 auto p = gtk_clipboard_wait_for_image(gtkClipboard); 571 572 if(p is null) 573 { 574 return null; 575 } 576 577 return ObjectG.getDObject!(Pixbuf)(cast(GdkPixbuf*) p, true); 578 } 579 580 /** 581 * Requests the contents of the clipboard as rich text. This function 582 * waits for the data to be received using the main loop, so events, 583 * timeouts, etc, may be dispatched during the wait. 584 * 585 * Params: 586 * buffer = a #GtkTextBuffer 587 * format = return location for the format of the returned data 588 * length = return location for the length of the returned data 589 * 590 * Return: a 591 * newly-allocated binary block of data which must be 592 * freed with g_free(), or %NULL if retrieving the 593 * selection data failed. (This could happen for various 594 * reasons, in particular if the clipboard was empty or 595 * if the contents of the clipboard could not be 596 * converted into text form.) 597 * 598 * Since: 2.10 599 */ 600 public ubyte[] waitForRichText(TextBuffer buffer, out GdkAtom format) 601 { 602 size_t length; 603 604 auto p = gtk_clipboard_wait_for_rich_text(gtkClipboard, (buffer is null) ? null : buffer.getTextBufferStruct(), &format, &length); 605 606 return p[0 .. length]; 607 } 608 609 /** 610 * Returns a list of targets that are present on the clipboard, or %NULL 611 * if there aren’t any targets available. The returned list must be 612 * freed with g_free(). 613 * This function waits for the data to be received using the main 614 * loop, so events, timeouts, etc, may be dispatched during the wait. 615 * 616 * Params: 617 * targets = location 618 * to store an array of targets. The result stored here must 619 * be freed with g_free(). 620 * nTargets = location to store number of items in @targets. 621 * 622 * Return: %TRUE if any targets are present on the clipboard, 623 * otherwise %FALSE. 624 * 625 * Since: 2.4 626 */ 627 public bool waitForTargets(out GdkAtom[] targets) 628 { 629 GdkAtom* outtargets = null; 630 int nTargets; 631 632 auto p = gtk_clipboard_wait_for_targets(gtkClipboard, &outtargets, &nTargets) != 0; 633 634 targets = outtargets[0 .. nTargets]; 635 636 return p; 637 } 638 639 /** 640 * Requests the contents of the clipboard as text and converts 641 * the result to UTF-8 if necessary. This function waits for 642 * the data to be received using the main loop, so events, 643 * timeouts, etc, may be dispatched during the wait. 644 * 645 * Return: a newly-allocated UTF-8 string which must 646 * be freed with g_free(), or %NULL if retrieving 647 * the selection data failed. (This could happen 648 * for various reasons, in particular if the 649 * clipboard was empty or if the contents of the 650 * clipboard could not be converted into text form.) 651 */ 652 public string waitForText() 653 { 654 return Str.toString(gtk_clipboard_wait_for_text(gtkClipboard)); 655 } 656 657 /** 658 * Requests the contents of the clipboard as URIs. This function waits 659 * for the data to be received using the main loop, so events, 660 * timeouts, etc, may be dispatched during the wait. 661 * 662 * Return: a newly-allocated %NULL-terminated array of strings which must 663 * be freed with g_strfreev(), or %NULL if retrieving the 664 * selection data failed. (This could happen for various reasons, 665 * in particular if the clipboard was empty or if the contents of 666 * the clipboard could not be converted into URI form.) 667 * 668 * Since: 2.14 669 */ 670 public string[] waitForUris() 671 { 672 return Str.toStringArray(gtk_clipboard_wait_for_uris(gtkClipboard)); 673 } 674 675 /** 676 * Test to see if there is an image available to be pasted 677 * This is done by requesting the TARGETS atom and checking 678 * if it contains any of the supported image targets. This function 679 * waits for the data to be received using the main loop, so events, 680 * timeouts, etc, may be dispatched during the wait. 681 * 682 * This function is a little faster than calling 683 * gtk_clipboard_wait_for_image() since it doesn’t need to retrieve 684 * the actual image data. 685 * 686 * Return: %TRUE is there is an image available, %FALSE otherwise. 687 * 688 * Since: 2.6 689 */ 690 public bool waitIsImageAvailable() 691 { 692 return gtk_clipboard_wait_is_image_available(gtkClipboard) != 0; 693 } 694 695 /** 696 * Test to see if there is rich text available to be pasted 697 * This is done by requesting the TARGETS atom and checking 698 * if it contains any of the supported rich text targets. This function 699 * waits for the data to be received using the main loop, so events, 700 * timeouts, etc, may be dispatched during the wait. 701 * 702 * This function is a little faster than calling 703 * gtk_clipboard_wait_for_rich_text() since it doesn’t need to retrieve 704 * the actual text. 705 * 706 * Params: 707 * buffer = a #GtkTextBuffer 708 * 709 * Return: %TRUE is there is rich text available, %FALSE otherwise. 710 * 711 * Since: 2.10 712 */ 713 public bool waitIsRichTextAvailable(TextBuffer buffer) 714 { 715 return gtk_clipboard_wait_is_rich_text_available(gtkClipboard, (buffer is null) ? null : buffer.getTextBufferStruct()) != 0; 716 } 717 718 /** 719 * Checks if a clipboard supports pasting data of a given type. This 720 * function can be used to determine if a “Paste” menu item should be 721 * insensitive or not. 722 * 723 * If you want to see if there’s text available on the clipboard, use 724 * gtk_clipboard_wait_is_text_available () instead. 725 * 726 * Params: 727 * target = A #GdkAtom indicating which target to look for. 728 * 729 * Return: %TRUE if the target is available, %FALSE otherwise. 730 * 731 * Since: 2.6 732 */ 733 public bool waitIsTargetAvailable(GdkAtom target) 734 { 735 return gtk_clipboard_wait_is_target_available(gtkClipboard, target) != 0; 736 } 737 738 /** 739 * Test to see if there is text available to be pasted 740 * This is done by requesting the TARGETS atom and checking 741 * if it contains any of the supported text targets. This function 742 * waits for the data to be received using the main loop, so events, 743 * timeouts, etc, may be dispatched during the wait. 744 * 745 * This function is a little faster than calling 746 * gtk_clipboard_wait_for_text() since it doesn’t need to retrieve 747 * the actual text. 748 * 749 * Return: %TRUE is there is text available, %FALSE otherwise. 750 */ 751 public bool waitIsTextAvailable() 752 { 753 return gtk_clipboard_wait_is_text_available(gtkClipboard) != 0; 754 } 755 756 /** 757 * Test to see if there is a list of URIs available to be pasted 758 * This is done by requesting the TARGETS atom and checking 759 * if it contains the URI targets. This function 760 * waits for the data to be received using the main loop, so events, 761 * timeouts, etc, may be dispatched during the wait. 762 * 763 * This function is a little faster than calling 764 * gtk_clipboard_wait_for_uris() since it doesn’t need to retrieve 765 * the actual URI data. 766 * 767 * Return: %TRUE is there is an URI list available, %FALSE otherwise. 768 * 769 * Since: 2.14 770 */ 771 public bool waitIsUrisAvailable() 772 { 773 return gtk_clipboard_wait_is_uris_available(gtkClipboard) != 0; 774 } 775 776 int[string] connectedSignals; 777 778 void delegate(GdkEventOwnerChange*, Clipboard)[] onOwnerChangeListeners; 779 /** 780 * The ::owner-change signal is emitted when GTK+ receives an 781 * event that indicates that the ownership of the selection 782 * associated with @clipboard has changed. 783 * 784 * Params: 785 * event = the @GdkEventOwnerChange event 786 * 787 * Since: 2.6 788 */ 789 void addOnOwnerChange(void delegate(GdkEventOwnerChange*, Clipboard) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 790 { 791 if ( "owner-change" !in connectedSignals ) 792 { 793 Signals.connectData( 794 this, 795 "owner-change", 796 cast(GCallback)&callBackOwnerChange, 797 cast(void*)this, 798 null, 799 connectFlags); 800 connectedSignals["owner-change"] = 1; 801 } 802 onOwnerChangeListeners ~= dlg; 803 } 804 extern(C) static void callBackOwnerChange(GtkClipboard* clipboardStruct, GdkEventOwnerChange* event, Clipboard _clipboard) 805 { 806 foreach ( void delegate(GdkEventOwnerChange*, Clipboard) dlg; _clipboard.onOwnerChangeListeners ) 807 { 808 dlg(event, _clipboard); 809 } 810 } 811 812 void delegate(Event, Clipboard)[] onOwnerChangeGenericListeners; 813 /** 814 * The ::owner-change signal is emitted when GTK+ receives an 815 * event that indicates that the ownership of the selection 816 * associated with @clipboard has changed. 817 * 818 * Params: 819 * event = the @GdkEventOwnerChange event 820 * 821 * Since: 2.6 822 */ 823 void addOnOwnerChange(void delegate(Event, Clipboard) dlg, ConnectFlags connectFlags=cast(ConnectFlags)0) 824 { 825 if ( "owner-change-generic-event" !in connectedSignals ) 826 { 827 Signals.connectData( 828 this, 829 "owner-change", 830 cast(GCallback)&callBackOwnerChangeGeneric, 831 cast(void*)this, 832 null, 833 connectFlags); 834 connectedSignals["owner-change-generic-event"] = 1; 835 } 836 onOwnerChangeGenericListeners ~= dlg; 837 } 838 extern(C) static void callBackOwnerChangeGeneric(GtkClipboard* clipboardStruct, GdkEvent* event, Clipboard _clipboard) 839 { 840 foreach ( void delegate(Event, Clipboard) dlg; _clipboard.onOwnerChangeGenericListeners ) 841 { 842 dlg(ObjectG.getDObject!(Event)(event), _clipboard); 843 } 844 } 845 }