/* GTK - The GIMP Toolkit

 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald

 *

 * 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.

 */

/* This file implements most of the work of the ICCCM selection protocol.

 * The code was written after an intensive study of the equivalent part

 * of John Ousterhout's Tk toolkit, and does many things in much the 

 * same way.

 *

 * The one thing in the ICCCM that isn't fully supported here (or in Tk)

 * is side effects targets. For these to be handled properly, MULTIPLE

 * targets need to be done in the order specified. This cannot be

 * guaranteed with the way we do things, since if we are doing INCR

 * transfers, the order will depend on the timing of the requestor.

 *

 * By Owen Taylor <owt1@cornell.edu>	      8/16/97

 */

/* Terminology note: when not otherwise specified, the term "incr" below

 * refers to the _sending_ part of the INCR protocol. The receiving

 * portion is referred to just as "retrieval". (Terminology borrowed

 * from Tk, because there is no good opposite to "retrieval" in English.

 * "send" can't be made into a noun gracefully and we're already using

 * "emission" for something else ....)

 */

/* The MOTIF entry widget seems to ask for the TARGETS target, then

   (regardless of the reply) ask for the TEXT target. It's slightly

   possible though that it somehow thinks we are responding negatively

   to the TARGETS request, though I don't really think so ... */

/*

 * Modified by the GTK+ Team and others 1997-2000.  See the AUTHORS

 * file for a list of people on the GTK+ Team.  See the ChangeLog

 * files for a list of changes.  These files are distributed with

 * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 

 */

#include "config.h"

#include <stdarg.h>

#include <string.h>

#include "gdk.h"

#include "gtkmain.h"

#include "gtkselection.h"

#include "gtktextbufferrichtext.h"

#include "gtkintl.h"

#include "gdk-pixbuf/gdk-pixbuf.h"

#ifdef GDK_WINDOWING_X11

#include "x11/gdkx.h"

#endif

#ifdef GDK_WINDOWING_WIN32

#include "win32/gdkwin32.h"

#endif

#include "gtkalias.h"

#undef DEBUG_SELECTION

/* Maximum size of a sent chunk, in bytes. Also the default size of

   our buffers */

#ifdef GDK_WINDOWING_X11

#define GTK_SELECTION_MAX_SIZE(display)                                 \

  MIN(262144,                                                           \

      XExtendedMaxRequestSize (GDK_DISPLAY_XDISPLAY (display)) == 0     \

       ? XMaxRequestSize (GDK_DISPLAY_XDISPLAY (display)) - 100         \

       : XExtendedMaxRequestSize (GDK_DISPLAY_XDISPLAY (display)) - 100)

#else

/* No chunks on Win32 */

#define GTK_SELECTION_MAX_SIZE(display) G_MAXINT

#endif

#define IDLE_ABORT_TIME 30

enum {

  INCR,

  MULTIPLE,

  TARGETS,

  TIMESTAMP,

  SAVE_TARGETS,

  LAST_ATOM

};

typedef struct _GtkSelectionInfo GtkSelectionInfo;

typedef struct _GtkIncrConversion GtkIncrConversion;

typedef struct _GtkIncrInfo GtkIncrInfo;

typedef struct _GtkRetrievalInfo GtkRetrievalInfo;

struct _GtkSelectionInfo

{

  GdkAtom	 selection;

  GtkWidget	*widget;	/* widget that owns selection */

  guint32	 time;		/* time used to acquire selection */

  GdkDisplay	*display;	/* needed in gtk_selection_remove_all */    

};

struct _GtkIncrConversion 

{

  GdkAtom	    target;	/* Requested target */

  GdkAtom	    property;	/* Property to store in */

  GtkSelectionData  data;	/* The data being supplied */

  gint		    offset;	/* Current offset in sent selection.

				 *  -1 => All done

				 *  -2 => Only the final (empty) portion

				 *	  left to send */

};

struct _GtkIncrInfo

{

  GdkWindow *requestor;		/* Requestor window - we create a GdkWindow

				   so we can receive events */

  GdkAtom    selection;		/* Selection we're sending */

  GtkIncrConversion *conversions; /* Information about requested conversions -

				   * With MULTIPLE requests (benighted 1980's

				   * hardware idea), there can be more than

				   * one */

