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"
33 #define CUT_BUFFER_SUPPORT
35 Lisp_Object QPRIMARY
, QSECONDARY
, QSTRING
, QINTEGER
, QCLIPBOARD
, QTIMESTAMP
,
36 QTEXT
, QDELETE
, QMULTIPLE
, QINCR
, QEMACS_TMP
, QTARGETS
, QATOM
, QNULL
,
39 Lisp_Object QCOMPOUND_TEXT
; /* This is a type of selection. */
41 #ifdef CUT_BUFFER_SUPPORT
42 Lisp_Object QCUT_BUFFER0
, QCUT_BUFFER1
, QCUT_BUFFER2
, QCUT_BUFFER3
,
43 QCUT_BUFFER4
, QCUT_BUFFER5
, QCUT_BUFFER6
, QCUT_BUFFER7
;
46 static Lisp_Object Vx_lost_selection_hooks
;
47 static Lisp_Object Vx_sent_selection_hooks
;
49 /* If this is a smaller number than the max-request-size of the display,
50 emacs will use INCR selection transfer when the selection is larger
51 than this. The max-request-size is usually around 64k, so if you want
52 emacs to use incremental selection transfers when the selection is
53 smaller than that, set this. I added this mostly for debugging the
54 incremental transfer stuff, but it might improve server performance. */
55 #define MAX_SELECTION_QUANTUM 0xFFFFFF
58 #define SELECTION_QUANTUM(dpy) ((XMaxRequestSize(dpy) << 2) - 100)
60 #define SELECTION_QUANTUM(dpy) (((dpy)->max_request_size << 2) - 100)
63 /* The timestamp of the last input event Emacs received from the X server. */
64 /* Defined in keyboard.c. */
65 extern unsigned long last_event_timestamp
;
67 /* This is an association list whose elements are of the form
68 ( SELECTION-NAME SELECTION-VALUE SELECTION-TIMESTAMP FRAME)
69 SELECTION-NAME is a lisp symbol, whose name is the name of an X Atom.
70 SELECTION-VALUE is the value that emacs owns for that selection.
71 It may be any kind of Lisp object.
72 SELECTION-TIMESTAMP is the time at which emacs began owning this selection,
73 as a cons of two 16-bit numbers (making a 32 bit time.)
74 FRAME is the frame for which we made the selection.
75 If there is an entry in this alist, then it can be assumed that Emacs owns
77 The only (eq) parts of this list that are visible from Lisp are the
79 static Lisp_Object Vselection_alist
;
81 /* This is an alist whose CARs are selection-types (whose names are the same
82 as the names of X Atoms) and whose CDRs are the names of Lisp functions to
83 call to convert the given Emacs selection value to a string representing
84 the given selection type. This is for Lisp-level extension of the emacs
85 selection handling. */
86 static Lisp_Object Vselection_converter_alist
;
88 /* If the selection owner takes too long to reply to a selection request,
89 we give up on it. This is in milliseconds (0 = no timeout.) */
90 static int x_selection_timeout
;
92 /* Utility functions */
94 static void lisp_data_to_selection_data ();
95 static Lisp_Object
selection_data_to_lisp_data ();
96 static Lisp_Object
x_get_window_property_as_lisp_data ();
98 /* This converts a Lisp symbol to a server Atom, avoiding a server
99 roundtrip whenever possible. */
102 symbol_to_x_atom (dpyinfo
, display
, sym
)
103 struct x_display_info
*dpyinfo
;
108 if (NILP (sym
)) return 0;
109 if (EQ (sym
, QPRIMARY
)) return XA_PRIMARY
;
110 if (EQ (sym
, QSECONDARY
)) return XA_SECONDARY
;
111 if (EQ (sym
, QSTRING
)) return XA_STRING
;
112 if (EQ (sym
, QINTEGER
)) return XA_INTEGER
;
113 if (EQ (sym
, QATOM
)) return XA_ATOM
;
114 if (EQ (sym
, QCLIPBOARD
)) return dpyinfo
->Xatom_CLIPBOARD
;
115 if (EQ (sym
, QTIMESTAMP
)) return dpyinfo
->Xatom_TIMESTAMP
;
116 if (EQ (sym
, QTEXT
)) return dpyinfo
->Xatom_TEXT
;
117 if (EQ (sym
, QCOMPOUND_TEXT
)) return dpyinfo
->Xatom_COMPOUND_TEXT
;
118 if (EQ (sym
, QDELETE
)) return dpyinfo
->Xatom_DELETE
;
119 if (EQ (sym
, QMULTIPLE
)) return dpyinfo
->Xatom_MULTIPLE
;
120 if (EQ (sym
, QINCR
)) return dpyinfo
->Xatom_INCR
;
121 if (EQ (sym
, QEMACS_TMP
)) return dpyinfo
->Xatom_EMACS_TMP
;
122 if (EQ (sym
, QTARGETS
)) return dpyinfo
->Xatom_TARGETS
;
123 if (EQ (sym
, QNULL
)) return dpyinfo
->Xatom_NULL
;
124 #ifdef CUT_BUFFER_SUPPORT
125 if (EQ (sym
, QCUT_BUFFER0
)) return XA_CUT_BUFFER0
;
126 if (EQ (sym
, QCUT_BUFFER1
)) return XA_CUT_BUFFER1
;
127 if (EQ (sym
, QCUT_BUFFER2
)) return XA_CUT_BUFFER2
;
128 if (EQ (sym
, QCUT_BUFFER3
)) return XA_CUT_BUFFER3
;
129 if (EQ (sym
, QCUT_BUFFER4
)) return XA_CUT_BUFFER4
;
130 if (EQ (sym
, QCUT_BUFFER5
)) return XA_CUT_BUFFER5
;
131 if (EQ (sym
, QCUT_BUFFER6
)) return XA_CUT_BUFFER6
;
132 if (EQ (sym
, QCUT_BUFFER7
)) return XA_CUT_BUFFER7
;
134 if (!SYMBOLP (sym
)) abort ();
137 fprintf (stderr
, " XInternAtom %s\n", (char *) XSYMBOL (sym
)->name
->data
);
140 val
= XInternAtom (display
, (char *) XSYMBOL (sym
)->name
->data
, False
);
146 /* This converts a server Atom to a Lisp symbol, avoiding server roundtrips
147 and calls to intern whenever possible. */
150 x_atom_to_symbol (dpyinfo
, display
, atom
)
151 struct x_display_info
*dpyinfo
;
157 if (! atom
) return Qnil
;
170 #ifdef CUT_BUFFER_SUPPORT
190 if (atom
== dpyinfo
->Xatom_CLIPBOARD
)
192 if (atom
== dpyinfo
->Xatom_TIMESTAMP
)
194 if (atom
== dpyinfo
->Xatom_TEXT
)
196 if (atom
== dpyinfo
->Xatom_COMPOUND_TEXT
)
197 return QCOMPOUND_TEXT
;
198 if (atom
== dpyinfo
->Xatom_DELETE
)
200 if (atom
== dpyinfo
->Xatom_MULTIPLE
)
202 if (atom
== dpyinfo
->Xatom_INCR
)
204 if (atom
== dpyinfo
->Xatom_EMACS_TMP
)
206 if (atom
== dpyinfo
->Xatom_TARGETS
)
208 if (atom
== dpyinfo
->Xatom_NULL
)
212 str
= XGetAtomName (display
, atom
);
215 fprintf (stderr
, " XGetAtomName --> %s\n", str
);
217 if (! str
) return Qnil
;
220 /* This was allocated by Xlib, so use XFree. */
226 /* Do protocol to assert ourself as a selection owner.
227 Update the Vselection_alist so that we can reply to later requests for
231 x_own_selection (selection_name
, selection_value
)
232 Lisp_Object selection_name
, selection_value
;
234 Window selecting_window
= FRAME_X_WINDOW (selected_frame
);
235 Display
*display
= FRAME_X_DISPLAY (selected_frame
);
236 Time time
= last_event_timestamp
;
238 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
241 CHECK_SYMBOL (selection_name
, 0);
242 selection_atom
= symbol_to_x_atom (dpyinfo
, display
, selection_name
);
245 count
= x_catch_errors (display
);
246 XSetSelectionOwner (display
, selection_atom
, selecting_window
, time
);
247 x_check_errors (display
, "Can't set selection: %s");
248 x_uncatch_errors (display
, count
);
251 /* Now update the local cache */
253 Lisp_Object selection_time
;
254 Lisp_Object selection_data
;
255 Lisp_Object prev_value
;
257 selection_time
= long_to_cons ((unsigned long) time
);
258 selection_data
= Fcons (selection_name
,
259 Fcons (selection_value
,
260 Fcons (selection_time
,
261 Fcons (Fselected_frame (), Qnil
))));
262 prev_value
= assq_no_quit (selection_name
, Vselection_alist
);
264 Vselection_alist
= Fcons (selection_data
, Vselection_alist
);
266 /* If we already owned the selection, remove the old selection data.
267 Perhaps we should destructively modify it instead.
268 Don't use Fdelq as that may QUIT. */
269 if (!NILP (prev_value
))
271 Lisp_Object rest
; /* we know it's not the CAR, so it's easy. */
272 for (rest
= Vselection_alist
; !NILP (rest
); rest
= Fcdr (rest
))
273 if (EQ (prev_value
, Fcar (XCONS (rest
)->cdr
)))
275 XCONS (rest
)->cdr
= Fcdr (XCONS (rest
)->cdr
);
282 /* Given a selection-name and desired type, look up our local copy of
283 the selection value and convert it to the type.
284 The value is nil or a string.
285 This function is used both for remote requests
286 and for local x-get-selection-internal.
288 This calls random Lisp code, and may signal or gc. */
291 x_get_local_selection (selection_symbol
, target_type
)
292 Lisp_Object selection_symbol
, target_type
;
294 Lisp_Object local_value
;
295 Lisp_Object handler_fn
, value
, type
, check
;
298 local_value
= assq_no_quit (selection_symbol
, Vselection_alist
);
300 if (NILP (local_value
)) return Qnil
;
302 /* TIMESTAMP and MULTIPLE are special cases 'cause that's easiest. */
303 if (EQ (target_type
, QTIMESTAMP
))
306 value
= XCONS (XCONS (XCONS (local_value
)->cdr
)->cdr
)->car
;
309 else if (EQ (target_type
, QDELETE
))
312 Fx_disown_selection_internal
314 XCONS (XCONS (XCONS (local_value
)->cdr
)->cdr
)->car
);
319 #if 0 /* #### MULTIPLE doesn't work yet */
320 else if (CONSP (target_type
)
321 && XCONS (target_type
)->car
== QMULTIPLE
)
326 pairs
= XCONS (target_type
)->cdr
;
327 size
= XVECTOR (pairs
)->size
;
328 /* If the target is MULTIPLE, then target_type looks like
329 (MULTIPLE . [[SELECTION1 TARGET1] [SELECTION2 TARGET2] ... ])
330 We modify the second element of each pair in the vector and
331 return it as [[SELECTION1 <value1>] [SELECTION2 <value2>] ... ]
333 for (i
= 0; i
< size
; i
++)
336 pair
= XVECTOR (pairs
)->contents
[i
];
337 XVECTOR (pair
)->contents
[1]
338 = x_get_local_selection (XVECTOR (pair
)->contents
[0],
339 XVECTOR (pair
)->contents
[1]);
346 /* Don't allow a quit within the converter.
347 When the user types C-g, he would be surprised
348 if by luck it came during a converter. */
349 count
= specpdl_ptr
- specpdl
;
350 specbind (Qinhibit_quit
, Qt
);
352 CHECK_SYMBOL (target_type
, 0);
353 handler_fn
= Fcdr (Fassq (target_type
, Vselection_converter_alist
));
354 if (!NILP (handler_fn
))
355 value
= call3 (handler_fn
,
356 selection_symbol
, target_type
,
357 XCONS (XCONS (local_value
)->cdr
)->car
);
360 unbind_to (count
, Qnil
);
363 /* Make sure this value is of a type that we could transmit
364 to another X client. */
368 && SYMBOLP (XCONS (value
)->car
))
369 type
= XCONS (value
)->car
,
370 check
= XCONS (value
)->cdr
;
378 /* Check for a value that cons_to_long could handle. */
379 else if (CONSP (check
)
380 && INTEGERP (XCONS (check
)->car
)
381 && (INTEGERP (XCONS (check
)->cdr
)
383 (CONSP (XCONS (check
)->cdr
)
384 && INTEGERP (XCONS (XCONS (check
)->cdr
)->car
)
385 && NILP (XCONS (XCONS (check
)->cdr
)->cdr
))))
390 Fcons (build_string ("invalid data returned by selection-conversion function"),
391 Fcons (handler_fn
, Fcons (value
, Qnil
))));
394 /* Subroutines of x_reply_selection_request. */
396 /* Send a SelectionNotify event to the requestor with property=None,
397 meaning we were unable to do what they wanted. */
400 x_decline_selection_request (event
)
401 struct input_event
*event
;
403 XSelectionEvent reply
;
404 reply
.type
= SelectionNotify
;
405 reply
.display
= SELECTION_EVENT_DISPLAY (event
);
406 reply
.requestor
= SELECTION_EVENT_REQUESTOR (event
);
407 reply
.selection
= SELECTION_EVENT_SELECTION (event
);
408 reply
.time
= SELECTION_EVENT_TIME (event
);
409 reply
.target
= SELECTION_EVENT_TARGET (event
);
410 reply
.property
= None
;
413 XSendEvent (reply
.display
, reply
.requestor
, False
, 0L,
415 XFlush (reply
.display
);
419 /* This is the selection request currently being processed.
420 It is set to zero when the request is fully processed. */
421 static struct input_event
*x_selection_current_request
;
423 /* Used as an unwind-protect clause so that, if a selection-converter signals
424 an error, we tell the requester that we were unable to do what they wanted
425 before we throw to top-level or go into the debugger or whatever. */
428 x_selection_request_lisp_error (ignore
)
431 if (x_selection_current_request
!= 0)
432 x_decline_selection_request (x_selection_current_request
);
437 /* This stuff is so that INCR selections are reentrant (that is, so we can
438 be servicing multiple INCR selection requests simultaneously.) I haven't
439 actually tested that yet. */
441 /* Keep a list of the property changes that are awaited. */
451 struct prop_location
*next
;
454 static struct prop_location
*expect_property_change ();
455 static void wait_for_property_change ();
456 static void unexpect_property_change ();
457 static int waiting_for_other_props_on_window ();
459 static int prop_location_identifier
;
461 static Lisp_Object property_change_reply
;
463 static struct prop_location
*property_change_reply_object
;
465 static struct prop_location
*property_change_wait_list
;
468 queue_selection_requests_unwind (frame
)
471 FRAME_PTR f
= XFRAME (frame
);
474 x_stop_queuing_selection_requests (FRAME_X_DISPLAY (f
));
478 /* Return some frame whose display info is DPYINFO.
479 Return nil if there is none. */
482 some_frame_on_display (dpyinfo
)
483 struct x_display_info
*dpyinfo
;
485 Lisp_Object list
, frame
;
487 FOR_EACH_FRAME (list
, frame
)
489 if (FRAME_X_DISPLAY_INFO (XFRAME (frame
)) == dpyinfo
)
496 /* Send the reply to a selection request event EVENT.
497 TYPE is the type of selection data requested.
498 DATA and SIZE describe the data to send, already converted.
499 FORMAT is the unit-size (in bits) of the data to be transmitted. */
502 x_reply_selection_request (event
, format
, data
, size
, type
)
503 struct input_event
*event
;
508 XSelectionEvent reply
;
509 Display
*display
= SELECTION_EVENT_DISPLAY (event
);
510 Window window
= SELECTION_EVENT_REQUESTOR (event
);
512 int format_bytes
= format
/8;
513 int max_bytes
= SELECTION_QUANTUM (display
);
514 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
517 if (max_bytes
> MAX_SELECTION_QUANTUM
)
518 max_bytes
= MAX_SELECTION_QUANTUM
;
520 reply
.type
= SelectionNotify
;
521 reply
.display
= display
;
522 reply
.requestor
= window
;
523 reply
.selection
= SELECTION_EVENT_SELECTION (event
);
524 reply
.time
= SELECTION_EVENT_TIME (event
);
525 reply
.target
= SELECTION_EVENT_TARGET (event
);
526 reply
.property
= SELECTION_EVENT_PROPERTY (event
);
527 if (reply
.property
== None
)
528 reply
.property
= reply
.target
;
530 /* #### XChangeProperty can generate BadAlloc, and we must handle it! */
532 count
= x_catch_errors (display
);
534 /* Store the data on the requested property.
535 If the selection is large, only store the first N bytes of it.
537 bytes_remaining
= size
* format_bytes
;
538 if (bytes_remaining
<= max_bytes
)
540 /* Send all the data at once, with minimal handshaking. */
542 fprintf (stderr
,"\nStoring all %d\n", bytes_remaining
);
544 XChangeProperty (display
, window
, reply
.property
, type
, format
,
545 PropModeReplace
, data
, size
);
546 /* At this point, the selection was successfully stored; ack it. */
547 XSendEvent (display
, window
, False
, 0L, (XEvent
*) &reply
);
551 /* Send an INCR selection. */
552 struct prop_location
*wait_object
;
556 frame
= some_frame_on_display (dpyinfo
);
558 /* If the display no longer has frames, we can't expect
559 to get many more selection requests from it, so don't
560 bother trying to queue them. */
563 x_start_queuing_selection_requests (display
);
565 record_unwind_protect (queue_selection_requests_unwind
,
569 if (x_window_to_frame (dpyinfo
, window
)) /* #### debug */
570 error ("Attempt to transfer an INCR to ourself!");
572 fprintf (stderr
, "\nINCR %d\n", bytes_remaining
);
574 wait_object
= expect_property_change (display
, window
, reply
.property
,
577 XChangeProperty (display
, window
, reply
.property
, dpyinfo
->Xatom_INCR
,
579 (unsigned char *) &bytes_remaining
, 1);
580 XSelectInput (display
, window
, PropertyChangeMask
);
581 /* Tell 'em the INCR data is there... */
582 XSendEvent (display
, window
, False
, 0L, (XEvent
*) &reply
);
585 had_errors
= x_had_errors_p (display
);
588 /* First, wait for the requester to ack by deleting the property.
589 This can run random lisp code (process handlers) or signal. */
591 wait_for_property_change (wait_object
);
593 while (bytes_remaining
)
595 int i
= ((bytes_remaining
< max_bytes
)
602 = expect_property_change (display
, window
, reply
.property
,
605 fprintf (stderr
," INCR adding %d\n", i
);
607 /* Append the next chunk of data to the property. */
608 XChangeProperty (display
, window
, reply
.property
, type
, format
,
609 PropModeAppend
, data
, i
/ format_bytes
);
610 bytes_remaining
-= i
;
613 had_errors
= x_had_errors_p (display
);
619 /* Now wait for the requester to ack this chunk by deleting the
620 property. This can run random lisp code or signal.
622 wait_for_property_change (wait_object
);
624 /* Now write a zero-length chunk to the property to tell the requester
627 fprintf (stderr
," INCR done\n");
630 if (! waiting_for_other_props_on_window (display
, window
))
631 XSelectInput (display
, window
, 0L);
633 XChangeProperty (display
, window
, reply
.property
, type
, format
,
634 PropModeReplace
, data
, 0);
638 x_uncatch_errors (display
, count
);
642 /* Handle a SelectionRequest event EVENT.
643 This is called from keyboard.c when such an event is found in the queue. */
646 x_handle_selection_request (event
)
647 struct input_event
*event
;
649 struct gcpro gcpro1
, gcpro2
, gcpro3
;
650 Lisp_Object local_selection_data
;
651 Lisp_Object selection_symbol
;
652 Lisp_Object target_symbol
;
653 Lisp_Object converted_selection
;
654 Time local_selection_time
;
655 Lisp_Object successful_p
;
657 struct x_display_info
*dpyinfo
658 = x_display_info_for_display (SELECTION_EVENT_DISPLAY (event
));
660 local_selection_data
= Qnil
;
661 target_symbol
= Qnil
;
662 converted_selection
= Qnil
;
665 GCPRO3 (local_selection_data
, converted_selection
, target_symbol
);
667 selection_symbol
= x_atom_to_symbol (dpyinfo
,
668 SELECTION_EVENT_DISPLAY (event
),
669 SELECTION_EVENT_SELECTION (event
));
671 local_selection_data
= assq_no_quit (selection_symbol
, Vselection_alist
);
673 if (NILP (local_selection_data
))
675 /* Someone asked for the selection, but we don't have it any more.
677 x_decline_selection_request (event
);
681 local_selection_time
= (Time
)
682 cons_to_long (XCONS (XCONS (XCONS (local_selection_data
)->cdr
)->cdr
)->car
);
684 if (SELECTION_EVENT_TIME (event
) != CurrentTime
685 && local_selection_time
> SELECTION_EVENT_TIME (event
))
687 /* Someone asked for the selection, and we have one, but not the one
690 x_decline_selection_request (event
);
694 count
= specpdl_ptr
- specpdl
;
695 x_selection_current_request
= event
;
696 record_unwind_protect (x_selection_request_lisp_error
, Qnil
);
698 target_symbol
= x_atom_to_symbol (dpyinfo
, SELECTION_EVENT_DISPLAY (event
),
699 SELECTION_EVENT_TARGET (event
));
701 #if 0 /* #### MULTIPLE doesn't work yet */
702 if (EQ (target_symbol
, QMULTIPLE
))
703 target_symbol
= fetch_multiple_target (event
);
706 /* Convert lisp objects back into binary data */
709 = x_get_local_selection (selection_symbol
, target_symbol
);
711 if (! NILP (converted_selection
))
719 lisp_data_to_selection_data (SELECTION_EVENT_DISPLAY (event
),
721 &data
, &type
, &size
, &format
, &nofree
);
723 x_reply_selection_request (event
, format
, data
, size
, type
);
726 /* Indicate we have successfully processed this event. */
727 x_selection_current_request
= 0;
729 /* Use free, not XFree, because lisp_data_to_selection_data
730 calls xmalloc itself. */
734 unbind_to (count
, Qnil
);
740 /* Let random lisp code notice that the selection has been asked for. */
743 rest
= Vx_sent_selection_hooks
;
744 if (!EQ (rest
, Qunbound
))
745 for (; CONSP (rest
); rest
= Fcdr (rest
))
746 call3 (Fcar (rest
), selection_symbol
, target_symbol
, successful_p
);
750 /* Handle a SelectionClear event EVENT, which indicates that some other
751 client cleared out our previously asserted selection.
752 This is called from keyboard.c when such an event is found in the queue. */
755 x_handle_selection_clear (event
)
756 struct input_event
*event
;
758 Display
*display
= SELECTION_EVENT_DISPLAY (event
);
759 Atom selection
= SELECTION_EVENT_SELECTION (event
);
760 Time changed_owner_time
= SELECTION_EVENT_TIME (event
);
762 Lisp_Object selection_symbol
, local_selection_data
;
763 Time local_selection_time
;
764 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
766 selection_symbol
= x_atom_to_symbol (dpyinfo
, display
, selection
);
768 local_selection_data
= assq_no_quit (selection_symbol
, Vselection_alist
);
770 /* Well, we already believe that we don't own it, so that's just fine. */
771 if (NILP (local_selection_data
)) return;
773 local_selection_time
= (Time
)
774 cons_to_long (XCONS (XCONS (XCONS (local_selection_data
)->cdr
)->cdr
)->car
);
776 /* This SelectionClear is for a selection that we no longer own, so we can
777 disregard it. (That is, we have reasserted the selection since this
778 request was generated.) */
780 if (changed_owner_time
!= CurrentTime
781 && local_selection_time
> changed_owner_time
)
784 /* Otherwise, we're really honest and truly being told to drop it.
785 Don't use Fdelq as that may QUIT;. */
787 if (EQ (local_selection_data
, Fcar (Vselection_alist
)))
788 Vselection_alist
= Fcdr (Vselection_alist
);
792 for (rest
= Vselection_alist
; !NILP (rest
); rest
= Fcdr (rest
))
793 if (EQ (local_selection_data
, Fcar (XCONS (rest
)->cdr
)))
795 XCONS (rest
)->cdr
= Fcdr (XCONS (rest
)->cdr
);
800 /* Let random lisp code notice that the selection has been stolen. */
804 rest
= Vx_lost_selection_hooks
;
805 if (!EQ (rest
, Qunbound
))
807 for (; CONSP (rest
); rest
= Fcdr (rest
))
808 call1 (Fcar (rest
), selection_symbol
);
809 prepare_menu_bars ();
810 redisplay_preserve_echo_area ();
815 /* Clear all selections that were made from frame F.
816 We do this when about to delete a frame. */
819 x_clear_frame_selections (f
)
825 XSETFRAME (frame
, f
);
827 /* Otherwise, we're really honest and truly being told to drop it.
828 Don't use Fdelq as that may QUIT;. */
830 /* Delete elements from the beginning of Vselection_alist. */
831 while (!NILP (Vselection_alist
)
832 && EQ (frame
, Fcar (Fcdr (Fcdr (Fcdr (Fcar (Vselection_alist
)))))))
834 /* Let random Lisp code notice that the selection has been stolen. */
835 Lisp_Object hooks
, selection_symbol
;
837 hooks
= Vx_lost_selection_hooks
;
838 selection_symbol
= Fcar (Fcar (Vselection_alist
));
840 if (!EQ (hooks
, Qunbound
))
842 for (; CONSP (hooks
); hooks
= Fcdr (hooks
))
843 call1 (Fcar (hooks
), selection_symbol
);
844 #if 0 /* This can crash when deleting a frame
845 from x_connection_closed. Anyway, it seems unnecessary;
846 something else should cause a redisplay. */
847 redisplay_preserve_echo_area ();
851 Vselection_alist
= Fcdr (Vselection_alist
);
854 /* Delete elements after the beginning of Vselection_alist. */
855 for (rest
= Vselection_alist
; !NILP (rest
); rest
= Fcdr (rest
))
856 if (EQ (frame
, Fcar (Fcdr (Fcdr (Fcdr (Fcar (XCONS (rest
)->cdr
)))))))
858 /* Let random Lisp code notice that the selection has been stolen. */
859 Lisp_Object hooks
, selection_symbol
;
861 hooks
= Vx_lost_selection_hooks
;
862 selection_symbol
= Fcar (Fcar (XCONS (rest
)->cdr
));
864 if (!EQ (hooks
, Qunbound
))
866 for (; CONSP (hooks
); hooks
= Fcdr (hooks
))
867 call1 (Fcar (hooks
), selection_symbol
);
868 #if 0 /* See above */
869 redisplay_preserve_echo_area ();
872 XCONS (rest
)->cdr
= Fcdr (XCONS (rest
)->cdr
);
877 /* Nonzero if any properties for DISPLAY and WINDOW
878 are on the list of what we are waiting for. */
881 waiting_for_other_props_on_window (display
, window
)
885 struct prop_location
*rest
= property_change_wait_list
;
887 if (rest
->display
== display
&& rest
->window
== window
)
894 /* Add an entry to the list of property changes we are waiting for.
895 DISPLAY, WINDOW, PROPERTY, STATE describe what we will wait for.
896 The return value is a number that uniquely identifies
897 this awaited property change. */
899 static struct prop_location
*
900 expect_property_change (display
, window
, property
, state
)
906 struct prop_location
*pl
907 = (struct prop_location
*) xmalloc (sizeof (struct prop_location
));
908 pl
->identifier
= ++prop_location_identifier
;
909 pl
->display
= display
;
911 pl
->property
= property
;
912 pl
->desired_state
= state
;
913 pl
->next
= property_change_wait_list
;
915 property_change_wait_list
= pl
;
919 /* Delete an entry from the list of property changes we are waiting for.
920 IDENTIFIER is the number that uniquely identifies the entry. */
923 unexpect_property_change (location
)
924 struct prop_location
*location
;
926 struct prop_location
*prev
= 0, *rest
= property_change_wait_list
;
929 if (rest
== location
)
932 prev
->next
= rest
->next
;
934 property_change_wait_list
= rest
->next
;
943 /* Remove the property change expectation element for IDENTIFIER. */
946 wait_for_property_change_unwind (identifierval
)
947 Lisp_Object identifierval
;
949 unexpect_property_change ((struct prop_location
*)
950 (XFASTINT (XCONS (identifierval
)->car
) << 16
951 | XFASTINT (XCONS (identifierval
)->cdr
)));
955 /* Actually wait for a property change.
956 IDENTIFIER should be the value that expect_property_change returned. */
959 wait_for_property_change (location
)
960 struct prop_location
*location
;
963 int count
= specpdl_ptr
- specpdl
;
966 tem
= Fcons (Qnil
, Qnil
);
967 XSETFASTINT (XCONS (tem
)->car
, (EMACS_UINT
)location
>> 16);
968 XSETFASTINT (XCONS (tem
)->cdr
, (EMACS_UINT
)location
& 0xffff);
970 /* Make sure to do unexpect_property_change if we quit or err. */
971 record_unwind_protect (wait_for_property_change_unwind
, tem
);
973 XCONS (property_change_reply
)->car
= Qnil
;
975 property_change_reply_object
= location
;
976 /* If the event we are waiting for arrives beyond here, it will set
977 property_change_reply, because property_change_reply_object says so. */
978 if (! location
->arrived
)
980 secs
= x_selection_timeout
/ 1000;
981 usecs
= (x_selection_timeout
% 1000) * 1000;
982 wait_reading_process_input (secs
, usecs
, property_change_reply
, 0);
984 if (NILP (XCONS (property_change_reply
)->car
))
985 error ("Timed out waiting for property-notify event");
988 unbind_to (count
, Qnil
);
991 /* Called from XTread_socket in response to a PropertyNotify event. */
994 x_handle_property_notify (event
)
995 XPropertyEvent
*event
;
997 struct prop_location
*prev
= 0, *rest
= property_change_wait_list
;
1000 if (rest
->property
== event
->atom
1001 && rest
->window
== event
->window
1002 && rest
->display
== event
->display
1003 && rest
->desired_state
== event
->state
)
1006 fprintf (stderr
, "Saw expected prop-%s on %s\n",
1007 (event
->state
== PropertyDelete
? "delete" : "change"),
1008 (char *) XSYMBOL (x_atom_to_symbol (dpyinfo
, event
->display
,
1015 /* If this is the one wait_for_property_change is waiting for,
1016 tell it to wake up. */
1017 if (rest
== property_change_reply_object
)
1018 XCONS (property_change_reply
)->car
= Qt
;
1021 prev
->next
= rest
->next
;
1023 property_change_wait_list
= rest
->next
;
1031 fprintf (stderr
, "Saw UNexpected prop-%s on %s\n",
1032 (event
->state
== PropertyDelete
? "delete" : "change"),
1033 (char *) XSYMBOL (x_atom_to_symbol (dpyinfo
,
1034 event
->display
, event
->atom
))
1041 #if 0 /* #### MULTIPLE doesn't work yet */
1044 fetch_multiple_target (event
)
1045 XSelectionRequestEvent
*event
;
1047 Display
*display
= event
->display
;
1048 Window window
= event
->requestor
;
1049 Atom target
= event
->target
;
1050 Atom selection_atom
= event
->selection
;
1055 x_get_window_property_as_lisp_data (display
, window
, target
,
1056 QMULTIPLE
, selection_atom
));
1060 copy_multiple_data (obj
)
1067 return Fcons (XCONS (obj
)->car
, copy_multiple_data (XCONS (obj
)->cdr
));
1069 CHECK_VECTOR (obj
, 0);
1070 vec
= Fmake_vector (size
= XVECTOR (obj
)->size
, Qnil
);
1071 for (i
= 0; i
< size
; i
++)
1073 Lisp_Object vec2
= XVECTOR (obj
)->contents
[i
];
1074 CHECK_VECTOR (vec2
, 0);
1075 if (XVECTOR (vec2
)->size
!= 2)
1076 /* ??? Confusing error message */
1077 Fsignal (Qerror
, Fcons (build_string ("vectors must be of length 2"),
1078 Fcons (vec2
, Qnil
)));
1079 XVECTOR (vec
)->contents
[i
] = Fmake_vector (2, Qnil
);
1080 XVECTOR (XVECTOR (vec
)->contents
[i
])->contents
[0]
1081 = XVECTOR (vec2
)->contents
[0];
1082 XVECTOR (XVECTOR (vec
)->contents
[i
])->contents
[1]
1083 = XVECTOR (vec2
)->contents
[1];
1091 /* Variables for communication with x_handle_selection_notify. */
1092 static Atom reading_which_selection
;
1093 static Lisp_Object reading_selection_reply
;
1094 static Window reading_selection_window
;
1096 /* Do protocol to read selection-data from the server.
1097 Converts this to Lisp data and returns it. */
1100 x_get_foreign_selection (selection_symbol
, target_type
)
1101 Lisp_Object selection_symbol
, target_type
;
1103 Window requestor_window
= FRAME_X_WINDOW (selected_frame
);
1104 Display
*display
= FRAME_X_DISPLAY (selected_frame
);
1105 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
1106 Time requestor_time
= last_event_timestamp
;
1107 Atom target_property
= dpyinfo
->Xatom_EMACS_TMP
;
1108 Atom selection_atom
= symbol_to_x_atom (dpyinfo
, display
, selection_symbol
);
1114 if (CONSP (target_type
))
1115 type_atom
= symbol_to_x_atom (dpyinfo
, display
, XCONS (target_type
)->car
);
1117 type_atom
= symbol_to_x_atom (dpyinfo
, display
, target_type
);
1120 count
= x_catch_errors (display
);
1121 XConvertSelection (display
, selection_atom
, type_atom
, target_property
,
1122 requestor_window
, requestor_time
);
1125 /* Prepare to block until the reply has been read. */
1126 reading_selection_window
= requestor_window
;
1127 reading_which_selection
= selection_atom
;
1128 XCONS (reading_selection_reply
)->car
= Qnil
;
1130 frame
= some_frame_on_display (dpyinfo
);
1132 /* If the display no longer has frames, we can't expect
1133 to get many more selection requests from it, so don't
1134 bother trying to queue them. */
1137 x_start_queuing_selection_requests (display
);
1139 record_unwind_protect (queue_selection_requests_unwind
,
1144 /* This allows quits. Also, don't wait forever. */
1145 secs
= x_selection_timeout
/ 1000;
1146 usecs
= (x_selection_timeout
% 1000) * 1000;
1147 wait_reading_process_input (secs
, usecs
, reading_selection_reply
, 0);
1150 x_check_errors (display
, "Cannot get selection: %s");
1151 x_uncatch_errors (display
, count
);
1154 if (NILP (XCONS (reading_selection_reply
)->car
))
1155 error ("Timed out waiting for reply from selection owner");
1156 if (EQ (XCONS (reading_selection_reply
)->car
, Qlambda
))
1157 error ("No `%s' selection", XSYMBOL (selection_symbol
)->name
->data
);
1159 /* Otherwise, the selection is waiting for us on the requested property. */
1161 x_get_window_property_as_lisp_data (display
, requestor_window
,
1162 target_property
, target_type
,
1166 /* Subroutines of x_get_window_property_as_lisp_data */
1168 /* Use free, not XFree, to free the data obtained with this function. */
1171 x_get_window_property (display
, window
, property
, data_ret
, bytes_ret
,
1172 actual_type_ret
, actual_format_ret
, actual_size_ret
,
1177 unsigned char **data_ret
;
1179 Atom
*actual_type_ret
;
1180 int *actual_format_ret
;
1181 unsigned long *actual_size_ret
;
1185 unsigned long bytes_remaining
;
1187 unsigned char *tmp_data
= 0;
1189 int buffer_size
= SELECTION_QUANTUM (display
);
1190 if (buffer_size
> MAX_SELECTION_QUANTUM
) buffer_size
= MAX_SELECTION_QUANTUM
;
1193 /* First probe the thing to find out how big it is. */
1194 result
= XGetWindowProperty (display
, window
, property
,
1195 0L, 0L, False
, AnyPropertyType
,
1196 actual_type_ret
, actual_format_ret
,
1198 &bytes_remaining
, &tmp_data
);
1199 if (result
!= Success
)
1206 /* This was allocated by Xlib, so use XFree. */
1207 XFree ((char *) tmp_data
);
1209 if (*actual_type_ret
== None
|| *actual_format_ret
== 0)
1215 total_size
= bytes_remaining
+ 1;
1216 *data_ret
= (unsigned char *) xmalloc (total_size
);
1218 /* Now read, until we've gotten it all. */
1219 while (bytes_remaining
)
1222 int last
= bytes_remaining
;
1225 = XGetWindowProperty (display
, window
, property
,
1226 (long)offset
/4, (long)buffer_size
/4,
1229 actual_type_ret
, actual_format_ret
,
1230 actual_size_ret
, &bytes_remaining
, &tmp_data
);
1232 fprintf (stderr
, "<< read %d\n", last
-bytes_remaining
);
1234 /* If this doesn't return Success at this point, it means that
1235 some clod deleted the selection while we were in the midst of
1236 reading it. Deal with that, I guess....
1238 if (result
!= Success
) break;
1239 *actual_size_ret
*= *actual_format_ret
/ 8;
1240 bcopy (tmp_data
, (*data_ret
) + offset
, *actual_size_ret
);
1241 offset
+= *actual_size_ret
;
1242 /* This was allocated by Xlib, so use XFree. */
1243 XFree ((char *) tmp_data
);
1248 *bytes_ret
= offset
;
1251 /* Use free, not XFree, to free the data obtained with this function. */
1254 receive_incremental_selection (display
, window
, property
, target_type
,
1255 min_size_bytes
, data_ret
, size_bytes_ret
,
1256 type_ret
, format_ret
, size_ret
)
1260 Lisp_Object target_type
; /* for error messages only */
1261 unsigned int min_size_bytes
;
1262 unsigned char **data_ret
;
1263 int *size_bytes_ret
;
1265 unsigned long *size_ret
;
1269 struct prop_location
*wait_object
;
1270 *size_bytes_ret
= min_size_bytes
;
1271 *data_ret
= (unsigned char *) xmalloc (*size_bytes_ret
);
1273 fprintf (stderr
, "\nread INCR %d\n", min_size_bytes
);
1276 /* At this point, we have read an INCR property.
1277 Delete the property to ack it.
1278 (But first, prepare to receive the next event in this handshake.)
1280 Now, we must loop, waiting for the sending window to put a value on
1281 that property, then reading the property, then deleting it to ack.
1282 We are done when the sender places a property of length 0.
1285 XSelectInput (display
, window
, STANDARD_EVENT_SET
| PropertyChangeMask
);
1286 XDeleteProperty (display
, window
, property
);
1287 wait_object
= expect_property_change (display
, window
, property
,
1294 unsigned char *tmp_data
;
1296 wait_for_property_change (wait_object
);
1297 /* expect it again immediately, because x_get_window_property may
1298 .. no it won't, I don't get it.
1299 .. Ok, I get it now, the Xt code that implements INCR is broken.
1301 x_get_window_property (display
, window
, property
,
1302 &tmp_data
, &tmp_size_bytes
,
1303 type_ret
, format_ret
, size_ret
, 1);
1305 if (tmp_size_bytes
== 0) /* we're done */
1308 fprintf (stderr
, " read INCR done\n");
1310 if (! waiting_for_other_props_on_window (display
, window
))
1311 XSelectInput (display
, window
, STANDARD_EVENT_SET
);
1312 unexpect_property_change (wait_object
);
1313 /* Use free, not XFree, because x_get_window_property
1314 calls xmalloc itself. */
1315 if (tmp_data
) free (tmp_data
);
1320 XDeleteProperty (display
, window
, property
);
1321 wait_object
= expect_property_change (display
, window
, property
,
1327 fprintf (stderr
, " read INCR %d\n", tmp_size_bytes
);
1329 if (*size_bytes_ret
< offset
+ tmp_size_bytes
)
1332 fprintf (stderr
, " read INCR realloc %d -> %d\n",
1333 *size_bytes_ret
, offset
+ tmp_size_bytes
);
1335 *size_bytes_ret
= offset
+ tmp_size_bytes
;
1336 *data_ret
= (unsigned char *) xrealloc (*data_ret
, *size_bytes_ret
);
1338 bcopy (tmp_data
, (*data_ret
) + offset
, tmp_size_bytes
);
1339 offset
+= tmp_size_bytes
;
1340 /* Use free, not XFree, because x_get_window_property
1341 calls xmalloc itself. */
1346 /* Once a requested selection is "ready" (we got a SelectionNotify event),
1347 fetch value from property PROPERTY of X window WINDOW on display DISPLAY.
1348 TARGET_TYPE and SELECTION_ATOM are used in error message if this fails. */
1351 x_get_window_property_as_lisp_data (display
, window
, property
, target_type
,
1356 Lisp_Object target_type
; /* for error messages only */
1357 Atom selection_atom
; /* for error messages only */
1361 unsigned long actual_size
;
1362 unsigned char *data
= 0;
1365 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1367 x_get_window_property (display
, window
, property
, &data
, &bytes
,
1368 &actual_type
, &actual_format
, &actual_size
, 1);
1371 int there_is_a_selection_owner
;
1373 there_is_a_selection_owner
1374 = XGetSelectionOwner (display
, selection_atom
);
1377 there_is_a_selection_owner
1378 ? Fcons (build_string ("selection owner couldn't convert"),
1380 ? Fcons (target_type
,
1381 Fcons (x_atom_to_symbol (dpyinfo
, display
,
1384 : Fcons (target_type
, Qnil
))
1385 : Fcons (build_string ("no selection"),
1386 Fcons (x_atom_to_symbol (dpyinfo
, display
,
1391 if (actual_type
== dpyinfo
->Xatom_INCR
)
1393 /* That wasn't really the data, just the beginning. */
1395 unsigned int min_size_bytes
= * ((unsigned int *) data
);
1397 /* Use free, not XFree, because x_get_window_property
1398 calls xmalloc itself. */
1399 free ((char *) data
);
1401 receive_incremental_selection (display
, window
, property
, target_type
,
1402 min_size_bytes
, &data
, &bytes
,
1403 &actual_type
, &actual_format
,
1408 XDeleteProperty (display
, window
, property
);
1412 /* It's been read. Now convert it to a lisp object in some semi-rational
1414 val
= selection_data_to_lisp_data (display
, data
, bytes
,
1415 actual_type
, actual_format
);
1417 /* Use free, not XFree, because x_get_window_property
1418 calls xmalloc itself. */
1419 free ((char *) data
);
1423 /* These functions convert from the selection data read from the server into
1424 something that we can use from Lisp, and vice versa.
1426 Type: Format: Size: Lisp Type:
1427 ----- ------- ----- -----------
1430 ATOM 32 > 1 Vector of Symbols
1432 * 16 > 1 Vector of Integers
1433 * 32 1 if <=16 bits: Integer
1434 if > 16 bits: Cons of top16, bot16
1435 * 32 > 1 Vector of the above
1437 When converting a Lisp number to C, it is assumed to be of format 16 if
1438 it is an integer, and of format 32 if it is a cons of two integers.
1440 When converting a vector of numbers from Lisp to C, it is assumed to be
1441 of format 16 if every element in the vector is an integer, and is assumed
1442 to be of format 32 if any element is a cons of two integers.
1444 When converting an object to C, it may be of the form (SYMBOL . <data>)
1445 where SYMBOL is what we should claim that the type is. Format and
1446 representation are as above. */
1451 selection_data_to_lisp_data (display
, data
, size
, type
, format
)
1453 unsigned char *data
;
1457 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1459 if (type
== dpyinfo
->Xatom_NULL
)
1462 /* Convert any 8-bit data to a string, for compactness. */
1463 else if (format
== 8)
1466 int require_encoding
= 0;
1468 /* If TYPE is `TEXT' or `COMPOUND_TEXT', we should decode DATA
1469 to Emacs internal format because DATA may be encoded in
1470 compound text format. In addtion, if TYPE is `STRING' and
1471 DATA contains any 8-bit Latin-1 code, we should also decode
1473 if (type
== dpyinfo
->Xatom_TEXT
|| type
== dpyinfo
->Xatom_COMPOUND_TEXT
)
1474 require_encoding
= 1;
1475 else if (type
== XA_STRING
)
1478 for (i
= 0; i
< size
; i
++)
1480 if (data
[i
] >= 0x80)
1482 require_encoding
= 1;
1487 if (!require_encoding
)
1488 str
= make_string ((char *) data
, size
);
1493 struct coding_system coding
;
1494 Lisp_Object sym
= intern ("iso-latin-1");
1496 setup_coding_system (Fcheck_coding_system (sym
), &coding
);
1497 coding
.last_block
= 1;
1498 bufsize
= decoding_buffer_size (&coding
, size
);
1499 buf
= (unsigned char *) xmalloc (bufsize
);
1500 size
= decode_coding (&coding
, data
, buf
, size
, bufsize
, &dummy
);
1501 str
= make_string ((char *) buf
, size
);
1506 /* Convert a single atom to a Lisp_Symbol. Convert a set of atoms to
1507 a vector of symbols.
1509 else if (type
== XA_ATOM
)
1512 if (size
== sizeof (Atom
))
1513 return x_atom_to_symbol (dpyinfo
, display
, *((Atom
*) data
));
1516 Lisp_Object v
= Fmake_vector (make_number (size
/ sizeof (Atom
)),
1518 for (i
= 0; i
< size
/ sizeof (Atom
); i
++)
1519 Faset (v
, make_number (i
),
1520 x_atom_to_symbol (dpyinfo
, display
, ((Atom
*) data
) [i
]));
1525 /* Convert a single 16 or small 32 bit number to a Lisp_Int.
1526 If the number is > 16 bits, convert it to a cons of integers,
1527 16 bits in each half.
1529 else if (format
== 32 && size
== sizeof (long))
1530 return long_to_cons (((unsigned long *) data
) [0]);
1531 else if (format
== 16 && size
== sizeof (short))
1532 return make_number ((int) (((unsigned short *) data
) [0]));
1534 /* Convert any other kind of data to a vector of numbers, represented
1535 as above (as an integer, or a cons of two 16 bit integers.)
1537 else if (format
== 16)
1541 v
= Fmake_vector (make_number (size
/ 2), make_number (0));
1542 for (i
= 0; i
< size
/ 2; i
++)
1544 int j
= (int) ((unsigned short *) data
) [i
];
1545 Faset (v
, make_number (i
), make_number (j
));
1552 Lisp_Object v
= Fmake_vector (make_number (size
/ 4), make_number (0));
1553 for (i
= 0; i
< size
/ 4; i
++)
1555 unsigned long j
= ((unsigned long *) data
) [i
];
1556 Faset (v
, make_number (i
), long_to_cons (j
));
1563 /* Use free, not XFree, to free the data obtained with this function. */
1566 lisp_data_to_selection_data (display
, obj
,
1567 data_ret
, type_ret
, size_ret
,
1568 format_ret
, nofree_ret
)
1571 unsigned char **data_ret
;
1573 unsigned int *size_ret
;
1577 Lisp_Object type
= Qnil
;
1578 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1582 if (CONSP (obj
) && SYMBOLP (XCONS (obj
)->car
))
1584 type
= XCONS (obj
)->car
;
1585 obj
= XCONS (obj
)->cdr
;
1586 if (CONSP (obj
) && NILP (XCONS (obj
)->cdr
))
1587 obj
= XCONS (obj
)->car
;
1590 if (EQ (obj
, QNULL
) || (EQ (type
, QNULL
)))
1591 { /* This is not the same as declining */
1597 else if (STRINGP (obj
))
1599 /* Since we are now handling multilingual text, we must consider
1600 sending back compound text. */
1601 int charsets
[MAX_CHARSET
+ 1];
1605 *size_ret
= XSTRING (obj
)->size
;
1606 *data_ret
= XSTRING (obj
)->data
;
1607 bzero (charsets
, (MAX_CHARSET
+ 1) * sizeof (int));
1608 num
= ((*size_ret
<= 1) /* Check the possibility of short cut. */
1610 : find_charset_in_str (*data_ret
, *size_ret
, charsets
, Qnil
));
1612 if (!num
|| (num
== 1 && charsets
[CHARSET_ASCII
]))
1614 /* No multibyte character in OBJ. We need not encode it. */
1616 if (NILP (type
)) type
= QSTRING
;
1620 /* We must encode contents of OBJ to compound text format.
1621 The format is compatible with what the target `STRING'
1622 expects if OBJ contains only ASCII and Latin-1
1626 struct coding_system coding
;
1627 Lisp_Object sym
= intern ("iso-latin-1");
1629 setup_coding_system (Fcheck_coding_system (sym
), &coding
);
1630 coding
.last_block
= 1;
1631 bufsize
= encoding_buffer_size (&coding
, *size_ret
);
1632 buf
= (unsigned char *) xmalloc (bufsize
);
1633 *size_ret
= encode_coding (&coding
, *data_ret
, buf
,
1634 *size_ret
, bufsize
, &dummy
);
1636 if (charsets
[charset_latin_iso8859_1
]
1637 && (num
== 1 || (num
== 2 && charsets
[CHARSET_ASCII
])))
1639 /* Ok, we can return it as `STRING'. */
1640 if (NILP (type
)) type
= QSTRING
;
1644 /* We must return it as `COMPOUND_TEXT'. */
1645 if (NILP (type
)) type
= QCOMPOUND_TEXT
;
1649 else if (SYMBOLP (obj
))
1653 *data_ret
= (unsigned char *) xmalloc (sizeof (Atom
) + 1);
1654 (*data_ret
) [sizeof (Atom
)] = 0;
1655 (*(Atom
**) data_ret
) [0] = symbol_to_x_atom (dpyinfo
, display
, obj
);
1656 if (NILP (type
)) type
= QATOM
;
1658 else if (INTEGERP (obj
)
1659 && XINT (obj
) < 0xFFFF
1660 && XINT (obj
) > -0xFFFF)
1664 *data_ret
= (unsigned char *) xmalloc (sizeof (short) + 1);
1665 (*data_ret
) [sizeof (short)] = 0;
1666 (*(short **) data_ret
) [0] = (short) XINT (obj
);
1667 if (NILP (type
)) type
= QINTEGER
;
1669 else if (INTEGERP (obj
)
1670 || (CONSP (obj
) && INTEGERP (XCONS (obj
)->car
)
1671 && (INTEGERP (XCONS (obj
)->cdr
)
1672 || (CONSP (XCONS (obj
)->cdr
)
1673 && INTEGERP (XCONS (XCONS (obj
)->cdr
)->car
)))))
1677 *data_ret
= (unsigned char *) xmalloc (sizeof (long) + 1);
1678 (*data_ret
) [sizeof (long)] = 0;
1679 (*(unsigned long **) data_ret
) [0] = cons_to_long (obj
);
1680 if (NILP (type
)) type
= QINTEGER
;
1682 else if (VECTORP (obj
))
1684 /* Lisp_Vectors may represent a set of ATOMs;
1685 a set of 16 or 32 bit INTEGERs;
1686 or a set of ATOM_PAIRs (represented as [[A1 A2] [A3 A4] ...]
1690 if (SYMBOLP (XVECTOR (obj
)->contents
[0]))
1691 /* This vector is an ATOM set */
1693 if (NILP (type
)) type
= QATOM
;
1694 *size_ret
= XVECTOR (obj
)->size
;
1696 *data_ret
= (unsigned char *) xmalloc ((*size_ret
) * sizeof (Atom
));
1697 for (i
= 0; i
< *size_ret
; i
++)
1698 if (SYMBOLP (XVECTOR (obj
)->contents
[i
]))
1699 (*(Atom
**) data_ret
) [i
]
1700 = symbol_to_x_atom (dpyinfo
, display
, XVECTOR (obj
)->contents
[i
]);
1702 Fsignal (Qerror
, /* Qselection_error */
1704 ("all elements of selection vector must have same type"),
1705 Fcons (obj
, Qnil
)));
1707 #if 0 /* #### MULTIPLE doesn't work yet */
1708 else if (VECTORP (XVECTOR (obj
)->contents
[0]))
1709 /* This vector is an ATOM_PAIR set */
1711 if (NILP (type
)) type
= QATOM_PAIR
;
1712 *size_ret
= XVECTOR (obj
)->size
;
1714 *data_ret
= (unsigned char *)
1715 xmalloc ((*size_ret
) * sizeof (Atom
) * 2);
1716 for (i
= 0; i
< *size_ret
; i
++)
1717 if (VECTORP (XVECTOR (obj
)->contents
[i
]))
1719 Lisp_Object pair
= XVECTOR (obj
)->contents
[i
];
1720 if (XVECTOR (pair
)->size
!= 2)
1723 ("elements of the vector must be vectors of exactly two elements"),
1724 Fcons (pair
, Qnil
)));
1726 (*(Atom
**) data_ret
) [i
* 2]
1727 = symbol_to_x_atom (dpyinfo
, display
,
1728 XVECTOR (pair
)->contents
[0]);
1729 (*(Atom
**) data_ret
) [(i
* 2) + 1]
1730 = symbol_to_x_atom (dpyinfo
, display
,
1731 XVECTOR (pair
)->contents
[1]);
1736 ("all elements of the vector must be of the same type"),
1737 Fcons (obj
, Qnil
)));
1742 /* This vector is an INTEGER set, or something like it */
1744 *size_ret
= XVECTOR (obj
)->size
;
1745 if (NILP (type
)) type
= QINTEGER
;
1747 for (i
= 0; i
< *size_ret
; i
++)
1748 if (CONSP (XVECTOR (obj
)->contents
[i
]))
1750 else if (!INTEGERP (XVECTOR (obj
)->contents
[i
]))
1751 Fsignal (Qerror
, /* Qselection_error */
1753 ("elements of selection vector must be integers or conses of integers"),
1754 Fcons (obj
, Qnil
)));
1756 *data_ret
= (unsigned char *) xmalloc (*size_ret
* (*format_ret
/8));
1757 for (i
= 0; i
< *size_ret
; i
++)
1758 if (*format_ret
== 32)
1759 (*((unsigned long **) data_ret
)) [i
]
1760 = cons_to_long (XVECTOR (obj
)->contents
[i
]);
1762 (*((unsigned short **) data_ret
)) [i
]
1763 = (unsigned short) cons_to_long (XVECTOR (obj
)->contents
[i
]);
1767 Fsignal (Qerror
, /* Qselection_error */
1768 Fcons (build_string ("unrecognised selection data"),
1769 Fcons (obj
, Qnil
)));
1771 *type_ret
= symbol_to_x_atom (dpyinfo
, display
, type
);
1775 clean_local_selection_data (obj
)
1779 && INTEGERP (XCONS (obj
)->car
)
1780 && CONSP (XCONS (obj
)->cdr
)
1781 && INTEGERP (XCONS (XCONS (obj
)->cdr
)->car
)
1782 && NILP (XCONS (XCONS (obj
)->cdr
)->cdr
))
1783 obj
= Fcons (XCONS (obj
)->car
, XCONS (obj
)->cdr
);
1786 && INTEGERP (XCONS (obj
)->car
)
1787 && INTEGERP (XCONS (obj
)->cdr
))
1789 if (XINT (XCONS (obj
)->car
) == 0)
1790 return XCONS (obj
)->cdr
;
1791 if (XINT (XCONS (obj
)->car
) == -1)
1792 return make_number (- XINT (XCONS (obj
)->cdr
));
1797 int size
= XVECTOR (obj
)->size
;
1800 return clean_local_selection_data (XVECTOR (obj
)->contents
[0]);
1801 copy
= Fmake_vector (make_number (size
), Qnil
);
1802 for (i
= 0; i
< size
; i
++)
1803 XVECTOR (copy
)->contents
[i
]
1804 = clean_local_selection_data (XVECTOR (obj
)->contents
[i
]);
1810 /* Called from XTread_socket to handle SelectionNotify events.
1811 If it's the selection we are waiting for, stop waiting
1812 by setting the car of reading_selection_reply to non-nil.
1813 We store t there if the reply is successful, lambda if not. */
1816 x_handle_selection_notify (event
)
1817 XSelectionEvent
*event
;
1819 if (event
->requestor
!= reading_selection_window
)
1821 if (event
->selection
!= reading_which_selection
)
1824 XCONS (reading_selection_reply
)->car
1825 = (event
->property
!= 0 ? Qt
: Qlambda
);
1829 DEFUN ("x-own-selection-internal", Fx_own_selection_internal
,
1830 Sx_own_selection_internal
, 2, 2, 0,
1831 "Assert an X selection of the given TYPE with the given VALUE.\n\
1832 TYPE is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1833 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1834 VALUE is typically a string, or a cons of two markers, but may be\n\
1835 anything that the functions on `selection-converter-alist' know about.")
1836 (selection_name
, selection_value
)
1837 Lisp_Object selection_name
, selection_value
;
1840 CHECK_SYMBOL (selection_name
, 0);
1841 if (NILP (selection_value
)) error ("selection-value may not be nil");
1842 x_own_selection (selection_name
, selection_value
);
1843 return selection_value
;
1847 /* Request the selection value from the owner. If we are the owner,
1848 simply return our selection value. If we are not the owner, this
1849 will block until all of the data has arrived. */
1851 DEFUN ("x-get-selection-internal", Fx_get_selection_internal
,
1852 Sx_get_selection_internal
, 2, 2, 0,
1853 "Return text selected from some X window.\n\
1854 SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1855 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1856 TYPE is the type of data desired, typically `STRING'.")
1857 (selection_symbol
, target_type
)
1858 Lisp_Object selection_symbol
, target_type
;
1860 Lisp_Object val
= Qnil
;
1861 struct gcpro gcpro1
, gcpro2
;
1862 GCPRO2 (target_type
, val
); /* we store newly consed data into these */
1864 CHECK_SYMBOL (selection_symbol
, 0);
1866 #if 0 /* #### MULTIPLE doesn't work yet */
1867 if (CONSP (target_type
)
1868 && XCONS (target_type
)->car
== QMULTIPLE
)
1870 CHECK_VECTOR (XCONS (target_type
)->cdr
, 0);
1871 /* So we don't destructively modify this... */
1872 target_type
= copy_multiple_data (target_type
);
1876 CHECK_SYMBOL (target_type
, 0);
1878 val
= x_get_local_selection (selection_symbol
, target_type
);
1882 val
= x_get_foreign_selection (selection_symbol
, target_type
);
1887 && SYMBOLP (XCONS (val
)->car
))
1889 val
= XCONS (val
)->cdr
;
1890 if (CONSP (val
) && NILP (XCONS (val
)->cdr
))
1891 val
= XCONS (val
)->car
;
1893 val
= clean_local_selection_data (val
);
1899 DEFUN ("x-disown-selection-internal", Fx_disown_selection_internal
,
1900 Sx_disown_selection_internal
, 1, 2, 0,
1901 "If we own the selection SELECTION, disown it.\n\
1902 Disowning it means there is no such selection.")
1904 Lisp_Object selection
;
1908 Atom selection_atom
;
1909 XSelectionClearEvent event
;
1911 struct x_display_info
*dpyinfo
;
1914 display
= FRAME_X_DISPLAY (selected_frame
);
1915 dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
1916 CHECK_SYMBOL (selection
, 0);
1918 timestamp
= last_event_timestamp
;
1920 timestamp
= cons_to_long (time
);
1922 if (NILP (assq_no_quit (selection
, Vselection_alist
)))
1923 return Qnil
; /* Don't disown the selection when we're not the owner. */
1925 selection_atom
= symbol_to_x_atom (dpyinfo
, display
, selection
);
1928 XSetSelectionOwner (display
, selection_atom
, None
, timestamp
);
1931 /* It doesn't seem to be guaranteed that a SelectionClear event will be
1932 generated for a window which owns the selection when that window sets
1933 the selection owner to None. The NCD server does, the MIT Sun4 server
1934 doesn't. So we synthesize one; this means we might get two, but
1935 that's ok, because the second one won't have any effect. */
1936 SELECTION_EVENT_DISPLAY (&event
) = display
;
1937 SELECTION_EVENT_SELECTION (&event
) = selection_atom
;
1938 SELECTION_EVENT_TIME (&event
) = timestamp
;
1939 x_handle_selection_clear (&event
);
1944 /* Get rid of all the selections in buffer BUFFER.
1945 This is used when we kill a buffer. */
1948 x_disown_buffer_selections (buffer
)
1952 struct buffer
*buf
= XBUFFER (buffer
);
1954 for (tail
= Vselection_alist
; CONSP (tail
); tail
= XCONS (tail
)->cdr
)
1956 Lisp_Object elt
, value
;
1957 elt
= XCONS (tail
)->car
;
1958 value
= XCONS (elt
)->cdr
;
1959 if (CONSP (value
) && MARKERP (XCONS (value
)->car
)
1960 && XMARKER (XCONS (value
)->car
)->buffer
== buf
)
1961 Fx_disown_selection_internal (XCONS (elt
)->car
, Qnil
);
1965 DEFUN ("x-selection-owner-p", Fx_selection_owner_p
, Sx_selection_owner_p
,
1967 "Whether the current Emacs process owns the given X Selection.\n\
1968 The arg should be the name of the selection in question, typically one of\n\
1969 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1970 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1971 For convenience, the symbol nil is the same as `PRIMARY',\n\
1972 and t is the same as `SECONDARY'.)")
1974 Lisp_Object selection
;
1977 CHECK_SYMBOL (selection
, 0);
1978 if (EQ (selection
, Qnil
)) selection
= QPRIMARY
;
1979 if (EQ (selection
, Qt
)) selection
= QSECONDARY
;
1981 if (NILP (Fassq (selection
, Vselection_alist
)))
1986 DEFUN ("x-selection-exists-p", Fx_selection_exists_p
, Sx_selection_exists_p
,
1988 "Whether there is an owner for the given X Selection.\n\
1989 The arg should be the name of the selection in question, typically one of\n\
1990 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
1991 \(Those are literal upper-case symbol names, since that's what X expects.)\n\
1992 For convenience, the symbol nil is the same as `PRIMARY',\n\
1993 and t is the same as `SECONDARY'.)")
1995 Lisp_Object selection
;
2001 /* It should be safe to call this before we have an X frame. */
2002 if (! FRAME_X_P (selected_frame
))
2005 dpy
= FRAME_X_DISPLAY (selected_frame
);
2006 CHECK_SYMBOL (selection
, 0);
2007 if (!NILP (Fx_selection_owner_p (selection
)))
2009 if (EQ (selection
, Qnil
)) selection
= QPRIMARY
;
2010 if (EQ (selection
, Qt
)) selection
= QSECONDARY
;
2011 atom
= symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame
),
2016 owner
= XGetSelectionOwner (dpy
, atom
);
2018 return (owner
? Qt
: Qnil
);
2022 #ifdef CUT_BUFFER_SUPPORT
2024 /* Ensure that all 8 cut buffers exist. ICCCM says we gotta... */
2026 initialize_cut_buffers (display
, window
)
2030 unsigned char *data
= (unsigned char *) "";
2032 #define FROB(atom) XChangeProperty (display, window, atom, XA_STRING, 8, \
2033 PropModeAppend, data, 0)
2034 FROB (XA_CUT_BUFFER0
);
2035 FROB (XA_CUT_BUFFER1
);
2036 FROB (XA_CUT_BUFFER2
);
2037 FROB (XA_CUT_BUFFER3
);
2038 FROB (XA_CUT_BUFFER4
);
2039 FROB (XA_CUT_BUFFER5
);
2040 FROB (XA_CUT_BUFFER6
);
2041 FROB (XA_CUT_BUFFER7
);
2047 #define CHECK_CUT_BUFFER(symbol,n) \
2048 { CHECK_SYMBOL ((symbol), (n)); \
2049 if (!EQ((symbol), QCUT_BUFFER0) && !EQ((symbol), QCUT_BUFFER1) \
2050 && !EQ((symbol), QCUT_BUFFER2) && !EQ((symbol), QCUT_BUFFER3) \
2051 && !EQ((symbol), QCUT_BUFFER4) && !EQ((symbol), QCUT_BUFFER5) \
2052 && !EQ((symbol), QCUT_BUFFER6) && !EQ((symbol), QCUT_BUFFER7)) \
2054 Fcons (build_string ("doesn't name a cut buffer"), \
2055 Fcons ((symbol), Qnil))); \
2058 DEFUN ("x-get-cut-buffer-internal", Fx_get_cut_buffer_internal
,
2059 Sx_get_cut_buffer_internal
, 1, 1, 0,
2060 "Returns the value of the named cut buffer (typically CUT_BUFFER0).")
2066 unsigned char *data
;
2073 struct x_display_info
*dpyinfo
;
2076 display
= FRAME_X_DISPLAY (selected_frame
);
2077 dpyinfo
= FRAME_X_DISPLAY_INFO (selected_frame
);
2078 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2079 CHECK_CUT_BUFFER (buffer
, 0);
2080 buffer_atom
= symbol_to_x_atom (dpyinfo
, display
, buffer
);
2082 x_get_window_property (display
, window
, buffer_atom
, &data
, &bytes
,
2083 &type
, &format
, &size
, 0);
2084 if (!data
) return Qnil
;
2086 if (format
!= 8 || type
!= XA_STRING
)
2088 Fcons (build_string ("cut buffer doesn't contain 8-bit data"),
2089 Fcons (x_atom_to_symbol (dpyinfo
, display
, type
),
2090 Fcons (make_number (format
), Qnil
))));
2092 ret
= (bytes
? make_string ((char *) data
, bytes
) : Qnil
);
2093 /* Use free, not XFree, because x_get_window_property
2094 calls xmalloc itself. */
2100 DEFUN ("x-store-cut-buffer-internal", Fx_store_cut_buffer_internal
,
2101 Sx_store_cut_buffer_internal
, 2, 2, 0,
2102 "Sets the value of the named cut buffer (typically CUT_BUFFER0).")
2104 Lisp_Object buffer
, string
;
2108 unsigned char *data
;
2110 int bytes_remaining
;
2115 display
= FRAME_X_DISPLAY (selected_frame
);
2116 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2118 max_bytes
= SELECTION_QUANTUM (display
);
2119 if (max_bytes
> MAX_SELECTION_QUANTUM
)
2120 max_bytes
= MAX_SELECTION_QUANTUM
;
2122 CHECK_CUT_BUFFER (buffer
, 0);
2123 CHECK_STRING (string
, 0);
2124 buffer_atom
= symbol_to_x_atom (FRAME_X_DISPLAY_INFO (selected_frame
),
2126 data
= (unsigned char *) XSTRING (string
)->data
;
2127 bytes
= XSTRING (string
)->size
;
2128 bytes_remaining
= bytes
;
2130 if (! FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
)
2132 initialize_cut_buffers (display
, window
);
2133 FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
= 1;
2138 /* Don't mess up with an empty value. */
2139 if (!bytes_remaining
)
2140 XChangeProperty (display
, window
, buffer_atom
, XA_STRING
, 8,
2141 PropModeReplace
, data
, 0);
2143 while (bytes_remaining
)
2145 int chunk
= (bytes_remaining
< max_bytes
2146 ? bytes_remaining
: max_bytes
);
2147 XChangeProperty (display
, window
, buffer_atom
, XA_STRING
, 8,
2148 (bytes_remaining
== bytes
2153 bytes_remaining
-= chunk
;
2160 DEFUN ("x-rotate-cut-buffers-internal", Fx_rotate_cut_buffers_internal
,
2161 Sx_rotate_cut_buffers_internal
, 1, 1, 0,
2162 "Rotate the values of the cut buffers by the given number of steps;\n\
2163 positive means move values forward, negative means backward.")
2172 display
= FRAME_X_DISPLAY (selected_frame
);
2173 window
= RootWindow (display
, 0); /* Cut buffers are on screen 0 */
2174 CHECK_NUMBER (n
, 0);
2177 if (! FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
)
2179 initialize_cut_buffers (display
, window
);
2180 FRAME_X_DISPLAY_INFO (selected_frame
)->cut_buffers_initialized
= 1;
2183 props
[0] = XA_CUT_BUFFER0
;
2184 props
[1] = XA_CUT_BUFFER1
;
2185 props
[2] = XA_CUT_BUFFER2
;
2186 props
[3] = XA_CUT_BUFFER3
;
2187 props
[4] = XA_CUT_BUFFER4
;
2188 props
[5] = XA_CUT_BUFFER5
;
2189 props
[6] = XA_CUT_BUFFER6
;
2190 props
[7] = XA_CUT_BUFFER7
;
2192 XRotateWindowProperties (display
, window
, props
, 8, XINT (n
));
2202 defsubr (&Sx_get_selection_internal
);
2203 defsubr (&Sx_own_selection_internal
);
2204 defsubr (&Sx_disown_selection_internal
);
2205 defsubr (&Sx_selection_owner_p
);
2206 defsubr (&Sx_selection_exists_p
);
2208 #ifdef CUT_BUFFER_SUPPORT
2209 defsubr (&Sx_get_cut_buffer_internal
);
2210 defsubr (&Sx_store_cut_buffer_internal
);
2211 defsubr (&Sx_rotate_cut_buffers_internal
);
2214 reading_selection_reply
= Fcons (Qnil
, Qnil
);
2215 staticpro (&reading_selection_reply
);
2216 reading_selection_window
= 0;
2217 reading_which_selection
= 0;
2219 property_change_wait_list
= 0;
2220 prop_location_identifier
= 0;
2221 property_change_reply
= Fcons (Qnil
, Qnil
);
2222 staticpro (&property_change_reply
);
2224 Vselection_alist
= Qnil
;
2225 staticpro (&Vselection_alist
);
2227 DEFVAR_LISP ("selection-converter-alist", &Vselection_converter_alist
,
2228 "An alist associating X Windows selection-types with functions.\n\
2229 These functions are called to convert the selection, with three args:\n\
2230 the name of the selection (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
2231 a desired type to which the selection should be converted;\n\
2232 and the local selection value (whatever was given to `x-own-selection').\n\
2234 The function should return the value to send to the X server\n\
2235 \(typically a string). A return value of nil\n\
2236 means that the conversion could not be done.\n\
2237 A return value which is the symbol `NULL'\n\
2238 means that a side-effect was executed,\n\
2239 and there is no meaningful selection value.");
2240 Vselection_converter_alist
= Qnil
;
2242 DEFVAR_LISP ("x-lost-selection-hooks", &Vx_lost_selection_hooks
,
2243 "A list of functions to be called when Emacs loses an X selection.\n\
2244 \(This happens when some other X client makes its own selection\n\
2245 or when a Lisp program explicitly clears the selection.)\n\
2246 The functions are called with one argument, the selection type\n\
2247 \(a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD').");
2248 Vx_lost_selection_hooks
= Qnil
;
2250 DEFVAR_LISP ("x-sent-selection-hooks", &Vx_sent_selection_hooks
,
2251 "A list of functions to be called when Emacs answers a selection request.\n\
2252 The functions are called with four arguments:\n\
2253 - the selection name (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');\n\
2254 - the selection-type which Emacs was asked to convert the\n\
2255 selection into before sending (for example, `STRING' or `LENGTH');\n\
2256 - a flag indicating success or failure for responding to the request.\n\
2257 We might have failed (and declined the request) for any number of reasons,\n\
2258 including being asked for a selection that we no longer own, or being asked\n\
2259 to convert into a type that we don't know about or that is inappropriate.\n\
2260 This hook doesn't let you change the behavior of Emacs's selection replies,\n\
2261 it merely informs you that they have happened.");
2262 Vx_sent_selection_hooks
= Qnil
;
2264 DEFVAR_INT ("x-selection-timeout", &x_selection_timeout
,
2265 "Number of milliseconds to wait for a selection reply.\n\
2266 If the selection owner doesn't reply in this time, we give up.\n\
2267 A value of 0 means wait as long as necessary. This is initialized from the\n\
2268 \"*selectionTimeout\" resource.");
2269 x_selection_timeout
= 0;
2271 QPRIMARY
= intern ("PRIMARY"); staticpro (&QPRIMARY
);
2272 QSECONDARY
= intern ("SECONDARY"); staticpro (&QSECONDARY
);
2273 QSTRING
= intern ("STRING"); staticpro (&QSTRING
);
2274 QINTEGER
= intern ("INTEGER"); staticpro (&QINTEGER
);
2275 QCLIPBOARD
= intern ("CLIPBOARD"); staticpro (&QCLIPBOARD
);
2276 QTIMESTAMP
= intern ("TIMESTAMP"); staticpro (&QTIMESTAMP
);
2277 QTEXT
= intern ("TEXT"); staticpro (&QTEXT
);
2278 QCOMPOUND_TEXT
= intern ("COMPOUND_TEXT"); staticpro (&QCOMPOUND_TEXT
);
2279 QTIMESTAMP
= intern ("TIMESTAMP"); staticpro (&QTIMESTAMP
);
2280 QDELETE
= intern ("DELETE"); staticpro (&QDELETE
);
2281 QMULTIPLE
= intern ("MULTIPLE"); staticpro (&QMULTIPLE
);
2282 QINCR
= intern ("INCR"); staticpro (&QINCR
);
2283 QEMACS_TMP
= intern ("_EMACS_TMP_"); staticpro (&QEMACS_TMP
);
2284 QTARGETS
= intern ("TARGETS"); staticpro (&QTARGETS
);
2285 QATOM
= intern ("ATOM"); staticpro (&QATOM
);
2286 QATOM_PAIR
= intern ("ATOM_PAIR"); staticpro (&QATOM_PAIR
);
2287 QNULL
= intern ("NULL"); staticpro (&QNULL
);
2289 #ifdef CUT_BUFFER_SUPPORT
2290 QCUT_BUFFER0
= intern ("CUT_BUFFER0"); staticpro (&QCUT_BUFFER0
);
2291 QCUT_BUFFER1
= intern ("CUT_BUFFER1"); staticpro (&QCUT_BUFFER1
);
2292 QCUT_BUFFER2
= intern ("CUT_BUFFER2"); staticpro (&QCUT_BUFFER2
);
2293 QCUT_BUFFER3
= intern ("CUT_BUFFER3"); staticpro (&QCUT_BUFFER3
);
2294 QCUT_BUFFER4
= intern ("CUT_BUFFER4"); staticpro (&QCUT_BUFFER4
);
2295 QCUT_BUFFER5
= intern ("CUT_BUFFER5"); staticpro (&QCUT_BUFFER5
);
2296 QCUT_BUFFER6
= intern ("CUT_BUFFER6"); staticpro (&QCUT_BUFFER6
);
2297 QCUT_BUFFER7
= intern ("CUT_BUFFER7"); staticpro (&QCUT_BUFFER7
);