gtkclipboard.c 28.6 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31
/* GTK - The GIMP Toolkit
 * Copyright (C) 2000 Red Hat, Inc.
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the
 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
 * Boston, MA 02111-1307, USA.
 *
 * Global clipboard abstraction. 
 */

#include <string.h>

#include "gtkclipboard.h"
#include "gtkinvisible.h"
#include "gtkmain.h"

#ifdef GDK_WINDOWING_X11
#include "x11/gdkx.h"
#endif

32 33 34 35
#ifdef GDK_WINDOWING_WIN32
#include "win32/gdkwin32.h"
#endif

36 37
typedef struct _GtkClipboardClass GtkClipboardClass;

38 39 40 41 42
typedef struct _RequestContentsInfo RequestContentsInfo;
typedef struct _RequestTextInfo RequestTextInfo;

struct _GtkClipboard 
{
43
  GObject parent_instance;
44

45 46 47 48 49 50 51 52 53 54
  GdkAtom selection;

  GtkClipboardGetFunc get_func;
  GtkClipboardClearFunc clear_func;
  gpointer user_data;
  gboolean have_owner;

  guint32 timestamp;

  gboolean have_selection;
55
  GdkDisplay *display;
56 57
};

58 59 60 61 62
struct _GtkClipboardClass
{
  GObjectClass parent_class;
};

63 64 65 66 67 68 69 70 71 72 73 74
struct _RequestContentsInfo
{
  GtkClipboardReceivedFunc callback;
  gpointer user_data;
};

struct _RequestTextInfo
{
  GtkClipboardTextReceivedFunc callback;
  gpointer user_data;
};

75 76 77
static void gtk_clipboard_class_init (GtkClipboardClass *class);
static void gtk_clipboard_finalize   (GObject           *object);

78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94
static void clipboard_unset    (GtkClipboard     *clipboard);
static void selection_received (GtkWidget        *widget,
				GtkSelectionData *selection_data,
				guint             time);

enum {
  TARGET_STRING,
  TARGET_TEXT,
  TARGET_COMPOUND_TEXT,
  TARGET_UTF8_STRING
};

static const gchar *request_contents_key = "gtk-request-contents";
static GQuark request_contents_key_id = 0;

static const gchar *clipboards_owned_key = "gtk-clipboards-owned";
static GQuark clipboards_owned_key_id = 0;
95

96
static GObjectClass *parent_class;
97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117

GType
gtk_clipboard_get_type (void)
{
  static GType clipboard_type = 0;
  
  if (!clipboard_type)
    {
      static const GTypeInfo clipboard_info =
      {
	sizeof (GtkClipboardClass),
	NULL,           /* base_init */
	NULL,           /* base_finalize */
	(GClassInitFunc) gtk_clipboard_class_init,
	NULL,           /* class_finalize */
	NULL,           /* class_data */
	sizeof (GtkClipboard),
	0,              /* n_preallocs */
	(GInstanceInitFunc) NULL,
      };
      
Manish Singh's avatar
Manish Singh committed
118 119
      clipboard_type = g_type_register_static (G_TYPE_OBJECT, "GtkClipboard",
					       &clipboard_info, 0);
120
    }
121
  
122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155
  return clipboard_type;
}

static void
gtk_clipboard_class_init (GtkClipboardClass *class)
{
  GObjectClass *gobject_class = G_OBJECT_CLASS (class);

  parent_class = g_type_class_peek_parent (class);
  
  gobject_class->finalize = gtk_clipboard_finalize;
}

static void
gtk_clipboard_finalize   (GObject *object)
{
  clipboard_unset (GTK_CLIPBOARD (object));
}

static void
clipboard_display_closed (GdkDisplay   *display,
			  gboolean      is_error,
			  GtkClipboard *clipboard)
{
  GSList *clipboards;

  clipboards = g_object_get_data (G_OBJECT (display), "gtk-clipboard-list");
  g_object_run_dispose (G_OBJECT (clipboard));
  g_object_unref (clipboard);
  clipboards = g_slist_remove (clipboards, clipboard);
  
  g_object_set_data (G_OBJECT (display), "gtk-clipboard-list", clipboards);
}