  gint num_conversions;

  gint num_incrs;		/* number of remaining INCR style transactions */

  guint32 idle_time;

};

struct _GtkRetrievalInfo

{

  GtkWidget *widget;

  GdkAtom selection;		/* Selection being retrieved. */

  GdkAtom target;		/* Form of selection that we requested */

  guint32 idle_time;		/* Number of seconds since we last heard

				   from selection owner */

  guchar   *buffer;		/* Buffer in which to accumulate results */

  gint	   offset;		/* Current offset in buffer, -1 indicates

				   not yet started */

  guint32 notify_time;		/* Timestamp from SelectionNotify */

};

/* Local Functions */

static void gtk_selection_init              (void);

static gboolean gtk_selection_incr_timeout      (GtkIncrInfo      *info);

static gboolean gtk_selection_retrieval_timeout (GtkRetrievalInfo *info);

static void gtk_selection_retrieval_report  (GtkRetrievalInfo *info,

					     GdkAtom           type,

					     gint              format,

					     guchar           *buffer,

					     gint              length,

					     guint32           time);

static void gtk_selection_invoke_handler    (GtkWidget        *widget,

					     GtkSelectionData *data,

					     guint             time);

static void gtk_selection_default_handler   (GtkWidget        *widget,

					     GtkSelectionData *data);

static int  gtk_selection_bytes_per_item    (gint              format);

/* Local Data */

static gint initialize = TRUE;

static GList *current_retrievals = NULL;

static GList *current_incrs = NULL;

static GList *current_selections = NULL;

static GdkAtom gtk_selection_atoms[LAST_ATOM];

static const char gtk_selection_handler_key[] = "gtk-selection-handlers";

/****************

 * Target Lists *

 ****************/

/*

 * Target lists

 */

/**

 * gtk_target_list_new:

 * @targets: (array length=ntargets): Pointer to an array of #GtkTargetEntry

 * @ntargets: number of entries in @targets.

 * 

 * Creates a new #GtkTargetList from an array of #GtkTargetEntry.

 * 

 * Return value: (transfer full): the new #GtkTargetList.

 **/

GtkTargetList *

gtk_target_list_new (const GtkTargetEntry *targets,

		     guint                 ntargets)

{

  GtkTargetList *result = g_slice_new (GtkTargetList);

  result->list = NULL;

  result->ref_count = 1;

  if (targets)

    gtk_target_list_add_table (result, targets, ntargets);

  return result;

}

/**

 * gtk_target_list_ref:

 * @list:  a #GtkTargetList

 * 

 * Increases the reference count of a #GtkTargetList by one.

 *

 * Return value: the passed in #GtkTargetList.

 **/

GtkTargetList *

gtk_target_list_ref (GtkTargetList *list)

{

  g_return_val_if_fail (list != NULL, NULL);

  list->ref_count++;

  return list;

}

/**

 * gtk_target_list_unref:

 * @list: a #GtkTargetList

 * 

 * Decreases the reference count of a #GtkTargetList by one.

 * If the resulting reference count is zero, frees the list.

 **/

void               

gtk_target_list_unref (GtkTargetList *list)

{

  g_return_if_fail (list != NULL);

  g_return_if_fail (list->ref_count > 0);

  list->ref_count--;

  if (list->ref_count == 0)

    {

      GList *tmp_list = list->list;

      while (tmp_list)

	{

	  GtkTargetPair *pair = tmp_list->data;

	  g_slice_free (GtkTargetPair, pair);

	  tmp_list = tmp_list->next;

	}

      g_list_free (list->list);

      g_slice_free (GtkTargetList, list);

    }

}

/**

 * gtk_target_list_add:

 * @list:  a #GtkTargetList

 * @target: the interned atom representing the target

 * @flags: the flags for this target

 * @info: an ID that will be passed back to the application

 * 

 * Appends another target to a #GtkTargetList.

 **/

void 

gtk_target_list_add (GtkTargetList *list,

		     GdkAtom        target,

		     guint          flags,

		     guint          info)

{

  GtkTargetPair *pair;

  g_return_if_fail (list != NULL);

  pair = g_slice_new (GtkTargetPair);

  pair->target = target;

  pair->flags = flags;

  pair->info = info;

  list->list = g_list_append (list->list, pair);

}

