X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkselection.c;h=67a774f7683107abffe95c8d9a9ddef0e1b6f7f7;hb=aaedf5a35219b034a244730564b8fdf2b7d32540;hp=8adffcb6136059163b8a8c6f4cbd145164a8ac8d;hpb=0e072ea8be69ca7a0d097b2fdca46ba4045a8d43;p=~andy%2Fgtk

diff --git a/gtk/gtkselection.c b/gtk/gtkselection.c
index 8adffcb61..67a774f76 100644
--- a/gtk/gtkselection.c
+++ b/gtk/gtkselection.c
@@ -12,9 +12,7 @@
  * 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.
+ * License along with this library. If not, see <http://www.gnu.org/licenses/>.
  */
 
 /* This file implements most of the work of the ICCCM selection protocol.
@@ -51,13 +49,43 @@
  * GTK+ at ftp://ftp.gtk.org/pub/gtk/. 
  */
 
-#include <config.h>
+/**
+ * SECTION:gtkselection
+ * @Title: Selections
+ * @Short_description: Functions for handling inter-process communication
+ *     via selections
+ * @See_also: #GtkWidget - Much of the operation of selections happens via
+ *     signals for #GtkWidget. In particular, if you are using the functions
+ *     in this section, you may need to pay attention to
+ *     #GtkWidget::selection-get, #GtkWidget::selection-received and
+ *     #GtkWidget::selection-clear-event signals
+ *
+ * The selection mechanism provides the basis for different types
+ * of communication between processes. In particular, drag and drop and
+ * #GtkClipboard work via selections. You will very seldom or
+ * never need to use most of the functions in this section directly;
+ * #GtkClipboard provides a nicer interface to the same functionality.
+ *
+ * Some of the datatypes defined this section are used in
+ * the #GtkClipboard and drag-and-drop API's as well. The
+ * #GtkTargetEntry structure and #GtkTargetList objects represent
+ * lists of data types that are supported when sending or
+ * receiving data. The #GtkSelectionData object is used to
+ * store a chunk of data along with the data type and other
+ * associated information.
+ */
+
+#include "config.h"
+
+#include "gtkselection.h"
+#include "gtkselectionprivate.h"
+
 #include <stdarg.h>
 #include <string.h>
 #include "gdk.h"
 
 #include "gtkmain.h"
-#include "gtkselection.h"
+#include "gtkdebug.h"
 #include "gtktextbufferrichtext.h"
 #include "gtkintl.h"
 #include "gdk-pixbuf/gdk-pixbuf.h"
@@ -70,8 +98,6 @@
 #include "win32/gdkwin32.h"
 #endif
 
