-/* X Selection processing for emacs
- Copyright (C) 1993 Free Software Foundation.
+/* X Selection processing for Emacs.
+ Copyright (C) 1993, 1994 Free Software Foundation.
This file is part of GNU Emacs.
along with GNU Emacs; see the file COPYING. If not, write to
the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
-/* x_handle_selection_notify
-x_reply_selection_request */
-
/* Rewritten by jwz */
-#include "config.h"
+#include <config.h>
#include "lisp.h"
-#if 0
-#include <stdio.h> /* termhooks.h needs this */
-#include "termhooks.h"
-#endif
#include "xterm.h" /* for all of the X includes */
#include "dispextern.h" /* frame.h seems to want this */
#include "frame.h" /* Need this to get the X window of selected_frame */
#define CUT_BUFFER_SUPPORT
-static Atom Xatom_CLIPBOARD, Xatom_TIMESTAMP, Xatom_TEXT, Xatom_DELETE,
- Xatom_MULTIPLE, Xatom_INCR, Xatom_EMACS_TMP, Xatom_TARGETS, Xatom_NULL,
- Xatom_ATOM_PAIR;
-
Lisp_Object QPRIMARY, QSECONDARY, QSTRING, QINTEGER, QCLIPBOARD, QTIMESTAMP,
QTEXT, QDELETE, QMULTIPLE, QINCR, QEMACS_TMP, QTARGETS, QATOM, QNULL,
QATOM_PAIR;
unsigned long last_event_timestamp;
/* This is an association list whose elements are of the form
- ( selection-name selection-value selection-timestamp )
- selection-name is a lisp symbol, whose name is the name of an X Atom.
- selection-value is the value that emacs owns for that selection.
+ ( SELECTION-NAME SELECTION-VALUE SELECTION-TIMESTAMP FRAME)
+ SELECTION-NAME is a lisp symbol, whose name is the name of an X Atom.
+ SELECTION-VALUE is the value that emacs owns for that selection.
It may be any kind of Lisp object.
- selection-timestamp is the time at which emacs began owning this selection,
+ SELECTION-TIMESTAMP is the time at which emacs began owning this selection,
as a cons of two 16-bit numbers (making a 32 bit time.)
- If there is an entry in this alist, then it can be assumed that emacs owns
+ FRAME is the frame for which we made the selection.
+ If there is an entry in this alist, then it can be assumed that Emacs owns
that selection.
The only (eq) parts of this list that are visible from Lisp are the
selection-values.
we give up on it. This is in milliseconds (0 = no timeout.)
*/
int x_selection_timeout;
-
\f
/* Utility functions */
static Lisp_Object selection_data_to_lisp_data ();
static Lisp_Object x_get_window_property_as_lisp_data ();
-static int expect_property_change ();
-static void wait_for_property_change ();
-static void unexpect_property_change ();
-static int waiting_for_other_props_on_window ();
-
/* This converts a Lisp symbol to a server Atom, avoiding a server
roundtrip whenever possible. */
static Atom
-symbol_to_x_atom (display, sym)
+symbol_to_x_atom (dpyinfo, display, sym)
+ struct x_display_info *dpyinfo;
Display *display;
Lisp_Object sym;
{
if (EQ (sym, QSTRING)) return XA_STRING;
if (EQ (sym, QINTEGER)) return XA_INTEGER;
if (EQ (sym, QATOM)) return XA_ATOM;
- if (EQ (sym, QCLIPBOARD)) return Xatom_CLIPBOARD;
- if (EQ (sym, QTIMESTAMP)) return Xatom_TIMESTAMP;
- if (EQ (sym, QTEXT)) return Xatom_TEXT;
- if (EQ (sym, QDELETE)) return Xatom_DELETE;
- if (EQ (sym, QMULTIPLE)) return Xatom_MULTIPLE;
- if (EQ (sym, QINCR)) return Xatom_INCR;
- if (EQ (sym, QEMACS_TMP)) return Xatom_EMACS_TMP;
- if (EQ (sym, QTARGETS)) return Xatom_TARGETS;
- if (EQ (sym, QNULL)) return Xatom_NULL;
+ if (EQ (sym, QCLIPBOARD)) return dpyinfo->Xatom_CLIPBOARD;
+ if (EQ (sym, QTIMESTAMP)) return dpyinfo->Xatom_TIMESTAMP;
+ if (EQ (sym, QTEXT)) return dpyinfo->Xatom_TEXT;
+ if (EQ (sym, QDELETE)) return dpyinfo->Xatom_DELETE;
+ if (EQ (sym, QMULTIPLE)) return dpyinfo->Xatom_MULTIPLE;
+ if (EQ (sym, QINCR)) return dpyinfo->Xatom_INCR;
+ if (EQ (sym, QEMACS_TMP)) return dpyinfo->Xatom_EMACS_TMP;
+ if (EQ (sym, QTARGETS)) return dpyinfo->Xatom_TARGETS;
+ if (EQ (sym, QNULL)) return dpyinfo->Xatom_NULL;
#ifdef CUT_BUFFER_SUPPORT
if (EQ (sym, QCUT_BUFFER0)) return XA_CUT_BUFFER0;
if (EQ (sym, QCUT_BUFFER1)) return XA_CUT_BUFFER1;
and calls to intern whenever possible. */
static Lisp_Object
-x_atom_to_symbol (display, atom)
+x_atom_to_symbol (dpyinfo, display, atom)
+ struct x_display_info *dpyinfo;
Display *display;
Atom atom;
{
#endif
}
- if (atom == Xatom_CLIPBOARD)
+ if (atom == dpyinfo->Xatom_CLIPBOARD)
return QCLIPBOARD;
- if (atom == Xatom_TIMESTAMP)
+ if (atom == dpyinfo->Xatom_TIMESTAMP)
return QTIMESTAMP;
- if (atom == Xatom_TEXT)
+ if (atom == dpyinfo->Xatom_TEXT)
return QTEXT;
- if (atom == Xatom_DELETE)
+ if (atom == dpyinfo->Xatom_DELETE)
return QDELETE;
- if (atom == Xatom_MULTIPLE)
+ if (atom == dpyinfo->Xatom_MULTIPLE)
return QMULTIPLE;
- if (atom == Xatom_INCR)
+ if (atom == dpyinfo->Xatom_INCR)
return QINCR;
- if (atom == Xatom_EMACS_TMP)
+ if (atom == dpyinfo->Xatom_EMACS_TMP)
return QEMACS_TMP;
- if (atom == Xatom_TARGETS)
+ if (atom == dpyinfo->Xatom_TARGETS)
return QTARGETS;
- if (atom == Xatom_NULL)
+ if (atom == dpyinfo->Xatom_NULL)
return QNULL;
BLOCK_INPUT;
x_own_selection (selection_name, selection_value)
Lisp_Object selection_name, selection_value;
{
- Display *display = x_current_display;
-#ifdef X_TOOLKIT
- Window selecting_window = XtWindow (selected_screen->display.x->edit_widget);
-#else
Window selecting_window = FRAME_X_WINDOW (selected_frame);
-#endif
+ Display *display = FRAME_X_DISPLAY (selected_frame);
Time time = last_event_timestamp;
Atom selection_atom;
+ struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (selected_frame);
CHECK_SYMBOL (selection_name, 0);
- selection_atom = symbol_to_x_atom (display, selection_name);
+ selection_atom = symbol_to_x_atom (dpyinfo, display, selection_name);
BLOCK_INPUT;
+ x_catch_errors (display);
XSetSelectionOwner (display, selection_atom, selecting_window, time);
+ x_check_errors (display, "Can't set selection: %s");
+ x_uncatch_errors (display);
UNBLOCK_INPUT;
/* Now update the local cache */
selection_time = long_to_cons ((unsigned long) time);
selection_data = Fcons (selection_name,
Fcons (selection_value,
- Fcons (selection_time, Qnil)));
+ Fcons (selection_time,
+ Fcons (Fselected_frame (), Qnil))));
prev_value = assq_no_quit (selection_name, Vselection_alist);
Vselection_alist = Fcons (selection_data, Vselection_alist);
else if (CONSP (target_type)
&& XCONS (target_type)->car == QMULTIPLE)
{
- Lisp_Object pairs = XCONS (target_type)->cdr;
- int size = XVECTOR (pairs)->size;
+ Lisp_Object pairs;
+ int size;
int i;
+ pairs = XCONS (target_type)->cdr;
+ size = XVECTOR (pairs)->size;
/* If the target is MULTIPLE, then target_type looks like
(MULTIPLE . [[SELECTION1 TARGET1] [SELECTION2 TARGET2] ... ])
We modify the second element of each pair in the vector and
*/
for (i = 0; i < size; i++)
{
- Lisp_Object pair = XVECTOR (pairs)->contents [i];
+ Lisp_Object pair;
+ pair = XVECTOR (pairs)->contents [i];
XVECTOR (pair)->contents [1]
= x_get_local_selection (XVECTOR (pair)->contents [0],
XVECTOR (pair)->contents [1]);
reply.property = None;
BLOCK_INPUT;
- (void) XSendEvent (reply.display, reply.requestor, False, 0L,
- (XEvent *) &reply);
+ XSendEvent (reply.display, reply.requestor, False, 0L,
+ (XEvent *) &reply);
+ XFlush (reply.display);
UNBLOCK_INPUT;
}
return Qnil;
}
\f
+
+/* 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;
+ Display *display;
+ Window window;
+ Atom property;
+ int desired_state;
+ int arrived;
+ struct prop_location *next;
+};
+
+static struct prop_location *expect_property_change ();
+static void wait_for_property_change ();
+static void unexpect_property_change ();
+static int waiting_for_other_props_on_window ();
+
+static int prop_location_identifier;
+
+static Lisp_Object property_change_reply;
+
+static struct prop_location *property_change_reply_object;
+
+static struct prop_location *property_change_wait_list;
+
+static Lisp_Object
+queue_selection_requests_unwind (frame)
+ Lisp_Object frame;
+{
+ FRAME_PTR f = XFRAME (frame);
+
+ if (! NILP (frame))
+ x_stop_queuing_selection_requests (FRAME_X_DISPLAY (f));
+}
+
+/* Return some frame whose display info is DPYINFO.
+ Return nil if there is none. */
+
+static Lisp_Object
+some_frame_on_display (dpyinfo)
+ struct x_display_info *dpyinfo;
+{
+ Lisp_Object list, frame;
+
+ FOR_EACH_FRAME (list, frame)
+ {
+ if (FRAME_X_DISPLAY_INFO (XFRAME (frame)) == dpyinfo)
+ return frame;
+ }
+
+ return Qnil;
+}
+\f
/* Send the reply to a selection request event EVENT.
TYPE is the type of selection data requested.
DATA and SIZE describe the data to send, already converted.
int bytes_remaining;
int format_bytes = format/8;
int max_bytes = SELECTION_QUANTUM (display);
+ struct x_display_info *dpyinfo = x_display_info_for_display (display);
if (max_bytes > MAX_SELECTION_QUANTUM)
max_bytes = MAX_SELECTION_QUANTUM;
reply.property = reply.target;
/* #### XChangeProperty can generate BadAlloc, and we must handle it! */
+ BLOCK_INPUT;
+ x_catch_errors (display);
/* Store the data on the requested property.
If the selection is large, only store the first N bytes of it.
#if 0
fprintf (stderr,"\nStoring all %d\n", bytes_remaining);
#endif
- BLOCK_INPUT;
XChangeProperty (display, window, reply.property, type, format,
PropModeReplace, data, size);
/* At this point, the selection was successfully stored; ack it. */
XSendEvent (display, window, False, 0L, (XEvent *) &reply);
- XFlushQueue ();
- UNBLOCK_INPUT;
}
else
{
/* Send an INCR selection. */
- int prop_id;
+ struct prop_location *wait_object;
+ int had_errors;
+ int count = specpdl_ptr - specpdl;
+ Lisp_Object frame;
- BLOCK_INPUT;
+ frame = some_frame_on_display (dpyinfo);
+
+ /* If the display no longer has frames, we can't expect
+ to get many more selection requests from it, so don't
+ bother trying to queue them. */
+ if (!NILP (frame))
+ {
+ x_start_queuing_selection_requests (display);
+
+ record_unwind_protect (queue_selection_requests_unwind,
+ frame);
+ }
if (x_window_to_frame (window)) /* #### debug */
error ("attempt to transfer an INCR to ourself!");
#if 0
fprintf (stderr, "\nINCR %d\n", bytes_remaining);
#endif
- prop_id = expect_property_change (display, window, reply.property,
- PropertyDelete);
+ wait_object = expect_property_change (display, window, reply.property,
+ PropertyDelete);
- XChangeProperty (display, window, reply.property, Xatom_INCR,
- 32, PropModeReplace, (unsigned char *)
- &bytes_remaining, 1);
+ XChangeProperty (display, window, reply.property, dpyinfo->Xatom_INCR,
+ 32, PropModeReplace,
+ (unsigned char *) &bytes_remaining, 1);
XSelectInput (display, window, PropertyChangeMask);
/* Tell 'em the INCR data is there... */
- (void) XSendEvent (display, window, False, 0L, (XEvent *) &reply);
- XFlushQueue ();
+ XSendEvent (display, window, False, 0L, (XEvent *) &reply);
+ XFlush (display);
+
+ had_errors = x_had_errors_p (display);
UNBLOCK_INPUT;
/* First, wait for the requestor to ack by deleting the property.
This can run random lisp code (process handlers) or signal. */
- wait_for_property_change (prop_id);
+ if (! had_errors)
+ wait_for_property_change (wait_object);
while (bytes_remaining)
{
BLOCK_INPUT;
- prop_id = expect_property_change (display, window, reply.property,
- PropertyDelete);
+ wait_object
+ = expect_property_change (display, window, reply.property,
+ PropertyDelete);
#if 0
fprintf (stderr," INCR adding %d\n", i);
#endif
PropModeAppend, data, i / format_bytes);
bytes_remaining -= i;
data += i;
- XFlushQueue ();
+ XFlush (display);
+ had_errors = x_had_errors_p (display);
UNBLOCK_INPUT;
+ if (had_errors)
+ break;
+
/* Now wait for the requestor to ack this chunk by deleting the
property. This can run random lisp code or signal.
*/
- wait_for_property_change (prop_id);
+ wait_for_property_change (wait_object);
}
/* Now write a zero-length chunk to the property to tell the requestor
that we're done. */
XChangeProperty (display, window, reply.property, type, format,
PropModeReplace, data, 0);
- XFlushQueue ();
- UNBLOCK_INPUT;
+
+ unbind_to (count, Qnil);
}
+
+ XFlush (display);
+ x_uncatch_errors (display);
+ UNBLOCK_INPUT;
}
\f
/* Handle a SelectionRequest event EVENT.
struct input_event *event;
{
struct gcpro gcpro1, gcpro2, gcpro3;
- Lisp_Object local_selection_data = Qnil;
+ Lisp_Object local_selection_data;
Lisp_Object selection_symbol;
- Lisp_Object target_symbol = Qnil;
- Lisp_Object converted_selection = Qnil;
+ Lisp_Object target_symbol;
+ Lisp_Object converted_selection;
Time local_selection_time;
- Lisp_Object successful_p = Qnil;
+ Lisp_Object successful_p;
int count;
+ struct x_display_info *dpyinfo
+ = x_display_info_for_display (SELECTION_EVENT_DISPLAY (event));
+
+ local_selection_data = Qnil;
+ target_symbol = Qnil;
+ converted_selection = Qnil;
+ successful_p = Qnil;
GCPRO3 (local_selection_data, converted_selection, target_symbol);
- selection_symbol = x_atom_to_symbol (SELECTION_EVENT_DISPLAY (event),
+ selection_symbol = x_atom_to_symbol (dpyinfo,
+ SELECTION_EVENT_DISPLAY (event),
SELECTION_EVENT_SELECTION (event));
local_selection_data = assq_no_quit (selection_symbol, Vselection_alist);
x_selection_current_request = event;
record_unwind_protect (x_selection_request_lisp_error, Qnil);
- target_symbol = x_atom_to_symbol (SELECTION_EVENT_DISPLAY (event),
+ target_symbol = x_atom_to_symbol (dpyinfo, SELECTION_EVENT_DISPLAY (event),
SELECTION_EVENT_TARGET (event));
#if 0 /* #### MULTIPLE doesn't work yet */
/* Let random lisp code notice that the selection has been asked for. */
{
- Lisp_Object rest = Vx_sent_selection_hooks;
+ Lisp_Object rest;
+ rest = Vx_sent_selection_hooks;
if (!EQ (rest, Qunbound))
for (; CONSP (rest); rest = Fcdr (rest))
call3 (Fcar (rest), selection_symbol, target_symbol, successful_p);
Lisp_Object selection_symbol, local_selection_data;
Time local_selection_time;
+ struct x_display_info *dpyinfo = x_display_info_for_display (display);
- selection_symbol = x_atom_to_symbol (display, selection);
+ selection_symbol = x_atom_to_symbol (dpyinfo, display, selection);
local_selection_data = assq_no_quit (selection_symbol, Vselection_alist);
/* Let random lisp code notice that the selection has been stolen. */
{
- Lisp_Object rest = Vx_lost_selection_hooks;
+ Lisp_Object rest;
+ rest = Vx_lost_selection_hooks;
if (!EQ (rest, Qunbound))
- for (; CONSP (rest); rest = Fcdr (rest))
- call1 (Fcar (rest), selection_symbol);
+ {
+ for (; CONSP (rest); rest = Fcdr (rest))
+ call1 (Fcar (rest), selection_symbol);
+ prepare_menu_bars ();
+ redisplay_preserve_echo_area ();
+ }
}
}
-\f
-/* 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. */
+/* Clear all selections that were made from frame F.
+ We do this when about to delete a frame. */
-static int prop_location_identifier;
+void
+x_clear_frame_selections (f)
+ FRAME_PTR f;
+{
+ Lisp_Object frame;
+ Lisp_Object rest;
-static Lisp_Object property_change_reply;
-static int property_change_reply_identifier;
+ XSETFRAME (frame, f);
-/* Keep a list of the property changes that are awaited. */
+ /* Otherwise, we're really honest and truly being told to drop it.
+ Don't use Fdelq as that may QUIT;. */
-struct prop_location
-{
- int identifier;
- Display *display;
- Window window;
- Atom property;
- int desired_state;
- struct prop_location *next;
-};
+ while (!NILP (Vselection_alist)
+ && EQ (frame, Fcar (Fcdr (Fcdr (Fcdr (Fcar (Vselection_alist)))))))
+ {
+ /* Let random Lisp code notice that the selection has been stolen. */
+ Lisp_Object hooks, selection_symbol;
-static struct prop_location *property_change_wait_list;
+ hooks = Vx_lost_selection_hooks;
+ selection_symbol = Fcar (Vselection_alist);
-static int
-property_deleted_p (identifier)
- void *identifier;
-{
- struct prop_location *rest = property_change_wait_list;
- while (rest)
- if (rest->identifier == (int) identifier)
- return 0;
- else
- rest = rest->next;
- return 1;
-}
+ if (!EQ (hooks, Qunbound))
+ {
+ for (; CONSP (hooks); hooks = Fcdr (hooks))
+ call1 (Fcar (hooks), selection_symbol);
+ redisplay_preserve_echo_area ();
+ }
+
+ Vselection_alist = Fcdr (Vselection_alist);
+ }
+
+ for (rest = Vselection_alist; !NILP (rest); rest = Fcdr (rest))
+ if (EQ (frame, Fcar (Fcdr (Fcdr (Fcdr (Fcar (XCONS (rest)->cdr)))))))
+ {
+ /* Let random Lisp code notice that the selection has been stolen. */
+ Lisp_Object hooks, selection_symbol;
+
+ hooks = Vx_lost_selection_hooks;
+ selection_symbol = Fcar (XCONS (rest)->cdr);
+ if (!EQ (hooks, Qunbound))
+ {
+ for (; CONSP (hooks); hooks = Fcdr (hooks))
+ call1 (Fcar (hooks), selection_symbol);
+ redisplay_preserve_echo_area ();
+ }
+ XCONS (rest)->cdr = Fcdr (XCONS (rest)->cdr);
+ break;
+ }
+}
+\f
/* Nonzero if any properties for DISPLAY and WINDOW
are on the list of what we are waiting for. */
The return value is a number that uniquely identifies
this awaited property change. */
-static int
+static struct prop_location *
expect_property_change (display, window, property, state)
Display *display;
Window window;
pl->property = property;
pl->desired_state = state;
pl->next = property_change_wait_list;
+ pl->arrived = 0;
property_change_wait_list = pl;
- return pl->identifier;
+ return pl;
}
/* 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 (identifier)
- int identifier;
+unexpect_property_change (location)
+ struct prop_location *location;
{
struct prop_location *prev = 0, *rest = property_change_wait_list;
while (rest)
{
- if (rest->identifier == identifier)
+ if (rest == location)
{
if (prev)
prev->next = rest->next;
wait_for_property_change_unwind (identifierval)
Lisp_Object identifierval;
{
- unexpect_property_change (XFASTINT (identifierval));
+ unexpect_property_change ((struct prop_location *)
+ (XFASTINT (XCONS (identifierval)->car) << 16
+ | XFASTINT (XCONS (identifierval)->cdr)));
}
/* Actually wait for a property change.
IDENTIFIER should be the value that expect_property_change returned. */
static void
-wait_for_property_change (identifier)
+wait_for_property_change (location)
+ struct prop_location *location;
{
int secs, usecs;
int count = specpdl_ptr - specpdl;
+ Lisp_Object tem;
+
+ tem = Fcons (Qnil, Qnil);
+ XSETFASTINT (XCONS (tem)->car, (EMACS_UINT)location >> 16);
+ XSETFASTINT (XCONS (tem)->cdr, (EMACS_UINT)location & 0xffff);
/* Make sure to do unexpect_property_change if we quit or err. */
- record_unwind_protect (wait_for_property_change_unwind,
- make_number (identifier));
+ record_unwind_protect (wait_for_property_change_unwind, tem);
XCONS (property_change_reply)->car = Qnil;
- property_change_reply_identifier = identifier;
- secs = x_selection_timeout / 1000;
- usecs = (x_selection_timeout % 1000) * 1000;
- wait_reading_process_input (secs, usecs, property_change_reply, 0);
- if (NILP (XCONS (property_change_reply)->car))
- error ("timed out waiting for property-notify event");
+ property_change_reply_object = location;
+ /* 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)
+ {
+ secs = x_selection_timeout / 1000;
+ usecs = (x_selection_timeout % 1000) * 1000;
+ wait_reading_process_input (secs, usecs, property_change_reply, 0);
+
+ if (NILP (XCONS (property_change_reply)->car))
+ error ("timed out waiting for property-notify event");
+ }
unbind_to (count, Qnil);
}
#if 0
fprintf (stderr, "Saw expected prop-%s on %s\n",
(event->state == PropertyDelete ? "delete" : "change"),
- (char *) XSYMBOL (x_atom_to_symbol (event->display,
+ (char *) XSYMBOL (x_atom_to_symbol (dpyinfo, event->display,
event->atom))
->name->data);
#endif
+ rest->arrived = 1;
+
/* If this is the one wait_for_property_change is waiting for,
tell it to wake up. */
- if (rest->identifier == property_change_reply_identifier)
+ if (rest == property_change_reply_object)
XCONS (property_change_reply)->car = Qt;
if (prev)
#if 0
fprintf (stderr, "Saw UNexpected prop-%s on %s\n",
(event->state == PropertyDelete ? "delete" : "change"),
- (char *) XSYMBOL (x_atom_to_symbol (event->display, event->atom))
+ (char *) XSYMBOL (x_atom_to_symbol (dpyinfo,
+ event->display, event->atom))
->name->data);
#endif
}
x_get_foreign_selection (selection_symbol, target_type)
Lisp_Object selection_symbol, target_type;
{
- Display *display = x_current_display;
-#ifdef X_TOOLKIT
- Window requestor_window = XtWindow (selected_screen->display.x->edit_widget);
-#else
Window requestor_window = FRAME_X_WINDOW (selected_frame);
-#endif
+ Display *display = FRAME_X_DISPLAY (selected_frame);
+ struct x_display_info *dpyinfo = FRAME_X_DISPLAY_INFO (selected_frame);
Time requestor_time = last_event_timestamp;
- Atom target_property = Xatom_EMACS_TMP;
- Atom selection_atom = symbol_to_x_atom (display, selection_symbol);
+ Atom target_property = dpyinfo->Xatom_EMACS_TMP;
+ Atom selection_atom = symbol_to_x_atom (dpyinfo, display, selection_symbol);
Atom type_atom;
int secs, usecs;
+ int count = specpdl_ptr - specpdl;
+ Lisp_Object frame;
if (CONSP (target_type))
- type_atom = symbol_to_x_atom (display, XCONS (target_type)->car);
+ type_atom = symbol_to_x_atom (dpyinfo, display, XCONS (target_type)->car);
else
- type_atom = symbol_to_x_atom (display, target_type);
+ type_atom = symbol_to_x_atom (dpyinfo, display, target_type);
BLOCK_INPUT;
+ x_catch_errors (display);
XConvertSelection (display, selection_atom, type_atom, target_property,
requestor_window, requestor_time);
- XFlushQueue ();
+ XFlush (display);
/* Prepare to block until the reply has been read. */
reading_selection_window = requestor_window;
reading_which_selection = selection_atom;
XCONS (reading_selection_reply)->car = Qnil;
+
+ frame = some_frame_on_display (dpyinfo);
+
+ /* If the display no longer has frames, we can't expect
+ to get many more selection requests from it, so don't
+ bother trying to queue them. */
+ if (!NILP (frame))
+ {
+ x_start_queuing_selection_requests (display);
+
+ record_unwind_protect (queue_selection_requests_unwind,
+ frame);
+ }
UNBLOCK_INPUT;
/* This allows quits. Also, don't wait forever. */
usecs = (x_selection_timeout % 1000) * 1000;
wait_reading_process_input (secs, usecs, reading_selection_reply, 0);
+ BLOCK_INPUT;
+ x_check_errors (display, "Cannot get selection: %s");
+ x_uncatch_errors (display);
+ unbind_to (count, Qnil);
+ UNBLOCK_INPUT;
+
if (NILP (XCONS (reading_selection_reply)->car))
error ("timed out waiting for reply from selection owner");
xfree ((char *) tmp_data);
}
- XFlushQueue ();
+ XFlush (display);
UNBLOCK_INPUT;
*bytes_ret = offset;
}
int *format_ret;
{
int offset = 0;
- int prop_id;
+ struct prop_location *wait_object;
*size_bytes_ret = min_size_bytes;
*data_ret = (unsigned char *) xmalloc (*size_bytes_ret);
#if 0
BLOCK_INPUT;
XSelectInput (display, window, STANDARD_EVENT_SET | PropertyChangeMask);
XDeleteProperty (display, window, property);
- prop_id = expect_property_change (display, window, property,
- PropertyNewValue);
- XFlushQueue ();
+ wait_object = expect_property_change (display, window, property,
+ PropertyNewValue);
+ XFlush (display);
UNBLOCK_INPUT;
while (1)
{
unsigned char *tmp_data;
int tmp_size_bytes;
- wait_for_property_change (prop_id);
+ wait_for_property_change (wait_object);
/* expect it again immediately, because x_get_window_property may
.. no it wont, I dont get it.
.. Ok, I get it now, the Xt code that implements INCR is broken.
#endif
if (! waiting_for_other_props_on_window (display, window))
XSelectInput (display, window, STANDARD_EVENT_SET);
- unexpect_property_change (prop_id);
+ unexpect_property_change (wait_object);
if (tmp_data) xfree (tmp_data);
break;
}
BLOCK_INPUT;
XDeleteProperty (display, window, property);
- prop_id = expect_property_change (display, window, property,
- PropertyNewValue);
- XFlushQueue ();
+ wait_object = expect_property_change (display, window, property,
+ PropertyNewValue);
+ XFlush (display);
UNBLOCK_INPUT;
#if 0
*size_bytes_ret = offset + tmp_size_bytes;
*data_ret = (unsigned char *) xrealloc (*data_ret, *size_bytes_ret);
}
- memcpy ((*data_ret) + offset, tmp_data, tmp_size_bytes);
+ bcopy (tmp_data, (*data_ret) + offset, tmp_size_bytes);
offset += tmp_size_bytes;
xfree (tmp_data);
}
unsigned char *data = 0;
int bytes = 0;
Lisp_Object val;
+ struct x_display_info *dpyinfo = x_display_info_for_display (display);
x_get_window_property (display, window, property, &data, &bytes,
&actual_type, &actual_format, &actual_size, 1);
Fcons (build_string ("selection owner couldn't convert"),
actual_type
? Fcons (target_type,
- Fcons (x_atom_to_symbol (display, actual_type),
+ Fcons (x_atom_to_symbol (dpyinfo, display,
+ actual_type),
Qnil))
: Fcons (target_type, Qnil))
: Fcons (build_string ("no selection"),
- Fcons (x_atom_to_symbol (display, selection_atom),
+ Fcons (x_atom_to_symbol (dpyinfo, display,
+ selection_atom),
Qnil)));
}
- if (actual_type == Xatom_INCR)
+ if (actual_type == dpyinfo->Xatom_INCR)
{
/* That wasn't really the data, just the beginning. */
BLOCK_INPUT;
XDeleteProperty (display, window, property);
- XFlushQueue ();
+ XFlush (display);
UNBLOCK_INPUT;
/* It's been read. Now convert it to a lisp object in some semi-rational
Atom type;
int size, format;
{
+ struct x_display_info *dpyinfo = x_display_info_for_display (display);
- if (type == Xatom_NULL)
+ if (type == dpyinfo->Xatom_NULL)
return QNULL;
/* Convert any 8-bit data to a string, for compactness. */
{
int i;
if (size == sizeof (Atom))
- return x_atom_to_symbol (display, *((Atom *) data));
+ return x_atom_to_symbol (dpyinfo, display, *((Atom *) data));
else
{
Lisp_Object v = Fmake_vector (size / sizeof (Atom), 0);
for (i = 0; i < size / sizeof (Atom); i++)
- Faset (v, i, x_atom_to_symbol (display, ((Atom *) data) [i]));
+ Faset (v, i, x_atom_to_symbol (dpyinfo, display,
+ ((Atom *) data) [i]));
return v;
}
}
int *nofree_ret;
{
Lisp_Object type = Qnil;
+ struct x_display_info *dpyinfo = x_display_info_for_display (display);
*nofree_ret = 0;
*size_ret = 1;
*data_ret = (unsigned char *) xmalloc (sizeof (Atom) + 1);
(*data_ret) [sizeof (Atom)] = 0;
- (*(Atom **) data_ret) [0] = symbol_to_x_atom (display, obj);
+ (*(Atom **) data_ret) [0] = symbol_to_x_atom (dpyinfo, display, obj);
if (NILP (type)) type = QATOM;
}
else if (INTEGERP (obj)
for (i = 0; i < *size_ret; i++)
if (SYMBOLP (XVECTOR (obj)->contents [i]))
(*(Atom **) data_ret) [i]
- = symbol_to_x_atom (display, XVECTOR (obj)->contents [i]);
+ = symbol_to_x_atom (dpyinfo, display, XVECTOR (obj)->contents [i]);
else
Fsignal (Qerror, /* Qselection_error */
Fcons (build_string
Fcons (pair, Qnil)));
(*(Atom **) data_ret) [i * 2]
- = symbol_to_x_atom (display, XVECTOR (pair)->contents [0]);
+ = symbol_to_x_atom (dpyinfo, display,
+ XVECTOR (pair)->contents [0]);
(*(Atom **) data_ret) [(i * 2) + 1]
- = symbol_to_x_atom (display, XVECTOR (pair)->contents [1]);
+ = symbol_to_x_atom (dpyinfo, display,
+ XVECTOR (pair)->contents [1]);
}
else
Fsignal (Qerror,
Fcons (build_string ("unrecognised selection data"),
Fcons (obj, Qnil)));
- *type_ret = symbol_to_x_atom (display, type);
+ *type_ret = symbol_to_x_atom (dpyinfo, display, type);
}
static Lisp_Object
(selection_name, selection_value)
Lisp_Object selection_name, selection_value;
{
+ check_x ();
CHECK_SYMBOL (selection_name, 0);
if (NILP (selection_value)) error ("selection-value may not be nil.");
x_own_selection (selection_name, selection_value);
Lisp_Object val = Qnil;
struct gcpro gcpro1, gcpro2;
GCPRO2 (target_type, val); /* we store newly consed data into these */
+ check_x ();
CHECK_SYMBOL (selection_symbol, 0);
#if 0 /* #### MULTIPLE doesn't work yet */
Lisp_Object selection;
Lisp_Object time;
{
- Display *display = x_current_display;
Time timestamp;
Atom selection_atom;
XSelectionClearEvent event;
+ Display *display;
+ struct x_display_info *dpyinfo;
+ check_x ();
+ display = FRAME_X_DISPLAY (selected_frame);
+ dpyinfo = FRAME_X_DISPLAY_INFO (selected_frame);
CHECK_SYMBOL (selection, 0);
if (NILP (time))
timestamp = last_event_timestamp;
if (NILP (assq_no_quit (selection, Vselection_alist)))
return Qnil; /* Don't disown the selection when we're not the owner. */
- selection_atom = symbol_to_x_atom (display, selection);
+ selection_atom = symbol_to_x_atom (dpyinfo, display, selection);
BLOCK_INPUT;
XSetSelectionOwner (display, selection_atom, None, timestamp);
the selection owner to None. The NCD server does, the MIT Sun4 server
doesn't. So we synthesize one; this means we might get two, but
that's ok, because the second one won't have any effect. */
- event.display = display;
- event.selection = selection_atom;
- event.time = timestamp;
+ SELECTION_EVENT_DISPLAY (&event) = display;
+ SELECTION_EVENT_SELECTION (&event) = selection_atom;
+ SELECTION_EVENT_TIME (&event) = timestamp;
x_handle_selection_clear (&event);
return Qt;
(selection)
Lisp_Object selection;
{
+ check_x ();
CHECK_SYMBOL (selection, 0);
if (EQ (selection, Qnil)) selection = QPRIMARY;
if (EQ (selection, Qt)) selection = QSECONDARY;
{
Window owner;
Atom atom;
- Display *dpy = x_current_display;
+ Display *dpy;
+
+ /* It should be safe to call this before we have an X frame. */
+ if (! FRAME_X_P (selected_frame))
+ return Qnil;
+
+ dpy = FRAME_X_DISPLAY (selected_frame);
CHECK_SYMBOL (selection, 0);
if (!NILP (Fx_selection_owner_p (selection)))
return Qt;
if (EQ (selection, Qnil)) selection = QPRIMARY;
if (EQ (selection, Qt)) selection = QSECONDARY;
- atom = symbol_to_x_atom (dpy, selection);
+ atom = symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame),
+ dpy, selection);
if (atom == 0)
return Qnil;
BLOCK_INPUT;
(buffer)
Lisp_Object buffer;
{
- Display *display = x_current_display;
- Window window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
+ Window window;
Atom buffer_atom;
unsigned char *data;
int bytes;
int format;
unsigned long size;
Lisp_Object ret;
+ Display *display;
+ struct x_display_info *dpyinfo;
+ check_x ();
+ display = FRAME_X_DISPLAY (selected_frame);
+ dpyinfo = FRAME_X_DISPLAY_INFO (selected_frame);
+ window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
CHECK_CUT_BUFFER (buffer, 0);
- buffer_atom = symbol_to_x_atom (display, buffer);
+ buffer_atom = symbol_to_x_atom (dpyinfo, display, buffer);
x_get_window_property (display, window, buffer_atom, &data, &bytes,
&type, &format, &size, 0);
if (format != 8 || type != XA_STRING)
Fsignal (Qerror,
Fcons (build_string ("cut buffer doesn't contain 8-bit data"),
- Fcons (x_atom_to_symbol (display, type),
+ Fcons (x_atom_to_symbol (dpyinfo, display, type),
Fcons (make_number (format), Qnil))));
ret = (bytes ? make_string ((char *) data, bytes) : Qnil);
(buffer, string)
Lisp_Object buffer, string;
{
- Display *display = x_current_display;
- Window window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
+ Window window;
Atom buffer_atom;
unsigned char *data;
int bytes;
int bytes_remaining;
- int max_bytes = SELECTION_QUANTUM (display);
- if (max_bytes > MAX_SELECTION_QUANTUM) max_bytes = MAX_SELECTION_QUANTUM;
+ int max_bytes;
+ Display *display;
+
+ check_x ();
+ display = FRAME_X_DISPLAY (selected_frame);
+ window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
+
+ max_bytes = SELECTION_QUANTUM (display);
+ if (max_bytes > MAX_SELECTION_QUANTUM)
+ max_bytes = MAX_SELECTION_QUANTUM;
CHECK_CUT_BUFFER (buffer, 0);
CHECK_STRING (string, 0);
- buffer_atom = symbol_to_x_atom (display, buffer);
+ buffer_atom = symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame),
+ display, buffer);
data = (unsigned char *) XSTRING (string)->data;
bytes = XSTRING (string)->size;
bytes_remaining = bytes;
(n)
Lisp_Object n;
{
- Display *display = x_current_display;
- Window window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
- Atom props [8];
+ Window window;
+ Atom props[8];
+ Display *display;
+ check_x ();
+ display = FRAME_X_DISPLAY (selected_frame);
+ window = RootWindow (display, 0); /* Cut buffers are on screen 0 */
CHECK_NUMBER (n, 0);
- if (XINT (n) == 0) return n;
- if (! cut_buffers_initialized) initialize_cut_buffers (display, window);
+ if (XINT (n) == 0)
+ return n;
+ if (! cut_buffers_initialized)
+ initialize_cut_buffers (display, window);
+
props[0] = XA_CUT_BUFFER0;
props[1] = XA_CUT_BUFFER1;
props[2] = XA_CUT_BUFFER2;
#endif
\f
-void
-Xatoms_of_xselect ()
-{
-#define ATOM(x) XInternAtom (x_current_display, (x), False)
-
- BLOCK_INPUT;
- /* Non-predefined atoms that we might end up using a lot */
- Xatom_CLIPBOARD = ATOM ("CLIPBOARD");
- Xatom_TIMESTAMP = ATOM ("TIMESTAMP");
- Xatom_TEXT = ATOM ("TEXT");
- Xatom_DELETE = ATOM ("DELETE");
- Xatom_MULTIPLE = ATOM ("MULTIPLE");
- Xatom_INCR = ATOM ("INCR");
- Xatom_EMACS_TMP = ATOM ("_EMACS_TMP_");
- Xatom_TARGETS = ATOM ("TARGETS");
- Xatom_NULL = ATOM ("NULL");
- Xatom_ATOM_PAIR = ATOM ("ATOM_PAIR");
- UNBLOCK_INPUT;
-}
-
void
syms_of_xselect ()
{