static GdkAtom utf8_atom;

static GdkAtom text_atom;

static GdkAtom ctext_atom;

static GdkAtom text_plain_atom;

static GdkAtom text_plain_utf8_atom;

static GdkAtom text_plain_locale_atom;

static GdkAtom text_uri_list_atom;

static void 

init_atoms (void)

{

  gchar *tmp;

  const gchar *charset;

  if (!utf8_atom)

    {

      utf8_atom = gdk_atom_intern_static_string ("UTF8_STRING");

      text_atom = gdk_atom_intern_static_string ("TEXT");

      ctext_atom = gdk_atom_intern_static_string ("COMPOUND_TEXT");

      text_plain_atom = gdk_atom_intern_static_string ("text/plain");

      text_plain_utf8_atom = gdk_atom_intern_static_string ("text/plain;charset=utf-8");

      g_get_charset (&charset);

      tmp = g_strdup_printf ("text/plain;charset=%s", charset);

      text_plain_locale_atom = gdk_atom_intern (tmp, FALSE);

      g_free (tmp);

      text_uri_list_atom = gdk_atom_intern_static_string ("text/uri-list");

    }

}

/**

 * gtk_target_list_add_text_targets:

 * @list: a #GtkTargetList

 * @info: an ID that will be passed back to the application

 * 

 * Appends the text targets supported by #GtkSelection to

 * the target list. All targets are added with the same @info.

 * 

 * Since: 2.6

 **/

void 

gtk_target_list_add_text_targets (GtkTargetList *list,

				  guint          info)

{

  g_return_if_fail (list != NULL);

  init_atoms ();

  /* Keep in sync with gtk_selection_data_targets_include_text()

   */

  gtk_target_list_add (list, utf8_atom, 0, info);  

  gtk_target_list_add (list, ctext_atom, 0, info);  

  gtk_target_list_add (list, text_atom, 0, info);  

  gtk_target_list_add (list, GDK_TARGET_STRING, 0, info);  

  gtk_target_list_add (list, text_plain_utf8_atom, 0, info);  

  if (!g_get_charset (NULL))

    gtk_target_list_add (list, text_plain_locale_atom, 0, info);  

  gtk_target_list_add (list, text_plain_atom, 0, info);  

}

/**

 * gtk_target_list_add_rich_text_targets:

 * @list: a #GtkTargetList

 * @info: an ID that will be passed back to the application

 * @deserializable: if %TRUE, then deserializable rich text formats

 *                  will be added, serializable formats otherwise.

 * @buffer: a #GtkTextBuffer.

 *

 * Appends the rich text targets registered with

 * gtk_text_buffer_register_serialize_format() or

 * gtk_text_buffer_register_deserialize_format() to the target list. All

 * targets are added with the same @info.

 *

 * Since: 2.10

 **/

void

gtk_target_list_add_rich_text_targets (GtkTargetList  *list,

                                       guint           info,

                                       gboolean        deserializable,

                                       GtkTextBuffer  *buffer)

{

  GdkAtom *atoms;

  gint     n_atoms;

  gint     i;

  g_return_if_fail (list != NULL);

  g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));

  if (deserializable)

    atoms = gtk_text_buffer_get_deserialize_formats (buffer, &n_atoms);

  else

    atoms = gtk_text_buffer_get_serialize_formats (buffer, &n_atoms);

  for (i = 0; i < n_atoms; i++)

    gtk_target_list_add (list, atoms[i], 0, info);

  g_free (atoms);

}

/**

 * gtk_target_list_add_image_targets:

 * @list: a #GtkTargetList

 * @info: an ID that will be passed back to the application

 * @writable: whether to add only targets for which GTK+ knows

 *   how to convert a pixbuf into the format

 * 

 * Appends the image targets supported by #GtkSelection to

 * the target list. All targets are added with the same @info.

 * 

 * Since: 2.6

 **/

void 

gtk_target_list_add_image_targets (GtkTargetList *list,

				   guint          info,

				   gboolean       writable)

