* 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
#include <string.h>
#include "gdk.h"
+#include "gtkalias.h"
#include "gtkmain.h"
#include "gtkselection.h"
+#include "gdk-pixbuf/gdk-pixbuf.h"
#ifdef GDK_WINDOWING_X11
#include "x11/gdkx.h"
#endif
-/* #define DEBUG_SELECTION */
+#undef 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
+#ifdef GDK_WINDOWING_X11
+#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)
#else
-#define GTK_SELECTION_MAX_SIZE 4000
+/* No chunks on Win32 */
+#define GTK_SELECTION_MAX_SIZE(display) G_MAXINT
#endif
-#define IDLE_ABORT_TIME 300
+#define IDLE_ABORT_TIME 30
enum {
INCR,
void
gtk_target_list_add (GtkTargetList *list,
- GdkAtom target,
- guint flags,
- guint info)
+ GdkAtom target,
+ guint flags,
+ guint info)
{
GtkTargetPair *pair;
list->list = g_list_append (list->list, pair);
}
+static GdkAtom utf8_atom;
+static GdkAtom text_atom;
+static GdkAtom ctext_atom;
+static GdkAtom text_plain_atom;
+static GdkAtom text_plain_utf8_atom;
+static GdkAtom text_plain_locale_atom;
+static GdkAtom text_uri_list_atom;
+
+static void
+init_atoms (void)
+{
+ gchar *tmp;
+ const gchar *charset;
+
+ 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);
+ text_plain_atom = gdk_atom_intern ("text/plain", FALSE);
+ text_plain_utf8_atom = gdk_atom_intern ("text/plain;charset=utf-8", FALSE);
+ g_get_charset (&charset);
+ tmp = g_strdup_printf ("text/plain;charset=%s", charset);
+ text_plain_locale_atom = gdk_atom_intern (tmp, FALSE);
+ g_free (tmp);
+
+ text_uri_list_atom = gdk_atom_intern ("text/uri-list", FALSE);
+ }
+}
+
+/**
+ * gtk_target_list_add_text_targets:
+ * @list: a #GtkTargetList
+ * @info: an ID that will be passed back to the application
+ *
+ * Adds the text targets supported by #GtkSelection to
+ * the target list. All targets are added with the same @info.
+ *
+ * Since: 2.6
+ **/
+void
+gtk_target_list_add_text_targets (GtkTargetList *list,
+ guint info)
+{
+ g_return_if_fail (list != NULL);
+
+ init_atoms ();
+
+ /* Keep in sync with gtk_selection_data_targets_include_text()
+ */
+ gtk_target_list_add (list, utf8_atom, 0, info);
+ gtk_target_list_add (list, ctext_atom, 0, info);
+ gtk_target_list_add (list, text_atom, 0, info);
+ gtk_target_list_add (list, GDK_TARGET_STRING, 0, info);
+ gtk_target_list_add (list, text_plain_utf8_atom, 0, info);
+ gtk_target_list_add (list, text_plain_locale_atom, 0, info);
+ gtk_target_list_add (list, text_plain_atom, 0, info);
+}
+
+/**
+ * gtk_target_list_add_image_targets:
+ * @list: a #GtkTargetList
+ * @info: an ID that will be passed back to the application
+ * @writable: whether to add only targets for which GTK+ knows
+ * how to convert a pixbuf into the format
+ *
+ * Adds the image targets supported by #GtkSelection to
+ * the target list. All targets are added with the same @info.
+ *
+ * Since: 2.6
+ **/
+void
+gtk_target_list_add_image_targets (GtkTargetList *list,
+ guint info,
+ gboolean writable)
+{
+ GSList *formats, *f;
+ gchar **mimes, **m;
+ GdkAtom atom;
+
+ g_return_if_fail (list != NULL);
+
+ formats = gdk_pixbuf_get_formats ();
+
+ for (f = formats; f; f = f->next)
+ {
+ GdkPixbufFormat *fmt = f->data;
+
+ if (writable && !gdk_pixbuf_format_is_writable (fmt))
+ continue;
+
+ mimes = gdk_pixbuf_format_get_mime_types (fmt);
+ for (m = mimes; *m; m++)
+ {
+ atom = gdk_atom_intern (*m, FALSE);
+ gtk_target_list_add (list, atom, 0, info);
+ }
+ g_strfreev (mimes);
+ }
+
+ g_slist_free (formats);
+}
+
+/**
+ * gtk_target_list_add_uri_targets:
+ * @list: a #GtkTargetList
+ * @info: an ID that will be passed back to the application
+ *
+ * Adds the URI targets supported by #GtkSelection to
+ * the target list. All targets are added with the same @info.
+ *
+ * Since: 2.6
+ **/
+void
+gtk_target_list_add_uri_targets (GtkTargetList *list,
+ guint info)
+{
+ g_return_if_fail (list != NULL);
+
+ init_atoms ();
+
+ gtk_target_list_add (list, text_uri_list_atom, 0, info);
+}
+
void
gtk_target_list_add_table (GtkTargetList *list,
const GtkTargetEntry *targets,
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);
- }
-}
-
static gboolean
selection_set_string (GtkSelectionData *selection_data,
const gchar *str,
return result;
}
+/* Normalize \r and \n into \r\n
+ */
+static gchar *
+normalize_to_crlf (const gchar *str,
+ gint len)
+{
+ GString *result = g_string_sized_new (len);
+ const gchar *p = str;
+
+ while (1)
+ {
+ if (*p == '\n')
+ g_string_append_c (result, '\r');
+
+ if (*p == '\r')
+ {
+ g_string_append_c (result, *p);
+ p++;
+ if (*p != '\n')
+ g_string_append_c (result, '\n');
+ }
+
+ if (*p == '\0')
+ break;
+
+ g_string_append_c (result, *p);
+ p++;
+ }
+
+ return g_string_free (result, FALSE);
+}
+
+/* Normalize \r and \r\n into \n
+ */
+static gchar *
+normalize_to_lf (gchar *str,
+ gint len)
+{
+ GString *result = g_string_sized_new (len);
+ const gchar *p = str;
+
+ while (1)
+ {
+ if (*p == '\r')
+ {
+ p++;
+ if (*p != '\n')
+ g_string_append_c (result, '\n');
+ }
+
+ if (*p == '\0')
+ break;
+
+ g_string_append_c (result, *p);
+ p++;
+ }
+
+ return g_string_free (result, FALSE);
+}
+
+static gboolean
+selection_set_text_plain (GtkSelectionData *selection_data,
+ const gchar *str,
+ gint len)
+{
+ const gchar *charset = NULL;
+ gchar *result;
+ GError *error = NULL;
+
+ result = normalize_to_crlf (str, len);
+ if (selection_data->target == text_plain_atom)
+ charset = "ASCII";
+ else if (selection_data->target == text_plain_locale_atom)
+ g_get_charset (&charset);
+
+ if (charset)
+ {
+ gchar *tmp = result;
+ result = g_convert_with_fallback (tmp, -1,
+ charset, "UTF-8",
+ NULL, NULL, NULL, &error);
+ g_free (tmp);
+ }
+
+ if (!result)
+ {
+ g_warning ("Error converting from UTF-8 to %s: %s",
+ charset, error->message);
+ g_error_free (error);
+
+ return FALSE;
+ }
+
+ gtk_selection_data_set (selection_data,
+ selection_data->target,
+ 8, result, strlen (result));
+ g_free (result);
+
+ return TRUE;
+}
+
+static gchar *
+selection_get_text_plain (GtkSelectionData *selection_data)
+{
+ const gchar *charset = NULL;
+ gchar *str, *result;
+ gsize len;
+ GError *error = NULL;
+
+ str = g_strdup (selection_data->data);
+ len = selection_data->length;
+
+ if (selection_data->type == text_plain_atom)
+ charset = "ISO-8859-1";
+ else if (selection_data->type == text_plain_locale_atom)
+ g_get_charset (&charset);
+
+ if (charset)
+ {
+ gchar *tmp = str;
+ str = g_convert_with_fallback (tmp, len,
+ charset, "UTF-8",
+ NULL, NULL, &len, &error);
+ g_free (tmp);
+
+ if (!str)
+ {
+ g_warning ("Error converting from %s to UTF-8: %s",
+ charset, error->message);
+ g_error_free (error);
+
+ return NULL;
+ }
+ }
+ else if (!g_utf8_validate (str, -1, NULL))
+ {
+ g_warning ("Error converting from text/plain;charset=utf-8 to UTF-8");
+ g_free (str);
+
+ return NULL;
+ }
+
+ result = normalize_to_lf (str, len);
+ g_free (str);
+
+ return result;
+}
+
/**
* gtk_selection_data_set_text:
* @selection_data: a #GtkSelectionData
else if (selection_data->target == text_atom)
return selection_set_string (selection_data, str, len);
}
+ else if (selection_data->target == text_plain_atom ||
+ selection_data->target == text_plain_utf8_atom ||
+ selection_data->target == text_plain_locale_atom)
+ {
+ return selection_set_text_plain (selection_data, str, len);
+ }
return FALSE;
}
g_free (list[i]);
g_free (list);
}
+ else if (selection_data->length >= 0 &&
+ (selection_data->type == text_plain_atom ||
+ selection_data->type == text_plain_utf8_atom ||
+ selection_data->type == text_plain_locale_atom))
+ {
+ result = selection_get_text_plain (selection_data);
+ }
return result;
}
+/**
+ * gtk_selection_data_set_pixbuf:
+ * @selection_data: a #GtkSelectionData
+ * @pixbuf: a #GdkPixbuf
+ *
+ * Sets the contents of the selection from a #GdkPixbuf
+ * The pixbuf is converted to the form determined by
+ * @selection_data->target.
+ *
+ * Return value: %TRUE if the selection was successfully set,
+ * otherwise %FALSE.
+ *
+ * Since: 2.6
+ **/
+gboolean
+gtk_selection_data_set_pixbuf (GtkSelectionData *selection_data,
+ GdkPixbuf *pixbuf)
+{
+ GSList *formats, *f;
+ gchar **mimes, **m;
+ GdkAtom atom;
+ gboolean result;
+ gchar *str, *type;
+ gsize len;
+
+ formats = gdk_pixbuf_get_formats ();
+
+ for (f = formats; f; f = f->next)
+ {
+ GdkPixbufFormat *fmt = f->data;
+
+ mimes = gdk_pixbuf_format_get_mime_types (fmt);
+ for (m = mimes; *m; m++)
+ {
+ atom = gdk_atom_intern (*m, FALSE);
+ if (selection_data->target == atom)
+ {
+ str = NULL;
+ type = gdk_pixbuf_format_get_name (fmt),
+ result = gdk_pixbuf_save_to_buffer (pixbuf, &str, &len,
+ type, NULL, NULL);
+ if (result)
+ gtk_selection_data_set (selection_data,
+ atom, 8, (guchar *)str, len);
+ g_free (type);
+ g_free (str);
+ g_strfreev (mimes);
+ g_slist_free (formats);
+
+ return result;
+ }
+ }
+
+ g_strfreev (mimes);
+ }
+
+ g_slist_free (formats);
+
+ return FALSE;
+}
+
+/**
+ * gtk_selection_data_get_pixbuf:
+ * @selection_data: a #GtkSelectionData
+ *
+ * Gets the contents of the selection data as a #GdkPixbuf.
+ *
+ * Return value: if the selection data contained a recognized
+ * image type and it could be converted to a #GdkPixbuf, a
+ * newly allocated pixbuf is returned, otherwise %NULL.
+ * If the result is non-%NULL it must be freed with g_object_unref().
+ *
+ * Since: 2.6
+ **/
+GdkPixbuf *
+gtk_selection_data_get_pixbuf (GtkSelectionData *selection_data)
+{
+ GdkPixbufLoader *loader;
+ GdkPixbuf *result = NULL;
+
+ if (selection_data->length > 0)
+ {
+ loader = gdk_pixbuf_loader_new ();
+
+ if (gdk_pixbuf_loader_write (loader,
+ selection_data->data,
+ selection_data->length,
+ NULL))
+ result = gdk_pixbuf_loader_get_pixbuf (loader);
+
+ if (result)
+ g_object_ref (result);
+
+ gdk_pixbuf_loader_close (loader, NULL);
+ g_object_unref (loader);
+ }
+
+ return result;
+}
+
+/**
+ * gtk_selection_data_set_uris:
+ * @selection_data: a #GtkSelectionData
+ * @uris: a %NULL-terminated array of strings hilding URIs
+ *
+ * Sets the contents of the selection from a list of URIs.
+ * The string is converted to the form determined by
+ * @selection_data->target.
+ *
+ * Return value: %TRUE if the selection was successfully set,
+ * otherwise %FALSE.
+ *
+ * Since: 2.6
+ **/
+gboolean
+gtk_selection_data_set_uris (GtkSelectionData *selection_data,
+ gchar **uris)
+{
+ init_atoms ();
+
+ if (selection_data->target == text_uri_list_atom)
+ {
+ GString *list;
+ gint i;
+ gchar *result;
+ gsize length;
+
+ list = g_string_new (NULL);
+ for (i = 0; uris[i]; i++)
+ {
+ g_string_append (list, uris[i]);
+ g_string_append (list, "\r\n");
+ }
+
+ result = g_convert (list->str, list->len,
+ "ASCII", "UTF-8",
+ NULL, &length, NULL);
+ g_string_free (list, TRUE);
+
+ if (result)
+ {
+ gtk_selection_data_set (selection_data,
+ text_uri_list_atom,
+ 8, (guchar *)result, length);
+
+ return TRUE;
+ }
+ }
+
+ return FALSE;
+}
+
+/**
+ * gtk_selection_data_get_uris:
+ * @selection_data: a #GtkSelectionData
+ *
+ * Gets the contents of the selection data as array of URIs.
+ *
+ * Return value: if the selection data contains a list of
+ * URIs, a newly allocated %NULL-terminated string array
+ * containing the URIs, otherwise %NULL. If the result is
+ * non-%NULL it must be freed with g_strfreev().
+ *
+ * Since: 2.6
+ **/
+gchar **
+gtk_selection_data_get_uris (GtkSelectionData *selection_data)
+{
+ gchar **result = NULL;
+
+ init_atoms ();
+
+ if (selection_data->length >= 0 &&
+ selection_data->type == text_uri_list_atom)
+ {
+ gchar **list;
+ gint i;
+ gint count = gdk_text_property_to_utf8_list_for_display (selection_data->display,
+ utf8_atom,
+ selection_data->format,
+ selection_data->data,
+ selection_data->length,
+ &list);
+ if (count > 0)
+ result = g_uri_list_extract_uris (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
gint i;
gboolean result = FALSE;
+ init_atoms ();
+
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;
+ if (targets[i] == utf8_atom ||
+ targets[i] == text_atom ||
+ targets[i] == GDK_TARGET_STRING ||
+ targets[i] == ctext_atom ||
+ targets[i] == text_plain_atom ||
+ targets[i] == text_plain_utf8_atom ||
+ targets[i] == text_plain_locale_atom)
+ {
+ result = TRUE;
+ break;
+ }
}
g_free (targets);
return result;
}
+
+/**
+ * gtk_selection_data_targets_include_image:
+ * @selection_data: a #GtkSelectionData object
+ * @writable: whether to accept only targets for which GTK+ knows
+ * how to convert a pixbuf into the format
+ *
+ * Given a #GtkSelectionData object holding a list of targets,
+ * determines if any of the targets in @targets can be used to
+ * provide a #GdkPixbuf.
+ *
+ * Return value: %TRUE if @selection_data holds a list of targets,
+ * and a suitable target for images is included, otherwise %FALSE.
+ *
+ * Since: 2.6
+ **/
+gboolean
+gtk_selection_data_targets_include_image (GtkSelectionData *selection_data,
+ gboolean writable)
+{
+ GdkAtom *targets;
+ gint n_targets;
+ gint i;
+ gboolean result = FALSE;
+ GtkTargetList *list;
+ GList *l;
+
+ init_atoms ();
+
+ if (gtk_selection_data_get_targets (selection_data, &targets, &n_targets))
+ {
+ list = gtk_target_list_new (NULL, 0);
+ gtk_target_list_add_image_targets (list, 0, writable);
+ for (i=0; i < n_targets && !result; i++)
+ {
+ for (l = list->list; l && !result; l = l->next)
+ {
+ GtkTargetPair *pair = (GtkTargetPair *)l->data;
+ if (pair->target == targets[i])
+ result = TRUE;
+ }
+ }
+ gtk_target_list_unref (list);
+ g_free (targets);
+ }
+
+ return result;
+}
/*************************************************************
* gtk_selection_init:
GtkIncrInfo *info;
GList *tmp_list;
int i;
-
+ gulong selection_max_size;
+
if (initialize)
gtk_selection_init ();
+ selection_max_size = GTK_SELECTION_MAX_SIZE (display);
+
/* Check if we own selection */
tmp_list = current_selections;
gdk_error_trap_push ();
if (!gdk_property_get (info->requestor, event->property, GDK_NONE, /* AnyPropertyType */
- 0, GTK_SELECTION_MAX_SIZE, FALSE,
+ 0, selection_max_size, FALSE,
&type, &format, &length, &mult_atoms))
{
gdk_selection_send_notify_for_display (display,
#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);
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;
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 */