156
/**
157 158
 * gtk_clipboard_get_for_display:
 * @display: the display for which the clipboard is to be retrieved or created
159
 * @selection: a #GdkAtom which identifies the clipboard
160
 *             to use.
161 162
 * 
 * Returns the clipboard object for the given selection.
163
 * Cut/copy/paste menu items and keyboard shortcuts should use
164 165 166
 * the default clipboard, returned by passing %GDK_SELECTION_CLIPBOARD for @selection.
 * (%GDK_NONE is supported as a synonym for GDK_SELECTION_CLIPBOARD
 * for backwards compatibility reasons.)
167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186
 * The currently-selected object or text should be provided on the clipboard
 * identified by #GDK_SELECTION_PRIMARY. Cut/copy/paste menu items
 * conceptually copy the contents of the #GDK_SELECTION_PRIMARY clipboard
 * to the default clipboard, i.e. they copy the selection to what the
 * user sees as the clipboard.
 *
 * (Passing #GDK_NONE is the same as using <literal>gdk_atom_intern
 * ("CLIPBOARD", FALSE)</literal>. See
 * <ulink url="http://www.freedesktop.org/standards/clipboards.txt">
 * http://www.freedesktop.org/standards/clipboards.txt</ulink>
 * for a detailed discussion of the "CLIPBOARD" vs. "PRIMARY" selections
 * under the X window system. On Win32 the #GDK_SELECTION_PRIMARY
 * clipboard is essentially ignored.)
 *
 * It's possible to have arbitrary named clipboards; if you do invent
 * new clipboards, you should prefix the selection name with an
 * underscore (because the ICCCM requires that nonstandard atoms are
 * underscore-prefixed), and namespace it as well. For example,
 * if your application called "Foo" has a special-purpose
 * clipboard, you might call it "_FOO_SPECIAL_CLIPBOARD".
187 188 189 190
 * 
 * Return value: the appropriate clipboard object. If no
 *             clipboard already exists, a new one will
 *             be created. Once a clipboard object has
191 192
 *             been created, it is persistent for all time and
 *             cannot be freed.
193 194
 *
 * Since: 2.2
195 196
 **/
GtkClipboard *
197
gtk_clipboard_get_for_display (GdkDisplay *display, GdkAtom selection)
198 199
{
  GtkClipboard *clipboard = NULL;
200
  GSList *clipboards;
201 202
  GSList *tmp_list;

203
  g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
204
  g_return_val_if_fail (!display->closed, NULL);
205

206
  if (selection == GDK_NONE)
207 208 209
    selection = GDK_SELECTION_CLIPBOARD;

  clipboards = g_object_get_data (G_OBJECT (display), "gtk-clipboard-list");
210 211 212 213 214 215 216 217 218 219 220 221 222

  tmp_list = clipboards;
  while (tmp_list)
    {
      clipboard = tmp_list->data;
      if (clipboard->selection == selection)
	break;

      tmp_list = tmp_list->next;
    }

  if (!tmp_list)
    {
223
      clipboard = g_object_new (GTK_TYPE_CLIPBOARD, NULL);
224
      clipboard->selection = selection;
225
      clipboard->display = display;
226
      clipboards = g_slist_prepend (clipboards, clipboard);
227
      g_object_set_data (G_OBJECT (display), "gtk-clipboard-list", clipboards);
228 229
      g_signal_connect (display, "closed",
			G_CALLBACK (clipboard_display_closed), clipboard);
230 231 232 233 234
    }
  
  return clipboard;
}

235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251
/**
 * gtk_clipboard_get():
 * @selection: a #GdkAtom which identifies the clipboard
 *             to use.
 * 
 * Returns the clipboard object for the given selection.
 * See gtk_clipboard_get_for_display() for complete details.
 * 
 * Return value: the appropriate clipboard object. If no
 *             clipboard already exists, a new one will
 *             be created. Once a clipboard object has
 *             been created, it is persistent for all time and
 *             cannot be freed.
 **/
GtkClipboard *
gtk_clipboard_get (GdkAtom selection)
{
Owen Taylor's avatar
Owen Taylor committed
252
  return gtk_clipboard_get_for_display (gdk_display_get_default (), selection);
253 254
}

255 256 257
static void 
selection_get_cb (GtkWidget          *widget,
		  GtkSelectionData   *selection_data,
258 259
		  guint               info,
		  guint               time)
260
{
261
  GtkClipboard *clipboard = gtk_widget_get_clipboard (widget, selection_data->selection);
262 263 264 265 266 267 268 269 270

  if (clipboard && clipboard->get_func)
    clipboard->get_func (clipboard, selection_data, info, clipboard->user_data);
}

