1 /* Selection processing for Emacs on the Microsoft W32 API.
2 Copyright (C) 1993, 1994 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. */
21 /* Written by Kevin Gallo */
25 #include "w32term.h" /* for all of the w32 includes */
26 #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 #include "composite.h"
35 Lisp_Object QCLIPBOARD
;
37 /* Coding system for communicating with other Windows programs via the
39 static Lisp_Object Vselection_coding_system
;
41 /* Coding system for the next communicating with other Windows programs. */
42 static Lisp_Object Vnext_selection_coding_system
;
44 /* Sequence number, used where possible to detect when we are pasting
46 static DWORD last_clipboard_sequence_number
;
47 extern ClipboardSequence_Proc clipboard_sequence_fn
;
49 /* The last text we put into the clipboard. This is used when the OS
50 does not support sequence numbers (NT4, 95). It is undesirable to
51 use data put on the clipboard by Emacs because the clipboard data
52 could be MULEtilated by inappropriately chosen
53 (next-)selection-coding-system. For this reason, we must store the
54 text *after* it was encoded/Unix-to-DOS-converted. */
55 static unsigned char *last_clipboard_text
= NULL
;
56 static size_t clipboard_storage_size
= 0;
59 DEFUN ("w32-open-clipboard", Fw32_open_clipboard
, Sw32_open_clipboard
, 0, 1, 0,
60 doc
: /* This opens the clipboard with the given frame pointer. */)
67 CHECK_LIVE_FRAME (frame
);
71 ok
= OpenClipboard ((!NILP (frame
) && FRAME_W32_P (XFRAME (frame
))) ? FRAME_W32_WINDOW (XFRAME (frame
)) : NULL
);
75 return (ok
? frame
: Qnil
);
78 DEFUN ("w32-empty-clipboard", Fw32_empty_clipboard
,
79 Sw32_empty_clipboard
, 0, 0, 0,
80 doc
: /* Empty the clipboard.
81 Assigns ownership of the clipboard to the window which opened it. */)
88 ok
= EmptyClipboard ();
92 return (ok
? Qt
: Qnil
);
95 DEFUN ("w32-close-clipboard", Fw32_close_clipboard
,
96 Sw32_close_clipboard
, 0, 0, 0,
97 doc
: /* Close the clipboard. */)
104 ok
= CloseClipboard ();
108 return (ok
? Qt
: Qnil
);
113 DEFUN ("w32-set-clipboard-data", Fw32_set_clipboard_data
,
114 Sw32_set_clipboard_data
, 1, 2, 0,
115 doc
: /* This sets the clipboard data to the given text. */)
117 Lisp_Object string
, frame
;
122 int truelen
, nlines
= 0;
126 CHECK_STRING (string
);
129 CHECK_LIVE_FRAME (frame
);
133 nbytes
= SBYTES (string
) + 1;
134 src
= SDATA (string
);
137 /* We need to know how many lines there are, since we need CRLF line
138 termination for compatibility with other Windows Programs.
139 avoid using strchr because it recomputes the length every time */
140 while ((dst
= memchr (dst
, '\n', nbytes
- (dst
- src
))) != NULL
)
147 /* Since we are now handling multilingual text, we must consider
148 encoding text for the clipboard. */
149 int charset_info
= find_charset_in_text (src
, SCHARS (string
),
152 if (charset_info
== 0)
154 /* No multibyte character in OBJ. We need not encode it. */
156 /* Need to know final size after CR chars are inserted (the
157 standard CF_TEXT clipboard format uses CRLF line endings,
158 while Emacs uses just LF internally). */
160 truelen
= nbytes
+ nlines
;
162 if ((htext
= GlobalAlloc (GMEM_MOVEABLE
| GMEM_DDESHARE
, truelen
)) == NULL
)
165 if ((dst
= (unsigned char *) GlobalLock (htext
)) == NULL
)
168 /* convert to CRLF line endings expected by clipboard */
172 /* copy next line or remaining bytes including '\0' */
173 next
= _memccpy (dst
, src
, '\n', nbytes
);
176 /* copied one line ending with '\n' */
177 int copied
= next
- dst
;
180 /* insert '\r' before '\n' */
186 /* copied remaining partial line -> now finished */
190 GlobalUnlock (htext
);
192 Vlast_coding_system_used
= Qraw_text
;
196 /* We must encode contents of OBJ to the selection coding
199 struct coding_system coding
;
202 if (NILP (Vnext_selection_coding_system
))
203 Vnext_selection_coding_system
= Vselection_coding_system
;
205 (Fcheck_coding_system (Vnext_selection_coding_system
), &coding
);
206 if (SYMBOLP (coding
.pre_write_conversion
)
207 && !NILP (Ffboundp (coding
.pre_write_conversion
)))
209 string
= run_pre_post_conversion_on_str (string
, &coding
, 1);
210 src
= SDATA (string
);
211 nbytes
= SBYTES (string
);
213 coding
.src_multibyte
= 1;
214 coding
.dst_multibyte
= 0;
215 Vnext_selection_coding_system
= Qnil
;
216 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
217 bufsize
= encoding_buffer_size (&coding
, nbytes
);
218 if ((htext
= GlobalAlloc (GMEM_MOVEABLE
| GMEM_DDESHARE
, bufsize
)) == NULL
)
220 if ((dst
= (unsigned char *) GlobalLock (htext
)) == NULL
)
222 encode_coding (&coding
, src
, dst
, nbytes
, bufsize
);
223 Vlast_coding_system_used
= coding
.symbol
;
225 /* If clipboard sequence numbers are not supported, keep a copy for
227 if (!clipboard_sequence_fn
)
229 /* Stash away the data we are about to put into the
230 clipboard, so we could later check inside
231 Fw32_get_clipboard_data whether the clipboard still
233 if (clipboard_storage_size
< coding
.produced
)
235 clipboard_storage_size
= coding
.produced
+ 100;
236 last_clipboard_text
= (char *) xrealloc (last_clipboard_text
,
237 clipboard_storage_size
);
239 if (last_clipboard_text
)
240 memcpy (last_clipboard_text
, dst
, coding
.produced
);
243 GlobalUnlock (htext
);
245 /* Shrink data block to actual size. */
246 htext2
= GlobalReAlloc (htext
, coding
.produced
,
247 GMEM_MOVEABLE
| GMEM_DDESHARE
);
248 if (htext2
!= NULL
) htext
= htext2
;
252 if (!OpenClipboard ((!NILP (frame
) && FRAME_W32_P (XFRAME (frame
))) ? FRAME_W32_WINDOW (XFRAME (frame
)) : NULL
))
255 ok
= EmptyClipboard () && SetClipboardData (CF_TEXT
, htext
);
257 if (clipboard_sequence_fn
)
258 last_clipboard_sequence_number
= clipboard_sequence_fn ();
267 if (htext
) GlobalFree (htext
);
268 if (last_clipboard_text
)
269 *last_clipboard_text
= '\0';
271 last_clipboard_sequence_number
= 0;
276 return (ok
? string
: Qnil
);
279 DEFUN ("w32-get-clipboard-data", Fw32_get_clipboard_data
,
280 Sw32_get_clipboard_data
, 0, 1, 0,
281 doc
: /* This gets the clipboard data in text format. */)
286 Lisp_Object ret
= Qnil
;
289 CHECK_LIVE_FRAME (frame
);
293 if (!OpenClipboard ((!NILP (frame
) && FRAME_W32_P (XFRAME (frame
))) ? FRAME_W32_WINDOW (XFRAME (frame
)) : NULL
))
296 if ((htext
= GetClipboardData (CF_TEXT
)) == NULL
)
304 int require_decoding
= 0;
306 if ((src
= (unsigned char *) GlobalLock (htext
)) == NULL
)
309 nbytes
= strlen (src
);
311 /* If the text in clipboard is identical to what we put there
312 last time w32_set_clipboard_data was called, pretend there's no
313 data in the clipboard. This is so we don't pass our own text
314 from the clipboard (which might be troublesome if the killed
315 text includes null characters). */
316 if ((clipboard_sequence_fn
317 && clipboard_sequence_fn () == last_clipboard_sequence_number
)
318 || (last_clipboard_text
319 && clipboard_storage_size
>= nbytes
320 && memcmp(last_clipboard_text
, src
, nbytes
) == 0))
324 /* If the clipboard data contains any non-ascii code, we
325 need to decode it. */
328 for (i
= 0; i
< nbytes
; i
++)
332 require_decoding
= 1;
338 if (require_decoding
)
342 struct coding_system coding
;
344 if (NILP (Vnext_selection_coding_system
))
345 Vnext_selection_coding_system
= Vselection_coding_system
;
347 (Fcheck_coding_system (Vnext_selection_coding_system
), &coding
);
348 coding
.src_multibyte
= 0;
349 coding
.dst_multibyte
= 1;
350 Vnext_selection_coding_system
= Qnil
;
351 coding
.mode
|= CODING_MODE_LAST_BLOCK
;
352 /* We explicitely disable composition handling because
353 selection data should not contain any composition
355 coding
.composing
= COMPOSITION_DISABLED
;
356 bufsize
= decoding_buffer_size (&coding
, nbytes
);
357 buf
= (unsigned char *) xmalloc (bufsize
);
358 decode_coding (&coding
, src
, buf
, nbytes
, bufsize
);
359 Vlast_coding_system_used
= coding
.symbol
;
360 ret
= make_string_from_bytes ((char *) buf
,
361 coding
.produced_char
, coding
.produced
);
363 if (SYMBOLP (coding
.post_read_conversion
)
364 && !NILP (Ffboundp (coding
.post_read_conversion
)))
365 ret
= run_pre_post_conversion_on_str (ret
, &coding
, 0);
369 /* Need to know final size after CR chars are removed because we
370 can't change the string size manually, and doing an extra
371 copy is silly. Note that we only remove CR when it appears
376 /* avoid using strchr because it recomputes the length everytime */
377 while ((dst
= memchr (dst
, '\r', nbytes
- (dst
- src
))) != NULL
)
379 if (dst
[1] == '\n') /* safe because of trailing '\0' */
384 ret
= make_uninit_string (truelen
);
386 /* Convert CRLF line endings (the standard CF_TEXT clipboard
387 format) to LF endings as used internally by Emacs. */
393 /* copy next line or remaining bytes excluding '\0' */
394 next
= _memccpy (dst
, src
, '\r', nbytes
);
397 /* copied one line ending with '\r' */
398 int copied
= next
- dst
;
403 dst
--; /* overwrite '\r' with '\n' */
406 /* copied remaining partial line -> now finished */
410 Vlast_coding_system_used
= Qraw_text
;
413 GlobalUnlock (htext
);
425 /* Support checking for a clipboard selection. */
427 DEFUN ("x-selection-exists-p", Fx_selection_exists_p
, Sx_selection_exists_p
,
429 doc
: /* Whether there is an owner for the given X Selection.
430 The arg should be the name of the selection in question, typically one of
431 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.
432 \(Those are literal upper-case symbol names, since that's what X expects.)
433 For convenience, the symbol nil is the same as `PRIMARY',
434 and t is the same as `SECONDARY'. */)
436 Lisp_Object selection
;
438 CHECK_SYMBOL (selection
);
440 /* Return nil for PRIMARY and SECONDARY selections; for CLIPBOARD, check
441 if the clipboard currently has valid text format contents. */
443 if (EQ (selection
, QCLIPBOARD
))
445 Lisp_Object val
= Qnil
;
447 if (OpenClipboard (NULL
))
450 while (format
= EnumClipboardFormats (format
))
451 if (format
== CF_TEXT
)
467 defsubr (&Sw32_open_clipboard
);
468 defsubr (&Sw32_empty_clipboard
);
469 defsubr (&Sw32_close_clipboard
);
471 defsubr (&Sw32_set_clipboard_data
);
472 defsubr (&Sw32_get_clipboard_data
);
473 defsubr (&Sx_selection_exists_p
);
475 DEFVAR_LISP ("selection-coding-system", &Vselection_coding_system
,
476 doc
: /* Coding system for communicating with other programs.
477 When sending or receiving text via cut_buffer, selection, and clipboard,
478 the text is encoded or decoded by this coding system.
479 The default value is `iso-latin-1-dos'. */);
480 Vselection_coding_system
= intern ("iso-latin-1-dos");
482 DEFVAR_LISP ("next-selection-coding-system", &Vnext_selection_coding_system
,
483 doc
: /* Coding system for the next communication with other programs.
484 Usually, `selection-coding-system' is used for communicating with
485 other programs. But, if this variable is set, it is used for the
486 next communication only. After the communication, this variable is
488 Vnext_selection_coding_system
= Qnil
;
490 QCLIPBOARD
= intern ("CLIPBOARD"); staticpro (&QCLIPBOARD
);
493 /* arch-tag: c96e9724-5eb1-4dad-be07-289f092fd2af
494 (do not change this comment) */