* 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
+ * 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.
* 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
+ * By Owen Taylor <owt1@cornell.edu> 8/16/97
*/
/* Terminology note: when not otherwise specified, the term "incr" below
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 <stdarg.h>
#include <string.h>
-#include <gdk/gdkx.h>
-/* we need this for gdk_window_lookup() */
+#include "gdk.h"
+
#include "gtkmain.h"
#include "gtkselection.h"
#include "gtksignal.h"
/* 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,
typedef struct _GtkIncrConversion GtkIncrConversion;
typedef struct _GtkIncrInfo GtkIncrInfo;
typedef struct _GtkRetrievalInfo GtkRetrievalInfo;
-typedef struct _GtkSelectionHandler GtkSelectionHandler;
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
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 */
- GtkCallbackMarshal marshal; /* Marshalling function */
- gpointer data; /* callback data */
- GtkDestroyNotify destroy; /* called when callback is removed */
+ 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 void gtk_selection_invoke_handler (GtkWidget *widget,
- GtkSelectionData *data);
-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;
static GdkAtom gtk_selection_atoms[LAST_ATOM];
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:
* Claim ownership of a selection.
* 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;
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
{
}
}
/* 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;
}
/*************************************************************
- * gtk_selection_add_handler_full:
- * 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)
- * marshal: Callback marshal function
- * data: User data for callback
- * destroy: Called when handler removed
+ * info: guint to pass to to the selection_get signal
*
* results:
*************************************************************/
-void
-gtk_selection_add_handler (GtkWidget *widget,
- GdkAtom selection,
- GdkAtom target,
- GtkSelectionFunction function,
- gpointer data)
+typedef struct _GtkSelectionTargetList GtkSelectionTargetList;
+
+struct _GtkSelectionTargetList {
+ GdkAtom selection;
+ GtkTargetList *list;
+};
+
+static GtkTargetList *
+gtk_selection_target_list_get (GtkWidget *widget,
+ GdkAtom selection)
{
- gtk_selection_add_handler_full (widget, selection, target, function,
- NULL, data, NULL);
+ 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)
+ {
+ 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);
+
+ return sellist->list;
}
-void
-gtk_selection_add_handler_full (GtkWidget *widget,
- GdkAtom selection,
- GdkAtom target,
- GtkSelectionFunction function,
- GtkCallbackMarshal marshal,
- gpointer data,
- GtkDestroyNotify destroy)
+static void
+gtk_selection_target_list_remove (GtkWidget *widget)
{
- GList *selection_handlers;
+ GtkSelectionTargetList *sellist;
GList *tmp_list;
- GtkSelectionHandler *handler;
-
- g_return_if_fail (widget != NULL);
- if (initialize)
- gtk_selection_init ();
+ GList *lists;
+
+ 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;
+
+ gtk_target_list_unref (sellist->list);
+
+ g_free (sellist);
+ tmp_list = tmp_list->next;
+ }
+
+ 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);
- /* Reuse old handler structure, if present */
- tmp_list = selection_handlers;
+ tmp_list = lists;
while (tmp_list)
{
- handler = (GtkSelectionHandler *)tmp_list->data;
- if ((handler->selection == selection) && (handler->target == target))
+ sellist = tmp_list->data;
+ if (sellist->selection == selection)
{
- if (handler->destroy)
- (*handler->destroy)(handler->data);
- if (function)
- {
- handler->function = function;
- handler->marshal = marshal;
- handler->data = data;
- handler->destroy = destroy;
- }
- else
- {
- selection_handlers = g_list_remove_link (selection_handlers,
- tmp_list);
- g_list_free (tmp_list);
- g_free (handler);
- }
- return;
+ lists = g_list_delete_link (lists, tmp_list);
+ gtk_target_list_unref (sellist->list);
+ g_free (sellist);
+
+ break;
}
+
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->marshal = marshal;
- handler->data = data;
- handler->destroy = destroy;
- selection_handlers = g_list_append (selection_handlers, handler);
- }
+ 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;
- gtk_object_set_data (GTK_OBJECT (widget), gtk_selection_handler_key,
- selection_handlers);
+ 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
GList *tmp_list;
GList *next;
GtkSelectionInfo *selection_info;
- GList *selection_handlers;
- GtkSelectionHandler *handler;
/* Remove pending requests/incrs for this widget */
tmp_list = next;
}
-
- /* Now remove all handlers */
-
- selection_handlers = gtk_object_get_data (GTK_OBJECT (widget),
- gtk_selection_handler_key);
- gtk_object_remove_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->destroy)
- (*handler->destroy)(handler->data);
-
- g_free (handler);
-
- tmp_list = next;
- }
-
- g_list_free (selection_handlers);
+
+ /* Remove all selection lists */
+ gtk_selection_target_list_remove (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
* 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;
if (owner_widget != NULL)
{
gtk_selection_invoke_handler (owner_widget,
- &selection_data);
+ &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);
* 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->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
* 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)
if (tmp_list)
{
- if (selection_info->time > event->time)
- return FALSE; /* return FALSE to indicate that
- * the selection was out of date,
- * and this clear should be ignored */
- else
- {
- current_selections = g_list_remove_link (current_selections, tmp_list);
- g_list_free (tmp_list);
- g_free (selection_info);
- }
+ current_selections = g_list_remove_link (current_selections, tmp_list);
+ g_list_free (tmp_list);
+ g_free (selection_info);
}
return TRUE;
* results:
*************************************************************/
-gint
+gboolean
gtk_selection_request (GtkWidget *widget,
GdkEventSelection *event)
{
guchar *mult_atoms;
int i;
+ if (initialize)
+ gtk_selection_init ();
+
/* Check if we own selection */
tmp_list = current_selections;
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);
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);
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; i<info->num_conversions; i++)
{
GtkSelectionData data;
- gint items;
+ glong items;
data.selection = event->selection;
data.target = info->conversions[i].target;
data.length = -1;
#ifdef DEBUG_SELECTION
- g_message("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
- gtk_selection_invoke_handler (widget, &data);
+ gtk_selection_invoke_handler (widget, &data, event->time);
if (data.length < 0)
{
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)
{
gdk_property_change (info->requestor,
info->conversions[i].property,
gtk_selection_atoms[INCR],
- 8*sizeof (GdkAtom),
+ 32,
GDK_PROP_MODE_REPLACE,
(guchar *)&items, 1);
}
exist */
#ifdef DEBUG_SELECTION
- g_message("Starting INCR...\n");
+ g_message ("Starting INCR...");
#endif
gdk_window_set_events (info->requestor,
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)
{
* 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;
return FALSE;
#ifdef DEBUG_SELECTION
- g_message("PropertyDelete, property %ld\n", event->atom);
+ g_message ("PropertyDelete, property %ld", event->atom);
#endif
/* Now find the appropriate ongoing INCR */
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
info->conversions[i].offset = -2;
}
#ifdef DEBUG_SELECTION
- g_message("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)
{
* Timeout callback for the sending portion of the INCR
* protocol
* arguments:
- * info: Information about this incr
+ * info: Information about this incr
* results:
*************************************************************/
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 */
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;
}
/*************************************************************
* 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_message("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;
if (!tmp_list) /* no retrieval in progress */
return FALSE;
+
+ 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)
+ 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,
info->offset = length;
gtk_selection_retrieval_report (info,
type, format,
- buffer, length);
+ buffer, length, event->time);
}
gdk_property_delete (widget->window, event->property);
* 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_message("PropertyNewValue, property %ld\n",
- event->atom);
+ g_message ("PropertyNewValue, property %ld",
+ event->atom);
#endif
tmp_list = current_retrievals;
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_message("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;
{
#ifdef DEBUG_SELECTION
- g_message("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);
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 */
{
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.data = buffer;
gtk_signal_emit_by_name (GTK_OBJECT(info->widget),
- "selection_received", &data);
+ "selection_received",
+ &data, time);
}
/*************************************************************
* gtk_selection_default_handler if none exists.
*
* arguments:
- * widget: selection owner
- * data: selection data [INOUT]
+ * widget: selection owner
+ * data: selection data [INOUT]
+ * time: time from requeset
*
* results:
* Number of bytes written to buffer, -1 if error
*************************************************************/
static void
-gtk_selection_invoke_handler (GtkWidget *widget,
- GtkSelectionData *data)
+gtk_selection_invoke_handler (GtkWidget *widget,
+ GtkSelectionData *data,
+ guint time)
{
- GList *tmp_list;
- GtkSelectionHandler *handler;
+ GtkTargetList *target_list;
+ guint info;
+
g_return_if_fail (widget != NULL);
-
- tmp_list = gtk_object_get_data (GTK_OBJECT (widget),
- gtk_selection_handler_key);
-
- while (tmp_list)
+
+ 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 == data->selection) &&
- (handler->target == data->target))
- break;
- tmp_list = tmp_list->next;
+ gtk_signal_emit_by_name (GTK_OBJECT (widget),
+ "selection_get",
+ data,
+ info, time);
}
-
- if (tmp_list == NULL)
- gtk_selection_default_handler (widget, data);
else
- {
- if (handler->marshal)
- {
- GtkArg args[2];
- args[0].type = GTK_TYPE_BOXED;
- args[0].name = NULL;
- GTK_VALUE_BOXED(args[0]) = data;
- args[1].type = GTK_TYPE_NONE;
- args[1].name = NULL;
-
- handler->marshal (GTK_OBJECT(widget), handler->data, 1, args);
- }
- else
- if (handler->function)
- handler->function (widget, data, handler->data);
- }
+ gtk_selection_default_handler (widget, data);
}
/*************************************************************
* require 1000 selection targets!
*
* arguments:
- * widget: selection owner
- * data: selection data [INOUT]
+ * 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])
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;
}
{
/* List of all targets supported for this widget/selection pair */
GdkAtom *p;
- gint count;
+ guint count;
GList *tmp_list;
- GtkSelectionHandler *handler;
+ GtkTargetList *target_list;
+ GtkTargetPair *pair;
- 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;
- }
+ 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[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;
}
}
-GtkSelectioData*
-gtk_selection_data_copy (GtkSelectionData *data)
+GtkSelectionData*
+gtk_selection_data_copy (GtkSelectionData *selection_data)
{
GtkSelectionData *new_data;
- g_return_val_if_fail (data != NULL, NULL);
+ g_return_val_if_fail (selection_data != NULL, NULL);
new_data = g_new (GtkSelectionData, 1);
- *new_data = *data;
+ *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;
}
{
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;
+}
projects / ~andy / gtk / blobdiff