static gboolean
selection_clear_event_cb (GtkWidget	    *widget,
			  GdkEventSelection *event)
{
271
  GtkClipboard *clipboard = gtk_widget_get_clipboard (widget, event->selection);
272 273 274 275 276 277 278 279 280 281

  if (clipboard)
    {
      clipboard_unset (clipboard);
      return TRUE;
    }

  return FALSE;
}

Havoc Pennington's avatar
Havoc Pennington committed
282
static GtkWidget *
283 284
make_clipboard_widget (GdkDisplay *display, 
		       gboolean    provider)
285
{
286
  GtkWidget *widget = gtk_invisible_new_for_screen (gdk_display_get_default_screen (display));
287

Manish Singh's avatar
Manish Singh committed
288 289
  g_signal_connect (widget, "selection_received",
		    G_CALLBACK (selection_received), NULL);
290 291 292 293 294 295

  if (provider)
    {
      /* We need this for gdk_x11_get_server_time() */
      gtk_widget_add_events (widget, GDK_PROPERTY_CHANGE_MASK);
      
Manish Singh's avatar
Manish Singh committed
296 297 298 299
      g_signal_connect (widget, "selection_get",
			G_CALLBACK (selection_get_cb), NULL);
      g_signal_connect (widget, "selection_clear_event",
			G_CALLBACK (selection_clear_event_cb), NULL);
300 301 302 303 304
    }

  return widget;
}

305 306
static GtkWidget *
get_clipboard_widget (GdkDisplay *display)
307
{
308 309 310 311 312 313 314 315
  GtkWidget *clip_widget = g_object_get_data (G_OBJECT (display), "gtk-clipboard-widget");
  if (!clip_widget)
    {
      clip_widget = make_clipboard_widget (display, TRUE);
      g_object_set_data (G_OBJECT (display), "gtk-clipboard-widget", clip_widget);
    }

  return clip_widget;
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335
}

/* This function makes a very good guess at what the correct
 * timestamp for a selection request should be. If there is
 * a currently processed event, it uses the timestamp for that
 * event, otherwise it uses the current server time. However,
 * if the time resulting from that is older than the time used
 * last time, it uses the time used last time instead.
 *
 * In order implement this correctly, we never use CurrentTime,
 * but actually retrieve the actual timestamp from the server.
 * This is a little slower but allows us to make the guarantee
 * that the times used by this application will always ascend
 * and we won't get selections being rejected just because
 * we are using a correct timestamp from an event, but used
 * CurrentTime previously.
 */
static guint32
clipboard_get_timestamp (GtkClipboard *clipboard)
{
336
  GtkWidget *clipboard_widget = get_clipboard_widget (clipboard->display);
337 338 339 340
  guint32 timestamp = gtk_get_current_event_time ();

  if (timestamp == GDK_CURRENT_TIME)
    {
341
#ifdef GDK_WINDOWING_X11
342
      timestamp = gdk_x11_get_server_time (clipboard_widget->window);
343 344 345
#elif defined GDK_WINDOWING_WIN32
      timestamp = GetMessageTime ();
#endif
346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394 395 396 397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431
    }
  else
    {
      if (clipboard->timestamp != GDK_CURRENT_TIME)
	{
	  /* Check to see if clipboard->timestamp is newer than
	   * timestamp, accounting for wraparound.
	   */

	  guint32 max = timestamp + 0x80000000;

	  if ((max > timestamp &&
	       (clipboard->timestamp > timestamp &&
		clipboard->timestamp <= max)) ||
	      (max <= timestamp &&
	       (clipboard->timestamp > timestamp ||
		clipboard->timestamp <= max)))
	    {
	      timestamp = clipboard->timestamp;
	    }
	}
    }

  clipboard->timestamp = timestamp;

  return timestamp;
}

static void
clipboard_owner_destroyed (gpointer data)
{
  GSList *clipboards = data;
  GSList *tmp_list;

  tmp_list = clipboards;
  while (tmp_list)
    {
      GtkClipboard *clipboard = tmp_list->data;

      clipboard->get_func = NULL;
      clipboard->clear_func = NULL;
      clipboard->user_data = NULL;
      clipboard->have_owner = FALSE;

      gtk_clipboard_clear (clipboard);

      tmp_list = tmp_list->next;
    }
  
  g_slist_free (clipboards);
}