{

  GSList *formats, *f;

  gchar **mimes, **m;

  GdkAtom atom;

  g_return_if_fail (list != NULL);

  formats = gdk_pixbuf_get_formats ();

  /* Make sure png comes first */

  for (f = formats; f; f = f->next)

    {

      GdkPixbufFormat *fmt = f->data;

      gchar *name; 

      name = gdk_pixbuf_format_get_name (fmt);

      if (strcmp (name, "png") == 0)

	{

	  formats = g_slist_delete_link (formats, f);

	  formats = g_slist_prepend (formats, fmt);

	  g_free (name);

	  break;

	}

      g_free (name);

    }  

  for (f = formats; f; f = f->next)

    {

      GdkPixbufFormat *fmt = f->data;

      if (writable && !gdk_pixbuf_format_is_writable (fmt))

	continue;

      mimes = gdk_pixbuf_format_get_mime_types (fmt);

      for (m = mimes; *m; m++)

	{

	  atom = gdk_atom_intern (*m, FALSE);

	  gtk_target_list_add (list, atom, 0, info);  

	}

      g_strfreev (mimes);

    }

  g_slist_free (formats);

}

/**

 * gtk_target_list_add_uri_targets:

 * @list: a #GtkTargetList

 * @info: an ID that will be passed back to the application

 * 

 * Appends the URI targets supported by #GtkSelection to

 * the target list. All targets are added with the same @info.

 * 

 * Since: 2.6

 **/

void 

gtk_target_list_add_uri_targets (GtkTargetList *list,

				 guint          info)

{

  g_return_if_fail (list != NULL);

  init_atoms ();

  gtk_target_list_add (list, text_uri_list_atom, 0, info);  

}

/**

 * gtk_target_list_add_table:

 * @list: a #GtkTargetList

 * @targets: (array length=ntargets): the table of #GtkTargetEntry

 * @ntargets: number of targets in the table

 * 

 * Prepends a table of #GtkTargetEntry to a target list.

 **/

void               

gtk_target_list_add_table (GtkTargetList        *list,

			   const GtkTargetEntry *targets,

			   guint                 ntargets)

{

  gint i;

  for (i=ntargets-1; i >= 0; i--)

    {

      GtkTargetPair *pair = g_slice_new (GtkTargetPair);

      pair->target = gdk_atom_intern (targets[i].target, FALSE);

      pair->flags = targets[i].flags;

      pair->info = targets[i].info;

      list->list = g_list_prepend (list->list, pair);

    }

}

/**

 * gtk_target_list_remove:

 * @list: a #GtkTargetList

 * @target: the interned atom representing the target

 * 

 * Removes a target from a target list.

 **/

void 

gtk_target_list_remove (GtkTargetList *list,

			GdkAtom            target)

{

  GList *tmp_list;

  g_return_if_fail (list != NULL);

  tmp_list = list->list;

  while (tmp_list)

    {

      GtkTargetPair *pair = tmp_list->data;

      if (pair->target == target)

	{

	  g_slice_free (GtkTargetPair, pair);

	  list->list = g_list_remove_link (list->list, tmp_list);

	  g_list_free_1 (tmp_list);

	  return;

	}

      tmp_list = tmp_list->next;

    }

}

/**

 * gtk_target_list_find:

 * @list: a #GtkTargetList

 * @target: an interned atom representing the target to search for

 * @info: a pointer to the location to store application info for target,

 *        or %NULL

 *

 * Looks up a given target in a #GtkTargetList.

 *

 * Return value: %TRUE if the target was found, otherwise %FALSE

 **/

gboolean

gtk_target_list_find (GtkTargetList *list,

		      GdkAtom        target,

		      guint         *info)

{

  GList *tmp_list;

  g_return_val_if_fail (list != NULL, FALSE);

  tmp_list = list->list;

  while (tmp_list)

    {

      GtkTargetPair *pair = tmp_list->data;

      if (pair->target == target)

	{

          if (info)

            *info = pair->info;

	  return TRUE;

	}

      tmp_list = tmp_list->next;

    }

  return FALSE;

}

/**

 * gtk_target_table_new_from_list:

 * @list: a #GtkTargetList

 * @n_targets: return location for the number ot targets in the table

 *

 * This function creates an #GtkTargetEntry array that contains the

 * same targets as the passed %list. The returned table is newly

 * allocated and should be freed using gtk_target_table_free() when no

 * longer needed.

 *

 * Return value: (array length=n_targets) (transfer full): the new table.

 *

 * Since: 2.10

 **/

