/* X Selection processing for Emacs.
- Copyright (C) 1993, 1994 Free Software Foundation.
+ Copyright (C) 1993, 1994, 1995, 1996 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. */
-
-/* x_handle_selection_notify
-x_reply_selection_request */
+the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
+Boston, MA 02111-1307, USA. */
/* Rewritten by jwz */
#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 */
#include "blockinput.h"
-#define xfree free
-
#define CUT_BUFFER_SUPPORT
Lisp_Object QPRIMARY, QSECONDARY, QSTRING, QINTEGER, QCLIPBOARD, QTIMESTAMP,
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;
/* 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
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 milliseconds (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 */
if (! str) return Qnil;
val = intern (str);
BLOCK_INPUT;
+ /* This was allocated by Xlib, so use XFree. */
XFree (str);
UNBLOCK_INPUT;
return val;
selection_atom = symbol_to_x_atom (dpyinfo, display, selection_name);
BLOCK_INPUT;
- x_catch_errors (selected_frame);
+ x_catch_errors (display);
XSetSelectionOwner (display, selection_atom, selecting_window, time);
- x_check_errors (selected_frame, "Can't set selection: %s");
- x_uncatch_errors (selected_frame);
+ x_check_errors (display, "Can't set selection: %s");
+ x_uncatch_errors (display);
UNBLOCK_INPUT;
/* Now update the local cache */
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
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.
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);
- XFlush (display);
- UNBLOCK_INPUT;
}
else
{
/* Send an INCR selection. */
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);
- 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
PropertyDelete);
XChangeProperty (display, window, reply.property, dpyinfo->Xatom_INCR,
- 32, PropModeReplace, (unsigned char *)
- &bytes_remaining, 1);
+ 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 (wait_object);
+ if (! had_errors)
+ wait_for_property_change (wait_object);
while (bytes_remaining)
{
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 (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");
XChangeProperty (display, window, reply.property, type, format,
PropModeReplace, data, 0);
- XFlush (display);
- UNBLOCK_INPUT;
+
+ unbind_to (count, Qnil);
}
+
+ XFlush (display);
+ x_uncatch_errors (display);
+ UNBLOCK_INPUT;
}
\f
/* Handle a SelectionRequest event EVENT.
/* Indicate we have successfully processed this event. */
x_selection_current_request = 0;
+ /* Use free, not XFree, because lisp_data_to_selection_data
+ calls xmalloc itself. */
if (!nofree)
- xfree (data);
+ free (data);
}
unbind_to (count, Qnil);
/* Otherwise, we're really honest and truly being told to drop it.
Don't use Fdelq as that may QUIT;. */
+ /* Delete elements from the beginning of Vselection_alist. */
while (!NILP (Vselection_alist)
&& EQ (frame, Fcar (Fcdr (Fcdr (Fcdr (Fcar (Vselection_alist)))))))
{
Lisp_Object hooks, selection_symbol;
hooks = Vx_lost_selection_hooks;
- selection_symbol = Fcar (Vselection_alist);
+ selection_symbol = Fcar (Fcar (Vselection_alist));
if (!EQ (hooks, Qunbound))
{
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)))))))
{
Lisp_Object hooks, selection_symbol;
hooks = Vx_lost_selection_hooks;
- selection_symbol = Fcar (XCONS (rest)->cdr);
+ selection_symbol = Fcar (Fcar (XCONS (rest)->cdr));
if (!EQ (hooks, Qunbound))
{
prev->next = rest->next;
else
property_change_wait_list = rest->next;
- xfree (rest);
+ free (rest);
return;
}
prev = rest;
wait_for_property_change_unwind (identifierval)
Lisp_Object identifierval;
{
- unexpect_property_change (XPNTR (identifierval));
+ unexpect_property_change ((struct prop_location *)
+ (XFASTINT (XCONS (identifierval)->car) << 16
+ | XFASTINT (XCONS (identifierval)->cdr)));
+ return Qnil;
}
/* Actually wait for a property change.
int count = specpdl_ptr - specpdl;
Lisp_Object tem;
- XSETCONS (tem, location);
+ 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_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)
{
- property_change_reply_object = location;
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");
+ error ("Timed out waiting for property-notify event");
}
unbind_to (count, Qnil);
prev->next = rest->next;
else
property_change_wait_list = rest->next;
- xfree (rest);
+ free (rest);
return;
}
prev = rest;
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 (dpyinfo, display, XCONS (target_type)->car);
type_atom = symbol_to_x_atom (dpyinfo, display, target_type);
BLOCK_INPUT;
- x_catch_errors (selected_frame);
+ x_catch_errors (display);
XConvertSelection (display, selection_atom, type_atom, target_property,
requestor_window, requestor_time);
XFlush (display);
reading_selection_window = requestor_window;
reading_which_selection = selection_atom;
XCONS (reading_selection_reply)->car = Qnil;
- x_start_queuing_selection_requests (selected_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);
+
+ record_unwind_protect (queue_selection_requests_unwind,
+ frame);
+ }
UNBLOCK_INPUT;
/* This allows quits. Also, don't wait forever. */
wait_reading_process_input (secs, usecs, reading_selection_reply, 0);
BLOCK_INPUT;
- x_check_errors (selected_frame, "Cannot get selection: %s");
- x_uncatch_errors (selected_frame);
- x_stop_queuing_selection_requests (selected_frame);
+ 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");
+ 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 free, 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);
*bytes_ret = 0;
return;
}
- xfree ((char *) tmp_data);
+ /* This was allocated by Xlib, so use XFree. */
+ XFree ((char *) tmp_data);
if (*actual_type_ret == None || *actual_format_ret == 0)
{
total_size = bytes_remaining + 1;
*data_ret = (unsigned char *) xmalloc (total_size);
- /* Now read, until weve gotten it all. */
+ /* Now read, until we've gotten it all. */
while (bytes_remaining)
{
#if 0
#endif
result
= XGetWindowProperty (display, window, property,
- offset/4, buffer_size/4,
+ (long)offset/4, (long)buffer_size/4,
False,
AnyPropertyType,
actual_type_ret, actual_format_ret,
*actual_size_ret *= *actual_format_ret / 8;
bcopy (tmp_data, (*data_ret) + offset, *actual_size_ret);
offset += *actual_size_ret;
- xfree ((char *) tmp_data);
+ /* This was allocated by Xlib, so use XFree. */
+ XFree ((char *) tmp_data);
}
XFlush (display);
*bytes_ret = offset;
}
\f
+/* Use free, 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 tmp_size_bytes;
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.
*/
x_get_window_property (display, window, property,
if (! waiting_for_other_props_on_window (display, window))
XSelectInput (display, window, STANDARD_EVENT_SET);
unexpect_property_change (wait_object);
- if (tmp_data) xfree (tmp_data);
+ /* Use free, not XFree, because x_get_window_property
+ calls xmalloc itself. */
+ if (tmp_data) free (tmp_data);
break;
}
}
bcopy (tmp_data, (*data_ret) + offset, tmp_size_bytes);
offset += tmp_size_bytes;
- xfree (tmp_data);
+ /* Use free, not XFree, because x_get_window_property
+ calls xmalloc itself. */
+ free (tmp_data);
}
}
\f
unsigned int min_size_bytes = * ((unsigned int *) data);
BLOCK_INPUT;
- XFree ((char *) data);
+ /* Use free, not XFree, because x_get_window_property
+ calls xmalloc itself. */
+ free ((char *) data);
UNBLOCK_INPUT;
receive_incremental_selection (display, window, property, target_type,
min_size_bytes, &data, &bytes,
val = selection_data_to_lisp_data (display, data, bytes,
actual_type, actual_format);
- xfree ((char *) data);
+ /* Use free, not XFree, because x_get_window_property
+ calls xmalloc itself. */
+ free ((char *) data);
return val;
}
\f
}
+/* Use free, 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,
}
\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
{
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;
}
Atom atom;
Display *dpy;
- check_x ();
+ /* 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)))
\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;
}
Fcons (make_number (format), Qnil))));
ret = (bytes ? make_string ((char *) data, bytes) : Qnil);
- xfree (data);
+ /* Use free, not XFree, because x_get_window_property
+ calls xmalloc itself. */
+ free (data);
return ret;
}
bytes = XSTRING (string)->size;
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;
CHECK_NUMBER (n, 0);
if (XINT (n) == 0)
return n;
- 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;
+ }
props[0] = XA_CUT_BUFFER0;
props[1] = XA_CUT_BUFFER1;
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);
\(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,
DEFVAR_INT ("x-selection-timeout", &x_selection_timeout,
"Number of milliseconds to wait for a selection reply.\n\
-If the selection owner doens't reply in this time, we give up.\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.");
x_selection_timeout = 0;
HCoop / bpt / emacs.git / blobdiff