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;
1476 if (! NILP (buffer_defaults
.enable_multibyte_characters
))
1478 /* If TYPE is `TEXT' or `COMPOUND_TEXT', we should decode
1479 DATA to Emacs internal format because DATA may be encoded
1480 in compound text format. In addtion, if TYPE is `STRING'
1481 and DATA contains any 8-bit Latin-1 code, we should also
1483 if (type
== dpyinfo
->Xatom_TEXT
1484 || type
== dpyinfo
->Xatom_COMPOUND_TEXT
)
1485 require_encoding
= 1;
1486 else if (type
== XA_STRING
)
1489 for (i
= 0; i
< size
; i
++)
1491 if (data
[i
] >= 0x80)
1493 require_encoding
= 1;
1499 if (!require_encoding
)
1501 str
= make_unibyte_string ((char *) data
, size
);
1502 Vlast_coding_system_used
= Qraw_text
;
1508 struct coding_system coding
;
1510 if (NILP (Vnext_selection_coding_system
))
1511 Vnext_selection_coding_system
= Vselection_coding_system
;
1513 (Fcheck_coding_system(Vnext_selection_coding_system
), &coding
);
1514 Vnext_selection_coding_system
= Qnil
;
1515 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
1516 bufsize
= decoding_buffer_size (&coding
, size
);
1517 buf
= (unsigned char *) xmalloc (bufsize
);
1518 decode_coding (&coding
, data
, buf
, size
, bufsize
);
1519 size
= (coding
.fake_multibyte
1520 ? multibyte_chars_in_text (buf
, coding
.produced
)
1521 : coding
.produced_char
);
1522 str
= make_string_from_bytes ((char *) buf
, size
, coding
.produced
);
1524 Vlast_coding_system_used
= coding
.symbol
;
1528 /* Convert a single atom to a Lisp_Symbol. Convert a set of atoms to
1529 a vector of symbols.
1531 else if (type
== XA_ATOM
)
1534 if (size
== sizeof (Atom
))
1535 return x_atom_to_symbol (dpyinfo
, display
, *((Atom
*) data
));
1538 Lisp_Object v
= Fmake_vector (make_number (size
/ sizeof (Atom
)),
1540 for (i
= 0; i
< size
/ sizeof (Atom
); i
++)
1541 Faset (v
, make_number (i
),
1542 x_atom_to_symbol (dpyinfo
, display
, ((Atom
*) data
) [i
]));
1547 /* Convert a single 16 or small 32 bit number to a Lisp_Int.
1548 If the number is > 16 bits, convert it to a cons of integers,
1549 16 bits in each half.
1551 else if (format
== 32 && size
== sizeof (long))
1552 return long_to_cons (((unsigned long *) data
) [0]);
1553 else if (format
== 16 && size
== sizeof (short))
1554 return make_number ((int) (((unsigned short *) data
) [0]));
1556 /* Convert any other kind of data to a vector of numbers, represented
1557 as above (as an integer, or a cons of two 16 bit integers.)
1559 else if (format
== 16)
1563 v
= Fmake_vector (make_number (size
/ 2), make_number (0));
1564 for (i
= 0; i
< size
/ 2; i
++)
1566 int j
= (int) ((unsigned short *) data
) [i
];
1567 Faset (v
, make_number (i
), make_number (j
));
1574 Lisp_Object v
= Fmake_vector (make_number (size
/ 4), make_number (0));
1575 for (i
= 0; i
< size
/ 4; i
++)
1577 unsigned long j
= ((unsigned long *) data
) [i
];
1578 Faset (v
, make_number (i
), long_to_cons (j
));
1585 /* Use xfree, not XFree, to free the data obtained with this function. */
1588 lisp_data_to_selection_data (display
, obj
,
1589 data_ret
, type_ret
, size_ret
,
1590 format_ret
, nofree_ret
)
1593 unsigned char **data_ret
;
1595 unsigned int *size_ret
;
1599 Lisp_Object type
= Qnil
;
1600 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1604 if (CONSP (obj
) && SYMBOLP (XCONS (obj
)->car
))
1606 type
= XCONS (obj
)->car
;
1607 obj
= XCONS (obj
)->cdr
;
1608 if (CONSP (obj
) && NILP (XCONS (obj
)->cdr
))
1609 obj
= XCONS (obj
)->car
;
1612 if (EQ (obj
, QNULL
) || (EQ (type
, QNULL
)))
1613 { /* This is not the same as declining */
1619 else if (STRINGP (obj
))
1621 /* Since we are now handling multilingual text, we must consider
1622 sending back compound text. */
1623 int charsets
[MAX_CHARSET
+ 1];
1627 *size_ret
= STRING_BYTES (XSTRING (obj
));
1628 *data_ret
= XSTRING (obj
)->data
;
1629 bzero (charsets
, (MAX_CHARSET
+ 1) * sizeof (int));
1630 num
= ((*size_ret
<= 1 /* Check the possibility of short cut. */
1631 || NILP (buffer_defaults
.enable_multibyte_characters
))
1633 : find_charset_in_str (*data_ret
, *size_ret
, charsets
, Qnil
, 1));
1635 if (!num
|| (num
== 1 && charsets
[CHARSET_ASCII
]))
1637 /* No multibyte character in OBJ. We need not encode it. */
1639 if (NILP (type
)) type
= QSTRING
;
1640 Vlast_coding_system_used
= Qraw_text
;
1644 /* We must encode contents of OBJ to compound text format.
1645 The format is compatible with what the target `STRING'
1646 expects if OBJ contains only ASCII and Latin-1
1650 struct coding_system coding
;
1652 if (NILP (Vnext_selection_coding_system
))
1653 Vnext_selection_coding_system
= Vselection_coding_system
;
1655 (Fcheck_coding_system (Vnext_selection_coding_system
), &coding
);
1656 Vnext_selection_coding_system
= Qnil
;
1657 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
1658 bufsize
= encoding_buffer_size (&coding
, *size_ret
);
1659 buf
= (unsigned char *) xmalloc (bufsize
);
1660 encode_coding (&coding
, *data_ret
, buf
, *size_ret
, bufsize
);
1661 *size_ret
= coding
.produced
;
1663 if (charsets
[charset_latin_iso8859_1
]
1664 && (num
== 1 || (num
== 2 && charsets
[CHARSET_ASCII
])))
1666 /* Ok, we can return it as `STRING'. */
1667 if (NILP (type
)) type
= QSTRING
;
1671 /* We must return it as `COMPOUND_TEXT'. */
1672 if (NILP (type
)) type
= QCOMPOUND_TEXT
;
1674 Vlast_coding_system_used
= coding
.symbol
;
1677 else if (SYMBOLP (obj
))
1681 *data_ret
= (unsigned char *) xmalloc (sizeof (Atom
) + 1);
1682 (*data_ret
) [sizeof (Atom
)] = 0;
1683 (*(Atom
**) data_ret
) [0] = symbol_to_x_atom (dpyinfo
, display
, obj
);
1684 if (NILP (type
)) type
= QATOM
;
1686 else if (INTEGERP (obj
)
1687 && XINT (obj
) < 0xFFFF
1688 && XINT (obj
) > -0xFFFF)
1692 *data_ret
= (unsigned char *) xmalloc (sizeof (short) + 1);
1693 (*data_ret
) [sizeof (short)] = 0;
1694 (*(short **) data_ret
) [0] = (short) XINT (obj
);
1695 if (NILP (type
)) type
= QINTEGER
;
1697 else if (INTEGERP (obj
)
1698 || (CONSP (obj
) && INTEGERP (XCONS (obj
)->car
)
1699 && (INTEGERP (XCONS (obj
)->cdr
)
1700 || (CONSP (XCONS (obj
)->cdr
)
1701 && INTEGERP (XCONS (XCONS (obj
)->cdr
)->car
)))))
1705 *data_ret
= (unsigned char *) xmalloc (sizeof (long) + 1);
1706 (*data_ret
) [sizeof (long)] = 0;
1707 (*(unsigned long **) data_ret
) [0] = cons_to_long (obj
);
1708 if (NILP (type
)) type
= QINTEGER
;
1710 else if (VECTORP (obj
))
1712 /* Lisp_Vectors may represent a set of ATOMs;
1713 a set of 16 or 32 bit INTEGERs;
1714 or a set of ATOM_PAIRs (represented as [[A1 A2] [A3 A4] ...]
1718 if (SYMBOLP (XVECTOR (obj
)->contents
[0]))
1719 /* This vector is an ATOM set */
1721 if (NILP (type
)) type
= QATOM
;
1722 *size_ret
= XVECTOR (obj
)->size
;
1724 *data_ret
= (unsigned char *) xmalloc ((*size_ret
) * sizeof (Atom
));
1725 for (i
= 0; i
< *size_ret
; i
++)
1726 if (SYMBOLP (XVECTOR (obj
)->contents
[i
]))
1727 (*(Atom
**) data_ret
) [i
]
1728 = symbol_to_x_atom (dpyinfo
, display
, XVECTOR (obj
)->contents
[i
]);
1730 Fsignal (Qerror
, /* Qselection_error */
1732 ("all elements of selection vector must have same type"),
1733 Fcons (obj
, Qnil
)));
1735 #if 0 /* #### MULTIPLE doesn't work yet */
1736 else if (VECTORP (XVECTOR (obj
)->contents
[0]))
1737 /* This vector is an ATOM_PAIR set */
1739 if (NILP (type
)) type
= QATOM_PAIR
;
1740 *size_ret
= XVECTOR (obj
)->size
;
1742 *data_ret
= (unsigned char *)
1743 xmalloc ((*size_ret
) * sizeof (Atom
) * 2);
1744 for (i
= 0; i
< *size_ret
; i
++)
1745 if (VECTORP (XVECTOR (obj
)->contents
[i
]))
1747 Lisp_Object pair
= XVECTOR (obj
)->contents
[i
];
1748 if (XVECTOR (pair
)->size
!= 2)
1751 ("elements of the vector must be vectors of exactly two elements"),
1752 Fcons (pair
, Qnil
)));
1754 (*(Atom
**) data_ret
) [i
* 2]
1755 = symbol_to_x_atom (dpyinfo
, display
,
1756 XVECTOR (pair
)->contents
[0]);
1757 (*(Atom
**) data_ret
) [(i
* 2) + 1]
1758 = symbol_to_x_atom (dpyinfo
, display
,
1759 XVECTOR (pair
)->contents
[1]);
1764 ("all elements of the vector must be of the same type"),
1765 Fcons (obj
, Qnil
)));
1770 /* This vector is an INTEGER set, or something like it */
1772 *size_ret
= XVECTOR (obj
)->size
;
1773 if (NILP (type
)) type
= QINTEGER
;
1775 for (i
= 0; i
< *size_ret
; i
++)
1776 if (CONSP (XVECTOR (obj
)->contents
[i
]))
1778 else if (!INTEGERP (XVECTOR (obj
)->contents
[i
]))
1779 Fsignal (Qerror
, /* Qselection_error */
1781 ("elements of selection vector must be integers or conses of integers"),
1782 Fcons (obj
, Qnil
)));
1784 *data_ret
= (unsigned char *) xmalloc (*size_ret
* (*format_ret
/8));
1785 for (i
= 0; i
< *size_ret
; i
++)
1786 if (*format_ret
== 32)
1787 (*((unsigned long **) data_ret
)) [i
]
1788 = cons_to_long (XVECTOR (obj
)->contents
[i
]);
1790 (*((unsigned short **) data_ret
)) [i
]
1791 = (unsigned short) cons_to_long (XVECTOR (obj
)->contents
[i
]);
1795 Fsignal (Qerror
, /* Qselection_error */
1796 Fcons (build_string ("unrecognised selection data"),
1797 Fcons (obj
, Qnil
)));
1799 *type_ret
= symbol_to_x_atom (dpyinfo
, display
, type
);
1803 clean_local_selection_data (obj
)
1807 && INTEGERP (XCONS (obj
)->car
)
1808 && CONSP (XCONS (obj
)->cdr
)
1809 && INTEGERP (XCONS (XCONS (obj
)->cdr
)->car
)
1810 && NILP (XCONS (XCONS (obj
)->cdr
)->cdr
))
1811 obj
= Fcons (XCONS (obj
)->car
, XCONS (obj
)->cdr
);
1814 && INTEGERP (XCONS (obj
)->car
)
1815 && INTEGERP (XCONS (obj
)->cdr
))
1817 if (XINT (XCONS (obj
)->car
) == 0)
1818 return XCONS (obj
)->cdr
;
1819 if (XINT (XCONS (obj
)->car
) == -1)
1820 return make_number (- XINT (XCONS (obj
)->cdr
));
1825 int size
= XVECTOR (obj
)->size
;
1828 return clean_local_selection_data (XVECTOR (obj
)->contents
[0]);
1829 copy
= Fmake_vector (make_number (size
), Qnil
);
1830 for (i
= 0; i
< size
; i
++)
1831 XVECTOR (copy
)->contents
[i
]
1832 = clean_local_selection_data (XVECTOR (obj
)->contents
[i
]);
1838 /* Called from XTread_socket to handle SelectionNotify events.
1839 If it's the selection we are waiting for, stop waiting
1840 by setting the car of reading_selection_reply to non-nil.
1841 We store t there if the reply is successful, lambda if not. */
1844 x_handle_selection_notify (event
)
1845 XSelectionEvent
*event
;
1847 if (event
->requestor
!= reading_selection_window
)
1849 if (event
->selection
!= reading_which_selection
)
1852 XCONS (reading_selection_reply
)->car
1853 = (event
->property
!= 0 ? Qt
: Qlambda
);
1857 DEFUN ("x-own-selection-internal", Fx_own_selection_internal
,
1858 Sx_own_selection_internal
, 2, 2, 0,
1859 "Assert an X selection of the given TYPE with the given VALUE.\n\
1860 TYPE is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1861 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1862 VALUE is typically a string, or a cons of two markers, but may be\n\
1863 anything that the functions on `selection-converter-alist' know about.")
1864 (selection_name
, selection_value
)
1865 Lisp_Object selection_name
, selection_value
;
1868 CHECK_SYMBOL (selection_name
, 0);
1869 if (NILP (selection_value
)) error ("selection-value may not be nil");
1870 x_own_selection (selection_name
, selection_value
);
1871 return selection_value
;
1875 /* Request the selection value from the owner. If we are the owner,
1876 simply return our selection value. If we are not the owner, this
1877 will block until all of the data has arrived. */
1879 DEFUN ("x-get-selection-internal", Fx_get_selection_internal
,
1880 Sx_get_selection_internal
, 2, 2, 0,
1881 "Return text selected from some X window.\n\
1882 SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1883 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1884 TYPE is the type of data desired, typically `STRING'.")
1885 (selection_symbol
, target_type
)
1886 Lisp_Object selection_symbol
, target_type
;
1888 Lisp_Object val
= Qnil
;
1889 struct gcpro gcpro1
, gcpro2
;
1890 GCPRO2 (target_type
, val
); /* we store newly consed data into these */
1892 CHECK_SYMBOL (selection_symbol
, 0);
1894 #if 0 /* #### MULTIPLE doesn't work yet */
1895 if (CONSP (target_type
)
1896 && XCONS (target_type
)->car
== QMULTIPLE
)
1898 CHECK_VECTOR (XCONS (target_type
)->cdr
, 0);
1899 /* So we don't destructively modify this... */
1900 target_type
= copy_multiple_data (target_type
);
1904 CHECK_SYMBOL (target_type
, 0);
1906 val
= x_get_local_selection (selection_symbol
, target_type
);
1910 val
= x_get_foreign_selection (selection_symbol
, target_type
);
1915 && SYMBOLP (XCONS (val
)->car
))
1917 val
= XCONS (val
)->cdr
;
1918 if (CONSP (val
) && NILP (XCONS (val
)->cdr
))
1919 val
= XCONS (val
)->car
;
1921 val
= clean_local_selection_data (val
);
1927 DEFUN ("x-disown-selection-internal", Fx_disown_selection_internal
,
1928 Sx_disown_selection_internal
, 1, 2, 0,
1929 "If we own the selection SELECTION, disown it.\n\
1930 Disowning it means there is no such selection.")
1932 Lisp_Object selection
;
1936 Atom selection_atom
;
1937 struct selection_input_event event
;
1939 struct x_display_info
*dpyinfo
;
1942 display
= FRAME_X_DISPLAY (selected_frame
);
1943 dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
1944 CHECK_SYMBOL (selection
, 0);
1946 timestamp
= last_event_timestamp
;
1948 timestamp
= cons_to_long (time
);
1950 if (NILP (assq_no_quit (selection
, Vselection_alist
)))
1951 return Qnil
; /* Don't disown the selection when we're not the owner. */
1953 selection_atom
= symbol_to_x_atom (dpyinfo
, display
, selection
);
1956 XSetSelectionOwner (display
, selection_atom
, None
, timestamp
);
1959 /* It doesn't seem to be guaranteed that a SelectionClear event will be
1960 generated for a window which owns the selection when that window sets
1961 the selection owner to None. The NCD server does, the MIT Sun4 server
1962 doesn't. So we synthesize one; this means we might get two, but
1963 that's ok, because the second one won't have any effect. */
1964 SELECTION_EVENT_DISPLAY (&event
) = display
;
1965 SELECTION_EVENT_SELECTION (&event
) = selection_atom
;
1966 SELECTION_EVENT_TIME (&event
) = timestamp
;
1967 x_handle_selection_clear ((struct input_event
*) &event
);
1972 /* Get rid of all the selections in buffer BUFFER.
1973 This is used when we kill a buffer. */
1976 x_disown_buffer_selections (buffer
)
1980 struct buffer
*buf
= XBUFFER (buffer
);
1982 for (tail
= Vselection_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1984 Lisp_Object elt
, value
;
1985 elt
= XCONS (tail
)->car
;
1986 value
= XCONS (elt
)->cdr
;
1987 if (CONSP (value
) && MARKERP (XCONS (value
)->car
)
1988 && XMARKER (XCONS (value
)->car
)->buffer
== buf
)
1989 Fx_disown_selection_internal (XCONS (elt
)->car
, Qnil
);
1993 DEFUN ("x-selection-owner-p", Fx_selection_owner_p
, Sx_selection_owner_p
,
1995 "Whether the current Emacs process owns the given X Selection.\n\
1996 The arg should be the name of the selection in question, typically one of\n\
1997 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1998 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1999 For convenience, the symbol nil is the same as `PRIMARY',\n\
2000 and t is the same as `SECONDARY'.)")
2002 Lisp_Object selection
;
2005 CHECK_SYMBOL (selection
, 0);
2006 if (EQ (selection
, Qnil
)) selection
= QPRIMARY
;
2007 if (EQ (selection
, Qt
)) selection
= QSECONDARY
;
2009 if (NILP (Fassq (selection
, Vselection_alist
)))
2014 DEFUN ("x-selection-exists-p", Fx_selection_exists_p
, Sx_selection_exists_p
,
2016 "Whether there is an owner for the given X Selection.\n\
2017 The arg should be the name of the selection in question, typically one of\n\
2018 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
2019 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
2020 For convenience, the symbol nil is the same as `PRIMARY',\n\
2021 and t is the same as `SECONDARY'.)")
2023 Lisp_Object selection
;
2029 /* It should be safe to call this before we have an X frame. */
2030 if (! FRAME_X_P (selected_frame
))
2033 dpy
= FRAME_X_DISPLAY (selected_frame
);
2034 CHECK_SYMBOL (selection
, 0);
2035 if (!NILP (Fx_selection_owner_p (selection
)))
2037 if (EQ (selection
, Qnil
)) selection
= QPRIMARY
;
2038 if (EQ (selection
, Qt
)) selection
= QSECONDARY
;
2039 atom
= symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame
),
2044 owner
= XGetSelectionOwner (dpy
, atom
);
2046 return (owner
? Qt
: Qnil
);
2050 #ifdef CUT_BUFFER_SUPPORT
2052 /* Ensure that all 8 cut buffers exist. ICCCM says we gotta... */
2054 initialize_cut_buffers (display
, window
)
2058 unsigned char *data
= (unsigned char *) "";
2060 #define FROB(atom) XChangeProperty (display, window, atom, XA_STRING, 8, \
2061 PropModeAppend, data, 0)
2062 FROB (XA_CUT_BUFFER0
);
2063 FROB (XA_CUT_BUFFER1
);
2064 FROB (XA_CUT_BUFFER2
);
2065 FROB (XA_CUT_BUFFER3
);
2066 FROB (XA_CUT_BUFFER4
);
2067 FROB (XA_CUT_BUFFER5
);
2068 FROB (XA_CUT_BUFFER6
);
2069 FROB (XA_CUT_BUFFER7
);
2075 #define CHECK_CUT_BUFFER(symbol,n) \
2076 { CHECK_SYMBOL ((symbol), (n)); \
2077 if (!EQ((symbol), QCUT_BUFFER0) && !EQ((symbol), QCUT_BUFFER1) \
2078 && !EQ((symbol), QCUT_BUFFER2) && !EQ((symbol), QCUT_BUFFER3) \
2079 && !EQ((symbol), QCUT_BUFFER4) && !EQ((symbol), QCUT_BUFFER5) \
2080 && !EQ((symbol), QCUT_BUFFER6) && !EQ((symbol), QCUT_BUFFER7)) \
2082 Fcons (build_string ("doesn't name a cut buffer"), \
2083 Fcons ((symbol), Qnil))); \
2086 DEFUN ("x-get-cut-buffer-internal", Fx_get_cut_buffer_internal
,
2087 Sx_get_cut_buffer_internal
, 1, 1, 0,
2088 "Returns the value of the named cut buffer (typically CUT_BUFFER0).")
2094 unsigned char *data
;
2101 struct x_display_info
*dpyinfo
;
2104 display
= FRAME_X_DISPLAY (selected_frame
);
2105 dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
2106 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2107 CHECK_CUT_BUFFER (buffer
, 0);
2108 buffer_atom
= symbol_to_x_atom (dpyinfo
, display
, buffer
);
2110 x_get_window_property (display
, window
, buffer_atom
, &data
, &bytes
,
2111 &type
, &format
, &size
, 0);
2112 if (!data
|| !format
)
2115 if (format
!= 8 || type
!= XA_STRING
)
2117 Fcons (build_string ("cut buffer doesn't contain 8-bit data"),
2118 Fcons (x_atom_to_symbol (dpyinfo
, display
, type
),
2119 Fcons (make_number (format
), Qnil
))));
2121 ret
= (bytes
? make_string ((char *) data
, bytes
) : Qnil
);
2122 /* Use xfree, not XFree, because x_get_window_property
2123 calls xmalloc itself. */
2129 DEFUN ("x-store-cut-buffer-internal", Fx_store_cut_buffer_internal
,
2130 Sx_store_cut_buffer_internal
, 2, 2, 0,
2131 "Sets the value of the named cut buffer (typically CUT_BUFFER0).")
2133 Lisp_Object buffer
, string
;
2137 unsigned char *data
;
2139 int bytes_remaining
;
2144 display
= FRAME_X_DISPLAY (selected_frame
);
2145 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2147 max_bytes
= SELECTION_QUANTUM (display
);
2148 if (max_bytes
> MAX_SELECTION_QUANTUM
)
2149 max_bytes
= MAX_SELECTION_QUANTUM
;
2151 CHECK_CUT_BUFFER (buffer
, 0);
2152 CHECK_STRING (string
, 0);
2153 buffer_atom
= symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame
),
2155 data
= (unsigned char *) XSTRING (string
)->data
;
2156 bytes
= STRING_BYTES (XSTRING (string
));
2157 bytes_remaining
= bytes
;
2159 if (! FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
)
2161 initialize_cut_buffers (display
, window
);
2162 FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
= 1;
2167 /* Don't mess up with an empty value. */
2168 if (!bytes_remaining
)
2169 XChangeProperty (display
, window
, buffer_atom
, XA_STRING
, 8,
2170 PropModeReplace
, data
, 0);
2172 while (bytes_remaining
)
2174 int chunk
= (bytes_remaining
< max_bytes
2175 ? bytes_remaining
: max_bytes
);
2176 XChangeProperty (display
, window
, buffer_atom
, XA_STRING
, 8,
2177 (bytes_remaining
== bytes
2182 bytes_remaining
-= chunk
;
2189 DEFUN ("x-rotate-cut-buffers-internal", Fx_rotate_cut_buffers_internal
,
2190 Sx_rotate_cut_buffers_internal
, 1, 1, 0,
2191 "Rotate the values of the cut buffers by the given number of step.\n\
2192 Positive means shift the values forward, negative means backward.")
2201 display
= FRAME_X_DISPLAY (selected_frame
);
2202 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2203 CHECK_NUMBER (n
, 0);
2206 if (! FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
)
2208 initialize_cut_buffers (display
, window
);
2209 FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
= 1;
2212 props
[0] = XA_CUT_BUFFER0
;
2213 props
[1] = XA_CUT_BUFFER1
;
2214 props
[2] = XA_CUT_BUFFER2
;
2215 props
[3] = XA_CUT_BUFFER3
;
2216 props
[4] = XA_CUT_BUFFER4
;
2217 props
[5] = XA_CUT_BUFFER5
;
2218 props
[6] = XA_CUT_BUFFER6
;
2219 props
[7] = XA_CUT_BUFFER7
;
2221 XRotateWindowProperties (display
, window
, props
, 8, XINT (n
));
2231 defsubr (&Sx_get_selection_internal
);
2232 defsubr (&Sx_own_selection_internal
);
2233 defsubr (&Sx_disown_selection_internal
);
2234 defsubr (&Sx_selection_owner_p
);
2235 defsubr (&Sx_selection_exists_p
);
2237 #ifdef CUT_BUFFER_SUPPORT
2238 defsubr (&Sx_get_cut_buffer_internal
);
2239 defsubr (&Sx_store_cut_buffer_internal
);
2240 defsubr (&Sx_rotate_cut_buffers_internal
);
2243 reading_selection_reply
= Fcons (Qnil
, Qnil
);
2244 staticpro (&reading_selection_reply
);
2245 reading_selection_window
= 0;
2246 reading_which_selection
= 0;
2248 property_change_wait_list
= 0;
2249 prop_location_identifier
= 0;
2250 property_change_reply
= Fcons (Qnil
, Qnil
);
2251 staticpro (&property_change_reply
);
2253 Vselection_alist
= Qnil
;
2254 staticpro (&Vselection_alist
);
2256 DEFVAR_LISP ("selection-converter-alist", &Vselection_converter_alist
,
2257 "An alist associating X Windows selection-types with functions.\n\
2258 These functions are called to convert the selection, with three args:\n\
2259 the name of the selection (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
2260 a desired type to which the selection should be converted;\n\
2261 and the local selection value (whatever was given to `x-own-selection').\n\
2263 The function should return the value to send to the X server\n\
2264 \(typically a string). A return value of nil\n\
2265 means that the conversion could not be done.\n\
2266 A return value which is the symbol `NULL'\n\
2267 means that a side-effect was executed,\n\
2268 and there is no meaningful selection value.");
2269 Vselection_converter_alist
= Qnil
;
2271 DEFVAR_LISP ("x-lost-selection-hooks", &Vx_lost_selection_hooks
,
2272 "A list of functions to be called when Emacs loses an X selection.\n\
2273 \(This happens when some other X client makes its own selection\n\
2274 or when a Lisp program explicitly clears the selection.)\n\
2275 The functions are called with one argument, the selection type\n\
2276 \(a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD').");
2277 Vx_lost_selection_hooks
= Qnil
;
2279 DEFVAR_LISP ("x-sent-selection-hooks", &Vx_sent_selection_hooks
,
2280 "A list of functions to be called when Emacs answers a selection request.\n\
2281 The functions are called with four arguments:\n\
2282 - the selection name (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
2283 - the selection-type which Emacs was asked to convert the\n\
2284 selection into before sending (for example, `STRING' or `LENGTH');\n\
2285 - a flag indicating success or failure for responding to the request.\n\
2286 We might have failed (and declined the request) for any number of reasons,\n\
2287 including being asked for a selection that we no longer own, or being asked\n\
2288 to convert into a type that we don't know about or that is inappropriate.\n\
2289 This hook doesn't let you change the behavior of Emacs's selection replies,\n\
2290 it merely informs you that they have happened.");
2291 Vx_sent_selection_hooks
= Qnil
;
2293 DEFVAR_LISP ("selection-coding-system", &Vselection_coding_system
,
2294 "Coding system for communicating with other X clients.\n\
2295 When sending or receiving text via cut_buffer, selection, and clipboard,\n\
2296 the text is encoded or decoded by this coding system.\n\
2297 A default value is `compound-text'");
2298 Vselection_coding_system
= intern ("compound-text");
2300 DEFVAR_LISP ("next-selection-coding-system", &Vnext_selection_coding_system
,
2301 "Coding system for the next communication with other X clients.\n\
2302 Usually, `selection-coding-system' is used for communicating with\n\
2303 other X clients. But, if this variable is set, it is used for the\n\
2304 next communication only. After the communication, this variable is\n\
2306 Vnext_selection_coding_system
= Qnil
;
2308 DEFVAR_INT ("x-selection-timeout", &x_selection_timeout
,
2309 "Number of milliseconds to wait for a selection reply.\n\
2310 If the selection owner doesn't reply in this time, we give up.\n\
2311 A value of 0 means wait as long as necessary. This is initialized from the\n\
2312 \"*selectionTimeout\" resource.");
2313 x_selection_timeout
= 0;
2315 QPRIMARY
= intern ("PRIMARY"); staticpro (&QPRIMARY
);
2316 QSECONDARY
= intern ("SECONDARY"); staticpro (&QSECONDARY
);
2317 QSTRING
= intern ("STRING"); staticpro (&QSTRING
);
2318 QINTEGER
= intern ("INTEGER"); staticpro (&QINTEGER
);
2319 QCLIPBOARD
= intern ("CLIPBOARD"); staticpro (&QCLIPBOARD
);
2320 QTIMESTAMP
= intern ("TIMESTAMP"); staticpro (&QTIMESTAMP
);
2321 QTEXT
= intern ("TEXT"); staticpro (&QTEXT
);
2322 QCOMPOUND_TEXT
= intern ("COMPOUND_TEXT"); staticpro (&QCOMPOUND_TEXT
);
2323 QTIMESTAMP
= intern ("TIMESTAMP"); staticpro (&QTIMESTAMP
);
2324 QDELETE
= intern ("DELETE"); staticpro (&QDELETE
);
2325 QMULTIPLE
= intern ("MULTIPLE"); staticpro (&QMULTIPLE
);
2326 QINCR
= intern ("INCR"); staticpro (&QINCR
);
2327 QEMACS_TMP
= intern ("_EMACS_TMP_"); staticpro (&QEMACS_TMP
);
2328 QTARGETS
= intern ("TARGETS"); staticpro (&QTARGETS
);
2329 QATOM
= intern ("ATOM"); staticpro (&QATOM
);
2330 QATOM_PAIR
= intern ("ATOM_PAIR"); staticpro (&QATOM_PAIR
);
2331 QNULL
= intern ("NULL"); staticpro (&QNULL
);
2333 #ifdef CUT_BUFFER_SUPPORT
2334 QCUT_BUFFER0
= intern ("CUT_BUFFER0"); staticpro (&QCUT_BUFFER0
);
2335 QCUT_BUFFER1
= intern ("CUT_BUFFER1"); staticpro (&QCUT_BUFFER1
);
2336 QCUT_BUFFER2
= intern ("CUT_BUFFER2"); staticpro (&QCUT_BUFFER2
);
2337 QCUT_BUFFER3
= intern ("CUT_BUFFER3"); staticpro (&QCUT_BUFFER3
);
2338 QCUT_BUFFER4
= intern ("CUT_BUFFER4"); staticpro (&QCUT_BUFFER4
);
2339 QCUT_BUFFER5
= intern ("CUT_BUFFER5"); staticpro (&QCUT_BUFFER5
);
2340 QCUT_BUFFER6
= intern ("CUT_BUFFER6"); staticpro (&QCUT_BUFFER6
);
2341 QCUT_BUFFER7
= intern ("CUT_BUFFER7"); staticpro (&QCUT_BUFFER7
);