AuroraMiddleware/gtk2
1
0
Fork 0
forked from AuroraMiddleware/gtk
Code Issues Pull Requests Projects Releases Wiki Activity
90aebd4f84
gtk2/gdk/x11/gdkselectionoutputstream-x11.c
Benjamin Otte 359bc7695c build: Reintroduce warning flags from autotools 
Some of the flags got lost in the meson transition or were demoted from
error flags to warning flags.
This commit reintroduces them.

It also includes fixes for the code that had warnings with those flags.
The big one being -Wshadow.
2019-01-22 04:33:12 +01:00

1060 lines
40 KiB
C
Raw Blame History

/* GIO - GLib Output, Output and Streaming Library
*
* Copyright (C) 2017 Red Hat, Inc.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General
* Public License along with this library; if not, see <http://www.gnu.org/licenses/>.
*
* Author: Benjamin Otte <otte@gnome.org>
* Christian Kellner <gicmo@gnome.org>
*/
#include "config.h"
#include "gdkselectionoutputstream-x11.h"
#include "gdkclipboard-x11.h"
#include "gdkdisplay-x11.h"
#include "gdkintl.h"
#include "gdktextlistconverter-x11.h"
#include "gdkx11display.h"
#include "gdkx11property.h"
#include "gdkx11surface.h"
typedef struct _GdkX11PendingSelectionNotify GdkX11PendingSelectionNotify;
typedef struct _GdkX11SelectionOutputStreamPrivate GdkX11SelectionOutputStreamPrivate;
struct _GdkX11SelectionOutputStreamPrivate {
GdkDisplay *display;
GdkX11PendingSelectionNotify *notify;
Window xwindow;
char *selection;
Atom xselection;
char *target;
Atom xtarget;
char *property;
Atom xproperty;
const char *type;
Atom xtype;
int format;
gulong timestamp;
GMutex mutex;
GCond cond;
GByteArray *data;
guint flush_requested : 1;
GTask *pending_task;
guint incr : 1;
guint delete_pending : 1;
};
struct _GdkX11PendingSelectionNotify
{
gsize n_pending;
XSelectionEvent xevent;
};
G_DEFINE_TYPE_WITH_PRIVATE (GdkX11SelectionOutputStream, gdk_x11_selection_output_stream, G_TYPE_OUTPUT_STREAM);
static GdkX11PendingSelectionNotify *
gdk_x11_pending_selection_notify_new (Window window,
Atom selection,
Atom target,
Atom property,
Time timestamp)
{
GdkX11PendingSelectionNotify *pending;
pending = g_slice_new0 (GdkX11PendingSelectionNotify);
pending->n_pending = 1;
pending->xevent.type = SelectionNotify;
pending->xevent.serial = 0;
pending->xevent.send_event = True;
pending->xevent.requestor = window;
pending->xevent.selection = selection;
pending->xevent.target = target;
pending->xevent.property = property;
pending->xevent.time = timestamp;
return pending;
}
static void
gdk_x11_pending_selection_notify_free (GdkX11PendingSelectionNotify *notify)
{
g_slice_free (GdkX11PendingSelectionNotify, notify);
}
static void
gdk_x11_pending_selection_notify_require (GdkX11PendingSelectionNotify *notify,
guint n_sends)
{
notify->n_pending += n_sends;
}
static void
gdk_x11_pending_selection_notify_send (GdkX11PendingSelectionNotify *notify,
GdkDisplay *display,
gboolean success)
{
Display *xdisplay;
int error;
notify->n_pending--;
if (notify->n_pending)
{
GDK_DISPLAY_NOTE (display, SELECTION, g_printerr ("%s:%s: not sending SelectionNotify yet, %zu streams still pending\n",
gdk_x11_get_xatom_name_for_display (display, notify->xevent.selection),
gdk_x11_get_xatom_name_for_display (display, notify->xevent.target),
notify->n_pending));
return;
}
GDK_DISPLAY_NOTE (display, SELECTION, g_printerr ("%s:%s: sending SelectionNotify reporting %s\n",
gdk_x11_get_xatom_name_for_display (display, notify->xevent.selection),
gdk_x11_get_xatom_name_for_display (display, notify->xevent.target),
success ? "success" : "failure"));
if (!success)
notify->xevent.property = None;
xdisplay = gdk_x11_display_get_xdisplay (display);
gdk_x11_display_error_trap_push (display);
if (XSendEvent (xdisplay, notify->xevent.requestor, False, NoEventMask, (XEvent*) &notify->xevent) == 0)
{
GDK_DISPLAY_NOTE (display, SELECTION, g_printerr ("%s:%s: failed to XSendEvent()\n",
gdk_x11_get_xatom_name_for_display (display, notify->xevent.selection),
gdk_x11_get_xatom_name_for_display (display, notify->xevent.target)));
}
XSync (xdisplay, False);
error = gdk_x11_display_error_trap_pop (display);
if (error != Success)
{
GDK_DISPLAY_NOTE (display, SELECTION, g_printerr ("%s:%s: X error during write: %d\n",
gdk_x11_get_xatom_name_for_display (display, notify->xevent.selection),
gdk_x11_get_xatom_name_for_display (display, notify->xevent.target),
error));
}
gdk_x11_pending_selection_notify_free (notify);
}
static gboolean
gdk_x11_selection_output_stream_xevent (GdkDisplay *display,
const XEvent *xevent,
gpointer data);
static gboolean
gdk_x11_selection_output_stream_can_flush (GdkX11SelectionOutputStream *stream)
{
GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
if (priv->delete_pending)
return FALSE;
return TRUE;
}
static gboolean
gdk_x11_selection_output_stream_needs_flush_unlocked (GdkX11SelectionOutputStream *stream)
{
GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
if (priv->data->len == 0 && priv->notify == NULL)
return FALSE;
if (g_output_stream_is_closing (G_OUTPUT_STREAM (stream)))
return TRUE;
if (priv->flush_requested)
return TRUE;
return priv->data->len >= gdk_x11_display_get_max_request_size (priv->display);
}
static gboolean
gdk_x11_selection_output_stream_needs_flush (GdkX11SelectionOutputStream *stream)
{
GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
gboolean result;
g_mutex_lock (&priv->mutex);
result = gdk_x11_selection_output_stream_needs_flush_unlocked (stream);
g_mutex_unlock (&priv->mutex);
return result;
}
static gsize
get_element_size (int format)
{
switch (format)
{
case 8:
return 1;
case 16:
return sizeof (short);
case 32:
return sizeof (long);
default:
g_warning ("Unknown format %u", format);
return 1;
}
}
static void
gdk_x11_selection_output_stream_perform_flush (GdkX11SelectionOutputStream *stream)
{
GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
Display *xdisplay;
gsize element_size, n_elements;
int error;
g_assert (!priv->delete_pending);
xdisplay = gdk_x11_display_get_xdisplay (priv->display);
/* We operate on a foreign window, better guard against catastrophe */
gdk_x11_display_error_trap_push (priv->display);
g_mutex_lock (&priv->mutex);
element_size = get_element_size (priv->format);
n_elements = priv->data->len / element_size;
if (priv->notify && !g_output_stream_is_closing (G_OUTPUT_STREAM (stream)))
{
XWindowAttributes attrs;
priv->incr = TRUE;
GDK_DISPLAY_NOTE (priv->display, SELECTION, g_printerr ("%s:%s: initiating INCR transfer\n",
priv->selection, priv->target));
XGetWindowAttributes (xdisplay,
priv->xwindow,
&attrs);
if (!(attrs.your_event_mask & PropertyChangeMask))
{
XSelectInput (xdisplay, priv->xwindow, attrs.your_event_mask | PropertyChangeMask);
}
XChangeProperty (GDK_DISPLAY_XDISPLAY (priv->display),
priv->xwindow,
priv->xproperty,
gdk_x11_get_xatom_by_name_for_display (priv->display, "INCR"),
32,
PropModeReplace,
(guchar *) &(long) { n_elements },
1);
}
else
{
XChangeProperty (GDK_DISPLAY_XDISPLAY (priv->display),
priv->xwindow,
priv->xproperty,
priv->xtype,
priv->format,
PropModeReplace,
priv->data->data,
n_elements);
GDK_DISPLAY_NOTE (priv->display, SELECTION, g_printerr ("%s:%s: wrote %zu/%u bytes\n",
priv->selection, priv->target, n_elements * element_size, priv->data->len));
g_byte_array_remove_range (priv->data, 0, n_elements * element_size);
if (priv->data->len < element_size)
priv->flush_requested = FALSE;
}
if (priv->notify)
{
gdk_x11_pending_selection_notify_send (priv->notify, priv->display, TRUE);
priv->notify = NULL;
}
priv->delete_pending = TRUE;
g_cond_broadcast (&priv->cond);
g_mutex_unlock (&priv->mutex);
/* XXX: handle failure here and report EPIPE for future operations on the stream? */
error = gdk_x11_display_error_trap_pop (priv->display);
if (error != Success)
{
GDK_DISPLAY_NOTE (priv->display, SELECTION, g_printerr ("%s:%s: X error during write: %d\n",
priv->selection, priv->target, error));
}
if (priv->pending_task)
{
g_task_return_int (priv->pending_task, GPOINTER_TO_SIZE (g_task_get_task_data (priv->pending_task)));
g_object_unref (priv->pending_task);
priv->pending_task = NULL;
}
}
static gboolean
gdk_x11_selection_output_stream_invoke_flush (gpointer data)
{
GdkX11SelectionOutputStream *stream = GDK_X11_SELECTION_OUTPUT_STREAM (data);
if (gdk_x11_selection_output_stream_needs_flush (stream) &&
gdk_x11_selection_output_stream_can_flush (stream))
gdk_x11_selection_output_stream_perform_flush (stream);
return G_SOURCE_REMOVE;
}
static gssize
gdk_x11_selection_output_stream_write (GOutputStream *output_stream,
const void *buffer,
gsize count,
GCancellable *cancellable,
GError **error)
{
GdkX11SelectionOutputStream *stream = GDK_X11_SELECTION_OUTPUT_STREAM (output_stream);
GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
g_mutex_lock (&priv->mutex);
g_byte_array_append (priv->data, buffer, count);
GDK_NOTE (SELECTION, g_printerr ("%s:%s: wrote %zu bytes, %u total now\n",
priv->selection, priv->target, count, priv->data->len));
g_mutex_unlock (&priv->mutex);
g_main_context_invoke (NULL, gdk_x11_selection_output_stream_invoke_flush, stream);
g_mutex_lock (&priv->mutex);
if (gdk_x11_selection_output_stream_needs_flush_unlocked (stream))
g_cond_wait (&priv->cond, &priv->mutex);
g_mutex_unlock (&priv->mutex);
return count;
}
static void
gdk_x11_selection_output_stream_write_async (GOutputStream *output_stream,
const void *buffer,
gsize count,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GdkX11SelectionOutputStream *stream = GDK_X11_SELECTION_OUTPUT_STREAM (output_stream);
GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
GTask *task;
task = g_task_new (stream, cancellable, callback, user_data);
g_task_set_source_tag (task, gdk_x11_selection_output_stream_write_async);
g_task_set_priority (task, io_priority);
g_mutex_lock (&priv->mutex);
g_byte_array_append (priv->data, buffer, count);
GDK_NOTE (SELECTION, g_printerr ("%s:%s: async wrote %zu bytes, %u total now\n",
priv->selection, priv->target, count, priv->data->len));
g_mutex_unlock (&priv->mutex);
if (!gdk_x11_selection_output_stream_needs_flush (stream))
{
g_task_return_int (task, count);
g_object_unref (task);
return;
}
else if (!gdk_x11_selection_output_stream_can_flush (stream))
{
g_assert (priv->pending_task == NULL);
priv->pending_task = task;
g_task_set_task_data (task, GSIZE_TO_POINTER (count), NULL);
return;
}
else
{
gdk_x11_selection_output_stream_perform_flush (stream);
g_task_return_int (task, count);
g_object_unref (task);
return;
}
}
static gssize
gdk_x11_selection_output_stream_write_finish (GOutputStream *stream,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (g_task_is_valid (result, stream), -1);
g_return_val_if_fail (g_task_get_source_tag (G_TASK (result)) == gdk_x11_selection_output_stream_write_async, -1);
return g_task_propagate_int (G_TASK (result), error);
}
static gboolean
gdk_x11_selection_output_request_flush (GdkX11SelectionOutputStream *stream)
{
GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
gboolean needs_flush;
g_mutex_lock (&priv->mutex);
if (priv->data->len >= get_element_size (priv->format))
priv->flush_requested = TRUE;
needs_flush = gdk_x11_selection_output_stream_needs_flush_unlocked (stream);
g_mutex_unlock (&priv->mutex);
GDK_NOTE (SELECTION, g_printerr ("%s:%s: requested flush%s\n",
priv->selection, priv->target, needs_flush ?"" : ", but not needed"));
return needs_flush;
}
static gboolean
gdk_x11_selection_output_stream_flush (GOutputStream *output_stream,
GCancellable *cancellable,
GError **error)
{
GdkX11SelectionOutputStream *stream = GDK_X11_SELECTION_OUTPUT_STREAM (output_stream);
GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
if (!gdk_x11_selection_output_request_flush (stream))
return TRUE;
g_main_context_invoke (NULL, gdk_x11_selection_output_stream_invoke_flush, stream);
g_mutex_lock (&priv->mutex);
if (gdk_x11_selection_output_stream_needs_flush_unlocked (stream))
g_cond_wait (&priv->cond, &priv->mutex);
g_mutex_unlock (&priv->mutex);
return TRUE;
}
static void
gdk_x11_selection_output_stream_flush_async (GOutputStream *output_stream,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GdkX11SelectionOutputStream *stream = GDK_X11_SELECTION_OUTPUT_STREAM (output_stream);
GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
GTask *task;
task = g_task_new (stream, cancellable, callback, user_data);
g_task_set_source_tag (task, gdk_x11_selection_output_stream_flush_async);
g_task_set_priority (task, io_priority);
if (!gdk_x11_selection_output_stream_can_flush (stream))
{
if (gdk_x11_selection_output_request_flush (stream))
{
g_assert (priv->pending_task == NULL);
priv->pending_task = task;
return;
}
else
{
g_task_return_boolean (task, TRUE);
g_object_unref (task);
return;
}
}
gdk_x11_selection_output_stream_perform_flush (stream);
g_task_return_boolean (task, TRUE);
g_object_unref (task);
return;
}
static gboolean
gdk_x11_selection_output_stream_flush_finish (GOutputStream *stream,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (g_task_is_valid (result, stream), FALSE);
g_return_val_if_fail (g_async_result_is_tagged (result, gdk_x11_selection_output_stream_flush_async), FALSE);
return g_task_propagate_boolean (G_TASK (result), error);
}
static gboolean
gdk_x11_selection_output_stream_invoke_close (gpointer stream)
{
GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
GDK_X11_DISPLAY (priv->display)->streams = g_slist_remove (GDK_X11_DISPLAY (priv->display)->streams, stream);
g_signal_handlers_disconnect_by_func (priv->display,
gdk_x11_selection_output_stream_xevent,
stream);
return G_SOURCE_REMOVE;
}
static gboolean
gdk_x11_selection_output_stream_close (GOutputStream *stream,
GCancellable *cancellable,
GError **error)
{
g_main_context_invoke (NULL, gdk_x11_selection_output_stream_invoke_close, stream);
return TRUE;
}
static void
gdk_x11_selection_output_stream_close_async (GOutputStream *stream,
int io_priority,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
task = g_task_new (stream, cancellable, callback, user_data);
g_task_set_source_tag (task, gdk_x11_selection_output_stream_close_async);
g_task_set_priority (task, io_priority);
gdk_x11_selection_output_stream_invoke_close (stream);
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
static gboolean
gdk_x11_selection_output_stream_close_finish (GOutputStream *stream,
GAsyncResult *result,
GError **error)
{
g_return_val_if_fail (g_task_is_valid (result, stream), FALSE);
g_return_val_if_fail (g_async_result_is_tagged (result, gdk_x11_selection_output_stream_close_async), FALSE);
return g_task_propagate_boolean (G_TASK (result), error);
}
static void
gdk_x11_selection_output_stream_finalize (GObject *object)
{
GdkX11SelectionOutputStream *stream = GDK_X11_SELECTION_OUTPUT_STREAM (object);
GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
/* not sending a notify is terrible */
g_assert (priv->notify == NULL);
g_byte_array_unref (priv->data);
g_cond_clear (&priv->cond);
g_mutex_clear (&priv->mutex);
g_free (priv->selection);
g_free (priv->target);
g_free (priv->property);
G_OBJECT_CLASS (gdk_x11_selection_output_stream_parent_class)->finalize (object);
}
static void
gdk_x11_selection_output_stream_class_init (GdkX11SelectionOutputStreamClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
GOutputStreamClass *output_stream_class = G_OUTPUT_STREAM_CLASS (klass);
object_class->finalize = gdk_x11_selection_output_stream_finalize;
output_stream_class->write_fn = gdk_x11_selection_output_stream_write;
output_stream_class->flush = gdk_x11_selection_output_stream_flush;
output_stream_class->close_fn = gdk_x11_selection_output_stream_close;
output_stream_class->write_async = gdk_x11_selection_output_stream_write_async;
output_stream_class->write_finish = gdk_x11_selection_output_stream_write_finish;
output_stream_class->flush_async = gdk_x11_selection_output_stream_flush_async;
output_stream_class->flush_finish = gdk_x11_selection_output_stream_flush_finish;
output_stream_class->close_async = gdk_x11_selection_output_stream_close_async;
output_stream_class->close_finish = gdk_x11_selection_output_stream_close_finish;
}
static void
gdk_x11_selection_output_stream_init (GdkX11SelectionOutputStream *stream)
{
GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
g_mutex_init (&priv->mutex);
g_cond_init (&priv->cond);
priv->data = g_byte_array_new ();
}
static gboolean
gdk_x11_selection_output_stream_xevent (GdkDisplay *display,
const XEvent *xevent,
gpointer data)
{
GdkX11SelectionOutputStream *stream = GDK_X11_SELECTION_OUTPUT_STREAM (data);
GdkX11SelectionOutputStreamPrivate *priv = gdk_x11_selection_output_stream_get_instance_private (stream);
Display *xdisplay;
xdisplay = gdk_x11_display_get_xdisplay (priv->display);
if (xevent->xany.display != xdisplay ||
xevent->xany.window != priv->xwindow)
return FALSE;
switch (xevent->type)
{
case PropertyNotify:
if (!priv->incr ||
xevent->xproperty.atom != priv->xproperty ||
xevent->xproperty.state != PropertyDelete)
return FALSE;
GDK_DISPLAY_NOTE (display, SELECTION, g_printerr ("%s:%s: got PropertyNotify Delete during INCR\n",
priv->selection, priv->target));
priv->delete_pending = FALSE;
if (gdk_x11_selection_output_stream_needs_flush (stream) &&
gdk_x11_selection_output_stream_can_flush (stream))
gdk_x11_selection_output_stream_perform_flush (stream);
return FALSE;
default:
return FALSE;
}
}
static GOutputStream *
gdk_x11_selection_output_stream_new (GdkDisplay *display,
GdkX11PendingSelectionNotify *notify,
Window window,
const char *selection,
const char *target,
const char *property,
const char *type,
int format,
gulong timestamp)
{
GdkX11SelectionOutputStream *stream;
GdkX11SelectionOutputStreamPrivate *priv;
stream = g_object_new (GDK_TYPE_X11_SELECTION_OUTPUT_STREAM, NULL);
priv = gdk_x11_selection_output_stream_get_instance_private (stream);
priv->display = display;
GDK_X11_DISPLAY (display)->streams = g_slist_prepend (GDK_X11_DISPLAY (display)->streams, stream);
priv->notify = notify;
priv->xwindow = window;
priv->selection = g_strdup (selection);
priv->xselection = gdk_x11_get_xatom_by_name_for_display (display, priv->selection);
priv->target = g_strdup (target);
priv->xtarget = gdk_x11_get_xatom_by_name_for_display (display, priv->target);
priv->property = g_strdup (property);
priv->xproperty = gdk_x11_get_xatom_by_name_for_display (display, priv->property);
priv->type = g_strdup (type);
priv->xtype = gdk_x11_get_xatom_by_name_for_display (display, priv->type);
priv->format = format;
priv->timestamp = timestamp;
g_signal_connect (display,
"xevent",
G_CALLBACK (gdk_x11_selection_output_stream_xevent),
stream);
return G_OUTPUT_STREAM (stream);
}
static void
print_atoms (GdkDisplay *display,
const char *selection,
const char *prefix,
const Atom *atoms,
gsize n_atoms)
{
GDK_DISPLAY_NOTE (display, CLIPBOARD,
gsize i;
g_printerr ("%s: %s [ ", selection, prefix);
for (i = 0; i < n_atoms; i++)
{
g_printerr ("%s%s", i > 0 ? ", " : "", gdk_x11_get_xatom_name_for_display (display , atoms[i]));
}
g_printerr (" ]\n");
);
}
static void
handle_targets_done (GObject *stream,
GAsyncResult *result,
gpointer user_data)
{
GError *error = NULL;
gsize bytes_written;
if (!g_output_stream_write_all_finish (G_OUTPUT_STREAM (stream), result, &bytes_written, &error))
{
GDK_NOTE (CLIPBOARD, g_printerr ("---: failed to send targets after %zu bytes: %s\n",
bytes_written, error->message));
g_error_free (error);
}
g_free (user_data);
}
static void
handle_targets (GOutputStream *stream,
GdkDisplay *display,
GdkContentFormats *formats,
const char *target,
const char *encoding,
int format,
gulong timestamp,
GdkX11SelectionOutputHandler handler,
gpointer user_data)
{
Atom *atoms;
gsize n_atoms;
atoms = gdk_x11_clipboard_formats_to_atoms (display,
TRUE,
formats,
&n_atoms);
print_atoms (display, "---", "sending targets", atoms, n_atoms);
g_output_stream_write_all_async (stream,
atoms,
n_atoms * sizeof (Atom),
G_PRIORITY_DEFAULT,
NULL,
handle_targets_done,
atoms);
g_object_unref (stream);
}
static void
handle_timestamp_done (GObject *stream,
GAsyncResult *result,
gpointer user_data)
{
GError *error = NULL;
gsize bytes_written;
if (!g_output_stream_write_all_finish (G_OUTPUT_STREAM (stream), result, &bytes_written, &error))
{
GDK_NOTE (CLIPBOARD, g_printerr ("---: failed to send timestamp after %zu bytes: %s\n",
bytes_written, error->message));
g_error_free (error);
}
g_slice_free (gulong, user_data);
}
static void
handle_timestamp (GOutputStream *stream,
GdkDisplay *display,
GdkContentFormats *formats,
const char *target,
const char *encoding,
int format,
gulong timestamp,
GdkX11SelectionOutputHandler handler,
gpointer user_data)
{
gulong *time_;
time_ = g_slice_new (gulong);
*time_ = timestamp;
g_output_stream_write_all_async (stream,
time_,
sizeof (gulong),
G_PRIORITY_DEFAULT,
NULL,
handle_timestamp_done,
time_);
g_object_unref (stream);
}
static void
handle_save_targets (GOutputStream *stream,
GdkDisplay *display,
GdkContentFormats *formats,
const char *target,
const char *encoding,
int format,
gulong timestamp,
GdkX11SelectionOutputHandler handler,
gpointer user_data)
{
/* Don't do anything */
g_object_unref (stream);
}
static void
handle_text_list (GOutputStream *stream,
GdkDisplay *display,
GdkContentFormats *formats,
const char *target,
const char *encoding,
int format,
gulong timestamp,
GdkX11SelectionOutputHandler handler,
gpointer user_data)
{
GOutputStream *converter_stream;
GConverter *converter;
converter = gdk_x11_text_list_converter_to_utf8_new (display,
encoding,
format);
converter_stream = g_converter_output_stream_new (stream, converter);
g_object_unref (converter);
g_object_unref (stream);
handler (converter_stream, gdk_intern_mime_type ("text/plain;charset=utf-8"), user_data);
}
static void
handle_utf8 (GOutputStream *stream,
GdkDisplay *display,
GdkContentFormats *formats,
const char *target,
const char *encoding,
int format,
gulong timestamp,
GdkX11SelectionOutputHandler handler,
gpointer user_data)
{
handler (stream, gdk_intern_mime_type ("text/plain;charset=utf-8"), user_data);
}
typedef void (* MimeTypeHandleFunc) (GOutputStream *, GdkDisplay *, GdkContentFormats *, const char *, const char *, int, gulong, GdkX11SelectionOutputHandler, gpointer);
static const struct {
const char *x_target;
const char *mime_type;
const char *type;
gint format;
MimeTypeHandleFunc handler;
} special_targets[] = {
{ "UTF8_STRING", "text/plain;charset=utf-8", "UTF8_STRING", 8, handle_utf8 },
{ "COMPOUND_TEXT", "text/plain;charset=utf-8", "COMPOUND_TEXT", 8, handle_text_list },
{ "TEXT", "text/plain;charset=utf-8", "STRING", 8, handle_text_list },
{ "STRING", "text/plain;charset=utf-8", "STRING", 8, handle_text_list },
{ "TARGETS", NULL, "ATOM", 32, handle_targets },
{ "TIMESTAMP", NULL, "INTEGER", 32, handle_timestamp },
{ "SAVE_TARGETS", NULL, "NULL", 32, handle_save_targets }
};
static gboolean
gdk_x11_selection_output_streams_request (GdkDisplay *display,
GdkX11PendingSelectionNotify *notify,
GdkContentFormats *formats,
Window requestor,
Atom xselection,
Atom xtarget,
Atom xproperty,
gulong timestamp,
GdkX11SelectionOutputHandler handler,
gpointer user_data)
{
const char *mime_type, *selection, *target, *property;
selection = gdk_x11_get_xatom_name_for_display (display, xselection);
target = gdk_x11_get_xatom_name_for_display (display, xtarget);
property = gdk_x11_get_xatom_name_for_display (display, xproperty);
mime_type = gdk_intern_mime_type (target);
if (mime_type)
{
if (gdk_content_formats_contain_mime_type (formats, mime_type))
{
GOutputStream *stream;
stream = gdk_x11_selection_output_stream_new (display,
notify,
requestor,
selection,
target,
property,
target,
8,
timestamp);
handler (stream, target, user_data);
return TRUE;
}
}
else if (g_str_equal (target, "MULTIPLE"))
{
gulong n_atoms;
gulong nbytes;
Atom prop_type;
gint prop_format;
Atom *atoms = NULL;
int error;
error = XGetWindowProperty (gdk_x11_display_get_xdisplay (display),
requestor,
xproperty,
0, 0x1FFFFFFF, False,
AnyPropertyType,
&prop_type, &prop_format,
&n_atoms, &nbytes, (guchar **) &atoms);
if (error != Success)
{
GDK_DISPLAY_NOTE (display, SELECTION, g_printerr ("%s: XGetProperty() during MULTIPLE failed with %d\n",
selection, error));
}
else if (prop_format != 32 ||
prop_type != gdk_x11_get_xatom_by_name_for_display (display, "ATOM_PAIR"))
{
GDK_DISPLAY_NOTE (display, SELECTION, g_printerr ("%s: XGetProperty() type/format should be ATOM_PAIR/32 but is %s/%d\n",
selection, gdk_x11_get_xatom_name_for_display (display, prop_type), prop_format));
}
else if (n_atoms < 2)
{
print_atoms (display, selection, "ignoring MULTIPLE request with too little elements", atoms, n_atoms);
}
else
{
gulong i;
print_atoms (display, selection, "MULTIPLE request", atoms, n_atoms);
if (n_atoms % 2)
{
GDK_DISPLAY_NOTE (display, SELECTION, g_printerr ("%s: Number of atoms is uneven at %lu, ignoring last element\n",
selection, n_atoms));
n_atoms &= ~1;
}
gdk_x11_pending_selection_notify_require (notify, n_atoms / 2);
for (i = 0; i < n_atoms / 2; i++)
{
gboolean success;
if (atoms[2 * i] == None || atoms[2 * i + 1] == None)
{
success = FALSE;
GDK_DISPLAY_NOTE (display, SELECTION, g_printerr ("%s: None not allowed as atom in MULTIPLE request\n",
selection));
gdk_x11_pending_selection_notify_send (notify, display, FALSE);
}
else if (atoms[2 * i] == gdk_x11_get_xatom_by_name_for_display (display, "MULTIPLE"))
{
success = FALSE;
GDK_DISPLAY_NOTE (display, SELECTION, g_printerr ("%s: MULTIPLE as target in MULTIPLE request would cause recursion\n",
selection));
gdk_x11_pending_selection_notify_send (notify, display, FALSE);
}
else
{
success = gdk_x11_selection_output_streams_request (display,
notify,
formats,
requestor,
xselection,
atoms[2 * i],
atoms[2 * i + 1],
timestamp,
handler,
user_data);
}
if (!success)
atoms[2 * i + 1] = None;
}
}
XChangeProperty (gdk_x11_display_get_xdisplay (display),
requestor,
xproperty,
prop_type, 32,
PropModeReplace, (guchar *)atoms, n_atoms);
if (atoms)
XFree (atoms);
gdk_x11_pending_selection_notify_send (notify, display, TRUE);
return TRUE;
}
else
{
gsize i;
for (i = 0; i < G_N_ELEMENTS (special_targets); i++)
{
if (g_str_equal (target, special_targets[i].x_target) &&
special_targets[i].handler)
{
GOutputStream *stream;
if (special_targets[i].mime_type)
mime_type = gdk_intern_mime_type (special_targets[i].mime_type);
stream = gdk_x11_selection_output_stream_new (display,
notify,
requestor,
selection,
target,
property,
special_targets[i].type,
special_targets[i].format,
timestamp);
special_targets[i].handler (stream,
display,
formats,
target,
special_targets[i].type,
special_targets[i].format,
timestamp,
handler,
user_data);
return TRUE;
}
}
}
gdk_x11_pending_selection_notify_send (notify, display, FALSE);
return FALSE;
}
void
gdk_x11_selection_output_streams_create (GdkDisplay *display,
GdkContentFormats *formats,
Window requestor,
Atom selection,
Atom target,
Atom property,
gulong timestamp,
GdkX11SelectionOutputHandler handler,
gpointer user_data)
{
GdkX11PendingSelectionNotify *notify;
notify = gdk_x11_pending_selection_notify_new (requestor,
selection,
target,
property,
timestamp);
gdk_x11_selection_output_streams_request (display,
notify,
formats,
requestor,
selection,
target,
property,
timestamp,
handler,
user_data);
}
Reference in New Issue View Git Blame Copy Permalink