1 /* X Selection processing for Emacs.
2 Copyright (C) 1993, 1994, 1995, 1996, 1997 Free Software Foundation.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 /* Rewritten by jwz */
26 #include "xterm.h" /* for all of the X includes */
27 #include "dispextern.h" /* frame.h seems to want this */
28 #include "frame.h" /* Need this to get the X window of selected_frame */
29 #include "blockinput.h"
35 #define CUT_BUFFER_SUPPORT
37 Lisp_Object QPRIMARY
, QSECONDARY
, QSTRING
, QINTEGER
, QCLIPBOARD
, QTIMESTAMP
,
38 QTEXT
, QDELETE
, QMULTIPLE
, QINCR
, QEMACS_TMP
, QTARGETS
, QATOM
, QNULL
,
41 Lisp_Object QCOMPOUND_TEXT
; /* This is a type of selection. */
43 #ifdef CUT_BUFFER_SUPPORT
44 Lisp_Object QCUT_BUFFER0
, QCUT_BUFFER1
, QCUT_BUFFER2
, QCUT_BUFFER3
,
45 QCUT_BUFFER4
, QCUT_BUFFER5
, QCUT_BUFFER6
, QCUT_BUFFER7
;
48 static Lisp_Object Vx_lost_selection_hooks
;
49 static Lisp_Object Vx_sent_selection_hooks
;
50 /* Coding system for communicating with other X clients via cutbuffer,
51 selection, and clipboard. */
52 static Lisp_Object Vselection_coding_system
;
54 /* Coding system for the next communicating with other X clients. */
55 static Lisp_Object Vnext_selection_coding_system
;
57 /* If this is a smaller number than the max-request-size of the display,
58 emacs will use INCR selection transfer when the selection is larger
59 than this. The max-request-size is usually around 64k, so if you want
60 emacs to use incremental selection transfers when the selection is
61 smaller than that, set this. I added this mostly for debugging the
62 incremental transfer stuff, but it might improve server performance. */
63 #define MAX_SELECTION_QUANTUM 0xFFFFFF
66 #define SELECTION_QUANTUM(dpy) ((XMaxRequestSize(dpy) << 2) - 100)
68 #define SELECTION_QUANTUM(dpy) (((dpy)->max_request_size << 2) - 100)
71 /* The timestamp of the last input event Emacs received from the X server. */
72 /* Defined in keyboard.c. */
73 extern unsigned long last_event_timestamp
;
75 /* This is an association list whose elements are of the form
76 ( SELECTION-NAME SELECTION-VALUE SELECTION-TIMESTAMP FRAME)
77 SELECTION-NAME is a lisp symbol, whose name is the name of an X Atom.
78 SELECTION-VALUE is the value that emacs owns for that selection.
79 It may be any kind of Lisp object.
80 SELECTION-TIMESTAMP is the time at which emacs began owning this selection,
81 as a cons of two 16-bit numbers (making a 32 bit time.)
82 FRAME is the frame for which we made the selection.
83 If there is an entry in this alist, then it can be assumed that Emacs owns
85 The only (eq) parts of this list that are visible from Lisp are the
87 static Lisp_Object Vselection_alist
;
89 /* This is an alist whose CARs are selection-types (whose names are the same
90 as the names of X Atoms) and whose CDRs are the names of Lisp functions to
91 call to convert the given Emacs selection value to a string representing
92 the given selection type. This is for Lisp-level extension of the emacs
93 selection handling. */
94 static Lisp_Object Vselection_converter_alist
;
96 /* If the selection owner takes too long to reply to a selection request,
97 we give up on it. This is in milliseconds (0 = no timeout.) */
98 static int x_selection_timeout
;
100 /* Utility functions */
102 static void lisp_data_to_selection_data ();
103 static Lisp_Object
selection_data_to_lisp_data ();
104 static Lisp_Object
x_get_window_property_as_lisp_data ();
106 /* This converts a Lisp symbol to a server Atom, avoiding a server
107 roundtrip whenever possible. */
110 symbol_to_x_atom (dpyinfo
, display
, sym
)
111 struct x_display_info
*dpyinfo
;
116 if (NILP (sym
)) return 0;
117 if (EQ (sym
, QPRIMARY
)) return XA_PRIMARY
;
118 if (EQ (sym
, QSECONDARY
)) return XA_SECONDARY
;
119 if (EQ (sym
, QSTRING
)) return XA_STRING
;
120 if (EQ (sym
, QINTEGER
)) return XA_INTEGER
;
121 if (EQ (sym
, QATOM
)) return XA_ATOM
;
122 if (EQ (sym
, QCLIPBOARD
)) return dpyinfo
->Xatom_CLIPBOARD
;
123 if (EQ (sym
, QTIMESTAMP
)) return dpyinfo
->Xatom_TIMESTAMP
;
124 if (EQ (sym
, QTEXT
)) return dpyinfo
->Xatom_TEXT
;
125 if (EQ (sym
, QCOMPOUND_TEXT
)) return dpyinfo
->Xatom_COMPOUND_TEXT
;
126 if (EQ (sym
, QDELETE
)) return dpyinfo
->Xatom_DELETE
;
127 if (EQ (sym
, QMULTIPLE
)) return dpyinfo
->Xatom_MULTIPLE
;
128 if (EQ (sym
, QINCR
)) return dpyinfo
->Xatom_INCR
;
129 if (EQ (sym
, QEMACS_TMP
)) return dpyinfo
->Xatom_EMACS_TMP
;
130 if (EQ (sym
, QTARGETS
)) return dpyinfo
->Xatom_TARGETS
;
131 if (EQ (sym
, QNULL
)) return dpyinfo
->Xatom_NULL
;
132 #ifdef CUT_BUFFER_SUPPORT
133 if (EQ (sym
, QCUT_BUFFER0
)) return XA_CUT_BUFFER0
;
134 if (EQ (sym
, QCUT_BUFFER1
)) return XA_CUT_BUFFER1
;
135 if (EQ (sym
, QCUT_BUFFER2
)) return XA_CUT_BUFFER2
;
136 if (EQ (sym
, QCUT_BUFFER3
)) return XA_CUT_BUFFER3
;
137 if (EQ (sym
, QCUT_BUFFER4
)) return XA_CUT_BUFFER4
;
138 if (EQ (sym
, QCUT_BUFFER5
)) return XA_CUT_BUFFER5
;
139 if (EQ (sym
, QCUT_BUFFER6
)) return XA_CUT_BUFFER6
;
140 if (EQ (sym
, QCUT_BUFFER7
)) return XA_CUT_BUFFER7
;
142 if (!SYMBOLP (sym
)) abort ();
145 fprintf (stderr
, " XInternAtom %s\n", (char *) XSYMBOL (sym
)->name
->data
);
148 val
= XInternAtom (display
, (char *) XSYMBOL (sym
)->name
->data
, False
);
154 /* This converts a server Atom to a Lisp symbol, avoiding server roundtrips
155 and calls to intern whenever possible. */
158 x_atom_to_symbol (dpyinfo
, display
, atom
)
159 struct x_display_info
*dpyinfo
;
165 if (! atom
) return Qnil
;
178 #ifdef CUT_BUFFER_SUPPORT
198 if (atom
== dpyinfo
->Xatom_CLIPBOARD
)
200 if (atom
== dpyinfo
->Xatom_TIMESTAMP
)
202 if (atom
== dpyinfo
->Xatom_TEXT
)
204 if (atom
== dpyinfo
->Xatom_COMPOUND_TEXT
)
205 return QCOMPOUND_TEXT
;
206 if (atom
== dpyinfo
->Xatom_DELETE
)
208 if (atom
== dpyinfo
->Xatom_MULTIPLE
)
210 if (atom
== dpyinfo
->Xatom_INCR
)
212 if (atom
== dpyinfo
->Xatom_EMACS_TMP
)
214 if (atom
== dpyinfo
->Xatom_TARGETS
)
216 if (atom
== dpyinfo
->Xatom_NULL
)
220 str
= XGetAtomName (display
, atom
);
223 fprintf (stderr
, " XGetAtomName --> %s\n", str
);
225 if (! str
) return Qnil
;
228 /* This was allocated by Xlib, so use XFree. */
234 /* Do protocol to assert ourself as a selection owner.
235 Update the Vselection_alist so that we can reply to later requests for
239 x_own_selection (selection_name
, selection_value
)
240 Lisp_Object selection_name
, selection_value
;
242 Window selecting_window
= FRAME_X_WINDOW (selected_frame
);
243 Display
*display
= FRAME_X_DISPLAY (selected_frame
);
244 Time time
= last_event_timestamp
;
246 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
249 CHECK_SYMBOL (selection_name
, 0);
250 selection_atom
= symbol_to_x_atom (dpyinfo
, display
, selection_name
);
253 count
= x_catch_errors (display
);
254 XSetSelectionOwner (display
, selection_atom
, selecting_window
, time
);
255 x_check_errors (display
, "Can't set selection: %s");
256 x_uncatch_errors (display
, count
);
259 /* Now update the local cache */
261 Lisp_Object selection_time
;
262 Lisp_Object selection_data
;
263 Lisp_Object prev_value
;
265 selection_time
= long_to_cons ((unsigned long) time
);
266 selection_data
= Fcons (selection_name
,
267 Fcons (selection_value
,
268 Fcons (selection_time
,
269 Fcons (Fselected_frame (), Qnil
))));
270 prev_value
= assq_no_quit (selection_name
, Vselection_alist
);
272 Vselection_alist
= Fcons (selection_data
, Vselection_alist
);
274 /* If we already owned the selection, remove the old selection data.
275 Perhaps we should destructively modify it instead.
276 Don't use Fdelq as that may QUIT. */
277 if (!NILP (prev_value
))
279 Lisp_Object rest
; /* we know it's not the CAR, so it's easy. */
280 for (rest
= Vselection_alist
; !NILP (rest
); rest
= Fcdr (rest
))
281 if (EQ (prev_value
, Fcar (XCONS (rest
)->cdr
)))
283 XCONS (rest
)->cdr
= Fcdr (XCONS (rest
)->cdr
);
290 /* Given a selection-name and desired type, look up our local copy of
291 the selection value and convert it to the type.
292 The value is nil or a string.
293 This function is used both for remote requests
294 and for local x-get-selection-internal.
296 This calls random Lisp code, and may signal or gc. */
299 x_get_local_selection (selection_symbol
, target_type
)
300 Lisp_Object selection_symbol
, target_type
;
302 Lisp_Object local_value
;
303 Lisp_Object handler_fn
, value
, type
, check
;
306 local_value
= assq_no_quit (selection_symbol
, Vselection_alist
);
308 if (NILP (local_value
)) return Qnil
;
310 /* TIMESTAMP and MULTIPLE are special cases 'cause that's easiest. */
311 if (EQ (target_type
, QTIMESTAMP
))
314 value
= XCONS (XCONS (XCONS (local_value
)->cdr
)->cdr
)->car
;
317 else if (EQ (target_type
, QDELETE
))
320 Fx_disown_selection_internal
322 XCONS (XCONS (XCONS (local_value
)->cdr
)->cdr
)->car
);
327 #if 0 /* #### MULTIPLE doesn't work yet */
328 else if (CONSP (target_type
)
329 && XCONS (target_type
)->car
== QMULTIPLE
)
334 pairs
= XCONS (target_type
)->cdr
;
335 size
= XVECTOR (pairs
)->size
;
336 /* If the target is MULTIPLE, then target_type looks like
337 (MULTIPLE . [[SELECTION1 TARGET1] [SELECTION2 TARGET2] ... ])
338 We modify the second element of each pair in the vector and
339 return it as [[SELECTION1 <value1>] [SELECTION2 <value2>] ... ]
341 for (i
= 0; i
< size
; i
++)
344 pair
= XVECTOR (pairs
)->contents
[i
];
345 XVECTOR (pair
)->contents
[1]
346 = x_get_local_selection (XVECTOR (pair
)->contents
[0],
347 XVECTOR (pair
)->contents
[1]);
354 /* Don't allow a quit within the converter.
355 When the user types C-g, he would be surprised
356 if by luck it came during a converter. */
357 count
= specpdl_ptr
- specpdl
;
358 specbind (Qinhibit_quit
, Qt
);
360 CHECK_SYMBOL (target_type
, 0);
361 handler_fn
= Fcdr (Fassq (target_type
, Vselection_converter_alist
));
362 if (!NILP (handler_fn
))
363 value
= call3 (handler_fn
,
364 selection_symbol
, target_type
,
365 XCONS (XCONS (local_value
)->cdr
)->car
);
368 unbind_to (count
, Qnil
);
371 /* Make sure this value is of a type that we could transmit
372 to another X client. */
376 && SYMBOLP (XCONS (value
)->car
))
377 type
= XCONS (value
)->car
,
378 check
= XCONS (value
)->cdr
;
386 /* Check for a value that cons_to_long could handle. */
387 else if (CONSP (check
)
388 && INTEGERP (XCONS (check
)->car
)
389 && (INTEGERP (XCONS (check
)->cdr
)
391 (CONSP (XCONS (check
)->cdr
)
392 && INTEGERP (XCONS (XCONS (check
)->cdr
)->car
)
393 && NILP (XCONS (XCONS (check
)->cdr
)->cdr
))))
398 Fcons (build_string ("invalid data returned by selection-conversion function"),
399 Fcons (handler_fn
, Fcons (value
, Qnil
))));
402 /* Subroutines of x_reply_selection_request. */
404 /* Send a SelectionNotify event to the requestor with property=None,
405 meaning we were unable to do what they wanted. */
408 x_decline_selection_request (event
)
409 struct input_event
*event
;
411 XSelectionEvent reply
;
412 reply
.type
= SelectionNotify
;
413 reply
.display
= SELECTION_EVENT_DISPLAY (event
);
414 reply
.requestor
= SELECTION_EVENT_REQUESTOR (event
);
415 reply
.selection
= SELECTION_EVENT_SELECTION (event
);
416 reply
.time
= SELECTION_EVENT_TIME (event
);
417 reply
.target
= SELECTION_EVENT_TARGET (event
);
418 reply
.property
= None
;
421 XSendEvent (reply
.display
, reply
.requestor
, False
, 0L,
423 XFlush (reply
.display
);
427 /* This is the selection request currently being processed.
428 It is set to zero when the request is fully processed. */
429 static struct input_event
*x_selection_current_request
;
431 /* Used as an unwind-protect clause so that, if a selection-converter signals
432 an error, we tell the requester that we were unable to do what they wanted
433 before we throw to top-level or go into the debugger or whatever. */
436 x_selection_request_lisp_error (ignore
)
439 if (x_selection_current_request
!= 0)
440 x_decline_selection_request (x_selection_current_request
);
445 /* This stuff is so that INCR selections are reentrant (that is, so we can
446 be servicing multiple INCR selection requests simultaneously.) I haven't
447 actually tested that yet. */
449 /* Keep a list of the property changes that are awaited. */
459 struct prop_location
*next
;
462 static struct prop_location
*expect_property_change ();
463 static void wait_for_property_change ();
464 static void unexpect_property_change ();
465 static int waiting_for_other_props_on_window ();
467 static int prop_location_identifier
;
469 static Lisp_Object property_change_reply
;
471 static struct prop_location
*property_change_reply_object
;
473 static struct prop_location
*property_change_wait_list
;
476 queue_selection_requests_unwind (frame
)
479 FRAME_PTR f
= XFRAME (frame
);
482 x_stop_queuing_selection_requests (FRAME_X_DISPLAY (f
));
486 /* Return some frame whose display info is DPYINFO.
487 Return nil if there is none. */
490 some_frame_on_display (dpyinfo
)
491 struct x_display_info
*dpyinfo
;
493 Lisp_Object list
, frame
;
495 FOR_EACH_FRAME (list
, frame
)
497 if (FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
504 /* Send the reply to a selection request event EVENT.
505 TYPE is the type of selection data requested.
506 DATA and SIZE describe the data to send, already converted.
507 FORMAT is the unit-size (in bits) of the data to be transmitted. */
510 x_reply_selection_request (event
, format
, data
, size
, type
)
511 struct input_event
*event
;
516 XSelectionEvent reply
;
517 Display
*display
= SELECTION_EVENT_DISPLAY (event
);
518 Window window
= SELECTION_EVENT_REQUESTOR (event
);
520 int format_bytes
= format
/8;
521 int max_bytes
= SELECTION_QUANTUM (display
);
522 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
525 if (max_bytes
> MAX_SELECTION_QUANTUM
)
526 max_bytes
= MAX_SELECTION_QUANTUM
;
528 reply
.type
= SelectionNotify
;
529 reply
.display
= display
;
530 reply
.requestor
= window
;
531 reply
.selection
= SELECTION_EVENT_SELECTION (event
);
532 reply
.time
= SELECTION_EVENT_TIME (event
);
533 reply
.target
= SELECTION_EVENT_TARGET (event
);
534 reply
.property
= SELECTION_EVENT_PROPERTY (event
);
535 if (reply
.property
== None
)
536 reply
.property
= reply
.target
;
538 /* #### XChangeProperty can generate BadAlloc, and we must handle it! */
540 count
= x_catch_errors (display
);
542 /* Store the data on the requested property.
543 If the selection is large, only store the first N bytes of it.
545 bytes_remaining
= size
* format_bytes
;
546 if (bytes_remaining
<= max_bytes
)
548 /* Send all the data at once, with minimal handshaking. */
550 fprintf (stderr
,"\nStoring all %d\n", bytes_remaining
);
552 XChangeProperty (display
, window
, reply
.property
, type
, format
,
553 PropModeReplace
, data
, size
);
554 /* At this point, the selection was successfully stored; ack it. */
555 XSendEvent (display
, window
, False
, 0L, (XEvent
*) &reply
);
559 /* Send an INCR selection. */
560 struct prop_location
*wait_object
;
564 frame
= some_frame_on_display (dpyinfo
);
566 /* If the display no longer has frames, we can't expect
567 to get many more selection requests from it, so don't
568 bother trying to queue them. */
571 x_start_queuing_selection_requests (display
);
573 record_unwind_protect (queue_selection_requests_unwind
,
577 if (x_window_to_frame (dpyinfo
, window
)) /* #### debug */
578 error ("Attempt to transfer an INCR to ourself!");
580 fprintf (stderr
, "\nINCR %d\n", bytes_remaining
);
582 wait_object
= expect_property_change (display
, window
, reply
.property
,
585 XChangeProperty (display
, window
, reply
.property
, dpyinfo
->Xatom_INCR
,
587 (unsigned char *) &bytes_remaining
, 1);
588 XSelectInput (display
, window
, PropertyChangeMask
);
589 /* Tell 'em the INCR data is there... */
590 XSendEvent (display
, window
, False
, 0L, (XEvent
*) &reply
);
593 had_errors
= x_had_errors_p (display
);
596 /* First, wait for the requester to ack by deleting the property.
597 This can run random lisp code (process handlers) or signal. */
599 wait_for_property_change (wait_object
);
601 while (bytes_remaining
)
603 int i
= ((bytes_remaining
< max_bytes
)
610 = expect_property_change (display
, window
, reply
.property
,
613 fprintf (stderr
," INCR adding %d\n", i
);
615 /* Append the next chunk of data to the property. */
616 XChangeProperty (display
, window
, reply
.property
, type
, format
,
617 PropModeAppend
, data
, i
/ format_bytes
);
618 bytes_remaining
-= i
;
621 had_errors
= x_had_errors_p (display
);
627 /* Now wait for the requester to ack this chunk by deleting the
628 property. This can run random lisp code or signal.
630 wait_for_property_change (wait_object
);
632 /* Now write a zero-length chunk to the property to tell the requester
635 fprintf (stderr
," INCR done\n");
638 if (! waiting_for_other_props_on_window (display
, window
))
639 XSelectInput (display
, window
, 0L);
641 XChangeProperty (display
, window
, reply
.property
, type
, format
,
642 PropModeReplace
, data
, 0);
646 x_uncatch_errors (display
, count
);
650 /* Handle a SelectionRequest event EVENT.
651 This is called from keyboard.c when such an event is found in the queue. */
654 x_handle_selection_request (event
)
655 struct input_event
*event
;
657 struct gcpro gcpro1
, gcpro2
, gcpro3
;
658 Lisp_Object local_selection_data
;
659 Lisp_Object selection_symbol
;
660 Lisp_Object target_symbol
;
661 Lisp_Object converted_selection
;
662 Time local_selection_time
;
663 Lisp_Object successful_p
;
665 struct x_display_info
*dpyinfo
666 = x_display_info_for_display (SELECTION_EVENT_DISPLAY (event
));
668 local_selection_data
= Qnil
;
669 target_symbol
= Qnil
;
670 converted_selection
= Qnil
;
673 GCPRO3 (local_selection_data
, converted_selection
, target_symbol
);
675 selection_symbol
= x_atom_to_symbol (dpyinfo
,
676 SELECTION_EVENT_DISPLAY (event
),
677 SELECTION_EVENT_SELECTION (event
));
679 local_selection_data
= assq_no_quit (selection_symbol
, Vselection_alist
);
681 if (NILP (local_selection_data
))
683 /* Someone asked for the selection, but we don't have it any more.
685 x_decline_selection_request (event
);
689 local_selection_time
= (Time
)
690 cons_to_long (XCONS (XCONS (XCONS (local_selection_data
)->cdr
)->cdr
)->car
);
692 if (SELECTION_EVENT_TIME (event
) != CurrentTime
693 && local_selection_time
> SELECTION_EVENT_TIME (event
))
695 /* Someone asked for the selection, and we have one, but not the one
698 x_decline_selection_request (event
);
702 count
= specpdl_ptr
- specpdl
;
703 x_selection_current_request
= event
;
704 record_unwind_protect (x_selection_request_lisp_error
, Qnil
);
706 target_symbol
= x_atom_to_symbol (dpyinfo
, SELECTION_EVENT_DISPLAY (event
),
707 SELECTION_EVENT_TARGET (event
));
709 #if 0 /* #### MULTIPLE doesn't work yet */
710 if (EQ (target_symbol
, QMULTIPLE
))
711 target_symbol
= fetch_multiple_target (event
);
714 /* Convert lisp objects back into binary data */
717 = x_get_local_selection (selection_symbol
, target_symbol
);
719 if (! NILP (converted_selection
))
727 lisp_data_to_selection_data (SELECTION_EVENT_DISPLAY (event
),
729 &data
, &type
, &size
, &format
, &nofree
);
731 x_reply_selection_request (event
, format
, data
, size
, type
);
734 /* Indicate we have successfully processed this event. */
735 x_selection_current_request
= 0;
737 /* Use xfree, not XFree, because lisp_data_to_selection_data
738 calls xmalloc itself. */
742 unbind_to (count
, Qnil
);
748 /* Let random lisp code notice that the selection has been asked for. */
751 rest
= Vx_sent_selection_hooks
;
752 if (!EQ (rest
, Qunbound
))
753 for (; CONSP (rest
); rest
= Fcdr (rest
))
754 call3 (Fcar (rest
), selection_symbol
, target_symbol
, successful_p
);
758 /* Handle a SelectionClear event EVENT, which indicates that some other
759 client cleared out our previously asserted selection.
760 This is called from keyboard.c when such an event is found in the queue. */
763 x_handle_selection_clear (event
)
764 struct input_event
*event
;
766 Display
*display
= SELECTION_EVENT_DISPLAY (event
);
767 Atom selection
= SELECTION_EVENT_SELECTION (event
);
768 Time changed_owner_time
= SELECTION_EVENT_TIME (event
);
770 Lisp_Object selection_symbol
, local_selection_data
;
771 Time local_selection_time
;
772 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
774 selection_symbol
= x_atom_to_symbol (dpyinfo
, display
, selection
);
776 local_selection_data
= assq_no_quit (selection_symbol
, Vselection_alist
);
778 /* Well, we already believe that we don't own it, so that's just fine. */
779 if (NILP (local_selection_data
)) return;
781 local_selection_time
= (Time
)
782 cons_to_long (XCONS (XCONS (XCONS (local_selection_data
)->cdr
)->cdr
)->car
);
784 /* This SelectionClear is for a selection that we no longer own, so we can
785 disregard it. (That is, we have reasserted the selection since this
786 request was generated.) */
788 if (changed_owner_time
!= CurrentTime
789 && local_selection_time
> changed_owner_time
)
792 /* Otherwise, we're really honest and truly being told to drop it.
793 Don't use Fdelq as that may QUIT;. */
795 if (EQ (local_selection_data
, Fcar (Vselection_alist
)))
796 Vselection_alist
= Fcdr (Vselection_alist
);
800 for (rest
= Vselection_alist
; !NILP (rest
); rest
= Fcdr (rest
))
801 if (EQ (local_selection_data
, Fcar (XCONS (rest
)->cdr
)))
803 XCONS (rest
)->cdr
= Fcdr (XCONS (rest
)->cdr
);
808 /* Let random lisp code notice that the selection has been stolen. */
812 rest
= Vx_lost_selection_hooks
;
813 if (!EQ (rest
, Qunbound
))
815 for (; CONSP (rest
); rest
= Fcdr (rest
))
816 call1 (Fcar (rest
), selection_symbol
);
817 prepare_menu_bars ();
818 redisplay_preserve_echo_area ();
823 /* Clear all selections that were made from frame F.
824 We do this when about to delete a frame. */
827 x_clear_frame_selections (f
)
833 XSETFRAME (frame
, f
);
835 /* Otherwise, we're really honest and truly being told to drop it.
836 Don't use Fdelq as that may QUIT;. */
838 /* Delete elements from the beginning of Vselection_alist. */
839 while (!NILP (Vselection_alist
)
840 && EQ (frame
, Fcar (Fcdr (Fcdr (Fcdr (Fcar (Vselection_alist
)))))))
842 /* Let random Lisp code notice that the selection has been stolen. */
843 Lisp_Object hooks
, selection_symbol
;
845 hooks
= Vx_lost_selection_hooks
;
846 selection_symbol
= Fcar (Fcar (Vselection_alist
));
848 if (!EQ (hooks
, Qunbound
))
850 for (; CONSP (hooks
); hooks
= Fcdr (hooks
))
851 call1 (Fcar (hooks
), selection_symbol
);
852 #if 0 /* This can crash when deleting a frame
853 from x_connection_closed. Anyway, it seems unnecessary;
854 something else should cause a redisplay. */
855 redisplay_preserve_echo_area ();
859 Vselection_alist
= Fcdr (Vselection_alist
);
862 /* Delete elements after the beginning of Vselection_alist. */
863 for (rest
= Vselection_alist
; !NILP (rest
); rest
= Fcdr (rest
))
864 if (EQ (frame
, Fcar (Fcdr (Fcdr (Fcdr (Fcar (XCONS (rest
)->cdr
)))))))
866 /* Let random Lisp code notice that the selection has been stolen. */
867 Lisp_Object hooks
, selection_symbol
;
869 hooks
= Vx_lost_selection_hooks
;
870 selection_symbol
= Fcar (Fcar (XCONS (rest
)->cdr
));
872 if (!EQ (hooks
, Qunbound
))
874 for (; CONSP (hooks
); hooks
= Fcdr (hooks
))
875 call1 (Fcar (hooks
), selection_symbol
);
876 #if 0 /* See above */
877 redisplay_preserve_echo_area ();
880 XCONS (rest
)->cdr
= Fcdr (XCONS (rest
)->cdr
);
885 /* Nonzero if any properties for DISPLAY and WINDOW
886 are on the list of what we are waiting for. */
889 waiting_for_other_props_on_window (display
, window
)
893 struct prop_location
*rest
= property_change_wait_list
;
895 if (rest
->display
== display
&& rest
->window
== window
)
902 /* Add an entry to the list of property changes we are waiting for.
903 DISPLAY, WINDOW, PROPERTY, STATE describe what we will wait for.
904 The return value is a number that uniquely identifies
905 this awaited property change. */
907 static struct prop_location
*
908 expect_property_change (display
, window
, property
, state
)
914 struct prop_location
*pl
915 = (struct prop_location
*) xmalloc (sizeof (struct prop_location
));
916 pl
->identifier
= ++prop_location_identifier
;
917 pl
->display
= display
;
919 pl
->property
= property
;
920 pl
->desired_state
= state
;
921 pl
->next
= property_change_wait_list
;
923 property_change_wait_list
= pl
;
927 /* Delete an entry from the list of property changes we are waiting for.
928 IDENTIFIER is the number that uniquely identifies the entry. */
931 unexpect_property_change (location
)
932 struct prop_location
*location
;
934 struct prop_location
*prev
= 0, *rest
= property_change_wait_list
;
937 if (rest
== location
)
940 prev
->next
= rest
->next
;
942 property_change_wait_list
= rest
->next
;
951 /* Remove the property change expectation element for IDENTIFIER. */
954 wait_for_property_change_unwind (identifierval
)
955 Lisp_Object identifierval
;
957 unexpect_property_change ((struct prop_location
*)
958 (XFASTINT (XCONS (identifierval
)->car
) << 16
959 | XFASTINT (XCONS (identifierval
)->cdr
)));
963 /* Actually wait for a property change.
964 IDENTIFIER should be the value that expect_property_change returned. */
967 wait_for_property_change (location
)
968 struct prop_location
*location
;
971 int count
= specpdl_ptr
- specpdl
;
974 tem
= Fcons (Qnil
, Qnil
);
975 XSETFASTINT (XCONS (tem
)->car
, (EMACS_UINT
)location
>> 16);
976 XSETFASTINT (XCONS (tem
)->cdr
, (EMACS_UINT
)location
& 0xffff);
978 /* Make sure to do unexpect_property_change if we quit or err. */
979 record_unwind_protect (wait_for_property_change_unwind
, tem
);
981 XCONS (property_change_reply
)->car
= Qnil
;
983 property_change_reply_object
= location
;
984 /* If the event we are waiting for arrives beyond here, it will set
985 property_change_reply, because property_change_reply_object says so. */
986 if (! location
->arrived
)
988 secs
= x_selection_timeout
/ 1000;
989 usecs
= (x_selection_timeout
% 1000) * 1000;
990 wait_reading_process_input (secs
, usecs
, property_change_reply
, 0);
992 if (NILP (XCONS (property_change_reply
)->car
))
993 error ("Timed out waiting for property-notify event");
996 unbind_to (count
, Qnil
);
999 /* Called from XTread_socket in response to a PropertyNotify event. */
1002 x_handle_property_notify (event
)
1003 XPropertyEvent
*event
;
1005 struct prop_location
*prev
= 0, *rest
= property_change_wait_list
;
1008 if (rest
->property
== event
->atom
1009 && rest
->window
== event
->window
1010 && rest
->display
== event
->display
1011 && rest
->desired_state
== event
->state
)
1014 fprintf (stderr
, "Saw expected prop-%s on %s\n",
1015 (event
->state
== PropertyDelete
? "delete" : "change"),
1016 (char *) XSYMBOL (x_atom_to_symbol (dpyinfo
, event
->display
,
1023 /* If this is the one wait_for_property_change is waiting for,
1024 tell it to wake up. */
1025 if (rest
== property_change_reply_object
)
1026 XCONS (property_change_reply
)->car
= Qt
;
1029 prev
->next
= rest
->next
;
1031 property_change_wait_list
= rest
->next
;
1039 fprintf (stderr
, "Saw UNexpected prop-%s on %s\n",
1040 (event
->state
== PropertyDelete
? "delete" : "change"),
1041 (char *) XSYMBOL (x_atom_to_symbol (dpyinfo
,
1042 event
->display
, event
->atom
))
1049 #if 0 /* #### MULTIPLE doesn't work yet */
1052 fetch_multiple_target (event
)
1053 XSelectionRequestEvent
*event
;
1055 Display
*display
= event
->display
;
1056 Window window
= event
->requestor
;
1057 Atom target
= event
->target
;
1058 Atom selection_atom
= event
->selection
;
1063 x_get_window_property_as_lisp_data (display
, window
, target
,
1064 QMULTIPLE
, selection_atom
));
1068 copy_multiple_data (obj
)
1075 return Fcons (XCONS (obj
)->car
, copy_multiple_data (XCONS (obj
)->cdr
));
1077 CHECK_VECTOR (obj
, 0);
1078 vec
= Fmake_vector (size
= XVECTOR (obj
)->size
, Qnil
);
1079 for (i
= 0; i
< size
; i
++)
1081 Lisp_Object vec2
= XVECTOR (obj
)->contents
[i
];
1082 CHECK_VECTOR (vec2
, 0);
1083 if (XVECTOR (vec2
)->size
!= 2)
1084 /* ??? Confusing error message */
1085 Fsignal (Qerror
, Fcons (build_string ("vectors must be of length 2"),
1086 Fcons (vec2
, Qnil
)));
1087 XVECTOR (vec
)->contents
[i
] = Fmake_vector (2, Qnil
);
1088 XVECTOR (XVECTOR (vec
)->contents
[i
])->contents
[0]
1089 = XVECTOR (vec2
)->contents
[0];
1090 XVECTOR (XVECTOR (vec
)->contents
[i
])->contents
[1]
1091 = XVECTOR (vec2
)->contents
[1];
1099 /* Variables for communication with x_handle_selection_notify. */
1100 static Atom reading_which_selection
;
1101 static Lisp_Object reading_selection_reply
;
1102 static Window reading_selection_window
;
1104 /* Do protocol to read selection-data from the server.
1105 Converts this to Lisp data and returns it. */
1108 x_get_foreign_selection (selection_symbol
, target_type
)
1109 Lisp_Object selection_symbol
, target_type
;
1111 Window requestor_window
= FRAME_X_WINDOW (selected_frame
);
1112 Display
*display
= FRAME_X_DISPLAY (selected_frame
);
1113 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
1114 Time requestor_time
= last_event_timestamp
;
1115 Atom target_property
= dpyinfo
->Xatom_EMACS_TMP
;
1116 Atom selection_atom
= symbol_to_x_atom (dpyinfo
, display
, selection_symbol
);
1122 if (CONSP (target_type
))
1123 type_atom
= symbol_to_x_atom (dpyinfo
, display
, XCONS (target_type
)->car
);
1125 type_atom
= symbol_to_x_atom (dpyinfo
, display
, target_type
);
1128 count
= x_catch_errors (display
);
1129 XConvertSelection (display
, selection_atom
, type_atom
, target_property
,
1130 requestor_window
, requestor_time
);
1133 /* Prepare to block until the reply has been read. */
1134 reading_selection_window
= requestor_window
;
1135 reading_which_selection
= selection_atom
;
1136 XCONS (reading_selection_reply
)->car
= Qnil
;
1138 frame
= some_frame_on_display (dpyinfo
);
1140 /* If the display no longer has frames, we can't expect
1141 to get many more selection requests from it, so don't
1142 bother trying to queue them. */
1145 x_start_queuing_selection_requests (display
);
1147 record_unwind_protect (queue_selection_requests_unwind
,
1152 /* This allows quits. Also, don't wait forever. */
1153 secs
= x_selection_timeout
/ 1000;
1154 usecs
= (x_selection_timeout
% 1000) * 1000;
1155 wait_reading_process_input (secs
, usecs
, reading_selection_reply
, 0);
1158 x_check_errors (display
, "Cannot get selection: %s");
1159 x_uncatch_errors (display
, count
);
1162 if (NILP (XCONS (reading_selection_reply
)->car
))
1163 error ("Timed out waiting for reply from selection owner");
1164 if (EQ (XCONS (reading_selection_reply
)->car
, Qlambda
))
1165 error ("No `%s' selection", XSYMBOL (selection_symbol
)->name
->data
);
1167 /* Otherwise, the selection is waiting for us on the requested property. */
1169 x_get_window_property_as_lisp_data (display
, requestor_window
,
1170 target_property
, target_type
,
1174 /* Subroutines of x_get_window_property_as_lisp_data */
1176 /* Use xfree, not XFree, to free the data obtained with this function. */
1179 x_get_window_property (display
, window
, property
, data_ret
, bytes_ret
,
1180 actual_type_ret
, actual_format_ret
, actual_size_ret
,
1185 unsigned char **data_ret
;
1187 Atom
*actual_type_ret
;
1188 int *actual_format_ret
;
1189 unsigned long *actual_size_ret
;
1193 unsigned long bytes_remaining
;
1195 unsigned char *tmp_data
= 0;
1197 int buffer_size
= SELECTION_QUANTUM (display
);
1198 if (buffer_size
> MAX_SELECTION_QUANTUM
) buffer_size
= MAX_SELECTION_QUANTUM
;
1201 /* First probe the thing to find out how big it is. */
1202 result
= XGetWindowProperty (display
, window
, property
,
1203 0L, 0L, False
, AnyPropertyType
,
1204 actual_type_ret
, actual_format_ret
,
1206 &bytes_remaining
, &tmp_data
);
1207 if (result
!= Success
)
1214 /* This was allocated by Xlib, so use XFree. */
1215 XFree ((char *) tmp_data
);
1217 if (*actual_type_ret
== None
|| *actual_format_ret
== 0)
1223 total_size
= bytes_remaining
+ 1;
1224 *data_ret
= (unsigned char *) xmalloc (total_size
);
1226 /* Now read, until we've gotten it all. */
1227 while (bytes_remaining
)
1230 int last
= bytes_remaining
;
1233 = XGetWindowProperty (display
, window
, property
,
1234 (long)offset
/4, (long)buffer_size
/4,
1237 actual_type_ret
, actual_format_ret
,
1238 actual_size_ret
, &bytes_remaining
, &tmp_data
);
1240 fprintf (stderr
, "<< read %d\n", last
-bytes_remaining
);
1242 /* If this doesn't return Success at this point, it means that
1243 some clod deleted the selection while we were in the midst of
1244 reading it. Deal with that, I guess....
1246 if (result
!= Success
) break;
1247 *actual_size_ret
*= *actual_format_ret
/ 8;
1248 bcopy (tmp_data
, (*data_ret
) + offset
, *actual_size_ret
);
1249 offset
+= *actual_size_ret
;
1250 /* This was allocated by Xlib, so use XFree. */
1251 XFree ((char *) tmp_data
);
1256 *bytes_ret
= offset
;
1259 /* Use xfree, not XFree, to free the data obtained with this function. */
1262 receive_incremental_selection (display
, window
, property
, target_type
,
1263 min_size_bytes
, data_ret
, size_bytes_ret
,
1264 type_ret
, format_ret
, size_ret
)
1268 Lisp_Object target_type
; /* for error messages only */
1269 unsigned int min_size_bytes
;
1270 unsigned char **data_ret
;
1271 int *size_bytes_ret
;
1273 unsigned long *size_ret
;
1277 struct prop_location
*wait_object
;
1278 *size_bytes_ret
= min_size_bytes
;
1279 *data_ret
= (unsigned char *) xmalloc (*size_bytes_ret
);
1281 fprintf (stderr
, "\nread INCR %d\n", min_size_bytes
);
1284 /* At this point, we have read an INCR property.
1285 Delete the property to ack it.
1286 (But first, prepare to receive the next event in this handshake.)
1288 Now, we must loop, waiting for the sending window to put a value on
1289 that property, then reading the property, then deleting it to ack.
1290 We are done when the sender places a property of length 0.
1293 XSelectInput (display
, window
, STANDARD_EVENT_SET
| PropertyChangeMask
);
1294 XDeleteProperty (display
, window
, property
);
1295 wait_object
= expect_property_change (display
, window
, property
,
1302 unsigned char *tmp_data
;
1304 wait_for_property_change (wait_object
);
1305 /* expect it again immediately, because x_get_window_property may
1306 .. no it won't, I don't get it.
1307 .. Ok, I get it now, the Xt code that implements INCR is broken.
1309 x_get_window_property (display
, window
, property
,
1310 &tmp_data
, &tmp_size_bytes
,
1311 type_ret
, format_ret
, size_ret
, 1);
1313 if (tmp_size_bytes
== 0) /* we're done */
1316 fprintf (stderr
, " read INCR done\n");
1318 if (! waiting_for_other_props_on_window (display
, window
))
1319 XSelectInput (display
, window
, STANDARD_EVENT_SET
);
1320 unexpect_property_change (wait_object
);
1321 /* Use xfree, not XFree, because x_get_window_property
1322 calls xmalloc itself. */
1323 if (tmp_data
) xfree (tmp_data
);
1328 XDeleteProperty (display
, window
, property
);
1329 wait_object
= expect_property_change (display
, window
, property
,
1335 fprintf (stderr
, " read INCR %d\n", tmp_size_bytes
);
1337 if (*size_bytes_ret
< offset
+ tmp_size_bytes
)
1340 fprintf (stderr
, " read INCR realloc %d -> %d\n",
1341 *size_bytes_ret
, offset
+ tmp_size_bytes
);
1343 *size_bytes_ret
= offset
+ tmp_size_bytes
;
1344 *data_ret
= (unsigned char *) xrealloc (*data_ret
, *size_bytes_ret
);
1346 bcopy (tmp_data
, (*data_ret
) + offset
, tmp_size_bytes
);
1347 offset
+= tmp_size_bytes
;
1348 /* Use xfree, not XFree, because x_get_window_property
1349 calls xmalloc itself. */
1354 /* Once a requested selection is "ready" (we got a SelectionNotify event),
1355 fetch value from property PROPERTY of X window WINDOW on display DISPLAY.
1356 TARGET_TYPE and SELECTION_ATOM are used in error message if this fails. */
1359 x_get_window_property_as_lisp_data (display
, window
, property
, target_type
,
1364 Lisp_Object target_type
; /* for error messages only */
1365 Atom selection_atom
; /* for error messages only */
1369 unsigned long actual_size
;
1370 unsigned char *data
= 0;
1373 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1375 x_get_window_property (display
, window
, property
, &data
, &bytes
,
1376 &actual_type
, &actual_format
, &actual_size
, 1);
1379 int there_is_a_selection_owner
;
1381 there_is_a_selection_owner
1382 = XGetSelectionOwner (display
, selection_atom
);
1385 there_is_a_selection_owner
1386 ? Fcons (build_string ("selection owner couldn't convert"),
1388 ? Fcons (target_type
,
1389 Fcons (x_atom_to_symbol (dpyinfo
, display
,
1392 : Fcons (target_type
, Qnil
))
1393 : Fcons (build_string ("no selection"),
1394 Fcons (x_atom_to_symbol (dpyinfo
, display
,
1399 if (actual_type
== dpyinfo
->Xatom_INCR
)
1401 /* That wasn't really the data, just the beginning. */
1403 unsigned int min_size_bytes
= * ((unsigned int *) data
);
1405 /* Use xfree, not XFree, because x_get_window_property
1406 calls xmalloc itself. */
1407 xfree ((char *) data
);
1409 receive_incremental_selection (display
, window
, property
, target_type
,
1410 min_size_bytes
, &data
, &bytes
,
1411 &actual_type
, &actual_format
,
1416 XDeleteProperty (display
, window
, property
);
1420 /* It's been read. Now convert it to a lisp object in some semi-rational
1422 val
= selection_data_to_lisp_data (display
, data
, bytes
,
1423 actual_type
, actual_format
);
1425 /* Use xfree, not XFree, because x_get_window_property
1426 calls xmalloc itself. */
1427 xfree ((char *) data
);
1431 /* These functions convert from the selection data read from the server into
1432 something that we can use from Lisp, and vice versa.
1434 Type: Format: Size: Lisp Type:
1435 ----- ------- ----- -----------
1438 ATOM 32 > 1 Vector of Symbols
1440 * 16 > 1 Vector of Integers
1441 * 32 1 if <=16 bits: Integer
1442 if > 16 bits: Cons of top16, bot16
1443 * 32 > 1 Vector of the above
1445 When converting a Lisp number to C, it is assumed to be of format 16 if
1446 it is an integer, and of format 32 if it is a cons of two integers.
1448 When converting a vector of numbers from Lisp to C, it is assumed to be
1449 of format 16 if every element in the vector is an integer, and is assumed
1450 to be of format 32 if any element is a cons of two integers.
1452 When converting an object to C, it may be of the form (SYMBOL . <data>)
1453 where SYMBOL is what we should claim that the type is. Format and
1454 representation are as above. */
1459 selection_data_to_lisp_data (display
, data
, size
, type
, format
)
1461 unsigned char *data
;
1465 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1467 if (type
== dpyinfo
->Xatom_NULL
)
1470 /* Convert any 8-bit data to a string, for compactness. */
1471 else if (format
== 8)
1474 int require_encoding
= 0;
1480 ! NILP (buffer_defaults
.enable_multibyte_characters
)
1484 /* If TYPE is `TEXT' or `COMPOUND_TEXT', we should decode
1485 DATA to Emacs internal format because DATA may be encoded
1486 in compound text format. In addtion, if TYPE is `STRING'
1487 and DATA contains any 8-bit Latin-1 code, we should also
1489 if (type
== dpyinfo
->Xatom_TEXT
1490 || type
== dpyinfo
->Xatom_COMPOUND_TEXT
)
1491 require_encoding
= 1;
1492 else if (type
== XA_STRING
)
1495 for (i
= 0; i
< size
; i
++)
1497 if (data
[i
] >= 0x80)
1499 require_encoding
= 1;
1505 if (!require_encoding
)
1507 str
= make_unibyte_string ((char *) data
, size
);
1508 Vlast_coding_system_used
= Qraw_text
;
1514 struct coding_system coding
;
1516 if (NILP (Vnext_selection_coding_system
))
1517 Vnext_selection_coding_system
= Vselection_coding_system
;
1519 (Fcheck_coding_system(Vnext_selection_coding_system
), &coding
);
1520 Vnext_selection_coding_system
= Qnil
;
1521 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
1522 bufsize
= decoding_buffer_size (&coding
, size
);
1523 buf
= (unsigned char *) xmalloc (bufsize
);
1524 decode_coding (&coding
, data
, buf
, size
, bufsize
);
1525 size
= (coding
.fake_multibyte
1526 ? multibyte_chars_in_text (buf
, coding
.produced
)
1527 : coding
.produced_char
);
1528 str
= make_string_from_bytes ((char *) buf
, size
, coding
.produced
);
1530 Vlast_coding_system_used
= coding
.symbol
;
1534 /* Convert a single atom to a Lisp_Symbol. Convert a set of atoms to
1535 a vector of symbols.
1537 else if (type
== XA_ATOM
)
1540 if (size
== sizeof (Atom
))
1541 return x_atom_to_symbol (dpyinfo
, display
, *((Atom
*) data
));
1544 Lisp_Object v
= Fmake_vector (make_number (size
/ sizeof (Atom
)),
1546 for (i
= 0; i
< size
/ sizeof (Atom
); i
++)
1547 Faset (v
, make_number (i
),
1548 x_atom_to_symbol (dpyinfo
, display
, ((Atom
*) data
) [i
]));
1553 /* Convert a single 16 or small 32 bit number to a Lisp_Int.
1554 If the number is > 16 bits, convert it to a cons of integers,
1555 16 bits in each half.
1557 else if (format
== 32 && size
== sizeof (long))
1558 return long_to_cons (((unsigned long *) data
) [0]);
1559 else if (format
== 16 && size
== sizeof (short))
1560 return make_number ((int) (((unsigned short *) data
) [0]));
1562 /* Convert any other kind of data to a vector of numbers, represented
1563 as above (as an integer, or a cons of two 16 bit integers.)
1565 else if (format
== 16)
1569 v
= Fmake_vector (make_number (size
/ 2), make_number (0));
1570 for (i
= 0; i
< size
/ 2; i
++)
1572 int j
= (int) ((unsigned short *) data
) [i
];
1573 Faset (v
, make_number (i
), make_number (j
));
1580 Lisp_Object v
= Fmake_vector (make_number (size
/ 4), make_number (0));
1581 for (i
= 0; i
< size
/ 4; i
++)
1583 unsigned long j
= ((unsigned long *) data
) [i
];
1584 Faset (v
, make_number (i
), long_to_cons (j
));
1591 /* Use xfree, not XFree, to free the data obtained with this function. */
1594 lisp_data_to_selection_data (display
, obj
,
1595 data_ret
, type_ret
, size_ret
,
1596 format_ret
, nofree_ret
)
1599 unsigned char **data_ret
;
1601 unsigned int *size_ret
;
1605 Lisp_Object type
= Qnil
;
1606 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1610 if (CONSP (obj
) && SYMBOLP (XCONS (obj
)->car
))
1612 type
= XCONS (obj
)->car
;
1613 obj
= XCONS (obj
)->cdr
;
1614 if (CONSP (obj
) && NILP (XCONS (obj
)->cdr
))
1615 obj
= XCONS (obj
)->car
;
1618 if (EQ (obj
, QNULL
) || (EQ (type
, QNULL
)))
1619 { /* This is not the same as declining */
1625 else if (STRINGP (obj
))
1627 /* Since we are now handling multilingual text, we must consider
1628 sending back compound text. */
1629 int charsets
[MAX_CHARSET
+ 1];
1633 *size_ret
= STRING_BYTES (XSTRING (obj
));
1634 *data_ret
= XSTRING (obj
)->data
;
1635 bzero (charsets
, (MAX_CHARSET
+ 1) * sizeof (int));
1636 num
= ((*size_ret
<= 1 /* Check the possibility of short cut. */
1637 || !STRING_MULTIBYTE (obj
)
1638 || *size_ret
== XSTRING (obj
)->size
)
1640 : find_charset_in_str (*data_ret
, *size_ret
, charsets
, Qnil
, 0, 1));
1642 if (!num
|| (num
== 1 && charsets
[CHARSET_ASCII
]))
1644 /* No multibyte character in OBJ. We need not encode it. */
1646 if (NILP (type
)) type
= QSTRING
;
1647 Vlast_coding_system_used
= Qraw_text
;
1651 /* We must encode contents of OBJ to compound text format.
1652 The format is compatible with what the target `STRING'
1653 expects if OBJ contains only ASCII and Latin-1
1657 struct coding_system coding
;
1659 if (NILP (Vnext_selection_coding_system
))
1660 Vnext_selection_coding_system
= Vselection_coding_system
;
1662 (Fcheck_coding_system (Vnext_selection_coding_system
), &coding
);
1663 Vnext_selection_coding_system
= Qnil
;
1664 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
1665 bufsize
= encoding_buffer_size (&coding
, *size_ret
);
1666 buf
= (unsigned char *) xmalloc (bufsize
);
1667 encode_coding (&coding
, *data_ret
, buf
, *size_ret
, bufsize
);
1668 *size_ret
= coding
.produced
;
1670 if (charsets
[charset_latin_iso8859_1
]
1671 && (num
== 1 || (num
== 2 && charsets
[CHARSET_ASCII
])))
1673 /* Ok, we can return it as `STRING'. */
1674 if (NILP (type
)) type
= QSTRING
;
1678 /* We must return it as `COMPOUND_TEXT'. */
1679 if (NILP (type
)) type
= QCOMPOUND_TEXT
;
1681 Vlast_coding_system_used
= coding
.symbol
;
1684 else if (SYMBOLP (obj
))
1688 *data_ret
= (unsigned char *) xmalloc (sizeof (Atom
) + 1);
1689 (*data_ret
) [sizeof (Atom
)] = 0;
1690 (*(Atom
**) data_ret
) [0] = symbol_to_x_atom (dpyinfo
, display
, obj
);
1691 if (NILP (type
)) type
= QATOM
;
1693 else if (INTEGERP (obj
)
1694 && XINT (obj
) < 0xFFFF
1695 && XINT (obj
) > -0xFFFF)
1699 *data_ret
= (unsigned char *) xmalloc (sizeof (short) + 1);
1700 (*data_ret
) [sizeof (short)] = 0;
1701 (*(short **) data_ret
) [0] = (short) XINT (obj
);
1702 if (NILP (type
)) type
= QINTEGER
;
1704 else if (INTEGERP (obj
)
1705 || (CONSP (obj
) && INTEGERP (XCONS (obj
)->car
)
1706 && (INTEGERP (XCONS (obj
)->cdr
)
1707 || (CONSP (XCONS (obj
)->cdr
)
1708 && INTEGERP (XCONS (XCONS (obj
)->cdr
)->car
)))))
1712 *data_ret
= (unsigned char *) xmalloc (sizeof (long) + 1);
1713 (*data_ret
) [sizeof (long)] = 0;
1714 (*(unsigned long **) data_ret
) [0] = cons_to_long (obj
);
1715 if (NILP (type
)) type
= QINTEGER
;
1717 else if (VECTORP (obj
))
1719 /* Lisp_Vectors may represent a set of ATOMs;
1720 a set of 16 or 32 bit INTEGERs;
1721 or a set of ATOM_PAIRs (represented as [[A1 A2] [A3 A4] ...]
1725 if (SYMBOLP (XVECTOR (obj
)->contents
[0]))
1726 /* This vector is an ATOM set */
1728 if (NILP (type
)) type
= QATOM
;
1729 *size_ret
= XVECTOR (obj
)->size
;
1731 *data_ret
= (unsigned char *) xmalloc ((*size_ret
) * sizeof (Atom
));
1732 for (i
= 0; i
< *size_ret
; i
++)
1733 if (SYMBOLP (XVECTOR (obj
)->contents
[i
]))
1734 (*(Atom
**) data_ret
) [i
]
1735 = symbol_to_x_atom (dpyinfo
, display
, XVECTOR (obj
)->contents
[i
]);
1737 Fsignal (Qerror
, /* Qselection_error */
1739 ("all elements of selection vector must have same type"),
1740 Fcons (obj
, Qnil
)));
1742 #if 0 /* #### MULTIPLE doesn't work yet */
1743 else if (VECTORP (XVECTOR (obj
)->contents
[0]))
1744 /* This vector is an ATOM_PAIR set */
1746 if (NILP (type
)) type
= QATOM_PAIR
;
1747 *size_ret
= XVECTOR (obj
)->size
;
1749 *data_ret
= (unsigned char *)
1750 xmalloc ((*size_ret
) * sizeof (Atom
) * 2);
1751 for (i
= 0; i
< *size_ret
; i
++)
1752 if (VECTORP (XVECTOR (obj
)->contents
[i
]))
1754 Lisp_Object pair
= XVECTOR (obj
)->contents
[i
];
1755 if (XVECTOR (pair
)->size
!= 2)
1758 ("elements of the vector must be vectors of exactly two elements"),
1759 Fcons (pair
, Qnil
)));
1761 (*(Atom
**) data_ret
) [i
* 2]
1762 = symbol_to_x_atom (dpyinfo
, display
,
1763 XVECTOR (pair
)->contents
[0]);
1764 (*(Atom
**) data_ret
) [(i
* 2) + 1]
1765 = symbol_to_x_atom (dpyinfo
, display
,
1766 XVECTOR (pair
)->contents
[1]);
1771 ("all elements of the vector must be of the same type"),
1772 Fcons (obj
, Qnil
)));
1777 /* This vector is an INTEGER set, or something like it */
1779 *size_ret
= XVECTOR (obj
)->size
;
1780 if (NILP (type
)) type
= QINTEGER
;
1782 for (i
= 0; i
< *size_ret
; i
++)
1783 if (CONSP (XVECTOR (obj
)->contents
[i
]))
1785 else if (!INTEGERP (XVECTOR (obj
)->contents
[i
]))
1786 Fsignal (Qerror
, /* Qselection_error */
1788 ("elements of selection vector must be integers or conses of integers"),
1789 Fcons (obj
, Qnil
)));
1791 *data_ret
= (unsigned char *) xmalloc (*size_ret
* (*format_ret
/8));
1792 for (i
= 0; i
< *size_ret
; i
++)
1793 if (*format_ret
== 32)
1794 (*((unsigned long **) data_ret
)) [i
]
1795 = cons_to_long (XVECTOR (obj
)->contents
[i
]);
1797 (*((unsigned short **) data_ret
)) [i
]
1798 = (unsigned short) cons_to_long (XVECTOR (obj
)->contents
[i
]);
1802 Fsignal (Qerror
, /* Qselection_error */
1803 Fcons (build_string ("unrecognised selection data"),
1804 Fcons (obj
, Qnil
)));
1806 *type_ret
= symbol_to_x_atom (dpyinfo
, display
, type
);
1810 clean_local_selection_data (obj
)
1814 && INTEGERP (XCONS (obj
)->car
)
1815 && CONSP (XCONS (obj
)->cdr
)
1816 && INTEGERP (XCONS (XCONS (obj
)->cdr
)->car
)
1817 && NILP (XCONS (XCONS (obj
)->cdr
)->cdr
))
1818 obj
= Fcons (XCONS (obj
)->car
, XCONS (obj
)->cdr
);
1821 && INTEGERP (XCONS (obj
)->car
)
1822 && INTEGERP (XCONS (obj
)->cdr
))
1824 if (XINT (XCONS (obj
)->car
) == 0)
1825 return XCONS (obj
)->cdr
;
1826 if (XINT (XCONS (obj
)->car
) == -1)
1827 return make_number (- XINT (XCONS (obj
)->cdr
));
1832 int size
= XVECTOR (obj
)->size
;
1835 return clean_local_selection_data (XVECTOR (obj
)->contents
[0]);
1836 copy
= Fmake_vector (make_number (size
), Qnil
);
1837 for (i
= 0; i
< size
; i
++)
1838 XVECTOR (copy
)->contents
[i
]
1839 = clean_local_selection_data (XVECTOR (obj
)->contents
[i
]);
1845 /* Called from XTread_socket to handle SelectionNotify events.
1846 If it's the selection we are waiting for, stop waiting
1847 by setting the car of reading_selection_reply to non-nil.
1848 We store t there if the reply is successful, lambda if not. */
1851 x_handle_selection_notify (event
)
1852 XSelectionEvent
*event
;
1854 if (event
->requestor
!= reading_selection_window
)
1856 if (event
->selection
!= reading_which_selection
)
1859 XCONS (reading_selection_reply
)->car
1860 = (event
->property
!= 0 ? Qt
: Qlambda
);
1864 DEFUN ("x-own-selection-internal", Fx_own_selection_internal
,
1865 Sx_own_selection_internal
, 2, 2, 0,
1866 "Assert an X selection of the given TYPE with the given VALUE.\n\
1867 TYPE is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1868 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1869 VALUE is typically a string, or a cons of two markers, but may be\n\
1870 anything that the functions on `selection-converter-alist' know about.")
1871 (selection_name
, selection_value
)
1872 Lisp_Object selection_name
, selection_value
;
1875 CHECK_SYMBOL (selection_name
, 0);
1876 if (NILP (selection_value
)) error ("selection-value may not be nil");
1877 x_own_selection (selection_name
, selection_value
);
1878 return selection_value
;
1882 /* Request the selection value from the owner. If we are the owner,
1883 simply return our selection value. If we are not the owner, this
1884 will block until all of the data has arrived. */
1886 DEFUN ("x-get-selection-internal", Fx_get_selection_internal
,
1887 Sx_get_selection_internal
, 2, 2, 0,
1888 "Return text selected from some X window.\n\
1889 SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1890 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1891 TYPE is the type of data desired, typically `STRING'.")
1892 (selection_symbol
, target_type
)
1893 Lisp_Object selection_symbol
, target_type
;
1895 Lisp_Object val
= Qnil
;
1896 struct gcpro gcpro1
, gcpro2
;
1897 GCPRO2 (target_type
, val
); /* we store newly consed data into these */
1899 CHECK_SYMBOL (selection_symbol
, 0);
1901 #if 0 /* #### MULTIPLE doesn't work yet */
1902 if (CONSP (target_type
)
1903 && XCONS (target_type
)->car
== QMULTIPLE
)
1905 CHECK_VECTOR (XCONS (target_type
)->cdr
, 0);
1906 /* So we don't destructively modify this... */
1907 target_type
= copy_multiple_data (target_type
);
1911 CHECK_SYMBOL (target_type
, 0);
1913 val
= x_get_local_selection (selection_symbol
, target_type
);
1917 val
= x_get_foreign_selection (selection_symbol
, target_type
);
1922 && SYMBOLP (XCONS (val
)->car
))
1924 val
= XCONS (val
)->cdr
;
1925 if (CONSP (val
) && NILP (XCONS (val
)->cdr
))
1926 val
= XCONS (val
)->car
;
1928 val
= clean_local_selection_data (val
);
1934 DEFUN ("x-disown-selection-internal", Fx_disown_selection_internal
,
1935 Sx_disown_selection_internal
, 1, 2, 0,
1936 "If we own the selection SELECTION, disown it.\n\
1937 Disowning it means there is no such selection.")
1939 Lisp_Object selection
;
1943 Atom selection_atom
;
1944 struct selection_input_event event
;
1946 struct x_display_info
*dpyinfo
;
1949 display
= FRAME_X_DISPLAY (selected_frame
);
1950 dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
1951 CHECK_SYMBOL (selection
, 0);
1953 timestamp
= last_event_timestamp
;
1955 timestamp
= cons_to_long (time
);
1957 if (NILP (assq_no_quit (selection
, Vselection_alist
)))
1958 return Qnil
; /* Don't disown the selection when we're not the owner. */
1960 selection_atom
= symbol_to_x_atom (dpyinfo
, display
, selection
);
1963 XSetSelectionOwner (display
, selection_atom
, None
, timestamp
);
1966 /* It doesn't seem to be guaranteed that a SelectionClear event will be
1967 generated for a window which owns the selection when that window sets
1968 the selection owner to None. The NCD server does, the MIT Sun4 server
1969 doesn't. So we synthesize one; this means we might get two, but
1970 that's ok, because the second one won't have any effect. */
1971 SELECTION_EVENT_DISPLAY (&event
) = display
;
1972 SELECTION_EVENT_SELECTION (&event
) = selection_atom
;
1973 SELECTION_EVENT_TIME (&event
) = timestamp
;
1974 x_handle_selection_clear ((struct input_event
*) &event
);
1979 /* Get rid of all the selections in buffer BUFFER.
1980 This is used when we kill a buffer. */
1983 x_disown_buffer_selections (buffer
)
1987 struct buffer
*buf
= XBUFFER (buffer
);
1989 for (tail
= Vselection_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1991 Lisp_Object elt
, value
;
1992 elt
= XCONS (tail
)->car
;
1993 value
= XCONS (elt
)->cdr
;
1994 if (CONSP (value
) && MARKERP (XCONS (value
)->car
)
1995 && XMARKER (XCONS (value
)->car
)->buffer
== buf
)
1996 Fx_disown_selection_internal (XCONS (elt
)->car
, Qnil
);
2000 DEFUN ("x-selection-owner-p", Fx_selection_owner_p
, Sx_selection_owner_p
,
2002 "Whether the current Emacs process owns the given X Selection.\n\
2003 The arg should be the name of the selection in question, typically one of\n\
2004 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
2005 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
2006 For convenience, the symbol nil is the same as `PRIMARY',\n\
2007 and t is the same as `SECONDARY'.)")
2009 Lisp_Object selection
;
2012 CHECK_SYMBOL (selection
, 0);
2013 if (EQ (selection
, Qnil
)) selection
= QPRIMARY
;
2014 if (EQ (selection
, Qt
)) selection
= QSECONDARY
;
2016 if (NILP (Fassq (selection
, Vselection_alist
)))
2021 DEFUN ("x-selection-exists-p", Fx_selection_exists_p
, Sx_selection_exists_p
,
2023 "Whether there is an owner for the given X Selection.\n\
2024 The arg should be the name of the selection in question, typically one of\n\
2025 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
2026 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
2027 For convenience, the symbol nil is the same as `PRIMARY',\n\
2028 and t is the same as `SECONDARY'.)")
2030 Lisp_Object selection
;
2036 /* It should be safe to call this before we have an X frame. */
2037 if (! FRAME_X_P (selected_frame
))
2040 dpy
= FRAME_X_DISPLAY (selected_frame
);
2041 CHECK_SYMBOL (selection
, 0);
2042 if (!NILP (Fx_selection_owner_p (selection
)))
2044 if (EQ (selection
, Qnil
)) selection
= QPRIMARY
;
2045 if (EQ (selection
, Qt
)) selection
= QSECONDARY
;
2046 atom
= symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame
),
2051 owner
= XGetSelectionOwner (dpy
, atom
);
2053 return (owner
? Qt
: Qnil
);
2057 #ifdef CUT_BUFFER_SUPPORT
2059 /* Ensure that all 8 cut buffers exist. ICCCM says we gotta... */
2061 initialize_cut_buffers (display
, window
)
2065 unsigned char *data
= (unsigned char *) "";
2067 #define FROB(atom) XChangeProperty (display, window, atom, XA_STRING, 8, \
2068 PropModeAppend, data, 0)
2069 FROB (XA_CUT_BUFFER0
);
2070 FROB (XA_CUT_BUFFER1
);
2071 FROB (XA_CUT_BUFFER2
);
2072 FROB (XA_CUT_BUFFER3
);
2073 FROB (XA_CUT_BUFFER4
);
2074 FROB (XA_CUT_BUFFER5
);
2075 FROB (XA_CUT_BUFFER6
);
2076 FROB (XA_CUT_BUFFER7
);
2082 #define CHECK_CUT_BUFFER(symbol,n) \
2083 { CHECK_SYMBOL ((symbol), (n)); \
2084 if (!EQ((symbol), QCUT_BUFFER0) && !EQ((symbol), QCUT_BUFFER1) \
2085 && !EQ((symbol), QCUT_BUFFER2) && !EQ((symbol), QCUT_BUFFER3) \
2086 && !EQ((symbol), QCUT_BUFFER4) && !EQ((symbol), QCUT_BUFFER5) \
2087 && !EQ((symbol), QCUT_BUFFER6) && !EQ((symbol), QCUT_BUFFER7)) \
2089 Fcons (build_string ("doesn't name a cut buffer"), \
2090 Fcons ((symbol), Qnil))); \
2093 DEFUN ("x-get-cut-buffer-internal", Fx_get_cut_buffer_internal
,
2094 Sx_get_cut_buffer_internal
, 1, 1, 0,
2095 "Returns the value of the named cut buffer (typically CUT_BUFFER0).")
2101 unsigned char *data
;
2108 struct x_display_info
*dpyinfo
;
2111 display
= FRAME_X_DISPLAY (selected_frame
);
2112 dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
2113 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2114 CHECK_CUT_BUFFER (buffer
, 0);
2115 buffer_atom
= symbol_to_x_atom (dpyinfo
, display
, buffer
);
2117 x_get_window_property (display
, window
, buffer_atom
, &data
, &bytes
,
2118 &type
, &format
, &size
, 0);
2119 if (!data
|| !format
)
2122 if (format
!= 8 || type
!= XA_STRING
)
2124 Fcons (build_string ("cut buffer doesn't contain 8-bit data"),
2125 Fcons (x_atom_to_symbol (dpyinfo
, display
, type
),
2126 Fcons (make_number (format
), Qnil
))));
2128 ret
= (bytes
? make_string ((char *) data
, bytes
) : Qnil
);
2129 /* Use xfree, not XFree, because x_get_window_property
2130 calls xmalloc itself. */
2136 DEFUN ("x-store-cut-buffer-internal", Fx_store_cut_buffer_internal
,
2137 Sx_store_cut_buffer_internal
, 2, 2, 0,
2138 "Sets the value of the named cut buffer (typically CUT_BUFFER0).")
2140 Lisp_Object buffer
, string
;
2144 unsigned char *data
;
2146 int bytes_remaining
;
2151 display
= FRAME_X_DISPLAY (selected_frame
);
2152 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2154 max_bytes
= SELECTION_QUANTUM (display
);
2155 if (max_bytes
> MAX_SELECTION_QUANTUM
)
2156 max_bytes
= MAX_SELECTION_QUANTUM
;
2158 CHECK_CUT_BUFFER (buffer
, 0);
2159 CHECK_STRING (string
, 0);
2160 buffer_atom
= symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame
),
2162 data
= (unsigned char *) XSTRING (string
)->data
;
2163 bytes
= STRING_BYTES (XSTRING (string
));
2164 bytes_remaining
= bytes
;
2166 if (! FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
)
2168 initialize_cut_buffers (display
, window
);
2169 FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
= 1;
2174 /* Don't mess up with an empty value. */
2175 if (!bytes_remaining
)
2176 XChangeProperty (display
, window
, buffer_atom
, XA_STRING
, 8,
2177 PropModeReplace
, data
, 0);
2179 while (bytes_remaining
)
2181 int chunk
= (bytes_remaining
< max_bytes
2182 ? bytes_remaining
: max_bytes
);
2183 XChangeProperty (display
, window
, buffer_atom
, XA_STRING
, 8,
2184 (bytes_remaining
== bytes
2189 bytes_remaining
-= chunk
;
2196 DEFUN ("x-rotate-cut-buffers-internal", Fx_rotate_cut_buffers_internal
,
2197 Sx_rotate_cut_buffers_internal
, 1, 1, 0,
2198 "Rotate the values of the cut buffers by the given number of step.\n\
2199 Positive means shift the values forward, negative means backward.")
2208 display
= FRAME_X_DISPLAY (selected_frame
);
2209 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2210 CHECK_NUMBER (n
, 0);
2213 if (! FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
)
2215 initialize_cut_buffers (display
, window
);
2216 FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
= 1;
2219 props
[0] = XA_CUT_BUFFER0
;
2220 props
[1] = XA_CUT_BUFFER1
;
2221 props
[2] = XA_CUT_BUFFER2
;
2222 props
[3] = XA_CUT_BUFFER3
;
2223 props
[4] = XA_CUT_BUFFER4
;
2224 props
[5] = XA_CUT_BUFFER5
;
2225 props
[6] = XA_CUT_BUFFER6
;
2226 props
[7] = XA_CUT_BUFFER7
;
2228 XRotateWindowProperties (display
, window
, props
, 8, XINT (n
));
2238 defsubr (&Sx_get_selection_internal
);
2239 defsubr (&Sx_own_selection_internal
);
2240 defsubr (&Sx_disown_selection_internal
);
2241 defsubr (&Sx_selection_owner_p
);
2242 defsubr (&Sx_selection_exists_p
);
2244 #ifdef CUT_BUFFER_SUPPORT
2245 defsubr (&Sx_get_cut_buffer_internal
);
2246 defsubr (&Sx_store_cut_buffer_internal
);
2247 defsubr (&Sx_rotate_cut_buffers_internal
);
2250 reading_selection_reply
= Fcons (Qnil
, Qnil
);
2251 staticpro (&reading_selection_reply
);
2252 reading_selection_window
= 0;
2253 reading_which_selection
= 0;
2255 property_change_wait_list
= 0;
2256 prop_location_identifier
= 0;
2257 property_change_reply
= Fcons (Qnil
, Qnil
);
2258 staticpro (&property_change_reply
);
2260 Vselection_alist
= Qnil
;
2261 staticpro (&Vselection_alist
);
2263 DEFVAR_LISP ("selection-converter-alist", &Vselection_converter_alist
,
2264 "An alist associating X Windows selection-types with functions.\n\
2265 These functions are called to convert the selection, with three args:\n\
2266 the name of the selection (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
2267 a desired type to which the selection should be converted;\n\
2268 and the local selection value (whatever was given to `x-own-selection').\n\
2270 The function should return the value to send to the X server\n\
2271 \(typically a string). A return value of nil\n\
2272 means that the conversion could not be done.\n\
2273 A return value which is the symbol `NULL'\n\
2274 means that a side-effect was executed,\n\
2275 and there is no meaningful selection value.");
2276 Vselection_converter_alist
= Qnil
;
2278 DEFVAR_LISP ("x-lost-selection-hooks", &Vx_lost_selection_hooks
,
2279 "A list of functions to be called when Emacs loses an X selection.\n\
2280 \(This happens when some other X client makes its own selection\n\
2281 or when a Lisp program explicitly clears the selection.)\n\
2282 The functions are called with one argument, the selection type\n\
2283 \(a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD').");
2284 Vx_lost_selection_hooks
= Qnil
;
2286 DEFVAR_LISP ("x-sent-selection-hooks", &Vx_sent_selection_hooks
,
2287 "A list of functions to be called when Emacs answers a selection request.\n\
2288 The functions are called with four arguments:\n\
2289 - the selection name (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
2290 - the selection-type which Emacs was asked to convert the\n\
2291 selection into before sending (for example, `STRING' or `LENGTH');\n\
2292 - a flag indicating success or failure for responding to the request.\n\
2293 We might have failed (and declined the request) for any number of reasons,\n\
2294 including being asked for a selection that we no longer own, or being asked\n\
2295 to convert into a type that we don't know about or that is inappropriate.\n\
2296 This hook doesn't let you change the behavior of Emacs's selection replies,\n\
2297 it merely informs you that they have happened.");
2298 Vx_sent_selection_hooks
= Qnil
;
2300 DEFVAR_LISP ("selection-coding-system", &Vselection_coding_system
,
2301 "Coding system for communicating with other X clients.\n\
2302 When sending or receiving text via cut_buffer, selection, and clipboard,\n\
2303 the text is encoded or decoded by this coding system.\n\
2304 The default value is `compound-text'.");
2305 Vselection_coding_system
= intern ("compound-text");
2307 DEFVAR_LISP ("next-selection-coding-system", &Vnext_selection_coding_system
,
2308 "Coding system for the next communication with other X clients.\n\
2309 Usually, `selection-coding-system' is used for communicating with\n\
2310 other X clients. But, if this variable is set, it is used for the\n\
2311 next communication only. After the communication, this variable is\n\
2313 Vnext_selection_coding_system
= Qnil
;
2315 DEFVAR_INT ("x-selection-timeout", &x_selection_timeout
,
2316 "Number of milliseconds to wait for a selection reply.\n\
2317 If the selection owner doesn't reply in this time, we give up.\n\
2318 A value of 0 means wait as long as necessary. This is initialized from the\n\
2319 \"*selectionTimeout\" resource.");
2320 x_selection_timeout
= 0;
2322 QPRIMARY
= intern ("PRIMARY"); staticpro (&QPRIMARY
);
2323 QSECONDARY
= intern ("SECONDARY"); staticpro (&QSECONDARY
);
2324 QSTRING
= intern ("STRING"); staticpro (&QSTRING
);
2325 QINTEGER
= intern ("INTEGER"); staticpro (&QINTEGER
);
2326 QCLIPBOARD
= intern ("CLIPBOARD"); staticpro (&QCLIPBOARD
);
2327 QTIMESTAMP
= intern ("TIMESTAMP"); staticpro (&QTIMESTAMP
);
2328 QTEXT
= intern ("TEXT"); staticpro (&QTEXT
);
2329 QCOMPOUND_TEXT
= intern ("COMPOUND_TEXT"); staticpro (&QCOMPOUND_TEXT
);
2330 QTIMESTAMP
= intern ("TIMESTAMP"); staticpro (&QTIMESTAMP
);
2331 QDELETE
= intern ("DELETE"); staticpro (&QDELETE
);
2332 QMULTIPLE
= intern ("MULTIPLE"); staticpro (&QMULTIPLE
);
2333 QINCR
= intern ("INCR"); staticpro (&QINCR
);
2334 QEMACS_TMP
= intern ("_EMACS_TMP_"); staticpro (&QEMACS_TMP
);
2335 QTARGETS
= intern ("TARGETS"); staticpro (&QTARGETS
);
2336 QATOM
= intern ("ATOM"); staticpro (&QATOM
);
2337 QATOM_PAIR
= intern ("ATOM_PAIR"); staticpro (&QATOM_PAIR
);
2338 QNULL
= intern ("NULL"); staticpro (&QNULL
);
2340 #ifdef CUT_BUFFER_SUPPORT
2341 QCUT_BUFFER0
= intern ("CUT_BUFFER0"); staticpro (&QCUT_BUFFER0
);
2342 QCUT_BUFFER1
= intern ("CUT_BUFFER1"); staticpro (&QCUT_BUFFER1
);
2343 QCUT_BUFFER2
= intern ("CUT_BUFFER2"); staticpro (&QCUT_BUFFER2
);
2344 QCUT_BUFFER3
= intern ("CUT_BUFFER3"); staticpro (&QCUT_BUFFER3
);
2345 QCUT_BUFFER4
= intern ("CUT_BUFFER4"); staticpro (&QCUT_BUFFER4
);
2346 QCUT_BUFFER5
= intern ("CUT_BUFFER5"); staticpro (&QCUT_BUFFER5
);
2347 QCUT_BUFFER6
= intern ("CUT_BUFFER6"); staticpro (&QCUT_BUFFER6
);
2348 QCUT_BUFFER7
= intern ("CUT_BUFFER7"); staticpro (&QCUT_BUFFER7
);