You should have received a copy of the GNU General Public License
along with GNU Emacs. If not, see <https://www.gnu.org/licenses/>. */
-/* FIXME: this file needs a major rewrite to replace the use of GTK's
- own high-level GtkClipboard API with the GDK selection API:
-
- https://developer-old.gnome.org/gdk3/stable/gdk3-Selections.html
-
- That way, most of the code can be shared with X, and non-text
- targets along with drag-and-drop can be supported. GDK implements
- selections according to the ICCCM, as on X, but its selection API
- will work on any supported window system. */
-
/* This should be the first include, as it may set up #defines affecting
interpretation of even the system includes. */
#include <config.h>
#include "pgtkterm.h"
#include "termhooks.h"
#include "keyboard.h"
-#include "pgtkselect.h"
-#include <gdk/gdk.h>
-
-static GQuark quark_primary_data = 0;
-static GQuark quark_primary_size = 0;
-static GQuark quark_secondary_data = 0;
-static GQuark quark_secondary_size = 0;
-static GQuark quark_clipboard_data = 0;
-static GQuark quark_clipboard_size = 0;
-
-/* ==========================================================================
-
- Internal utility functions
-
- ========================================================================== */
+#include "atimer.h"
+#include "blockinput.h"
+
+/* This file deliberately does not implement INCR, since it adds a
+ bunch of extra code for no real gain, as PGTK isn't supposed to
+ support X11 anyway. */
+
+/* Advance declaration of structs. */
+struct selection_data;
+struct prop_location;
+
+static void pgtk_decline_selection_request (struct selection_input_event *);
+static bool pgtk_convert_selection (Lisp_Object, Lisp_Object, GdkAtom, bool,
+ struct pgtk_display_info *);
+static bool waiting_for_other_props_on_window (GdkDisplay *, GdkWindow *);
+#if 0
+static struct prop_location *expect_property_change (GdkDisplay *, GdkWindow *,
+ GdkAtom, int);
+#endif
+static void unexpect_property_change (struct prop_location *);
+static void wait_for_property_change (struct prop_location *);
+static Lisp_Object pgtk_get_window_property_as_lisp_data (struct pgtk_display_info *,
+ GdkWindow *, GdkAtom,
+ Lisp_Object, GdkAtom, bool);
+static Lisp_Object selection_data_to_lisp_data (struct pgtk_display_info *,
+ const unsigned char *,
+ ptrdiff_t, GdkAtom, int);
+static void lisp_data_to_selection_data (struct pgtk_display_info *, Lisp_Object,
+ struct selection_data *);
+static Lisp_Object pgtk_get_local_selection (Lisp_Object, Lisp_Object,
+ bool, struct pgtk_display_info *);
/* From a Lisp_Object, return a suitable frame for selection
operations. OBJECT may be a frame, a terminal object, or nil
return NULL;
}
-static GtkClipboard *
-symbol_to_gtk_clipboard (GtkWidget * widget, Lisp_Object symbol)
+#define LOCAL_SELECTION(selection_symbol, dpyinfo) \
+ assq_no_quit (selection_symbol, dpyinfo->terminal->Vselection_alist)
+
+static GdkAtom
+symbol_to_gdk_atom (Lisp_Object sym)
{
- GdkAtom atom;
+ if (NILP (sym))
+ return GDK_NONE;
- CHECK_SYMBOL (symbol);
- if (NILP (symbol))
- {
- atom = GDK_SELECTION_PRIMARY;
- }
- else if (EQ (symbol, QCLIPBOARD))
+ if (EQ (sym, QPRIMARY))
+ return GDK_SELECTION_PRIMARY;
+ if (EQ (sym, QSECONDARY))
+ return GDK_SELECTION_SECONDARY;
+ if (EQ (sym, QCLIPBOARD))
+ return GDK_SELECTION_CLIPBOARD;
+
+ if (!SYMBOLP (sym))
+ emacs_abort ();
+
+ return gdk_atom_intern (SSDATA (SYMBOL_NAME (sym)), FALSE);
+}
+
+static Lisp_Object
+gdk_atom_to_symbol (GdkAtom atom)
+{
+ return intern (gdk_atom_name (atom));
+}
+
+\f
+
+/* Do protocol to assert ourself as a selection owner.
+ FRAME shall be the owner; it must be a valid GDK frame.
+ Update the Vselection_alist so that we can reply to later requests for
+ our selection. */
+
+static void
+pgtk_own_selection (Lisp_Object selection_name, Lisp_Object selection_value,
+ Lisp_Object frame)
+{
+ struct frame *f = XFRAME (frame);
+ struct pgtk_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
+ guint32 timestamp = gtk_get_current_event_time ();
+ GdkAtom selection_atom = symbol_to_gdk_atom (selection_name);
+ Lisp_Object targets;
+ ptrdiff_t i, ntargets;
+ GtkTargetEntry *gtargets;
+
+ if (timestamp == GDK_CURRENT_TIME)
+ timestamp = dpyinfo->last_user_time;
+
+ /* Assert ownership over the selection. Ideally we would use the
+ GDK selection API for this as well, but it just doesn't work on
+ Wayland. */
+
+ if (!gdk_selection_owner_set_for_display (dpyinfo->display,
+ FRAME_GDK_WINDOW (f),
+ selection_atom,
+ timestamp, TRUE))
+ signal_error ("Could not assert ownership over selection", selection_name);
+
+ /* Update the local cache */
+ {
+ Lisp_Object selection_data;
+ Lisp_Object prev_value;
+
+ selection_data = list4 (selection_name, selection_value,
+ INT_TO_INTEGER (timestamp), frame);
+ prev_value = LOCAL_SELECTION (selection_name, dpyinfo);
+
+ tset_selection_alist
+ (dpyinfo->terminal,
+ Fcons (selection_data, dpyinfo->terminal->Vselection_alist));
+
+ /* If we already owned the selection, remove the old selection
+ data. Don't use Fdelq as that may quit. */
+ if (!NILP (prev_value))
+ {
+ /* We know it's not the CAR, so it's easy. */
+ Lisp_Object rest = dpyinfo->terminal->Vselection_alist;
+ for (; CONSP (rest); rest = XCDR (rest))
+ if (EQ (prev_value, Fcar (XCDR (rest))))
+ {
+ XSETCDR (rest, XCDR (XCDR (rest)));
+ break;
+ }
+ }
+ }
+
+ /* Announce the targets to the display server. This isn't required
+ on X, but is on Wayland. */
+
+ targets = pgtk_get_local_selection (selection_name, QTARGETS,
+ true, dpyinfo);
+
+ /* GC must not happen inside this segment. */
+ block_input ();
+ gtk_selection_clear_targets (FRAME_GTK_WIDGET (f), selection_atom);
+
+ if (VECTORP (targets))
{
- atom = GDK_SELECTION_CLIPBOARD;
+ gtargets = xzalloc (sizeof *gtargets * ASIZE (targets));
+ ntargets = 0;
+
+ for (i = 0; i < ASIZE (targets); ++i)
+ {
+ if (SYMBOLP (AREF (targets, i)))
+ gtargets[ntargets++].target
+ = SSDATA (SYMBOL_NAME (AREF (targets, i)));
+ }
+
+ gtk_selection_add_targets (FRAME_GTK_WIDGET (f),
+ selection_atom, gtargets,
+ ntargets);
+
+ xfree (gtargets);
}
- else if (EQ (symbol, QPRIMARY))
+ unblock_input ();
+}
+
+static Lisp_Object
+pgtk_get_local_selection (Lisp_Object selection_symbol, Lisp_Object target_type,
+ bool local_request, struct pgtk_display_info *dpyinfo)
+{
+ Lisp_Object local_value, tem;
+ Lisp_Object handler_fn, value, check;
+
+ local_value = LOCAL_SELECTION (selection_symbol, dpyinfo);
+
+ if (NILP (local_value)) return Qnil;
+
+ /* TIMESTAMP is a special case. */
+ if (EQ (target_type, QTIMESTAMP))
{
- atom = GDK_SELECTION_PRIMARY;
+ handler_fn = Qnil;
+ value = XCAR (XCDR (XCDR (local_value)));
}
- else if (EQ (symbol, QSECONDARY))
+ else
{
- atom = GDK_SELECTION_SECONDARY;
+ /* Don't allow a quit within the converter.
+ When the user types C-g, he would be surprised
+ if by luck it came during a converter. */
+ specpdl_ref count = SPECPDL_INDEX ();
+ specbind (Qinhibit_quit, Qt);
+
+ CHECK_SYMBOL (target_type);
+ handler_fn = Fcdr (Fassq (target_type, Vselection_converter_alist));
+
+ if (CONSP (handler_fn))
+ handler_fn = XCDR (handler_fn);
+
+ tem = XCAR (XCDR (local_value));
+
+ if (STRINGP (tem))
+ {
+ local_value = Fget_text_property (make_fixnum (0),
+ target_type, tem);
+
+ if (!NILP (local_value))
+ tem = local_value;
+ }
+
+ if (!NILP (handler_fn))
+ value = call3 (handler_fn, selection_symbol,
+ (local_request
+ ? Qnil
+ : target_type),
+ tem);
+ else
+ value = Qnil;
+ value = unbind_to (count, value);
}
- else if (EQ (symbol, Qt))
+
+ /* Make sure this value is of a type that we could transmit
+ to another client. */
+
+ check = value;
+ if (CONSP (value)
+ && SYMBOLP (XCAR (value)))
+ check = XCDR (value);
+
+ if (STRINGP (check)
+ || VECTORP (check)
+ || SYMBOLP (check)
+ || INTEGERP (check)
+ || NILP (value))
+ return value;
+ /* Check for a value that CONS_TO_INTEGER could handle. */
+ else if (CONSP (check)
+ && INTEGERP (XCAR (check))
+ && (INTEGERP (XCDR (check))
+ ||
+ (CONSP (XCDR (check))
+ && INTEGERP (XCAR (XCDR (check)))
+ && NILP (XCDR (XCDR (check))))))
+ return value;
+
+ signal_error ("Invalid data returned by selection-conversion function",
+ list2 (handler_fn, value));
+}
+
+static void
+pgtk_decline_selection_request (struct selection_input_event *event)
+{
+ gdk_selection_send_notify (SELECTION_EVENT_REQUESTOR (event),
+ SELECTION_EVENT_SELECTION (event),
+ SELECTION_EVENT_TARGET (event),
+ GDK_NONE, SELECTION_EVENT_TIME (event));
+}
+
+struct selection_data
+{
+ unsigned char *data;
+ ptrdiff_t size;
+ int format;
+ GdkAtom type;
+ bool nofree;
+ GdkAtom property;
+
+ /* This can be set to non-NULL during x_reply_selection_request, if
+ the selection is waiting for an INCR transfer to complete. Don't
+ free these; that's done by unexpect_property_change. */
+ struct prop_location *wait_object;
+ struct selection_data *next;
+};
+
+struct pgtk_selection_request
+{
+ /* The last element in this stack. */
+ struct pgtk_selection_request *last;
+
+ /* Its display info. */
+ struct pgtk_display_info *dpyinfo;
+
+ /* Its selection input event. */
+ struct selection_input_event *request;
+
+ /* Linked list of the above (in support of MULTIPLE targets). */
+ struct selection_data *converted_selections;
+
+ /* "Data" to send a requestor for a failed MULTIPLE subtarget. */
+ GdkAtom conversion_fail_tag;
+
+ /* Whether or not conversion was successful. */
+ bool converted;
+};
+
+/* Stack of selections currently being processed.
+ NULL if all requests have been fully processed. */
+
+struct pgtk_selection_request *selection_request_stack;
+
+static void
+pgtk_push_current_selection_request (struct selection_input_event *se,
+ struct pgtk_display_info *dpyinfo)
+{
+ struct pgtk_selection_request *frame;
+
+ frame = xmalloc (sizeof *frame);
+ frame->converted = false;
+ frame->last = selection_request_stack;
+ frame->request = se;
+ frame->dpyinfo = dpyinfo;
+ frame->converted_selections = NULL;
+ frame->conversion_fail_tag = GDK_NONE;
+
+ selection_request_stack = frame;
+}
+
+static void
+pgtk_pop_current_selection_request (void)
+{
+ struct pgtk_selection_request *tem;
+
+ tem = selection_request_stack;
+ selection_request_stack = selection_request_stack->last;
+
+ xfree (tem);
+}
+
+/* Used as an unwind-protect clause so that, if a selection-converter signals
+ an error, we tell the requestor that we were unable to do what they wanted
+ before we throw to top-level or go into the debugger or whatever. */
+
+static void
+pgtk_selection_request_lisp_error (void)
+{
+ struct selection_data *cs, *next;
+ struct pgtk_selection_request *frame;
+
+ frame = selection_request_stack;
+
+ for (cs = frame->converted_selections; cs; cs = next)
{
- atom = GDK_SELECTION_SECONDARY;
+ next = cs->next;
+ if (! cs->nofree && cs->data)
+ xfree (cs->data);
+ xfree (cs);
}
- else
+ frame->converted_selections = NULL;
+
+ if (!frame->converted && frame->dpyinfo->display)
+ pgtk_decline_selection_request (frame->request);
+}
+
+/* This stuff is so that INCR selections are reentrant (that is, so we can
+ be servicing multiple INCR selection requests simultaneously.) I haven't
+ actually tested that yet. */
+
+/* Keep a list of the property changes that are awaited. */
+
+struct prop_location
+{
+ int identifier;
+ GdkDisplay *display;
+ GdkWindow *window;
+ GdkAtom property;
+ int desired_state;
+ bool arrived;
+ struct prop_location *next;
+};
+
+#if 0
+
+static int prop_location_identifier;
+
+#endif
+
+static Lisp_Object property_change_reply;
+
+static struct prop_location *property_change_reply_object;
+
+static struct prop_location *property_change_wait_list;
+
+static void
+set_property_change_object (struct prop_location *location)
+{
+ /* Input must be blocked so we don't get the event before we set these. */
+ if (!input_blocked_p ())
+ emacs_abort ();
+
+ XSETCAR (property_change_reply, Qnil);
+ property_change_reply_object = location;
+}
+
+\f
+/* Send the reply to a selection request event EVENT. */
+
+static void
+pgtk_reply_selection_request (struct selection_input_event *event,
+ struct pgtk_display_info *dpyinfo)
+{
+ GdkDisplay *display = SELECTION_EVENT_DISPLAY (event);
+ GdkWindow *window = SELECTION_EVENT_REQUESTOR (event);
+ ptrdiff_t bytes_remaining;
+ struct selection_data *cs;
+ struct pgtk_selection_request *frame;
+
+ frame = selection_request_stack;
+
+ block_input ();
+ /* Loop over converted selections, storing them in the requested
+ properties. If data is large, only store the first N bytes
+ (section 2.7.2 of ICCCM). Note that we store the data for a
+ MULTIPLE request in the opposite order; the ICCM says only that
+ the conversion itself must be done in the same order. */
+ for (cs = frame->converted_selections; cs; cs = cs->next)
{
- atom = 0;
- error ("Bad selection");
+ if (cs->property == GDK_NONE)
+ continue;
+
+ bytes_remaining = cs->size;
+ bytes_remaining *= cs->format >> 3;
+
+ gdk_property_change (window, cs->property,
+ cs->type, cs->format,
+ GDK_PROP_MODE_APPEND,
+ cs->data, cs->size);
}
- return gtk_widget_get_clipboard (widget, atom);
+ /* Now issue the SelectionNotify event. */
+ gdk_selection_send_notify (window,
+ SELECTION_EVENT_SELECTION (event),
+ SELECTION_EVENT_TARGET (event),
+ SELECTION_EVENT_PROPERTY (event),
+ SELECTION_EVENT_TIME (event));
+ gdk_display_flush (display);
+
+ /* Finish sending the rest of each of the INCR values. This should
+ be improved; there's a chance of deadlock if more than one
+ subtarget in a MULTIPLE selection requires an INCR transfer, and
+ the requestor and Emacs loop waiting on different transfers. */
+ for (cs = frame->converted_selections; cs; cs = cs->next)
+ if (cs->wait_object)
+ {
+ int format_bytes = cs->format / 8;
+
+ /* Must set this inside block_input (). unblock_input may read
+ events and setting property_change_reply in
+ wait_for_property_change is then too late. */
+ set_property_change_object (cs->wait_object);
+ unblock_input ();
+
+ bytes_remaining = cs->size;
+ bytes_remaining *= format_bytes;
+
+ /* Wait for the requestor to ack by deleting the property.
+ This can run Lisp code (process handlers) or signal. */
+ wait_for_property_change (cs->wait_object);
+
+ /* Now write a zero-length chunk to the property to tell the
+ requestor that we're done. */
+ block_input ();
+ if (! waiting_for_other_props_on_window (display, window))
+ gdk_window_set_events (window, 0);
+ gdk_property_change (window, cs->property, cs->type, cs->format,
+ GDK_PROP_MODE_REPLACE, cs->data, 0);
+ }
+
+ gdk_display_sync (display);
+ unblock_input ();
}
+\f
+
+/* Handle a SelectionRequest event EVENT.
+ This is called from keyboard.c when such an event is found in the queue. */
+
static void
-selection_type_to_quarks (GdkAtom type, GQuark * quark_data,
- GQuark * quark_size)
+pgtk_handle_selection_request (struct selection_input_event *event)
{
- if (type == GDK_SELECTION_PRIMARY)
+ guint32 local_selection_time;
+ struct pgtk_display_info *dpyinfo = SELECTION_EVENT_DPYINFO (event);
+ GdkAtom selection = SELECTION_EVENT_SELECTION (event);
+ Lisp_Object selection_symbol = gdk_atom_to_symbol (selection);
+ GdkAtom target = SELECTION_EVENT_TARGET (event);
+ Lisp_Object target_symbol = gdk_atom_to_symbol (target);
+ GdkAtom property = SELECTION_EVENT_PROPERTY (event);
+ Lisp_Object local_selection_data;
+ bool success = false;
+ specpdl_ref count = SPECPDL_INDEX ();
+ bool pushed;
+ Lisp_Object alias, tem;
+
+ alias = Vpgtk_selection_alias_alist;
+
+ FOR_EACH_TAIL_SAFE (alias)
{
- *quark_data = quark_primary_data;
- *quark_size = quark_primary_size;
+ tem = Qnil;
+
+ if (CONSP (alias))
+ tem = XCAR (alias);
+
+ if (CONSP (tem)
+ && EQ (XCAR (tem), selection_symbol)
+ && SYMBOLP (XCDR (tem)))
+ {
+ selection_symbol = XCDR (tem);
+ break;
+ }
}
- else if (type == GDK_SELECTION_SECONDARY)
+
+ pushed = false;
+
+ if (!dpyinfo)
+ goto DONE;
+
+ local_selection_data = LOCAL_SELECTION (selection_symbol, dpyinfo);
+
+ /* Decline if we don't own any selections. */
+ if (NILP (local_selection_data)) goto DONE;
+
+ /* Decline requests issued prior to our acquiring the selection. */
+ CONS_TO_INTEGER (XCAR (XCDR (XCDR (local_selection_data))),
+ guint32, local_selection_time);
+ if (SELECTION_EVENT_TIME (event) != GDK_CURRENT_TIME
+ && local_selection_time > SELECTION_EVENT_TIME (event))
+ goto DONE;
+
+ block_input ();
+ pushed = true;
+ pgtk_push_current_selection_request (event, dpyinfo);
+ record_unwind_protect_void (pgtk_pop_current_selection_request);
+ record_unwind_protect_void (pgtk_selection_request_lisp_error);
+ unblock_input ();
+
+ if (EQ (target_symbol, QMULTIPLE))
{
- *quark_data = quark_secondary_data;
- *quark_size = quark_secondary_size;
+ /* For MULTIPLE targets, the event property names a list of atom
+ pairs; the first atom names a target and the second names a
+ non-GDK_NONE property. */
+ GdkWindow *requestor = SELECTION_EVENT_REQUESTOR (event);
+ Lisp_Object multprop;
+ ptrdiff_t j, nselections;
+ struct selection_data cs;
+
+ if (property == GDK_NONE)
+ goto DONE;
+
+ multprop = pgtk_get_window_property_as_lisp_data (dpyinfo,
+ requestor,
+ property,
+ QMULTIPLE,
+ selection,
+ true);
+
+ if (!VECTORP (multprop) || ASIZE (multprop) % 2)
+ goto DONE;
+
+ nselections = ASIZE (multprop) / 2;
+ /* Perform conversions. This can signal. */
+ for (j = 0; j < nselections; j++)
+ {
+ Lisp_Object subtarget = AREF (multprop, 2*j);
+ GdkAtom subproperty = symbol_to_gdk_atom (AREF (multprop, 2 * j + 1));
+ bool subsuccess = false;
+
+ if (subproperty != GDK_NONE)
+ subsuccess = pgtk_convert_selection (selection_symbol, subtarget,
+ subproperty, true, dpyinfo);
+ if (!subsuccess)
+ ASET (multprop, 2*j+1, Qnil);
+ }
+ /* Save conversion results */
+ lisp_data_to_selection_data (dpyinfo, multprop, &cs);
+ gdk_property_change (requestor, property,
+ cs.type, cs.format,
+ GDK_PROP_MODE_REPLACE,
+ cs.data, cs.size);
+ success = true;
}
- else if (type == GDK_SELECTION_CLIPBOARD)
+ else
{
- *quark_data = quark_clipboard_data;
- *quark_size = quark_clipboard_size;
+ if (property == GDK_NONE)
+ property = SELECTION_EVENT_TARGET (event);
+
+ success = pgtk_convert_selection (selection_symbol,
+ target_symbol, property,
+ false, dpyinfo);
}
+
+ DONE:
+
+ if (pushed)
+ selection_request_stack->converted = true;
+
+ if (success)
+ pgtk_reply_selection_request (event, dpyinfo);
else
- /* FIXME: Is it safe to use 'error' here? */
- error ("Unknown selection type.");
+ pgtk_decline_selection_request (event);
+
+ /* Run the `pgtk-sent-selection-functions' abnormal hook. */
+ if (!NILP (Vpgtk_sent_selection_functions)
+ && !BASE_EQ (Vpgtk_sent_selection_functions, Qunbound))
+ CALLN (Frun_hook_with_args, Qpgtk_sent_selection_functions,
+ selection_symbol, target_symbol, success ? Qt : Qnil);
+
+ unbind_to (count, Qnil);
}
-static void
-get_func (GtkClipboard * cb, GtkSelectionData * data, guint info,
- gpointer user_data_or_owner)
+/* Perform the requested selection conversion, and write the data to
+ the converted_selections linked list, where it can be accessed by
+ x_reply_selection_request. If FOR_MULTIPLE, write out
+ the data even if conversion fails, using conversion_fail_tag.
+
+ Return true if (and only if) successful. */
+
+static bool
+pgtk_convert_selection (Lisp_Object selection_symbol,
+ Lisp_Object target_symbol, GdkAtom property,
+ bool for_multiple, struct pgtk_display_info *dpyinfo)
{
- GObject *obj = G_OBJECT (user_data_or_owner);
- const char *str;
- int size;
- GQuark quark_data, quark_size;
+ Lisp_Object lisp_selection;
+ struct selection_data *cs;
+ struct pgtk_selection_request *frame;
+
+ lisp_selection
+ = pgtk_get_local_selection (selection_symbol, target_symbol,
+ false, dpyinfo);
- selection_type_to_quarks (gtk_clipboard_get_selection (cb), &quark_data,
- &quark_size);
+ frame = selection_request_stack;
- str = g_object_get_qdata (obj, quark_data);
- size = GPOINTER_TO_SIZE (g_object_get_qdata (obj, quark_size));
- gtk_selection_data_set_text (data, str, size);
+ /* A nil return value means we can't perform the conversion. */
+ if (NILP (lisp_selection)
+ || (CONSP (lisp_selection) && NILP (XCDR (lisp_selection))))
+ {
+ if (for_multiple)
+ {
+ cs = xmalloc (sizeof *cs);
+ cs->data = ((unsigned char *)
+ &selection_request_stack->conversion_fail_tag);
+ cs->size = 1;
+ cs->format = 32;
+ cs->type = GDK_SELECTION_TYPE_ATOM;
+ cs->nofree = true;
+ cs->property = property;
+ cs->wait_object = NULL;
+ cs->next = frame->converted_selections;
+ frame->converted_selections = cs;
+ }
+
+ return false;
+ }
+
+ /* Otherwise, record the converted selection to binary. */
+ cs = xmalloc (sizeof *cs);
+ cs->data = NULL;
+ cs->nofree = true;
+ cs->property = property;
+ cs->wait_object = NULL;
+ cs->next = frame->converted_selections;
+ frame->converted_selections = cs;
+ lisp_data_to_selection_data (dpyinfo, lisp_selection, cs);
+ return true;
}
+\f
+
+/* Handle a SelectionClear event EVENT, which indicates that some
+ client cleared out our previously asserted selection.
+ This is called from keyboard.c when such an event is found in the queue. */
+
static void
-clear_func (GtkClipboard * cb, gpointer user_data_or_owner)
+pgtk_handle_selection_clear (struct selection_input_event *event)
{
- GObject *obj = G_OBJECT (user_data_or_owner);
- GQuark quark_data, quark_size;
+ GdkAtom selection = SELECTION_EVENT_SELECTION (event);
+ guint32 changed_owner_time = SELECTION_EVENT_TIME (event);
- selection_type_to_quarks (gtk_clipboard_get_selection (cb), &quark_data,
- &quark_size);
+ Lisp_Object selection_symbol, local_selection_data;
+ guint32 local_selection_time;
+ struct pgtk_display_info *dpyinfo = SELECTION_EVENT_DPYINFO (event);
+ Lisp_Object Vselection_alist;
- g_object_set_qdata (obj, quark_data, NULL);
- g_object_set_qdata (obj, quark_size, 0);
-}
+ if (!dpyinfo) return;
+ selection_symbol = gdk_atom_to_symbol (selection);
+ local_selection_data = LOCAL_SELECTION (selection_symbol, dpyinfo);
-/* ==========================================================================
+ /* Well, we already believe that we don't own it, so that's just fine. */
+ if (NILP (local_selection_data)) return;
- Functions used externally
+ CONS_TO_INTEGER (XCAR (XCDR (XCDR (local_selection_data))),
+ guint32, local_selection_time);
- ========================================================================== */
+ /* We have reasserted the selection since this SelectionClear was
+ generated, so we can disregard it. */
+ if (changed_owner_time != GDK_CURRENT_TIME
+ && local_selection_time > changed_owner_time)
+ return;
+
+ /* Otherwise, really clear. Don't use Fdelq as that may quit. */
+ Vselection_alist = dpyinfo->terminal->Vselection_alist;
+ if (EQ (local_selection_data, CAR (Vselection_alist)))
+ Vselection_alist = XCDR (Vselection_alist);
+ else
+ {
+ Lisp_Object rest;
+ for (rest = Vselection_alist; CONSP (rest); rest = XCDR (rest))
+ if (EQ (local_selection_data, CAR (XCDR (rest))))
+ {
+ XSETCDR (rest, XCDR (XCDR (rest)));
+ break;
+ }
+ }
+ tset_selection_alist (dpyinfo->terminal, Vselection_alist);
+
+ /* Run the `pgtk-lost-selection-functions' abnormal hook. */
+ CALLN (Frun_hook_with_args, Qpgtk_lost_selection_functions, selection_symbol);
+
+ redisplay_preserve_echo_area (20);
+}
+
+void
+pgtk_handle_selection_event (struct selection_input_event *event)
+{
+ if (event->kind != SELECTION_REQUEST_EVENT)
+ pgtk_handle_selection_clear (event);
+ else
+ pgtk_handle_selection_request (event);
+}
+
+/* Clear all selections that were made from frame F.
+ We do this when about to delete a frame. */
void
-pgtk_selection_init (void)
+pgtk_clear_frame_selections (struct frame *f)
+{
+ Lisp_Object frame;
+ Lisp_Object rest;
+ struct pgtk_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
+ struct terminal *t = dpyinfo->terminal;
+
+ XSETFRAME (frame, f);
+
+ /* Delete elements from the beginning of Vselection_alist. */
+ while (CONSP (t->Vselection_alist)
+ && EQ (frame, XCAR (XCDR (XCDR (XCDR (XCAR (t->Vselection_alist)))))))
+ {
+ /* Run the `pgtk-lost-selection-functions' abnormal hook. */
+ CALLN (Frun_hook_with_args, Qpgtk_lost_selection_functions,
+ Fcar (Fcar (t->Vselection_alist)));
+
+ tset_selection_alist (t, XCDR (t->Vselection_alist));
+ }
+
+ /* Delete elements after the beginning of Vselection_alist. */
+ for (rest = t->Vselection_alist; CONSP (rest); rest = XCDR (rest))
+ if (CONSP (XCDR (rest))
+ && EQ (frame, XCAR (XCDR (XCDR (XCDR (XCAR (XCDR (rest))))))))
+ {
+ CALLN (Frun_hook_with_args, Qpgtk_lost_selection_functions,
+ XCAR (XCAR (XCDR (rest))));
+ XSETCDR (rest, XCDR (XCDR (rest)));
+ break;
+ }
+}
+
+/* True if any properties for DISPLAY and WINDOW
+ are on the list of what we are waiting for. */
+
+static bool
+waiting_for_other_props_on_window (GdkDisplay *display, GdkWindow *window)
+{
+ for (struct prop_location *p = property_change_wait_list; p; p = p->next)
+ if (p->display == display && p->window == window)
+ return true;
+ return false;
+}
+
+/* Add an entry to the list of property changes we are waiting for.
+ DISPLAY, WINDOW, PROPERTY, STATE describe what we will wait for.
+ The return value is a number that uniquely identifies
+ this awaited property change. */
+
+/* Currently unused -- uncomment later if we decide to implement INCR
+ transfer for X. */
+
+#if 0
+
+static struct prop_location *
+expect_property_change (GdkDisplay *display, GdkWindow *window,
+ GdkAtom property, int state)
+{
+ struct prop_location *pl = xmalloc (sizeof *pl);
+ pl->identifier = ++prop_location_identifier;
+ pl->display = display;
+ pl->window = window;
+ pl->property = property;
+ pl->desired_state = state;
+ pl->next = property_change_wait_list;
+ pl->arrived = false;
+ property_change_wait_list = pl;
+ return pl;
+}
+
+#endif
+
+/* Delete an entry from the list of property changes we are waiting for.
+ IDENTIFIER is the number that uniquely identifies the entry. */
+
+static void
+unexpect_property_change (struct prop_location *location)
{
- if (quark_primary_data == 0)
+ struct prop_location *prop, **pprev = &property_change_wait_list;
+
+ for (prop = property_change_wait_list; prop; prop = *pprev)
{
- quark_primary_data = g_quark_from_static_string ("pgtk-primary-data");
- quark_primary_size = g_quark_from_static_string ("pgtk-primary-size");
- quark_secondary_data =
- g_quark_from_static_string ("pgtk-secondary-data");
- quark_secondary_size =
- g_quark_from_static_string ("pgtk-secondary-size");
- quark_clipboard_data =
- g_quark_from_static_string ("pgtk-clipboard-data");
- quark_clipboard_size =
- g_quark_from_static_string ("pgtk-clipboard-size");
+ if (prop == location)
+ {
+ *pprev = prop->next;
+ xfree (prop);
+ break;
+ }
+ else
+ pprev = &prop->next;
}
}
+/* Remove the property change expectation element for IDENTIFIER. */
+
+static void
+wait_for_property_change_unwind (void *loc)
+{
+ struct prop_location *location = loc;
+
+ unexpect_property_change (location);
+ if (location == property_change_reply_object)
+ property_change_reply_object = 0;
+}
+
+/* Actually wait for a property change.
+ IDENTIFIER should be the value that expect_property_change returned. */
+
+static void
+wait_for_property_change (struct prop_location *location)
+{
+ specpdl_ref count = SPECPDL_INDEX ();
+
+ /* Make sure to do unexpect_property_change if we quit or err. */
+ record_unwind_protect_ptr (wait_for_property_change_unwind, location);
+
+ /* See comment in x_reply_selection_request about setting
+ property_change_reply. Do not do it here. */
+
+ /* If the event we are waiting for arrives beyond here, it will set
+ property_change_reply, because property_change_reply_object says so. */
+ if (! location->arrived)
+ {
+ intmax_t timeout = max (0, 5000);
+ intmax_t secs = timeout / 1000;
+ int nsecs = (timeout % 1000) * 1000000;
+
+ wait_reading_process_output (secs, nsecs, 0, false,
+ property_change_reply, NULL, 0);
+
+ if (NILP (XCAR (property_change_reply)))
+ error ("Timed out waiting for property-notify event");
+ }
+
+ unbind_to (count, Qnil);
+}
+
+/* Called from the big filter in response to a PropertyNotify
+ event. */
+
void
-pgtk_selection_lost (GtkWidget * widget, GdkEventSelection * event,
- gpointer user_data)
+pgtk_handle_property_notify (GdkEventProperty *event)
{
- GQuark quark_data, quark_size;
+ struct prop_location *rest;
+ GdkDisplay *dpy;
+
+ dpy = gdk_window_get_display (event->window);
- selection_type_to_quarks (event->selection, &quark_data, &quark_size);
+ for (rest = property_change_wait_list; rest; rest = rest->next)
+ {
+ if (!rest->arrived
+ && rest->property == event->atom
+ && rest->window == event->window
+ && rest->display == dpy
+ && rest->desired_state == event->state)
+ {
+ rest->arrived = true;
- g_object_set_qdata (G_OBJECT (widget), quark_data, NULL);
- g_object_set_qdata (G_OBJECT (widget), quark_size, 0);
+ /* If this is the one wait_for_property_change is waiting for,
+ tell it to wake up. */
+ if (rest == property_change_reply_object)
+ XSETCAR (property_change_reply, Qt);
+
+ return;
+ }
+ }
}
-static bool
-pgtk_selection_usable (void)
+static void
+pgtk_display_selection_waiting_message (struct atimer *timer)
{
- if (pgtk_enable_selection_on_multi_display)
- return true;
+ Lisp_Object val;
- /* Gdk uses `gdk_display_get_default' when handling selections, so
- selections don't work properly when Emacs is connected to
- multiple displays. */
+ val = build_string ("Waiting for reply from selection owner...");
+ message3_nolog (val);
+}
- GdkDisplayManager *dpyman = gdk_display_manager_get ();
- GSList *list = gdk_display_manager_list_displays (dpyman);
- int len = g_slist_length (list);
- g_slist_free (list);
- return len < 2;
+static void
+pgtk_cancel_atimer (void *atimer)
+{
+ cancel_atimer (atimer);
}
-/* ==========================================================================
+\f
+/* Variables for communication with pgtk_handle_selection_notify. */
+static GdkAtom reading_which_selection;
+static Lisp_Object reading_selection_reply;
+static GdkWindow *reading_selection_window;
- Lisp Defuns
+/* Do protocol to read selection-data from the window server.
+ Converts this to Lisp data and returns it.
+ FRAME is the frame whose window shall request the selection. */
- ========================================================================== */
+static Lisp_Object
+pgtk_get_foreign_selection (Lisp_Object selection_symbol, Lisp_Object target_type,
+ Lisp_Object time_stamp, Lisp_Object frame)
+{
+ struct frame *f = XFRAME (frame);
+ struct pgtk_display_info *dpyinfo = FRAME_DISPLAY_INFO (f);
+ GdkWindow *requestor_window = FRAME_GDK_WINDOW (f);
+ guint32 requestor_time = dpyinfo->last_user_time;
+ GdkAtom selection_atom = symbol_to_gdk_atom (selection_symbol);
+ GdkAtom type_atom = (CONSP (target_type)
+ ? symbol_to_gdk_atom (XCAR (target_type))
+ : symbol_to_gdk_atom (target_type));
+ struct atimer *delayed_message;
+ struct timespec message_interval;
+ specpdl_ref count;
+
+ count = SPECPDL_INDEX ();
+
+ if (!FRAME_LIVE_P (f))
+ return unbind_to (count, Qnil);
+
+ if (!NILP (time_stamp))
+ CONS_TO_INTEGER (time_stamp, guint32, requestor_time);
+
+ block_input ();
+ /* Prepare to block until the reply has been read. */
+ reading_selection_window = requestor_window;
+ reading_which_selection = selection_atom;
+ XSETCAR (reading_selection_reply, Qnil);
+
+ gdk_selection_convert (requestor_window, selection_atom,
+ type_atom, requestor_time);
+ unblock_input ();
+
+ /* It should not be necessary to stop handling selection requests
+ during this time. In fact, the SAVE_TARGETS mechanism requires
+ us to handle a clipboard manager's requests before it returns
+ GDK_SELECTION_NOTIFY. */
+
+ message_interval = make_timespec (1, 0);
+ delayed_message = start_atimer (ATIMER_RELATIVE, message_interval,
+ pgtk_display_selection_waiting_message,
+ NULL);
+ record_unwind_protect_ptr (pgtk_cancel_atimer, delayed_message);
+
+ /* This allows quits. Also, don't wait forever. */
+ intmax_t timeout = max (0, 5000);
+ intmax_t secs = timeout / 1000;
+ int nsecs = (timeout % 1000) * 1000000;
+
+ wait_reading_process_output (secs, nsecs, 0, false,
+ reading_selection_reply, NULL, 0);
+
+ if (NILP (XCAR (reading_selection_reply)))
+ error ("Timed out waiting for reply from selection owner");
+ if (EQ (XCAR (reading_selection_reply), Qlambda))
+ return unbind_to (count, Qnil);
+
+ /* Otherwise, the selection is waiting for us on the requested property. */
+ return unbind_to (count,
+ pgtk_get_window_property_as_lisp_data (dpyinfo,
+ requestor_window,
+ GDK_NONE,
+ target_type,
+ selection_atom,
+ false));
+}
+/* Subroutines of pgtk_get_window_property_as_lisp_data */
-DEFUN ("pgtk-own-selection-internal", Fpgtk_own_selection_internal, Spgtk_own_selection_internal, 2, 3, 0,
- doc: /* Assert an X selection of type SELECTION and value VALUE.
-SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.
-\(Those are literal upper-case symbol names, since that's what X expects.)
-VALUE is typically a string, or a cons of two markers, but may be
-anything that the functions on `selection-converter-alist' know about.
+static ptrdiff_t
+pgtk_size_for_format (gint format)
+{
+ switch (format)
+ {
+ case 8:
+ return sizeof (unsigned char);
+ case 16:
+ return sizeof (unsigned short);
+ case 32:
+ return sizeof (unsigned long);
+
+ default:
+ emacs_abort ();
+ }
+}
-FRAME should be a frame that should own the selection. If omitted or
-nil, it defaults to the selected frame. */)
- (Lisp_Object selection, Lisp_Object value, Lisp_Object frame)
+/* Use xfree, not g_free, to free the data obtained with this function. */
+
+static void
+pgtk_get_window_property (GdkWindow *window, unsigned char **data_ret,
+ ptrdiff_t *bytes_ret, GdkAtom *actual_type_ret,
+ int *actual_format_ret, unsigned long *actual_size_ret)
{
- Lisp_Object successful_p = Qnil;
- Lisp_Object target_symbol, rest;
- GtkClipboard *cb;
- struct frame *f;
- GQuark quark_data, quark_size;
+ gint length, actual_format;
+ unsigned char *data;
+ ptrdiff_t element_size;
+ void *xdata;
+ GdkAtom actual_type;
+ unsigned long i;
+ unsigned int *idata;
+ unsigned long *ldata;
+
+ data = NULL;
+
+ length = gdk_selection_property_get (window, &data,
+ &actual_type,
+ &actual_format);
+
+ if (!data)
+ {
+ *data_ret = NULL;
+ *actual_type_ret = GDK_NONE;
+ *bytes_ret = 0;
+ *actual_format_ret = 8;
+ *actual_size_ret = 0;
- check_window_system (NULL);
+ return;
+ }
- if (!pgtk_selection_usable ())
- return Qnil;
+ if (actual_type == GDK_SELECTION_TYPE_ATOM
+ || actual_type == gdk_atom_intern_static_string ("ATOM_PAIR"))
+ {
+ /* GDK should not allow anything else. */
+ eassert (actual_format == 32);
- if (NILP (frame))
- frame = selected_frame;
- if (!FRAME_LIVE_P (XFRAME (frame)) || !FRAME_PGTK_P (XFRAME (frame)))
- error ("pgtk selection unavailable for this frame");
- f = XFRAME (frame);
+ length = length / sizeof (GdkAtom);
+ xdata = xmalloc (sizeof (GdkAtom) * length);
+ memcpy (xdata, data, 1 + length * sizeof (GdkAtom));
+
+ g_free (data);
+
+ *data_ret = xdata;
+ *actual_type_ret = actual_type;
+ *bytes_ret = length * sizeof (GdkAtom);
+ *actual_format_ret = 32;
+ *actual_size_ret = length;
- cb = symbol_to_gtk_clipboard (FRAME_GTK_WIDGET (f), selection);
- selection_type_to_quarks (gtk_clipboard_get_selection (cb), &quark_data,
- &quark_size);
+ return;
+ }
+
+ element_size = pgtk_size_for_format (actual_format);
+ length = length / element_size;
- /* We only support copy of text. */
- target_symbol = QTEXT;
- if (STRINGP (value))
+ /* Add an extra byte on the end. GDK guarantees that it is
+ NULL. */
+ xdata = xmalloc (1 + element_size * length);
+ memcpy (xdata, data, 1 + element_size * length);
+
+ if (actual_format == 32 && LONG_WIDTH > 32)
{
- GtkTargetList *list;
- GtkTargetEntry *targets;
- gint n_targets;
- GtkWidget *widget;
+ ldata = (typeof (ldata)) data;
+ idata = xdata;
- list = gtk_target_list_new (NULL, 0);
- gtk_target_list_add_text_targets (list, 0);
+ for (i = 0; i < length; ++i)
+ idata[i] = ldata[i];
- {
- /* text/plain: Strings encoded by Gtk are not correctly decoded by Chromium(Wayland). */
- GdkAtom atom_text_plain = gdk_atom_intern ("text/plain", false);
- gtk_target_list_remove (list, atom_text_plain);
- }
+ /* There is always enough space in idata. */
+ idata[length] = 0;
+ *bytes_ret = sizeof *idata * length;
+ }
+ else
+ /* I think GDK itself prevents element_size from exceeding the
+ length at which this computation fails. */
+ *bytes_ret = element_size * length;
+
+ /* Now free the original `data' allocated by GDK. */
+ g_free (data);
+
+ *data_ret = xdata;
+ *actual_type_ret = GDK_NONE;
+ *actual_size_ret = length;
+ *actual_format_ret = actual_format;
+ *actual_type_ret = actual_type;
+}
+
+static Lisp_Object
+pgtk_get_window_property_as_lisp_data (struct pgtk_display_info *dpyinfo,
+ GdkWindow *window, GdkAtom property,
+ Lisp_Object target_type, GdkAtom selection_atom,
+ bool for_multiple)
+{
+ GdkAtom actual_type;
+ int actual_format;
+ unsigned long actual_size;
+ unsigned char *data = 0;
+ ptrdiff_t bytes = 0;
+ Lisp_Object val;
+ GdkDisplay *display = dpyinfo->display;
+
+ pgtk_get_window_property (window, &data, &bytes,
+ &actual_type, &actual_format,
+ &actual_size);
+
+ if (!data)
+ {
+ if (for_multiple)
+ return Qnil;
+
+ if (gdk_selection_owner_get_for_display (display, selection_atom))
+ {
+ AUTO_STRING (format, "Selection owner couldn't convert: %s");
+ CALLN (Fmessage, format,
+ actual_type
+ ? list2 (target_type,
+ gdk_atom_to_symbol (actual_type))
+ : target_type);
+ return Qnil;
+ }
+ else
+ {
+ AUTO_STRING (format, "No selection: %s");
+ CALLN (Fmessage, format,
+ gdk_atom_to_symbol (selection_atom));
+ return Qnil;
+ }
+ }
- targets = gtk_target_table_new_from_list (list, &n_targets);
+ if (!for_multiple && property != GDK_NONE)
+ gdk_property_delete (window, property);
- int size = SBYTES (value);
- gchar *str = xmalloc (size + 1);
- memcpy (str, SSDATA (value), size);
- str[size] = '\0';
+ /* It's been read. Now convert it to a lisp object in some semi-rational
+ manner. */
+ val = selection_data_to_lisp_data (dpyinfo, data, bytes,
+ actual_type, actual_format);
- widget = FRAME_GTK_WIDGET (f);
- g_object_set_qdata_full (G_OBJECT (widget), quark_data, str, xfree);
- g_object_set_qdata_full (G_OBJECT (widget), quark_size,
- GSIZE_TO_POINTER (size), NULL);
+ /* Use xfree, not g_free, because pgtk_get_window_property calls
+ xmalloc itself. */
+ xfree (data);
+ return val;
+}
+
+\f
+
+/* These functions convert from the selection data read from the
+ server into something that we can use from Lisp, and vice versa.
+
+ Type: Format: Size: Lisp Type:
+ ----- ------- ----- -----------
+ * 8 * String
+ ATOM 32 1 Symbol
+ ATOM 32 > 1 Vector of Symbols
+ * 16 1 Integer
+ * 16 > 1 Vector of Integers
+ * 32 1 if small enough: fixnum
+ otherwise: bignum
+ * 32 > 1 Vector of the above
+
+ When converting an object to C, it may be of the form (SYMBOL
+ . <data>) where SYMBOL is what we should claim that the type is.
+ Format and representation are as above.
+
+ Important: When format is 32, data should contain an array of int,
+ not an array of long as GDK returns. Unless TYPE is also
+ GDK_SELECTION_TYPE_ATOM, in which case data should be an array of
+ GdkAtom. This makes a difference when sizeof (long) != sizeof
+ (int). */
+
+static Lisp_Object
+selection_data_to_lisp_data (struct pgtk_display_info *dpyinfo,
+ const unsigned char *data,
+ ptrdiff_t size, GdkAtom type, int format)
+{
+ if (type == gdk_atom_intern_static_string ("NULL"))
+ return QNULL;
+ /* Convert any 8-bit data to a string, for compactness. */
+ else if (format == 8)
+ {
+ Lisp_Object str, lispy_type;
+
+ str = make_unibyte_string ((char *) data, size);
+ /* Indicate that this string is from foreign selection by a text
+ property `foreign-selection' so that the caller of
+ x-get-selection-internal (usually x-get-selection) can know
+ that the string must be decode. */
+ if (type == gdk_atom_intern_static_string ("COMPOUND_TEXT"))
+ lispy_type = QCOMPOUND_TEXT;
+ else if (type == gdk_atom_intern_static_string ("UTF8_STRING"))
+ lispy_type = QUTF8_STRING;
+ else
+ lispy_type = QSTRING;
+
+ Fput_text_property (make_fixnum (0), make_fixnum (size),
+ Qforeign_selection, lispy_type, str);
+ return str;
+ }
+ /* Convert a single atom to a Lisp_Symbol. Convert a set of atoms to
+ a vector of symbols. */
+ else if (format == 32
+ && (type == GDK_SELECTION_TYPE_ATOM
+ /* Treat ATOM_PAIR type similar to list of atoms. */
+ || type == gdk_atom_intern_static_string ("ATOM_PAIR")))
+ {
+ ptrdiff_t i;
+ GdkAtom *idata = (GdkAtom *) data;
- if (gtk_clipboard_set_with_owner (cb,
- targets, n_targets,
- get_func, clear_func,
- G_OBJECT (FRAME_GTK_WIDGET (f))))
+ if (size == sizeof (GdkAtom))
+ return gdk_atom_to_symbol (idata[0]);
+ else
{
- successful_p = Qt;
+ Lisp_Object v = make_nil_vector (size / sizeof (GdkAtom));
+
+ for (i = 0; i < size / sizeof (GdkAtom); i++)
+ ASET (v, i, gdk_atom_to_symbol (idata[i]));
+ return v;
}
- gtk_clipboard_set_can_store (cb, NULL, 0);
+ }
+
+ /* Convert a single 16-bit number or a small 32-bit number to a Lisp_Int.
+ If the number is 32 bits and won't fit in a Lisp_Int, convert it
+ to a bignum.
- gtk_target_table_free (targets, n_targets);
- gtk_target_list_unref (list);
+ INTEGER is a signed type, CARDINAL is unsigned.
+ Assume any other types are unsigned as well.
+ */
+ else if (format == 32 && size == sizeof (int))
+ {
+ if (type == GDK_SELECTION_TYPE_INTEGER)
+ return INT_TO_INTEGER (((int *) data) [0]);
+ else
+ return INT_TO_INTEGER (((unsigned int *) data) [0]);
+ }
+ else if (format == 16 && size == sizeof (short))
+ {
+ if (type == GDK_SELECTION_TYPE_INTEGER)
+ return make_fixnum (((short *) data) [0]);
+ else
+ return make_fixnum (((unsigned short *) data) [0]);
+ }
+ /* Convert any other kind of data to a vector of numbers, represented
+ as above (as an integer, or a cons of two 16 bit integers.)
+ */
+ else if (format == 16)
+ {
+ ptrdiff_t i;
+ Lisp_Object v = make_uninit_vector (size / 2);
+
+ if (type == GDK_SELECTION_TYPE_INTEGER)
+ {
+ for (i = 0; i < size / 2; i++)
+ {
+ short j = ((short *) data) [i];
+ ASET (v, i, make_fixnum (j));
+ }
+ }
+ else
+ {
+ for (i = 0; i < size / 2; i++)
+ {
+ unsigned short j = ((unsigned short *) data) [i];
+ ASET (v, i, make_fixnum (j));
+ }
+ }
+ return v;
}
+ else
+ {
+ ptrdiff_t i;
+ Lisp_Object v = make_nil_vector (size / sizeof (gint));
+
+ if (type == GDK_SELECTION_TYPE_INTEGER)
+ {
+ for (i = 0; i < size / sizeof (gint); i++)
+ {
+ int j = ((gint *) data) [i];
+ ASET (v, i, INT_TO_INTEGER (j));
+ }
+ }
+ else
+ {
+ for (i = 0; i < size / sizeof (gint); i++)
+ {
+ unsigned int j = ((unsigned int *) data) [i];
+ ASET (v, i, INT_TO_INTEGER (j));
+ }
+ }
+ return v;
+ }
+}
+
+/* Convert OBJ to an X long value, and return it as unsigned long.
+ OBJ should be an integer or a cons representing an integer.
+ Treat values in the range X_LONG_MAX + 1 .. X_ULONG_MAX as X
+ unsigned long values: in theory these values are supposed to be
+ signed but in practice unsigned 32-bit data are communicated via X
+ selections and we need to support that. */
+static unsigned long
+cons_to_gdk_long (Lisp_Object obj)
+{
+ if (G_MAXUINT32 <= INTMAX_MAX
+ || NILP (Fnatnump (CONSP (obj) ? XCAR (obj) : obj)))
+ return cons_to_signed (obj, 0, min (G_MAXUINT32, INTMAX_MAX));
+ else
+ return cons_to_unsigned (obj, G_MAXUINT32);
+}
+
+/* Use xfree, not XFree, to free the data obtained with this function. */
+
+static void
+lisp_data_to_selection_data (struct pgtk_display_info *dpyinfo,
+ Lisp_Object obj, struct selection_data *cs)
+{
+ Lisp_Object type = Qnil;
- if (!BASE_EQ (Vpgtk_sent_selection_hooks, Qunbound))
+ eassert (cs != NULL);
+ cs->nofree = false;
+
+ if (CONSP (obj) && SYMBOLP (XCAR (obj)))
{
- /* FIXME: Use run-hook-with-args! */
- for (rest = Vpgtk_sent_selection_hooks; CONSP (rest);
- rest = Fcdr (rest))
- call3 (Fcar (rest), selection, target_symbol, successful_p);
+ type = XCAR (obj);
+ obj = XCDR (obj);
+ if (CONSP (obj) && NILP (XCDR (obj)))
+ obj = XCAR (obj);
}
+ if (EQ (obj, QNULL) || (EQ (type, QNULL)))
+ { /* This is not the same as declining */
+ cs->format = 32;
+ cs->size = 0;
+ cs->data = NULL;
+ type = QNULL;
+ }
+ else if (STRINGP (obj))
+ {
+ if (SCHARS (obj) < SBYTES (obj))
+ /* OBJ is a multibyte string containing a non-ASCII char. */
+ signal_error ("Non-ASCII string must be encoded in advance", obj);
+ if (NILP (type))
+ type = QSTRING;
+ cs->format = 8;
+ cs->size = SBYTES (obj);
+ cs->data = SDATA (obj);
+ cs->nofree = true;
+ }
+ else if (SYMBOLP (obj))
+ {
+ void *data = xmalloc (sizeof (GdkAtom) + 1);
+ GdkAtom *x_atom_ptr = data;
+ cs->data = data;
+ cs->format = 32;
+ cs->size = 1;
+ cs->data[sizeof (GdkAtom)] = 0;
+ *x_atom_ptr = symbol_to_gdk_atom (obj);
+ if (NILP (type)) type = QATOM;
+ }
+ else if (RANGED_FIXNUMP (SHRT_MIN, obj, SHRT_MAX))
+ {
+ void *data = xmalloc (sizeof (short) + 1);
+ short *short_ptr = data;
+ cs->data = data;
+ cs->format = 16;
+ cs->size = 1;
+ cs->data[sizeof (short)] = 0;
+ *short_ptr = XFIXNUM (obj);
+ if (NILP (type)) type = QINTEGER;
+ }
+ else if (INTEGERP (obj)
+ || (CONSP (obj) && INTEGERP (XCAR (obj))
+ && (FIXNUMP (XCDR (obj))
+ || (CONSP (XCDR (obj))
+ && FIXNUMP (XCAR (XCDR (obj)))))))
+ {
+ void *data = xmalloc (sizeof (unsigned long) + 1);
+ unsigned long *x_long_ptr = data;
+ cs->data = data;
+ cs->format = 32;
+ cs->size = 1;
+ cs->data[sizeof (unsigned long)] = 0;
+ *x_long_ptr = cons_to_gdk_long (obj);
+ if (NILP (type)) type = QINTEGER;
+ }
+ else if (VECTORP (obj))
+ {
+ /* Lisp_Vectors may represent a set of ATOMs;
+ a set of 16 or 32 bit INTEGERs;
+ or a set of ATOM_PAIRs (represented as [[A1 A2] [A3 A4] ...]
+ */
+ ptrdiff_t i;
+ ptrdiff_t size = ASIZE (obj);
+
+ if (SYMBOLP (AREF (obj, 0)))
+ /* This vector is an ATOM set */
+ {
+ void *data;
+ GdkAtom *x_atoms;
+ if (NILP (type)) type = QATOM;
+ for (i = 0; i < size; i++)
+ if (!SYMBOLP (AREF (obj, i)))
+ signal_error ("All elements of selection vector must have same type", obj);
+
+ cs->data = data = xnmalloc (size, sizeof *x_atoms);
+ x_atoms = data;
+ cs->format = 32;
+ cs->size = size;
+ for (i = 0; i < size; i++)
+ x_atoms[i] = symbol_to_gdk_atom (AREF (obj, i));
+ }
+ else
+ /* This vector is an INTEGER set, or something like it */
+ {
+ int format = 16;
+ int data_size = sizeof (short);
+ void *data;
+ unsigned long *x_atoms;
+ short *shorts;
+ if (NILP (type)) type = QINTEGER;
+ for (i = 0; i < size; i++)
+ {
+ if (! RANGED_FIXNUMP (SHRT_MIN, AREF (obj, i), SHRT_MAX))
+ {
+ /* Use sizeof (long) even if it is more than 32 bits.
+ See comment in x_get_window_property and
+ x_fill_property_data. */
+ data_size = sizeof (long);
+ format = 32;
+ break;
+ }
+ }
+ cs->data = data = xnmalloc (size, data_size);
+ x_atoms = data;
+ shorts = data;
+ cs->format = format;
+ cs->size = size;
+ for (i = 0; i < size; i++)
+ {
+ if (format == 32)
+ x_atoms[i] = cons_to_gdk_long (AREF (obj, i));
+ else
+ shorts[i] = XFIXNUM (AREF (obj, i));
+ }
+ }
+ }
+ else
+ signal_error (/* Qselection_error */ "Unrecognized selection data", obj);
+
+ cs->type = symbol_to_gdk_atom (type);
+}
+
+static Lisp_Object
+clean_local_selection_data (Lisp_Object obj)
+{
+ if (CONSP (obj)
+ && INTEGERP (XCAR (obj))
+ && CONSP (XCDR (obj))
+ && FIXNUMP (XCAR (XCDR (obj)))
+ && NILP (XCDR (XCDR (obj))))
+ obj = Fcons (XCAR (obj), XCDR (obj));
+
+ if (CONSP (obj)
+ && INTEGERP (XCAR (obj))
+ && FIXNUMP (XCDR (obj)))
+ {
+ if (BASE_EQ (XCAR (obj), make_fixnum (0)))
+ return XCDR (obj);
+ if (BASE_EQ (XCAR (obj), make_fixnum (-1)))
+ return make_fixnum (- XFIXNUM (XCDR (obj)));
+ }
+ if (VECTORP (obj))
+ {
+ ptrdiff_t i;
+ ptrdiff_t size = ASIZE (obj);
+ Lisp_Object copy;
+ if (size == 1)
+ return clean_local_selection_data (AREF (obj, 0));
+ copy = make_nil_vector (size);
+ for (i = 0; i < size; i++)
+ ASET (copy, i, clean_local_selection_data (AREF (obj, i)));
+ return copy;
+ }
+ return obj;
+}
+
+DEFUN ("pgtk-own-selection-internal", Fpgtk_own_selection_internal,
+ Spgtk_own_selection_internal, 2, 3, 0,
+ doc: /* Assert a selection of type SELECTION and value VALUE.
+SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.
+\(Those are literal upper-case symbol names, since that's what GDK expects.)
+VALUE is typically a string, or a cons of two markers, but may be
+anything that the functions on `selection-converter-alist' know about.
+
+FRAME should be a frame that should own the selection. If omitted or
+nil, it defaults to the selected frame. */)
+ (Lisp_Object selection, Lisp_Object value, Lisp_Object frame)
+{
+ if (NILP (frame)) frame = selected_frame;
+ if (!FRAME_LIVE_P (XFRAME (frame)) || !FRAME_PGTK_P (XFRAME (frame)))
+ error ("GDK selection unavailable for this frame");
+
+ CHECK_SYMBOL (selection);
+ if (NILP (value)) error ("VALUE may not be nil");
+ pgtk_own_selection (selection, value, frame);
return value;
}
+/* Request the selection value from the owner. If we are the owner,
+ simply return our selection value. If we are not the owner, this
+ will block until all of the data has arrived. */
-DEFUN ("pgtk-disown-selection-internal", Fpgtk_disown_selection_internal,
- Spgtk_disown_selection_internal, 1, 2, 0,
- doc: /* If we own the selection SELECTION, disown it.
-Disowning it means there is no such selection.
+DEFUN ("pgtk-get-selection-internal", Fpgtk_get_selection_internal,
+ Spgtk_get_selection_internal, 2, 4, 0,
+ doc: /* Return text selected from some X window.
+SELECTION-SYMBOL is typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.
+\(Those are literal upper-case symbol names, since that's what X expects.)
+TARGET-TYPE is the type of data desired, typically `STRING'.
+
+TIME-STAMP is the time to use in the XConvertSelection call for foreign
+selections. If omitted, defaults to the time for the last event.
TERMINAL should be a terminal object or a frame specifying the X
server to query. If omitted or nil, that stands for the selected
frame's display, or the first available X display. */)
- (Lisp_Object selection, Lisp_Object terminal)
+ (Lisp_Object selection_symbol, Lisp_Object target_type,
+ Lisp_Object time_stamp, Lisp_Object terminal)
{
+ Lisp_Object val = Qnil;
+ Lisp_Object maybe_alias;
struct frame *f = frame_for_pgtk_selection (terminal);
- GtkClipboard *cb;
- if (!pgtk_selection_usable ())
- return Qnil;
+ CHECK_SYMBOL (selection_symbol);
+ CHECK_SYMBOL (target_type);
+ if (EQ (target_type, QMULTIPLE))
+ error ("Retrieving MULTIPLE selections is currently unimplemented");
if (!f)
- return Qnil;
+ error ("GDK selection unavailable for this frame");
- cb = symbol_to_gtk_clipboard (FRAME_GTK_WIDGET (f), selection);
+ /* Quitting inside this function is okay, so we don't have to use
+ FOR_EACH_TAIL_SAFE. */
+ maybe_alias = Fassq (selection_symbol, Vpgtk_selection_alias_alist);
- gtk_clipboard_clear (cb);
+ if (!NILP (maybe_alias))
+ {
+ selection_symbol = XCDR (maybe_alias);
+ CHECK_SYMBOL (selection_symbol);
+ }
- return Qt;
+ val = pgtk_get_local_selection (selection_symbol, target_type, true,
+ FRAME_DISPLAY_INFO (f));
+
+ if (NILP (val) && FRAME_LIVE_P (f))
+ {
+ Lisp_Object frame;
+ XSETFRAME (frame, f);
+ return pgtk_get_foreign_selection (selection_symbol, target_type,
+ time_stamp, frame);
+ }
+
+ if (CONSP (val) && SYMBOLP (XCAR (val)))
+ {
+ val = XCDR (val);
+ if (CONSP (val) && NILP (XCDR (val)))
+ val = XCAR (val);
+ }
+ return clean_local_selection_data (val);
}
+DEFUN ("pgtk-disown-selection-internal", Fpgtk_disown_selection_internal,
+ Spgtk_disown_selection_internal, 1, 3, 0,
+ doc: /* If we own the selection SELECTION, disown it.
+Disowning it means there is no such selection.
-DEFUN ("pgtk-selection-exists-p", Fpgtk_selection_exists_p, Spgtk_selection_exists_p, 0, 2, 0,
- doc: /* Whether there is an owner for the given X selection.
-SELECTION should be the name of the selection in question, typically
-one of the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'. (X expects
-these literal upper-case names.) The symbol nil is the same as
-`PRIMARY', and t is the same as `SECONDARY'.
+Sets the last-change time for the selection to TIME-OBJECT (by default
+the time of the last event).
TERMINAL should be a terminal object or a frame specifying the X
server to query. If omitted or nil, that stands for the selected
-frame's display, or the first available X display.
-
-On Nextstep, TERMINAL is unused. */)
- (Lisp_Object selection, Lisp_Object terminal)
+frame's display, or the first available X display. */)
+ (Lisp_Object selection, Lisp_Object time_object, Lisp_Object terminal)
{
+ guint32 timestamp;
+ GdkAtom selection_atom;
struct frame *f = frame_for_pgtk_selection (terminal);
- GtkClipboard *cb;
+ struct pgtk_display_info *dpyinfo;
- if (!pgtk_selection_usable ())
+ if (!f)
return Qnil;
- if (!f)
+ dpyinfo = FRAME_DISPLAY_INFO (f);
+ CHECK_SYMBOL (selection);
+
+ /* Don't disown the selection when we're not the owner. */
+ if (NILP (LOCAL_SELECTION (selection, dpyinfo)))
return Qnil;
- cb = symbol_to_gtk_clipboard (FRAME_GTK_WIDGET (f), selection);
+ selection_atom = symbol_to_gdk_atom (selection);
- return gtk_clipboard_wait_is_text_available (cb) ? Qt : Qnil;
-}
+ block_input ();
+ if (NILP (time_object))
+ timestamp = dpyinfo->last_user_time;
+ else
+ CONS_TO_INTEGER (time_object, guint32, timestamp);
+ gdk_selection_owner_set_for_display (dpyinfo->display, NULL,
+ selection_atom, timestamp,
+ TRUE);
+ unblock_input ();
+ return Qt;
+}
-DEFUN ("pgtk-selection-owner-p", Fpgtk_selection_owner_p, Spgtk_selection_owner_p, 0, 2, 0,
- doc: /* Whether the current Emacs process owns the given X Selection.
+DEFUN ("pgtk-selection-owner-p", Fpgtk_selection_owner_p, Spgtk_selection_owner_p,
+ 0, 2, 0,
+ doc: /* Whether the current Emacs process owns the given selection.
The arg should be the name of the selection in question, typically one of
the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.
-\(Those are literal upper-case symbol names, since that's what X expects.)
+\(Those are literal upper-case symbol names, since that's what GDK expects.)
For convenience, the symbol nil is the same as `PRIMARY',
and t is the same as `SECONDARY'.
-TERMINAL should be a terminal object or a frame specifying the X
+TERMINAL should be a terminal object or a frame specifying the GDK
server to query. If omitted or nil, that stands for the selected
-frame's display, or the first available X display.
-
-On Nextstep, TERMINAL is unused. */)
+frame's display, or the first available X display. */)
(Lisp_Object selection, Lisp_Object terminal)
{
struct frame *f = frame_for_pgtk_selection (terminal);
- GtkClipboard *cb;
- GObject *obj;
- GQuark quark_data, quark_size;
-
- if (!pgtk_selection_usable ())
- return Qnil;
- cb = symbol_to_gtk_clipboard (FRAME_GTK_WIDGET (f), selection);
- selection_type_to_quarks (gtk_clipboard_get_selection (cb), &quark_data,
- &quark_size);
+ CHECK_SYMBOL (selection);
+ if (NILP (selection)) selection = QPRIMARY;
+ if (EQ (selection, Qt)) selection = QSECONDARY;
- obj = gtk_clipboard_get_owner (cb);
-
- return obj && g_object_get_qdata (obj, quark_data) != NULL ? Qt : Qnil;
+ if (f && !NILP (LOCAL_SELECTION (selection, FRAME_DISPLAY_INFO (f))))
+ return Qt;
+ else
+ return Qnil;
}
+DEFUN ("pgtk-selection-exists-p", Fpgtk_selection_exists_p, Spgtk_selection_exists_p,
+ 0, 2, 0,
+ doc: /* Whether there is an owner for the given selection.
+SELECTION should be the name of the selection in question, typically
+one of the symbols `PRIMARY', `SECONDARY', `CLIPBOARD', or
+`CLIPBOARD_MANAGER' (GDK expects these literal upper-case names.) The
+symbol nil is the same as `PRIMARY', and t is the same as `SECONDARY'.
-DEFUN ("pgtk-get-selection-internal", Fpgtk_get_selection_internal,
- Spgtk_get_selection_internal, 2, 3, 0,
- doc: /* Return text selected from some program.
-SELECTION-SYMBOL is typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.
-\(Those are literal upper-case symbol names, since that's what X expects.)
-TARGET-TYPE is the type of data desired, typically `STRING'.
-
-TERMINAL should be a terminal object or a frame specifying the X
+TERMINAL should be a terminal object or a frame specifying the GDK
server to query. If omitted or nil, that stands for the selected
-frame's display, or the first available display. */)
- (Lisp_Object selection_symbol, Lisp_Object target_type,
- Lisp_Object terminal)
+frame's display, or the first available X display. */)
+ (Lisp_Object selection, Lisp_Object terminal)
{
+ GdkWindow *owner;
+ GdkAtom atom;
struct frame *f = frame_for_pgtk_selection (terminal);
- GtkClipboard *cb;
+ struct pgtk_display_info *dpyinfo;
- CHECK_SYMBOL (selection_symbol);
- CHECK_SYMBOL (target_type);
+ CHECK_SYMBOL (selection);
+ if (NILP (selection)) selection = QPRIMARY;
+ if (EQ (selection, Qt)) selection = QSECONDARY;
- if (EQ (target_type, QMULTIPLE))
- error ("Retrieving MULTIPLE selections is currently unimplemented");
if (!f)
- error ("PGTK selection unavailable for this frame");
-
- if (!pgtk_selection_usable ())
return Qnil;
- cb = symbol_to_gtk_clipboard (FRAME_GTK_WIDGET (f), selection_symbol);
-
- GdkAtom target_atom = gdk_atom_intern (SSDATA (SYMBOL_NAME (target_type)), false);
- GtkSelectionData *seldata = gtk_clipboard_wait_for_contents (cb, target_atom);
+ dpyinfo = FRAME_DISPLAY_INFO (f);
- if (seldata == NULL)
- return Qnil;
+ if (!NILP (LOCAL_SELECTION (selection, dpyinfo)))
+ return Qt;
- const guchar *sd_data = gtk_selection_data_get_data (seldata);
- int sd_len = gtk_selection_data_get_length (seldata);
- int sd_format = gtk_selection_data_get_format (seldata);
- GdkAtom sd_type = gtk_selection_data_get_data_type (seldata);
+ atom = symbol_to_gdk_atom (selection);
+ if (atom == 0) return Qnil;
+ block_input ();
+ owner = gdk_selection_owner_get_for_display (dpyinfo->display, atom);
+ unblock_input ();
+ return (owner ? Qt : Qnil);
+}
- if (sd_format == 8)
- {
- Lisp_Object str, lispy_type;
+/* Called to handle GDK_SELECTION_NOTIFY events.
+ If it's the selection we are waiting for, stop waiting
+ by setting the car of reading_selection_reply to non-nil.
+ We store t there if the reply is successful, lambda if not. */
- str = make_unibyte_string ((char *) sd_data, sd_len);
- /* Indicate that this string is from foreign selection by a text
- property `foreign-selection' so that the caller of
- x-get-selection-internal (usually x-get-selection) can know
- that the string must be decode. */
- if (sd_type == gdk_atom_intern ("COMPOUND_TEXT", false))
- lispy_type = QCOMPOUND_TEXT;
- else if (sd_type == gdk_atom_intern ("UTF8_STRING", false))
- lispy_type = QUTF8_STRING;
- else if (sd_type == gdk_atom_intern ("text/plain;charset=utf-8", false))
- lispy_type = Qtext_plain_charset_utf_8;
- else
- lispy_type = QSTRING;
- Fput_text_property (make_fixnum (0), make_fixnum (sd_len),
- Qforeign_selection, lispy_type, str);
+void
+pgtk_handle_selection_notify (GdkEventSelection *event)
+{
+ /* GDK doesn't populate event->requestor, contrary to what the ICCCM
+ says should be done with SelectionNotify events. */
- gtk_selection_data_free (seldata);
- return str;
- }
+ if (event->selection != reading_which_selection)
+ return;
- gtk_selection_data_free (seldata);
- return Qnil;
+ XSETCAR (reading_selection_reply,
+ (event->property != GDK_NONE ? Qt : Qlambda));
}
void
DEFSYM (QSECONDARY, "SECONDARY");
DEFSYM (QTEXT, "TEXT");
DEFSYM (QFILE_NAME, "FILE_NAME");
+ DEFSYM (QSTRING, "STRING");
+ DEFSYM (QINTEGER, "INTEGER");
+ DEFSYM (QTIMESTAMP, "TIMESTAMP");
+ DEFSYM (QTEXT, "TEXT");
DEFSYM (QMULTIPLE, "MULTIPLE");
+ DEFSYM (QNULL, "NULL");
+ DEFSYM (QATOM, "ATOM");
+ DEFSYM (QTARGETS, "TARGETS");
+
+ DEFSYM (Qpgtk_sent_selection_functions,
+ "pgtk-sent-selection-functions");
+ DEFSYM (Qpgtk_lost_selection_functions,
+ "pgtk-lost-selection-functions");
DEFSYM (Qforeign_selection, "foreign-selection");
DEFSYM (QUTF8_STRING, "UTF8_STRING");
defsubr (&Spgtk_selection_exists_p);
defsubr (&Spgtk_selection_owner_p);
+ DEFVAR_LISP ("selection-converter-alist", Vselection_converter_alist,
+ doc: /* SKIP: real doc in xselect.c. */);
+ Vselection_converter_alist = Qnil;
+
+ DEFVAR_LISP ("pgtk-lost-selection-functions", Vpgtk_lost_selection_functions,
+ doc: /* A list of functions to be called when Emacs loses a selection.
+\(This happens when some other client makes its own selection
+or when a Lisp program explicitly clears the selection.)
+The functions are called with one argument, the selection type
+\(a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'). */);
+ Vpgtk_lost_selection_functions = Qnil;
+
+ DEFVAR_LISP ("pgtk-sent-selection-functions", Vpgtk_sent_selection_functions,
+ doc: /* A list of functions to be called when Emacs answers a selection request.
+The functions are called with three arguments:
+ - the selection name (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');
+ - the selection-type which Emacs was asked to convert the
+ selection into before sending (for example, `STRING' or `LENGTH');
+ - a flag indicating success or failure for responding to the request.
+We might have failed (and declined the request) for any number of reasons,
+including being asked for a selection that we no longer own, or being asked
+to convert into a type that we don't know about or that is inappropriate.
+This hook doesn't let you change the behavior of Emacs's selection replies,
+it merely informs you that they have happened. */);
+ Vpgtk_sent_selection_functions = Qnil;
+
DEFVAR_LISP ("pgtk-sent-selection-hooks", Vpgtk_sent_selection_hooks,
doc: /* A list of functions to be called when Emacs answers a selection request
The functions are called with four arguments:
will connect to a single display. It might also cause selections to
not arrive at the correct display. */);
pgtk_enable_selection_on_multi_display = false;
+
+ DEFVAR_LISP ("pgtk-selection-alias-alist", Vpgtk_selection_alias_alist,
+ doc: /* List of selections to alias to another.
+It should be an alist of a selection name to another. When a
+selection request arrives for the first selection, Emacs will respond
+as if the request was meant for the other.
+
+Note that this does not affect setting or owning selections. */);
+ Vpgtk_selection_alias_alist = Qnil;
+
+ reading_selection_reply = Fcons (Qnil, Qnil);
+ staticpro (&reading_selection_reply);
+
+ property_change_reply = Fcons (Qnil, Qnil);
+ staticpro (&property_change_reply);
}
projects / emacs.git / commitdiff