diff options
Diffstat (limited to 'gtk/gtkselection.c')
| -rw-r--r-- | gtk/gtkselection.c | 1388 |
1 files changed, 1388 insertions, 0 deletions
diff --git a/gtk/gtkselection.c b/gtk/gtkselection.c new file mode 100644 index 0000000000..ca6f5742f4 --- /dev/null +++ b/gtk/gtkselection.c @@ -0,0 +1,1388 @@ +/* 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 Library 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. + * + * 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. + */ + +/* This file implements most of the work of the ICCM 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 ICCM 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 ... */ + +#include <stdarg.h> +#include <gdk/gdkx.h> +/* we need this for gdk_window_lookup() */ +#include "gtkmain.h" +#include "gtkselection.h" +#include "gtksignal.h" + +/* #define DEBUG_SELECTION */ + +/* Maximum size of a sent chunk, in bytes. Also the default size of + our buffers */ +#define GTK_SELECTION_MAX_SIZE 4000 + +enum { + INCR, + MULTIPLE, + TARGETS, + TIMESTAMP, + LAST_ATOM +}; + +typedef struct _GtkSelectionInfo GtkSelectionInfo; +typedef struct _GtkIncrConversion GtkIncrConversion; +typedef struct _GtkIncrInfo GtkIncrInfo; +typedef struct _GtkRetrievalInfo GtkRetrievalInfo; +typedef struct _GtkSelectionHandler GtkSelectionHandler; + +struct _GtkSelectionInfo +{ + GdkAtom selection; + GtkWidget *widget; /* widget that owns selection */ + guint32 time; /* time used to acquire selection */ +}; + +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 +{ + GtkWidget *widget; /* Selection owner */ + 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 */ +}; + +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 */ +}; + +/* 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); + +/* 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 = "selection_handlers"; + +/************************************************************* + * gtk_selection_owner_set: + * Claim ownership of a selection. + * arguments: + * widget: new selection owner + * selection: which selection + * time: time (use GDK_CURRENT_TIME only if necessary) + * + * results: + *************************************************************/ + +gint +gtk_selection_owner_set (GtkWidget *widget, + GdkAtom selection, + guint32 time) +{ + GList *tmp_list; + GtkWidget *old_owner; + GtkSelectionInfo *selection_info; + GdkWindow *window; + + if (widget == NULL) + window = NULL; + else + { + if (!GTK_WIDGET_REALIZED (widget)) + gtk_widget_realize (widget); + + window = widget->window; + } + + tmp_list = current_selections; + while (tmp_list) + { + selection_info = (GtkSelectionInfo *)tmp_list->data; + + if (selection_info->selection == selection) + 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; + + 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_free (selection_info); + } + } + else + { + if (selection_info == NULL) + { + selection_info = g_new (GtkSelectionInfo, 1); + selection_info->selection = selection; + selection_info->widget = widget; + selection_info->time = time; + current_selections = g_list_append (current_selections, + selection_info); + } + else + { + old_owner = selection_info->widget; + selection_info->widget = widget; + selection_info->time = time; + } + } + /* 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)) + { + GdkEventSelection event; + + event.type = GDK_SELECTION_CLEAR; + event.window = old_owner->window; + event.selection = selection; + event.time = time; + + gtk_widget_event (widget, (GdkEvent *) &event); + } + return TRUE; + } + else + return FALSE; +} + +/************************************************************* + * gtk_selection_add_handler: + * Add a handler for a specified selection/target pair + * + * arguments: + * widget: The widget the handler applies to + * selection: + * target: + * format: Format in which this handler will return data + * function: Callback function (can be NULL) + * data: User data for callback + * + * results: + *************************************************************/ + +void +gtk_selection_add_handler (GtkWidget *widget, + GdkAtom selection, + GdkAtom target, + GtkSelectionFunction function, + GtkRemoveFunction remove_func, + gpointer data) +{ + GList *selection_handlers; + GList *tmp_list; + GtkSelectionHandler *handler; + + g_return_if_fail (widget != NULL); + if (initialize) + gtk_selection_init (); + + selection_handlers = gtk_object_get_data (GTK_OBJECT (widget), + gtk_selection_handler_key); + + /* Reuse old handler structure, if present */ + tmp_list = selection_handlers; + 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; + } + tmp_list = tmp_list->next; + } + + if (tmp_list == NULL && function) + { + 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); + } + + gtk_object_set_data (GTK_OBJECT (widget), gtk_selection_handler_key, + selection_handlers); +} + +/************************************************************* + * gtk_selection_remove_all: + * Removes all handlers and unsets ownership of all + * selections for a widget. Called when widget is being + * destroyed + * + * arguments: + * widget: The widget + * results: + *************************************************************/ + +void +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) + { + next = tmp_list->next; + if (((GtkIncrInfo *)tmp_list->data)->widget == widget) + { + current_incrs = g_list_remove_link (current_incrs, tmp_list); + /* structure will be freed in timeout */ + g_list_free (tmp_list); + } + tmp_list = next; + } + + tmp_list = current_retrievals; + while (tmp_list) + { + next = tmp_list->next; + if (((GtkRetrievalInfo *)tmp_list->data)->widget == widget) + { + current_retrievals = g_list_remove_link (current_retrievals, + tmp_list); + /* structure will be freed in timeout */ + g_list_free (tmp_list); + } + tmp_list = next; + } + + /* Disclaim ownership of any selections */ + + tmp_list = current_selections; + while (tmp_list) + { + next = tmp_list->next; + selection_info = (GtkSelectionInfo *)tmp_list->data; + + if (selection_info->widget == widget) + { + gdk_selection_owner_set (NULL, + selection_info->selection, + GDK_CURRENT_TIME, FALSE); + current_selections = g_list_remove_link (current_selections, + tmp_list); + g_list_free (tmp_list); + g_free (selection_info); + } + + 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); +} + +/************************************************************* + * gtk_selection_convert: + * Request the contents of a selection. When received, + * a "selection_received" signal will be generated. + * + * arguments: + * 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 + * + * results: + * TRUE if requested succeeded. FALSE if we could not process + * request. (e.g., there was already a request in process for + * this widget). + *************************************************************/ + +gint +gtk_selection_convert (GtkWidget *widget, + 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) + { + info = (GtkRetrievalInfo *)tmp_list->data; + if (info->widget == 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_retrieval_report (info, + selection_data.type, + selection_data.format, + selection_data.data, + selection_data.length); + + g_free (selection_data.data); + + g_free (info); + return TRUE; + } + } + + /* 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; +} + +/************************************************************* + * gtk_selection_data_set: + * Store new data into a GtkSelectionData object. Should + * _only_ by called from a selection handler callback. + * 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 + * results: + *************************************************************/ + +void +gtk_selection_data_set (GtkSelectionData *selection_data, + GdkAtom type, + gint format, + 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); + memcpy (selection_data->data, data, length); + selection_data->data[length] = 0; + } + else + selection_data->data = NULL; + + selection_data->length = length; +} + +/************************************************************* + * gtk_selection_init: + * Initialize local variables + * arguments: + * + * results: + *************************************************************/ + +static void +gtk_selection_init (void) +{ + gtk_selection_atoms[INCR] = gdk_atom_intern ("INCR", FALSE); + gtk_selection_atoms[MULTIPLE] = gdk_atom_intern ("MULTIPLE", FALSE); + gtk_selection_atoms[TIMESTAMP] = gdk_atom_intern ("TIMESTAMP", FALSE); + gtk_selection_atoms[TARGETS] = gdk_atom_intern ("TARGETS", FALSE); +} + +/************************************************************* + * gtk_selection_clear: + * Handler for "selection_clear_event" + * arguments: + * widget: + * event: + * results: + *************************************************************/ + +gint +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. */ + + GList *tmp_list; + GtkSelectionInfo *selection_info; + + tmp_list = current_selections; + while (tmp_list) + { + 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 || 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); + + return TRUE; +} + + +/************************************************************* + * gtk_selection_request: + * Handler for "selection_request_event" + * arguments: + * widget: + * event: + * results: + *************************************************************/ + +gint +gtk_selection_request (GtkWidget *widget, + GdkEventSelection *event) +{ + GtkIncrInfo *info; + GtkSelectionHandler *handler; + GList *tmp_list; + guchar *mult_atoms; + int i; + + /* 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->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, + 0, GTK_SELECTION_MAX_SIZE, FALSE, + &type, &format, &length, &mult_atoms) || + type != GDK_SELECTION_TYPE_ATOM || format != 8*sizeof(GdkAtom)) + { + gdk_selection_send_notify (event->requestor, event->selection, + event->target, GDK_NONE, event->time); + g_free (mult_atoms); + g_free (info); + return TRUE; + } + + info->num_conversions = length / (2*sizeof (GdkAtom)); + info->conversions = g_new (GtkIncrConversion, info->num_conversions); + + for (i=0; i<info->num_conversions; i++) + { + info->conversions[i].target = ((GdkAtom *)mult_atoms)[2*i]; + info->conversions[i].property = ((GdkAtom *)mult_atoms)[2*i+1]; + } + } + else /* only a single conversion */ + { + info->conversions = g_new (GtkIncrConversion, 1); + info->num_conversions = 1; + info->conversions[0].target = event->target; + 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; i<info->num_conversions; i++) + { + GtkSelectionData data; + gint 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); +#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); + + 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); + + if (data.length > GTK_SELECTION_MAX_SIZE) + { + /* Sending via INCR */ + + info->conversions[i].offset = 0; + info->conversions[i].data = data; + info->num_incrs++; + + gdk_property_change (info->requestor, + info->conversions[i].property, + gtk_selection_atoms[INCR], + 8*sizeof (GdkAtom), + 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"); +#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_PROP_MODE_REPLACE, + mult_atoms, info->num_conversions); + g_free (mult_atoms); + } + + 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; +} + +/************************************************************* + * gtk_selection_incr_event: + * Called whenever an PropertyNotify event occurs for an + * GdkWindow with user_data == NULL. These will be notifications + * that a window we are sending the selection to via the + * INCR protocol has deleted a property and is ready for + * more data. + * + * arguments: + * window: the requestor window + * event: the property event structure + * + * results: + *************************************************************/ + +gint +gtk_selection_incr_event (GdkWindow *window, + GdkEventProperty *event) +{ + GList *tmp_list; + GtkIncrInfo *info; + 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); +#endif + + /* Now find the appropriate ongoing INCR */ + tmp_list = current_incrs; + while (tmp_list) + { + info = (GtkIncrInfo *)tmp_list->data; + if (info->requestor == event->window) + break; + + tmp_list = tmp_list->next; + } + + if (tmp_list == NULL) + return FALSE; + + /* Find out which target this is for */ + for (i=0; i<info->num_conversions; i++) + { + if (info->conversions[i].property == event->atom && + info->conversions[i].offset != -1) + { + info->idle_time = 0; + + if (info->conversions[i].offset == -2) /* only the last 0-length + piece*/ + { + num_bytes = 0; + buffer = NULL; + } + else + { + num_bytes = info->conversions[i].data.length - + 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; + info->conversions[i].offset += GTK_SELECTION_MAX_SIZE; + } + else + 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); +#endif + 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)); + + if (info->conversions[i].offset == -2) + { + g_free (info->conversions[i].data.data); + info->conversions[i].data.data = NULL; + } + + if (num_bytes == 0) + { + info->num_incrs--; + info->conversions[i].offset = -1; + } + } + 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); + g_list_free (tmp_list); + /* Let the timeout free it */ + } + + return TRUE; +} + +/************************************************************* + * gtk_selection_incr_timeout: + * Timeout callback for the sending portion of the INCR + * protocol + * arguments: + * info: Information about this incr + * results: + *************************************************************/ + +static gint +gtk_selection_incr_timeout (GtkIncrInfo *info) +{ + GList *tmp_list; + + /* Determine if retrieval has finished by checking if it still in + list of pending retrievals */ + + tmp_list = current_incrs; + while (tmp_list) + { + if (info == (GtkIncrInfo *)tmp_list->data) + break; + tmp_list = tmp_list->next; + } + + /* If retrieval is finished */ + if (!tmp_list || info->idle_time >= 5) + { + if (tmp_list && info->idle_time >= 5) + { + current_incrs = g_list_remove_link (current_incrs, tmp_list); + g_list_free (tmp_list); + } + + 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 */ + } + else + { + info->idle_time++; + + return TRUE; /* timeout will happen again */ + } +} + +/************************************************************* + * gtk_selection_notify: + * 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: + * widget: Widget getting signal + * event: Selection event structure + * info: Information about this retrieval + * results: + * was event handled? + *************************************************************/ + +gint +gtk_selection_notify (GtkWidget *widget, + GdkEventSelection *event) +{ + GList *tmp_list; + GtkRetrievalInfo *info; + guchar *buffer; + gint length; + GdkAtom type; + gint format; + +#ifdef DEBUG_SELECTION + g_print("Initial receipt of selection %ld, target %ld (property = %ld)\n", + event->selection, event->target, event->property); +#endif + + tmp_list = current_retrievals; + while (tmp_list) + { + info = (GtkRetrievalInfo *)tmp_list->data; + if (info->widget == widget && info->selection == event->selection) + break; + tmp_list = tmp_list->next; + } + + if (!tmp_list) /* no retrieval in progress */ + return FALSE; + + if (event->property == GDK_NONE) + { + 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); + + 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->idle_time = 0; + info->offset = 0; /* Mark as OK to proceed */ + gdk_window_set_events (widget->window, + gdk_window_get_events (widget->window) + | GDK_PROPERTY_CHANGE_MASK); + } + else + { + /* 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); + } + + gdk_property_delete (widget->window, event->property); + + g_free (buffer); + + return TRUE; +} + +/************************************************************* + * gtk_selection_property_notify: + * Handler for "property_notify_event" signals on windows + * 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 + * results: + * was event handled? + *************************************************************/ + +gint +gtk_selection_property_notify (GtkWidget *widget, + GdkEventProperty *event) +{ + GList *tmp_list; + GtkRetrievalInfo *info; + guchar *new_buffer; + int length; + GdkAtom type; + gint format; + + if ((event->state != GDK_PROPERTY_NEW_VALUE) || /* property was deleted */ + (event->atom != gdk_selection_property)) /* not the right property */ + return FALSE; + +#ifdef DEBUG_SELECTION + g_print("PropertyNewValue, property %ld\n", + event->atom); +#endif + + tmp_list = current_retrievals; + while (tmp_list) + { + info = (GtkRetrievalInfo *)tmp_list->data; + if (info->widget == 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 */ + current_retrievals = g_list_remove_link (current_retrievals, tmp_list); + g_list_free (tmp_list); + gtk_selection_retrieval_report (info, + type, format, + (type == GDK_NONE) ? NULL : info->buffer, + (type == GDK_NONE) ? -1 : info->offset); + } + else /* append on newly arrived data */ + { + if (!info->buffer) + { +#ifdef DEBUG_SELECTION + g_print("Start - Adding %d bytes at offset 0\n", + 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); +#endif + /* We copy length+1 bytes to preserve guaranteed null termination */ + info->buffer = g_realloc (info->buffer, info->offset+length+1); + memcpy (info->buffer + info->offset, new_buffer, length+1); + info->offset += length; + g_free (new_buffer); + } + } + + return TRUE; +} + +/************************************************************* + * gtk_selection_retrieval_timeout: + * Timeout callback while receiving a selection. + * arguments: + * info: Information about this retrieval + * results: + *************************************************************/ + +static gint +gtk_selection_retrieval_timeout (GtkRetrievalInfo *info) +{ + GList *tmp_list; + + /* Determine if retrieval has finished by checking if it still in + list of pending retrievals */ + + tmp_list = current_retrievals; + while (tmp_list) + { + if (info == (GtkRetrievalInfo *)tmp_list->data) + break; + tmp_list = tmp_list->next; + } + + /* If retrieval is finished */ + if (!tmp_list || info->idle_time >= 5) + { + if (tmp_list && info->idle_time >= 5) + { + 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); + } + + g_free (info->buffer); + g_free (info); + + return FALSE; /* remove timeout */ + } + else + { + info->idle_time++; + + return TRUE; /* timeout will happen again */ + } + +} + +/************************************************************* + * gtk_selection_retrieval_report: + * Emits a "selection_received" signal. + * arguments: + * info: information about the retrieval that completed + * buffer: buffer containing data (NULL => errror) + * results: + *************************************************************/ + +static void +gtk_selection_retrieval_report (GtkRetrievalInfo *info, + GdkAtom type, gint format, + guchar *buffer, gint length) +{ + 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); +} + +/************************************************************* + * gtk_selection_find_handler: + * Find handler for specified widget/selection/target + * arguments: + * widget: + * selection: + * target: + * results: + *************************************************************/ + +static GtkSelectionHandler * +gtk_selection_find_handler (GtkWidget *widget, + GdkAtom selection, + GdkAtom target) +{ + GList *tmp_list; + GtkSelectionHandler *handler; + + g_return_val_if_fail (widget != NULL, FALSE); + + tmp_list = gtk_object_get_data (GTK_OBJECT (widget), + gtk_selection_handler_key); + + while (tmp_list) + { + handler = (GtkSelectionHandler *)tmp_list->data; + if ((handler->selection == selection) && (handler->target == target)) + return handler; + tmp_list = tmp_list->next; + } + + return NULL; +} + + +/************************************************************* + * gtk_selection_default_handler: + * Handles some default targets that exist for any widget + * If it can't fit results into buffer, returns -1. This + * won't happen in any conceivable case, since it would + * 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 + *************************************************************/ + +static void +gtk_selection_default_handler (GtkWidget *widget, + GtkSelectionData *data) +{ + if (data->target == gtk_selection_atoms[TIMESTAMP]) + { + /* Time which was used to obtain selection */ + GList *tmp_list; + GtkSelectionInfo *selection_info; + + tmp_list = current_selections; + while (tmp_list) + { + selection_info = (GtkSelectionInfo *)tmp_list->data; + if ((selection_info->widget == widget) && + (selection_info->selection == data->selection)) + { + gtk_selection_data_set (data, + GDK_SELECTION_TYPE_INTEGER, + sizeof (guint32)*8, + (guchar *)&selection_info->time, + sizeof (guint32)); + 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; + 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; + } + + data->type = GDK_SELECTION_TYPE_ATOM; + data->format = 8*sizeof (GdkAtom); + 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); + while (tmp_list) + { + handler = (GtkSelectionHandler *)tmp_list->data; + + if (handler->selection == data->selection) + *p++ = handler->target; + + tmp_list = tmp_list->next; + } + } + else + { + data->length = -1; + } +} |