GtkTargetEntry *

gtk_target_table_new_from_list (GtkTargetList *list,

                                gint          *n_targets)

{

  GtkTargetEntry *targets;

  GList          *tmp_list;

  gint            i;

  g_return_val_if_fail (list != NULL, NULL);

  g_return_val_if_fail (n_targets != NULL, NULL);

  *n_targets = g_list_length (list->list);

  targets = g_new0 (GtkTargetEntry, *n_targets);

  for (i = 0, tmp_list = list->list;

       i < *n_targets;

       i++, tmp_list = g_list_next (tmp_list))

    {

      GtkTargetPair *pair = tmp_list->data;

      targets[i].target = gdk_atom_name (pair->target);

      targets[i].flags  = pair->flags;

      targets[i].info   = pair->info;

    }

  return targets;

}

/**

 * gtk_target_table_free:

 * @targets: (array length=n_targets): a #GtkTargetEntry array

 * @n_targets: the number of entries in the array

 *

 * This function frees a target table as returned by

 * gtk_target_table_new_from_list()

 *

 * Since: 2.10

 **/

void

gtk_target_table_free (GtkTargetEntry *targets,

                       gint            n_targets)

{

  gint i;

  g_return_if_fail (targets == NULL || n_targets > 0);

  for (i = 0; i < n_targets; i++)

    g_free (targets[i].target);

  g_free (targets);

}

/**

 * gtk_selection_owner_set_for_display:

 * @display: the #Gdkdisplay where the selection is set

 * @widget: (allow-none): new selection owner (a #GdkWidget), or %NULL.

 * @selection: an interned atom representing the selection to claim.

 * @time_: timestamp with which to claim the selection

 *

 * Claim ownership of a given selection for a particular widget, or,

 * if @widget is %NULL, release ownership of the selection.

 *

 * Return value: TRUE if the operation succeeded 

 * 

 * Since: 2.2

 */

gboolean

gtk_selection_owner_set_for_display (GdkDisplay   *display,

				     GtkWidget    *widget,

				     GdkAtom       selection,

				     guint32       time)

{

  GList *tmp_list;

  GtkWidget *old_owner;

  GtkSelectionInfo *selection_info = NULL;

  GdkWindow *window;

  g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);

  g_return_val_if_fail (selection != GDK_NONE, FALSE);

  g_return_val_if_fail (widget == NULL || gtk_widget_get_realized (widget), FALSE);

  g_return_val_if_fail (widget == NULL || gtk_widget_get_display (widget) == display, FALSE);

  if (widget == NULL)

    window = NULL;

  else

    window = widget->window;

  tmp_list = current_selections;

  while (tmp_list)

    {

      if (((GtkSelectionInfo *)tmp_list->data)->selection == selection)

	{

	  selection_info = tmp_list->data;

	  break;

	}

      tmp_list = tmp_list->next;

    }

  if (gdk_selection_owner_set_for_display (display, window, selection, time, TRUE))

    {

      old_owner = NULL;

      if (widget == NULL)

	{

	  if (selection_info)

	    {

	      old_owner = selection_info->widget;

	      current_selections = g_list_remove_link (current_selections,

						       tmp_list);

	      g_list_free (tmp_list);

	      g_slice_free (GtkSelectionInfo, selection_info);

	    }

	}

      else

	{

	  if (selection_info == NULL)

	    {

	      selection_info = g_slice_new (GtkSelectionInfo);

	      selection_info->selection = selection;

	      selection_info->widget = widget;

	      selection_info->time = time;

	      selection_info->display = display;

	      current_selections = g_list_prepend (current_selections,

						   selection_info);

	    }

	  else

	    {

	      old_owner = selection_info->widget;

	      selection_info->widget = widget;

	      selection_info->time = time;

	      selection_info->display = display;

	    }

	}

      /* If another widget in the application lost the selection,

       *  send it a GDK_SELECTION_CLEAR event.

       */

      if (old_owner && old_owner != widget)

	{

	  GdkEvent *event = gdk_event_new (GDK_SELECTION_CLEAR);

	  event->selection.window = g_object_ref (old_owner->window);

	  event->selection.selection = selection;

	  event->selection.time = time;

	  gtk_widget_event (old_owner, event);

	  gdk_event_free (event);

	}

      return TRUE;

    }

  else

    return FALSE;

}

