1 /* X Selection processing for Emacs.
2 Copyright (C) 1993-1997, 2000-2012 Free Software Foundation, Inc.
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 3 of the License, or
9 (at your option) any later version.
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. If not, see <http://www.gnu.org/licenses/>. */
20 /* Rewritten by jwz */
24 #include <stdio.h> /* termhooks.h needs this */
27 #ifdef HAVE_SYS_TYPES_H
28 #include <sys/types.h>
34 #include "xterm.h" /* for all of the X includes */
35 #include "dispextern.h" /* frame.h seems to want this */
36 #include "frame.h" /* Need this to get the X window of selected_frame */
37 #include "blockinput.h"
38 #include "character.h"
41 #include "termhooks.h"
44 #include <X11/Xproto.h>
47 struct selection_data
;
49 static Lisp_Object
x_atom_to_symbol (Display
*dpy
, Atom atom
);
50 static Atom
symbol_to_x_atom (struct x_display_info
*, Lisp_Object
);
51 static void x_own_selection (Lisp_Object
, Lisp_Object
, Lisp_Object
);
52 static Lisp_Object
x_get_local_selection (Lisp_Object
, Lisp_Object
, int,
53 struct x_display_info
*);
54 static void x_decline_selection_request (struct input_event
*);
55 static Lisp_Object
x_selection_request_lisp_error (Lisp_Object
);
56 static Lisp_Object
queue_selection_requests_unwind (Lisp_Object
);
57 static Lisp_Object
x_catch_errors_unwind (Lisp_Object
);
58 static void x_reply_selection_request (struct input_event
*, struct x_display_info
*);
59 static int x_convert_selection (struct input_event
*, Lisp_Object
, Lisp_Object
,
60 Atom
, int, struct x_display_info
*);
61 static int waiting_for_other_props_on_window (Display
*, Window
);
62 static struct prop_location
*expect_property_change (Display
*, Window
,
64 static void unexpect_property_change (struct prop_location
*);
65 static Lisp_Object
wait_for_property_change_unwind (Lisp_Object
);
66 static void wait_for_property_change (struct prop_location
*);
67 static Lisp_Object
x_get_foreign_selection (Lisp_Object
, Lisp_Object
,
68 Lisp_Object
, Lisp_Object
);
69 static Lisp_Object
x_get_window_property_as_lisp_data (Display
*,
72 static Lisp_Object
selection_data_to_lisp_data (Display
*,
73 const unsigned char *,
74 ptrdiff_t, Atom
, int);
75 static void lisp_data_to_selection_data (Display
*, Lisp_Object
,
76 unsigned char **, Atom
*,
77 ptrdiff_t *, int *, int *);
78 static Lisp_Object
clean_local_selection_data (Lisp_Object
);
80 /* Printing traces to stderr. */
82 #ifdef TRACE_SELECTION
84 fprintf (stderr, "%"pMd": " fmt "\n", (printmax_t) getpid ())
85 #define TRACE1(fmt, a0) \
86 fprintf (stderr, "%"pMd": " fmt "\n", (printmax_t) getpid (), a0)
87 #define TRACE2(fmt, a0, a1) \
88 fprintf (stderr, "%"pMd": " fmt "\n", (printmax_t) getpid (), a0, a1)
89 #define TRACE3(fmt, a0, a1, a2) \
90 fprintf (stderr, "%"pMd": " fmt "\n", (printmax_t) getpid (), a0, a1, a2)
92 #define TRACE0(fmt) (void) 0
93 #define TRACE1(fmt, a0) (void) 0
94 #define TRACE2(fmt, a0, a1) (void) 0
98 static Lisp_Object QSECONDARY
, QSTRING
, QINTEGER
, QCLIPBOARD
, QTIMESTAMP
,
99 QTEXT
, QDELETE
, QMULTIPLE
, QINCR
, QEMACS_TMP
, QTARGETS
, QATOM
, QNULL
,
100 QATOM_PAIR
, QCLIPBOARD_MANAGER
, QSAVE_TARGETS
;
102 static Lisp_Object QCOMPOUND_TEXT
; /* This is a type of selection. */
103 static Lisp_Object QUTF8_STRING
; /* This is a type of selection. */
105 static Lisp_Object Qcompound_text_with_extensions
;
107 static Lisp_Object Qforeign_selection
;
108 static Lisp_Object Qx_lost_selection_functions
, Qx_sent_selection_functions
;
110 /* Bytes needed to represent 'long' data. This is as per libX11; it
111 is not necessarily sizeof (long). */
112 #define X_LONG_SIZE 4
114 /* Extreme 'short' and 'long' values suitable for libX11. */
115 #define X_SHRT_MAX 0x7fff
116 #define X_SHRT_MIN (-1 - X_SHRT_MAX)
117 #define X_LONG_MAX 0x7fffffff
118 #define X_LONG_MIN (-1 - X_LONG_MAX)
119 #define X_ULONG_MAX 0xffffffffUL
121 /* If this is a smaller number than the max-request-size of the display,
122 emacs will use INCR selection transfer when the selection is larger
123 than this. The max-request-size is usually around 64k, so if you want
124 emacs to use incremental selection transfers when the selection is
125 smaller than that, set this. I added this mostly for debugging the
126 incremental transfer stuff, but it might improve server performance.
128 This value cannot exceed INT_MAX / max (X_LONG_SIZE, sizeof (long))
129 because it is multiplied by X_LONG_SIZE and by sizeof (long) in
130 subscript calculations. Similarly for PTRDIFF_MAX - 1 or SIZE_MAX
131 - 1 in place of INT_MAX. */
132 #define MAX_SELECTION_QUANTUM \
133 ((int) min (0xFFFFFF, (min (INT_MAX, min (PTRDIFF_MAX, SIZE_MAX) - 1) \
134 / max (X_LONG_SIZE, sizeof (long)))))
137 selection_quantum (Display
*display
)
139 long mrs
= XMaxRequestSize (display
);
140 return (mrs
< MAX_SELECTION_QUANTUM
/ X_LONG_SIZE
+ 25
141 ? (mrs
- 25) * X_LONG_SIZE
142 : MAX_SELECTION_QUANTUM
);
145 #define LOCAL_SELECTION(selection_symbol,dpyinfo) \
146 assq_no_quit (selection_symbol, dpyinfo->terminal->Vselection_alist)
149 /* Define a queue to save up SELECTION_REQUEST_EVENT events for later
152 struct selection_event_queue
154 struct input_event event
;
155 struct selection_event_queue
*next
;
158 static struct selection_event_queue
*selection_queue
;
160 /* Nonzero means queue up SELECTION_REQUEST_EVENT events. */
162 static int x_queue_selection_requests
;
164 /* Queue up an SELECTION_REQUEST_EVENT *EVENT, to be processed later. */
167 x_queue_event (struct input_event
*event
)
169 struct selection_event_queue
*queue_tmp
;
171 /* Don't queue repeated requests.
172 This only happens for large requests which uses the incremental protocol. */
173 for (queue_tmp
= selection_queue
; queue_tmp
; queue_tmp
= queue_tmp
->next
)
175 if (!memcmp (&queue_tmp
->event
, event
, sizeof (*event
)))
177 TRACE1 ("DECLINE DUP SELECTION EVENT %p", queue_tmp
);
178 x_decline_selection_request (event
);
184 = (struct selection_event_queue
*) xmalloc (sizeof (struct selection_event_queue
));
186 if (queue_tmp
!= NULL
)
188 TRACE1 ("QUEUE SELECTION EVENT %p", queue_tmp
);
189 queue_tmp
->event
= *event
;
190 queue_tmp
->next
= selection_queue
;
191 selection_queue
= queue_tmp
;
195 /* Start queuing SELECTION_REQUEST_EVENT events. */
198 x_start_queuing_selection_requests (void)
200 if (x_queue_selection_requests
)
203 x_queue_selection_requests
++;
204 TRACE1 ("x_start_queuing_selection_requests %d", x_queue_selection_requests
);
207 /* Stop queuing SELECTION_REQUEST_EVENT events. */
210 x_stop_queuing_selection_requests (void)
212 TRACE1 ("x_stop_queuing_selection_requests %d", x_queue_selection_requests
);
213 --x_queue_selection_requests
;
215 /* Take all the queued events and put them back
216 so that they get processed afresh. */
218 while (selection_queue
!= NULL
)
220 struct selection_event_queue
*queue_tmp
= selection_queue
;
221 TRACE1 ("RESTORE SELECTION EVENT %p", queue_tmp
);
222 kbd_buffer_unget_event (&queue_tmp
->event
);
223 selection_queue
= queue_tmp
->next
;
224 xfree ((char *)queue_tmp
);
229 /* This converts a Lisp symbol to a server Atom, avoiding a server
230 roundtrip whenever possible. */
233 symbol_to_x_atom (struct x_display_info
*dpyinfo
, Lisp_Object sym
)
236 if (NILP (sym
)) return 0;
237 if (EQ (sym
, QPRIMARY
)) return XA_PRIMARY
;
238 if (EQ (sym
, QSECONDARY
)) return XA_SECONDARY
;
239 if (EQ (sym
, QSTRING
)) return XA_STRING
;
240 if (EQ (sym
, QINTEGER
)) return XA_INTEGER
;
241 if (EQ (sym
, QATOM
)) return XA_ATOM
;
242 if (EQ (sym
, QCLIPBOARD
)) return dpyinfo
->Xatom_CLIPBOARD
;
243 if (EQ (sym
, QTIMESTAMP
)) return dpyinfo
->Xatom_TIMESTAMP
;
244 if (EQ (sym
, QTEXT
)) return dpyinfo
->Xatom_TEXT
;
245 if (EQ (sym
, QCOMPOUND_TEXT
)) return dpyinfo
->Xatom_COMPOUND_TEXT
;
246 if (EQ (sym
, QUTF8_STRING
)) return dpyinfo
->Xatom_UTF8_STRING
;
247 if (EQ (sym
, QDELETE
)) return dpyinfo
->Xatom_DELETE
;
248 if (EQ (sym
, QMULTIPLE
)) return dpyinfo
->Xatom_MULTIPLE
;
249 if (EQ (sym
, QINCR
)) return dpyinfo
->Xatom_INCR
;
250 if (EQ (sym
, QEMACS_TMP
)) return dpyinfo
->Xatom_EMACS_TMP
;
251 if (EQ (sym
, QTARGETS
)) return dpyinfo
->Xatom_TARGETS
;
252 if (EQ (sym
, QNULL
)) return dpyinfo
->Xatom_NULL
;
253 if (!SYMBOLP (sym
)) abort ();
255 TRACE1 (" XInternAtom %s", SSDATA (SYMBOL_NAME (sym
)));
257 val
= XInternAtom (dpyinfo
->display
, SSDATA (SYMBOL_NAME (sym
)), False
);
263 /* This converts a server Atom to a Lisp symbol, avoiding server roundtrips
264 and calls to intern whenever possible. */
267 x_atom_to_symbol (Display
*dpy
, Atom atom
)
269 struct x_display_info
*dpyinfo
;
290 dpyinfo
= x_display_info_for_display (dpy
);
293 if (atom
== dpyinfo
->Xatom_CLIPBOARD
)
295 if (atom
== dpyinfo
->Xatom_TIMESTAMP
)
297 if (atom
== dpyinfo
->Xatom_TEXT
)
299 if (atom
== dpyinfo
->Xatom_COMPOUND_TEXT
)
300 return QCOMPOUND_TEXT
;
301 if (atom
== dpyinfo
->Xatom_UTF8_STRING
)
303 if (atom
== dpyinfo
->Xatom_DELETE
)
305 if (atom
== dpyinfo
->Xatom_MULTIPLE
)
307 if (atom
== dpyinfo
->Xatom_INCR
)
309 if (atom
== dpyinfo
->Xatom_EMACS_TMP
)
311 if (atom
== dpyinfo
->Xatom_TARGETS
)
313 if (atom
== dpyinfo
->Xatom_NULL
)
317 str
= XGetAtomName (dpy
, atom
);
319 TRACE1 ("XGetAtomName --> %s", str
);
320 if (! str
) return Qnil
;
323 /* This was allocated by Xlib, so use XFree. */
329 /* Do protocol to assert ourself as a selection owner.
330 FRAME shall be the owner; it must be a valid X frame.
331 Update the Vselection_alist so that we can reply to later requests for
335 x_own_selection (Lisp_Object selection_name
, Lisp_Object selection_value
,
338 struct frame
*f
= XFRAME (frame
);
339 Window selecting_window
= FRAME_X_WINDOW (f
);
340 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
341 Display
*display
= dpyinfo
->display
;
342 Time timestamp
= last_event_timestamp
;
343 Atom selection_atom
= symbol_to_x_atom (dpyinfo
, selection_name
);
346 x_catch_errors (display
);
347 XSetSelectionOwner (display
, selection_atom
, selecting_window
, timestamp
);
348 x_check_errors (display
, "Can't set selection: %s");
352 /* Now update the local cache */
354 Lisp_Object selection_data
;
355 Lisp_Object prev_value
;
357 selection_data
= list4 (selection_name
, selection_value
,
358 INTEGER_TO_CONS (timestamp
), frame
);
359 prev_value
= LOCAL_SELECTION (selection_name
, dpyinfo
);
361 dpyinfo
->terminal
->Vselection_alist
362 = Fcons (selection_data
, dpyinfo
->terminal
->Vselection_alist
);
364 /* If we already owned the selection, remove the old selection
365 data. Don't use Fdelq as that may QUIT. */
366 if (!NILP (prev_value
))
368 /* We know it's not the CAR, so it's easy. */
369 Lisp_Object rest
= dpyinfo
->terminal
->Vselection_alist
;
370 for (; CONSP (rest
); rest
= XCDR (rest
))
371 if (EQ (prev_value
, Fcar (XCDR (rest
))))
373 XSETCDR (rest
, XCDR (XCDR (rest
)));
380 /* Given a selection-name and desired type, look up our local copy of
381 the selection value and convert it to the type.
382 Return nil, a string, a vector, a symbol, an integer, or a cons
383 that CONS_TO_INTEGER could plausibly handle.
384 This function is used both for remote requests (LOCAL_REQUEST is zero)
385 and for local x-get-selection-internal (LOCAL_REQUEST is nonzero).
387 This calls random Lisp code, and may signal or gc. */
390 x_get_local_selection (Lisp_Object selection_symbol
, Lisp_Object target_type
,
391 int local_request
, struct x_display_info
*dpyinfo
)
393 Lisp_Object local_value
;
394 Lisp_Object handler_fn
, value
, check
;
396 local_value
= LOCAL_SELECTION (selection_symbol
, dpyinfo
);
398 if (NILP (local_value
)) return Qnil
;
400 /* TIMESTAMP is a special case. */
401 if (EQ (target_type
, QTIMESTAMP
))
404 value
= XCAR (XCDR (XCDR (local_value
)));
408 /* Don't allow a quit within the converter.
409 When the user types C-g, he would be surprised
410 if by luck it came during a converter. */
411 ptrdiff_t count
= SPECPDL_INDEX ();
412 specbind (Qinhibit_quit
, Qt
);
414 CHECK_SYMBOL (target_type
);
415 handler_fn
= Fcdr (Fassq (target_type
, Vselection_converter_alist
));
416 /* gcpro is not needed here since nothing but HANDLER_FN
417 is live, and that ought to be a symbol. */
419 if (!NILP (handler_fn
))
420 value
= call3 (handler_fn
,
421 selection_symbol
, (local_request
? Qnil
: target_type
),
422 XCAR (XCDR (local_value
)));
425 unbind_to (count
, Qnil
);
428 /* Make sure this value is of a type that we could transmit
429 to another X client. */
433 && SYMBOLP (XCAR (value
)))
434 check
= XCDR (value
);
442 /* Check for a value that CONS_TO_INTEGER could handle. */
443 else if (CONSP (check
)
444 && INTEGERP (XCAR (check
))
445 && (INTEGERP (XCDR (check
))
447 (CONSP (XCDR (check
))
448 && INTEGERP (XCAR (XCDR (check
)))
449 && NILP (XCDR (XCDR (check
))))))
452 signal_error ("Invalid data returned by selection-conversion function",
453 list2 (handler_fn
, value
));
456 /* Subroutines of x_reply_selection_request. */
458 /* Send a SelectionNotify event to the requestor with property=None,
459 meaning we were unable to do what they wanted. */
462 x_decline_selection_request (struct input_event
*event
)
465 XSelectionEvent
*reply
= &(reply_base
.xselection
);
467 reply
->type
= SelectionNotify
;
468 reply
->display
= SELECTION_EVENT_DISPLAY (event
);
469 reply
->requestor
= SELECTION_EVENT_REQUESTOR (event
);
470 reply
->selection
= SELECTION_EVENT_SELECTION (event
);
471 reply
->time
= SELECTION_EVENT_TIME (event
);
472 reply
->target
= SELECTION_EVENT_TARGET (event
);
473 reply
->property
= None
;
475 /* The reason for the error may be that the receiver has
476 died in the meantime. Handle that case. */
478 x_catch_errors (reply
->display
);
479 XSendEvent (reply
->display
, reply
->requestor
, False
, 0L, &reply_base
);
480 XFlush (reply
->display
);
485 /* This is the selection request currently being processed.
486 It is set to zero when the request is fully processed. */
487 static struct input_event
*x_selection_current_request
;
489 /* Display info in x_selection_request. */
491 static struct x_display_info
*selection_request_dpyinfo
;
493 /* Raw selection data, for sending to a requestor window. */
495 struct selection_data
503 /* This can be set to non-NULL during x_reply_selection_request, if
504 the selection is waiting for an INCR transfer to complete. Don't
505 free these; that's done by unexpect_property_change. */
506 struct prop_location
*wait_object
;
507 struct selection_data
*next
;
510 /* Linked list of the above (in support of MULTIPLE targets). */
512 static struct selection_data
*converted_selections
;
514 /* "Data" to send a requestor for a failed MULTIPLE subtarget. */
515 static Atom conversion_fail_tag
;
517 /* Used as an unwind-protect clause so that, if a selection-converter signals
518 an error, we tell the requestor that we were unable to do what they wanted
519 before we throw to top-level or go into the debugger or whatever. */
522 x_selection_request_lisp_error (Lisp_Object ignore
)
524 struct selection_data
*cs
, *next
;
526 for (cs
= converted_selections
; cs
; cs
= next
)
529 if (cs
->nofree
== 0 && cs
->data
)
533 converted_selections
= NULL
;
535 if (x_selection_current_request
!= 0
536 && selection_request_dpyinfo
->display
)
537 x_decline_selection_request (x_selection_current_request
);
542 x_catch_errors_unwind (Lisp_Object dummy
)
551 /* This stuff is so that INCR selections are reentrant (that is, so we can
552 be servicing multiple INCR selection requests simultaneously.) I haven't
553 actually tested that yet. */
555 /* Keep a list of the property changes that are awaited. */
565 struct prop_location
*next
;
568 static struct prop_location
*expect_property_change (Display
*display
, Window window
, Atom property
, int state
);
569 static void wait_for_property_change (struct prop_location
*location
);
570 static void unexpect_property_change (struct prop_location
*location
);
571 static int waiting_for_other_props_on_window (Display
*display
, Window window
);
573 static int prop_location_identifier
;
575 static Lisp_Object property_change_reply
;
577 static struct prop_location
*property_change_reply_object
;
579 static struct prop_location
*property_change_wait_list
;
582 queue_selection_requests_unwind (Lisp_Object tem
)
584 x_stop_queuing_selection_requests ();
589 /* Send the reply to a selection request event EVENT. */
591 #ifdef TRACE_SELECTION
592 static int x_reply_selection_request_cnt
;
593 #endif /* TRACE_SELECTION */
596 x_reply_selection_request (struct input_event
*event
,
597 struct x_display_info
*dpyinfo
)
600 XSelectionEvent
*reply
= &(reply_base
.xselection
);
601 Display
*display
= SELECTION_EVENT_DISPLAY (event
);
602 Window window
= SELECTION_EVENT_REQUESTOR (event
);
603 ptrdiff_t bytes_remaining
;
604 int max_bytes
= selection_quantum (display
);
605 ptrdiff_t count
= SPECPDL_INDEX ();
606 struct selection_data
*cs
;
608 reply
->type
= SelectionNotify
;
609 reply
->display
= display
;
610 reply
->requestor
= window
;
611 reply
->selection
= SELECTION_EVENT_SELECTION (event
);
612 reply
->time
= SELECTION_EVENT_TIME (event
);
613 reply
->target
= SELECTION_EVENT_TARGET (event
);
614 reply
->property
= SELECTION_EVENT_PROPERTY (event
);
615 if (reply
->property
== None
)
616 reply
->property
= reply
->target
;
619 /* The protected block contains wait_for_property_change, which can
620 run random lisp code (process handlers) or signal. Therefore, we
621 put the x_uncatch_errors call in an unwind. */
622 record_unwind_protect (x_catch_errors_unwind
, Qnil
);
623 x_catch_errors (display
);
625 /* Loop over converted selections, storing them in the requested
626 properties. If data is large, only store the first N bytes
627 (section 2.7.2 of ICCCM). Note that we store the data for a
628 MULTIPLE request in the opposite order; the ICCM says only that
629 the conversion itself must be done in the same order. */
630 for (cs
= converted_selections
; cs
; cs
= cs
->next
)
632 if (cs
->property
== None
)
635 bytes_remaining
= cs
->size
;
636 bytes_remaining
*= cs
->format
>> 3;
637 if (bytes_remaining
<= max_bytes
)
639 /* Send all the data at once, with minimal handshaking. */
640 TRACE1 ("Sending all %"pD
"d bytes", bytes_remaining
);
641 XChangeProperty (display
, window
, cs
->property
,
642 cs
->type
, cs
->format
, PropModeReplace
,
647 /* Send an INCR tag to initiate incremental transfer. */
650 TRACE2 ("Start sending %"pD
"d bytes incrementally (%s)",
651 bytes_remaining
, XGetAtomName (display
, cs
->property
));
653 = expect_property_change (display
, window
, cs
->property
,
656 /* XChangeProperty expects an array of long even if long is
657 more than 32 bits. */
658 value
[0] = min (bytes_remaining
, X_LONG_MAX
);
659 XChangeProperty (display
, window
, cs
->property
,
660 dpyinfo
->Xatom_INCR
, 32, PropModeReplace
,
661 (unsigned char *) value
, 1);
662 XSelectInput (display
, window
, PropertyChangeMask
);
666 /* Now issue the SelectionNotify event. */
667 XSendEvent (display
, window
, False
, 0L, &reply_base
);
670 #ifdef TRACE_SELECTION
672 char *sel
= XGetAtomName (display
, reply
->selection
);
673 char *tgt
= XGetAtomName (display
, reply
->target
);
674 TRACE3 ("Sent SelectionNotify: %s, target %s (%d)",
675 sel
, tgt
, ++x_reply_selection_request_cnt
);
676 if (sel
) XFree (sel
);
677 if (tgt
) XFree (tgt
);
679 #endif /* TRACE_SELECTION */
681 /* Finish sending the rest of each of the INCR values. This should
682 be improved; there's a chance of deadlock if more than one
683 subtarget in a MULTIPLE selection requires an INCR transfer, and
684 the requestor and Emacs loop waiting on different transfers. */
685 for (cs
= converted_selections
; cs
; cs
= cs
->next
)
688 int format_bytes
= cs
->format
/ 8;
689 int had_errors
= x_had_errors_p (display
);
692 bytes_remaining
= cs
->size
;
693 bytes_remaining
*= format_bytes
;
695 /* Wait for the requestor to ack by deleting the property.
696 This can run Lisp code (process handlers) or signal. */
699 TRACE1 ("Waiting for ACK (deletion of %s)",
700 XGetAtomName (display
, cs
->property
));
701 wait_for_property_change (cs
->wait_object
);
704 unexpect_property_change (cs
->wait_object
);
706 while (bytes_remaining
)
708 int i
= ((bytes_remaining
< max_bytes
)
710 : max_bytes
) / format_bytes
;
714 = expect_property_change (display
, window
, cs
->property
,
717 TRACE1 ("Sending increment of %d elements", i
);
718 TRACE1 ("Set %s to increment data",
719 XGetAtomName (display
, cs
->property
));
721 /* Append the next chunk of data to the property. */
722 XChangeProperty (display
, window
, cs
->property
,
723 cs
->type
, cs
->format
, PropModeAppend
,
725 bytes_remaining
-= i
* format_bytes
;
726 cs
->data
+= i
* ((cs
->format
== 32) ? sizeof (long)
729 had_errors
= x_had_errors_p (display
);
732 if (had_errors
) break;
734 /* Wait for the requestor to ack this chunk by deleting
735 the property. This can run Lisp code or signal. */
736 TRACE1 ("Waiting for increment ACK (deletion of %s)",
737 XGetAtomName (display
, cs
->property
));
738 wait_for_property_change (cs
->wait_object
);
741 /* Now write a zero-length chunk to the property to tell the
742 requestor that we're done. */
744 if (! waiting_for_other_props_on_window (display
, window
))
745 XSelectInput (display
, window
, 0L);
747 TRACE1 ("Set %s to a 0-length chunk to indicate EOF",
748 XGetAtomName (display
, cs
->property
));
749 XChangeProperty (display
, window
, cs
->property
,
750 cs
->type
, cs
->format
, PropModeReplace
,
752 TRACE0 ("Done sending incrementally");
755 /* rms, 2003-01-03: I think I have fixed this bug. */
756 /* The window we're communicating with may have been deleted
757 in the meantime (that's a real situation from a bug report).
758 In this case, there may be events in the event queue still
759 referring to the deleted window, and we'll get a BadWindow error
760 in XTread_socket when processing the events. I don't have
761 an idea how to fix that. gerd, 2001-01-98. */
762 /* 2004-09-10: XSync and UNBLOCK so that possible protocol errors are
763 delivered before uncatch errors. */
764 XSync (display
, False
);
767 /* GTK queues events in addition to the queue in Xlib. So we
768 UNBLOCK to enter the event loop and get possible errors delivered,
769 and then BLOCK again because x_uncatch_errors requires it. */
771 /* This calls x_uncatch_errors. */
772 unbind_to (count
, Qnil
);
776 /* Handle a SelectionRequest event EVENT.
777 This is called from keyboard.c when such an event is found in the queue. */
780 x_handle_selection_request (struct input_event
*event
)
782 struct gcpro gcpro1
, gcpro2
;
783 Time local_selection_time
;
785 Display
*display
= SELECTION_EVENT_DISPLAY (event
);
786 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
787 Atom selection
= SELECTION_EVENT_SELECTION (event
);
788 Lisp_Object selection_symbol
= x_atom_to_symbol (display
, selection
);
789 Atom target
= SELECTION_EVENT_TARGET (event
);
790 Lisp_Object target_symbol
= x_atom_to_symbol (display
, target
);
791 Atom property
= SELECTION_EVENT_PROPERTY (event
);
792 Lisp_Object local_selection_data
;
794 ptrdiff_t count
= SPECPDL_INDEX ();
795 GCPRO2 (local_selection_data
, target_symbol
);
797 if (!dpyinfo
) goto DONE
;
799 local_selection_data
= LOCAL_SELECTION (selection_symbol
, dpyinfo
);
801 /* Decline if we don't own any selections. */
802 if (NILP (local_selection_data
)) goto DONE
;
804 /* Decline requests issued prior to our acquiring the selection. */
805 CONS_TO_INTEGER (XCAR (XCDR (XCDR (local_selection_data
))),
806 Time
, local_selection_time
);
807 if (SELECTION_EVENT_TIME (event
) != CurrentTime
808 && local_selection_time
> SELECTION_EVENT_TIME (event
))
811 x_selection_current_request
= event
;
812 selection_request_dpyinfo
= dpyinfo
;
813 record_unwind_protect (x_selection_request_lisp_error
, Qnil
);
815 /* We might be able to handle nested x_handle_selection_requests,
816 but this is difficult to test, and seems unimportant. */
817 x_start_queuing_selection_requests ();
818 record_unwind_protect (queue_selection_requests_unwind
, Qnil
);
820 TRACE2 ("x_handle_selection_request: selection=%s, target=%s",
821 SDATA (SYMBOL_NAME (selection_symbol
)),
822 SDATA (SYMBOL_NAME (target_symbol
)));
824 if (EQ (target_symbol
, QMULTIPLE
))
826 /* For MULTIPLE targets, the event property names a list of atom
827 pairs; the first atom names a target and the second names a
828 non-None property. */
829 Window requestor
= SELECTION_EVENT_REQUESTOR (event
);
830 Lisp_Object multprop
;
831 ptrdiff_t j
, nselections
;
833 if (property
== None
) goto DONE
;
835 = x_get_window_property_as_lisp_data (display
, requestor
, property
,
836 QMULTIPLE
, selection
);
838 if (!VECTORP (multprop
) || ASIZE (multprop
) % 2)
841 nselections
= ASIZE (multprop
) / 2;
842 /* Perform conversions. This can signal. */
843 for (j
= 0; j
< nselections
; j
++)
845 Lisp_Object subtarget
= AREF (multprop
, 2*j
);
846 Atom subproperty
= symbol_to_x_atom (dpyinfo
,
847 AREF (multprop
, 2*j
+1));
849 if (subproperty
!= None
)
850 x_convert_selection (event
, selection_symbol
, subtarget
,
851 subproperty
, 1, dpyinfo
);
857 if (property
== None
)
858 property
= SELECTION_EVENT_TARGET (event
);
859 success
= x_convert_selection (event
, selection_symbol
,
860 target_symbol
, property
,
867 x_reply_selection_request (event
, dpyinfo
);
869 x_decline_selection_request (event
);
870 x_selection_current_request
= 0;
872 /* Run the `x-sent-selection-functions' abnormal hook. */
873 if (!NILP (Vx_sent_selection_functions
)
874 && !EQ (Vx_sent_selection_functions
, Qunbound
))
877 args
[0] = Qx_sent_selection_functions
;
878 args
[1] = selection_symbol
;
879 args
[2] = target_symbol
;
880 args
[3] = success
? Qt
: Qnil
;
881 Frun_hook_with_args (4, args
);
884 unbind_to (count
, Qnil
);
888 /* Perform the requested selection conversion, and write the data to
889 the converted_selections linked list, where it can be accessed by
890 x_reply_selection_request. If FOR_MULTIPLE is non-zero, write out
891 the data even if conversion fails, using conversion_fail_tag.
893 Return 0 if the selection failed to convert, 1 otherwise. */
896 x_convert_selection (struct input_event
*event
, Lisp_Object selection_symbol
,
897 Lisp_Object target_symbol
, Atom property
,
898 int for_multiple
, struct x_display_info
*dpyinfo
)
901 Lisp_Object lisp_selection
;
902 struct selection_data
*cs
;
903 GCPRO1 (lisp_selection
);
906 = x_get_local_selection (selection_symbol
, target_symbol
,
909 /* A nil return value means we can't perform the conversion. */
910 if (NILP (lisp_selection
)
911 || (CONSP (lisp_selection
) && NILP (XCDR (lisp_selection
))))
915 cs
= xmalloc (sizeof (struct selection_data
));
916 cs
->data
= (unsigned char *) &conversion_fail_tag
;
921 cs
->property
= property
;
922 cs
->wait_object
= NULL
;
923 cs
->next
= converted_selections
;
924 converted_selections
= cs
;
931 /* Otherwise, record the converted selection to binary. */
932 cs
= xmalloc (sizeof (struct selection_data
));
935 cs
->property
= property
;
936 cs
->wait_object
= NULL
;
937 cs
->next
= converted_selections
;
938 converted_selections
= cs
;
939 lisp_data_to_selection_data (SELECTION_EVENT_DISPLAY (event
),
941 &(cs
->data
), &(cs
->type
),
942 &(cs
->size
), &(cs
->format
),
948 /* Handle a SelectionClear event EVENT, which indicates that some
949 client cleared out our previously asserted selection.
950 This is called from keyboard.c when such an event is found in the queue. */
953 x_handle_selection_clear (struct input_event
*event
)
955 Display
*display
= SELECTION_EVENT_DISPLAY (event
);
956 Atom selection
= SELECTION_EVENT_SELECTION (event
);
957 Time changed_owner_time
= SELECTION_EVENT_TIME (event
);
959 Lisp_Object selection_symbol
, local_selection_data
;
960 Time local_selection_time
;
961 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
962 Lisp_Object Vselection_alist
;
964 TRACE0 ("x_handle_selection_clear");
966 if (!dpyinfo
) return;
968 selection_symbol
= x_atom_to_symbol (display
, selection
);
969 local_selection_data
= LOCAL_SELECTION (selection_symbol
, dpyinfo
);
971 /* Well, we already believe that we don't own it, so that's just fine. */
972 if (NILP (local_selection_data
)) return;
974 CONS_TO_INTEGER (XCAR (XCDR (XCDR (local_selection_data
))),
975 Time
, local_selection_time
);
977 /* We have reasserted the selection since this SelectionClear was
978 generated, so we can disregard it. */
979 if (changed_owner_time
!= CurrentTime
980 && local_selection_time
> changed_owner_time
)
983 /* Otherwise, really clear. Don't use Fdelq as that may QUIT;. */
984 Vselection_alist
= dpyinfo
->terminal
->Vselection_alist
;
985 if (EQ (local_selection_data
, CAR (Vselection_alist
)))
986 Vselection_alist
= XCDR (Vselection_alist
);
990 for (rest
= Vselection_alist
; CONSP (rest
); rest
= XCDR (rest
))
991 if (EQ (local_selection_data
, CAR (XCDR (rest
))))
993 XSETCDR (rest
, XCDR (XCDR (rest
)));
997 dpyinfo
->terminal
->Vselection_alist
= Vselection_alist
;
999 /* Run the `x-lost-selection-functions' abnormal hook. */
1001 Lisp_Object args
[2];
1002 args
[0] = Qx_lost_selection_functions
;
1003 args
[1] = selection_symbol
;
1004 Frun_hook_with_args (2, args
);
1007 prepare_menu_bars ();
1008 redisplay_preserve_echo_area (20);
1012 x_handle_selection_event (struct input_event
*event
)
1014 TRACE0 ("x_handle_selection_event");
1015 if (event
->kind
!= SELECTION_REQUEST_EVENT
)
1016 x_handle_selection_clear (event
);
1017 else if (x_queue_selection_requests
)
1018 x_queue_event (event
);
1020 x_handle_selection_request (event
);
1024 /* Clear all selections that were made from frame F.
1025 We do this when about to delete a frame. */
1028 x_clear_frame_selections (FRAME_PTR f
)
1032 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1033 struct terminal
*t
= dpyinfo
->terminal
;
1035 XSETFRAME (frame
, f
);
1037 /* Delete elements from the beginning of Vselection_alist. */
1038 while (CONSP (t
->Vselection_alist
)
1039 && EQ (frame
, XCAR (XCDR (XCDR (XCDR (XCAR (t
->Vselection_alist
)))))))
1041 /* Run the `x-lost-selection-functions' abnormal hook. */
1042 Lisp_Object args
[2];
1043 args
[0] = Qx_lost_selection_functions
;
1044 args
[1] = Fcar (Fcar (t
->Vselection_alist
));
1045 Frun_hook_with_args (2, args
);
1047 t
->Vselection_alist
= XCDR (t
->Vselection_alist
);
1050 /* Delete elements after the beginning of Vselection_alist. */
1051 for (rest
= t
->Vselection_alist
; CONSP (rest
); rest
= XCDR (rest
))
1052 if (CONSP (XCDR (rest
))
1053 && EQ (frame
, XCAR (XCDR (XCDR (XCDR (XCAR (XCDR (rest
))))))))
1055 Lisp_Object args
[2];
1056 args
[0] = Qx_lost_selection_functions
;
1057 args
[1] = XCAR (XCAR (XCDR (rest
)));
1058 Frun_hook_with_args (2, args
);
1059 XSETCDR (rest
, XCDR (XCDR (rest
)));
1064 /* Nonzero if any properties for DISPLAY and WINDOW
1065 are on the list of what we are waiting for. */
1068 waiting_for_other_props_on_window (Display
*display
, Window window
)
1070 struct prop_location
*rest
= property_change_wait_list
;
1072 if (rest
->display
== display
&& rest
->window
== window
)
1079 /* Add an entry to the list of property changes we are waiting for.
1080 DISPLAY, WINDOW, PROPERTY, STATE describe what we will wait for.
1081 The return value is a number that uniquely identifies
1082 this awaited property change. */
1084 static struct prop_location
*
1085 expect_property_change (Display
*display
, Window window
,
1086 Atom property
, int state
)
1088 struct prop_location
*pl
= (struct prop_location
*) xmalloc (sizeof *pl
);
1089 pl
->identifier
= ++prop_location_identifier
;
1090 pl
->display
= display
;
1091 pl
->window
= window
;
1092 pl
->property
= property
;
1093 pl
->desired_state
= state
;
1094 pl
->next
= property_change_wait_list
;
1096 property_change_wait_list
= pl
;
1100 /* Delete an entry from the list of property changes we are waiting for.
1101 IDENTIFIER is the number that uniquely identifies the entry. */
1104 unexpect_property_change (struct prop_location
*location
)
1106 struct prop_location
*prev
= 0, *rest
= property_change_wait_list
;
1109 if (rest
== location
)
1112 prev
->next
= rest
->next
;
1114 property_change_wait_list
= rest
->next
;
1123 /* Remove the property change expectation element for IDENTIFIER. */
1126 wait_for_property_change_unwind (Lisp_Object loc
)
1128 struct prop_location
*location
= XSAVE_VALUE (loc
)->pointer
;
1130 unexpect_property_change (location
);
1131 if (location
== property_change_reply_object
)
1132 property_change_reply_object
= 0;
1136 /* Actually wait for a property change.
1137 IDENTIFIER should be the value that expect_property_change returned. */
1140 wait_for_property_change (struct prop_location
*location
)
1142 ptrdiff_t count
= SPECPDL_INDEX ();
1144 if (property_change_reply_object
)
1147 /* Make sure to do unexpect_property_change if we quit or err. */
1148 record_unwind_protect (wait_for_property_change_unwind
,
1149 make_save_value (location
, 0));
1151 XSETCAR (property_change_reply
, Qnil
);
1152 property_change_reply_object
= location
;
1154 /* If the event we are waiting for arrives beyond here, it will set
1155 property_change_reply, because property_change_reply_object says so. */
1156 if (! location
->arrived
)
1158 EMACS_INT timeout
= max (0, x_selection_timeout
);
1159 EMACS_INT secs
= timeout
/ 1000;
1160 int nsecs
= (timeout
% 1000) * 1000000;
1161 TRACE2 (" Waiting %"pI
"d secs, %d nsecs", secs
, nsecs
);
1162 wait_reading_process_output (secs
, nsecs
, 0, 0,
1163 property_change_reply
, NULL
, 0);
1165 if (NILP (XCAR (property_change_reply
)))
1167 TRACE0 (" Timed out");
1168 error ("Timed out waiting for property-notify event");
1172 unbind_to (count
, Qnil
);
1175 /* Called from XTread_socket in response to a PropertyNotify event. */
1178 x_handle_property_notify (XPropertyEvent
*event
)
1180 struct prop_location
*rest
;
1182 for (rest
= property_change_wait_list
; rest
; rest
= rest
->next
)
1185 && rest
->property
== event
->atom
1186 && rest
->window
== event
->window
1187 && rest
->display
== event
->display
1188 && rest
->desired_state
== event
->state
)
1190 TRACE2 ("Expected %s of property %s",
1191 (event
->state
== PropertyDelete
? "deletion" : "change"),
1192 XGetAtomName (event
->display
, event
->atom
));
1196 /* If this is the one wait_for_property_change is waiting for,
1197 tell it to wake up. */
1198 if (rest
== property_change_reply_object
)
1199 XSETCAR (property_change_reply
, Qt
);
1208 /* Variables for communication with x_handle_selection_notify. */
1209 static Atom reading_which_selection
;
1210 static Lisp_Object reading_selection_reply
;
1211 static Window reading_selection_window
;
1213 /* Do protocol to read selection-data from the server.
1214 Converts this to Lisp data and returns it.
1215 FRAME is the frame whose X window shall request the selection. */
1218 x_get_foreign_selection (Lisp_Object selection_symbol
, Lisp_Object target_type
,
1219 Lisp_Object time_stamp
, Lisp_Object frame
)
1221 struct frame
*f
= XFRAME (frame
);
1222 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1223 Display
*display
= dpyinfo
->display
;
1224 Window requestor_window
= FRAME_X_WINDOW (f
);
1225 Time requestor_time
= last_event_timestamp
;
1226 Atom target_property
= dpyinfo
->Xatom_EMACS_TMP
;
1227 Atom selection_atom
= symbol_to_x_atom (dpyinfo
, selection_symbol
);
1228 Atom type_atom
= (CONSP (target_type
)
1229 ? symbol_to_x_atom (dpyinfo
, XCAR (target_type
))
1230 : symbol_to_x_atom (dpyinfo
, target_type
));
1231 EMACS_INT timeout
, secs
;
1234 if (!FRAME_LIVE_P (f
))
1237 if (! NILP (time_stamp
))
1238 CONS_TO_INTEGER (time_stamp
, Time
, requestor_time
);
1241 TRACE2 ("Get selection %s, type %s",
1242 XGetAtomName (display
, type_atom
),
1243 XGetAtomName (display
, target_property
));
1245 x_catch_errors (display
);
1246 XConvertSelection (display
, selection_atom
, type_atom
, target_property
,
1247 requestor_window
, requestor_time
);
1248 x_check_errors (display
, "Can't convert selection: %s");
1249 x_uncatch_errors ();
1251 /* Prepare to block until the reply has been read. */
1252 reading_selection_window
= requestor_window
;
1253 reading_which_selection
= selection_atom
;
1254 XSETCAR (reading_selection_reply
, Qnil
);
1256 /* It should not be necessary to stop handling selection requests
1257 during this time. In fact, the SAVE_TARGETS mechanism requires
1258 us to handle a clipboard manager's requests before it returns
1261 x_start_queuing_selection_requests ();
1262 record_unwind_protect (queue_selection_requests_unwind
, Qnil
);
1267 /* This allows quits. Also, don't wait forever. */
1268 timeout
= max (0, x_selection_timeout
);
1269 secs
= timeout
/ 1000;
1270 nsecs
= (timeout
% 1000) * 1000000;
1271 TRACE1 (" Start waiting %"pI
"d secs for SelectionNotify", secs
);
1272 wait_reading_process_output (secs
, nsecs
, 0, 0,
1273 reading_selection_reply
, NULL
, 0);
1274 TRACE1 (" Got event = %d", !NILP (XCAR (reading_selection_reply
)));
1276 if (NILP (XCAR (reading_selection_reply
)))
1277 error ("Timed out waiting for reply from selection owner");
1278 if (EQ (XCAR (reading_selection_reply
), Qlambda
))
1281 /* Otherwise, the selection is waiting for us on the requested property. */
1283 x_get_window_property_as_lisp_data (display
, requestor_window
,
1284 target_property
, target_type
,
1288 /* Subroutines of x_get_window_property_as_lisp_data */
1290 /* Use xfree, not XFree, to free the data obtained with this function. */
1293 x_get_window_property (Display
*display
, Window window
, Atom property
,
1294 unsigned char **data_ret
, ptrdiff_t *bytes_ret
,
1295 Atom
*actual_type_ret
, int *actual_format_ret
,
1296 unsigned long *actual_size_ret
, int delete_p
)
1298 ptrdiff_t total_size
;
1299 unsigned long bytes_remaining
;
1300 ptrdiff_t offset
= 0;
1301 unsigned char *data
= 0;
1302 unsigned char *tmp_data
= 0;
1304 int buffer_size
= selection_quantum (display
);
1306 /* Wide enough to avoid overflow in expressions using it. */
1307 ptrdiff_t x_long_size
= X_LONG_SIZE
;
1309 /* Maximum value for TOTAL_SIZE. It cannot exceed PTRDIFF_MAX - 1
1310 and SIZE_MAX - 1, for an extra byte at the end. And it cannot
1311 exceed LONG_MAX * X_LONG_SIZE, for XGetWindowProperty. */
1312 ptrdiff_t total_size_max
=
1313 ((min (PTRDIFF_MAX
, SIZE_MAX
) - 1) / x_long_size
< LONG_MAX
1314 ? min (PTRDIFF_MAX
, SIZE_MAX
) - 1
1315 : LONG_MAX
* x_long_size
);
1319 /* First probe the thing to find out how big it is. */
1320 result
= XGetWindowProperty (display
, window
, property
,
1321 0L, 0L, False
, AnyPropertyType
,
1322 actual_type_ret
, actual_format_ret
,
1324 &bytes_remaining
, &tmp_data
);
1325 if (result
!= Success
)
1328 /* This was allocated by Xlib, so use XFree. */
1329 XFree ((char *) tmp_data
);
1331 if (*actual_type_ret
== None
|| *actual_format_ret
== 0)
1334 if (total_size_max
< bytes_remaining
)
1336 total_size
= bytes_remaining
;
1337 data
= malloc (total_size
+ 1);
1339 goto memory_exhausted
;
1341 /* Now read, until we've gotten it all. */
1342 while (bytes_remaining
)
1344 ptrdiff_t bytes_gotten
;
1347 = XGetWindowProperty (display
, window
, property
,
1348 offset
/ X_LONG_SIZE
,
1349 buffer_size
/ X_LONG_SIZE
,
1352 actual_type_ret
, actual_format_ret
,
1353 actual_size_ret
, &bytes_remaining
, &tmp_data
);
1355 /* If this doesn't return Success at this point, it means that
1356 some clod deleted the selection while we were in the midst of
1357 reading it. Deal with that, I guess.... */
1358 if (result
!= Success
)
1361 bytes_per_item
= *actual_format_ret
>> 3;
1362 xassert (*actual_size_ret
<= buffer_size
/ bytes_per_item
);
1364 /* The man page for XGetWindowProperty says:
1365 "If the returned format is 32, the returned data is represented
1366 as a long array and should be cast to that type to obtain the
1368 This applies even if long is more than 32 bits, the X library
1369 converts from 32 bit elements received from the X server to long
1370 and passes the long array to us. Thus, for that case memcpy can not
1371 be used. We convert to a 32 bit type here, because so much code
1374 The bytes and offsets passed to XGetWindowProperty refers to the
1375 property and those are indeed in 32 bit quantities if format is 32. */
1377 bytes_gotten
= *actual_size_ret
;
1378 bytes_gotten
*= bytes_per_item
;
1380 TRACE2 ("Read %"pD
"d bytes from property %s",
1381 bytes_gotten
, XGetAtomName (display
, property
));
1383 if (total_size
- offset
< bytes_gotten
)
1385 unsigned char *data1
;
1386 ptrdiff_t remaining_lim
= total_size_max
- offset
- bytes_gotten
;
1387 if (remaining_lim
< 0 || remaining_lim
< bytes_remaining
)
1389 total_size
= offset
+ bytes_gotten
+ bytes_remaining
;
1390 data1
= realloc (data
, total_size
+ 1);
1392 goto memory_exhausted
;
1396 if (32 < BITS_PER_LONG
&& *actual_format_ret
== 32)
1399 int *idata
= (int *) (data
+ offset
);
1400 long *ldata
= (long *) tmp_data
;
1402 for (i
= 0; i
< *actual_size_ret
; ++i
)
1403 idata
[i
] = ldata
[i
];
1406 memcpy (data
+ offset
, tmp_data
, bytes_gotten
);
1408 offset
+= bytes_gotten
;
1410 /* This was allocated by Xlib, so use XFree. */
1411 XFree ((char *) tmp_data
);
1415 data
[offset
] = '\0';
1420 *bytes_ret
= offset
;
1426 memory_full (SIZE_MAX
);
1431 memory_full (total_size
+ 1);
1434 /* Use xfree, not XFree, to free the data obtained with this function. */
1437 receive_incremental_selection (Display
*display
, Window window
, Atom property
,
1438 Lisp_Object target_type
,
1439 unsigned int min_size_bytes
,
1440 unsigned char **data_ret
,
1441 ptrdiff_t *size_bytes_ret
,
1442 Atom
*type_ret
, int *format_ret
,
1443 unsigned long *size_ret
)
1445 ptrdiff_t offset
= 0;
1446 struct prop_location
*wait_object
;
1447 if (min (PTRDIFF_MAX
, SIZE_MAX
) < min_size_bytes
)
1448 memory_full (SIZE_MAX
);
1449 *data_ret
= (unsigned char *) xmalloc (min_size_bytes
);
1450 *size_bytes_ret
= min_size_bytes
;
1452 TRACE1 ("Read %u bytes incrementally", min_size_bytes
);
1454 /* At this point, we have read an INCR property.
1455 Delete the property to ack it.
1456 (But first, prepare to receive the next event in this handshake.)
1458 Now, we must loop, waiting for the sending window to put a value on
1459 that property, then reading the property, then deleting it to ack.
1460 We are done when the sender places a property of length 0.
1463 XSelectInput (display
, window
, STANDARD_EVENT_SET
| PropertyChangeMask
);
1464 TRACE1 (" Delete property %s",
1465 SDATA (SYMBOL_NAME (x_atom_to_symbol (display
, property
))));
1466 XDeleteProperty (display
, window
, property
);
1467 TRACE1 (" Expect new value of property %s",
1468 SDATA (SYMBOL_NAME (x_atom_to_symbol (display
, property
))));
1469 wait_object
= expect_property_change (display
, window
, property
,
1476 unsigned char *tmp_data
;
1477 ptrdiff_t tmp_size_bytes
;
1479 TRACE0 (" Wait for property change");
1480 wait_for_property_change (wait_object
);
1482 /* expect it again immediately, because x_get_window_property may
1483 .. no it won't, I don't get it.
1484 .. Ok, I get it now, the Xt code that implements INCR is broken. */
1485 TRACE0 (" Get property value");
1486 x_get_window_property (display
, window
, property
,
1487 &tmp_data
, &tmp_size_bytes
,
1488 type_ret
, format_ret
, size_ret
, 1);
1490 TRACE1 (" Read increment of %"pD
"d bytes", tmp_size_bytes
);
1492 if (tmp_size_bytes
== 0) /* we're done */
1494 TRACE0 ("Done reading incrementally");
1496 if (! waiting_for_other_props_on_window (display
, window
))
1497 XSelectInput (display
, window
, STANDARD_EVENT_SET
);
1498 /* Use xfree, not XFree, because x_get_window_property
1499 calls xmalloc itself. */
1505 TRACE1 (" ACK by deleting property %s",
1506 XGetAtomName (display
, property
));
1507 XDeleteProperty (display
, window
, property
);
1508 wait_object
= expect_property_change (display
, window
, property
,
1513 if (*size_bytes_ret
- offset
< tmp_size_bytes
)
1514 *data_ret
= xpalloc (*data_ret
, size_bytes_ret
,
1515 tmp_size_bytes
- (*size_bytes_ret
- offset
),
1518 memcpy ((*data_ret
) + offset
, tmp_data
, tmp_size_bytes
);
1519 offset
+= tmp_size_bytes
;
1521 /* Use xfree, not XFree, because x_get_window_property
1522 calls xmalloc itself. */
1528 /* Fetch a value from property PROPERTY of X window WINDOW on display
1529 DISPLAY. TARGET_TYPE and SELECTION_ATOM are used in error message
1533 x_get_window_property_as_lisp_data (Display
*display
, Window window
,
1535 Lisp_Object target_type
,
1536 Atom selection_atom
)
1540 unsigned long actual_size
;
1541 unsigned char *data
= 0;
1542 ptrdiff_t bytes
= 0;
1544 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1546 TRACE0 ("Reading selection data");
1548 x_get_window_property (display
, window
, property
, &data
, &bytes
,
1549 &actual_type
, &actual_format
, &actual_size
, 1);
1552 int there_is_a_selection_owner
;
1554 there_is_a_selection_owner
1555 = XGetSelectionOwner (display
, selection_atom
);
1557 if (there_is_a_selection_owner
)
1558 signal_error ("Selection owner couldn't convert",
1560 ? list2 (target_type
,
1561 x_atom_to_symbol (display
, actual_type
))
1564 signal_error ("No selection",
1565 x_atom_to_symbol (display
, selection_atom
));
1568 if (actual_type
== dpyinfo
->Xatom_INCR
)
1570 /* That wasn't really the data, just the beginning. */
1572 unsigned int min_size_bytes
= * ((unsigned int *) data
);
1574 /* Use xfree, not XFree, because x_get_window_property
1575 calls xmalloc itself. */
1576 xfree ((char *) data
);
1578 receive_incremental_selection (display
, window
, property
, target_type
,
1579 min_size_bytes
, &data
, &bytes
,
1580 &actual_type
, &actual_format
,
1585 TRACE1 (" Delete property %s", XGetAtomName (display
, property
));
1586 XDeleteProperty (display
, window
, property
);
1590 /* It's been read. Now convert it to a lisp object in some semi-rational
1592 val
= selection_data_to_lisp_data (display
, data
, bytes
,
1593 actual_type
, actual_format
);
1595 /* Use xfree, not XFree, because x_get_window_property
1596 calls xmalloc itself. */
1597 xfree ((char *) data
);
1601 /* These functions convert from the selection data read from the server into
1602 something that we can use from Lisp, and vice versa.
1604 Type: Format: Size: Lisp Type:
1605 ----- ------- ----- -----------
1608 ATOM 32 > 1 Vector of Symbols
1610 * 16 > 1 Vector of Integers
1611 * 32 1 if <=16 bits: Integer
1612 if > 16 bits: Cons of top16, bot16
1613 * 32 > 1 Vector of the above
1615 When converting a Lisp number to C, it is assumed to be of format 16 if
1616 it is an integer, and of format 32 if it is a cons of two integers.
1618 When converting a vector of numbers from Lisp to C, it is assumed to be
1619 of format 16 if every element in the vector is an integer, and is assumed
1620 to be of format 32 if any element is a cons of two integers.
1622 When converting an object to C, it may be of the form (SYMBOL . <data>)
1623 where SYMBOL is what we should claim that the type is. Format and
1624 representation are as above.
1626 Important: When format is 32, data should contain an array of int,
1627 not an array of long as the X library returns. This makes a difference
1628 when sizeof(long) != sizeof(int). */
1633 selection_data_to_lisp_data (Display
*display
, const unsigned char *data
,
1634 ptrdiff_t size
, Atom type
, int format
)
1636 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1638 if (type
== dpyinfo
->Xatom_NULL
)
1641 /* Convert any 8-bit data to a string, for compactness. */
1642 else if (format
== 8)
1644 Lisp_Object str
, lispy_type
;
1646 str
= make_unibyte_string ((char *) data
, size
);
1647 /* Indicate that this string is from foreign selection by a text
1648 property `foreign-selection' so that the caller of
1649 x-get-selection-internal (usually x-get-selection) can know
1650 that the string must be decode. */
1651 if (type
== dpyinfo
->Xatom_COMPOUND_TEXT
)
1652 lispy_type
= QCOMPOUND_TEXT
;
1653 else if (type
== dpyinfo
->Xatom_UTF8_STRING
)
1654 lispy_type
= QUTF8_STRING
;
1656 lispy_type
= QSTRING
;
1657 Fput_text_property (make_number (0), make_number (size
),
1658 Qforeign_selection
, lispy_type
, str
);
1661 /* Convert a single atom to a Lisp_Symbol. Convert a set of atoms to
1662 a vector of symbols. */
1663 else if (type
== XA_ATOM
1664 /* Treat ATOM_PAIR type similar to list of atoms. */
1665 || type
== dpyinfo
->Xatom_ATOM_PAIR
)
1668 /* On a 64 bit machine sizeof(Atom) == sizeof(long) == 8.
1669 But the callers of these function has made sure the data for
1670 format == 32 is an array of int. Thus, use int instead
1672 int *idata
= (int *) data
;
1674 if (size
== sizeof (int))
1675 return x_atom_to_symbol (display
, (Atom
) idata
[0]);
1678 Lisp_Object v
= Fmake_vector (make_number (size
/ sizeof (int)),
1680 for (i
= 0; i
< size
/ sizeof (int); i
++)
1681 Faset (v
, make_number (i
),
1682 x_atom_to_symbol (display
, (Atom
) idata
[i
]));
1687 /* Convert a single 16-bit number or a small 32-bit number to a Lisp_Int.
1688 If the number is 32 bits and won't fit in a Lisp_Int,
1689 convert it to a cons of integers, 16 bits in each half.
1691 else if (format
== 32 && size
== sizeof (int))
1692 return INTEGER_TO_CONS (((int *) data
) [0]);
1693 else if (format
== 16 && size
== sizeof (short))
1694 return make_number (((short *) data
) [0]);
1696 /* Convert any other kind of data to a vector of numbers, represented
1697 as above (as an integer, or a cons of two 16 bit integers.)
1699 else if (format
== 16)
1703 v
= Fmake_vector (make_number (size
/ 2), make_number (0));
1704 for (i
= 0; i
< size
/ 2; i
++)
1706 short j
= ((short *) data
) [i
];
1707 Faset (v
, make_number (i
), make_number (j
));
1714 Lisp_Object v
= Fmake_vector (make_number (size
/ X_LONG_SIZE
),
1716 for (i
= 0; i
< size
/ X_LONG_SIZE
; i
++)
1718 int j
= ((int *) data
) [i
];
1719 Faset (v
, make_number (i
), INTEGER_TO_CONS (j
));
1725 /* Convert OBJ to an X long value, and return it as unsigned long.
1726 OBJ should be an integer or a cons representing an integer.
1727 Treat values in the range X_LONG_MAX + 1 .. X_ULONG_MAX as X
1728 unsigned long values: in theory these values are supposed to be
1729 signed but in practice unsigned 32-bit data are communicated via X
1730 selections and we need to support that. */
1731 static unsigned long
1732 cons_to_x_long (Lisp_Object obj
)
1734 if (X_ULONG_MAX
<= INTMAX_MAX
1735 || XINT (INTEGERP (obj
) ? obj
: XCAR (obj
)) < 0)
1736 return cons_to_signed (obj
, X_LONG_MIN
, min (X_ULONG_MAX
, INTMAX_MAX
));
1738 return cons_to_unsigned (obj
, X_ULONG_MAX
);
1741 /* Use xfree, not XFree, to free the data obtained with this function. */
1744 lisp_data_to_selection_data (Display
*display
, Lisp_Object obj
,
1745 unsigned char **data_ret
, Atom
*type_ret
,
1746 ptrdiff_t *size_ret
,
1747 int *format_ret
, int *nofree_ret
)
1749 Lisp_Object type
= Qnil
;
1750 struct x_display_info
*dpyinfo
= x_display_info_for_display (display
);
1754 if (CONSP (obj
) && SYMBOLP (XCAR (obj
)))
1758 if (CONSP (obj
) && NILP (XCDR (obj
)))
1762 if (EQ (obj
, QNULL
) || (EQ (type
, QNULL
)))
1763 { /* This is not the same as declining */
1769 else if (STRINGP (obj
))
1771 if (SCHARS (obj
) < SBYTES (obj
))
1772 /* OBJ is a multibyte string containing a non-ASCII char. */
1773 signal_error ("Non-ASCII string must be encoded in advance", obj
);
1777 *size_ret
= SBYTES (obj
);
1778 *data_ret
= SDATA (obj
);
1781 else if (SYMBOLP (obj
))
1783 *data_ret
= (unsigned char *) xmalloc (sizeof (Atom
) + 1);
1786 (*data_ret
) [sizeof (Atom
)] = 0;
1787 (*(Atom
**) data_ret
) [0] = symbol_to_x_atom (dpyinfo
, obj
);
1788 if (NILP (type
)) type
= QATOM
;
1790 else if (RANGED_INTEGERP (X_SHRT_MIN
, obj
, X_SHRT_MAX
))
1792 *data_ret
= (unsigned char *) xmalloc (sizeof (short) + 1);
1795 (*data_ret
) [sizeof (short)] = 0;
1796 (*(short **) data_ret
) [0] = XINT (obj
);
1797 if (NILP (type
)) type
= QINTEGER
;
1799 else if (INTEGERP (obj
)
1800 || (CONSP (obj
) && INTEGERP (XCAR (obj
))
1801 && (INTEGERP (XCDR (obj
))
1802 || (CONSP (XCDR (obj
))
1803 && INTEGERP (XCAR (XCDR (obj
)))))))
1805 *data_ret
= (unsigned char *) xmalloc (sizeof (unsigned long) + 1);
1808 (*data_ret
) [sizeof (unsigned long)] = 0;
1809 (*(unsigned long **) data_ret
) [0] = cons_to_x_long (obj
);
1810 if (NILP (type
)) type
= QINTEGER
;
1812 else if (VECTORP (obj
))
1814 /* Lisp_Vectors may represent a set of ATOMs;
1815 a set of 16 or 32 bit INTEGERs;
1816 or a set of ATOM_PAIRs (represented as [[A1 A2] [A3 A4] ...]
1819 ptrdiff_t size
= ASIZE (obj
);
1821 if (SYMBOLP (AREF (obj
, 0)))
1822 /* This vector is an ATOM set */
1824 if (NILP (type
)) type
= QATOM
;
1825 for (i
= 0; i
< size
; i
++)
1826 if (!SYMBOLP (AREF (obj
, i
)))
1827 signal_error ("All elements of selection vector must have same type", obj
);
1829 *data_ret
= xnmalloc (size
, sizeof (Atom
));
1832 for (i
= 0; i
< size
; i
++)
1833 (*(Atom
**) data_ret
) [i
]
1834 = symbol_to_x_atom (dpyinfo
, AREF (obj
, i
));
1837 /* This vector is an INTEGER set, or something like it */
1840 int data_size
= sizeof (short);
1841 if (NILP (type
)) type
= QINTEGER
;
1842 for (i
= 0; i
< size
; i
++)
1844 if (! RANGED_INTEGERP (X_SHRT_MIN
, AREF (obj
, i
),
1847 /* Use sizeof (long) even if it is more than 32 bits.
1848 See comment in x_get_window_property and
1849 x_fill_property_data. */
1850 data_size
= sizeof (long);
1855 *data_ret
= xnmalloc (size
, data_size
);
1856 *format_ret
= format
;
1858 for (i
= 0; i
< size
; i
++)
1861 (*((unsigned long **) data_ret
)) [i
] =
1862 cons_to_x_long (AREF (obj
, i
));
1864 (*((short **) data_ret
)) [i
] =
1865 XINT (AREF (obj
, i
));
1870 signal_error (/* Qselection_error */ "Unrecognized selection data", obj
);
1872 *type_ret
= symbol_to_x_atom (dpyinfo
, type
);
1876 clean_local_selection_data (Lisp_Object obj
)
1879 && INTEGERP (XCAR (obj
))
1880 && CONSP (XCDR (obj
))
1881 && INTEGERP (XCAR (XCDR (obj
)))
1882 && NILP (XCDR (XCDR (obj
))))
1883 obj
= Fcons (XCAR (obj
), XCDR (obj
));
1886 && INTEGERP (XCAR (obj
))
1887 && INTEGERP (XCDR (obj
)))
1889 if (XINT (XCAR (obj
)) == 0)
1891 if (XINT (XCAR (obj
)) == -1)
1892 return make_number (- XINT (XCDR (obj
)));
1897 ptrdiff_t size
= ASIZE (obj
);
1900 return clean_local_selection_data (AREF (obj
, 0));
1901 copy
= Fmake_vector (make_number (size
), Qnil
);
1902 for (i
= 0; i
< size
; i
++)
1903 ASET (copy
, i
, clean_local_selection_data (AREF (obj
, i
)));
1909 /* Called from XTread_socket to handle SelectionNotify events.
1910 If it's the selection we are waiting for, stop waiting
1911 by setting the car of reading_selection_reply to non-nil.
1912 We store t there if the reply is successful, lambda if not. */
1915 x_handle_selection_notify (XSelectionEvent
*event
)
1917 if (event
->requestor
!= reading_selection_window
)
1919 if (event
->selection
!= reading_which_selection
)
1922 TRACE0 ("Received SelectionNotify");
1923 XSETCAR (reading_selection_reply
,
1924 (event
->property
!= 0 ? Qt
: Qlambda
));
1928 /* From a Lisp_Object, return a suitable frame for selection
1929 operations. OBJECT may be a frame, a terminal object, or nil
1930 (which stands for the selected frame--or, if that is not an X
1931 frame, the first X display on the list). If no suitable frame can
1932 be found, return NULL. */
1934 static struct frame
*
1935 frame_for_x_selection (Lisp_Object object
)
1942 f
= XFRAME (selected_frame
);
1943 if (FRAME_X_P (f
) && FRAME_LIVE_P (f
))
1946 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1948 f
= XFRAME (XCAR (tail
));
1949 if (FRAME_X_P (f
) && FRAME_LIVE_P (f
))
1953 else if (TERMINALP (object
))
1955 struct terminal
*t
= get_terminal (object
, 1);
1956 if (t
->type
== output_x_window
)
1958 for (tail
= Vframe_list
; CONSP (tail
); tail
= XCDR (tail
))
1960 f
= XFRAME (XCAR (tail
));
1961 if (FRAME_LIVE_P (f
) && f
->terminal
== t
)
1966 else if (FRAMEP (object
))
1968 f
= XFRAME (object
);
1969 if (FRAME_X_P (f
) && FRAME_LIVE_P (f
))
1977 DEFUN ("x-own-selection-internal", Fx_own_selection_internal
,
1978 Sx_own_selection_internal
, 2, 3, 0,
1979 doc
: /* Assert an X selection of type SELECTION and value VALUE.
1980 SELECTION is a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.
1981 \(Those are literal upper-case symbol names, since that's what X expects.)
1982 VALUE is typically a string, or a cons of two markers, but may be
1983 anything that the functions on `selection-converter-alist' know about.
1985 FRAME should be a frame that should own the selection. If omitted or
1986 nil, it defaults to the selected frame.
1988 On Nextstep, FRAME is unused. */)
1989 (Lisp_Object selection
, Lisp_Object value
, Lisp_Object frame
)
1991 if (NILP (frame
)) frame
= selected_frame
;
1992 if (!FRAME_LIVE_P (XFRAME (frame
)) || !FRAME_X_P (XFRAME (frame
)))
1993 error ("X selection unavailable for this frame");
1995 CHECK_SYMBOL (selection
);
1996 if (NILP (value
)) error ("VALUE may not be nil");
1997 x_own_selection (selection
, value
, frame
);
2002 /* Request the selection value from the owner. If we are the owner,
2003 simply return our selection value. If we are not the owner, this
2004 will block until all of the data has arrived. */
2006 DEFUN ("x-get-selection-internal", Fx_get_selection_internal
,
2007 Sx_get_selection_internal
, 2, 4, 0,
2008 doc
: /* Return text selected from some X window.
2009 SELECTION-SYMBOL is typically `PRIMARY', `SECONDARY', or `CLIPBOARD'.
2010 \(Those are literal upper-case symbol names, since that's what X expects.)
2011 TARGET-TYPE is the type of data desired, typically `STRING'.
2013 TIME-STAMP is the time to use in the XConvertSelection call for foreign
2014 selections. If omitted, defaults to the time for the last event.
2016 TERMINAL should be a terminal object or a frame specifying the X
2017 server to query. If omitted or nil, that stands for the selected
2018 frame's display, or the first available X display.
2020 On Nextstep, TIME-STAMP and TERMINAL are unused. */)
2021 (Lisp_Object selection_symbol
, Lisp_Object target_type
,
2022 Lisp_Object time_stamp
, Lisp_Object terminal
)
2024 Lisp_Object val
= Qnil
;
2025 struct gcpro gcpro1
, gcpro2
;
2026 struct frame
*f
= frame_for_x_selection (terminal
);
2027 GCPRO2 (target_type
, val
); /* we store newly consed data into these */
2029 CHECK_SYMBOL (selection_symbol
);
2030 CHECK_SYMBOL (target_type
);
2031 if (EQ (target_type
, QMULTIPLE
))
2032 error ("Retrieving MULTIPLE selections is currently unimplemented");
2034 error ("X selection unavailable for this frame");
2036 val
= x_get_local_selection (selection_symbol
, target_type
, 1,
2037 FRAME_X_DISPLAY_INFO (f
));
2039 if (NILP (val
) && FRAME_LIVE_P (f
))
2042 XSETFRAME (frame
, f
);
2043 RETURN_UNGCPRO (x_get_foreign_selection (selection_symbol
, target_type
,
2044 time_stamp
, frame
));
2047 if (CONSP (val
) && SYMBOLP (XCAR (val
)))
2050 if (CONSP (val
) && NILP (XCDR (val
)))
2053 RETURN_UNGCPRO (clean_local_selection_data (val
));
2056 DEFUN ("x-disown-selection-internal", Fx_disown_selection_internal
,
2057 Sx_disown_selection_internal
, 1, 3, 0,
2058 doc
: /* If we own the selection SELECTION, disown it.
2059 Disowning it means there is no such selection.
2061 Sets the last-change time for the selection to TIME-OBJECT (by default
2062 the time of the last event).
2064 TERMINAL should be a terminal object or a frame specifying the X
2065 server to query. If omitted or nil, that stands for the selected
2066 frame's display, or the first available X display.
2068 On Nextstep, the TIME-OBJECT and TERMINAL arguments are unused.
2069 On MS-DOS, all this does is return non-nil if we own the selection. */)
2070 (Lisp_Object selection
, Lisp_Object time_object
, Lisp_Object terminal
)
2073 Atom selection_atom
;
2075 struct selection_input_event sie
;
2076 struct input_event ie
;
2078 struct frame
*f
= frame_for_x_selection (terminal
);
2079 struct x_display_info
*dpyinfo
;
2084 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2085 CHECK_SYMBOL (selection
);
2087 /* Don't disown the selection when we're not the owner. */
2088 if (NILP (LOCAL_SELECTION (selection
, dpyinfo
)))
2091 selection_atom
= symbol_to_x_atom (dpyinfo
, selection
);
2094 if (NILP (time_object
))
2095 timestamp
= last_event_timestamp
;
2097 CONS_TO_INTEGER (time_object
, Time
, timestamp
);
2098 XSetSelectionOwner (dpyinfo
->display
, selection_atom
, None
, timestamp
);
2101 /* It doesn't seem to be guaranteed that a SelectionClear event will be
2102 generated for a window which owns the selection when that window sets
2103 the selection owner to None. The NCD server does, the MIT Sun4 server
2104 doesn't. So we synthesize one; this means we might get two, but
2105 that's ok, because the second one won't have any effect. */
2106 SELECTION_EVENT_DISPLAY (&event
.sie
) = dpyinfo
->display
;
2107 SELECTION_EVENT_SELECTION (&event
.sie
) = selection_atom
;
2108 SELECTION_EVENT_TIME (&event
.sie
) = timestamp
;
2109 x_handle_selection_clear (&event
.ie
);
2114 DEFUN ("x-selection-owner-p", Fx_selection_owner_p
, Sx_selection_owner_p
,
2116 doc
: /* Whether the current Emacs process owns the given X Selection.
2117 The arg should be the name of the selection in question, typically one of
2118 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.
2119 \(Those are literal upper-case symbol names, since that's what X expects.)
2120 For convenience, the symbol nil is the same as `PRIMARY',
2121 and t is the same as `SECONDARY'.
2123 TERMINAL should be a terminal object or a frame specifying the X
2124 server to query. If omitted or nil, that stands for the selected
2125 frame's display, or the first available X display.
2127 On Nextstep, TERMINAL is unused. */)
2128 (Lisp_Object selection
, Lisp_Object terminal
)
2130 struct frame
*f
= frame_for_x_selection (terminal
);
2132 CHECK_SYMBOL (selection
);
2133 if (EQ (selection
, Qnil
)) selection
= QPRIMARY
;
2134 if (EQ (selection
, Qt
)) selection
= QSECONDARY
;
2136 if (f
&& !NILP (LOCAL_SELECTION (selection
, FRAME_X_DISPLAY_INFO (f
))))
2142 DEFUN ("x-selection-exists-p", Fx_selection_exists_p
, Sx_selection_exists_p
,
2144 doc
: /* Whether there is an owner for the given X selection.
2145 SELECTION should be the name of the selection in question, typically
2146 one of the symbols `PRIMARY', `SECONDARY', `CLIPBOARD', or
2147 `CLIPBOARD_MANAGER' (X expects these literal upper-case names.) The
2148 symbol nil is the same as `PRIMARY', and t is the same as `SECONDARY'.
2150 TERMINAL should be a terminal object or a frame specifying the X
2151 server to query. If omitted or nil, that stands for the selected
2152 frame's display, or the first available X display.
2154 On Nextstep, TERMINAL is unused. */)
2155 (Lisp_Object selection
, Lisp_Object terminal
)
2159 struct frame
*f
= frame_for_x_selection (terminal
);
2160 struct x_display_info
*dpyinfo
;
2162 CHECK_SYMBOL (selection
);
2163 if (EQ (selection
, Qnil
)) selection
= QPRIMARY
;
2164 if (EQ (selection
, Qt
)) selection
= QSECONDARY
;
2169 dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2171 if (!NILP (LOCAL_SELECTION (selection
, dpyinfo
)))
2174 atom
= symbol_to_x_atom (dpyinfo
, selection
);
2175 if (atom
== 0) return Qnil
;
2177 owner
= XGetSelectionOwner (dpyinfo
->display
, atom
);
2179 return (owner
? Qt
: Qnil
);
2183 /* Send clipboard manager a SAVE_TARGETS request with a UTF8_STRING
2184 property (http://www.freedesktop.org/wiki/ClipboardManager). */
2187 x_clipboard_manager_save (Lisp_Object frame
)
2189 struct frame
*f
= XFRAME (frame
);
2190 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2191 Atom data
= dpyinfo
->Xatom_UTF8_STRING
;
2193 XChangeProperty (FRAME_X_DISPLAY (f
), FRAME_X_WINDOW (f
),
2194 dpyinfo
->Xatom_EMACS_TMP
,
2195 dpyinfo
->Xatom_ATOM
, 32, PropModeReplace
,
2196 (unsigned char *) &data
, 1);
2197 x_get_foreign_selection (QCLIPBOARD_MANAGER
, QSAVE_TARGETS
,
2202 /* Error handler for x_clipboard_manager_save_frame. */
2205 x_clipboard_manager_error_1 (Lisp_Object err
)
2207 Lisp_Object args
[2];
2208 args
[0] = build_string ("X clipboard manager error: %s\n\
2209 If the problem persists, set `x-select-enable-clipboard-manager' to nil.");
2210 args
[1] = CAR (CDR (err
));
2215 /* Error handler for x_clipboard_manager_save_all. */
2218 x_clipboard_manager_error_2 (Lisp_Object err
)
2220 fprintf (stderr
, "Error saving to X clipboard manager.\n\
2221 If the problem persists, set `x-select-enable-clipboard-manager' \
2226 /* Called from delete_frame: save any clipboard owned by FRAME to the
2227 clipboard manager. Do nothing if FRAME does not own the clipboard,
2228 or if no clipboard manager is present. */
2231 x_clipboard_manager_save_frame (Lisp_Object frame
)
2235 if (!NILP (Vx_select_enable_clipboard_manager
)
2237 && (f
= XFRAME (frame
), FRAME_X_P (f
))
2238 && FRAME_LIVE_P (f
))
2240 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2241 Lisp_Object local_selection
2242 = LOCAL_SELECTION (QCLIPBOARD
, dpyinfo
);
2244 if (!NILP (local_selection
)
2245 && EQ (frame
, XCAR (XCDR (XCDR (XCDR (local_selection
)))))
2246 && XGetSelectionOwner (dpyinfo
->display
,
2247 dpyinfo
->Xatom_CLIPBOARD_MANAGER
))
2248 internal_condition_case_1 (x_clipboard_manager_save
, frame
, Qt
,
2249 x_clipboard_manager_error_1
);
2253 /* Called from Fkill_emacs: save any clipboard owned by FRAME to the
2254 clipboard manager. Do nothing if FRAME does not own the clipboard,
2255 or if no clipboard manager is present. */
2258 x_clipboard_manager_save_all (void)
2260 /* Loop through all X displays, saving owned clipboards. */
2261 struct x_display_info
*dpyinfo
;
2262 Lisp_Object local_selection
, local_frame
;
2264 if (NILP (Vx_select_enable_clipboard_manager
))
2267 for (dpyinfo
= x_display_list
; dpyinfo
; dpyinfo
= dpyinfo
->next
)
2269 local_selection
= LOCAL_SELECTION (QCLIPBOARD
, dpyinfo
);
2270 if (NILP (local_selection
)
2271 || !XGetSelectionOwner (dpyinfo
->display
,
2272 dpyinfo
->Xatom_CLIPBOARD_MANAGER
))
2275 local_frame
= XCAR (XCDR (XCDR (XCDR (local_selection
))));
2276 if (FRAME_LIVE_P (XFRAME (local_frame
)))
2278 Lisp_Object args
[1];
2279 args
[0] = build_string ("Saving clipboard to X clipboard manager...");
2282 internal_condition_case_1 (x_clipboard_manager_save
, local_frame
,
2283 Qt
, x_clipboard_manager_error_2
);
2289 /***********************************************************************
2290 Drag and drop support
2291 ***********************************************************************/
2292 /* Check that lisp values are of correct type for x_fill_property_data.
2293 That is, number, string or a cons with two numbers (low and high 16
2294 bit parts of a 32 bit number). Return the number of items in DATA,
2295 or -1 if there is an error. */
2298 x_check_property_data (Lisp_Object data
)
2303 for (iter
= data
; CONSP (iter
); iter
= XCDR (iter
))
2305 Lisp_Object o
= XCAR (iter
);
2307 if (! NUMBERP (o
) && ! STRINGP (o
) && ! CONSP (o
))
2309 else if (CONSP (o
) &&
2310 (! NUMBERP (XCAR (o
)) || ! NUMBERP (XCDR (o
))))
2312 if (size
== INT_MAX
)
2320 /* Convert lisp values to a C array. Values may be a number, a string
2321 which is taken as an X atom name and converted to the atom value, or
2322 a cons containing the two 16 bit parts of a 32 bit number.
2324 DPY is the display use to look up X atoms.
2325 DATA is a Lisp list of values to be converted.
2326 RET is the C array that contains the converted values. It is assumed
2327 it is big enough to hold all values.
2328 FORMAT is 8, 16 or 32 and denotes char/short/long for each C value to
2329 be stored in RET. Note that long is used for 32 even if long is more
2330 than 32 bits (see man pages for XChangeProperty, XGetWindowProperty and
2331 XClientMessageEvent). */
2334 x_fill_property_data (Display
*dpy
, Lisp_Object data
, void *ret
, int format
)
2337 long *d32
= (long *) ret
;
2338 short *d16
= (short *) ret
;
2339 char *d08
= (char *) ret
;
2342 for (iter
= data
; CONSP (iter
); iter
= XCDR (iter
))
2344 Lisp_Object o
= XCAR (iter
);
2346 if (INTEGERP (o
) || FLOATP (o
) || CONSP (o
))
2347 val
= cons_to_signed (o
, LONG_MIN
, LONG_MAX
);
2348 else if (STRINGP (o
))
2351 val
= (long) XInternAtom (dpy
, SSDATA (o
), False
);
2355 error ("Wrong type, must be string, number or cons");
2359 if (CHAR_MIN
<= val
&& val
<= CHAR_MAX
)
2362 error ("Out of 'char' range");
2364 else if (format
== 16)
2366 if (SHRT_MIN
<= val
&& val
<= SHRT_MAX
)
2369 error ("Out of 'short' range");
2376 /* Convert an array of C values to a Lisp list.
2377 F is the frame to be used to look up X atoms if the TYPE is XA_ATOM.
2378 DATA is a C array of values to be converted.
2379 TYPE is the type of the data. Only XA_ATOM is special, it converts
2380 each number in DATA to its corresponding X atom as a symbol.
2381 FORMAT is 8, 16 or 32 and gives the size in bits for each C value to
2383 SIZE is the number of elements in DATA.
2385 Important: When format is 32, data should contain an array of int,
2386 not an array of long as the X library returns. This makes a difference
2387 when sizeof(long) != sizeof(int).
2389 Also see comment for selection_data_to_lisp_data above. */
2392 x_property_data_to_lisp (struct frame
*f
, const unsigned char *data
,
2393 Atom type
, int format
, long unsigned int size
)
2395 ptrdiff_t format_bytes
= format
>> 3;
2396 if (PTRDIFF_MAX
/ format_bytes
< size
)
2397 memory_full (SIZE_MAX
);
2398 return selection_data_to_lisp_data (FRAME_X_DISPLAY (f
),
2399 data
, size
* format_bytes
, type
, format
);
2402 /* Get the mouse position in frame relative coordinates. */
2405 mouse_position_for_drop (FRAME_PTR f
, int *x
, int *y
)
2407 Window root
, dummy_window
;
2412 XQueryPointer (FRAME_X_DISPLAY (f
),
2413 DefaultRootWindow (FRAME_X_DISPLAY (f
)),
2415 /* The root window which contains the pointer. */
2418 /* Window pointer is on, not used */
2421 /* The position on that root window. */
2424 /* x/y in dummy_window coordinates, not used. */
2427 /* Modifier keys and pointer buttons, about which
2429 (unsigned int *) &dummy
);
2432 /* Absolute to relative. */
2433 *x
-= f
->left_pos
+ FRAME_OUTER_TO_INNER_DIFF_X (f
);
2434 *y
-= f
->top_pos
+ FRAME_OUTER_TO_INNER_DIFF_Y (f
);
2439 DEFUN ("x-get-atom-name", Fx_get_atom_name
,
2440 Sx_get_atom_name
, 1, 2, 0,
2441 doc
: /* Return the X atom name for VALUE as a string.
2442 VALUE may be a number or a cons where the car is the upper 16 bits and
2443 the cdr is the lower 16 bits of a 32 bit value.
2444 Use the display for FRAME or the current frame if FRAME is not given or nil.
2446 If the value is 0 or the atom is not known, return the empty string. */)
2447 (Lisp_Object value
, Lisp_Object frame
)
2449 struct frame
*f
= check_x_frame (frame
);
2452 Lisp_Object ret
= Qnil
;
2453 Display
*dpy
= FRAME_X_DISPLAY (f
);
2457 CONS_TO_INTEGER (value
, Atom
, atom
);
2460 x_catch_errors (dpy
);
2461 name
= atom
? XGetAtomName (dpy
, atom
) : empty
;
2462 had_errors
= x_had_errors_p (dpy
);
2463 x_uncatch_errors ();
2466 ret
= build_string (name
);
2468 if (atom
&& name
) XFree (name
);
2469 if (NILP (ret
)) ret
= empty_unibyte_string
;
2476 DEFUN ("x-register-dnd-atom", Fx_register_dnd_atom
,
2477 Sx_register_dnd_atom
, 1, 2, 0,
2478 doc
: /* Request that dnd events are made for ClientMessages with ATOM.
2479 ATOM can be a symbol or a string. The ATOM is interned on the display that
2480 FRAME is on. If FRAME is nil, the selected frame is used. */)
2481 (Lisp_Object atom
, Lisp_Object frame
)
2484 struct frame
*f
= check_x_frame (frame
);
2486 struct x_display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2490 x_atom
= symbol_to_x_atom (dpyinfo
, atom
);
2491 else if (STRINGP (atom
))
2494 x_atom
= XInternAtom (FRAME_X_DISPLAY (f
), SSDATA (atom
), False
);
2498 error ("ATOM must be a symbol or a string");
2500 for (i
= 0; i
< dpyinfo
->x_dnd_atoms_length
; ++i
)
2501 if (dpyinfo
->x_dnd_atoms
[i
] == x_atom
)
2504 if (dpyinfo
->x_dnd_atoms_length
== dpyinfo
->x_dnd_atoms_size
)
2505 dpyinfo
->x_dnd_atoms
=
2506 xpalloc (dpyinfo
->x_dnd_atoms
, &dpyinfo
->x_dnd_atoms_size
,
2507 1, -1, sizeof *dpyinfo
->x_dnd_atoms
);
2509 dpyinfo
->x_dnd_atoms
[dpyinfo
->x_dnd_atoms_length
++] = x_atom
;
2513 /* Convert an XClientMessageEvent to a Lisp event of type DRAG_N_DROP_EVENT. */
2516 x_handle_dnd_message (struct frame
*f
, XClientMessageEvent
*event
,
2517 struct x_display_info
*dpyinfo
, struct input_event
*bufp
)
2521 /* format 32 => size 5, format 16 => size 10, format 8 => size 20 */
2522 unsigned long size
= 160/event
->format
;
2524 unsigned char *data
= (unsigned char *) event
->data
.b
;
2528 for (i
= 0; i
< dpyinfo
->x_dnd_atoms_length
; ++i
)
2529 if (dpyinfo
->x_dnd_atoms
[i
] == event
->message_type
) break;
2531 if (i
== dpyinfo
->x_dnd_atoms_length
) return 0;
2533 XSETFRAME (frame
, f
);
2535 /* On a 64 bit machine, the event->data.l array members are 64 bits (long),
2536 but the x_property_data_to_lisp (or rather selection_data_to_lisp_data)
2537 function expects them to be of size int (i.e. 32). So to be able to
2538 use that function, put the data in the form it expects if format is 32. */
2540 if (32 < BITS_PER_LONG
&& event
->format
== 32)
2542 for (i
= 0; i
< 5; ++i
) /* There are only 5 longs in a ClientMessage. */
2543 idata
[i
] = event
->data
.l
[i
];
2544 data
= (unsigned char *) idata
;
2547 vec
= Fmake_vector (make_number (4), Qnil
);
2548 ASET (vec
, 0, SYMBOL_NAME (x_atom_to_symbol (FRAME_X_DISPLAY (f
),
2549 event
->message_type
)));
2550 ASET (vec
, 1, frame
);
2551 ASET (vec
, 2, make_number (event
->format
));
2552 ASET (vec
, 3, x_property_data_to_lisp (f
,
2554 event
->message_type
,
2558 mouse_position_for_drop (f
, &x
, &y
);
2559 bufp
->kind
= DRAG_N_DROP_EVENT
;
2560 bufp
->frame_or_window
= frame
;
2561 bufp
->timestamp
= CurrentTime
;
2562 bufp
->x
= make_number (x
);
2563 bufp
->y
= make_number (y
);
2565 bufp
->modifiers
= 0;
2570 DEFUN ("x-send-client-message", Fx_send_client_event
,
2571 Sx_send_client_message
, 6, 6, 0,
2572 doc
: /* Send a client message of MESSAGE-TYPE to window DEST on DISPLAY.
2574 For DISPLAY, specify either a frame or a display name (a string).
2575 If DISPLAY is nil, that stands for the selected frame's display.
2576 DEST may be a number, in which case it is a Window id. The value 0 may
2577 be used to send to the root window of the DISPLAY.
2578 If DEST is a cons, it is converted to a 32 bit number
2579 with the high 16 bits from the car and the lower 16 bit from the cdr. That
2580 number is then used as a window id.
2581 If DEST is a frame the event is sent to the outer window of that frame.
2582 A value of nil means the currently selected frame.
2583 If DEST is the string "PointerWindow" the event is sent to the window that
2584 contains the pointer. If DEST is the string "InputFocus" the event is
2585 sent to the window that has the input focus.
2586 FROM is the frame sending the event. Use nil for currently selected frame.
2587 MESSAGE-TYPE is the name of an Atom as a string.
2588 FORMAT must be one of 8, 16 or 32 and determines the size of the values in
2589 bits. VALUES is a list of numbers, cons and/or strings containing the values
2590 to send. If a value is a string, it is converted to an Atom and the value of
2591 the Atom is sent. If a value is a cons, it is converted to a 32 bit number
2592 with the high 16 bits from the car and the lower 16 bit from the cdr.
2593 If more values than fits into the event is given, the excessive values
2595 (Lisp_Object display
, Lisp_Object dest
, Lisp_Object from
,
2596 Lisp_Object message_type
, Lisp_Object format
, Lisp_Object values
)
2598 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
2600 CHECK_STRING (message_type
);
2601 x_send_client_event (display
, dest
, from
,
2602 XInternAtom (dpyinfo
->display
,
2603 SSDATA (message_type
),
2611 x_send_client_event (Lisp_Object display
, Lisp_Object dest
, Lisp_Object from
,
2612 Atom message_type
, Lisp_Object format
, Lisp_Object values
)
2614 struct x_display_info
*dpyinfo
= check_x_display_info (display
);
2617 struct frame
*f
= check_x_frame (from
);
2620 CHECK_NUMBER (format
);
2621 CHECK_CONS (values
);
2623 if (x_check_property_data (values
) == -1)
2624 error ("Bad data in VALUES, must be number, cons or string");
2626 if (XINT (format
) != 8 && XINT (format
) != 16 && XINT (format
) != 32)
2627 error ("FORMAT must be one of 8, 16 or 32");
2629 event
.xclient
.type
= ClientMessage
;
2630 event
.xclient
.format
= XINT (format
);
2632 if (FRAMEP (dest
) || NILP (dest
))
2634 struct frame
*fdest
= check_x_frame (dest
);
2635 wdest
= FRAME_OUTER_WINDOW (fdest
);
2637 else if (STRINGP (dest
))
2639 if (strcmp (SSDATA (dest
), "PointerWindow") == 0)
2640 wdest
= PointerWindow
;
2641 else if (strcmp (SSDATA (dest
), "InputFocus") == 0)
2644 error ("DEST as a string must be one of PointerWindow or InputFocus");
2646 else if (INTEGERP (dest
) || FLOATP (dest
) || CONSP (dest
))
2647 CONS_TO_INTEGER (dest
, Window
, wdest
);
2649 error ("DEST must be a frame, nil, string, number or cons");
2651 if (wdest
== 0) wdest
= dpyinfo
->root_window
;
2652 to_root
= wdest
== dpyinfo
->root_window
;
2656 event
.xclient
.message_type
= message_type
;
2657 event
.xclient
.display
= dpyinfo
->display
;
2659 /* Some clients (metacity for example) expects sending window to be here
2660 when sending to the root window. */
2661 event
.xclient
.window
= to_root
? FRAME_OUTER_WINDOW (f
) : wdest
;
2664 memset (event
.xclient
.data
.b
, 0, sizeof (event
.xclient
.data
.b
));
2665 x_fill_property_data (dpyinfo
->display
, values
, event
.xclient
.data
.b
,
2666 event
.xclient
.format
);
2668 /* If event mask is 0 the event is sent to the client that created
2669 the destination window. But if we are sending to the root window,
2670 there is no such client. Then we set the event mask to 0xffff. The
2671 event then goes to clients selecting for events on the root window. */
2672 x_catch_errors (dpyinfo
->display
);
2674 int propagate
= to_root
? False
: True
;
2675 unsigned mask
= to_root
? 0xffff : 0;
2676 XSendEvent (dpyinfo
->display
, wdest
, propagate
, mask
, &event
);
2677 XFlush (dpyinfo
->display
);
2679 x_uncatch_errors ();
2685 syms_of_xselect (void)
2687 defsubr (&Sx_get_selection_internal
);
2688 defsubr (&Sx_own_selection_internal
);
2689 defsubr (&Sx_disown_selection_internal
);
2690 defsubr (&Sx_selection_owner_p
);
2691 defsubr (&Sx_selection_exists_p
);
2693 defsubr (&Sx_get_atom_name
);
2694 defsubr (&Sx_send_client_message
);
2695 defsubr (&Sx_register_dnd_atom
);
2697 reading_selection_reply
= Fcons (Qnil
, Qnil
);
2698 staticpro (&reading_selection_reply
);
2699 reading_selection_window
= 0;
2700 reading_which_selection
= 0;
2702 property_change_wait_list
= 0;
2703 prop_location_identifier
= 0;
2704 property_change_reply
= Fcons (Qnil
, Qnil
);
2705 staticpro (&property_change_reply
);
2707 converted_selections
= NULL
;
2708 conversion_fail_tag
= None
;
2710 DEFVAR_LISP ("selection-converter-alist", Vselection_converter_alist
,
2711 doc
: /* An alist associating X Windows selection-types with functions.
2712 These functions are called to convert the selection, with three args:
2713 the name of the selection (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');
2714 a desired type to which the selection should be converted;
2715 and the local selection value (whatever was given to `x-own-selection').
2717 The function should return the value to send to the X server
2718 \(typically a string). A return value of nil
2719 means that the conversion could not be done.
2720 A return value which is the symbol `NULL'
2721 means that a side-effect was executed,
2722 and there is no meaningful selection value. */);
2723 Vselection_converter_alist
= Qnil
;
2725 DEFVAR_LISP ("x-lost-selection-functions", Vx_lost_selection_functions
,
2726 doc
: /* A list of functions to be called when Emacs loses an X selection.
2727 \(This happens when some other X client makes its own selection
2728 or when a Lisp program explicitly clears the selection.)
2729 The functions are called with one argument, the selection type
2730 \(a symbol, typically `PRIMARY', `SECONDARY', or `CLIPBOARD'). */);
2731 Vx_lost_selection_functions
= Qnil
;
2733 DEFVAR_LISP ("x-sent-selection-functions", Vx_sent_selection_functions
,
2734 doc
: /* A list of functions to be called when Emacs answers a selection request.
2735 The functions are called with three arguments:
2736 - the selection name (typically `PRIMARY', `SECONDARY', or `CLIPBOARD');
2737 - the selection-type which Emacs was asked to convert the
2738 selection into before sending (for example, `STRING' or `LENGTH');
2739 - a flag indicating success or failure for responding to the request.
2740 We might have failed (and declined the request) for any number of reasons,
2741 including being asked for a selection that we no longer own, or being asked
2742 to convert into a type that we don't know about or that is inappropriate.
2743 This hook doesn't let you change the behavior of Emacs's selection replies,
2744 it merely informs you that they have happened. */);
2745 Vx_sent_selection_functions
= Qnil
;
2747 DEFVAR_LISP ("x-select-enable-clipboard-manager",
2748 Vx_select_enable_clipboard_manager
,
2749 doc
: /* Whether to enable X clipboard manager support.
2750 If non-nil, then whenever Emacs is killed or an Emacs frame is deleted
2751 while owning the X clipboard, the clipboard contents are saved to the
2752 clipboard manager if one is present. */);
2753 Vx_select_enable_clipboard_manager
= Qt
;
2755 DEFVAR_INT ("x-selection-timeout", x_selection_timeout
,
2756 doc
: /* Number of milliseconds to wait for a selection reply.
2757 If the selection owner doesn't reply in this time, we give up.
2758 A value of 0 means wait as long as necessary. This is initialized from the
2759 \"*selectionTimeout\" resource. */);
2760 x_selection_timeout
= 0;
2762 /* QPRIMARY is defined in keyboard.c. */
2763 DEFSYM (QSECONDARY
, "SECONDARY");
2764 DEFSYM (QSTRING
, "STRING");
2765 DEFSYM (QINTEGER
, "INTEGER");
2766 DEFSYM (QCLIPBOARD
, "CLIPBOARD");
2767 DEFSYM (QTIMESTAMP
, "TIMESTAMP");
2768 DEFSYM (QTEXT
, "TEXT");
2769 DEFSYM (QCOMPOUND_TEXT
, "COMPOUND_TEXT");
2770 DEFSYM (QUTF8_STRING
, "UTF8_STRING");
2771 DEFSYM (QDELETE
, "DELETE");
2772 DEFSYM (QMULTIPLE
, "MULTIPLE");
2773 DEFSYM (QINCR
, "INCR");
2774 DEFSYM (QEMACS_TMP
, "_EMACS_TMP_");
2775 DEFSYM (QTARGETS
, "TARGETS");
2776 DEFSYM (QATOM
, "ATOM");
2777 DEFSYM (QATOM_PAIR
, "ATOM_PAIR");
2778 DEFSYM (QCLIPBOARD_MANAGER
, "CLIPBOARD_MANAGER");
2779 DEFSYM (QSAVE_TARGETS
, "SAVE_TARGETS");
2780 DEFSYM (QNULL
, "NULL");
2781 DEFSYM (Qcompound_text_with_extensions
, "compound-text-with-extensions");
2782 DEFSYM (Qforeign_selection
, "foreign-selection");
2783 DEFSYM (Qx_lost_selection_functions
, "x-lost-selection-functions");
2784 DEFSYM (Qx_sent_selection_functions
, "x-sent-selection-functions");