static void
clipboard_add_owner_notify (GtkClipboard *clipboard)
{
  if (!clipboards_owned_key_id)
    clipboards_owned_key_id = g_quark_from_static_string (clipboards_owned_key);
  
  if (clipboard->have_owner)
    g_object_set_qdata_full (clipboard->user_data, clipboards_owned_key_id,
			     g_slist_prepend (g_object_steal_qdata (clipboard->user_data,
								    clipboards_owned_key_id),
					      clipboard),
			     clipboard_owner_destroyed);
}

static void
clipboard_remove_owner_notify (GtkClipboard *clipboard)
{
  if (clipboard->have_owner)
     g_object_set_qdata_full (clipboard->user_data, clipboards_owned_key_id,
			      g_slist_remove (g_object_steal_qdata (clipboard->user_data,
								    clipboards_owned_key_id),
					      clipboard),
			      clipboard_owner_destroyed);
}
	  
static gboolean
gtk_clipboard_set_contents (GtkClipboard         *clipboard,
			    const GtkTargetEntry *targets,
			    guint                 n_targets,
			    GtkClipboardGetFunc   get_func,
			    GtkClipboardClearFunc clear_func,
			    gpointer              user_data,
			    gboolean              have_owner)
{
432
  GtkWidget *clipboard_widget = get_clipboard_widget (clipboard->display);
433

434 435 436 437
  if (gtk_selection_owner_set_for_display (clipboard->display,
					   clipboard_widget,
					   clipboard->selection,
					   clipboard_get_timestamp (clipboard)))
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477 478 479 480 481 482 483 484 485 486 487 488 489 490
    {
      clipboard->have_selection = TRUE;

      if (!(clipboard->have_owner && have_owner) ||
	  clipboard->user_data != user_data)
	{
	  clipboard_unset (clipboard);

	  if (clipboard->get_func)
	    {
	      /* Calling unset() caused the clipboard contents to be reset!
	       * Avoid leaking and return 
	       */
	      if (!(clipboard->have_owner && have_owner) ||
		  clipboard->user_data != user_data)
		{
		  (*clear_func) (clipboard, user_data);
		  return FALSE;
		}
	      else
		return TRUE;
	    }
	  else
	    {
	      clipboard->user_data = user_data;
	      clipboard->have_owner = have_owner;
	      if (have_owner)
		clipboard_add_owner_notify (clipboard);
	    }
	  
 	}

      clipboard->get_func = get_func;
      clipboard->clear_func = clear_func;

      gtk_selection_clear_targets (clipboard_widget, clipboard->selection);
      gtk_selection_add_targets (clipboard_widget, clipboard->selection,
				 targets, n_targets);

      return TRUE;
    }
  else
    return FALSE;
}

/**
 * gtk_clipboard_set_with_data:
 * @clipboard:  a #GtkClipboard
 * @targets:    array containing information about the available forms for the
 *              clipboard data
 * @n_targets:  number of elements in @targets
 * @get_func:   function to call to get the actual clipboard data
 * @clear_func: when the clipboard contents are set again, this function will
491
 *              be called, and @get_func will not be subsequently called.
492 493
 * @user_data:  user data to pass to @get_func and @clear_func.
 * 
494
 * Virtually sets the contents of the specified clipboard by providing
495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
 * a list of supported formats for the clipboard data and a function
 * to call to get the actual data when it is requested.
 * 
 * Return value: %TRUE if setting the clipboard data succeeded. If setting
 *               the clipboard data failed the provided callback functions
 *               will be ignored.
 **/
gboolean
gtk_clipboard_set_with_data (GtkClipboard          *clipboard,
			     const GtkTargetEntry  *targets,
			     guint                  n_targets,
			     GtkClipboardGetFunc    get_func,
			     GtkClipboardClearFunc  clear_func,
			     gpointer               user_data)
{
  g_return_val_if_fail (clipboard != NULL, FALSE);
  g_return_val_if_fail (targets != NULL, FALSE);
  g_return_val_if_fail (get_func != NULL, FALSE);

  return gtk_clipboard_set_contents (clipboard, targets, n_targets,
				     get_func, clear_func, user_data,
				     FALSE);
}

