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"
34 #define CUT_BUFFER_SUPPORT
36 Lisp_Object QPRIMARY
, QSECONDARY
, QSTRING
, QINTEGER
, QCLIPBOARD
, QTIMESTAMP
,
37 QTEXT
, QDELETE
, QMULTIPLE
, QINCR
, QEMACS_TMP
, QTARGETS
, QATOM
, QNULL
,
40 Lisp_Object QCOMPOUND_TEXT
; /* This is a type of selection. */
42 #ifdef CUT_BUFFER_SUPPORT
43 Lisp_Object QCUT_BUFFER0
, QCUT_BUFFER1
, QCUT_BUFFER2
, QCUT_BUFFER3
,
44 QCUT_BUFFER4
, QCUT_BUFFER5
, QCUT_BUFFER6
, QCUT_BUFFER7
;
47 static Lisp_Object Vx_lost_selection_hooks
;
48 static Lisp_Object Vx_sent_selection_hooks
;
49 /* Coding system for communicating with other X clients via cutbuffer,
50 selection, and clipboard. */
51 static Lisp_Object Vclipboard_coding_system
;
53 /* If this is a smaller number than the max-request-size of the display,
54 emacs will use INCR selection transfer when the selection is larger
55 than this. The max-request-size is usually around 64k, so if you want
56 emacs to use incremental selection transfers when the selection is
57 smaller than that, set this. I added this mostly for debugging the
58 incremental transfer stuff, but it might improve server performance. */
59 #define MAX_SELECTION_QUANTUM 0xFFFFFF
62 #define SELECTION_QUANTUM(dpy) ((XMaxRequestSize(dpy) << 2) - 100)
64 #define SELECTION_QUANTUM(dpy) (((dpy)->max_request_size << 2) - 100)
67 /* The timestamp of the last input event Emacs received from the X server. */
68 /* Defined in keyboard.c. */
69 extern unsigned long last_event_timestamp
;
71 /* This is an association list whose elements are of the form
72 ( SELECTION-NAME SELECTION-VALUE SELECTION-TIMESTAMP FRAME)
73 SELECTION-NAME is a lisp symbol, whose name is the name of an X Atom.
74 SELECTION-VALUE is the value that emacs owns for that selection.
75 It may be any kind of Lisp object.
76 SELECTION-TIMESTAMP is the time at which emacs began owning this selection,
77 as a cons of two 16-bit numbers (making a 32 bit time.)
78 FRAME is the frame for which we made the selection.
79 If there is an entry in this alist, then it can be assumed that Emacs owns
81 The only (eq) parts of this list that are visible from Lisp are the
83 static Lisp_Object Vselection_alist
;
85 /* This is an alist whose CARs are selection-types (whose names are the same
86 as the names of X Atoms) and whose CDRs are the names of Lisp functions to
87 call to convert the given Emacs selection value to a string representing
88 the given selection type. This is for Lisp-level extension of the emacs
89 selection handling. */
90 static Lisp_Object Vselection_converter_alist
;
92 /* If the selection owner takes too long to reply to a selection request,
93 we give up on it. This is in milliseconds (0 = no timeout.) */
94 static int x_selection_timeout
;
96 /* Utility functions */
98 static void lisp_data_to_selection_data ();
99 static Lisp_Object
selection_data_to_lisp_data ();
100 static Lisp_Object
x_get_window_property_as_lisp_data ();
102 /* This converts a Lisp symbol to a server Atom, avoiding a server
103 roundtrip whenever possible. */
106 symbol_to_x_atom (dpyinfo
, display
, sym
)
107 struct x_display_info
*dpyinfo
;
112 if (NILP (sym
)) return 0;
113 if (EQ (sym
, QPRIMARY
)) return XA_PRIMARY
;
114 if (EQ (sym
, QSECONDARY
)) return XA_SECONDARY
;
115 if (EQ (sym
, QSTRING
)) return XA_STRING
;
116 if (EQ (sym
, QINTEGER
)) return XA_INTEGER
;
117 if (EQ (sym
, QATOM
)) return XA_ATOM
;
118 if (EQ (sym
, QCLIPBOARD
)) return dpyinfo
->Xatom_CLIPBOARD
;
119 if (EQ (sym
, QTIMESTAMP
)) return dpyinfo
->Xatom_TIMESTAMP
;
120 if (EQ (sym
, QTEXT
)) return dpyinfo
->Xatom_TEXT
;
121 if (EQ (sym
, QCOMPOUND_TEXT
)) return dpyinfo
->Xatom_COMPOUND_TEXT
;
122 if (EQ (sym
, QDELETE
)) return dpyinfo
->Xatom_DELETE
;
123 if (EQ (sym
, QMULTIPLE
)) return dpyinfo
->Xatom_MULTIPLE
;
124 if (EQ (sym
, QINCR
)) return dpyinfo
->Xatom_INCR
;
125 if (EQ (sym
, QEMACS_TMP
)) return dpyinfo
->Xatom_EMACS_TMP
;
126 if (EQ (sym
, QTARGETS
)) return dpyinfo
->Xatom_TARGETS
;
127 if (EQ (sym
, QNULL
)) return dpyinfo
->Xatom_NULL
;
128 #ifdef CUT_BUFFER_SUPPORT
129 if (EQ (sym
, QCUT_BUFFER0
)) return XA_CUT_BUFFER0
;
130 if (EQ (sym
, QCUT_BUFFER1
)) return XA_CUT_BUFFER1
;
131 if (EQ (sym
, QCUT_BUFFER2
)) return XA_CUT_BUFFER2
;
132 if (EQ (sym
, QCUT_BUFFER3
)) return XA_CUT_BUFFER3
;
133 if (EQ (sym
, QCUT_BUFFER4
)) return XA_CUT_BUFFER4
;
134 if (EQ (sym
, QCUT_BUFFER5
)) return XA_CUT_BUFFER5
;
135 if (EQ (sym
, QCUT_BUFFER6
)) return XA_CUT_BUFFER6
;
136 if (EQ (sym
, QCUT_BUFFER7
)) return XA_CUT_BUFFER7
;
138 if (!SYMBOLP (sym
)) abort ();
141 fprintf (stderr
, " XInternAtom %s\n", (char *) XSYMBOL (sym
)->name
->data
);
144 val
= XInternAtom (display
, (char *) XSYMBOL (sym
)->name
->data
, False
);
150 /* This converts a server Atom to a Lisp symbol, avoiding server roundtrips
151 and calls to intern whenever possible. */
154 x_atom_to_symbol (dpyinfo
, display
, atom
)
155 struct x_display_info
*dpyinfo
;
161 if (! atom
) return Qnil
;
174 #ifdef CUT_BUFFER_SUPPORT
194 if (atom
== dpyinfo
->Xatom_CLIPBOARD
)
196 if (atom
== dpyinfo
->Xatom_TIMESTAMP
)
198 if (atom
== dpyinfo
->Xatom_TEXT
)
200 if (atom
== dpyinfo
->Xatom_COMPOUND_TEXT
)
201 return QCOMPOUND_TEXT
;
202 if (atom
== dpyinfo
->Xatom_DELETE
)
204 if (atom
== dpyinfo
->Xatom_MULTIPLE
)
206 if (atom
== dpyinfo
->Xatom_INCR
)
208 if (atom
== dpyinfo
->Xatom_EMACS_TMP
)
210 if (atom
== dpyinfo
->Xatom_TARGETS
)
212 if (atom
== dpyinfo
->Xatom_NULL
)
216 str
= XGetAtomName (display
, atom
);
219 fprintf (stderr
, " XGetAtomName --> %s\n", str
);
221 if (! str
) return Qnil
;
224 /* This was allocated by Xlib, so use XFree. */
230 /* Do protocol to assert ourself as a selection owner.
231 Update the Vselection_alist so that we can reply to later requests for
235 x_own_selection (selection_name
, selection_value
)
236 Lisp_Object selection_name
, selection_value
;
238 Window selecting_window
= FRAME_X_WINDOW (selected_frame
);
239 Display
*display
= FRAME_X_DISPLAY (selected_frame
);
240 Time time
= last_event_timestamp
;
242 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
245 CHECK_SYMBOL (selection_name
, 0);
246 selection_atom
= symbol_to_x_atom (dpyinfo
, display
, selection_name
);
249 count
= x_catch_errors (display
);
250 XSetSelectionOwner (display
, selection_atom
, selecting_window
, time
);
251 x_check_errors (display
, "Can't set selection: %s");
252 x_uncatch_errors (display
, count
);
255 /* Now update the local cache */
257 Lisp_Object selection_time
;
258 Lisp_Object selection_data
;
259 Lisp_Object prev_value
;
261 selection_time
= long_to_cons ((unsigned long) time
);
262 selection_data
= Fcons (selection_name
,
263 Fcons (selection_value
,
264 Fcons (selection_time
,
265 Fcons (Fselected_frame (), Qnil
))));
266 prev_value
= assq_no_quit (selection_name
, Vselection_alist
);
268 Vselection_alist
= Fcons (selection_data
, Vselection_alist
);
270 /* If we already owned the selection, remove the old selection data.
271 Perhaps we should destructively modify it instead.
272 Don't use Fdelq as that may QUIT. */
273 if (!NILP (prev_value
))
275 Lisp_Object rest
; /* we know it's not the CAR, so it's easy. */
276 for (rest
= Vselection_alist
; !NILP (rest
); rest
= Fcdr (rest
))
277 if (EQ (prev_value
, Fcar (XCONS (rest
)->cdr
)))
279 XCONS (rest
)->cdr
= Fcdr (XCONS (rest
)->cdr
);
286 /* Given a selection-name and desired type, look up our local copy of
287 the selection value and convert it to the type.
288 The value is nil or a string.
289 This function is used both for remote requests
290 and for local x-get-selection-internal.
292 This calls random Lisp code, and may signal or gc. */
295 x_get_local_selection (selection_symbol
, target_type
)
296 Lisp_Object selection_symbol
, target_type
;
298 Lisp_Object local_value
;
299 Lisp_Object handler_fn
, value
, type
, check
;
302 local_value
= assq_no_quit (selection_symbol
, Vselection_alist
);
304 if (NILP (local_value
)) return Qnil
;
306 /* TIMESTAMP and MULTIPLE are special cases 'cause that's easiest. */
307 if (EQ (target_type
, QTIMESTAMP
))
310 value
= XCONS (XCONS (XCONS (local_value
)->cdr
)->cdr
)->car
;
313 else if (EQ (target_type
, QDELETE
))
316 Fx_disown_selection_internal
318 XCONS (XCONS (XCONS (local_value
)->cdr
)->cdr
)->car
);
323 #if 0 /* #### MULTIPLE doesn't work yet */
324 else if (CONSP (target_type
)
325 && XCONS (target_type
)->car
== QMULTIPLE
)
330 pairs
= XCONS (target_type
)->cdr
;
331 size
= XVECTOR (pairs
)->size
;
332 /* If the target is MULTIPLE, then target_type looks like
333 (MULTIPLE . [[SELECTION1 TARGET1] [SELECTION2 TARGET2] ... ])
334 We modify the second element of each pair in the vector and
335 return it as [[SELECTION1 <value1>] [SELECTION2 <value2>] ... ]
337 for (i
= 0; i
< size
; i
++)
340 pair
= XVECTOR (pairs
)->contents
[i
];
341 XVECTOR (pair
)->contents
[1]
342 = x_get_local_selection (XVECTOR (pair
)->contents
[0],
343 XVECTOR (pair
)->contents
[1]);
350 /* Don't allow a quit within the converter.
351 When the user types C-g, he would be surprised
352 if by luck it came during a converter. */
353 count
= specpdl_ptr
- specpdl
;
354 specbind (Qinhibit_quit
, Qt
);
356 CHECK_SYMBOL (target_type
, 0);
357 handler_fn
= Fcdr (Fassq (target_type
, Vselection_converter_alist
));
358 if (!NILP (handler_fn
))
359 value
= call3 (handler_fn
,
360 selection_symbol
, target_type
,
361 XCONS (XCONS (local_value
)->cdr
)->car
);
364 unbind_to (count
, Qnil
);
367 /* Make sure this value is of a type that we could transmit
368 to another X client. */
372 && SYMBOLP (XCONS (value
)->car
))
373 type
= XCONS (value
)->car
,
374 check
= XCONS (value
)->cdr
;
382 /* Check for a value that cons_to_long could handle. */
383 else if (CONSP (check
)
384 && INTEGERP (XCONS (check
)->car
)
385 && (INTEGERP (XCONS (check
)->cdr
)
387 (CONSP (XCONS (check
)->cdr
)
388 && INTEGERP (XCONS (XCONS (check
)->cdr
)->car
)
389 && NILP (XCONS (XCONS (check
)->cdr
)->cdr
))))
394 Fcons (build_string ("invalid data returned by selection-conversion function"),
395 Fcons (handler_fn
, Fcons (value
, Qnil
))));
398 /* Subroutines of x_reply_selection_request. */
400 /* Send a SelectionNotify event to the requestor with property=None,
401 meaning we were unable to do what they wanted. */
404 x_decline_selection_request (event
)
405 struct input_event
*event
;
407 XSelectionEvent reply
;
408 reply
.type
= SelectionNotify
;
409 reply
.display
= SELECTION_EVENT_DISPLAY (event
);
410 reply
.requestor
= SELECTION_EVENT_REQUESTOR (event
);
411 reply
.selection
= SELECTION_EVENT_SELECTION (event
);
412 reply
.time
= SELECTION_EVENT_TIME (event
);
413 reply
.target
= SELECTION_EVENT_TARGET (event
);
414 reply
.property
= None
;
417 XSendEvent (reply
.display
, reply
.requestor
, False
, 0L,
419 XFlush (reply
.display
);
423 /* This is the selection request currently being processed.
424 It is set to zero when the request is fully processed. */
425 static struct input_event
*x_selection_current_request
;
427 /* Used as an unwind-protect clause so that, if a selection-converter signals
428 an error, we tell the requester that we were unable to do what they wanted
429 before we throw to top-level or go into the debugger or whatever. */
432 x_selection_request_lisp_error (ignore
)
435 if (x_selection_current_request
!= 0)
436 x_decline_selection_request (x_selection_current_request
);
441 /* This stuff is so that INCR selections are reentrant (that is, so we can
442 be servicing multiple INCR selection requests simultaneously.) I haven't
443 actually tested that yet. */
445 /* Keep a list of the property changes that are awaited. */
455 struct prop_location
*next
;
458 static struct prop_location
*expect_property_change ();
459 static void wait_for_property_change ();
460 static void unexpect_property_change ();
461 static int waiting_for_other_props_on_window ();
463 static int prop_location_identifier
;
465 static Lisp_Object property_change_reply
;
467 static struct prop_location
*property_change_reply_object
;
469 static struct prop_location
*property_change_wait_list
;
472 queue_selection_requests_unwind (frame
)
475 FRAME_PTR f
= XFRAME (frame
);
478 x_stop_queuing_selection_requests (FRAME_X_DISPLAY (f
));
482 /* Return some frame whose display info is DPYINFO.
483 Return nil if there is none. */
486 some_frame_on_display (dpyinfo
)
487 struct x_display_info
*dpyinfo
;
489 Lisp_Object list
, frame
;
491 FOR_EACH_FRAME (list
, frame
)
493 if (FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
500 /* Send the reply to a selection request event EVENT.
501 TYPE is the type of selection data requested.
502 DATA and SIZE describe the data to send, already converted.
503 FORMAT is the unit-size (in bits) of the data to be transmitted. */
506 x_reply_selection_request (event
, format
, data
, size
, type
)
507 struct input_event
*event
;
512 XSelectionEvent reply
;
513 Display
*display
= SELECTION_EVENT_DISPLAY (event
);
514 Window window
= SELECTION_EVENT_REQUESTOR (event
);
516 int format_bytes
= format
/8;
517 int max_bytes
= SELECTION_QUANTUM (display
);
518 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
521 if (max_bytes
> MAX_SELECTION_QUANTUM
)
522 max_bytes
= MAX_SELECTION_QUANTUM
;
524 reply
.type
= SelectionNotify
;
525 reply
.display
= display
;
526 reply
.requestor
= window
;
527 reply
.selection
= SELECTION_EVENT_SELECTION (event
);
528 reply
.time
= SELECTION_EVENT_TIME (event
);
529 reply
.target
= SELECTION_EVENT_TARGET (event
);
530 reply
.property
= SELECTION_EVENT_PROPERTY (event
);
531 if (reply
.property
== None
)
532 reply
.property
= reply
.target
;
534 /* #### XChangeProperty can generate BadAlloc, and we must handle it! */
536 count
= x_catch_errors (display
);
538 /* Store the data on the requested property.
539 If the selection is large, only store the first N bytes of it.
541 bytes_remaining
= size
* format_bytes
;
542 if (bytes_remaining
<= max_bytes
)
544 /* Send all the data at once, with minimal handshaking. */
546 fprintf (stderr
,"\nStoring all %d\n", bytes_remaining
);
548 XChangeProperty (display
, window
, reply
.property
, type
, format
,
549 PropModeReplace
, data
, size
);
550 /* At this point, the selection was successfully stored; ack it. */
551 XSendEvent (display
, window
, False
, 0L, (XEvent
*) &reply
);
555 /* Send an INCR selection. */
556 struct prop_location
*wait_object
;
560 frame
= some_frame_on_display (dpyinfo
);
562 /* If the display no longer has frames, we can't expect
563 to get many more selection requests from it, so don't
564 bother trying to queue them. */
567 x_start_queuing_selection_requests (display
);
569 record_unwind_protect (queue_selection_requests_unwind
,
573 if (x_window_to_frame (dpyinfo
, window
)) /* #### debug */
574 error ("Attempt to transfer an INCR to ourself!");
576 fprintf (stderr
, "\nINCR %d\n", bytes_remaining
);
578 wait_object
= expect_property_change (display
, window
, reply
.property
,
581 XChangeProperty (display
, window
, reply
.property
, dpyinfo
->Xatom_INCR
,
583 (unsigned char *) &bytes_remaining
, 1);
584 XSelectInput (display
, window
, PropertyChangeMask
);
585 /* Tell 'em the INCR data is there... */
586 XSendEvent (display
, window
, False
, 0L, (XEvent
*) &reply
);
589 had_errors
= x_had_errors_p (display
);
592 /* First, wait for the requester to ack by deleting the property.
593 This can run random lisp code (process handlers) or signal. */
595 wait_for_property_change (wait_object
);
597 while (bytes_remaining
)
599 int i
= ((bytes_remaining
< max_bytes
)
606 = expect_property_change (display
, window
, reply
.property
,
609 fprintf (stderr
," INCR adding %d\n", i
);
611 /* Append the next chunk of data to the property. */
612 XChangeProperty (display
, window
, reply
.property
, type
, format
,
613 PropModeAppend
, data
, i
/ format_bytes
);
614 bytes_remaining
-= i
;
617 had_errors
= x_had_errors_p (display
);
623 /* Now wait for the requester to ack this chunk by deleting the
624 property. This can run random lisp code or signal.
626 wait_for_property_change (wait_object
);
628 /* Now write a zero-length chunk to the property to tell the requester
631 fprintf (stderr
," INCR done\n");
634 if (! waiting_for_other_props_on_window (display
, window
))
635 XSelectInput (display
, window
, 0L);
637 XChangeProperty (display
, window
, reply
.property
, type
, format
,
638 PropModeReplace
, data
, 0);
642 x_uncatch_errors (display
, count
);
646 /* Handle a SelectionRequest event EVENT.
647 This is called from keyboard.c when such an event is found in the queue. */
650 x_handle_selection_request (event
)
651 struct input_event
*event
;
653 struct gcpro gcpro1
, gcpro2
, gcpro3
;
654 Lisp_Object local_selection_data
;
655 Lisp_Object selection_symbol
;
656 Lisp_Object target_symbol
;
657 Lisp_Object converted_selection
;
658 Time local_selection_time
;
659 Lisp_Object successful_p
;
661 struct x_display_info
*dpyinfo
662 = x_display_info_for_display (SELECTION_EVENT_DISPLAY (event
));
664 local_selection_data
= Qnil
;
665 target_symbol
= Qnil
;
666 converted_selection
= Qnil
;
669 GCPRO3 (local_selection_data
, converted_selection
, target_symbol
);
671 selection_symbol
= x_atom_to_symbol (dpyinfo
,
672 SELECTION_EVENT_DISPLAY (event
),
673 SELECTION_EVENT_SELECTION (event
));
675 local_selection_data
= assq_no_quit (selection_symbol
, Vselection_alist
);
677 if (NILP (local_selection_data
))
679 /* Someone asked for the selection, but we don't have it any more.
681 x_decline_selection_request (event
);
685 local_selection_time
= (Time
)
686 cons_to_long (XCONS (XCONS (XCONS (local_selection_data
)->cdr
)->cdr
)->car
);
688 if (SELECTION_EVENT_TIME (event
) != CurrentTime
689 && local_selection_time
> SELECTION_EVENT_TIME (event
))
691 /* Someone asked for the selection, and we have one, but not the one
694 x_decline_selection_request (event
);
698 count
= specpdl_ptr
- specpdl
;
699 x_selection_current_request
= event
;
700 record_unwind_protect (x_selection_request_lisp_error
, Qnil
);
702 target_symbol
= x_atom_to_symbol (dpyinfo
, SELECTION_EVENT_DISPLAY (event
),
703 SELECTION_EVENT_TARGET (event
));
705 #if 0 /* #### MULTIPLE doesn't work yet */
706 if (EQ (target_symbol
, QMULTIPLE
))
707 target_symbol
= fetch_multiple_target (event
);
710 /* Convert lisp objects back into binary data */
713 = x_get_local_selection (selection_symbol
, target_symbol
);
715 if (! NILP (converted_selection
))
723 lisp_data_to_selection_data (SELECTION_EVENT_DISPLAY (event
),
725 &data
, &type
, &size
, &format
, &nofree
);
727 x_reply_selection_request (event
, format
, data
, size
, type
);
730 /* Indicate we have successfully processed this event. */
731 x_selection_current_request
= 0;
733 /* Use xfree, not XFree, because lisp_data_to_selection_data
734 calls xmalloc itself. */
738 unbind_to (count
, Qnil
);
744 /* Let random lisp code notice that the selection has been asked for. */
747 rest
= Vx_sent_selection_hooks
;
748 if (!EQ (rest
, Qunbound
))
749 for (; CONSP (rest
); rest
= Fcdr (rest
))
750 call3 (Fcar (rest
), selection_symbol
, target_symbol
, successful_p
);
754 /* Handle a SelectionClear event EVENT, which indicates that some other
755 client cleared out our previously asserted selection.
756 This is called from keyboard.c when such an event is found in the queue. */
759 x_handle_selection_clear (event
)
760 struct input_event
*event
;
762 Display
*display
= SELECTION_EVENT_DISPLAY (event
);
763 Atom selection
= SELECTION_EVENT_SELECTION (event
);
764 Time changed_owner_time
= SELECTION_EVENT_TIME (event
);
766 Lisp_Object selection_symbol
, local_selection_data
;
767 Time local_selection_time
;
768 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
770 selection_symbol
= x_atom_to_symbol (dpyinfo
, display
, selection
);
772 local_selection_data
= assq_no_quit (selection_symbol
, Vselection_alist
);
774 /* Well, we already believe that we don't own it, so that's just fine. */
775 if (NILP (local_selection_data
)) return;
777 local_selection_time
= (Time
)
778 cons_to_long (XCONS (XCONS (XCONS (local_selection_data
)->cdr
)->cdr
)->car
);
780 /* This SelectionClear is for a selection that we no longer own, so we can
781 disregard it. (That is, we have reasserted the selection since this
782 request was generated.) */
784 if (changed_owner_time
!= CurrentTime
785 && local_selection_time
> changed_owner_time
)
788 /* Otherwise, we're really honest and truly being told to drop it.
789 Don't use Fdelq as that may QUIT;. */
791 if (EQ (local_selection_data
, Fcar (Vselection_alist
)))
792 Vselection_alist
= Fcdr (Vselection_alist
);
796 for (rest
= Vselection_alist
; !NILP (rest
); rest
= Fcdr (rest
))
797 if (EQ (local_selection_data
, Fcar (XCONS (rest
)->cdr
)))
799 XCONS (rest
)->cdr
= Fcdr (XCONS (rest
)->cdr
);
804 /* Let random lisp code notice that the selection has been stolen. */
808 rest
= Vx_lost_selection_hooks
;
809 if (!EQ (rest
, Qunbound
))
811 for (; CONSP (rest
); rest
= Fcdr (rest
))
812 call1 (Fcar (rest
), selection_symbol
);
813 prepare_menu_bars ();
814 redisplay_preserve_echo_area ();
819 /* Clear all selections that were made from frame F.
820 We do this when about to delete a frame. */
823 x_clear_frame_selections (f
)
829 XSETFRAME (frame
, f
);
831 /* Otherwise, we're really honest and truly being told to drop it.
832 Don't use Fdelq as that may QUIT;. */
834 /* Delete elements from the beginning of Vselection_alist. */
835 while (!NILP (Vselection_alist
)
836 && EQ (frame
, Fcar (Fcdr (Fcdr (Fcdr (Fcar (Vselection_alist
)))))))
838 /* Let random Lisp code notice that the selection has been stolen. */
839 Lisp_Object hooks
, selection_symbol
;
841 hooks
= Vx_lost_selection_hooks
;
842 selection_symbol
= Fcar (Fcar (Vselection_alist
));
844 if (!EQ (hooks
, Qunbound
))
846 for (; CONSP (hooks
); hooks
= Fcdr (hooks
))
847 call1 (Fcar (hooks
), selection_symbol
);
848 #if 0 /* This can crash when deleting a frame
849 from x_connection_closed. Anyway, it seems unnecessary;
850 something else should cause a redisplay. */
851 redisplay_preserve_echo_area ();
855 Vselection_alist
= Fcdr (Vselection_alist
);
858 /* Delete elements after the beginning of Vselection_alist. */
859 for (rest
= Vselection_alist
; !NILP (rest
); rest
= Fcdr (rest
))
860 if (EQ (frame
, Fcar (Fcdr (Fcdr (Fcdr (Fcar (XCONS (rest
)->cdr
)))))))
862 /* Let random Lisp code notice that the selection has been stolen. */
863 Lisp_Object hooks
, selection_symbol
;
865 hooks
= Vx_lost_selection_hooks
;
866 selection_symbol
= Fcar (Fcar (XCONS (rest
)->cdr
));
868 if (!EQ (hooks
, Qunbound
))
870 for (; CONSP (hooks
); hooks
= Fcdr (hooks
))
871 call1 (Fcar (hooks
), selection_symbol
);
872 #if 0 /* See above */
873 redisplay_preserve_echo_area ();
876 XCONS (rest
)->cdr
= Fcdr (XCONS (rest
)->cdr
);
881 /* Nonzero if any properties for DISPLAY and WINDOW
882 are on the list of what we are waiting for. */
885 waiting_for_other_props_on_window (display
, window
)
889 struct prop_location
*rest
= property_change_wait_list
;
891 if (rest
->display
== display
&& rest
->window
== window
)
898 /* Add an entry to the list of property changes we are waiting for.
899 DISPLAY, WINDOW, PROPERTY, STATE describe what we will wait for.
900 The return value is a number that uniquely identifies
901 this awaited property change. */
903 static struct prop_location
*
904 expect_property_change (display
, window
, property
, state
)
910 struct prop_location
*pl
911 = (struct prop_location
*) xmalloc (sizeof (struct prop_location
));
912 pl
->identifier
= ++prop_location_identifier
;
913 pl
->display
= display
;
915 pl
->property
= property
;
916 pl
->desired_state
= state
;
917 pl
->next
= property_change_wait_list
;
919 property_change_wait_list
= pl
;
923 /* Delete an entry from the list of property changes we are waiting for.
924 IDENTIFIER is the number that uniquely identifies the entry. */
927 unexpect_property_change (location
)
928 struct prop_location
*location
;
930 struct prop_location
*prev
= 0, *rest
= property_change_wait_list
;
933 if (rest
== location
)
936 prev
->next
= rest
->next
;
938 property_change_wait_list
= rest
->next
;
947 /* Remove the property change expectation element for IDENTIFIER. */
950 wait_for_property_change_unwind (identifierval
)
951 Lisp_Object identifierval
;
953 unexpect_property_change ((struct prop_location
*)
954 (XFASTINT (XCONS (identifierval
)->car
) << 16
955 | XFASTINT (XCONS (identifierval
)->cdr
)));
959 /* Actually wait for a property change.
960 IDENTIFIER should be the value that expect_property_change returned. */
963 wait_for_property_change (location
)
964 struct prop_location
*location
;
967 int count
= specpdl_ptr
- specpdl
;
970 tem
= Fcons (Qnil
, Qnil
);
971 XSETFASTINT (XCONS (tem
)->car
, (EMACS_UINT
)location
>> 16);
972 XSETFASTINT (XCONS (tem
)->cdr
, (EMACS_UINT
)location
& 0xffff);
974 /* Make sure to do unexpect_property_change if we quit or err. */
975 record_unwind_protect (wait_for_property_change_unwind
, tem
);
977 XCONS (property_change_reply
)->car
= Qnil
;
979 property_change_reply_object
= location
;
980 /* If the event we are waiting for arrives beyond here, it will set
981 property_change_reply, because property_change_reply_object says so. */
982 if (! location
->arrived
)
984 secs
= x_selection_timeout
/ 1000;
985 usecs
= (x_selection_timeout
% 1000) * 1000;
986 wait_reading_process_input (secs
, usecs
, property_change_reply
, 0);
988 if (NILP (XCONS (property_change_reply
)->car
))
989 error ("Timed out waiting for property-notify event");
992 unbind_to (count
, Qnil
);
995 /* Called from XTread_socket in response to a PropertyNotify event. */
998 x_handle_property_notify (event
)
999 XPropertyEvent
*event
;
1001 struct prop_location
*prev
= 0, *rest
= property_change_wait_list
;
1004 if (rest
->property
== event
->atom
1005 && rest
->window
== event
->window
1006 && rest
->display
== event
->display
1007 && rest
->desired_state
== event
->state
)
1010 fprintf (stderr
, "Saw expected prop-%s on %s\n",
1011 (event
->state
== PropertyDelete
? "delete" : "change"),
1012 (char *) XSYMBOL (x_atom_to_symbol (dpyinfo
, event
->display
,
1019 /* If this is the one wait_for_property_change is waiting for,
1020 tell it to wake up. */
1021 if (rest
== property_change_reply_object
)
1022 XCONS (property_change_reply
)->car
= Qt
;
1025 prev
->next
= rest
->next
;
1027 property_change_wait_list
= rest
->next
;
1035 fprintf (stderr
, "Saw UNexpected prop-%s on %s\n",
1036 (event
->state
== PropertyDelete
? "delete" : "change"),
1037 (char *) XSYMBOL (x_atom_to_symbol (dpyinfo
,
1038 event
->display
, event
->atom
))
1045 #if 0 /* #### MULTIPLE doesn't work yet */
1048 fetch_multiple_target (event
)
1049 XSelectionRequestEvent
*event
;
1051 Display
*display
= event
->display
;
1052 Window window
= event
->requestor
;
1053 Atom target
= event
->target
;
1054 Atom selection_atom
= event
->selection
;
1059 x_get_window_property_as_lisp_data (display
, window
, target
,
1060 QMULTIPLE
, selection_atom
));
1064 copy_multiple_data (obj
)
1071 return Fcons (XCONS (obj
)->car
, copy_multiple_data (XCONS (obj
)->cdr
));
1073 CHECK_VECTOR (obj
, 0);
1074 vec
= Fmake_vector (size
= XVECTOR (obj
)->size
, Qnil
);
1075 for (i
= 0; i
< size
; i
++)
1077 Lisp_Object vec2
= XVECTOR (obj
)->contents
[i
];
1078 CHECK_VECTOR (vec2
, 0);
1079 if (XVECTOR (vec2
)->size
!= 2)
1080 /* ??? Confusing error message */
1081 Fsignal (Qerror
, Fcons (build_string ("vectors must be of length 2"),
1082 Fcons (vec2
, Qnil
)));
1083 XVECTOR (vec
)->contents
[i
] = Fmake_vector (2, Qnil
);
1084 XVECTOR (XVECTOR (vec
)->contents
[i
])->contents
[0]
1085 = XVECTOR (vec2
)->contents
[0];
1086 XVECTOR (XVECTOR (vec
)->contents
[i
])->contents
[1]
1087 = XVECTOR (vec2
)->contents
[1];
1095 /* Variables for communication with x_handle_selection_notify. */
1096 static Atom reading_which_selection
;
1097 static Lisp_Object reading_selection_reply
;
1098 static Window reading_selection_window
;
1100 /* Do protocol to read selection-data from the server.
1101 Converts this to Lisp data and returns it. */
1104 x_get_foreign_selection (selection_symbol
, target_type
)
1105 Lisp_Object selection_symbol
, target_type
;
1107 Window requestor_window
= FRAME_X_WINDOW (selected_frame
);
1108 Display
*display
= FRAME_X_DISPLAY (selected_frame
);
1109 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
1110 Time requestor_time
= last_event_timestamp
;
1111 Atom target_property
= dpyinfo
->Xatom_EMACS_TMP
;
1112 Atom selection_atom
= symbol_to_x_atom (dpyinfo
, display
, selection_symbol
);
1118 if (CONSP (target_type
))
1119 type_atom
= symbol_to_x_atom (dpyinfo
, display
, XCONS (target_type
)->car
);
1121 type_atom
= symbol_to_x_atom (dpyinfo
, display
, target_type
);
1124 count
= x_catch_errors (display
);
1125 XConvertSelection (display
, selection_atom
, type_atom
, target_property
,
1126 requestor_window
, requestor_time
);
1129 /* Prepare to block until the reply has been read. */
1130 reading_selection_window
= requestor_window
;
1131 reading_which_selection
= selection_atom
;
1132 XCONS (reading_selection_reply
)->car
= Qnil
;
1134 frame
= some_frame_on_display (dpyinfo
);
1136 /* If the display no longer has frames, we can't expect
1137 to get many more selection requests from it, so don't
1138 bother trying to queue them. */
1141 x_start_queuing_selection_requests (display
);
1143 record_unwind_protect (queue_selection_requests_unwind
,
1148 /* This allows quits. Also, don't wait forever. */
1149 secs
= x_selection_timeout
/ 1000;
1150 usecs
= (x_selection_timeout
% 1000) * 1000;
1151 wait_reading_process_input (secs
, usecs
, reading_selection_reply
, 0);
1154 x_check_errors (display
, "Cannot get selection: %s");
1155 x_uncatch_errors (display
, count
);
1158 if (NILP (XCONS (reading_selection_reply
)->car
))
1159 error ("Timed out waiting for reply from selection owner");
1160 if (EQ (XCONS (reading_selection_reply
)->car
, Qlambda
))
1161 error ("No `%s' selection", XSYMBOL (selection_symbol
)->name
->data
);
1163 /* Otherwise, the selection is waiting for us on the requested property. */
1165 x_get_window_property_as_lisp_data (display
, requestor_window
,
1166 target_property
, target_type
,
1170 /* Subroutines of x_get_window_property_as_lisp_data */
1172 /* Use xfree, not XFree, to free the data obtained with this function. */
1175 x_get_window_property (display
, window
, property
, data_ret
, bytes_ret
,
1176 actual_type_ret
, actual_format_ret
, actual_size_ret
,
1181 unsigned char **data_ret
;
1183 Atom
*actual_type_ret
;
1184 int *actual_format_ret
;
1185 unsigned long *actual_size_ret
;
1189 unsigned long bytes_remaining
;
1191 unsigned char *tmp_data
= 0;
1193 int buffer_size
= SELECTION_QUANTUM (display
);
1194 if (buffer_size
> MAX_SELECTION_QUANTUM
) buffer_size
= MAX_SELECTION_QUANTUM
;
1197 /* First probe the thing to find out how big it is. */
1198 result
= XGetWindowProperty (display
, window
, property
,
1199 0L, 0L, False
, AnyPropertyType
,
1200 actual_type_ret
, actual_format_ret
,
1202 &bytes_remaining
, &tmp_data
);
1203 if (result
!= Success
)
1210 /* This was allocated by Xlib, so use XFree. */
1211 XFree ((char *) tmp_data
);
1213 if (*actual_type_ret
== None
|| *actual_format_ret
== 0)
1219 total_size
= bytes_remaining
+ 1;
1220 *data_ret
= (unsigned char *) xmalloc (total_size
);
1222 /* Now read, until we've gotten it all. */
1223 while (bytes_remaining
)
1226 int last
= bytes_remaining
;
1229 = XGetWindowProperty (display
, window
, property
,
1230 (long)offset
/4, (long)buffer_size
/4,
1233 actual_type_ret
, actual_format_ret
,
1234 actual_size_ret
, &bytes_remaining
, &tmp_data
);
1236 fprintf (stderr
, "<< read %d\n", last
-bytes_remaining
);
1238 /* If this doesn't return Success at this point, it means that
1239 some clod deleted the selection while we were in the midst of
1240 reading it. Deal with that, I guess....
1242 if (result
!= Success
) break;
1243 *actual_size_ret
*= *actual_format_ret
/ 8;
1244 bcopy (tmp_data
, (*data_ret
) + offset
, *actual_size_ret
);
1245 offset
+= *actual_size_ret
;
1246 /* This was allocated by Xlib, so use XFree. */
1247 XFree ((char *) tmp_data
);
1252 *bytes_ret
= offset
;
1255 /* Use xfree, not XFree, to free the data obtained with this function. */
1258 receive_incremental_selection (display
, window
, property
, target_type
,
1259 min_size_bytes
, data_ret
, size_bytes_ret
,
1260 type_ret
, format_ret
, size_ret
)
1264 Lisp_Object target_type
; /* for error messages only */
1265 unsigned int min_size_bytes
;
1266 unsigned char **data_ret
;
1267 int *size_bytes_ret
;
1269 unsigned long *size_ret
;
1273 struct prop_location
*wait_object
;
1274 *size_bytes_ret
= min_size_bytes
;
1275 *data_ret
= (unsigned char *) xmalloc (*size_bytes_ret
);
1277 fprintf (stderr
, "\nread INCR %d\n", min_size_bytes
);
1280 /* At this point, we have read an INCR property.
1281 Delete the property to ack it.
1282 (But first, prepare to receive the next event in this handshake.)
1284 Now, we must loop, waiting for the sending window to put a value on
1285 that property, then reading the property, then deleting it to ack.
1286 We are done when the sender places a property of length 0.
1289 XSelectInput (display
, window
, STANDARD_EVENT_SET
| PropertyChangeMask
);
1290 XDeleteProperty (display
, window
, property
);
1291 wait_object
= expect_property_change (display
, window
, property
,
1298 unsigned char *tmp_data
;
1300 wait_for_property_change (wait_object
);
1301 /* expect it again immediately, because x_get_window_property may
1302 .. no it won't, I don't get it.
1303 .. Ok, I get it now, the Xt code that implements INCR is broken.
1305 x_get_window_property (display
, window
, property
,
1306 &tmp_data
, &tmp_size_bytes
,
1307 type_ret
, format_ret
, size_ret
, 1);
1309 if (tmp_size_bytes
== 0) /* we're done */
1312 fprintf (stderr
, " read INCR done\n");
1314 if (! waiting_for_other_props_on_window (display
, window
))
1315 XSelectInput (display
, window
, STANDARD_EVENT_SET
);
1316 unexpect_property_change (wait_object
);
1317 /* Use xfree, not XFree, because x_get_window_property
1318 calls xmalloc itself. */
1319 if (tmp_data
) xfree (tmp_data
);
1324 XDeleteProperty (display
, window
, property
);
1325 wait_object
= expect_property_change (display
, window
, property
,
1331 fprintf (stderr
, " read INCR %d\n", tmp_size_bytes
);
1333 if (*size_bytes_ret
< offset
+ tmp_size_bytes
)
1336 fprintf (stderr
, " read INCR realloc %d -> %d\n",
1337 *size_bytes_ret
, offset
+ tmp_size_bytes
);
1339 *size_bytes_ret
= offset
+ tmp_size_bytes
;
1340 *data_ret
= (unsigned char *) xrealloc (*data_ret
, *size_bytes_ret
);
1342 bcopy (tmp_data
, (*data_ret
) + offset
, tmp_size_bytes
);
1343 offset
+= tmp_size_bytes
;
1344 /* Use xfree, not XFree, because x_get_window_property
1345 calls xmalloc itself. */
1350 /* Once a requested selection is "ready" (we got a SelectionNotify event),
1351 fetch value from property PROPERTY of X window WINDOW on display DISPLAY.
1352 TARGET_TYPE and SELECTION_ATOM are used in error message if this fails. */
1355 x_get_window_property_as_lisp_data (display
, window
, property
, target_type
,
1360 Lisp_Object target_type
; /* for error messages only */
1361 Atom selection_atom
; /* for error messages only */
1365 unsigned long actual_size
;
1366 unsigned char *data
= 0;
1369 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1371 x_get_window_property (display
, window
, property
, &data
, &bytes
,
1372 &actual_type
, &actual_format
, &actual_size
, 1);
1375 int there_is_a_selection_owner
;
1377 there_is_a_selection_owner
1378 = XGetSelectionOwner (display
, selection_atom
);
1381 there_is_a_selection_owner
1382 ? Fcons (build_string ("selection owner couldn't convert"),
1384 ? Fcons (target_type
,
1385 Fcons (x_atom_to_symbol (dpyinfo
, display
,
1388 : Fcons (target_type
, Qnil
))
1389 : Fcons (build_string ("no selection"),
1390 Fcons (x_atom_to_symbol (dpyinfo
, display
,
1395 if (actual_type
== dpyinfo
->Xatom_INCR
)
1397 /* That wasn't really the data, just the beginning. */
1399 unsigned int min_size_bytes
= * ((unsigned int *) data
);
1401 /* Use xfree, not XFree, because x_get_window_property
1402 calls xmalloc itself. */
1403 xfree ((char *) data
);
1405 receive_incremental_selection (display
, window
, property
, target_type
,
1406 min_size_bytes
, &data
, &bytes
,
1407 &actual_type
, &actual_format
,
1412 XDeleteProperty (display
, window
, property
);
1416 /* It's been read. Now convert it to a lisp object in some semi-rational
1418 val
= selection_data_to_lisp_data (display
, data
, bytes
,
1419 actual_type
, actual_format
);
1421 /* Use xfree, not XFree, because x_get_window_property
1422 calls xmalloc itself. */
1423 xfree ((char *) data
);
1427 /* These functions convert from the selection data read from the server into
1428 something that we can use from Lisp, and vice versa.
1430 Type: Format: Size: Lisp Type:
1431 ----- ------- ----- -----------
1434 ATOM 32 > 1 Vector of Symbols
1436 * 16 > 1 Vector of Integers
1437 * 32 1 if <=16 bits: Integer
1438 if > 16 bits: Cons of top16, bot16
1439 * 32 > 1 Vector of the above
1441 When converting a Lisp number to C, it is assumed to be of format 16 if
1442 it is an integer, and of format 32 if it is a cons of two integers.
1444 When converting a vector of numbers from Lisp to C, it is assumed to be
1445 of format 16 if every element in the vector is an integer, and is assumed
1446 to be of format 32 if any element is a cons of two integers.
1448 When converting an object to C, it may be of the form (SYMBOL . <data>)
1449 where SYMBOL is what we should claim that the type is. Format and
1450 representation are as above. */
1455 selection_data_to_lisp_data (display
, data
, size
, type
, format
)
1457 unsigned char *data
;
1461 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1463 if (type
== dpyinfo
->Xatom_NULL
)
1466 /* Convert any 8-bit data to a string, for compactness. */
1467 else if (format
== 8)
1470 int require_encoding
= 0;
1472 if (! NILP (buffer_defaults
.enable_multibyte_characters
))
1474 /* If TYPE is `TEXT' or `COMPOUND_TEXT', we should decode
1475 DATA to Emacs internal format because DATA may be encoded
1476 in compound text format. In addtion, if TYPE is `STRING'
1477 and DATA contains any 8-bit Latin-1 code, we should also
1479 if (type
== dpyinfo
->Xatom_TEXT
1480 || type
== dpyinfo
->Xatom_COMPOUND_TEXT
)
1481 require_encoding
= 1;
1482 else if (type
== XA_STRING
)
1485 for (i
= 0; i
< size
; i
++)
1487 if (data
[i
] >= 0x80)
1489 require_encoding
= 1;
1495 if (!require_encoding
)
1496 str
= make_unibyte_string ((char *) data
, size
);
1501 struct coding_system coding
;
1504 (Fcheck_coding_system(Vclipboard_coding_system
), &coding
);
1505 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
1506 bufsize
= decoding_buffer_size (&coding
, size
);
1507 buf
= (unsigned char *) xmalloc (bufsize
);
1508 decode_coding (&coding
, data
, buf
, size
, bufsize
);
1509 str
= make_multibyte_string ((char *) buf
,
1510 coding
.produced_char
, coding
.produced
);
1515 /* Convert a single atom to a Lisp_Symbol. Convert a set of atoms to
1516 a vector of symbols.
1518 else if (type
== XA_ATOM
)
1521 if (size
== sizeof (Atom
))
1522 return x_atom_to_symbol (dpyinfo
, display
, *((Atom
*) data
));
1525 Lisp_Object v
= Fmake_vector (make_number (size
/ sizeof (Atom
)),
1527 for (i
= 0; i
< size
/ sizeof (Atom
); i
++)
1528 Faset (v
, make_number (i
),
1529 x_atom_to_symbol (dpyinfo
, display
, ((Atom
*) data
) [i
]));
1534 /* Convert a single 16 or small 32 bit number to a Lisp_Int.
1535 If the number is > 16 bits, convert it to a cons of integers,
1536 16 bits in each half.
1538 else if (format
== 32 && size
== sizeof (long))
1539 return long_to_cons (((unsigned long *) data
) [0]);
1540 else if (format
== 16 && size
== sizeof (short))
1541 return make_number ((int) (((unsigned short *) data
) [0]));
1543 /* Convert any other kind of data to a vector of numbers, represented
1544 as above (as an integer, or a cons of two 16 bit integers.)
1546 else if (format
== 16)
1550 v
= Fmake_vector (make_number (size
/ 2), make_number (0));
1551 for (i
= 0; i
< size
/ 2; i
++)
1553 int j
= (int) ((unsigned short *) data
) [i
];
1554 Faset (v
, make_number (i
), make_number (j
));
1561 Lisp_Object v
= Fmake_vector (make_number (size
/ 4), make_number (0));
1562 for (i
= 0; i
< size
/ 4; i
++)
1564 unsigned long j
= ((unsigned long *) data
) [i
];
1565 Faset (v
, make_number (i
), long_to_cons (j
));
1572 /* Use xfree, not XFree, to free the data obtained with this function. */
1575 lisp_data_to_selection_data (display
, obj
,
1576 data_ret
, type_ret
, size_ret
,
1577 format_ret
, nofree_ret
)
1580 unsigned char **data_ret
;
1582 unsigned int *size_ret
;
1586 Lisp_Object type
= Qnil
;
1587 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1591 if (CONSP (obj
) && SYMBOLP (XCONS (obj
)->car
))
1593 type
= XCONS (obj
)->car
;
1594 obj
= XCONS (obj
)->cdr
;
1595 if (CONSP (obj
) && NILP (XCONS (obj
)->cdr
))
1596 obj
= XCONS (obj
)->car
;
1599 if (EQ (obj
, QNULL
) || (EQ (type
, QNULL
)))
1600 { /* This is not the same as declining */
1606 else if (STRINGP (obj
))
1608 /* Since we are now handling multilingual text, we must consider
1609 sending back compound text. */
1610 int charsets
[MAX_CHARSET
+ 1];
1614 *size_ret
= STRING_BYTES (XSTRING (obj
));
1615 *data_ret
= XSTRING (obj
)->data
;
1616 bzero (charsets
, (MAX_CHARSET
+ 1) * sizeof (int));
1617 num
= ((*size_ret
<= 1 /* Check the possibility of short cut. */
1618 || NILP (buffer_defaults
.enable_multibyte_characters
))
1620 : find_charset_in_str (*data_ret
, *size_ret
, charsets
, Qnil
));
1622 if (!num
|| (num
== 1 && charsets
[CHARSET_ASCII
]))
1624 /* No multibyte character in OBJ. We need not encode it. */
1626 if (NILP (type
)) type
= QSTRING
;
1630 /* We must encode contents of OBJ to compound text format.
1631 The format is compatible with what the target `STRING'
1632 expects if OBJ contains only ASCII and Latin-1
1636 struct coding_system coding
;
1639 (Fcheck_coding_system (Vclipboard_coding_system
), &coding
);
1640 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
1641 bufsize
= encoding_buffer_size (&coding
, *size_ret
);
1642 buf
= (unsigned char *) xmalloc (bufsize
);
1643 encode_coding (&coding
, *data_ret
, buf
, *size_ret
, bufsize
);
1644 *size_ret
= coding
.produced
;
1646 if (charsets
[charset_latin_iso8859_1
]
1647 && (num
== 1 || (num
== 2 && charsets
[CHARSET_ASCII
])))
1649 /* Ok, we can return it as `STRING'. */
1650 if (NILP (type
)) type
= QSTRING
;
1654 /* We must return it as `COMPOUND_TEXT'. */
1655 if (NILP (type
)) type
= QCOMPOUND_TEXT
;
1659 else if (SYMBOLP (obj
))
1663 *data_ret
= (unsigned char *) xmalloc (sizeof (Atom
) + 1);
1664 (*data_ret
) [sizeof (Atom
)] = 0;
1665 (*(Atom
**) data_ret
) [0] = symbol_to_x_atom (dpyinfo
, display
, obj
);
1666 if (NILP (type
)) type
= QATOM
;
1668 else if (INTEGERP (obj
)
1669 && XINT (obj
) < 0xFFFF
1670 && XINT (obj
) > -0xFFFF)
1674 *data_ret
= (unsigned char *) xmalloc (sizeof (short) + 1);
1675 (*data_ret
) [sizeof (short)] = 0;
1676 (*(short **) data_ret
) [0] = (short) XINT (obj
);
1677 if (NILP (type
)) type
= QINTEGER
;
1679 else if (INTEGERP (obj
)
1680 || (CONSP (obj
) && INTEGERP (XCONS (obj
)->car
)
1681 && (INTEGERP (XCONS (obj
)->cdr
)
1682 || (CONSP (XCONS (obj
)->cdr
)
1683 && INTEGERP (XCONS (XCONS (obj
)->cdr
)->car
)))))
1687 *data_ret
= (unsigned char *) xmalloc (sizeof (long) + 1);
1688 (*data_ret
) [sizeof (long)] = 0;
1689 (*(unsigned long **) data_ret
) [0] = cons_to_long (obj
);
1690 if (NILP (type
)) type
= QINTEGER
;
1692 else if (VECTORP (obj
))
1694 /* Lisp_Vectors may represent a set of ATOMs;
1695 a set of 16 or 32 bit INTEGERs;
1696 or a set of ATOM_PAIRs (represented as [[A1 A2] [A3 A4] ...]
1700 if (SYMBOLP (XVECTOR (obj
)->contents
[0]))
1701 /* This vector is an ATOM set */
1703 if (NILP (type
)) type
= QATOM
;
1704 *size_ret
= XVECTOR (obj
)->size
;
1706 *data_ret
= (unsigned char *) xmalloc ((*size_ret
) * sizeof (Atom
));
1707 for (i
= 0; i
< *size_ret
; i
++)
1708 if (SYMBOLP (XVECTOR (obj
)->contents
[i
]))
1709 (*(Atom
**) data_ret
) [i
]
1710 = symbol_to_x_atom (dpyinfo
, display
, XVECTOR (obj
)->contents
[i
]);
1712 Fsignal (Qerror
, /* Qselection_error */
1714 ("all elements of selection vector must have same type"),
1715 Fcons (obj
, Qnil
)));
1717 #if 0 /* #### MULTIPLE doesn't work yet */
1718 else if (VECTORP (XVECTOR (obj
)->contents
[0]))
1719 /* This vector is an ATOM_PAIR set */
1721 if (NILP (type
)) type
= QATOM_PAIR
;
1722 *size_ret
= XVECTOR (obj
)->size
;
1724 *data_ret
= (unsigned char *)
1725 xmalloc ((*size_ret
) * sizeof (Atom
) * 2);
1726 for (i
= 0; i
< *size_ret
; i
++)
1727 if (VECTORP (XVECTOR (obj
)->contents
[i
]))
1729 Lisp_Object pair
= XVECTOR (obj
)->contents
[i
];
1730 if (XVECTOR (pair
)->size
!= 2)
1733 ("elements of the vector must be vectors of exactly two elements"),
1734 Fcons (pair
, Qnil
)));
1736 (*(Atom
**) data_ret
) [i
* 2]
1737 = symbol_to_x_atom (dpyinfo
, display
,
1738 XVECTOR (pair
)->contents
[0]);
1739 (*(Atom
**) data_ret
) [(i
* 2) + 1]
1740 = symbol_to_x_atom (dpyinfo
, display
,
1741 XVECTOR (pair
)->contents
[1]);
1746 ("all elements of the vector must be of the same type"),
1747 Fcons (obj
, Qnil
)));
1752 /* This vector is an INTEGER set, or something like it */
1754 *size_ret
= XVECTOR (obj
)->size
;
1755 if (NILP (type
)) type
= QINTEGER
;
1757 for (i
= 0; i
< *size_ret
; i
++)
1758 if (CONSP (XVECTOR (obj
)->contents
[i
]))
1760 else if (!INTEGERP (XVECTOR (obj
)->contents
[i
]))
1761 Fsignal (Qerror
, /* Qselection_error */
1763 ("elements of selection vector must be integers or conses of integers"),
1764 Fcons (obj
, Qnil
)));
1766 *data_ret
= (unsigned char *) xmalloc (*size_ret
* (*format_ret
/8));
1767 for (i
= 0; i
< *size_ret
; i
++)
1768 if (*format_ret
== 32)
1769 (*((unsigned long **) data_ret
)) [i
]
1770 = cons_to_long (XVECTOR (obj
)->contents
[i
]);
1772 (*((unsigned short **) data_ret
)) [i
]
1773 = (unsigned short) cons_to_long (XVECTOR (obj
)->contents
[i
]);
1777 Fsignal (Qerror
, /* Qselection_error */
1778 Fcons (build_string ("unrecognised selection data"),
1779 Fcons (obj
, Qnil
)));
1781 *type_ret
= symbol_to_x_atom (dpyinfo
, display
, type
);
1785 clean_local_selection_data (obj
)
1789 && INTEGERP (XCONS (obj
)->car
)
1790 && CONSP (XCONS (obj
)->cdr
)
1791 && INTEGERP (XCONS (XCONS (obj
)->cdr
)->car
)
1792 && NILP (XCONS (XCONS (obj
)->cdr
)->cdr
))
1793 obj
= Fcons (XCONS (obj
)->car
, XCONS (obj
)->cdr
);
1796 && INTEGERP (XCONS (obj
)->car
)
1797 && INTEGERP (XCONS (obj
)->cdr
))
1799 if (XINT (XCONS (obj
)->car
) == 0)
1800 return XCONS (obj
)->cdr
;
1801 if (XINT (XCONS (obj
)->car
) == -1)
1802 return make_number (- XINT (XCONS (obj
)->cdr
));
1807 int size
= XVECTOR (obj
)->size
;
1810 return clean_local_selection_data (XVECTOR (obj
)->contents
[0]);
1811 copy
= Fmake_vector (make_number (size
), Qnil
);
1812 for (i
= 0; i
< size
; i
++)
1813 XVECTOR (copy
)->contents
[i
]
1814 = clean_local_selection_data (XVECTOR (obj
)->contents
[i
]);
1820 /* Called from XTread_socket to handle SelectionNotify events.
1821 If it's the selection we are waiting for, stop waiting
1822 by setting the car of reading_selection_reply to non-nil.
1823 We store t there if the reply is successful, lambda if not. */
1826 x_handle_selection_notify (event
)
1827 XSelectionEvent
*event
;
1829 if (event
->requestor
!= reading_selection_window
)
1831 if (event
->selection
!= reading_which_selection
)
1834 XCONS (reading_selection_reply
)->car
1835 = (event
->property
!= 0 ? Qt
: Qlambda
);
1839 DEFUN ("x-own-selection-internal", Fx_own_selection_internal
,
1840 Sx_own_selection_internal
, 2, 2, 0,
1841 "Assert an X selection of the given TYPE with the given VALUE.\n\
1842 TYPE is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1843 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1844 VALUE is typically a string, or a cons of two markers, but may be\n\
1845 anything that the functions on `selection-converter-alist' know about.")
1846 (selection_name
, selection_value
)
1847 Lisp_Object selection_name
, selection_value
;
1850 CHECK_SYMBOL (selection_name
, 0);
1851 if (NILP (selection_value
)) error ("selection-value may not be nil");
1852 x_own_selection (selection_name
, selection_value
);
1853 return selection_value
;
1857 /* Request the selection value from the owner. If we are the owner,
1858 simply return our selection value. If we are not the owner, this
1859 will block until all of the data has arrived. */
1861 DEFUN ("x-get-selection-internal", Fx_get_selection_internal
,
1862 Sx_get_selection_internal
, 2, 2, 0,
1863 "Return text selected from some X window.\n\
1864 SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1865 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1866 TYPE is the type of data desired, typically `STRING'.")
1867 (selection_symbol
, target_type
)
1868 Lisp_Object selection_symbol
, target_type
;
1870 Lisp_Object val
= Qnil
;
1871 struct gcpro gcpro1
, gcpro2
;
1872 GCPRO2 (target_type
, val
); /* we store newly consed data into these */
1874 CHECK_SYMBOL (selection_symbol
, 0);
1876 #if 0 /* #### MULTIPLE doesn't work yet */
1877 if (CONSP (target_type
)
1878 && XCONS (target_type
)->car
== QMULTIPLE
)
1880 CHECK_VECTOR (XCONS (target_type
)->cdr
, 0);
1881 /* So we don't destructively modify this... */
1882 target_type
= copy_multiple_data (target_type
);
1886 CHECK_SYMBOL (target_type
, 0);
1888 val
= x_get_local_selection (selection_symbol
, target_type
);
1892 val
= x_get_foreign_selection (selection_symbol
, target_type
);
1897 && SYMBOLP (XCONS (val
)->car
))
1899 val
= XCONS (val
)->cdr
;
1900 if (CONSP (val
) && NILP (XCONS (val
)->cdr
))
1901 val
= XCONS (val
)->car
;
1903 val
= clean_local_selection_data (val
);
1909 DEFUN ("x-disown-selection-internal", Fx_disown_selection_internal
,
1910 Sx_disown_selection_internal
, 1, 2, 0,
1911 "If we own the selection SELECTION, disown it.\n\
1912 Disowning it means there is no such selection.")
1914 Lisp_Object selection
;
1918 Atom selection_atom
;
1919 struct selection_input_event event
;
1921 struct x_display_info
*dpyinfo
;
1924 display
= FRAME_X_DISPLAY (selected_frame
);
1925 dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
1926 CHECK_SYMBOL (selection
, 0);
1928 timestamp
= last_event_timestamp
;
1930 timestamp
= cons_to_long (time
);
1932 if (NILP (assq_no_quit (selection
, Vselection_alist
)))
1933 return Qnil
; /* Don't disown the selection when we're not the owner. */
1935 selection_atom
= symbol_to_x_atom (dpyinfo
, display
, selection
);
1938 XSetSelectionOwner (display
, selection_atom
, None
, timestamp
);
1941 /* It doesn't seem to be guaranteed that a SelectionClear event will be
1942 generated for a window which owns the selection when that window sets
1943 the selection owner to None. The NCD server does, the MIT Sun4 server
1944 doesn't. So we synthesize one; this means we might get two, but
1945 that's ok, because the second one won't have any effect. */
1946 SELECTION_EVENT_DISPLAY (&event
) = display
;
1947 SELECTION_EVENT_SELECTION (&event
) = selection_atom
;
1948 SELECTION_EVENT_TIME (&event
) = timestamp
;
1949 x_handle_selection_clear ((struct input_event
*) &event
);
1954 /* Get rid of all the selections in buffer BUFFER.
1955 This is used when we kill a buffer. */
1958 x_disown_buffer_selections (buffer
)
1962 struct buffer
*buf
= XBUFFER (buffer
);
1964 for (tail
= Vselection_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1966 Lisp_Object elt
, value
;
1967 elt
= XCONS (tail
)->car
;
1968 value
= XCONS (elt
)->cdr
;
1969 if (CONSP (value
) && MARKERP (XCONS (value
)->car
)
1970 && XMARKER (XCONS (value
)->car
)->buffer
== buf
)
1971 Fx_disown_selection_internal (XCONS (elt
)->car
, Qnil
);
1975 DEFUN ("x-selection-owner-p", Fx_selection_owner_p
, Sx_selection_owner_p
,
1977 "Whether the current Emacs process owns the given X Selection.\n\
1978 The arg should be the name of the selection in question, typically one of\n\
1979 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1980 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1981 For convenience, the symbol nil is the same as `PRIMARY',\n\
1982 and t is the same as `SECONDARY'.)")
1984 Lisp_Object selection
;
1987 CHECK_SYMBOL (selection
, 0);
1988 if (EQ (selection
, Qnil
)) selection
= QPRIMARY
;
1989 if (EQ (selection
, Qt
)) selection
= QSECONDARY
;
1991 if (NILP (Fassq (selection
, Vselection_alist
)))
1996 DEFUN ("x-selection-exists-p", Fx_selection_exists_p
, Sx_selection_exists_p
,
1998 "Whether there is an owner for the given X Selection.\n\
1999 The arg should be the name of the selection in question, typically one of\n\
2000 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
2001 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
2002 For convenience, the symbol nil is the same as `PRIMARY',\n\
2003 and t is the same as `SECONDARY'.)")
2005 Lisp_Object selection
;
2011 /* It should be safe to call this before we have an X frame. */
2012 if (! FRAME_X_P (selected_frame
))
2015 dpy
= FRAME_X_DISPLAY (selected_frame
);
2016 CHECK_SYMBOL (selection
, 0);
2017 if (!NILP (Fx_selection_owner_p (selection
)))
2019 if (EQ (selection
, Qnil
)) selection
= QPRIMARY
;
2020 if (EQ (selection
, Qt
)) selection
= QSECONDARY
;
2021 atom
= symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame
),
2026 owner
= XGetSelectionOwner (dpy
, atom
);
2028 return (owner
? Qt
: Qnil
);
2032 #ifdef CUT_BUFFER_SUPPORT
2034 /* Ensure that all 8 cut buffers exist. ICCCM says we gotta... */
2036 initialize_cut_buffers (display
, window
)
2040 unsigned char *data
= (unsigned char *) "";
2042 #define FROB(atom) XChangeProperty (display, window, atom, XA_STRING, 8, \
2043 PropModeAppend, data, 0)
2044 FROB (XA_CUT_BUFFER0
);
2045 FROB (XA_CUT_BUFFER1
);
2046 FROB (XA_CUT_BUFFER2
);
2047 FROB (XA_CUT_BUFFER3
);
2048 FROB (XA_CUT_BUFFER4
);
2049 FROB (XA_CUT_BUFFER5
);
2050 FROB (XA_CUT_BUFFER6
);
2051 FROB (XA_CUT_BUFFER7
);
2057 #define CHECK_CUT_BUFFER(symbol,n) \
2058 { CHECK_SYMBOL ((symbol), (n)); \
2059 if (!EQ((symbol), QCUT_BUFFER0) && !EQ((symbol), QCUT_BUFFER1) \
2060 && !EQ((symbol), QCUT_BUFFER2) && !EQ((symbol), QCUT_BUFFER3) \
2061 && !EQ((symbol), QCUT_BUFFER4) && !EQ((symbol), QCUT_BUFFER5) \
2062 && !EQ((symbol), QCUT_BUFFER6) && !EQ((symbol), QCUT_BUFFER7)) \
2064 Fcons (build_string ("doesn't name a cut buffer"), \
2065 Fcons ((symbol), Qnil))); \
2068 DEFUN ("x-get-cut-buffer-internal", Fx_get_cut_buffer_internal
,
2069 Sx_get_cut_buffer_internal
, 1, 1, 0,
2070 "Returns the value of the named cut buffer (typically CUT_BUFFER0).")
2076 unsigned char *data
;
2083 struct x_display_info
*dpyinfo
;
2086 display
= FRAME_X_DISPLAY (selected_frame
);
2087 dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
2088 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2089 CHECK_CUT_BUFFER (buffer
, 0);
2090 buffer_atom
= symbol_to_x_atom (dpyinfo
, display
, buffer
);
2092 x_get_window_property (display
, window
, buffer_atom
, &data
, &bytes
,
2093 &type
, &format
, &size
, 0);
2094 if (!data
) return Qnil
;
2096 if (format
!= 8 || type
!= XA_STRING
)
2098 Fcons (build_string ("cut buffer doesn't contain 8-bit data"),
2099 Fcons (x_atom_to_symbol (dpyinfo
, display
, type
),
2100 Fcons (make_number (format
), Qnil
))));
2102 ret
= (bytes
? make_string ((char *) data
, bytes
) : Qnil
);
2103 /* Use xfree, not XFree, because x_get_window_property
2104 calls xmalloc itself. */
2110 DEFUN ("x-store-cut-buffer-internal", Fx_store_cut_buffer_internal
,
2111 Sx_store_cut_buffer_internal
, 2, 2, 0,
2112 "Sets the value of the named cut buffer (typically CUT_BUFFER0).")
2114 Lisp_Object buffer
, string
;
2118 unsigned char *data
;
2120 int bytes_remaining
;
2125 display
= FRAME_X_DISPLAY (selected_frame
);
2126 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2128 max_bytes
= SELECTION_QUANTUM (display
);
2129 if (max_bytes
> MAX_SELECTION_QUANTUM
)
2130 max_bytes
= MAX_SELECTION_QUANTUM
;
2132 CHECK_CUT_BUFFER (buffer
, 0);
2133 CHECK_STRING (string
, 0);
2134 buffer_atom
= symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame
),
2136 data
= (unsigned char *) XSTRING (string
)->data
;
2137 bytes
= STRING_BYTES (XSTRING (string
));
2138 bytes_remaining
= bytes
;
2140 if (! FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
)
2142 initialize_cut_buffers (display
, window
);
2143 FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
= 1;
2148 /* Don't mess up with an empty value. */
2149 if (!bytes_remaining
)
2150 XChangeProperty (display
, window
, buffer_atom
, XA_STRING
, 8,
2151 PropModeReplace
, data
, 0);
2153 while (bytes_remaining
)
2155 int chunk
= (bytes_remaining
< max_bytes
2156 ? bytes_remaining
: max_bytes
);
2157 XChangeProperty (display
, window
, buffer_atom
, XA_STRING
, 8,
2158 (bytes_remaining
== bytes
2163 bytes_remaining
-= chunk
;
2170 DEFUN ("x-rotate-cut-buffers-internal", Fx_rotate_cut_buffers_internal
,
2171 Sx_rotate_cut_buffers_internal
, 1, 1, 0,
2172 "Rotate the values of the cut buffers by the given number of step.\n\
2173 Positive means shift the values forward, negative means backward.")
2182 display
= FRAME_X_DISPLAY (selected_frame
);
2183 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2184 CHECK_NUMBER (n
, 0);
2187 if (! FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
)
2189 initialize_cut_buffers (display
, window
);
2190 FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
= 1;
2193 props
[0] = XA_CUT_BUFFER0
;
2194 props
[1] = XA_CUT_BUFFER1
;
2195 props
[2] = XA_CUT_BUFFER2
;
2196 props
[3] = XA_CUT_BUFFER3
;
2197 props
[4] = XA_CUT_BUFFER4
;
2198 props
[5] = XA_CUT_BUFFER5
;
2199 props
[6] = XA_CUT_BUFFER6
;
2200 props
[7] = XA_CUT_BUFFER7
;
2202 XRotateWindowProperties (display
, window
, props
, 8, XINT (n
));
2212 defsubr (&Sx_get_selection_internal
);
2213 defsubr (&Sx_own_selection_internal
);
2214 defsubr (&Sx_disown_selection_internal
);
2215 defsubr (&Sx_selection_owner_p
);
2216 defsubr (&Sx_selection_exists_p
);
2218 #ifdef CUT_BUFFER_SUPPORT
2219 defsubr (&Sx_get_cut_buffer_internal
);
2220 defsubr (&Sx_store_cut_buffer_internal
);
2221 defsubr (&Sx_rotate_cut_buffers_internal
);
2224 reading_selection_reply
= Fcons (Qnil
, Qnil
);
2225 staticpro (&reading_selection_reply
);
2226 reading_selection_window
= 0;
2227 reading_which_selection
= 0;
2229 property_change_wait_list
= 0;
2230 prop_location_identifier
= 0;
2231 property_change_reply
= Fcons (Qnil
, Qnil
);
2232 staticpro (&property_change_reply
);
2234 Vselection_alist
= Qnil
;
2235 staticpro (&Vselection_alist
);
2237 DEFVAR_LISP ("selection-converter-alist", &Vselection_converter_alist
,
2238 "An alist associating X Windows selection-types with functions.\n\
2239 These functions are called to convert the selection, with three args:\n\
2240 the name of the selection (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
2241 a desired type to which the selection should be converted;\n\
2242 and the local selection value (whatever was given to `x-own-selection').\n\
2244 The function should return the value to send to the X server\n\
2245 \(typically a string). A return value of nil\n\
2246 means that the conversion could not be done.\n\
2247 A return value which is the symbol `NULL'\n\
2248 means that a side-effect was executed,\n\
2249 and there is no meaningful selection value.");
2250 Vselection_converter_alist
= Qnil
;
2252 DEFVAR_LISP ("x-lost-selection-hooks", &Vx_lost_selection_hooks
,
2253 "A list of functions to be called when Emacs loses an X selection.\n\
2254 \(This happens when some other X client makes its own selection\n\
2255 or when a Lisp program explicitly clears the selection.)\n\
2256 The functions are called with one argument, the selection type\n\
2257 \(a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD').");
2258 Vx_lost_selection_hooks
= Qnil
;
2260 DEFVAR_LISP ("x-sent-selection-hooks", &Vx_sent_selection_hooks
,
2261 "A list of functions to be called when Emacs answers a selection request.\n\
2262 The functions are called with four arguments:\n\
2263 - the selection name (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
2264 - the selection-type which Emacs was asked to convert the\n\
2265 selection into before sending (for example, `STRING' or `LENGTH');\n\
2266 - a flag indicating success or failure for responding to the request.\n\
2267 We might have failed (and declined the request) for any number of reasons,\n\
2268 including being asked for a selection that we no longer own, or being asked\n\
2269 to convert into a type that we don't know about or that is inappropriate.\n\
2270 This hook doesn't let you change the behavior of Emacs's selection replies,\n\
2271 it merely informs you that they have happened.");
2272 Vx_sent_selection_hooks
= Qnil
;
2274 DEFVAR_LISP ("clipboard-coding-system", &Vclipboard_coding_system
,
2275 "Coding system for communicating with other X clients.\n\
2276 When sending or receiving text via cut_buffer, selection, and clipboard,\n\
2277 the text is encoded or decoded by this coding system.\n\
2278 A default value is `compound-text'");
2279 Vclipboard_coding_system
=intern ("compound-text");
2280 staticpro(&Vclipboard_coding_system
);
2282 DEFVAR_INT ("x-selection-timeout", &x_selection_timeout
,
2283 "Number of milliseconds to wait for a selection reply.\n\
2284 If the selection owner doesn't reply in this time, we give up.\n\
2285 A value of 0 means wait as long as necessary. This is initialized from the\n\
2286 \"*selectionTimeout\" resource.");
2287 x_selection_timeout
= 0;
2289 QPRIMARY
= intern ("PRIMARY"); staticpro (&QPRIMARY
);
2290 QSECONDARY
= intern ("SECONDARY"); staticpro (&QSECONDARY
);
2291 QSTRING
= intern ("STRING"); staticpro (&QSTRING
);
2292 QINTEGER
= intern ("INTEGER"); staticpro (&QINTEGER
);
2293 QCLIPBOARD
= intern ("CLIPBOARD"); staticpro (&QCLIPBOARD
);
2294 QTIMESTAMP
= intern ("TIMESTAMP"); staticpro (&QTIMESTAMP
);
2295 QTEXT
= intern ("TEXT"); staticpro (&QTEXT
);
2296 QCOMPOUND_TEXT
= intern ("COMPOUND_TEXT"); staticpro (&QCOMPOUND_TEXT
);
2297 QTIMESTAMP
= intern ("TIMESTAMP"); staticpro (&QTIMESTAMP
);
2298 QDELETE
= intern ("DELETE"); staticpro (&QDELETE
);
2299 QMULTIPLE
= intern ("MULTIPLE"); staticpro (&QMULTIPLE
);
2300 QINCR
= intern ("INCR"); staticpro (&QINCR
);
2301 QEMACS_TMP
= intern ("_EMACS_TMP_"); staticpro (&QEMACS_TMP
);
2302 QTARGETS
= intern ("TARGETS"); staticpro (&QTARGETS
);
2303 QATOM
= intern ("ATOM"); staticpro (&QATOM
);
2304 QATOM_PAIR
= intern ("ATOM_PAIR"); staticpro (&QATOM_PAIR
);
2305 QNULL
= intern ("NULL"); staticpro (&QNULL
);
2307 #ifdef CUT_BUFFER_SUPPORT
2308 QCUT_BUFFER0
= intern ("CUT_BUFFER0"); staticpro (&QCUT_BUFFER0
);
2309 QCUT_BUFFER1
= intern ("CUT_BUFFER1"); staticpro (&QCUT_BUFFER1
);
2310 QCUT_BUFFER2
= intern ("CUT_BUFFER2"); staticpro (&QCUT_BUFFER2
);
2311 QCUT_BUFFER3
= intern ("CUT_BUFFER3"); staticpro (&QCUT_BUFFER3
);
2312 QCUT_BUFFER4
= intern ("CUT_BUFFER4"); staticpro (&QCUT_BUFFER4
);
2313 QCUT_BUFFER5
= intern ("CUT_BUFFER5"); staticpro (&QCUT_BUFFER5
);
2314 QCUT_BUFFER6
= intern ("CUT_BUFFER6"); staticpro (&QCUT_BUFFER6
);
2315 QCUT_BUFFER7
= intern ("CUT_BUFFER7"); staticpro (&QCUT_BUFFER7
);