X-Git-Url: http://pileus.org/git/?a=blobdiff_plain;f=gtk%2Fgtkselection.c;h=21bcb510be6d3bc89395088e71d2cab2d32031d7;hb=b6ba7a5f0450fb68ee95415dfaf2d746551c5d00;hp=e3d27de7a95136b51a42c37f78e44188b5835548;hpb=0e9ff02e85c6b8b6476d47a264b98fd56335be5a;p=~andy%2Fgtk diff --git a/gtk/gtkselection.c b/gtk/gtkselection.c index e3d27de7a..21bcb510b 100644 --- a/gtk/gtkselection.c +++ b/gtk/gtkselection.c @@ -2,18 +2,19 @@ * 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 Library General Public + * 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 - * Library General Public License for more details. + * 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 Library General Public - * License along with this library; if not, write to the Free - * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + * 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 ICCM selection protocol. @@ -27,7 +28,7 @@ * 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 8/16/97 + * By Owen Taylor 8/16/97 */ /* Terminology note: when not otherwise specified, the term "incr" below @@ -43,10 +44,17 @@ 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 #include -#include -/* we need this for gdk_window_lookup() */ +#include "gdk.h" + #include "gtkmain.h" #include "gtkselection.h" #include "gtksignal.h" @@ -55,8 +63,12 @@ /* Maximum size of a sent chunk, in bytes. Also the default size of our buffers */ +#ifdef GDK_WINDOWING_WIN32 +/* No chunks on Win32 */ +#define GTK_SELECTION_MAX_SIZE G_MAXINT +#else #define GTK_SELECTION_MAX_SIZE 4000 - +#endif enum { INCR, MULTIPLE, @@ -69,7 +81,6 @@ typedef struct _GtkSelectionInfo GtkSelectionInfo; typedef struct _GtkIncrConversion GtkIncrConversion; typedef struct _GtkIncrInfo GtkIncrInfo; typedef struct _GtkRetrievalInfo GtkRetrievalInfo; -typedef struct _GtkSelectionHandler GtkSelectionHandler; struct _GtkSelectionInfo { @@ -80,13 +91,13 @@ struct _GtkSelectionInfo struct _GtkIncrConversion { - GdkAtom target; /* Requested target */ - GdkAtom property; /* Property to store in */ + GdkAtom target; /* Requested target */ + GdkAtom property; /* Property to store in */ GtkSelectionData data; /* The data being supplied */ - gint offset; /* Current offset in sent selection. + gint offset; /* Current offset in sent selection. * -1 => All done * -2 => Only the final (empty) portion - * left to send */ + * left to send */ }; struct _GtkIncrInfo @@ -95,7 +106,7 @@ 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 @@ -114,31 +125,27 @@ struct _GtkRetrievalInfo 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 + gint offset; /* Current offset in buffer, -1 indicates not yet started */ -}; - -struct _GtkSelectionHandler -{ - GdkAtom selection; /* selection thats handled */ - GdkAtom target; /* target thats handled */ - GtkSelectionFunction function; /* callback function */ - GtkRemoveFunction remove_func; /* called when callback is removed */ - gpointer data; /* callback data */ + guint32 notify_time; /* Timestamp from SelectionNotify */ }; /* Local Functions */ -static void gtk_selection_init (void); -static gint gtk_selection_incr_timeout (GtkIncrInfo *info); -static gint gtk_selection_retrieval_timeout (GtkRetrievalInfo *info); -static void gtk_selection_retrieval_report (GtkRetrievalInfo *info, - GdkAtom type, gint format, - guchar *buffer, gint length); -static GtkSelectionHandler *gtk_selection_find_handler (GtkWidget *widget, - GdkAtom selection, - GdkAtom target); -static void gtk_selection_default_handler (GtkWidget *widget, - GtkSelectionData *data); +static void gtk_selection_init (void); +static gint gtk_selection_incr_timeout (GtkIncrInfo *info); +static gint 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; @@ -147,7 +154,145 @@ static GList *current_incrs = NULL; static GList *current_selections = NULL; static GdkAtom gtk_selection_atoms[LAST_ATOM]; -static const char *gtk_selection_handler_key = "selection_handlers"; +static const char *gtk_selection_handler_key = "gtk-selection-handlers"; + +/**************** + * Target Lists * + ****************/ + +/* + * Target lists + */ + +GtkTargetList * +gtk_target_list_new (const GtkTargetEntry *targets, + guint ntargets) +{ + GtkTargetList *result = g_new (GtkTargetList, 1); + result->list = NULL; + result->ref_count = 1; + + if (targets) + gtk_target_list_add_table (result, targets, ntargets); + + return result; +} + +void +gtk_target_list_ref (GtkTargetList *list) +{ + g_return_if_fail (list != NULL); + + list->ref_count++; +} + +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_free (pair); + + tmp_list = tmp_list->next; + } + + g_list_free (list->list); + g_free (list); + } +} + +void +gtk_target_list_add (GtkTargetList *list, + GdkAtom target, + guint flags, + guint info) +{ + GtkTargetPair *pair; + + g_return_if_fail (list != NULL); + + pair = g_new (GtkTargetPair, 1); + pair->target = target; + pair->flags = flags; + pair->info = info; + + list->list = g_list_append (list->list, pair); +} + +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_new (GtkTargetPair, 1); + 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); + } +} + +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_free (pair); + + list->list = g_list_remove_link (list->list, tmp_list); + g_list_free_1 (tmp_list); + + return; + } + + tmp_list = tmp_list->next; + } +} + +gboolean +gtk_target_list_find (GtkTargetList *list, + GdkAtom target, + guint *info) +{ + GList *tmp_list = list->list; + while (tmp_list) + { + GtkTargetPair *pair = tmp_list->data; + + if (pair->target == target) + { + *info = pair->info; + return TRUE; + } + tmp_list = tmp_list->next; + } + + return FALSE; +} + /************************************************************* * gtk_selection_owner_set: @@ -160,43 +305,35 @@ static const char *gtk_selection_handler_key = "selection_handlers"; * results: *************************************************************/ -gint +gboolean gtk_selection_owner_set (GtkWidget *widget, GdkAtom selection, guint32 time) { GList *tmp_list; GtkWidget *old_owner; - GtkSelectionInfo *selection_info; + GtkSelectionInfo *selection_info = NULL; GdkWindow *window; + g_return_val_if_fail (widget == NULL || GTK_WIDGET_REALIZED (widget), FALSE); + if (widget == NULL) window = NULL; else - { - if (!GTK_WIDGET_REALIZED (widget)) - gtk_widget_realize (widget); - - window = widget->window; - } + window = widget->window; tmp_list = current_selections; while (tmp_list) { - selection_info = (GtkSelectionInfo *)tmp_list->data; - - if (selection_info->selection == selection) - break; + if (((GtkSelectionInfo *)tmp_list->data)->selection == selection) + { + selection_info = tmp_list->data; + break; + } tmp_list = tmp_list->next; } - - if (tmp_list == NULL) - selection_info = NULL; - else - if (selection_info->widget == widget) - return TRUE; - + if (gdk_selection_owner_set (window, selection, time, TRUE)) { old_owner = NULL; @@ -220,8 +357,8 @@ gtk_selection_owner_set (GtkWidget *widget, selection_info->selection = selection; selection_info->widget = widget; selection_info->time = time; - current_selections = g_list_append (current_selections, - selection_info); + current_selections = g_list_prepend (current_selections, + selection_info); } else { @@ -231,9 +368,9 @@ gtk_selection_owner_set (GtkWidget *widget, } } /* If another widget in the application lost the selection, - * send it a GDK_SELECTION_CLEAR event, unless we're setting - * the owner to None, in which case an event will be sent */ - if (old_owner && (widget != NULL)) + * send it a GDK_SELECTION_CLEAR event. + */ + if (old_owner && old_owner != widget) { GdkEventSelection event; @@ -241,7 +378,7 @@ gtk_selection_owner_set (GtkWidget *widget, event.window = old_owner->window; event.selection = selection; event.time = time; - + gtk_widget_event (old_owner, (GdkEvent *) &event); } return TRUE; @@ -251,81 +388,145 @@ gtk_selection_owner_set (GtkWidget *widget, } /************************************************************* - * gtk_selection_add_handler: - * Add a handler for a specified selection/target pair + * gtk_selection_add_target + * Add specified target to list of supported targets * * arguments: - * widget: The widget the handler applies to + * widget: The widget for which this target applies * selection: * target: - * format: Format in which this handler will return data - * function: Callback function (can be NULL) - * data: User data for callback + * info: guint to pass to to the selection_get signal * * results: *************************************************************/ -void -gtk_selection_add_handler (GtkWidget *widget, - GdkAtom selection, - GdkAtom target, - GtkSelectionFunction function, - GtkRemoveFunction remove_func, - gpointer data) +typedef struct _GtkSelectionTargetList GtkSelectionTargetList; + +struct _GtkSelectionTargetList { + GdkAtom selection; + GtkTargetList *list; +}; + +static GtkTargetList * +gtk_selection_target_list_get (GtkWidget *widget, + GdkAtom selection) { - GList *selection_handlers; + GtkSelectionTargetList *sellist; GList *tmp_list; - GtkSelectionHandler *handler; + GList *lists; - g_return_if_fail (widget != NULL); - if (initialize) - gtk_selection_init (); + lists = gtk_object_get_data (GTK_OBJECT (widget), gtk_selection_handler_key); - selection_handlers = gtk_object_get_data (GTK_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_new (GtkSelectionTargetList, 1); + sellist->selection = selection; + sellist->list = gtk_target_list_new (NULL, 0); + + lists = g_list_prepend (lists, sellist); + gtk_object_set_data (GTK_OBJECT (widget), gtk_selection_handler_key, lists); - /* Reuse old handler structure, if present */ - tmp_list = selection_handlers; + return sellist->list; +} + +static void +gtk_selection_target_list_remove (GtkWidget *widget) +{ + GtkSelectionTargetList *sellist; + GList *tmp_list; + GList *lists; + + lists = gtk_object_get_data (GTK_OBJECT (widget), gtk_selection_handler_key); + + tmp_list = lists; while (tmp_list) { - handler = (GtkSelectionHandler *)tmp_list->data; - if ((handler->selection == selection) && (handler->target == target)) - { - if (handler->remove_func) - (*handler->remove_func)(handler->data); - if (function) - { - handler->function = function; - handler->remove_func = remove_func; - handler->data = data; - } - else - { - selection_handlers = g_list_remove_link (selection_handlers, - tmp_list); - g_list_free (tmp_list); - g_free (handler); - } - return; - } + sellist = tmp_list->data; + + gtk_target_list_unref (sellist->list); + + g_free (sellist); tmp_list = tmp_list->next; } - if (tmp_list == NULL && function) + g_list_free (lists); + gtk_object_set_data (GTK_OBJECT (widget), 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; + + lists = gtk_object_get_data (GTK_OBJECT (widget), gtk_selection_handler_key); + + tmp_list = lists; + while (tmp_list) { - handler = g_new (GtkSelectionHandler, 1); - handler->selection = selection; - handler->target = target; - handler->function = function; - handler->remove_func = remove_func; - handler->data = data; - selection_handlers = g_list_append (selection_handlers, handler); + sellist = tmp_list->data; + if (sellist->selection == selection) + { + lists = g_list_delete_link (lists, tmp_list); + gtk_target_list_unref (sellist->list); + g_free (sellist); + + break; + } + + tmp_list = tmp_list->next; } - gtk_object_set_data (GTK_OBJECT (widget), gtk_selection_handler_key, - selection_handlers); + gtk_object_set_data (GTK_OBJECT (widget), gtk_selection_handler_key, lists); +} + +void +gtk_selection_add_target (GtkWidget *widget, + GdkAtom selection, + GdkAtom target, + guint info) +{ + GtkTargetList *list; + + g_return_if_fail (widget != NULL); + + list = gtk_selection_target_list_get (widget, selection); + gtk_target_list_add (list, target, 0, info); +} + +void +gtk_selection_add_targets (GtkWidget *widget, + GdkAtom selection, + const GtkTargetEntry *targets, + guint ntargets) +{ + GtkTargetList *list; + + g_return_if_fail (widget != NULL); + g_return_if_fail (targets != NULL); + + list = gtk_selection_target_list_get (widget, selection); + gtk_target_list_add_table (list, targets, ntargets); } + /************************************************************* * gtk_selection_remove_all: * Removes all handlers and unsets ownership of all @@ -343,11 +544,9 @@ gtk_selection_remove_all (GtkWidget *widget) GList *tmp_list; GList *next; GtkSelectionInfo *selection_info; - GList *selection_handlers; - GtkSelectionHandler *handler; - + /* Remove pending requests/incrs for this widget */ - + tmp_list = current_incrs; while (tmp_list) { @@ -360,7 +559,7 @@ gtk_selection_remove_all (GtkWidget *widget) } tmp_list = next; } - + tmp_list = current_retrievals; while (tmp_list) { @@ -376,7 +575,7 @@ gtk_selection_remove_all (GtkWidget *widget) } /* Disclaim ownership of any selections */ - + tmp_list = current_selections; while (tmp_list) { @@ -397,26 +596,8 @@ gtk_selection_remove_all (GtkWidget *widget) tmp_list = next; } - /* Now remove all handlers */ - - selection_handlers = gtk_object_get_data (GTK_OBJECT (widget), - gtk_selection_handler_key); - - tmp_list = selection_handlers; - while (tmp_list) - { - next = tmp_list->next; - handler = (GtkSelectionHandler *)tmp_list->data; - - if (handler->remove_func) - (*handler->remove_func)(handler->data); - - g_free (handler); - - tmp_list = next; - } - - g_list_free (selection_handlers); + /* Remove all selection lists */ + gtk_selection_target_list_remove (widget); } /************************************************************* @@ -425,11 +606,11 @@ gtk_selection_remove_all (GtkWidget *widget) * a "selection_received" signal will be generated. * * arguments: - * widget: The widget which acts as requestor + * widget: The widget which acts as requestor * selection: Which selection to get - * target: Form of information desired (e.g., STRING) - * time: Time of request (usually of triggering event) - * In emergency, you could use GDK_CURRENT_TIME + * target: Form of information desired (e.g., STRING) + * time: Time of request (usually of triggering event) + * In emergency, you could use GDK_CURRENT_TIME * * results: * TRUE if requested succeeded. FALSE if we could not process @@ -437,30 +618,30 @@ gtk_selection_remove_all (GtkWidget *widget) * this widget). *************************************************************/ -gint +gboolean gtk_selection_convert (GtkWidget *widget, - GdkAtom selection, - GdkAtom target, - guint32 time) + GdkAtom selection, + GdkAtom target, + guint32 time) { GtkRetrievalInfo *info; GList *tmp_list; GdkWindow *owner_window; - + g_return_val_if_fail (widget != NULL, FALSE); - + if (initialize) gtk_selection_init (); if (!GTK_WIDGET_REALIZED (widget)) gtk_widget_realize (widget); - + /* Check to see if there are already any retrievals in progress for this widget. If we changed GDK to use the selection for the window property in which to store the retrieved information, then we could support multiple retrievals for different selections. This might be useful for DND. */ - + tmp_list = current_retrievals; while (tmp_list) { @@ -469,50 +650,45 @@ gtk_selection_convert (GtkWidget *widget, return FALSE; tmp_list = tmp_list->next; } - + info = g_new (GtkRetrievalInfo, 1); - + info->widget = widget; info->selection = selection; info->target = target; info->buffer = NULL; info->offset = -1; - + /* Check if this process has current owner. If so, call handler procedure directly to avoid deadlocks with INCR. */ - + owner_window = gdk_selection_owner_get (selection); if (owner_window != NULL) { GtkWidget *owner_widget; - GtkSelectionHandler *handler; GtkSelectionData selection_data; - + selection_data.selection = selection; selection_data.target = target; selection_data.data = NULL; selection_data.length = -1; - + gdk_window_get_user_data (owner_window, (gpointer *)&owner_widget); - + if (owner_widget != NULL) { - handler = gtk_selection_find_handler (owner_widget, selection, target); - if (handler) - (* handler->function)(owner_widget, - &selection_data, - handler->data); - else /* try the default handler */ - gtk_selection_default_handler (owner_widget, - &selection_data); - + gtk_selection_invoke_handler (owner_widget, + &selection_data, + time); + gtk_selection_retrieval_report (info, selection_data.type, selection_data.format, selection_data.data, - selection_data.length); - + selection_data.length, + time); + g_free (selection_data.data); g_free (info); @@ -521,11 +697,11 @@ 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); gtk_timeout_add (1000, (GtkFunction) gtk_selection_retrieval_timeout, info); - + return TRUE; } @@ -536,25 +712,25 @@ gtk_selection_convert (GtkWidget *widget, * Null terminates the stored data. * arguments: * type: the type of selection data - * format: format (number of bits in a unit) - * data: pointer to the data (will be copied) - * length: length of the data + * format: format (number of bits in a unit) + * data: pointer to the data (will be copied) + * length: length of the data * results: *************************************************************/ void gtk_selection_data_set (GtkSelectionData *selection_data, - GdkAtom type, - gint format, - guchar *data, - gint length) + GdkAtom type, + gint format, + const guchar *data, + gint length) { if (selection_data->data) g_free (selection_data->data); - + selection_data->type = type; selection_data->format = format; - + if (data) { selection_data->data = g_new (guchar, length+1); @@ -562,11 +738,212 @@ gtk_selection_data_set (GtkSelectionData *selection_data, selection_data->data[length] = 0; } else - selection_data->data = NULL; - + { + g_return_if_fail (length <= 0); + + if (length < 0) + selection_data->data = NULL; + else + selection_data->data = g_strdup(""); + } + selection_data->length = length; } +static GdkAtom utf8_atom; +static GdkAtom text_atom; +static GdkAtom ctext_atom; + +static void +init_atoms (void) +{ + if (!utf8_atom) + { + utf8_atom = gdk_atom_intern ("UTF8_STRING", FALSE); + text_atom = gdk_atom_intern ("TEXT", FALSE); + ctext_atom = gdk_atom_intern ("COMPOUND_TEXT", FALSE); + } +} + +/** + * gtk_selection_data_set_text: + * @selection_data: a #GtkSelectionData + * @str: a UTF-8 string + * + * Sets the contents of the selection from a UTF-8 encoded string. + * The string is converted to the form determined by + * @selection_data->target. + * + * Return value: %TRUE if the selection was successfully set, + * otherwise %FALSE. + **/ +gboolean +gtk_selection_data_set_text (GtkSelectionData *selection_data, + const guchar *str) +{ + init_atoms (); + + if (selection_data->target == utf8_atom) + { + gtk_selection_data_set (selection_data, + utf8_atom, + 8, (guchar *)str, strlen (str)); + return TRUE; + } + else if (selection_data->target == GDK_TARGET_STRING) + { + gchar *latin1 = gdk_utf8_to_string_target (str); + + if (latin1) + { + gtk_selection_data_set (selection_data, + GDK_SELECTION_TYPE_STRING, + 8, latin1, strlen (latin1)); + g_free(latin1); + + return TRUE; + } + + } + else if (selection_data->target == ctext_atom || + selection_data->target == text_atom) + { + guchar *text; + GdkAtom encoding; + gint format; + gint new_length; + + if (gdk_utf8_to_compound_text (str, &encoding, &format, &text, &new_length)) + { + gtk_selection_data_set (selection_data, encoding, format, text, new_length); + gdk_free_compound_text (text); + + return TRUE; + } + } + + return FALSE; +} + +/** + * gtk_selection_data_get_text: + * @selection_data: a #GtkSelectionData + * + * 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. + * If the result is non-%NULL it must be freed with g_free(). + **/ +guchar * +gtk_selection_data_get_text (GtkSelectionData *selection_data) +{ + guchar *result = NULL; + + init_atoms (); + + if (selection_data->length >= 0 && + (selection_data->type == GDK_TARGET_STRING || + selection_data->type == ctext_atom || + selection_data->type == utf8_atom)) + { + gchar **list; + gint i; + gint count = gdk_text_property_to_utf8_list (selection_data->type, + selection_data->format, + selection_data->data, + selection_data->length, + &list); + if (count > 0) + result = list[0]; + + for (i = 1; i < count; i++) + g_free (list[i]); + g_free (list); + } + + return result; +} + +/** + * 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(). + * @n_atoms: location to store number of items in @targets. + * + * Get the contents of @selection_data as an array of targets. + * This can be used to interpret the results of getting + * the standard TARGETS target that is always supplied for + * any selection. + * + * Return value: %TRUE if @selection_data contains a valid + * array of targets, otherwise %FALSE. + **/ +gboolean +gtk_selection_data_get_targets (GtkSelectionData *selection_data, + GdkAtom **targets, + gint *n_atoms) +{ + if (selection_data->length >= 0 && + selection_data->format == 32 && + selection_data->type == GDK_SELECTION_TYPE_ATOM) + { + if (targets) + *targets = g_memdup (selection_data->data, selection_data->length); + if (n_atoms) + *n_atoms = selection_data->length / sizeof (GdkAtom); + + return TRUE; + } + else + { + if (targets) + *targets = NULL; + if (n_atoms) + *n_atoms = -1; + + return FALSE; + } +} + +/** + * gtk_selection_data_targets_include_text: + * @selection_data: a #GtkSelectionData object + * + * Given a #GtkSelectionData object holding a list of targets, + * Determines if any of the targets in @targets can be used to + * provide text. + * + * Return value: %TRUE if @selection_data holds a list of targets, + * and a suitable target for text is included, otherwise %FALSE. + **/ +gboolean +gtk_selection_data_targets_include_text (GtkSelectionData *selection_data) +{ + GdkAtom *targets; + gint n_targets; + gint i; + gboolean result = FALSE; + + if (gtk_selection_data_get_targets (selection_data, &targets, &n_targets)) + { + for (i=0; i < n_targets; i++) + { + if (targets[i] == gdk_atom_intern ("STRING", FALSE) || + targets[i] == gdk_atom_intern ("TEXT", FALSE) || + targets[i] == gdk_atom_intern ("COMPOUND_TEXT", FALSE) || + targets[i] == gdk_atom_intern ("UTF8_STRING", FALSE)) + result = TRUE; + } + + g_free (targets); + } + + return result; +} + /************************************************************* * gtk_selection_init: * Initialize local variables @@ -593,20 +970,17 @@ gtk_selection_init (void) * results: *************************************************************/ -gint -gtk_selection_clear (GtkWidget *widget, +gboolean +gtk_selection_clear (GtkWidget *widget, GdkEventSelection *event) { - /* FIXME: there can be a problem if we change the selection - via gtk_selection_owner_set after another client claims - the selection, but before we get the notification event. - Tk filters based on serial #'s, which aren't retained by - GTK. Filtering based on time's will be inherently - somewhat unreliable. */ - + /* Note that we filter clear events in gdkselection-x11.c, so + * that we only will get here if the clear event actually + * represents a change that we didn't do ourself. + */ GList *tmp_list; - GtkSelectionInfo *selection_info; - + GtkSelectionInfo *selection_info = NULL; + tmp_list = current_selections; while (tmp_list) { @@ -618,14 +992,14 @@ gtk_selection_clear (GtkWidget *widget, tmp_list = tmp_list->next; } - - if (tmp_list == NULL || selection_info->time > event->time) - return TRUE; - - current_selections = g_list_remove_link (current_selections, tmp_list); - g_list_free (tmp_list); - g_free (selection_info); - + + if (tmp_list) + { + current_selections = g_list_remove_link (current_selections, tmp_list); + g_list_free (tmp_list); + g_free (selection_info); + } + return TRUE; } @@ -639,58 +1013,60 @@ gtk_selection_clear (GtkWidget *widget, * results: *************************************************************/ -gint +gboolean gtk_selection_request (GtkWidget *widget, GdkEventSelection *event) { GtkIncrInfo *info; - GtkSelectionHandler *handler; GList *tmp_list; guchar *mult_atoms; int i; - + + if (initialize) + gtk_selection_init (); + /* Check if we own selection */ - + tmp_list = current_selections; while (tmp_list) { GtkSelectionInfo *selection_info = (GtkSelectionInfo *)tmp_list->data; - + if ((selection_info->selection == event->selection) && (selection_info->widget == widget)) break; - + tmp_list = tmp_list->next; } - + if (tmp_list == NULL) return FALSE; - info = g_new(GtkIncrInfo, 1); - + info = g_new (GtkIncrInfo, 1); + info->widget = widget; info->selection = event->selection; info->num_incrs = 0; - + /* Create GdkWindow structure for the requestor */ - info->requestor = gdk_window_lookup (event->requestor); if (!info->requestor) info->requestor = gdk_window_foreign_new (event->requestor); /* Determine conversions we need to perform */ - + if (event->target == gtk_selection_atoms[MULTIPLE]) { GdkAtom type; gint format; gint length; - + mult_atoms = NULL; - if (!gdk_property_get (info->requestor, event->property, GDK_SELECTION_TYPE_ATOM, + + gdk_error_trap_push (); + if (!gdk_property_get (info->requestor, event->property, 0, /* AnyPropertyType */ 0, GTK_SELECTION_MAX_SIZE, FALSE, - &type, &format, &length, &mult_atoms) || - type != GDK_SELECTION_TYPE_ATOM || format != 8*sizeof(GdkAtom)) + &type, &format, &length, &mult_atoms)) { gdk_selection_send_notify (event->requestor, event->selection, event->target, GDK_NONE, event->time); @@ -698,10 +1074,11 @@ gtk_selection_request (GtkWidget *widget, g_free (info); return TRUE; } - + gdk_error_trap_pop (); + info->num_conversions = length / (2*sizeof (GdkAtom)); info->conversions = g_new (GtkIncrConversion, info->num_conversions); - + for (i=0; inum_conversions; i++) { info->conversions[i].target = ((GdkAtom *)mult_atoms)[2*i]; @@ -716,44 +1093,39 @@ gtk_selection_request (GtkWidget *widget, info->conversions[0].property = event->property; mult_atoms = (guchar *)info->conversions; } - + /* Loop through conversions and determine which of these are big enough to require doing them via INCR */ for (i=0; inum_conversions; i++) { GtkSelectionData data; - gint items; - + glong items; + data.selection = event->selection; data.target = info->conversions[i].target; data.data = NULL; data.length = -1; - + #ifdef DEBUG_SELECTION - g_print("Selection %ld, target %ld (%s) requested by 0x%x (property = %ld)\n", - event->selection, info->conversions[i].target, - gdk_atom_name(info->conversions[i].target), - event->requestor, event->property); + g_message ("Selection %ld, target %ld (%s) requested by 0x%x (property = %ld)", + event->selection, info->conversions[i].target, + gdk_atom_name (info->conversions[i].target), + event->requestor, event->property); #endif - - handler = gtk_selection_find_handler (widget, event->selection, - info->conversions[i].target); - if (handler) - (* handler->function)(widget, &data, handler->data); - else - gtk_selection_default_handler (widget, &data); - + + gtk_selection_invoke_handler (widget, &data, event->time); + if (data.length < 0) { ((GdkAtom *)mult_atoms)[2*i+1] = GDK_NONE; info->conversions[i].property = GDK_NONE; continue; } - + g_return_val_if_fail ((data.format >= 8) && (data.format % 8 == 0), FALSE); - - items = (data.length + data.format/8 - 1) / (data.format/8); - + + items = data.length / gtk_selection_bytes_per_item (data.format); + if (data.length > GTK_SELECTION_MAX_SIZE) { /* Sending via INCR */ @@ -765,64 +1137,74 @@ gtk_selection_request (GtkWidget *widget, gdk_property_change (info->requestor, info->conversions[i].property, gtk_selection_atoms[INCR], - 8*sizeof (GdkAtom), + 32, GDK_PROP_MODE_REPLACE, (guchar *)&items, 1); } else { info->conversions[i].offset = -1; - + gdk_property_change (info->requestor, info->conversions[i].property, data.type, data.format, GDK_PROP_MODE_REPLACE, data.data, items); - + g_free (data.data); } } - + /* If we have some INCR's, we need to send the rest of the data in a callback */ - + if (info->num_incrs > 0) { /* FIXME: this could be dangerous if window doesn't still exist */ - + #ifdef DEBUG_SELECTION - g_print("Starting INCR...\n"); + g_message ("Starting INCR..."); #endif - + gdk_window_set_events (info->requestor, gdk_window_get_events (info->requestor) | GDK_PROPERTY_CHANGE_MASK); current_incrs = g_list_append (current_incrs, info); gtk_timeout_add (1000, (GtkFunction)gtk_selection_incr_timeout, info); } - + /* If it was a MULTIPLE request, set the property to indicate which conversions succeeded */ if (event->target == gtk_selection_atoms[MULTIPLE]) { gdk_property_change (info->requestor, event->property, - GDK_SELECTION_TYPE_ATOM, 8*sizeof(GdkAtom), + GDK_SELECTION_TYPE_ATOM, 32, GDK_PROP_MODE_REPLACE, - mult_atoms, info->num_conversions); + mult_atoms, 2*info->num_conversions); g_free (mult_atoms); } - gdk_selection_send_notify (event->requestor, event->selection, event->target, - event->property, event->time); - + if (info->num_conversions == 1 && + info->conversions[0].property == GDK_NONE) + { + /* Reject the entire conversion */ + gdk_selection_send_notify (event->requestor, event->selection, + event->target, GDK_NONE, event->time); + } + else + { + gdk_selection_send_notify (event->requestor, event->selection, + event->target, event->property, event->time); + } + if (info->num_incrs == 0) { g_free (info->conversions); g_free (info); } - + return TRUE; } @@ -835,30 +1217,30 @@ gtk_selection_request (GtkWidget *widget, * more data. * * arguments: - * window: the requestor window - * event: the property event structure + * window: the requestor window + * event: the property event structure * * results: *************************************************************/ -gint -gtk_selection_incr_event (GdkWindow *window, +gboolean +gtk_selection_incr_event (GdkWindow *window, GdkEventProperty *event) { GList *tmp_list; - GtkIncrInfo *info; + GtkIncrInfo *info = NULL; gint num_bytes; guchar *buffer; - + int i; if (event->state != GDK_PROPERTY_DELETE) return FALSE; - + #ifdef DEBUG_SELECTION - g_print("PropertyDelete, property %ld\n", event->atom); + g_message ("PropertyDelete, property %ld", event->atom); #endif - + /* Now find the appropriate ongoing INCR */ tmp_list = current_incrs; while (tmp_list) @@ -869,16 +1251,18 @@ gtk_selection_incr_event (GdkWindow *window, tmp_list = tmp_list->next; } - + if (tmp_list == NULL) return FALSE; - + /* Find out which target this is for */ for (i=0; inum_conversions; i++) { if (info->conversions[i].property == event->atom && info->conversions[i].offset != -1) { + int bytes_per_item; + info->idle_time = 0; if (info->conversions[i].offset == -2) /* only the last 0-length @@ -893,7 +1277,7 @@ gtk_selection_incr_event (GdkWindow *window, info->conversions[i].offset; buffer = info->conversions[i].data.data + info->conversions[i].offset; - + if (num_bytes > GTK_SELECTION_MAX_SIZE) { num_bytes = GTK_SELECTION_MAX_SIZE; @@ -903,18 +1287,19 @@ gtk_selection_incr_event (GdkWindow *window, info->conversions[i].offset = -2; } #ifdef DEBUG_SELECTION - g_print("INCR: put %d bytes (offset = %d) into window 0x%lx , property %ld\n", - num_bytes, info->conversions[i].offset, - GDK_WINDOW_XWINDOW(info->requestor), event->atom); + 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); #endif + + bytes_per_item = gtk_selection_bytes_per_item (info->conversions[i].data.format); gdk_property_change (info->requestor, event->atom, info->conversions[i].data.type, info->conversions[i].data.format, GDK_PROP_MODE_REPLACE, - buffer, - (num_bytes + info->conversions[i].data.format/8 - 1) / - (info->conversions[i].data.format/8)); - + buffer, + num_bytes / bytes_per_item); + if (info->conversions[i].offset == -2) { g_free (info->conversions[i].data.data); @@ -929,9 +1314,9 @@ gtk_selection_incr_event (GdkWindow *window, } break; } - + /* Check if we're finished with all the targets */ - + if (info->num_incrs == 0) { current_incrs = g_list_remove_link (current_incrs, tmp_list); @@ -947,7 +1332,7 @@ gtk_selection_incr_event (GdkWindow *window, * Timeout callback for the sending portion of the INCR * protocol * arguments: - * info: Information about this incr + * info: Information about this incr * results: *************************************************************/ @@ -955,10 +1340,13 @@ static gint gtk_selection_incr_timeout (GtkIncrInfo *info) { GList *tmp_list; + gboolean retval; + + GDK_THREADS_ENTER (); /* Determine if retrieval has finished by checking if it still in list of pending retrievals */ - + tmp_list = current_incrs; while (tmp_list) { @@ -979,17 +1367,21 @@ gtk_selection_incr_timeout (GtkIncrInfo *info) g_free (info->conversions); /* FIXME: we should check if requestor window is still in use, and if not, remove it? */ - + g_free (info); - return FALSE; /* remove timeout */ + retval = FALSE; /* remove timeout */ } else { info->idle_time++; - return TRUE; /* timeout will happen again */ + retval = TRUE; /* timeout will happen again */ } + + GDK_THREADS_LEAVE (); + + return retval; } /************************************************************* @@ -998,27 +1390,27 @@ gtk_selection_incr_timeout (GtkIncrInfo *info) * where a retrieval is currently in process. The selection * owner has responded to our conversion request. * arguments: - * widget: Widget getting signal - * event: Selection event structure - * info: Information about this retrieval + * widget: Widget getting signal + * event: Selection event structure + * info: Information about this retrieval * results: * was event handled? *************************************************************/ -gint -gtk_selection_notify (GtkWidget *widget, +gboolean +gtk_selection_notify (GtkWidget *widget, GdkEventSelection *event) { GList *tmp_list; - GtkRetrievalInfo *info; - guchar *buffer; + GtkRetrievalInfo *info = NULL; + guchar *buffer = NULL; gint length; GdkAtom type; - gint format; + gint format; #ifdef DEBUG_SELECTION - g_print("Initial receipt of selection %ld, target %ld (property = %ld)\n", - event->selection, event->target, event->property); + g_message ("Initial receipt of selection %ld, target %ld (property = %ld)", + event->selection, event->target, event->property); #endif tmp_list = current_retrievals; @@ -1029,29 +1421,33 @@ gtk_selection_notify (GtkWidget *widget, break; tmp_list = tmp_list->next; } - + if (!tmp_list) /* no retrieval in progress */ return FALSE; - if (event->property == GDK_NONE) + if (event->property != GDK_NONE) + length = gdk_selection_property_get (widget->window, &buffer, + &type, &format); + else + length = 0; /* silence gcc */ + + if (event->property == GDK_NONE || buffer == NULL) { current_retrievals = g_list_remove_link (current_retrievals, tmp_list); g_list_free (tmp_list); /* structure will be freed in timeout */ gtk_selection_retrieval_report (info, - GDK_NONE, 0, NULL, -1); - + GDK_NONE, 0, NULL, -1, event->time); + return TRUE; } - length = gdk_selection_property_get (widget->window, &buffer, - &type, &format); - if (type == gtk_selection_atoms[INCR]) { /* The remainder of the selection will come through PropertyNotify events */ + info->notify_time = event->time; info->idle_time = 0; info->offset = 0; /* Mark as OK to proceed */ gdk_window_set_events (widget->window, @@ -1063,17 +1459,17 @@ gtk_selection_notify (GtkWidget *widget, /* We don't delete the info structure - that will happen in timeout */ current_retrievals = g_list_remove_link (current_retrievals, tmp_list); g_list_free (tmp_list); - + info->offset = length; gtk_selection_retrieval_report (info, type, format, - buffer, length); + buffer, length, event->time); } - + gdk_property_delete (widget->window, event->property); - + g_free (buffer); - + return TRUE; } @@ -1083,31 +1479,36 @@ gtk_selection_notify (GtkWidget *widget, * where a retrieval is currently in process. The selection * owner has added more data. * arguments: - * widget: Widget getting signal - * event: Property event structure - * info: Information about this retrieval + * widget: Widget getting signal + * event: Property event structure + * info: Information about this retrieval * results: * was event handled? *************************************************************/ -gint -gtk_selection_property_notify (GtkWidget *widget, +gboolean +gtk_selection_property_notify (GtkWidget *widget, GdkEventProperty *event) { GList *tmp_list; - GtkRetrievalInfo *info; + GtkRetrievalInfo *info = NULL; guchar *new_buffer; int length; GdkAtom type; - gint format; + gint format; + + g_return_val_if_fail (widget != NULL, FALSE); + g_return_val_if_fail (event != NULL, FALSE); +#if defined(GDK_WINDOWING_WIN32) || defined(GDK_WINDOWING_X11) if ((event->state != GDK_PROPERTY_NEW_VALUE) || /* property was deleted */ - (event->atom != gdk_selection_property)) /* not the right property */ + (event->atom != gdk_atom_intern ("GDK_SELECTION", FALSE))) /* not the right property */ +#endif return FALSE; - + #ifdef DEBUG_SELECTION - g_print("PropertyNewValue, property %ld\n", - event->atom); + g_message ("PropertyNewValue, property %ld", + event->atom); #endif tmp_list = current_retrievals; @@ -1118,25 +1519,25 @@ gtk_selection_property_notify (GtkWidget *widget, break; tmp_list = tmp_list->next; } - + if (!tmp_list) /* No retrieval in progress */ return FALSE; - + if (info->offset < 0) /* We haven't got the SelectionNotify for this retrieval yet */ return FALSE; - + info->idle_time = 0; length = gdk_selection_property_get (widget->window, &new_buffer, &type, &format); gdk_property_delete (widget->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 be a _lower bound_ (pretty useless!) */ - + if (length == 0 || type == GDK_NONE) /* final zero length portion */ { /* Info structure will be freed in timeout */ @@ -1145,25 +1546,26 @@ gtk_selection_property_notify (GtkWidget *widget, gtk_selection_retrieval_report (info, type, format, (type == GDK_NONE) ? NULL : info->buffer, - (type == GDK_NONE) ? -1 : info->offset); + (type == GDK_NONE) ? -1 : info->offset, + info->notify_time); } else /* append on newly arrived data */ { if (!info->buffer) { #ifdef DEBUG_SELECTION - g_print("Start - Adding %d bytes at offset 0\n", - length); + g_message ("Start - Adding %d bytes at offset 0", + length); #endif info->buffer = new_buffer; info->offset = length; } else { - + #ifdef DEBUG_SELECTION - g_print("Appending %d bytes at offset %d\n", - length,info->offset); + g_message ("Appending %d bytes at offset %d", + length,info->offset); #endif /* We copy length+1 bytes to preserve guaranteed null termination */ info->buffer = g_realloc (info->buffer, info->offset+length+1); @@ -1172,7 +1574,7 @@ gtk_selection_property_notify (GtkWidget *widget, g_free (new_buffer); } } - + return TRUE; } @@ -1188,10 +1590,13 @@ static gint gtk_selection_retrieval_timeout (GtkRetrievalInfo *info) { GList *tmp_list; + gboolean retval; + + GDK_THREADS_ENTER (); /* Determine if retrieval has finished by checking if it still in list of pending retrievals */ - + tmp_list = current_retrievals; while (tmp_list) { @@ -1207,86 +1612,96 @@ gtk_selection_retrieval_timeout (GtkRetrievalInfo *info) { current_retrievals = g_list_remove_link (current_retrievals, tmp_list); g_list_free (tmp_list); - gtk_selection_retrieval_report (info, GDK_NONE, 0, NULL, -1); + gtk_selection_retrieval_report (info, GDK_NONE, 0, NULL, -1, GDK_CURRENT_TIME); } g_free (info->buffer); g_free (info); - return FALSE; /* remove timeout */ + retval = FALSE; /* remove timeout */ } else { info->idle_time++; - return TRUE; /* timeout will happen again */ + retval = TRUE; /* timeout will happen again */ } + GDK_THREADS_LEAVE (); + + return retval; } /************************************************************* * gtk_selection_retrieval_report: * Emits a "selection_received" signal. * arguments: - * info: information about the retrieval that completed - * buffer: buffer containing data (NULL => errror) + * info: information about the retrieval that completed + * buffer: buffer containing data (NULL => errror) + * time: timestamp for data in buffer * results: *************************************************************/ static void gtk_selection_retrieval_report (GtkRetrievalInfo *info, GdkAtom type, gint format, - guchar *buffer, gint length) + guchar *buffer, gint length, + guint32 time) { GtkSelectionData data; - + data.selection = info->selection; data.target = info->target; data.type = type; data.format = format; - + data.length = length; data.data = buffer; - + gtk_signal_emit_by_name (GTK_OBJECT(info->widget), - "selection_received", &data); + "selection_received", + &data, time); } /************************************************************* - * gtk_selection_find_handler: - * Find handler for specified widget/selection/target + * gtk_selection_invoke_handler: + * Finds and invokes handler for specified + * widget/selection/target combination, calls + * gtk_selection_default_handler if none exists. + * * arguments: - * widget: - * selection: - * target: + * widget: selection owner + * data: selection data [INOUT] + * time: time from requeset + * * results: + * Number of bytes written to buffer, -1 if error *************************************************************/ -static GtkSelectionHandler * -gtk_selection_find_handler (GtkWidget *widget, - GdkAtom selection, - GdkAtom target) +static void +gtk_selection_invoke_handler (GtkWidget *widget, + GtkSelectionData *data, + guint time) { - GList *tmp_list; - GtkSelectionHandler *handler; - - g_return_val_if_fail (widget != NULL, FALSE); + GtkTargetList *target_list; + guint info; - tmp_list = gtk_object_get_data (GTK_OBJECT (widget), - gtk_selection_handler_key); - while (tmp_list) + g_return_if_fail (widget != NULL); + + target_list = gtk_selection_target_list_get (widget, data->selection); + if (target_list && + gtk_target_list_find (target_list, data->target, &info)) { - handler = (GtkSelectionHandler *)tmp_list->data; - if ((handler->selection == selection) && (handler->target == target)) - return handler; - tmp_list = tmp_list->next; + gtk_signal_emit_by_name (GTK_OBJECT (widget), + "selection_get", + data, + info, time); } - - return NULL; + else + gtk_selection_default_handler (widget, data); } - /************************************************************* * gtk_selection_default_handler: * Handles some default targets that exist for any widget @@ -1295,20 +1710,13 @@ gtk_selection_find_handler (GtkWidget *widget, * require 1000 selection targets! * * arguments: - * widget: selection owner - * selection: selection requested - * target: target requested - * buffer: buffer to write results into - * length: size of buffer - * type: type atom - * format: length of type's units in bits - * - * results: - * Number of bytes written to buffer, -1 if error + * widget: selection owner + * data: selection data [INOUT] + * *************************************************************/ static void -gtk_selection_default_handler (GtkWidget *widget, +gtk_selection_default_handler (GtkWidget *widget, GtkSelectionData *data) { if (data->target == gtk_selection_atoms[TIMESTAMP]) @@ -1324,60 +1732,51 @@ gtk_selection_default_handler (GtkWidget *widget, if ((selection_info->widget == widget) && (selection_info->selection == data->selection)) { + gulong time = selection_info->time; + gtk_selection_data_set (data, GDK_SELECTION_TYPE_INTEGER, - sizeof (guint32)*8, - (guchar *)&selection_info->time, - sizeof (guint32)); + 32, + (guchar *)&time, + sizeof (time)); return; } - + tmp_list = tmp_list->next; } - + data->length = -1; } else if (data->target == gtk_selection_atoms[TARGETS]) { /* List of all targets supported for this widget/selection pair */ GdkAtom *p; - gint count; + guint count; GList *tmp_list; - GtkSelectionHandler *handler; - - count = 3; - tmp_list = gtk_object_get_data (GTK_OBJECT(widget), - gtk_selection_handler_key); - while (tmp_list) - { - handler = (GtkSelectionHandler *)tmp_list->data; - - if (handler->selection == data->selection) - count++; - - tmp_list = tmp_list->next; - } - + GtkTargetList *target_list; + GtkTargetPair *pair; + + target_list = gtk_selection_target_list_get (widget, + data->selection); + count = g_list_length (target_list->list) + 3; + data->type = GDK_SELECTION_TYPE_ATOM; - data->format = 8*sizeof (GdkAtom); - data->length = count*sizeof (GdkAtom); - + data->format = 32; + data->length = count * sizeof (GdkAtom); + p = g_new (GdkAtom, count); data->data = (guchar *)p; - + *p++ = gtk_selection_atoms[TIMESTAMP]; *p++ = gtk_selection_atoms[TARGETS]; *p++ = gtk_selection_atoms[MULTIPLE]; - - tmp_list = gtk_object_get_data (GTK_OBJECT(widget), - gtk_selection_handler_key); + + tmp_list = target_list->list; while (tmp_list) { - handler = (GtkSelectionHandler *)tmp_list->data; - - if (handler->selection == data->selection) - *p++ = handler->target; - + pair = (GtkTargetPair *)tmp_list->data; + *p++ = pair->target; + tmp_list = tmp_list->next; } } @@ -1386,3 +1785,54 @@ gtk_selection_default_handler (GtkWidget *widget, data->length = -1; } } + + +GtkSelectionData* +gtk_selection_data_copy (GtkSelectionData *selection_data) +{ + GtkSelectionData *new_data; + + g_return_val_if_fail (selection_data != NULL, NULL); + + new_data = g_new (GtkSelectionData, 1); + *new_data = *selection_data; + + if (selection_data->data) + { + new_data->data = g_malloc (selection_data->length + 1); + memcpy (new_data->data, selection_data->data, selection_data->length + 1); + } + + return new_data; +} + +void +gtk_selection_data_free (GtkSelectionData *data) +{ + g_return_if_fail (data != NULL); + + if (data->data) + g_free (data->data); + + g_free (data); +} + +static int +gtk_selection_bytes_per_item (gint format) +{ + switch (format) + { + case 8: + return sizeof (char); + break; + case 16: + return sizeof (short); + break; + case 32: + return sizeof (long); + break; + default: + g_assert_not_reached(); + } + return 0; +}