1 /* X Selection processing for Emacs.
2 Copyright (C) 1993, 1994, 1995, 1996 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_string ((char *) data
, size
);
1501 struct coding_system coding
;
1504 (Fcheck_coding_system(Vclipboard_coding_system
), &coding
);
1505 coding
.last_block
= 1;
1506 bufsize
= decoding_buffer_size (&coding
, size
);
1507 buf
= (unsigned char *) xmalloc (bufsize
);
1508 size
= decode_coding (&coding
, data
, buf
, size
, bufsize
, &dummy
);
1509 str
= make_string ((char *) buf
, size
);
1514 /* Convert a single atom to a Lisp_Symbol. Convert a set of atoms to
1515 a vector of symbols.
1517 else if (type
== XA_ATOM
)
1520 if (size
== sizeof (Atom
))
1521 return x_atom_to_symbol (dpyinfo
, display
, *((Atom
*) data
));
1524 Lisp_Object v
= Fmake_vector (make_number (size
/ sizeof (Atom
)),
1526 for (i
= 0; i
< size
/ sizeof (Atom
); i
++)
1527 Faset (v
, make_number (i
),
1528 x_atom_to_symbol (dpyinfo
, display
, ((Atom
*) data
) [i
]));
1533 /* Convert a single 16 or small 32 bit number to a Lisp_Int.
1534 If the number is > 16 bits, convert it to a cons of integers,
1535 16 bits in each half.
1537 else if (format
== 32 && size
== sizeof (long))
1538 return long_to_cons (((unsigned long *) data
) [0]);
1539 else if (format
== 16 && size
== sizeof (short))
1540 return make_number ((int) (((unsigned short *) data
) [0]));
1542 /* Convert any other kind of data to a vector of numbers, represented
1543 as above (as an integer, or a cons of two 16 bit integers.)
1545 else if (format
== 16)
1549 v
= Fmake_vector (make_number (size
/ 2), make_number (0));
1550 for (i
= 0; i
< size
/ 2; i
++)
1552 int j
= (int) ((unsigned short *) data
) [i
];
1553 Faset (v
, make_number (i
), make_number (j
));
1560 Lisp_Object v
= Fmake_vector (make_number (size
/ 4), make_number (0));
1561 for (i
= 0; i
< size
/ 4; i
++)
1563 unsigned long j
= ((unsigned long *) data
) [i
];
1564 Faset (v
, make_number (i
), long_to_cons (j
));
1571 /* Use xfree, not XFree, to free the data obtained with this function. */
1574 lisp_data_to_selection_data (display
, obj
,
1575 data_ret
, type_ret
, size_ret
,
1576 format_ret
, nofree_ret
)
1579 unsigned char **data_ret
;
1581 unsigned int *size_ret
;
1585 Lisp_Object type
= Qnil
;
1586 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1590 if (CONSP (obj
) && SYMBOLP (XCONS (obj
)->car
))
1592 type
= XCONS (obj
)->car
;
1593 obj
= XCONS (obj
)->cdr
;
1594 if (CONSP (obj
) && NILP (XCONS (obj
)->cdr
))
1595 obj
= XCONS (obj
)->car
;
1598 if (EQ (obj
, QNULL
) || (EQ (type
, QNULL
)))
1599 { /* This is not the same as declining */
1605 else if (STRINGP (obj
))
1607 /* Since we are now handling multilingual text, we must consider
1608 sending back compound text. */
1609 int charsets
[MAX_CHARSET
+ 1];
1613 *size_ret
= XSTRING (obj
)->size
;
1614 *data_ret
= XSTRING (obj
)->data
;
1615 bzero (charsets
, (MAX_CHARSET
+ 1) * sizeof (int));
1616 num
= ((*size_ret
<= 1 /* Check the possibility of short cut. */
1617 || NILP (buffer_defaults
.enable_multibyte_characters
))
1619 : find_charset_in_str (*data_ret
, *size_ret
, charsets
, Qnil
));
1621 if (!num
|| (num
== 1 && charsets
[CHARSET_ASCII
]))
1623 /* No multibyte character in OBJ. We need not encode it. */
1625 if (NILP (type
)) type
= QSTRING
;
1629 /* We must encode contents of OBJ to compound text format.
1630 The format is compatible with what the target `STRING'
1631 expects if OBJ contains only ASCII and Latin-1
1635 struct coding_system coding
;
1638 (Fcheck_coding_system (Vclipboard_coding_system
), &coding
);
1639 coding
.last_block
= 1;
1640 bufsize
= encoding_buffer_size (&coding
, *size_ret
);
1641 buf
= (unsigned char *) xmalloc (bufsize
);
1642 *size_ret
= encode_coding (&coding
, *data_ret
, buf
,
1643 *size_ret
, bufsize
, &dummy
);
1645 if (charsets
[charset_latin_iso8859_1
]
1646 && (num
== 1 || (num
== 2 && charsets
[CHARSET_ASCII
])))
1648 /* Ok, we can return it as `STRING'. */
1649 if (NILP (type
)) type
= QSTRING
;
1653 /* We must return it as `COMPOUND_TEXT'. */
1654 if (NILP (type
)) type
= QCOMPOUND_TEXT
;
1658 else if (SYMBOLP (obj
))
1662 *data_ret
= (unsigned char *) xmalloc (sizeof (Atom
) + 1);
1663 (*data_ret
) [sizeof (Atom
)] = 0;
1664 (*(Atom
**) data_ret
) [0] = symbol_to_x_atom (dpyinfo
, display
, obj
);
1665 if (NILP (type
)) type
= QATOM
;
1667 else if (INTEGERP (obj
)
1668 && XINT (obj
) < 0xFFFF
1669 && XINT (obj
) > -0xFFFF)
1673 *data_ret
= (unsigned char *) xmalloc (sizeof (short) + 1);
1674 (*data_ret
) [sizeof (short)] = 0;
1675 (*(short **) data_ret
) [0] = (short) XINT (obj
);
1676 if (NILP (type
)) type
= QINTEGER
;
1678 else if (INTEGERP (obj
)
1679 || (CONSP (obj
) && INTEGERP (XCONS (obj
)->car
)
1680 && (INTEGERP (XCONS (obj
)->cdr
)
1681 || (CONSP (XCONS (obj
)->cdr
)
1682 && INTEGERP (XCONS (XCONS (obj
)->cdr
)->car
)))))
1686 *data_ret
= (unsigned char *) xmalloc (sizeof (long) + 1);
1687 (*data_ret
) [sizeof (long)] = 0;
1688 (*(unsigned long **) data_ret
) [0] = cons_to_long (obj
);
1689 if (NILP (type
)) type
= QINTEGER
;
1691 else if (VECTORP (obj
))
1693 /* Lisp_Vectors may represent a set of ATOMs;
1694 a set of 16 or 32 bit INTEGERs;
1695 or a set of ATOM_PAIRs (represented as [[A1 A2] [A3 A4] ...]
1699 if (SYMBOLP (XVECTOR (obj
)->contents
[0]))
1700 /* This vector is an ATOM set */
1702 if (NILP (type
)) type
= QATOM
;
1703 *size_ret
= XVECTOR (obj
)->size
;
1705 *data_ret
= (unsigned char *) xmalloc ((*size_ret
) * sizeof (Atom
));
1706 for (i
= 0; i
< *size_ret
; i
++)
1707 if (SYMBOLP (XVECTOR (obj
)->contents
[i
]))
1708 (*(Atom
**) data_ret
) [i
]
1709 = symbol_to_x_atom (dpyinfo
, display
, XVECTOR (obj
)->contents
[i
]);
1711 Fsignal (Qerror
, /* Qselection_error */
1713 ("all elements of selection vector must have same type"),
1714 Fcons (obj
, Qnil
)));
1716 #if 0 /* #### MULTIPLE doesn't work yet */
1717 else if (VECTORP (XVECTOR (obj
)->contents
[0]))
1718 /* This vector is an ATOM_PAIR set */
1720 if (NILP (type
)) type
= QATOM_PAIR
;
1721 *size_ret
= XVECTOR (obj
)->size
;
1723 *data_ret
= (unsigned char *)
1724 xmalloc ((*size_ret
) * sizeof (Atom
) * 2);
1725 for (i
= 0; i
< *size_ret
; i
++)
1726 if (VECTORP (XVECTOR (obj
)->contents
[i
]))
1728 Lisp_Object pair
= XVECTOR (obj
)->contents
[i
];
1729 if (XVECTOR (pair
)->size
!= 2)
1732 ("elements of the vector must be vectors of exactly two elements"),
1733 Fcons (pair
, Qnil
)));
1735 (*(Atom
**) data_ret
) [i
* 2]
1736 = symbol_to_x_atom (dpyinfo
, display
,
1737 XVECTOR (pair
)->contents
[0]);
1738 (*(Atom
**) data_ret
) [(i
* 2) + 1]
1739 = symbol_to_x_atom (dpyinfo
, display
,
1740 XVECTOR (pair
)->contents
[1]);
1745 ("all elements of the vector must be of the same type"),
1746 Fcons (obj
, Qnil
)));
1751 /* This vector is an INTEGER set, or something like it */
1753 *size_ret
= XVECTOR (obj
)->size
;
1754 if (NILP (type
)) type
= QINTEGER
;
1756 for (i
= 0; i
< *size_ret
; i
++)
1757 if (CONSP (XVECTOR (obj
)->contents
[i
]))
1759 else if (!INTEGERP (XVECTOR (obj
)->contents
[i
]))
1760 Fsignal (Qerror
, /* Qselection_error */
1762 ("elements of selection vector must be integers or conses of integers"),
1763 Fcons (obj
, Qnil
)));
1765 *data_ret
= (unsigned char *) xmalloc (*size_ret
* (*format_ret
/8));
1766 for (i
= 0; i
< *size_ret
; i
++)
1767 if (*format_ret
== 32)
1768 (*((unsigned long **) data_ret
)) [i
]
1769 = cons_to_long (XVECTOR (obj
)->contents
[i
]);
1771 (*((unsigned short **) data_ret
)) [i
]
1772 = (unsigned short) cons_to_long (XVECTOR (obj
)->contents
[i
]);
1776 Fsignal (Qerror
, /* Qselection_error */
1777 Fcons (build_string ("unrecognised selection data"),
1778 Fcons (obj
, Qnil
)));
1780 *type_ret
= symbol_to_x_atom (dpyinfo
, display
, type
);
1784 clean_local_selection_data (obj
)
1788 && INTEGERP (XCONS (obj
)->car
)
1789 && CONSP (XCONS (obj
)->cdr
)
1790 && INTEGERP (XCONS (XCONS (obj
)->cdr
)->car
)
1791 && NILP (XCONS (XCONS (obj
)->cdr
)->cdr
))
1792 obj
= Fcons (XCONS (obj
)->car
, XCONS (obj
)->cdr
);
1795 && INTEGERP (XCONS (obj
)->car
)
1796 && INTEGERP (XCONS (obj
)->cdr
))
1798 if (XINT (XCONS (obj
)->car
) == 0)
1799 return XCONS (obj
)->cdr
;
1800 if (XINT (XCONS (obj
)->car
) == -1)
1801 return make_number (- XINT (XCONS (obj
)->cdr
));
1806 int size
= XVECTOR (obj
)->size
;
1809 return clean_local_selection_data (XVECTOR (obj
)->contents
[0]);
1810 copy
= Fmake_vector (make_number (size
), Qnil
);
1811 for (i
= 0; i
< size
; i
++)
1812 XVECTOR (copy
)->contents
[i
]
1813 = clean_local_selection_data (XVECTOR (obj
)->contents
[i
]);
1819 /* Called from XTread_socket to handle SelectionNotify events.
1820 If it's the selection we are waiting for, stop waiting
1821 by setting the car of reading_selection_reply to non-nil.
1822 We store t there if the reply is successful, lambda if not. */
1825 x_handle_selection_notify (event
)
1826 XSelectionEvent
*event
;
1828 if (event
->requestor
!= reading_selection_window
)
1830 if (event
->selection
!= reading_which_selection
)
1833 XCONS (reading_selection_reply
)->car
1834 = (event
->property
!= 0 ? Qt
: Qlambda
);
1838 DEFUN ("x-own-selection-internal", Fx_own_selection_internal
,
1839 Sx_own_selection_internal
, 2, 2, 0,
1840 "Assert an X selection of the given TYPE with the given VALUE.\n\
1841 TYPE is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1842 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1843 VALUE is typically a string, or a cons of two markers, but may be\n\
1844 anything that the functions on `selection-converter-alist' know about.")
1845 (selection_name
, selection_value
)
1846 Lisp_Object selection_name
, selection_value
;
1849 CHECK_SYMBOL (selection_name
, 0);
1850 if (NILP (selection_value
)) error ("selection-value may not be nil");
1851 x_own_selection (selection_name
, selection_value
);
1852 return selection_value
;
1856 /* Request the selection value from the owner. If we are the owner,
1857 simply return our selection value. If we are not the owner, this
1858 will block until all of the data has arrived. */
1860 DEFUN ("x-get-selection-internal", Fx_get_selection_internal
,
1861 Sx_get_selection_internal
, 2, 2, 0,
1862 "Return text selected from some X window.\n\
1863 SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1864 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1865 TYPE is the type of data desired, typically `STRING'.")
1866 (selection_symbol
, target_type
)
1867 Lisp_Object selection_symbol
, target_type
;
1869 Lisp_Object val
= Qnil
;
1870 struct gcpro gcpro1
, gcpro2
;
1871 GCPRO2 (target_type
, val
); /* we store newly consed data into these */
1873 CHECK_SYMBOL (selection_symbol
, 0);
1875 #if 0 /* #### MULTIPLE doesn't work yet */
1876 if (CONSP (target_type
)
1877 && XCONS (target_type
)->car
== QMULTIPLE
)
1879 CHECK_VECTOR (XCONS (target_type
)->cdr
, 0);
1880 /* So we don't destructively modify this... */
1881 target_type
= copy_multiple_data (target_type
);
1885 CHECK_SYMBOL (target_type
, 0);
1887 val
= x_get_local_selection (selection_symbol
, target_type
);
1891 val
= x_get_foreign_selection (selection_symbol
, target_type
);
1896 && SYMBOLP (XCONS (val
)->car
))
1898 val
= XCONS (val
)->cdr
;
1899 if (CONSP (val
) && NILP (XCONS (val
)->cdr
))
1900 val
= XCONS (val
)->car
;
1902 val
= clean_local_selection_data (val
);
1908 DEFUN ("x-disown-selection-internal", Fx_disown_selection_internal
,
1909 Sx_disown_selection_internal
, 1, 2, 0,
1910 "If we own the selection SELECTION, disown it.\n\
1911 Disowning it means there is no such selection.")
1913 Lisp_Object selection
;
1917 Atom selection_atom
;
1918 struct selection_input_event event
;
1920 struct x_display_info
*dpyinfo
;
1923 display
= FRAME_X_DISPLAY (selected_frame
);
1924 dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
1925 CHECK_SYMBOL (selection
, 0);
1927 timestamp
= last_event_timestamp
;
1929 timestamp
= cons_to_long (time
);
1931 if (NILP (assq_no_quit (selection
, Vselection_alist
)))
1932 return Qnil
; /* Don't disown the selection when we're not the owner. */
1934 selection_atom
= symbol_to_x_atom (dpyinfo
, display
, selection
);
1937 XSetSelectionOwner (display
, selection_atom
, None
, timestamp
);
1940 /* It doesn't seem to be guaranteed that a SelectionClear event will be
1941 generated for a window which owns the selection when that window sets
1942 the selection owner to None. The NCD server does, the MIT Sun4 server
1943 doesn't. So we synthesize one; this means we might get two, but
1944 that's ok, because the second one won't have any effect. */
1945 SELECTION_EVENT_DISPLAY (&event
) = display
;
1946 SELECTION_EVENT_SELECTION (&event
) = selection_atom
;
1947 SELECTION_EVENT_TIME (&event
) = timestamp
;
1948 x_handle_selection_clear ((struct input_event
*) &event
);
1953 /* Get rid of all the selections in buffer BUFFER.
1954 This is used when we kill a buffer. */
1957 x_disown_buffer_selections (buffer
)
1961 struct buffer
*buf
= XBUFFER (buffer
);
1963 for (tail
= Vselection_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1965 Lisp_Object elt
, value
;
1966 elt
= XCONS (tail
)->car
;
1967 value
= XCONS (elt
)->cdr
;
1968 if (CONSP (value
) && MARKERP (XCONS (value
)->car
)
1969 && XMARKER (XCONS (value
)->car
)->buffer
== buf
)
1970 Fx_disown_selection_internal (XCONS (elt
)->car
, Qnil
);
1974 DEFUN ("x-selection-owner-p", Fx_selection_owner_p
, Sx_selection_owner_p
,
1976 "Whether the current Emacs process owns the given X Selection.\n\
1977 The arg should be the name of the selection in question, typically one of\n\
1978 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1979 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1980 For convenience, the symbol nil is the same as `PRIMARY',\n\
1981 and t is the same as `SECONDARY'.)")
1983 Lisp_Object selection
;
1986 CHECK_SYMBOL (selection
, 0);
1987 if (EQ (selection
, Qnil
)) selection
= QPRIMARY
;
1988 if (EQ (selection
, Qt
)) selection
= QSECONDARY
;
1990 if (NILP (Fassq (selection
, Vselection_alist
)))
1995 DEFUN ("x-selection-exists-p", Fx_selection_exists_p
, Sx_selection_exists_p
,
1997 "Whether there is an owner for the given X Selection.\n\
1998 The arg should be the name of the selection in question, typically one of\n\
1999 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
2000 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
2001 For convenience, the symbol nil is the same as `PRIMARY',\n\
2002 and t is the same as `SECONDARY'.)")
2004 Lisp_Object selection
;
2010 /* It should be safe to call this before we have an X frame. */
2011 if (! FRAME_X_P (selected_frame
))
2014 dpy
= FRAME_X_DISPLAY (selected_frame
);
2015 CHECK_SYMBOL (selection
, 0);
2016 if (!NILP (Fx_selection_owner_p (selection
)))
2018 if (EQ (selection
, Qnil
)) selection
= QPRIMARY
;
2019 if (EQ (selection
, Qt
)) selection
= QSECONDARY
;
2020 atom
= symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame
),
2025 owner
= XGetSelectionOwner (dpy
, atom
);
2027 return (owner
? Qt
: Qnil
);
2031 #ifdef CUT_BUFFER_SUPPORT
2033 /* Ensure that all 8 cut buffers exist. ICCCM says we gotta... */
2035 initialize_cut_buffers (display
, window
)
2039 unsigned char *data
= (unsigned char *) "";
2041 #define FROB(atom) XChangeProperty (display, window, atom, XA_STRING, 8, \
2042 PropModeAppend, data, 0)
2043 FROB (XA_CUT_BUFFER0
);
2044 FROB (XA_CUT_BUFFER1
);
2045 FROB (XA_CUT_BUFFER2
);
2046 FROB (XA_CUT_BUFFER3
);
2047 FROB (XA_CUT_BUFFER4
);
2048 FROB (XA_CUT_BUFFER5
);
2049 FROB (XA_CUT_BUFFER6
);
2050 FROB (XA_CUT_BUFFER7
);
2056 #define CHECK_CUT_BUFFER(symbol,n) \
2057 { CHECK_SYMBOL ((symbol), (n)); \
2058 if (!EQ((symbol), QCUT_BUFFER0) && !EQ((symbol), QCUT_BUFFER1) \
2059 && !EQ((symbol), QCUT_BUFFER2) && !EQ((symbol), QCUT_BUFFER3) \
2060 && !EQ((symbol), QCUT_BUFFER4) && !EQ((symbol), QCUT_BUFFER5) \
2061 && !EQ((symbol), QCUT_BUFFER6) && !EQ((symbol), QCUT_BUFFER7)) \
2063 Fcons (build_string ("doesn't name a cut buffer"), \
2064 Fcons ((symbol), Qnil))); \
2067 DEFUN ("x-get-cut-buffer-internal", Fx_get_cut_buffer_internal
,
2068 Sx_get_cut_buffer_internal
, 1, 1, 0,
2069 "Returns the value of the named cut buffer (typically CUT_BUFFER0).")
2075 unsigned char *data
;
2082 struct x_display_info
*dpyinfo
;
2085 display
= FRAME_X_DISPLAY (selected_frame
);
2086 dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
2087 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2088 CHECK_CUT_BUFFER (buffer
, 0);
2089 buffer_atom
= symbol_to_x_atom (dpyinfo
, display
, buffer
);
2091 x_get_window_property (display
, window
, buffer_atom
, &data
, &bytes
,
2092 &type
, &format
, &size
, 0);
2093 if (!data
) return Qnil
;
2095 if (format
!= 8 || type
!= XA_STRING
)
2097 Fcons (build_string ("cut buffer doesn't contain 8-bit data"),
2098 Fcons (x_atom_to_symbol (dpyinfo
, display
, type
),
2099 Fcons (make_number (format
), Qnil
))));
2101 ret
= (bytes
? make_string ((char *) data
, bytes
) : Qnil
);
2102 /* Use xfree, not XFree, because x_get_window_property
2103 calls xmalloc itself. */
2109 DEFUN ("x-store-cut-buffer-internal", Fx_store_cut_buffer_internal
,
2110 Sx_store_cut_buffer_internal
, 2, 2, 0,
2111 "Sets the value of the named cut buffer (typically CUT_BUFFER0).")
2113 Lisp_Object buffer
, string
;
2117 unsigned char *data
;
2119 int bytes_remaining
;
2124 display
= FRAME_X_DISPLAY (selected_frame
);
2125 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2127 max_bytes
= SELECTION_QUANTUM (display
);
2128 if (max_bytes
> MAX_SELECTION_QUANTUM
)
2129 max_bytes
= MAX_SELECTION_QUANTUM
;
2131 CHECK_CUT_BUFFER (buffer
, 0);
2132 CHECK_STRING (string
, 0);
2133 buffer_atom
= symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame
),
2135 data
= (unsigned char *) XSTRING (string
)->data
;
2136 bytes
= XSTRING (string
)->size
;
2137 bytes_remaining
= bytes
;
2139 if (! FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
)
2141 initialize_cut_buffers (display
, window
);
2142 FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
= 1;
2147 /* Don't mess up with an empty value. */
2148 if (!bytes_remaining
)
2149 XChangeProperty (display
, window
, buffer_atom
, XA_STRING
, 8,
2150 PropModeReplace
, data
, 0);
2152 while (bytes_remaining
)
2154 int chunk
= (bytes_remaining
< max_bytes
2155 ? bytes_remaining
: max_bytes
);
2156 XChangeProperty (display
, window
, buffer_atom
, XA_STRING
, 8,
2157 (bytes_remaining
== bytes
2162 bytes_remaining
-= chunk
;
2169 DEFUN ("x-rotate-cut-buffers-internal", Fx_rotate_cut_buffers_internal
,
2170 Sx_rotate_cut_buffers_internal
, 1, 1, 0,
2171 "Rotate the values of the cut buffers by the given number of steps;\n\
2172 positive means move values forward, negative means backward.")
2181 display
= FRAME_X_DISPLAY (selected_frame
);
2182 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2183 CHECK_NUMBER (n
, 0);
2186 if (! FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
)
2188 initialize_cut_buffers (display
, window
);
2189 FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
= 1;
2192 props
[0] = XA_CUT_BUFFER0
;
2193 props
[1] = XA_CUT_BUFFER1
;
2194 props
[2] = XA_CUT_BUFFER2
;
2195 props
[3] = XA_CUT_BUFFER3
;
2196 props
[4] = XA_CUT_BUFFER4
;
2197 props
[5] = XA_CUT_BUFFER5
;
2198 props
[6] = XA_CUT_BUFFER6
;
2199 props
[7] = XA_CUT_BUFFER7
;
2201 XRotateWindowProperties (display
, window
, props
, 8, XINT (n
));
2211 defsubr (&Sx_get_selection_internal
);
2212 defsubr (&Sx_own_selection_internal
);
2213 defsubr (&Sx_disown_selection_internal
);
2214 defsubr (&Sx_selection_owner_p
);
2215 defsubr (&Sx_selection_exists_p
);
2217 #ifdef CUT_BUFFER_SUPPORT
2218 defsubr (&Sx_get_cut_buffer_internal
);
2219 defsubr (&Sx_store_cut_buffer_internal
);
2220 defsubr (&Sx_rotate_cut_buffers_internal
);
2223 reading_selection_reply
= Fcons (Qnil
, Qnil
);
2224 staticpro (&reading_selection_reply
);
2225 reading_selection_window
= 0;
2226 reading_which_selection
= 0;
2228 property_change_wait_list
= 0;
2229 prop_location_identifier
= 0;
2230 property_change_reply
= Fcons (Qnil
, Qnil
);
2231 staticpro (&property_change_reply
);
2233 Vselection_alist
= Qnil
;
2234 staticpro (&Vselection_alist
);
2236 DEFVAR_LISP ("selection-converter-alist", &Vselection_converter_alist
,
2237 "An alist associating X Windows selection-types with functions.\n\
2238 These functions are called to convert the selection, with three args:\n\
2239 the name of the selection (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
2240 a desired type to which the selection should be converted;\n\
2241 and the local selection value (whatever was given to `x-own-selection').\n\
2243 The function should return the value to send to the X server\n\
2244 \(typically a string). A return value of nil\n\
2245 means that the conversion could not be done.\n\
2246 A return value which is the symbol `NULL'\n\
2247 means that a side-effect was executed,\n\
2248 and there is no meaningful selection value.");
2249 Vselection_converter_alist
= Qnil
;
2251 DEFVAR_LISP ("x-lost-selection-hooks", &Vx_lost_selection_hooks
,
2252 "A list of functions to be called when Emacs loses an X selection.\n\
2253 \(This happens when some other X client makes its own selection\n\
2254 or when a Lisp program explicitly clears the selection.)\n\
2255 The functions are called with one argument, the selection type\n\
2256 \(a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD').");
2257 Vx_lost_selection_hooks
= Qnil
;
2259 DEFVAR_LISP ("x-sent-selection-hooks", &Vx_sent_selection_hooks
,
2260 "A list of functions to be called when Emacs answers a selection request.\n\
2261 The functions are called with four arguments:\n\
2262 - the selection name (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
2263 - the selection-type which Emacs was asked to convert the\n\
2264 selection into before sending (for example, `STRING' or `LENGTH');\n\
2265 - a flag indicating success or failure for responding to the request.\n\
2266 We might have failed (and declined the request) for any number of reasons,\n\
2267 including being asked for a selection that we no longer own, or being asked\n\
2268 to convert into a type that we don't know about or that is inappropriate.\n\
2269 This hook doesn't let you change the behavior of Emacs's selection replies,\n\
2270 it merely informs you that they have happened.");
2271 Vx_sent_selection_hooks
= Qnil
;
2273 DEFVAR_LISP ("clipboard-coding-system", &Vclipboard_coding_system
,
2274 "Coding system for communicating with other X clients.\n\
2275 When sending or receiving text via cut_buffer, selection, and clipboard,\n\
2276 the text is encoded or decoded by this coding system.\n\
2277 A default value is `iso-latin-1'");
2278 Vclipboard_coding_system
=intern ("iso-latin-1");
2279 staticpro(&Vclipboard_coding_system
);
2281 DEFVAR_INT ("x-selection-timeout", &x_selection_timeout
,
2282 "Number of milliseconds to wait for a selection reply.\n\
2283 If the selection owner doesn't reply in this time, we give up.\n\
2284 A value of 0 means wait as long as necessary. This is initialized from the\n\
2285 \"*selectionTimeout\" resource.");
2286 x_selection_timeout
= 0;
2288 QPRIMARY
= intern ("PRIMARY"); staticpro (&QPRIMARY
);
2289 QSECONDARY
= intern ("SECONDARY"); staticpro (&QSECONDARY
);
2290 QSTRING
= intern ("STRING"); staticpro (&QSTRING
);
2291 QINTEGER
= intern ("INTEGER"); staticpro (&QINTEGER
);
2292 QCLIPBOARD
= intern ("CLIPBOARD"); staticpro (&QCLIPBOARD
);
2293 QTIMESTAMP
= intern ("TIMESTAMP"); staticpro (&QTIMESTAMP
);
2294 QTEXT
= intern ("TEXT"); staticpro (&QTEXT
);
2295 QCOMPOUND_TEXT
= intern ("COMPOUND_TEXT"); staticpro (&QCOMPOUND_TEXT
);
2296 QTIMESTAMP
= intern ("TIMESTAMP"); staticpro (&QTIMESTAMP
);
2297 QDELETE
= intern ("DELETE"); staticpro (&QDELETE
);
2298 QMULTIPLE
= intern ("MULTIPLE"); staticpro (&QMULTIPLE
);
2299 QINCR
= intern ("INCR"); staticpro (&QINCR
);
2300 QEMACS_TMP
= intern ("_EMACS_TMP_"); staticpro (&QEMACS_TMP
);
2301 QTARGETS
= intern ("TARGETS"); staticpro (&QTARGETS
);
2302 QATOM
= intern ("ATOM"); staticpro (&QATOM
);
2303 QATOM_PAIR
= intern ("ATOM_PAIR"); staticpro (&QATOM_PAIR
);
2304 QNULL
= intern ("NULL"); staticpro (&QNULL
);
2306 #ifdef CUT_BUFFER_SUPPORT
2307 QCUT_BUFFER0
= intern ("CUT_BUFFER0"); staticpro (&QCUT_BUFFER0
);
2308 QCUT_BUFFER1
= intern ("CUT_BUFFER1"); staticpro (&QCUT_BUFFER1
);
2309 QCUT_BUFFER2
= intern ("CUT_BUFFER2"); staticpro (&QCUT_BUFFER2
);
2310 QCUT_BUFFER3
= intern ("CUT_BUFFER3"); staticpro (&QCUT_BUFFER3
);
2311 QCUT_BUFFER4
= intern ("CUT_BUFFER4"); staticpro (&QCUT_BUFFER4
);
2312 QCUT_BUFFER5
= intern ("CUT_BUFFER5"); staticpro (&QCUT_BUFFER5
);
2313 QCUT_BUFFER6
= intern ("CUT_BUFFER6"); staticpro (&QCUT_BUFFER6
);
2314 QCUT_BUFFER7
= intern ("CUT_BUFFER7"); staticpro (&QCUT_BUFFER7
);