/**
 * gtk_clipboard_set_with_owner:
 * @clipboard:  a #GtkClipboard
 * @targets:    array containing information about the available forms for the
 *              clipboard data
 * @n_targets:  number of elements in @targets
 * @get_func:   function to call to get the actual clipboard data
 * @clear_func: when the clipboard contents are set again, this function will
527
 *              be called, and @get_func will not be subsequently called.
528 529 530
 * @owner:      an object that "owns" the data. This object will be passed
 *              to the callbacks when called. 
 * 
531
 * Virtually sets the contents of the specified clipboard by providing
532 533 534
 * a list of supported formats for the clipboard data and a function
 * to call to get the actual data when it is requested.
 *
Matthias Clasen's avatar
Matthias Clasen committed
535
 * The difference between this function and gtk_clipboard_set_with_data()
536
 * is that instead of an generic @user_data pointer, a #GObject is passed
537
 * in. 
538 539 540 541 542 543 544 545 546 547 548 549 550 551 552 553 554 555 556 557 558 559 560 561 562 563 564
 * 
 * Return value: %TRUE if setting the clipboard data succeeded. If setting
 *               the clipboard data failed the provided callback functions
 *               will be ignored.
 **/
gboolean
gtk_clipboard_set_with_owner (GtkClipboard          *clipboard,
			      const GtkTargetEntry  *targets,
			      guint                  n_targets,
			      GtkClipboardGetFunc    get_func,
			      GtkClipboardClearFunc  clear_func,
			      GObject               *owner)
{
  g_return_val_if_fail (clipboard != NULL, FALSE);
  g_return_val_if_fail (targets != NULL, FALSE);
  g_return_val_if_fail (get_func != NULL, FALSE);
  g_return_val_if_fail (G_IS_OBJECT (owner), FALSE);

  return gtk_clipboard_set_contents (clipboard, targets, n_targets,
				     get_func, clear_func, owner,
				     TRUE);
}

/**
 * gtk_clipboard_get_owner:
 * @clipboard: a #GtkClipboard
 * 
Matthias Clasen's avatar
Matthias Clasen committed
565 566
 * If the clipboard contents callbacks were set with 
 * gtk_clipboard_set_with_owner(), and the gtk_clipboard_set_with_data() or 
Matthias Clasen's avatar
Matthias Clasen committed
567
 * gtk_clipboard_clear() has not subsequently called, returns the owner set 
Matthias Clasen's avatar
Matthias Clasen committed
568
 * by gtk_clipboard_set_with_owner().
569 570 571 572 573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608 609
 * 
 * Return value: the owner of the clipboard, if any; otherwise %NULL.
 **/
GObject *
gtk_clipboard_get_owner (GtkClipboard *clipboard)
{
  g_return_val_if_fail (clipboard != NULL, NULL);

  if (clipboard->have_owner)
    return clipboard->user_data;
  else
    return NULL;
}

static void
clipboard_unset (GtkClipboard *clipboard)
{
  GtkClipboardClearFunc old_clear_func;
  gpointer old_data;
  
  old_clear_func = clipboard->clear_func;
  old_data = clipboard->user_data;
	  
  if (clipboard->have_owner)
    {
      clipboard_remove_owner_notify (clipboard);
      clipboard->have_owner = FALSE;
    }
  
  clipboard->get_func = NULL;
  clipboard->clear_func = NULL;
  clipboard->user_data = NULL;
  
  if (old_clear_func)
    old_clear_func (clipboard, old_data);
}

/**
 * gtk_clipboard_clear:
 * @clipboard:  a #GtkClipboard
 * 
610
 * Clears the contents of the clipboard. Generally this should only
611 612
 * be called between the time you call gtk_clipboard_set_with_owner()
 * or gtk_clipboard_set_with_data(),
613 614 615 616 617 618 619 620 621
 * and when the @clear_func you supplied is called. Otherwise, the
 * clipboard may be owned by someone else.
 **/
void
gtk_clipboard_clear (GtkClipboard *clipboard)
{
  g_return_if_fail (clipboard != NULL);

  if (clipboard->have_selection)
622 623 624 625
    gtk_selection_owner_set_for_display (clipboard->display, 
					 NULL,
					 clipboard->selection,
					 clipboard_get_timestamp (clipboard));
626 627
}

Havoc Pennington's avatar
Havoc Pennington committed
628
static void 
629 630 631 632 633
text_get_func (GtkClipboard     *clipboard,
	       GtkSelectionData *selection_data,
	       guint             info,
	       gpointer          data)
{
634
  gtk_selection_data_set_text (selection_data, data, -1);
635 636
}

Havoc Pennington's avatar
Havoc Pennington committed
637
static void 
638 639 640 641 642 643 644 645 646 647 648
text_clear_func (GtkClipboard *clipboard,
		 gpointer      data)
{
  g_free (data);
}

