-/* x_handle_selection_notify
-x_reply_selection_request
-XFree
-x_selection_timeout initial value */
-
-/* X Selection processing for emacs
- Copyright (C) 1990-1993 Free Software Foundation.
+/* X Selection processing for Emacs.
+ Copyright (C) 1993, 1994, 1995, 1996, 1997 Free Software Foundation.
This file is part of GNU Emacs.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
+
/* 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 xfree free
+#include "blockinput.h"
+#include "buffer.h"
+#include "charset.h"
+#include "coding.h"
#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;
+Lisp_Object QCOMPOUND_TEXT; /* This is a type of selection. */
+
#ifdef CUT_BUFFER_SUPPORT
Lisp_Object QCUT_BUFFER0, QCUT_BUFFER1, QCUT_BUFFER2, QCUT_BUFFER3,
QCUT_BUFFER4, QCUT_BUFFER5, QCUT_BUFFER6, QCUT_BUFFER7;
#endif
-Lisp_Object Vx_lost_selection_hooks;
-Lisp_Object Vx_sent_selection_hooks;
+static Lisp_Object Vx_lost_selection_hooks;
+static Lisp_Object Vx_sent_selection_hooks;
+/* Coding system for communicating with other X clients via cutbuffer,
+ selection, and clipboard. */
+static Lisp_Object Vclipboard_coding_system;
/* If this is a smaller number than the max-request-size of the display,
emacs will use INCR selection transfer when the selection is larger
than this. The max-request-size is usually around 64k, so if you want
emacs to use incremental selection transfers when the selection is
smaller than that, set this. I added this mostly for debugging the
- incremental transfer stuff, but it might improve server performance.
- */
+ incremental transfer stuff, but it might improve server performance. */
#define MAX_SELECTION_QUANTUM 0xFFFFFF
#ifdef HAVE_X11R4
#endif
/* The timestamp of the last input event Emacs received from the X server. */
-unsigned long last_event_timestamp;
+/* Defined in keyboard.c. */
+extern 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.
- */
-Lisp_Object Vselection_alist;
+ selection-values. */
+static Lisp_Object Vselection_alist;
/* This is an alist whose CARs are selection-types (whose names are the same
as the names of X Atoms) and whose CDRs are the names of Lisp functions to
call to convert the given Emacs selection value to a string representing
the given selection type. This is for Lisp-level extension of the emacs
- selection handling.
- */
-Lisp_Object Vselection_converter_alist;
+ selection handling. */
+static Lisp_Object Vselection_converter_alist;
/* If the selection owner takes too long to reply to a selection request,
- we give up on it. This is in seconds (0 = no timeout.)
- */
-int x_selection_timeout;
-
+ we give up on it. This is in milliseconds (0 = no timeout.) */
+static 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, QCOMPOUND_TEXT)) return dpyinfo->Xatom_COMPOUND_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_COMPOUND_TEXT)
+ return QCOMPOUND_TEXT;
+ 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;
if (! str) return Qnil;
val = intern (str);
BLOCK_INPUT;
+ /* This was allocated by Xlib, so use XFree. */
XFree (str);
UNBLOCK_INPUT;
return val;
}
\f
-/* Convert between full word time values (last modification times, etc)
- and their Lisp representation as a cons cell (HIGH . LOW). */
-
-Lisp_Object
-long_to_cons (i)
- unsigned long i;
-{
- unsigned int top = i >> 16;
- unsigned int bot = i & 0xFFFF;
- if (top == 0)
- return make_number (bot);
- if (top == 0xFFFF)
- return Fcons (make_number (-1), make_number (bot));
- return Fcons (make_number (top), make_number (bot));
-}
-
-unsigned long
-cons_to_long (c)
- Lisp_Object c;
-{
- int top, bot;
- if (INTEGERP (c))
- return XINT (c);
- top = XCONS (c)->car;
- bot = XCONS (c)->cdr;
- if (CONSP (bot))
- bot = XCONS (bot)->car;
- return ((XINT (top) << 16) | XINT (bot));
-}
-\f
/* Do protocol to assert ourself as a selection owner.
Update the Vselection_alist so that we can reply to later requests for
our selection. */
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);
+ int count;
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;
+ count = x_catch_errors (display);
XSetSelectionOwner (display, selection_atom, selecting_window, time);
+ x_check_errors (display, "Can't set selection: %s");
+ x_uncatch_errors (display, count);
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]);
CHECK_SYMBOL (target_type, 0);
handler_fn = Fcdr (Fassq (target_type, Vselection_converter_alist));
- if (NILP (handler_fn))
- Fsignal (Qerror,
- Fcons (build_string ("missing selection-conversion function"),
- Fcons (target_type, Fcons (value, Qnil))));
- value = call3 (handler_fn,
- selection_symbol, target_type,
- XCONS (XCONS (local_value)->cdr)->car);
+ if (!NILP (handler_fn))
+ value = call3 (handler_fn,
+ selection_symbol, target_type,
+ XCONS (XCONS (local_value)->cdr)->car);
+ else
+ value = Qnil;
unbind_to (count, Qnil);
}
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;
}
static struct input_event *x_selection_current_request;
/* 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
+ an error, we tell the requester that we were unable to do what they wanted
before we throw to top-level or go into the debugger or whatever. */
static Lisp_Object
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 Qnil;
+}
+
+/* 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);
+ int count;
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;
+ count = x_catch_errors (display);
+
/* Store the data on the requested property.
If the selection is large, only store the first N bytes of it.
*/
XChangeProperty (display, window, reply.property, type, format,
PropModeReplace, data, size);
/* At this point, the selection was successfully stored; ack it. */
- (void) XSendEvent (display, window, False, 0L, (XEvent *) &reply);
+ XSendEvent (display, window, False, 0L, (XEvent *) &reply);
}
else
{
/* Send an INCR selection. */
- int prop_id;
+ struct prop_location *wait_object;
+ int had_errors;
+ Lisp_Object frame;
+
+ 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);
- if (x_window_to_frame (window)) /* #### debug */
- error ("attempt to transfer an INCR to ourself!");
+ record_unwind_protect (queue_selection_requests_unwind,
+ frame);
+ }
+
+ if (x_window_to_frame (dpyinfo, 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);
+ 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.
+ /* First, wait for the requester 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)
{
int i = ((bytes_remaining < max_bytes)
? bytes_remaining
: max_bytes);
- prop_id = expect_property_change (display, window, reply.property,
- PropertyDelete);
+
+ BLOCK_INPUT;
+
+ 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;
+ XFlush (display);
+ had_errors = x_had_errors_p (display);
+ UNBLOCK_INPUT;
- /* Now wait for the requestor to ack this chunk by deleting the
+ if (had_errors)
+ break;
+
+ /* Now wait for the requester 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
+ /* Now write a zero-length chunk to the property to tell the requester
that we're done. */
#if 0
fprintf (stderr," INCR done\n");
#endif
+ BLOCK_INPUT;
if (! waiting_for_other_props_on_window (display, window))
XSelectInput (display, window, 0L);
XChangeProperty (display, window, reply.property, type, format,
PropModeReplace, data, 0);
}
+
+ XFlush (display);
+ x_uncatch_errors (display, count);
UNBLOCK_INPUT;
}
\f
struct input_event *event;
{
struct gcpro gcpro1, gcpro2, gcpro3;
- XSelectionEvent reply;
- 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));
- GCPRO3 (local_selection_data, converted_selection, target_symbol);
+ local_selection_data = Qnil;
+ target_symbol = Qnil;
+ converted_selection = Qnil;
+ successful_p = Qnil;
- reply.type = SelectionNotify; /* Construct the reply event */
- reply.display = SELECTION_EVENT_DISPLAY (event);
- reply.requestor = SELECTION_EVENT_REQUESTOR (event);
- reply.selection = SELECTION_EVENT_SELECTION (event);
- reply.time = SELECTION_EVENT_TIME (event);
- reply.target = SELECTION_EVENT_TARGET (event);
- reply.property = SELECTION_EVENT_PROPERTY (event);
- if (reply.property == None)
- reply.property = reply.target;
+ GCPRO3 (local_selection_data, converted_selection, target_symbol);
- selection_symbol = x_atom_to_symbol (reply.display,
+ 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);
-
-#if 0
-# define CDR(x) (XCONS (x)->cdr)
-# define CAR(x) (XCONS (x)->car)
- /* This list isn't user-visible, so it can't "go bad." */
- if (!CONSP (local_selection_data)) abort ();
- if (!CONSP (CDR (local_selection_data))) abort ();
- if (!CONSP (CDR (CDR (local_selection_data)))) abort ();
- if (!NILP (CDR (CDR (CDR (local_selection_data))))) abort ();
- if (!CONSP (CAR (CDR (CDR (local_selection_data))))) abort ();
- if (!INTEGERP (CAR (CAR (CDR (CDR (local_selection_data)))))) abort ();
- if (!INTEGERP (CDR (CAR (CDR (CDR (local_selection_data)))))) abort ();
-# undef CAR
-# undef CDR
-#endif
if (NILP (local_selection_data))
{
x_selection_current_request = event;
record_unwind_protect (x_selection_request_lisp_error, Qnil);
- target_symbol = x_atom_to_symbol (reply.display,
+ target_symbol = x_atom_to_symbol (dpyinfo, SELECTION_EVENT_DISPLAY (event),
SELECTION_EVENT_TARGET (event));
#if 0 /* #### MULTIPLE doesn't work yet */
unsigned int size;
int format;
Atom type;
- lisp_data_to_selection_data (reply.display, converted_selection,
- &data, &type, &size, &format);
+ int nofree;
+
+ lisp_data_to_selection_data (SELECTION_EVENT_DISPLAY (event),
+ converted_selection,
+ &data, &type, &size, &format, &nofree);
x_reply_selection_request (event, format, data, size, type);
successful_p = Qt;
/* Indicate we have successfully processed this event. */
x_selection_current_request = 0;
- xfree (data);
+ /* Use xfree, not XFree, because lisp_data_to_selection_data
+ calls xmalloc itself. */
+ if (!nofree)
+ xfree (data);
}
unbind_to (count, Qnil);
/* 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_tick;
+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_tick;
+ 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 tick;
- Display *display;
- Window window;
- Atom property;
- int desired_state;
- struct prop_location *next;
-};
+ /* Delete elements from the beginning of Vselection_alist. */
+ 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 (Fcar (Vselection_alist));
-static int
-property_deleted_p (tick)
- void *tick;
-{
- struct prop_location *rest = property_change_wait_list;
- while (rest)
- if (rest->tick == (int) tick)
- return 0;
- else
- rest = rest->next;
- return 1;
-}
+ if (!EQ (hooks, Qunbound))
+ {
+ for (; CONSP (hooks); hooks = Fcdr (hooks))
+ call1 (Fcar (hooks), selection_symbol);
+#if 0 /* This can crash when deleting a frame
+ from x_connection_closed. Anyway, it seems unnecessary;
+ something else should cause a redisplay. */
+ redisplay_preserve_echo_area ();
+#endif
+ }
+
+ Vselection_alist = Fcdr (Vselection_alist);
+ }
+
+ /* Delete elements after the beginning of 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 (Fcar (XCONS (rest)->cdr));
+ if (!EQ (hooks, Qunbound))
+ {
+ for (; CONSP (hooks); hooks = Fcdr (hooks))
+ call1 (Fcar (hooks), selection_symbol);
+#if 0 /* See above */
+ redisplay_preserve_echo_area ();
+#endif
+ }
+ 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;
- Lisp_Object property;
+ Atom property;
int state;
{
struct prop_location *pl
= (struct prop_location *) xmalloc (sizeof (struct prop_location));
- pl->tick = ++prop_location_tick;
+ 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 = 0;
property_change_wait_list = pl;
- return pl->tick;
+ return pl;
}
/* Delete an entry from the list of property changes we are waiting for.
- TICK is the number that uniquely identifies the entry. */
+ IDENTIFIER is the number that uniquely identifies the entry. */
static void
-unexpect_property_change (tick)
- int tick;
+unexpect_property_change (location)
+ struct prop_location *location;
{
struct prop_location *prev = 0, *rest = property_change_wait_list;
while (rest)
{
- if (rest->tick == tick)
+ if (rest == location)
{
if (prev)
prev->next = rest->next;
}
}
+/* Remove the property change expectation element for IDENTIFIER. */
+
+static Lisp_Object
+wait_for_property_change_unwind (identifierval)
+ Lisp_Object identifierval;
+{
+ unexpect_property_change ((struct prop_location *)
+ (XFASTINT (XCONS (identifierval)->car) << 16
+ | XFASTINT (XCONS (identifierval)->cdr)));
+ return Qnil;
+}
+
/* Actually wait for a property change.
- TICK should be the value that expect_property_change returned. */
+ IDENTIFIER should be the value that expect_property_change returned. */
static void
-wait_for_property_change (tick)
+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, tem);
+
XCONS (property_change_reply)->car = Qnil;
- property_change_reply_tick = tick;
- wait_reading_process_input (0, 0, property_change_reply, 0);
+
+ 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);
}
/* Called from XTread_socket in response to a PropertyNotify event. */
#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->tick == property_change_reply_tick)
+ 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;
+ 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;
+ count = 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. */
- wait_reading_process_input (x_selection_timeout, 0,
- reading_selection_reply, 0);
+ /* This allows quits. Also, don't wait forever. */
+ secs = x_selection_timeout / 1000;
+ 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, count);
+ UNBLOCK_INPUT;
if (NILP (XCONS (reading_selection_reply)->car))
- error ("timed out waiting for reply from selection owner");
+ error ("Timed out waiting for reply from selection owner");
+ if (EQ (XCONS (reading_selection_reply)->car, Qlambda))
+ error ("No `%s' selection", XSYMBOL (selection_symbol)->name->data);
/* Otherwise, the selection is waiting for us on the requested property. */
return
\f
/* Subroutines of x_get_window_property_as_lisp_data */
+/* Use xfree, not XFree, to free the data obtained with this function. */
+
static void
x_get_window_property (display, window, property, data_ret, bytes_ret,
actual_type_ret, actual_format_ret, actual_size_ret,
BLOCK_INPUT;
/* First probe the thing to find out how big it is. */
result = XGetWindowProperty (display, window, property,
- 0, 0, False, AnyPropertyType,
+ 0L, 0L, False, AnyPropertyType,
actual_type_ret, actual_format_ret,
actual_size_ret,
&bytes_remaining, &tmp_data);
- UNBLOCK_INPUT;
if (result != Success)
{
+ UNBLOCK_INPUT;
*data_ret = 0;
*bytes_ret = 0;
return;
}
- BLOCK_INPUT;
+ /* This was allocated by Xlib, so use XFree. */
XFree ((char *) tmp_data);
- UNBLOCK_INPUT;
if (*actual_type_ret == None || *actual_format_ret == 0)
{
- if (delete_p) XDeleteProperty (display, window, property);
+ UNBLOCK_INPUT;
return;
}
total_size = bytes_remaining + 1;
*data_ret = (unsigned char *) xmalloc (total_size);
- /* Now read, until weve gotten it all. */
- BLOCK_INPUT;
+ /* Now read, until we've gotten it all. */
while (bytes_remaining)
{
#if 0
#endif
result
= XGetWindowProperty (display, window, property,
- offset/4, buffer_size/4,
- (delete_p ? True : False),
+ (long)offset/4, (long)buffer_size/4,
+ False,
AnyPropertyType,
actual_type_ret, actual_format_ret,
actual_size_ret, &bytes_remaining, &tmp_data);
*actual_size_ret *= *actual_format_ret / 8;
bcopy (tmp_data, (*data_ret) + offset, *actual_size_ret);
offset += *actual_size_ret;
+ /* This was allocated by Xlib, so use XFree. */
XFree ((char *) tmp_data);
}
+
+ XFlush (display);
UNBLOCK_INPUT;
*bytes_ret = offset;
}
\f
+/* Use xfree, not XFree, to free the data obtained with this function. */
+
static void
receive_incremental_selection (display, window, property, target_type,
min_size_bytes, data_ret, size_bytes_ret,
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
fprintf (stderr, "\nread INCR %d\n", min_size_bytes);
#endif
- /* At this point, we have read an INCR property, and deleted it (which
- is how we ack its receipt: the sending window will be selecting
- PropertyNotify events on our window to notice this.)
+
+ /* At this point, we have read an INCR property.
+ Delete the property to ack it.
+ (But first, prepare to receive the next event in this handshake.)
Now, we must loop, waiting for the sending window to put a value on
that property, then reading the property, then deleting it to ack.
We are done when the sender places a property of length 0.
*/
- prop_id = expect_property_change (display, window, property,
- PropertyNewValue);
+ BLOCK_INPUT;
+ XSelectInput (display, window, STANDARD_EVENT_SET | PropertyChangeMask);
+ XDeleteProperty (display, window, property);
+ 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.
+ .. no it won't, I don't get it.
.. Ok, I get it now, the Xt code that implements INCR is broken.
*/
- prop_id = expect_property_change (display, window, property,
- PropertyNewValue);
x_get_window_property (display, window, property,
&tmp_data, &tmp_size_bytes,
type_ret, format_ret, size_ret, 1);
#if 0
fprintf (stderr, " read INCR done\n");
#endif
- unexpect_property_change (prop_id);
+ if (! waiting_for_other_props_on_window (display, window))
+ XSelectInput (display, window, STANDARD_EVENT_SET);
+ unexpect_property_change (wait_object);
+ /* Use xfree, not XFree, because x_get_window_property
+ calls xmalloc itself. */
if (tmp_data) xfree (tmp_data);
break;
}
+
+ BLOCK_INPUT;
+ XDeleteProperty (display, window, property);
+ wait_object = expect_property_change (display, window, property,
+ PropertyNewValue);
+ XFlush (display);
+ UNBLOCK_INPUT;
+
#if 0
fprintf (stderr, " read INCR %d\n", tmp_size_bytes);
#endif
*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;
+ /* Use xfree, not XFree, because x_get_window_property
+ calls xmalloc itself. */
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);
there_is_a_selection_owner
= XGetSelectionOwner (display, selection_atom);
UNBLOCK_INPUT;
- while (1) /* Note debugger can no longer return, so this is obsolete */
- Fsignal (Qerror,
- there_is_a_selection_owner ?
- Fcons (build_string ("selection owner couldn't convert"),
+ Fsignal (Qerror,
+ there_is_a_selection_owner
+ ? 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),
- Qnil)));
+ : Fcons (build_string ("no selection"),
+ 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. */
unsigned int min_size_bytes = * ((unsigned int *) data);
BLOCK_INPUT;
- XFree ((char *) data);
+ /* Use xfree, not XFree, because x_get_window_property
+ calls xmalloc itself. */
+ xfree ((char *) data);
UNBLOCK_INPUT;
receive_incremental_selection (display, window, property, target_type,
min_size_bytes, &data, &bytes,
&actual_size);
}
+ BLOCK_INPUT;
+ XDeleteProperty (display, window, property);
+ XFlush (display);
+ UNBLOCK_INPUT;
+
/* It's been read. Now convert it to a lisp object in some semi-rational
manner. */
val = selection_data_to_lisp_data (display, data, bytes,
actual_type, actual_format);
+ /* Use xfree, not XFree, because x_get_window_property
+ calls xmalloc itself. */
xfree ((char *) data);
return val;
}
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. */
else if (format == 8)
- return make_string ((char *) data, size);
+ {
+ Lisp_Object str;
+ int require_encoding = 0;
+ if (! NILP (buffer_defaults.enable_multibyte_characters))
+ {
+ /* If TYPE is `TEXT' or `COMPOUND_TEXT', we should decode
+ DATA to Emacs internal format because DATA may be encoded
+ in compound text format. In addtion, if TYPE is `STRING'
+ and DATA contains any 8-bit Latin-1 code, we should also
+ decode it. */
+ if (type == dpyinfo->Xatom_TEXT
+ || type == dpyinfo->Xatom_COMPOUND_TEXT)
+ require_encoding = 1;
+ else if (type == XA_STRING)
+ {
+ int i;
+ for (i = 0; i < size; i++)
+ {
+ if (data[i] >= 0x80)
+ {
+ require_encoding = 1;
+ break;
+ }
+ }
+ }
+ }
+ if (!require_encoding)
+ str = make_unibyte_string ((char *) data, size);
+ else
+ {
+ int bufsize;
+ unsigned char *buf;
+ struct coding_system coding;
+
+ setup_coding_system
+ (Fcheck_coding_system(Vclipboard_coding_system), &coding);
+ coding.mode |= CODING_MODE_LAST_BLOCK;
+ bufsize = decoding_buffer_size (&coding, size);
+ buf = (unsigned char *) xmalloc (bufsize);
+ decode_coding (&coding, data, buf, size, bufsize);
+ str = make_multibyte_string ((char *) buf,
+ coding.produced_char, coding.produced);
+ xfree (buf);
+ }
+ return str;
+ }
/* Convert a single atom to a Lisp_Symbol. Convert a set of atoms to
a vector of symbols.
*/
{
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);
+ Lisp_Object v = Fmake_vector (make_number (size / sizeof (Atom)),
+ make_number (0));
for (i = 0; i < size / sizeof (Atom); i++)
- Faset (v, i, x_atom_to_symbol (display, ((Atom *) data) [i]));
+ Faset (v, make_number (i),
+ x_atom_to_symbol (dpyinfo, display, ((Atom *) data) [i]));
return v;
}
}
else if (format == 16)
{
int i;
- Lisp_Object v = Fmake_vector (size / 4, 0);
- for (i = 0; i < size / 4; i++)
+ Lisp_Object v;
+ v = Fmake_vector (make_number (size / 2), make_number (0));
+ for (i = 0; i < size / 2; i++)
{
int j = (int) ((unsigned short *) data) [i];
- Faset (v, i, make_number (j));
+ Faset (v, make_number (i), make_number (j));
}
return v;
}
else
{
int i;
- Lisp_Object v = Fmake_vector (size / 4, 0);
+ Lisp_Object v = Fmake_vector (make_number (size / 4), make_number (0));
for (i = 0; i < size / 4; i++)
{
unsigned long j = ((unsigned long *) data) [i];
- Faset (v, i, long_to_cons (j));
+ Faset (v, make_number (i), long_to_cons (j));
}
return v;
}
}
+/* Use xfree, not XFree, to free the data obtained with this function. */
+
static void
lisp_data_to_selection_data (display, obj,
- data_ret, type_ret, size_ret, format_ret)
+ data_ret, type_ret, size_ret,
+ format_ret, nofree_ret)
Display *display;
Lisp_Object obj;
unsigned char **data_ret;
Atom *type_ret;
unsigned int *size_ret;
int *format_ret;
+ int *nofree_ret;
{
Lisp_Object type = Qnil;
+ struct x_display_info *dpyinfo = x_display_info_for_display (display);
+
+ *nofree_ret = 0;
+
if (CONSP (obj) && SYMBOLP (XCONS (obj)->car))
{
type = XCONS (obj)->car;
}
else if (STRINGP (obj))
{
+ /* Since we are now handling multilingual text, we must consider
+ sending back compound text. */
+ int charsets[MAX_CHARSET + 1];
+ int num;
+
*format_ret = 8;
- *size_ret = XSTRING (obj)->size;
- *data_ret = (unsigned char *) xmalloc (*size_ret);
- memcpy (*data_ret, (char *) XSTRING (obj)->data, *size_ret);
- if (NILP (type)) type = QSTRING;
+ *size_ret = STRING_BYTES (XSTRING (obj));
+ *data_ret = XSTRING (obj)->data;
+ bzero (charsets, (MAX_CHARSET + 1) * sizeof (int));
+ num = ((*size_ret <= 1 /* Check the possibility of short cut. */
+ || NILP (buffer_defaults.enable_multibyte_characters))
+ ? 0
+ : find_charset_in_str (*data_ret, *size_ret, charsets, Qnil));
+
+ if (!num || (num == 1 && charsets[CHARSET_ASCII]))
+ {
+ /* No multibyte character in OBJ. We need not encode it. */
+ *nofree_ret = 1;
+ if (NILP (type)) type = QSTRING;
+ }
+ else
+ {
+ /* We must encode contents of OBJ to compound text format.
+ The format is compatible with what the target `STRING'
+ expects if OBJ contains only ASCII and Latin-1
+ characters. */
+ int bufsize;
+ unsigned char *buf;
+ struct coding_system coding;
+
+ setup_coding_system
+ (Fcheck_coding_system (Vclipboard_coding_system), &coding);
+ coding.mode |= CODING_MODE_LAST_BLOCK;
+ bufsize = encoding_buffer_size (&coding, *size_ret);
+ buf = (unsigned char *) xmalloc (bufsize);
+ encode_coding (&coding, *data_ret, buf, *size_ret, bufsize);
+ *size_ret = coding.produced;
+ *data_ret = buf;
+ if (charsets[charset_latin_iso8859_1]
+ && (num == 1 || (num == 2 && charsets[CHARSET_ASCII])))
+ {
+ /* Ok, we can return it as `STRING'. */
+ if (NILP (type)) type = QSTRING;
+ }
+ else
+ {
+ /* We must return it as `COMPOUND_TEXT'. */
+ if (NILP (type)) type = QCOMPOUND_TEXT;
+ }
+ }
}
else if (SYMBOLP (obj))
{
*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
Lisp_Object copy;
if (size == 1)
return clean_local_selection_data (XVECTOR (obj)->contents [0]);
- copy = Fmake_vector (size, Qnil);
+ copy = Fmake_vector (make_number (size), Qnil);
for (i = 0; i < size; i++)
XVECTOR (copy)->contents [i]
= clean_local_selection_data (XVECTOR (obj)->contents [i]);
}
\f
/* Called from XTread_socket to handle SelectionNotify events.
- If it's the selection we are waiting for, stop waiting. */
+ 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. */
void
x_handle_selection_notify (event)
if (event->selection != reading_which_selection)
return;
- XCONS (reading_selection_reply)->car = Qt;
+ XCONS (reading_selection_reply)->car
+ = (event->property != 0 ? Qt : Qlambda);
}
\f
-DEFUN ("x-own-selection-internal",
- Fx_own_selection_internal, Sx_own_selection_internal,
- 2, 2, 0,
+DEFUN ("x-own-selection-internal", Fx_own_selection_internal,
+ Sx_own_selection_internal, 2, 2, 0,
"Assert an X selection of the given TYPE with the given VALUE.\n\
TYPE is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
\(Those are literal upper-case symbol names, since that's what X expects.)\n\
(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.");
+ if (NILP (selection_value)) error ("selection-value may not be nil");
x_own_selection (selection_name, selection_value);
return selection_value;
}
simply return our selection value. If we are not the owner, this
will block until all of the data has arrived. */
-DEFUN ("x-get-selection-internal",
- Fx_get_selection_internal, Sx_get_selection_internal, 2, 2, 0,
+DEFUN ("x-get-selection-internal", Fx_get_selection_internal,
+ Sx_get_selection_internal, 2, 2, 0,
"Return text selected from some X window.\n\
SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
\(Those are literal upper-case symbol names, since that's what X expects.)\n\
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 */
return val;
}
-DEFUN ("x-disown-selection-internal",
- Fx_disown_selection_internal, Sx_disown_selection_internal, 1, 2, 0,
+DEFUN ("x-disown-selection-internal", Fx_disown_selection_internal,
+ Sx_disown_selection_internal, 1, 2, 0,
"If we own the selection SELECTION, disown it.\n\
Disowning it means there is no such selection.")
(selection, time)
Lisp_Object selection;
Lisp_Object time;
{
- Display *display = x_current_display;
Time timestamp;
Atom selection_atom;
- XSelectionClearEvent event;
+ struct selection_input_event 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);
UNBLOCK_INPUT;
- /* It doesn't seem to be guarenteed that a SelectionClear event will be
+ /* It doesn't seem to be guaranteed that a SelectionClear event will be
generated for a window which owns the selection when that window sets
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;
- x_handle_selection_clear (&event);
+ SELECTION_EVENT_DISPLAY (&event) = display;
+ SELECTION_EVENT_SELECTION (&event) = selection_atom;
+ SELECTION_EVENT_TIME (&event) = timestamp;
+ x_handle_selection_clear ((struct input_event *) &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;
Lisp_Object selection;
{
Window owner;
- Display *dpy = x_current_display;
+ Atom atom;
+ 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 (FRAME_X_DISPLAY_INFO (selected_frame),
+ dpy, selection);
+ if (atom == 0)
+ return Qnil;
BLOCK_INPUT;
- owner = XGetSelectionOwner (dpy, symbol_to_x_atom (dpy, selection));
+ owner = XGetSelectionOwner (dpy, atom);
UNBLOCK_INPUT;
return (owner ? Qt : Qnil);
}
\f
#ifdef CUT_BUFFER_SUPPORT
-static int cut_buffers_initialized; /* Whether we're sure they all exist */
-
/* Ensure that all 8 cut buffers exist. ICCCM says we gotta... */
static void
initialize_cut_buffers (display, window)
FROB (XA_CUT_BUFFER7);
#undef FROB
UNBLOCK_INPUT;
- cut_buffers_initialized = 1;
}
(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);
+ /* Use xfree, not XFree, because x_get_window_property
+ calls xmalloc itself. */
xfree (data);
return ret;
}
(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 = STRING_BYTES (XSTRING (string));
bytes_remaining = bytes;
- if (! cut_buffers_initialized) initialize_cut_buffers (display, window);
+ if (! FRAME_X_DISPLAY_INFO (selected_frame)->cut_buffers_initialized)
+ {
+ initialize_cut_buffers (display, window);
+ FRAME_X_DISPLAY_INFO (selected_frame)->cut_buffers_initialized = 1;
+ }
BLOCK_INPUT;
+
+ /* Don't mess up with an empty value. */
+ if (!bytes_remaining)
+ XChangeProperty (display, window, buffer_atom, XA_STRING, 8,
+ PropModeReplace, data, 0);
+
while (bytes_remaining)
{
int chunk = (bytes_remaining < max_bytes
DEFUN ("x-rotate-cut-buffers-internal", Fx_rotate_cut_buffers_internal,
Sx_rotate_cut_buffers_internal, 1, 1, 0,
- "Rotate the values of the cut buffers by the given number of steps;\n\
-positive means move values forward, negative means backward.")
+ "Rotate the values of the cut buffers by the given number of step.\n\
+Positive means shift the values forward, negative means backward.")
(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 (! FRAME_X_DISPLAY_INFO (selected_frame)->cut_buffers_initialized)
+ {
+ initialize_cut_buffers (display, window);
+ FRAME_X_DISPLAY_INFO (selected_frame)->cut_buffers_initialized = 1;
+ }
+
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 ()
{
defsubr (&Sx_get_cut_buffer_internal);
defsubr (&Sx_store_cut_buffer_internal);
defsubr (&Sx_rotate_cut_buffers_internal);
- cut_buffers_initialized = 0;
#endif
reading_selection_reply = Fcons (Qnil, Qnil);
reading_which_selection = 0;
property_change_wait_list = 0;
- prop_location_tick = 0;
+ prop_location_identifier = 0;
property_change_reply = Fcons (Qnil, Qnil);
staticpro (&property_change_reply);
staticpro (&Vselection_alist);
DEFVAR_LISP ("selection-converter-alist", &Vselection_converter_alist,
- "An alist associating X Windows selection-types with functions.\n\
+ "An alist associating X Windows selection-types with functions.\n\
These functions are called to convert the selection, with three args:\n\
the name of the selection (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
a desired type to which the selection should be converted;\n\
Vselection_converter_alist = Qnil;
DEFVAR_LISP ("x-lost-selection-hooks", &Vx_lost_selection_hooks,
- "A list of functions to be called when Emacs loses an X selection.\n\
+ "A list of functions to be called when Emacs loses an X selection.\n\
\(This happens when some other X client makes its own selection\n\
or when a Lisp program explicitly clears the selection.)\n\
The functions are called with one argument, the selection type\n\
-\(a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.)");
+\(a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD').");
Vx_lost_selection_hooks = Qnil;
DEFVAR_LISP ("x-sent-selection-hooks", &Vx_sent_selection_hooks,
- "A list of functions to be called when Emacs answers a selection request.\n\
+ "A list of functions to be called when Emacs answers a selection request.\n\
The functions are called with four arguments:\n\
- the selection name (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
- the selection-type which Emacs was asked to convert the\n\
it merely informs you that they have happened.");
Vx_sent_selection_hooks = Qnil;
+ DEFVAR_LISP ("clipboard-coding-system", &Vclipboard_coding_system,
+ "Coding system for communicating with other X clients.\n\
+When sending or receiving text via cut_buffer, selection, and clipboard,\n\
+the text is encoded or decoded by this coding system.\n\
+A default value is `compound-text'");
+ Vclipboard_coding_system=intern ("compound-text");
+ staticpro(&Vclipboard_coding_system);
+
DEFVAR_INT ("x-selection-timeout", &x_selection_timeout,
- "Number of seconds to wait for a selection reply from another X client.\n\
-If the selection owner doens't reply in this many seconds, we give up.\n\
+ "Number of milliseconds to wait for a selection reply.\n\
+If the selection owner doesn't reply in this time, we give up.\n\
A value of 0 means wait as long as necessary. This is initialized from the\n\
-\"*selectionTimeout\" resource (which is expressed in milliseconds).");
+\"*selectionTimeout\" resource.");
x_selection_timeout = 0;
QPRIMARY = intern ("PRIMARY"); staticpro (&QPRIMARY);
QCLIPBOARD = intern ("CLIPBOARD"); staticpro (&QCLIPBOARD);
QTIMESTAMP = intern ("TIMESTAMP"); staticpro (&QTIMESTAMP);
QTEXT = intern ("TEXT"); staticpro (&QTEXT);
+ QCOMPOUND_TEXT = intern ("COMPOUND_TEXT"); staticpro (&QCOMPOUND_TEXT);
QTIMESTAMP = intern ("TIMESTAMP"); staticpro (&QTIMESTAMP);
QDELETE = intern ("DELETE"); staticpro (&QDELETE);
QMULTIPLE = intern ("MULTIPLE"); staticpro (&QMULTIPLE);
HCoop / bpt / emacs.git / blobdiff