-#include "gtkalias.h"
-
 #undef DEBUG_SELECTION
 
 /* Maximum size of a sent chunk, in bytes. Also the default size of
@@ -94,6 +120,7 @@ enum {
   MULTIPLE,
   TARGETS,
   TIMESTAMP,
+  SAVE_TARGETS,
   LAST_ATOM
 };
 
@@ -187,12 +214,12 @@ static const char gtk_selection_handler_key[] = "gtk-selection-handlers";
 
 /**
  * gtk_target_list_new:
- * @targets: Pointer to an array of #GtkTargetEntry
- * @ntargets:  number of entries in @targets.
+ * @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: the new #GtkTargetList.
+ * Return value: (transfer full): the new #GtkTargetList.
  **/
 GtkTargetList *
 gtk_target_list_new (const GtkTargetEntry *targets,
@@ -470,7 +497,7 @@ gtk_target_list_add_uri_targets (GtkTargetList *list,
 /**
  * gtk_target_list_add_table:
  * @list: a #GtkTargetList
- * @targets: the table of #GtkTargetEntry
+ * @targets: (array length=ntargets): the table of #GtkTargetEntry
  * @ntargets: number of targets in the table
  * 
  * Prepends a table of #GtkTargetEntry to a target list.
@@ -569,14 +596,14 @@ gtk_target_list_find (GtkTargetList *list,
 /**
  * gtk_target_table_new_from_list:
  * @list: a #GtkTargetList
- * @n_targets: return location for the number ot targets in the table
+ * @n_targets: (out): 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: the new table.
+ * Return value: (array length=n_targets) (transfer full): the new table.
  *
  * Since: 2.10
  **/
@@ -610,7 +637,7 @@ gtk_target_table_new_from_list (GtkTargetList *list,
 
 /**
  * gtk_target_table_free:
- * @targets: a #GtkTargetEntry array
+ * @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
@@ -634,8 +661,8 @@ gtk_target_table_free (GtkTargetEntry *targets,
 
 /**
  * gtk_selection_owner_set_for_display:
- * @display: the #Gdkdisplay where the selection is set 
- * @widget: new selection owner (a #GdkWidget), or %NULL.
+ * @display: the #GdkDisplay where the selection is set
+ * @widget: (allow-none): new selection owner (a #GtkWidget), or %NULL.
  * @selection: an interned atom representing the selection to claim.
  * @time_: timestamp with which to claim the selection
  *
@@ -659,13 +686,13 @@ gtk_selection_owner_set_for_display (GdkDisplay   *display,
 
   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_REALIZED (widget), 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;
+    window = gtk_widget_get_window (widget);
 
   tmp_list = current_selections;
   while (tmp_list)
@@ -720,8 +747,8 @@ gtk_selection_owner_set_for_display (GdkDisplay   *display,
       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.window = g_object_ref (gtk_widget_get_window (old_owner));
 	  event->selection.selection = selection;
 	  event->selection.time = time;
 	  
@@ -737,7 +764,7 @@ gtk_selection_owner_set_for_display (GdkDisplay   *display,
 
 /**
  * gtk_selection_owner_set:
- * @widget:  a #GtkWidget, or %NULL.
+ * @widget: (allow-none):  a #GtkWidget, or %NULL.
  * @selection:  an interned atom representing the selection to claim
  * @time_: timestamp with which to claim the selection
  * 
@@ -753,7 +780,7 @@ gtk_selection_owner_set (GtkWidget *widget,
 {
   GdkDisplay *display;
   
-  g_return_val_if_fail (widget == NULL || GTK_WIDGET_REALIZED (widget), FALSE);
+  g_return_val_if_fail (widget == NULL || gtk_widget_get_realized (widget), FALSE);
   g_return_val_if_fail (selection != GDK_NONE, FALSE);
 
   if (widget)
@@ -894,7 +921,7 @@ gtk_selection_add_target (GtkWidget	    *widget,
   list = gtk_selection_target_list_get (widget, selection);
   gtk_target_list_add (list, target, 0, info);
 #ifdef GDK_WINDOWING_WIN32
-  gdk_win32_selection_add_targets (widget->window, selection, 1, &target);
+  gdk_win32_selection_add_targets (gtk_widget_get_window (widget), selection, 1, &target);
 #endif
 }
 
@@ -902,7 +929,7 @@ gtk_selection_add_target (GtkWidget	    *widget,
  * gtk_selection_add_targets:
  * @widget: a #GtkWidget
  * @selection: the selection
- * @targets: a table of targets to add
+ * @targets: (array length=ntargets): a table of targets to add
  * @ntargets:  number of entries in @targets
  * 
  * Prepends a table of targets to the list of supported targets
@@ -930,7 +957,7 @@ gtk_selection_add_targets (GtkWidget            *widget,
 
     for (i = 0; i < ntargets; ++i)
       atoms[i] = gdk_atom_intern (targets[i].target, FALSE);
-    gdk_win32_selection_add_targets (widget->window, selection, ntargets, atoms);
+    gdk_win32_selection_add_targets (gtk_widget_get_window (widget), selection, ntargets, atoms);
     g_free (atoms);
   }
 #endif
@@ -1008,7 +1035,7 @@ gtk_selection_remove_all (GtkWidget *widget)
        In emergency, you could use #GDK_CURRENT_TIME
  * 
  * Requests the contents of a selection. When received, 
- * a "selection_received" signal will be generated.
+ * a "selection-received" signal will be generated.
  * 
  * Return value: %TRUE if requested succeeded. %FALSE if we could not process
  *          request. (e.g., there was already a request in process for
@@ -1031,7 +1058,7 @@ gtk_selection_convert (GtkWidget *widget,
   if (initialize)
     gtk_selection_init ();
   
-  if (!GTK_WIDGET_REALIZED (widget))
+  if (!gtk_widget_get_realized (widget))
     gtk_widget_realize (widget);
   
   /* Check to see if there are already any retrievals in progress for
@@ -1067,15 +1094,16 @@ gtk_selection_convert (GtkWidget *widget,
   if (owner_window != NULL)
     {
       GtkWidget *owner_widget;
-      GtkSelectionData selection_data;
+      gpointer owner_widget_ptr;
+      GtkSelectionData selection_data = {0};
       
       selection_data.selection = selection;
       selection_data.target = target;
-      selection_data.data = NULL;
       selection_data.length = -1;
       selection_data.display = display;
       
-      gdk_window_get_user_data (owner_window, (gpointer *)&owner_widget);
+      gdk_window_get_user_data (owner_window, &owner_widget_ptr);
+      owner_widget = owner_widget_ptr;
       
       if (owner_widget != NULL)
 	{
@@ -1102,7 +1130,7 @@ gtk_selection_convert (GtkWidget *widget,
   /* Otherwise, we need to go through X */
   
   current_retrievals = g_list_append (current_retrievals, info);
-  gdk_selection_convert (widget->window, selection, target, time_);
+  gdk_selection_convert (gtk_widget_get_window (widget), selection, target, time_);
   gdk_threads_add_timeout (1000,
       (GSourceFunc) gtk_selection_retrieval_timeout, info);
   
@@ -1110,21 +1138,21 @@ gtk_selection_convert (GtkWidget *widget,
 }
 
 /**
- * gtk_selection_data_set_target:
+ * gtk_selection_data_get_selection:
  * @selection_data: a pointer to a #GtkSelectionData structure.
- * @target: target of the selection
  *
- * Sets the target of the selection.
+ * Retrieves the selection #GdkAtom of the selection data.
+ *
+ * Returns: (transfer none): the selection #GdkAtom of the selection data.
  *
- * Since: GSEAL-branch
+ * Since: 2.16
  **/
-void
-gtk_selection_data_set_target (GtkSelectionData *selection_data,
-			       GdkAtom           target)
+GdkAtom
+gtk_selection_data_get_selection (const GtkSelectionData *selection_data)
 {
-  g_return_if_fail (selection_data != NULL);
+  g_return_val_if_fail (selection_data != NULL, 0);
 
-  selection_data->target = target;
+  return selection_data->selection;
 }
 
 /**
@@ -1133,78 +1161,48 @@ gtk_selection_data_set_target (GtkSelectionData *selection_data,
  *
  * Retrieves the target of the selection.
  *
- * Since: GSEAL-branch
+ * Returns: (transfer none): the target of the selection.
+ *
+ * Since: 2.14
  **/
 GdkAtom
-gtk_selection_data_get_target (GtkSelectionData *selection_data)
+gtk_selection_data_get_target (const GtkSelectionData *selection_data)
 {
   g_return_val_if_fail (selection_data != NULL, 0);
 
   return selection_data->target;
 }
 
-/**
- * gtk_selection_data_set_data_type:
- * @selection_data: a pointer to a #GtkSelectionData structure.
- * @data_type: data type of the selection
- *
- * Sets the data type of the selection.
- *
- * Since: GSEAL-branch
- **/
-void
-gtk_selection_data_set_data_type (GtkSelectionData *selection_data,
-				  GdkAtom           data_type)
-{
-  g_return_if_fail (selection_data != NULL);
-
-  selection_data->type = data_type;
-}
-
 /**
  * gtk_selection_data_get_data_type:
  * @selection_data: a pointer to a #GtkSelectionData structure.
  *
  * Retrieves the data type of the selection.
  *
- * Since: GSEAL-branch
+ * Returns: (transfer none): the data type of the selection.
+ *
+ * Since: 2.14
  **/
 GdkAtom
-gtk_selection_data_get_data_type (GtkSelectionData *selection_data)
+gtk_selection_data_get_data_type (const GtkSelectionData *selection_data)
 {
   g_return_val_if_fail (selection_data != NULL, 0);
 
   return selection_data->type;
 }
 
-/**
- * gtk_selection_data_set_format:
- * @selection_data: a pointer to a #GtkSelectionData structure.
- * @format: format of the selection
- *
- * Sets the format of the selection.
- *
- * Since: GSEAL-branch
- **/
-void
-gtk_selection_data_set_format (GtkSelectionData *selection_data,
-			       gint              format)
-{
-  g_return_if_fail (selection_data != NULL);
-
-  selection_data->format = format;
-}
-
 /**
  * gtk_selection_data_get_format:
  * @selection_data: a pointer to a #GtkSelectionData structure.
  *
  * Retrieves the format of the selection.
  *
- * Since: GSEAL-branch
+ * Returns: the format of the selection.
+ *
+ * Since: 2.14
  **/
 gint
-gtk_selection_data_get_format (GtkSelectionData *selection_data)
+gtk_selection_data_get_format (const GtkSelectionData *selection_data)
 {
   g_return_val_if_fail (selection_data != NULL, 0);
 
@@ -1212,34 +1210,17 @@ gtk_selection_data_get_format (GtkSelectionData *selection_data)
 }
 
 /**
- * gtk_selection_data_set_data:
- * @selection_data: a pointer to a #GtkSelectionData structure.
- * @data: data of the selection
- *
- * Sets the raw data of the selection.
- *
- * Since: GSEAL-branch
- **/
-void
-gtk_selection_data_set_data (GtkSelectionData *selection_data,
-			     const guchar     *data)
-{
-  g_return_if_fail (selection_data != NULL);
-
-  g_free (selection_data->data);
-  selection_data->data = (guchar*) g_strdup (data);
-}
-
-/**
- * gtk_selection_data_get_data:
+ * gtk_selection_data_get_data: (skip)
  * @selection_data: a pointer to a #GtkSelectionData structure.
  *
  * Retrieves the raw data of the selection.
  *
- * Since: GSEAL-branch
+ * Returns: the raw data of the selection.
+ *
+ * Since: 2.14
  **/
 const guchar*
-gtk_selection_data_get_data (GtkSelectionData *selection_data)
+gtk_selection_data_get_data (const GtkSelectionData *selection_data)
 {
   g_return_val_if_fail (selection_data != NULL, NULL);
 
@@ -1247,37 +1228,44 @@ gtk_selection_data_get_data (GtkSelectionData *selection_data)
 }
 
 /**
- * gtk_selection_data_set_target:
+ * gtk_selection_data_get_length:
  * @selection_data: a pointer to a #GtkSelectionData structure.
- * @length: length of the selection
  *
- * Sets the length of the selection.
+ * Retrieves the length of the raw data of the selection.
  *
- * Since: GSEAL-branch
- **/
-void
-gtk_selection_data_set_length (GtkSelectionData *selection_data,
-			       gint             length)
+ * Returns: the length of the data of the selection.
+ *
+ * Since: 2.14
+ */
+gint
+gtk_selection_data_get_length (const GtkSelectionData *selection_data)
 {
-  g_return_if_fail (selection_data != NULL);
+  g_return_val_if_fail (selection_data != NULL, -1);
 
-  selection_data->length = length;
+  return selection_data->length;
 }
 
 /**
- * gtk_selection_data_get_length:
- * @selection_data: a pointer to a #GtkSelectionData structure.
+ * gtk_selection_data_get_data_with_length:
+ * @selection_data: a pointer to a #GtkSelectionData structure
+ * @length: (out): return location for length of the data segment
  *
- * Retrieves the length of the selection.
+ * Retrieves the raw data of the selection along with its length.
  *
- * Since: GSEAL-branch
- **/
-gint
-gtk_selection_data_get_length (GtkSelectionData *selection_data)
+ * Returns: (array length=length): the raw data of the selection
+ *
+ * Rename to: gtk_selection_data_get_data
+ * Since: 3.0
+ */
+const guchar*
+gtk_selection_data_get_data_with_length (const GtkSelectionData *selection_data,
+                                         gint                   *length)
 {
-  g_return_val_if_fail (selection_data != NULL, 0);
+  g_return_val_if_fail (selection_data != NULL, NULL);
 
-  return selection_data->length;
+  *length = selection_data->length;
+
+  return selection_data->data;
 }
 
 /**
@@ -1286,10 +1274,12 @@ gtk_selection_data_get_length (GtkSelectionData *selection_data)
  *
  * Retrieves the display of the selection.
  *
- * Since: GSEAL-branch
+ * Returns: (transfer none): the display of the selection.
+ *
+ * Since: 2.14
  **/
 GdkDisplay *
-gtk_selection_data_get_display (GtkSelectionData *selection_data)
+gtk_selection_data_get_display (const GtkSelectionData *selection_data)
 {
   g_return_val_if_fail (selection_data != NULL, NULL);
 
@@ -1301,7 +1291,7 @@ gtk_selection_data_get_display (GtkSelectionData *selection_data)
  * @selection_data: a pointer to a #GtkSelectionData structure.
  * @type: the type of selection data
  * @format: format (number of bits in a unit)
- * @data: pointer to the data (will be copied)
+ * @data: (array length=length): pointer to the data (will be copied)
  * @length: length of the data
  * 
  * Stores new data into a #GtkSelectionData object. Should
@@ -1374,18 +1364,22 @@ selection_set_compound_text (GtkSelectionData *selection_data,
   gint format;
   gint new_length;
   gboolean result = FALSE;
-  
-  tmp = g_strndup (str, len);
-  if (gdk_utf8_to_compound_text_for_display (selection_data->display, tmp,
-					     &encoding, &format, &text, &new_length))
+
+#ifdef GDK_WINDOWING_X11
+  if (GDK_IS_X11_DISPLAY (selection_data->display))
     {
-      gtk_selection_data_set (selection_data, encoding, format, text, new_length);
-      gdk_free_compound_text (text);
-      
-      result = TRUE;
-    }
+      tmp = g_strndup (str, len);
+      if (gdk_x11_display_utf8_to_compound_text (selection_data->display, tmp,
+                                                 &encoding, &format, &text, &new_length))
+        {
+          gtk_selection_data_set (selection_data, encoding, format, text, new_length);
+          gdk_x11_free_compound_text (text);
 
-  g_free (tmp);
+          result = TRUE;
+        }
+      g_free (tmp);
+    }
+#endif
 
   return result;
 }
@@ -1492,7 +1486,7 @@ selection_set_text_plain (GtkSelectionData *selection_data,
 }
 
 static guchar *
-selection_get_text_plain (GtkSelectionData *selection_data)
+selection_get_text_plain (const GtkSelectionData *selection_data)
 {
   const gchar *charset = NULL;
   gchar *str, *result;
@@ -1599,13 +1593,13 @@ gtk_selection_data_set_text (GtkSelectionData     *selection_data,
  * 
  * Gets the contents of the selection data as a UTF-8 string.
  * 
- * Return value: if the selection data contained a recognized
- *   text type and it could be converted to UTF-8, a newly allocated
- *   string containing the converted text, otherwise %NULL.
+ * Return value: (type utf8): if the selection data contained a
+ *   recognized text type and it could be converted to UTF-8, a newly
+ *   allocated string containing the converted text, otherwise %NULL.
  *   If the result is non-%NULL it must be freed with g_free().
  **/
 guchar *
-gtk_selection_data_get_text (GtkSelectionData *selection_data)
+gtk_selection_data_get_text (const GtkSelectionData *selection_data)
 {
   guchar *result = NULL;
 
@@ -1717,7 +1711,7 @@ gtk_selection_data_set_pixbuf (GtkSelectionData *selection_data,
  * 
  * Gets the contents of the selection data as a #GdkPixbuf.
  * 
- * Return value: if the selection data contained a recognized
+ * Return value: (transfer full): if the selection data contained a recognized
  *   image type and it could be converted to a #GdkPixbuf, a 
  *   newly allocated pixbuf is returned, otherwise %NULL.
  *   If the result is non-%NULL it must be freed with g_object_unref().
@@ -1725,7 +1719,7 @@ gtk_selection_data_set_pixbuf (GtkSelectionData *selection_data,
  * Since: 2.6
  **/
 GdkPixbuf *
-gtk_selection_data_get_pixbuf (GtkSelectionData *selection_data)
+gtk_selection_data_get_pixbuf (const GtkSelectionData *selection_data)
 {
   GdkPixbufLoader *loader;
   GdkPixbuf *result = NULL;
@@ -1755,7 +1749,8 @@ gtk_selection_data_get_pixbuf (GtkSelectionData *selection_data)
 /**
  * gtk_selection_data_set_uris:
  * @selection_data: a #GtkSelectionData
- * @uris: a %NULL-terminated array of strings hilding URIs
+ * @uris: (array zero-terminated=1): a %NULL-terminated array of
+ *     strings holding URIs
  * 
  * Sets the contents of the selection from a list of URIs.
  * The string is converted to the form determined by
@@ -1814,16 +1809,17 @@ gtk_selection_data_set_uris (GtkSelectionData  *selection_data,
  * @selection_data: a #GtkSelectionData
  * 
  * Gets the contents of the selection data as array of URIs.
- * 
- * Return value: if the selection data contains a list of
+ *
+ * Return value:  (array zero-terminated=1) (element-type utf8) (transfer full): if
+ *   the selection data contains a list of
  *   URIs, a newly allocated %NULL-terminated string array
- *   containing the URIs, otherwise %NULL. If the result is 
+ *   containing the URIs, otherwise %NULL. If the result is
  *   non-%NULL it must be freed with g_strfreev().
  *
  * Since: 2.6
  **/
 gchar **
-gtk_selection_data_get_uris (GtkSelectionData *selection_data)
+gtk_selection_data_get_uris (const GtkSelectionData *selection_data)
 {
   gchar **result = NULL;
 
@@ -1854,8 +1850,9 @@ gtk_selection_data_get_uris (GtkSelectionData *selection_data)
 /**
  * gtk_selection_data_get_targets:
  * @selection_data: a #GtkSelectionData object
- * @targets: location to store an array of targets. The result
- *           stored here must be freed with g_free().
+ * @targets: (out) (array length=n_atoms) (transfer container):
+ *           location to store an array of targets. The result stored
+ *           here must be freed with g_free().
  * @n_atoms: location to store number of items in @targets.
  * 
  * Gets the contents of @selection_data as an array of targets.
@@ -1867,9 +1864,9 @@ gtk_selection_data_get_uris (GtkSelectionData *selection_data)
  *    array of targets, otherwise %FALSE.
  **/
 gboolean
-gtk_selection_data_get_targets (GtkSelectionData  *selection_data,
-				GdkAtom          **targets,
-				gint              *n_atoms)
+gtk_selection_data_get_targets (const GtkSelectionData  *selection_data,
+				GdkAtom                **targets,
+				gint                    *n_atoms)
 {
   g_return_val_if_fail (selection_data != NULL, FALSE);
 
@@ -1897,7 +1894,7 @@ gtk_selection_data_get_targets (GtkSelectionData  *selection_data,
 
 /**
  * gtk_targets_include_text:
- * @targets: an array of #GdkAtom<!-- -->s
+ * @targets: (array length=n_targets): an array of #GdkAtom<!-- -->s
  * @n_targets: the length of @targets
  * 
  * Determines if any of the targets in @targets can be used to
@@ -1942,7 +1939,7 @@ gtk_targets_include_text (GdkAtom *targets,
 
 /**
  * gtk_targets_include_rich_text:
- * @targets: an array of #GdkAtom<!-- -->s
+ * @targets: (array length=n_targets): an array of #GdkAtom<!-- -->s
  * @n_targets: the length of @targets
  * @buffer: a #GtkTextBuffer
  *
@@ -2002,7 +1999,7 @@ gtk_targets_include_rich_text (GdkAtom       *targets,
  *   and a suitable target for text is included, otherwise %FALSE.
  **/
 gboolean
-gtk_selection_data_targets_include_text (GtkSelectionData *selection_data)
+gtk_selection_data_targets_include_text (const GtkSelectionData *selection_data)
 {
   GdkAtom *targets;
   gint n_targets;
@@ -2037,8 +2034,8 @@ gtk_selection_data_targets_include_text (GtkSelectionData *selection_data)
  * Since: 2.10
  **/
 gboolean
-gtk_selection_data_targets_include_rich_text (GtkSelectionData *selection_data,
-                                              GtkTextBuffer    *buffer)
+gtk_selection_data_targets_include_rich_text (const GtkSelectionData *selection_data,
+                                              GtkTextBuffer          *buffer)
 {
   GdkAtom *targets;
   gint n_targets;
@@ -2060,7 +2057,7 @@ gtk_selection_data_targets_include_rich_text (GtkSelectionData *selection_data,
 
 /**
  * gtk_targets_include_image:
- * @targets: an array of #GdkAtom<!-- -->s
+ * @targets: (array length=n_targets): an array of #GdkAtom<!-- -->s
  * @n_targets: the length of @targets
  * @writable: whether to accept only targets for which GTK+ knows
  *   how to convert a pixbuf into the format
@@ -2120,8 +2117,8 @@ gtk_targets_include_image (GdkAtom *targets,
  * Since: 2.6
  **/
 gboolean 
-gtk_selection_data_targets_include_image (GtkSelectionData *selection_data,
-					  gboolean          writable)
+gtk_selection_data_targets_include_image (const GtkSelectionData *selection_data,
+					  gboolean                writable)
 {
   GdkAtom *targets;
   gint n_targets;
@@ -2142,7 +2139,7 @@ gtk_selection_data_targets_include_image (GtkSelectionData *selection_data,
 
 /**
  * gtk_targets_include_uri:
- * @targets: an array of #GdkAtom<!-- -->s
+ * @targets: (array length=n_targets): an array of #GdkAtom<!-- -->s
  * @n_targets: the length of @targets
  * 
  * Determines if any of the targets in @targets can be used to
@@ -2193,7 +2190,7 @@ gtk_targets_include_uri (GdkAtom *targets,
  * Since: 2.10
  **/
 gboolean
-gtk_selection_data_targets_include_uri (GtkSelectionData *selection_data)
+gtk_selection_data_targets_include_uri (const GtkSelectionData *selection_data)
 {
   GdkAtom *targets;
   gint n_targets;
@@ -2228,28 +2225,23 @@ gtk_selection_init (void)
   gtk_selection_atoms[MULTIPLE] = gdk_atom_intern_static_string ("MULTIPLE");
   gtk_selection_atoms[TIMESTAMP] = gdk_atom_intern_static_string ("TIMESTAMP");
   gtk_selection_atoms[TARGETS] = gdk_atom_intern_static_string ("TARGETS");
+  gtk_selection_atoms[SAVE_TARGETS] = gdk_atom_intern_static_string ("SAVE_TARGETS");
 
   initialize = FALSE;
 }
 
 /**
- * gtk_selection_clear:
+ * _gtk_selection_clear:
  * @widget: a #GtkWidget
  * @event: the event
  * 
- * The default handler for the GtkWidget::selection_clear_event
+ * The default handler for the #GtkWidget::selection-clear-event
  * signal. 
  * 
  * Return value: %TRUE if the event was handled, otherwise false
- * 
- * Since: 2.2
- *
- * Deprecated: 2.4: Instead of calling this function, chain up from
- * your selection_clear_event handler. Calling this function
- * from any other context is illegal. 
  **/
 gboolean
-gtk_selection_clear (GtkWidget         *widget,
+_gtk_selection_clear (GtkWidget         *widget,
 		     GdkEventSelection *event)
 {
   /* Note that we filter clear events in gdkselection-x11.c, so
@@ -2326,20 +2318,12 @@ _gtk_selection_request (GtkWidget *widget,
   info = g_slice_new (GtkIncrInfo);
 
   g_object_ref (widget);
-  
+
   info->selection = event->selection;
   info->num_incrs = 0;
-  
-  /* Create GdkWindow structure for the requestor */
-  
-  info->requestor = gdk_window_lookup_for_display (display,
-						   event->requestor);
-  if (!info->requestor)
-    info->requestor = gdk_window_foreign_new_for_display (display,
-							  event->requestor);
-  
+  info->requestor = g_object_ref (event->requestor);
+
   /* Determine conversions we need to perform */
-  
   if (event->target == gtk_selection_atoms[MULTIPLE])
     {
       GdkAtom  type;
@@ -2362,10 +2346,10 @@ _gtk_selection_request (GtkWidget *widget,
 						 event->time);
 	  g_free (mult_atoms);
 	  g_slice_free (GtkIncrInfo, info);
-          gdk_error_trap_pop ();
+          gdk_error_trap_pop_ignored ();
 	  return TRUE;
 	}
-      gdk_error_trap_pop ();
+      gdk_error_trap_pop_ignored ();
 
       /* This is annoying; the ICCCM doesn't specify the property type
        * used for the property contents, so the autoconversion for
@@ -2433,7 +2417,6 @@ _gtk_selection_request (GtkWidget *widget,
 #endif
       
       gtk_selection_invoke_handler (widget, &data, event->time);
-      
       if (data.length < 0)
 	{
 	  info->conversions[i].property = GDK_NONE;
@@ -2581,7 +2564,7 @@ _gtk_selection_incr_event (GdkWindow	   *window,
   g_message ("PropertyDelete, property %ld", event->atom);
 #endif
 
-  selection_max_size = GTK_SELECTION_MAX_SIZE (gdk_drawable_get_display (window));  
+  selection_max_size = GTK_SELECTION_MAX_SIZE (gdk_window_get_display (window));  
 
   /* Now find the appropriate ongoing INCR */
   tmp_list = current_incrs;
@@ -2631,7 +2614,7 @@ _gtk_selection_incr_event (GdkWindow	   *window,
 #ifdef DEBUG_SELECTION
 	  g_message ("INCR: put %d bytes (offset = %d) into window 0x%lx , property %ld",
 		     num_bytes, info->conversions[i].offset, 
-		     GDK_WINDOW_XWINDOW(info->requestor), event->atom);
+		     GDK_WINDOW_XID(info->requestor), event->atom);
 #endif
 
 	  bytes_per_item = gtk_selection_bytes_per_item (info->conversions[i].data.format);
@@ -2723,7 +2706,7 @@ gtk_selection_incr_timeout (GtkIncrInfo *info)
 
 /*************************************************************
  * _gtk_selection_notify:
- *     Handler for "selection_notify_event" signals on windows
+ *     Handler for "selection-notify-event" signals on windows
  *     where a retrieval is currently in process. The selection
  *     owner has responded to our conversion request.
  *   arguments:
@@ -2735,21 +2718,24 @@ gtk_selection_incr_timeout (GtkIncrInfo *info)
  *************************************************************/
 
 gboolean
-_gtk_selection_notify (GtkWidget	       *widget,
+_gtk_selection_notify (GtkWidget	 *widget,
 		       GdkEventSelection *event)
 {
   GList *tmp_list;
   GtkRetrievalInfo *info = NULL;
+  GdkWindow *window;
   guchar  *buffer = NULL;
   gint length;
   GdkAtom type;
   gint	  format;
-  
+
 #ifdef DEBUG_SELECTION
   g_message ("Initial receipt of selection %ld, target %ld (property = %ld)",
 	     event->selection, event->target, event->property);
 #endif
-  
+
+  window = gtk_widget_get_window (widget);
+
   tmp_list = current_retrievals;
   while (tmp_list)
     {
@@ -2763,7 +2749,7 @@ _gtk_selection_notify (GtkWidget	       *widget,
     return FALSE;
 
   if (event->property != GDK_NONE)
-    length = gdk_selection_property_get (widget->window, &buffer, 
+    length = gdk_selection_property_get (window, &buffer,
 					 &type, &format);
   else
     length = 0; /* silence gcc */
@@ -2787,8 +2773,8 @@ _gtk_selection_notify (GtkWidget	       *widget,
       info->notify_time = event->time;
       info->idle_time = 0;
       info->offset = 0;		/* Mark as OK to proceed */
-      gdk_window_set_events (widget->window,
-			     gdk_window_get_events (widget->window)
+      gdk_window_set_events (window,
+                             gdk_window_get_events (window)
 			     | GDK_PROPERTY_CHANGE_MASK);
     }
   else
@@ -2802,9 +2788,9 @@ _gtk_selection_notify (GtkWidget	       *widget,
 				      type, format, 
 				      buffer, length, event->time);
     }
-  
-  gdk_property_delete (widget->window, event->property);
-  
+
+  gdk_property_delete (window, event->property);
+
   g_free (buffer);
   
   return TRUE;
@@ -2812,7 +2798,7 @@ _gtk_selection_notify (GtkWidget	       *widget,
 
 /*************************************************************
  * _gtk_selection_property_notify:
- *     Handler for "property_notify_event" signals on windows
+ *     Handler for "property-notify-event" signals on windows
  *     where a retrieval is currently in process. The selection
  *     owner has added more data.
  *   arguments:
@@ -2829,6 +2815,7 @@ _gtk_selection_property_notify (GtkWidget	*widget,
 {
   GList *tmp_list;
   GtkRetrievalInfo *info = NULL;
+  GdkWindow *window;
   guchar *new_buffer;
   int length;
   GdkAtom type;
@@ -2865,11 +2852,12 @@ _gtk_selection_property_notify (GtkWidget	*widget,
     return FALSE;
   
   info->idle_time = 0;
-  
-  length = gdk_selection_property_get (widget->window, &new_buffer, 
+
+  window = gtk_widget_get_window (widget);
+  length = gdk_selection_property_get (window, &new_buffer,
 				       &type, &format);
-  gdk_property_delete (widget->window, event->atom);
-  
+  gdk_property_delete (window, event->atom);
+
   /* We could do a lot better efficiency-wise by paying attention to
      what length was sent in the initial INCR transaction, instead of
      doing memory allocation at every step. But its only guaranteed to
@@ -2967,7 +2955,7 @@ gtk_selection_retrieval_timeout (GtkRetrievalInfo *info)
 
 /*************************************************************
  * gtk_selection_retrieval_report:
- *     Emits a "selection_received" signal.
+ *     Emits a "selection-received" signal.
  *   arguments:
  *     info:	  information about the retrieval that completed
  *     buffer:	  buffer containing data (NULL => errror)
@@ -2993,7 +2981,7 @@ gtk_selection_retrieval_report (GtkRetrievalInfo *info,
   data.display = gtk_widget_get_display (info->widget);
   
   g_signal_emit_by_name (info->widget,
-			 "selection_received", 
+			 "selection-received", 
 			 &data, time);
 }
 
@@ -3024,11 +3012,12 @@ gtk_selection_invoke_handler (GtkWidget	       *widget,
   g_return_if_fail (widget != NULL);
 
   target_list = gtk_selection_target_list_get (widget, data->selection);
-  if (target_list && 
+  if (data->target != gtk_selection_atoms[SAVE_TARGETS] &&
+      target_list &&
       gtk_target_list_find (target_list, data->target, &info))
     {
       g_signal_emit_by_name (widget,
-			     "selection_get",
+			     "selection-get",
 			     data,
 			     info, time);
     }
@@ -3117,6 +3106,12 @@ gtk_selection_default_handler (GtkWidget	*widget,
 	  tmp_list = tmp_list->next;
 	}
     }
+  else if (data->target == gtk_selection_atoms[SAVE_TARGETS])
+    {
+      gtk_selection_data_set (data,
+			      gdk_atom_intern_static_string ("NULL"),
+			      32, NULL, 0);
+    }
   else
     {
       data->length = -1;
@@ -3133,7 +3128,7 @@ gtk_selection_default_handler (GtkWidget	*widget,
  * Return value: a pointer to a copy of @data.
  **/
 GtkSelectionData*
-gtk_selection_data_copy (GtkSelectionData *data)
+gtk_selection_data_copy (const GtkSelectionData *data)
 {
   GtkSelectionData *new_data;
   
@@ -3168,33 +3163,81 @@ gtk_selection_data_free (GtkSelectionData *data)
   g_slice_free (GtkSelectionData, data);
 }
 
-GType
-gtk_selection_data_get_type (void)
+/**
+ * gtk_target_entry_new:
+ * @target: String identifier for target
+ * @flags: Set of flags, see #GtkTargetFlags
+ * @info: an ID that will be passed back to the application
+ *
+ * Makes a new #GtkTargetEntry structure.
+ *
+ * Return value: a pointer to a new GtkTargetEntry structure.
+ *     Free with gtk_target_entry_free()
+ **/
+GtkTargetEntry *
+gtk_target_entry_new (const char *target,
+		      guint       flags,
+		      guint       info)
 {
-  static GType our_type = 0;
-  
-  if (our_type == 0)
-    our_type = g_boxed_type_register_static (I_("GtkSelectionData"),
-					     (GBoxedCopyFunc) gtk_selection_data_copy,
-					     (GBoxedFreeFunc) gtk_selection_data_free);
+  GtkTargetEntry entry = { (char *) target, flags, info };
+  return gtk_target_entry_copy (&entry);
+}
 
-  return our_type;
+/**
+ * gtk_target_entry_copy:
+ * @data: a pointer to a #GtkTargetEntry structure.
+ *
+ * Makes a copy of a #GtkTargetEntry structure and its data.
+ *
+ * Return value: a pointer to a copy of @data.
+ *     Free with gtk_target_entry_free()
+ **/
+GtkTargetEntry *
+gtk_target_entry_copy (GtkTargetEntry *data)
+{
+  GtkTargetEntry *new_data;
+
+  g_return_val_if_fail (data != NULL, NULL);
+
+  new_data = g_slice_new (GtkTargetEntry);
+  new_data->target = g_strdup (data->target);
+  new_data->flags = data->flags;
+  new_data->info = data->info;
+
+  return new_data;
 }
 
-GType
-gtk_target_list_get_type (void)
+/**
+ * gtk_target_entry_free:
+ * @data: a pointer to a #GtkTargetEntry structure.
+ *
+ * Frees a #GtkTargetEntry structure returned from
+ * gtk_target_entry_new() or gtk_target_entry_copy().
+ **/
+void
+gtk_target_entry_free (GtkTargetEntry *data)
 {
-  static GType our_type = 0;
+  g_return_if_fail (data != NULL);
 
-  if (our_type == 0)
-    our_type = g_boxed_type_register_static (I_("GtkTargetList"),
-					     (GBoxedCopyFunc) gtk_target_list_ref,
-					     (GBoxedFreeFunc) gtk_target_list_unref);
+  g_free (data->target);
 
-  return our_type;
+  g_slice_free (GtkTargetEntry, data);
 }
 
-static int 
+
+G_DEFINE_BOXED_TYPE (GtkSelectionData, gtk_selection_data,
+                     gtk_selection_data_copy,
+                     gtk_selection_data_free)
+
+G_DEFINE_BOXED_TYPE (GtkTargetList, gtk_target_list,
+                     gtk_target_list_ref,
+                     gtk_target_list_unref)
+
+G_DEFINE_BOXED_TYPE (GtkTargetEntry, gtk_target_entry,
+                     gtk_target_entry_copy,
+                     gtk_target_entry_free)
+
+static int
 gtk_selection_bytes_per_item (gint format)
 {
   switch (format)
@@ -3213,6 +3256,3 @@ gtk_selection_bytes_per_item (gint format)
     }
   return 0;
 }
-
-#define __GTK_SELECTION_C__
-#include "gtkaliasdef.c"