/**
 * gtk_clipboard_set_text:
 * @clipboard: a #GtkClipboard object
 * @text:      a UTF-8 string.
 * @len:       length of @text, in bytes, or -1, in which case
Matthias Clasen's avatar
Matthias Clasen committed
649
 *             the length will be determined with <function>strlen()</function>.
650
 * 
651
 * Sets the contents of the clipboard to the given UTF-8 string. GTK+ will
652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668 669 670 671 672 673 674 675 676 677 678 679 680 681 682 683 684 685 686
 * make a copy of the text and take responsibility for responding
 * for requests for the text, and for converting the text into
 * the requested format.
 **/
void 
gtk_clipboard_set_text (GtkClipboard *clipboard,
			const gchar  *text,
			gint          len)
{
  static const GtkTargetEntry targets[] = {
    { "STRING", 0, TARGET_STRING },
    { "TEXT",   0, TARGET_TEXT }, 
    { "COMPOUND_TEXT", 0, TARGET_COMPOUND_TEXT },
    { "UTF8_STRING", 0, TARGET_UTF8_STRING }
  };

  g_return_if_fail (clipboard != NULL);
  g_return_if_fail (text != NULL);
  
  if (len < 0)
    len = strlen (text);
  
  gtk_clipboard_set_with_data (clipboard, 
			       targets, G_N_ELEMENTS (targets),
			       text_get_func, text_clear_func,
			       g_strndup (text, len));
}

static void
set_request_contents_info (GtkWidget           *widget,
			   RequestContentsInfo *info)
{
  if (!request_contents_key_id)
    request_contents_key_id = g_quark_from_static_string (request_contents_key);

Manish Singh's avatar
Manish Singh committed
687
  g_object_set_qdata (G_OBJECT (widget), request_contents_key_id, info);
688 689 690 691 692 693 694 695
}

static RequestContentsInfo *
get_request_contents_info (GtkWidget *widget)
{
  if (!request_contents_key_id)
    return NULL;
  else
Manish Singh's avatar
Manish Singh committed
696
    return g_object_get_qdata (G_OBJECT (widget), request_contents_key_id);
697 698 699 700 701 702 703 704 705 706
}

static void 
selection_received (GtkWidget            *widget,
		    GtkSelectionData     *selection_data,
		    guint                 time)
{
  RequestContentsInfo *request_info = get_request_contents_info (widget);
  set_request_contents_info (widget, NULL);
  
707
  request_info->callback (gtk_widget_get_clipboard (widget, selection_data->selection), 
708 709 710 711 712
			  selection_data,
			  request_info->user_data);

  g_free (request_info);

713
  if (widget != get_clipboard_widget (gtk_widget_get_display (widget)))
714 715 716 717 718 719 720 721 722
    gtk_widget_destroy (widget);
}

/**
 * gtk_clipboard_request_contents:
 * @clipboard: a #GtkClipboard
 * @target:    an atom representing the form into which the clipboard
 *             owner should convert the selection.
 * @callback:  A function to call when the results are received
723
 *             (or the retrieval fails). If the retrieval fails
724 725 726 727 728 729 730 731 732 733 734 735 736 737 738 739
 *             the length field of @selection_data will be
 *             negative.
 * @user_data: user data to pass to @callback
 * 
 * Requests the contents of clipboard as the given target.
 * When the results of the result are later received the supplied callback
 * will be called.
 **/
void 
gtk_clipboard_request_contents (GtkClipboard            *clipboard,
				GdkAtom                  target,
				GtkClipboardReceivedFunc callback,
				gpointer                 user_data)
{
  RequestContentsInfo *info;
  GtkWidget *widget;
740
  GtkWidget *clipboard_widget;
741 742 743 744 745

  g_return_if_fail (clipboard != NULL);
  g_return_if_fail (target != GDK_NONE);
  g_return_if_fail (callback != NULL);
  
746
  clipboard_widget = get_clipboard_widget (clipboard->display);
747 748

  if (get_request_contents_info (clipboard_widget))
749
    widget = make_clipboard_widget (clipboard->display, FALSE);
750 751 752 753 754 755 756 757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772 773 774
  else
    widget = clipboard_widget;

  info = g_new (RequestContentsInfo, 1);
  info->callback = callback;
  info->user_data = user_data;

  set_request_contents_info (widget, info);

  gtk_selection_convert (widget, clipboard->selection, target,
			 clipboard_get_timestamp (clipboard));
}