/**

 * gtk_selection_owner_set:

 * @widget: (allow-none):  a #GtkWidget, or %NULL.

 * @selection:  an interned atom representing the selection to claim

 * @time_: timestamp with which to claim the selection

 * 

 * Claims ownership of a given selection for a particular widget,

 * or, if @widget is %NULL, release ownership of the selection.

 * 

 * Return value: %TRUE if the operation succeeded

 **/

gboolean

gtk_selection_owner_set (GtkWidget *widget,

			 GdkAtom    selection,

			 guint32    time)

{

  GdkDisplay *display;

  g_return_val_if_fail (widget == NULL || gtk_widget_get_realized (widget), FALSE);

  g_return_val_if_fail (selection != GDK_NONE, FALSE);

  if (widget)

    display = gtk_widget_get_display (widget);

  else

    {

      GTK_NOTE (MULTIHEAD,

		g_warning ("gtk_selection_owner_set (NULL,...) is not multihead safe"));

      display = gdk_display_get_default ();

    }

  return gtk_selection_owner_set_for_display (display, widget,

					      selection, time);

}

typedef struct _GtkSelectionTargetList GtkSelectionTargetList;

struct _GtkSelectionTargetList {

  GdkAtom selection;

  GtkTargetList *list;

};

static GtkTargetList *

gtk_selection_target_list_get (GtkWidget    *widget,

			       GdkAtom       selection)

{

  GtkSelectionTargetList *sellist;

  GList *tmp_list;

  GList *lists;

  lists = g_object_get_data (G_OBJECT (widget), gtk_selection_handler_key);

  tmp_list = lists;

  while (tmp_list)

    {

      sellist = tmp_list->data;

      if (sellist->selection == selection)

	return sellist->list;

      tmp_list = tmp_list->next;

    }

  sellist = g_slice_new (GtkSelectionTargetList);

  sellist->selection = selection;

  sellist->list = gtk_target_list_new (NULL, 0);

  lists = g_list_prepend (lists, sellist);

  g_object_set_data (G_OBJECT (widget), I_(gtk_selection_handler_key), lists);

  return sellist->list;

}

static void

gtk_selection_target_list_remove (GtkWidget    *widget)

{

  GtkSelectionTargetList *sellist;

  GList *tmp_list;

  GList *lists;

  lists = g_object_get_data (G_OBJECT (widget), gtk_selection_handler_key);

  tmp_list = lists;

  while (tmp_list)

    {

      sellist = tmp_list->data;

      gtk_target_list_unref (sellist->list);

      g_slice_free (GtkSelectionTargetList, sellist);

      tmp_list = tmp_list->next;

    }

  g_list_free (lists);

  g_object_set_data (G_OBJECT (widget), I_(gtk_selection_handler_key), NULL);

}

/**

 * gtk_selection_clear_targets:

 * @widget:    a #GtkWidget

 * @selection: an atom representing a selection

 *

 * Remove all targets registered for the given selection for the

 * widget.

 **/

void 

gtk_selection_clear_targets (GtkWidget *widget,

			     GdkAtom    selection)

{

  GtkSelectionTargetList *sellist;

  GList *tmp_list;

  GList *lists;

  g_return_if_fail (GTK_IS_WIDGET (widget));

  g_return_if_fail (selection != GDK_NONE);

  lists = g_object_get_data (G_OBJECT (widget), gtk_selection_handler_key);

  tmp_list = lists;

  while (tmp_list)

    {

      sellist = tmp_list->data;

      if (sellist->selection == selection)

	{

	  lists = g_list_delete_link (lists, tmp_list);

	  gtk_target_list_unref (sellist->list);

	  g_slice_free (GtkSelectionTargetList, sellist);

	  break;

	}

      tmp_list = tmp_list->next;

    }

  g_object_set_data (G_OBJECT (widget), I_(gtk_selection_handler_key), lists);

}

/**

 * gtk_selection_add_target:

 * @widget:  a #GtkTarget

 * @selection: the selection

 * @target: target to add.

 * @info: A unsigned integer which will be passed back to the application.

 *