* Boston, MA 02111-1307, USA.
*/
-/* This file implements most of the work of the ICCM selection protocol.
+/* This file implements most of the work of the ICCCM selection protocol.
* The code was written after an intensive study of the equivalent part
* of John Ousterhout's Tk toolkit, and does many things in much the
* same way.
*
- * The one thing in the ICCM that isn't fully supported here (or in Tk)
+ * The one thing in the ICCCM that isn't fully supported here (or in Tk)
* is side effects targets. For these to be handled properly, MULTIPLE
* targets need to be done in the order specified. This cannot be
* guaranteed with the way we do things, since if we are doing INCR
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
+#include <config.h>
#include <stdarg.h>
#include <string.h>
#include "gdk.h"
-#if defined (GDK_WINDOWING_X11)
-#include "x11/gdkx.h" /* For gdk_window_lookup() */
-#elif defined (GDK_WINDOWING_WIN32)
-#include "win32/gdkwin32.h" /* For gdk_window_lookup() */
-#elif defined (GDK_WINDOWING_FB)
-#include "linux-fb/gdkfb.h" /* For gdk_window_lookup() */
-#elif defined (GDK_WINDOWING_NANOX)
-#include "nanox/gdkprivate-nanox.h" /* For gdk_window_lookup() */
-#endif
-
#include "gtkmain.h"
#include "gtkselection.h"
-#include "gtksignal.h"
-/* #define DEBUG_SELECTION */
+#ifdef GDK_WINDOWING_X11
+#include "x11/gdkx.h"
+#endif
+
+#define DEBUG_SELECTION
/* 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
+#define GTK_SELECTION_MAX_SIZE(display) G_MAXINT
#else
-#define GTK_SELECTION_MAX_SIZE 4000
+#define GTK_SELECTION_MAX_SIZE(display) \
+ MIN(262144, \
+ XExtendedMaxRequestSize (GDK_DISPLAY_XDISPLAY (display)) == 0 \
+ ? XMaxRequestSize (GDK_DISPLAY_XDISPLAY (display)) - 100 \
+ : XExtendedMaxRequestSize (GDK_DISPLAY_XDISPLAY (display)) - 100)
#endif
+
+#define IDLE_ABORT_TIME 300
+
enum {
INCR,
MULTIPLE,
struct _GtkSelectionInfo
{
- GdkAtom selection;
- GtkWidget *widget; /* widget that owns selection */
- guint32 time; /* time used to acquire selection */
+ GdkAtom selection;
+ GtkWidget *widget; /* widget that owns selection */
+ guint32 time; /* time used to acquire selection */
+ GdkDisplay *display; /* needed in gtk_selection_remove_all */
};
struct _GtkIncrConversion
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 */
static GList *current_selections = NULL;
static GdkAtom gtk_selection_atoms[LAST_ATOM];
-static const char *gtk_selection_handler_key = "gtk-selection-handlers";
+static const char gtk_selection_handler_key[] = "gtk-selection-handlers";
/****************
* Target Lists *
return FALSE;
}
-
-/*************************************************************
- * 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)
+/**
+ * gtk_selection_owner_set_for_display:
+ * @display: the #Gdkdisplay where the selection is set
+ * @widget: new selection owner (a #GdkWidget), or %NULL.
+ * @selection: an interned atom representing the selection to claim.
+ * @time_: timestamp with which to claim the selection
*
- * results:
- *************************************************************/
-
+ * Claim ownership of a given selection for a particular widget, or,
+ * if @widget is %NULL, release ownership of the selection.
+ *
+ * Return value: TRUE if the operation succeeded
+ *
+ * Since: 2.2
+ */
gboolean
-gtk_selection_owner_set (GtkWidget *widget,
- GdkAtom selection,
- guint32 time)
+gtk_selection_owner_set_for_display (GdkDisplay *display,
+ GtkWidget *widget,
+ GdkAtom selection,
+ guint32 time)
{
GList *tmp_list;
GtkWidget *old_owner;
GtkSelectionInfo *selection_info = NULL;
GdkWindow *window;
+ g_return_val_if_fail (GDK_IS_DISPLAY (display), FALSE);
+ g_return_val_if_fail (selection != GDK_NONE, FALSE);
g_return_val_if_fail (widget == NULL || GTK_WIDGET_REALIZED (widget), FALSE);
+ g_return_val_if_fail (widget == NULL || gtk_widget_get_display (widget) == display, FALSE);
if (widget == NULL)
window = NULL;
tmp_list = tmp_list->next;
}
- if (gdk_selection_owner_set (window, selection, time, TRUE))
+ if (gdk_selection_owner_set_for_display (display, window, selection, time, TRUE))
{
old_owner = NULL;
selection_info->selection = selection;
selection_info->widget = widget;
selection_info->time = time;
- current_selections = g_list_prepend (current_selections,
+ selection_info->display = display;
+ current_selections = g_list_prepend (current_selections,
selection_info);
}
else
old_owner = selection_info->widget;
selection_info->widget = widget;
selection_info->time = time;
+ selection_info->display = display;
}
}
/* If another widget in the application lost the selection,
*/
if (old_owner && old_owner != widget)
{
- GdkEventSelection event;
+ GdkEvent *event = gdk_event_new (GDK_SELECTION_CLEAR);
- event.type = GDK_SELECTION_CLEAR;
- event.window = old_owner->window;
- event.selection = selection;
- event.time = time;
+ event->selection.window = g_object_ref (old_owner->window);
+ event->selection.selection = selection;
+ event->selection.time = time;
- gtk_widget_event (old_owner, (GdkEvent *) &event);
+ gtk_widget_event (old_owner, event);
+
+ gdk_event_free (event);
}
return TRUE;
}
return FALSE;
}
+/**
+ * gtk_selection_owner_set:
+ * @widget: a #GtkWidget, or %NULL.
+ * @selection: an interned atom representing the selection to claim
+ * @time_: timestamp with which to claim the selection
+ *
+ * Claims ownership of a given selection for a particular widget,
+ * or, if @widget is %NULL, release ownership of the selection.
+ *
+ * Return value: %TRUE if the operation succeeded
+ **/
+gboolean
+gtk_selection_owner_set (GtkWidget *widget,
+ GdkAtom selection,
+ guint32 time)
+{
+ GdkDisplay *display;
+
+ g_return_val_if_fail (widget == NULL || GTK_WIDGET_REALIZED (widget), FALSE);
+ g_return_val_if_fail (selection != GDK_NONE, FALSE);
+
+ if (widget)
+ display = gtk_widget_get_display (widget);
+ else
+ {
+ GTK_NOTE (MULTIHEAD,
+ g_warning ("gtk_selection_owner_set (NULL,...) is not multihead safe"));
+
+ display = gdk_display_get_default ();
+ }
+
+ return gtk_selection_owner_set_for_display (display, widget,
+ selection, time);
+}
+
/*************************************************************
* gtk_selection_add_target
* Add specified target to list of supported targets
GList *tmp_list;
GList *lists;
- lists = gtk_object_get_data (GTK_OBJECT (widget), gtk_selection_handler_key);
+ lists = g_object_get_data (G_OBJECT (widget), gtk_selection_handler_key);
tmp_list = lists;
while (tmp_list)
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);
+ g_object_set_data (G_OBJECT (widget), gtk_selection_handler_key, lists);
return sellist->list;
}
GList *tmp_list;
GList *lists;
- lists = gtk_object_get_data (GTK_OBJECT (widget), gtk_selection_handler_key);
+ lists = g_object_get_data (G_OBJECT (widget), gtk_selection_handler_key);
tmp_list = lists;
while (tmp_list)
}
g_list_free (lists);
- gtk_object_set_data (GTK_OBJECT (widget), gtk_selection_handler_key, NULL);
+ g_object_set_data (G_OBJECT (widget), gtk_selection_handler_key, NULL);
}
/**
GList *tmp_list;
GList *lists;
- lists = gtk_object_get_data (GTK_OBJECT (widget), gtk_selection_handler_key);
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (selection != GDK_NONE);
+
+ lists = g_object_get_data (G_OBJECT (widget), gtk_selection_handler_key);
tmp_list = lists;
while (tmp_list)
tmp_list = tmp_list->next;
}
- gtk_object_set_data (GTK_OBJECT (widget), gtk_selection_handler_key, lists);
+ g_object_set_data (G_OBJECT (widget), gtk_selection_handler_key, lists);
}
void
{
GtkTargetList *list;
- g_return_if_fail (widget != NULL);
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (selection != GDK_NONE);
list = gtk_selection_target_list_get (widget, selection);
gtk_target_list_add (list, target, 0, info);
guint ntargets)
{
GtkTargetList *list;
-
- g_return_if_fail (widget != NULL);
+
+ g_return_if_fail (GTK_IS_WIDGET (widget));
+ g_return_if_fail (selection != GDK_NONE);
g_return_if_fail (targets != NULL);
list = gtk_selection_target_list_get (widget, selection);
/* 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)
{
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,
+ gdk_selection_owner_set_for_display (selection_info->display,
+ 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);
GtkRetrievalInfo *info;
GList *tmp_list;
GdkWindow *owner_window;
+ GdkDisplay *display;
- g_return_val_if_fail (widget != NULL, FALSE);
+ g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
+ g_return_val_if_fail (selection != GDK_NONE, FALSE);
if (initialize)
gtk_selection_init ();
info->widget = widget;
info->selection = selection;
info->target = target;
+ info->idle_time = 0;
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);
+
+ display = gtk_widget_get_display (widget);
+ owner_window = gdk_selection_owner_get_for_display (display, selection);
if (owner_window != NULL)
{
selection_data.target = target;
selection_data.data = NULL;
selection_data.length = -1;
+ selection_data.display = display;
gdk_window_get_user_data (owner_window, (gpointer *)&owner_widget);
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);
+ g_timeout_add (1000, (GSourceFunc) gtk_selection_retrieval_timeout, info);
return TRUE;
}
}
}
+static gboolean
+selection_set_string (GtkSelectionData *selection_data,
+ const gchar *str,
+ gint len)
+{
+ gchar *tmp = g_strndup (str, len);
+ gchar *latin1 = gdk_utf8_to_string_target (tmp);
+ g_free (tmp);
+
+ if (latin1)
+ {
+ gtk_selection_data_set (selection_data,
+ GDK_SELECTION_TYPE_STRING,
+ 8, latin1, strlen (latin1));
+ g_free (latin1);
+
+ return TRUE;
+ }
+ else
+ return FALSE;
+}
+
+static gboolean
+selection_set_compound_text (GtkSelectionData *selection_data,
+ const gchar *str,
+ gint len)
+{
+ gchar *tmp;
+ guchar *text;
+ GdkAtom encoding;
+ gint format;
+ gint new_length;
+ gboolean result = FALSE;
+
+ tmp = g_strndup (str, len);
+ if (gdk_utf8_to_compound_text_for_display (selection_data->display, tmp,
+ &encoding, &format, &text, &new_length))
+ {
+ gtk_selection_data_set (selection_data, encoding, format, text, new_length);
+ gdk_free_compound_text (text);
+
+ result = TRUE;
+ }
+
+ g_free (tmp);
+
+ return result;
+}
+
/**
* gtk_selection_data_set_text:
* @selection_data: a #GtkSelectionData
* @str: a UTF-8 string
+ * @len: the length of @str, or -1 if @str is nul-terminated.
*
* 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 succesfully set,
+ * Return value: %TRUE if the selection was successfully set,
* otherwise %FALSE.
**/
gboolean
gtk_selection_data_set_text (GtkSelectionData *selection_data,
- const guchar *str)
+ const gchar *str,
+ gint len)
{
+ if (len < 0)
+ len = strlen (str);
+
init_atoms ();
if (selection_data->target == utf8_atom)
{
gtk_selection_data_set (selection_data,
utf8_atom,
- 8, (guchar *)str, strlen (str));
+ 8, (guchar *)str, len);
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;
- }
-
+ return selection_set_string (selection_data, str, len);
}
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;
- }
+ if (selection_set_compound_text (selection_data, str, len))
+ return TRUE;
+ else if (selection_data->target == text_atom)
+ return selection_set_string (selection_data, str, len);
}
-
+
return FALSE;
}
{
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);
+ gint count = gdk_text_property_to_utf8_list_for_display (selection_data->display,
+ selection_data->type,
+ selection_data->format,
+ selection_data->data,
+ selection_data->length,
+ &list);
if (count > 0)
result = list[0];
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.
+ *
+ * Gets 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
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);
+
+ initialize = FALSE;
}
-/*************************************************************
+/**
* gtk_selection_clear:
- * Handler for "selection_clear_event"
- * arguments:
- * widget:
- * event:
- * results:
- *************************************************************/
-
+ * @widget: a #GtkWidget
+ * @event: the event
+ *
+ * The default handler for the GtkWidget::selection_clear_event
+ * signal.
+ *
+ * Return value: %TRUE if the event was handled, otherwise false
+ *
+ * Since: 2.2
+ *
+ * Deprecated: Instead of calling this function, chain up from
+ * your selection_clear_event handler. Calling this function
+ * from any other context is illegal.
+ **/
gboolean
gtk_selection_clear (GtkWidget *widget,
GdkEventSelection *event)
/*************************************************************
- * gtk_selection_request:
+ * _gtk_selection_request:
* Handler for "selection_request_event"
* arguments:
* widget:
*************************************************************/
gboolean
-gtk_selection_request (GtkWidget *widget,
- GdkEventSelection *event)
+_gtk_selection_request (GtkWidget *widget,
+ GdkEventSelection *event)
{
+ GdkDisplay *display = gtk_widget_get_display (widget);
GtkIncrInfo *info;
GList *tmp_list;
- guchar *mult_atoms;
int i;
-
+ gulong selection_max_size;
+
if (initialize)
gtk_selection_init ();
+ g_message ("max request sizes %ld %ld\n",
+ XMaxRequestSize(GDK_DISPLAY_XDISPLAY(display)),
+ XExtendedMaxRequestSize(GDK_DISPLAY_XDISPLAY(display)));
+ selection_max_size = GTK_SELECTION_MAX_SIZE (display);
+
/* Check if we own selection */
tmp_list = current_selections;
return FALSE;
info = g_new (GtkIncrInfo, 1);
+
+ g_object_ref (widget);
- info->widget = widget;
info->selection = event->selection;
info->num_incrs = 0;
/* Create GdkWindow structure for the requestor */
-#if defined(GDK_WINDOWING_WIN32) || defined(GDK_WINDOWING_X11) || defined(GDK_WINDOWING_FB)
- info->requestor = gdk_window_lookup (event->requestor);
+ info->requestor = gdk_window_lookup_for_display (display,
+ event->requestor);
if (!info->requestor)
- info->requestor = gdk_window_foreign_new (event->requestor);
-#else
- info->requestor = NULL;
-#endif
+ info->requestor = gdk_window_foreign_new_for_display (display,
+ event->requestor);
/* Determine conversions we need to perform */
if (event->target == gtk_selection_atoms[MULTIPLE])
{
GdkAtom type;
+ guchar *mult_atoms;
gint format;
gint length;
mult_atoms = NULL;
gdk_error_trap_push ();
- if (!gdk_property_get (info->requestor, event->property, 0, /* AnyPropertyType */
- 0, GTK_SELECTION_MAX_SIZE, FALSE,
+ if (!gdk_property_get (info->requestor, event->property, GDK_NONE, /* AnyPropertyType */
+ 0, selection_max_size, FALSE,
&type, &format, &length, &mult_atoms))
{
- gdk_selection_send_notify (event->requestor, event->selection,
- event->target, GDK_NONE, event->time);
+ gdk_selection_send_notify_for_display (display,
+ event->requestor,
+ event->selection,
+ event->target,
+ GDK_NONE,
+ event->time);
g_free (mult_atoms);
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++)
+
+ /* This is annoying; the ICCCM doesn't specify the property type
+ * used for the property contents, so the autoconversion for
+ * ATOM / ATOM_PAIR in GDK doesn't work properly.
+ */
+#ifdef GDK_WINDOWING_X11
+ if (type != GDK_SELECTION_TYPE_ATOM &&
+ type != gdk_atom_intern ("ATOM_PAIR", FALSE))
{
- info->conversions[i].target = ((GdkAtom *)mult_atoms)[2*i];
- info->conversions[i].property = ((GdkAtom *)mult_atoms)[2*i+1];
+ info->num_conversions = length / (2*sizeof (glong));
+ info->conversions = g_new (GtkIncrConversion, info->num_conversions);
+
+ for (i=0; i<info->num_conversions; i++)
+ {
+ info->conversions[i].target = gdk_x11_xatom_to_atom_for_display (display,
+ ((glong *)mult_atoms)[2*i]);
+ info->conversions[i].property = gdk_x11_xatom_to_atom_for_display (display,
+ ((glong *)mult_atoms)[2*i + 1]);
+ }
+ }
+ else
+#endif
+ {
+ 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->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
data.target = info->conversions[i].target;
data.data = NULL;
data.length = -1;
+ data.display = gtk_widget_get_display (widget);
#ifdef DEBUG_SELECTION
g_message ("Selection %ld, target %ld (%s) requested by 0x%x (property = %ld)",
- event->selection, info->conversions[i].target,
+ event->selection,
+ info->conversions[i].target,
gdk_atom_name (info->conversions[i].target),
- event->requestor, event->property);
+ event->requestor, info->conversions[i].property);
#endif
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;
}
items = data.length / gtk_selection_bytes_per_item (data.format);
- if (data.length > GTK_SELECTION_MAX_SIZE)
+ if (data.length > selection_max_size)
{
/* Sending via INCR */
+#ifdef DEBUG_SELECTION
+ g_message ("Target larger (%d) than max. request size (%ld), sending incrementally\n",
+ data.length, selection_max_size);
+#endif
info->conversions[i].offset = 0;
info->conversions[i].data = data;
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);
+ g_timeout_add (1000, (GSourceFunc) 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])
{
+ GdkAtom *mult_atoms = g_new (GdkAtom, 2 * info->num_conversions);
+ for (i = 0; i < info->num_conversions; i++)
+ {
+ mult_atoms[2*i] = info->conversions[i].target;
+ mult_atoms[2*i+1] = info->conversions[i].property;
+ }
+
gdk_property_change (info->requestor, event->property,
- GDK_SELECTION_TYPE_ATOM, 32,
+ gdk_atom_intern ("ATOM_PAIR", FALSE), 32,
GDK_PROP_MODE_REPLACE,
- mult_atoms, 2*info->num_conversions);
+ (guchar *)mult_atoms, 2*info->num_conversions);
g_free (mult_atoms);
}
info->conversions[0].property == GDK_NONE)
{
/* Reject the entire conversion */
- gdk_selection_send_notify (event->requestor, event->selection,
- event->target, GDK_NONE, event->time);
+ gdk_selection_send_notify_for_display (gtk_widget_get_display (widget),
+ 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);
+ gdk_selection_send_notify_for_display (gtk_widget_get_display (widget),
+ event->requestor,
+ event->selection,
+ event->target,
+ event->property,
+ event->time);
}
-
+
if (info->num_incrs == 0)
{
g_free (info->conversions);
g_free (info);
}
+
+ g_object_unref (widget);
return TRUE;
}
/*************************************************************
- * gtk_selection_incr_event:
+ * _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
*************************************************************/
gboolean
-gtk_selection_incr_event (GdkWindow *window,
- GdkEventProperty *event)
+_gtk_selection_incr_event (GdkWindow *window,
+ GdkEventProperty *event)
{
GList *tmp_list;
GtkIncrInfo *info = NULL;
gint num_bytes;
guchar *buffer;
+ gulong selection_max_size;
int i;
#ifdef DEBUG_SELECTION
g_message ("PropertyDelete, property %ld", event->atom);
#endif
-
+
+ selection_max_size = GTK_SELECTION_MAX_SIZE (gdk_drawable_get_display (window));
+
/* Now find the appropriate ongoing INCR */
tmp_list = current_incrs;
while (tmp_list)
buffer = info->conversions[i].data.data +
info->conversions[i].offset;
- if (num_bytes > GTK_SELECTION_MAX_SIZE)
+ if (num_bytes > selection_max_size)
{
- num_bytes = GTK_SELECTION_MAX_SIZE;
- info->conversions[i].offset += GTK_SELECTION_MAX_SIZE;
+ num_bytes = selection_max_size;
+ info->conversions[i].offset += selection_max_size;
}
else
info->conversions[i].offset = -2;
info->conversions[i].offset = -1;
}
}
- break;
}
/* Check if we're finished with all the targets */
}
/* If retrieval is finished */
- if (!tmp_list || info->idle_time >= 5)
+ if (!tmp_list || info->idle_time >= IDLE_ABORT_TIME)
{
- if (tmp_list && info->idle_time >= 5)
+ if (tmp_list && info->idle_time >= IDLE_ABORT_TIME)
{
current_incrs = g_list_remove_link (current_incrs, tmp_list);
g_list_free (tmp_list);
}
/*************************************************************
- * gtk_selection_notify:
+ * _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.
*************************************************************/
gboolean
-gtk_selection_notify (GtkWidget *widget,
- GdkEventSelection *event)
+_gtk_selection_notify (GtkWidget *widget,
+ GdkEventSelection *event)
{
GList *tmp_list;
GtkRetrievalInfo *info = NULL;
}
/*************************************************************
- * gtk_selection_property_notify:
+ * _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.
*************************************************************/
gboolean
-gtk_selection_property_notify (GtkWidget *widget,
- GdkEventProperty *event)
+_gtk_selection_property_notify (GtkWidget *widget,
+ GdkEventProperty *event)
{
GList *tmp_list;
GtkRetrievalInfo *info = NULL;
}
/* If retrieval is finished */
- if (!tmp_list || info->idle_time >= 5)
+ if (!tmp_list || info->idle_time >= IDLE_ABORT_TIME)
{
- if (tmp_list && info->idle_time >= 5)
+ if (tmp_list && info->idle_time >= IDLE_ABORT_TIME)
{
current_retrievals = g_list_remove_link (current_retrievals, tmp_list);
g_list_free (tmp_list);
data.length = length;
data.data = buffer;
+ data.display = gtk_widget_get_display (info->widget);
- gtk_signal_emit_by_name (GTK_OBJECT(info->widget),
- "selection_received",
- &data, time);
+ g_signal_emit_by_name (info->widget,
+ "selection_received",
+ &data, time);
}
/*************************************************************
if (target_list &&
gtk_target_list_find (target_list, data->target, &info))
{
- gtk_signal_emit_by_name (GTK_OBJECT (widget),
- "selection_get",
- data,
- info, time);
+ g_signal_emit_by_name (widget,
+ "selection_get",
+ data,
+ info, time);
}
else
gtk_selection_default_handler (widget, data);
data->type = GDK_SELECTION_TYPE_ATOM;
data->format = 32;
data->length = count * sizeof (GdkAtom);
-
- p = g_new (GdkAtom, count);
+
+ /* selection data is always terminated by a trailing \0
+ */
+ p = g_malloc (data->length + 1);
data->data = (guchar *)p;
+ data->data[data->length] = '\0';
*p++ = gtk_selection_atoms[TIMESTAMP];
*p++ = gtk_selection_atoms[TARGETS];
g_free (data);
}
+GType
+gtk_selection_data_get_type (void)
+{
+ static GType our_type = 0;
+
+ if (our_type == 0)
+ our_type = g_boxed_type_register_static ("GtkSelectionData",
+ (GBoxedCopyFunc) gtk_selection_data_copy,
+ (GBoxedFreeFunc) gtk_selection_data_free);
+
+ return our_type;
+}
+
static int
gtk_selection_bytes_per_item (gint format)
{