static void 
request_text_received_func (GtkClipboard     *clipboard,
			    GtkSelectionData *selection_data,
			    gpointer          data)
{
  RequestTextInfo *info = data;
  gchar *result = NULL;

  result = gtk_selection_data_get_text (selection_data);

  if (!result)
    {
775 776 777
      /* If we asked for UTF8 and didn't get it, try compound_text;
       * if we asked for compound_text and didn't get it, try string;
       * If we asked for anything else and didn't get it, give up.
778 779 780 781
       */
      if (selection_data->target == gdk_atom_intern ("UTF8_STRING", FALSE))
	{
	  gtk_clipboard_request_contents (clipboard,
782
					  gdk_atom_intern ("COMPOUND_TEXT", FALSE), 
783 784 785
					  request_text_received_func, info);
	  return;
	}
786
      else if (selection_data->target == gdk_atom_intern ("COMPOUND_TEXT", FALSE))
787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816 817 818 819 820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846 847 848 849 850 851 852
	{
	  gtk_clipboard_request_contents (clipboard,
					  GDK_TARGET_STRING, 
					  request_text_received_func, info);
	  return;
	}
    }

  info->callback (clipboard, result, info->user_data);
  g_free (info);
  g_free (result);
}

/**
 * gtk_clipboard_request_text:
 * @clipboard: a #GtkClipboard
 * @callback:  a function to call when the text is received,
 *             or the retrieval fails. (It will always be called
 *             one way or the other.)
 * @user_data: user data to pass to @callback.
 * 
 * Requests the contents of the clipboard as text. When the text is
 * later received, it will be converted to UTF-8 if necessary, and
 * @callback will be called. 
 *
 * The @text parameter to @callback will contain the resulting text if
 * the request succeeded, or %NULL if it failed. This could happen for
 * various reasons, in particular if the clipboard was empty or if the
 * contents of the clipboard could not be converted into text form.
 **/
void 
gtk_clipboard_request_text (GtkClipboard                *clipboard,
			    GtkClipboardTextReceivedFunc callback,
			    gpointer                     user_data)
{
  RequestTextInfo *info;
  
  g_return_if_fail (clipboard != NULL);
  g_return_if_fail (callback != NULL);
  
  info = g_new (RequestTextInfo, 1);
  info->callback = callback;
  info->user_data = user_data;

  gtk_clipboard_request_contents (clipboard, gdk_atom_intern ("UTF8_STRING", FALSE),
				  request_text_received_func,
				  info);
}


typedef struct
{
  GMainLoop *loop;
  gpointer data;
} WaitResults;

static void 
clipboard_received_func (GtkClipboard     *clipboard,
			 GtkSelectionData *selection_data,
			 gpointer          data)
{
  WaitResults *results = data;

  if (selection_data->length >= 0)
    results->data = gtk_selection_data_copy (selection_data);
  
Manish Singh's avatar
Manish Singh committed
853
  g_main_loop_quit (results->loop);
854 855 856 857 858 859 860 861 862 863 864 865
}

/**
 * gtk_clipboard_wait_for_contents:
 * @clipboard: a #GtkClipboard
 * @target: an atom representing the form into which the clipboard
 *          owner should convert the selection.
 * 
 * Requests the contents of the clipboard using the given target.
 * This function waits for the data to be received using the main 
 * loop, so events, timeouts, etc, may be dispatched during the wait.
 * 
Matthias Clasen's avatar
Matthias Clasen committed
866
 * Return value: a newly-allocated #GtkSelectionData object or %NULL
867
 *               if retrieving the given target failed. If non-%NULL,
Matthias Clasen's avatar
Matthias Clasen committed
868 869
 *               this value must be freed with gtk_selection_data_free() 
 *               when you are finished with it.
870 871 872 873 874 875 876 877 878 879 880
 **/
GtkSelectionData *
gtk_clipboard_wait_for_contents (GtkClipboard *clipboard,
				 GdkAtom       target)
{
  WaitResults results;

  g_return_val_if_fail (clipboard != NULL, NULL);
  g_return_val_if_fail (target != GDK_NONE, NULL);
  
  results.data = NULL;
Manish Singh's avatar
Manish Singh committed
881
  results.loop = g_main_loop_new (NULL, TRUE);
882 883 884 885 886

  gtk_clipboard_request_contents (clipboard, target, 
				  clipboard_received_func,
				  &results);

Manish Singh's avatar
Manish Singh committed
887
  if (g_main_loop_is_running (results.loop))
888 889
    {
      GDK_THREADS_LEAVE ();
Manish Singh's avatar
Manish Singh committed
890
      g_main_loop_run (results.loop);
891 892
      GDK_THREADS_ENTER ();
    }
893

Manish Singh's avatar
Manish Singh committed
894
  g_main_loop_unref (results.loop);
895 896 897 898 899 900 901 902 903 904 905 906

  return results.data;
}

static void 
clipboard_text_received_func (GtkClipboard *clipboard,
			      const gchar  *text,
			      gpointer      data)
{
  WaitResults *results = data;

  results->data = g_strdup (text);
Manish Singh's avatar
Manish Singh committed
907
  g_main_loop_quit (results->loop);
908 909 910 911 912 913 914 915 916 917 918 919
}


/**
 * gtk_clipboard_wait_for_text:
 * @clipboard: a #GtkClipboard
 * 
 * Requests the contents of the clipboard as text and converts
 * the result to UTF-8 if necessary. This function waits for
 * the data to be received using the main loop, so events,
 * timeouts, etc, may be dispatched during the wait.
 * 
920
 * Return value: a newly-allocated UTF-8 string which must
921 922 923 924 925 926 927 928 929 930 931 932 933 934 935
 *               be freed with g_free(), or %NULL if retrieving
 *               the selection data failed. (This could happen
 *               for various reasons, in particular if the
 *               clipboard was empty or if the contents of the
 *               clipboard could not be converted into text form.)
 **/
gchar *
gtk_clipboard_wait_for_text (GtkClipboard *clipboard)
{
  WaitResults results;

  g_return_val_if_fail (clipboard != NULL, NULL);
  g_return_val_if_fail (clipboard != NULL, NULL);
  
  results.data = NULL;
Manish Singh's avatar
Manish Singh committed
936
  results.loop = g_main_loop_new (NULL, TRUE);
937 938 939 940 941

  gtk_clipboard_request_text (clipboard,
			      clipboard_text_received_func,
			      &results);

Manish Singh's avatar
Manish Singh committed
942
  if (g_main_loop_is_running (results.loop))
943 944
    {
      GDK_THREADS_LEAVE ();
Manish Singh's avatar
Manish Singh committed
945
      g_main_loop_run (results.loop);
946 947
      GDK_THREADS_ENTER ();
    }
948

Manish Singh's avatar
Manish Singh committed
949
  g_main_loop_unref (results.loop);
950 951 952

  return results.data;
}
953 954 955 956 957 958 959
/**
 * gtk_clipboard_get_display:
 * @clipboard: a #GtkClipboard
 *
 * Gets the #GdkDisplay associated with @clipboard
 *
 * Return value: the #GdkDisplay associated with @clipboard
960 961
 *
 * Since: 2.2
962 963 964 965 966 967 968 969
 **/
GdkDisplay *
gtk_clipboard_get_display (GtkClipboard *clipboard)
{
  g_return_val_if_fail (clipboard != NULL, NULL);

  return clipboard->display;
}
970

971 972 973 974 975 976 977 978 979 980 981 982 983 984 985 986 987 988 989 990 991 992 993 994 995 996 997 998 999 1000 1001 1002
/**
 * gtk_clipboard_wait_is_text_available:
 * @clipboard: a #GtkClipboard
 * 
 * Test to see if there is text available to be pasted
 * This is done by requesting the TARGETS atom and checking
 * if it contains any of the names: STRING, TEXT, COMPOUND_TEXT,
 * UTF8_STRING. This function waits for the data to be received
 * using the main loop, so events, timeouts, etc, may be dispatched
 * during the wait.
 *
 * This function is a little faster than calling
 * gtk_clipboard_wait_for_text() since it doesn't need to retrieve
 * the actual text.
 * 
 * Return value: %TRUE is there is text available, %FALSE otherwise.
 **/
gboolean
gtk_clipboard_wait_is_text_available (GtkClipboard *clipboard)
{
  GtkSelectionData *data;
  gboolean result = FALSE;

  data = gtk_clipboard_wait_for_contents (clipboard, gdk_atom_intern ("TARGETS", FALSE));
  if (data)
    {
      result = gtk_selection_data_targets_include_text (data);
      gtk_selection_data_free (data);
    }

  return result;
}