*** empty log message ***
[bpt/emacs.git] / src / w16select.c
CommitLineData
767079a8 1/* 16-bit Windows Selection processing for emacs on MS-Windows
a97569cb 2 Copyright (C) 1996, 1997, 2001 Free Software Foundation.
8de1855e 3
21cfcccf
EZ
4This file is part of GNU Emacs.
5
6GNU Emacs is free software; you can redistribute it and/or modify
7it under the terms of the GNU General Public License as published by
8the Free Software Foundation; either version 2, or (at your option)
9any later version.
10
11GNU Emacs is distributed in the hope that it will be useful,
12but WITHOUT ANY WARRANTY; without even the implied warranty of
13MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14GNU General Public License for more details.
15
16You should have received a copy of the GNU General Public License
17along with GNU Emacs; see the file COPYING. If not, write to
18the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19Boston, MA 02111-1307, USA. */
20
21/* These functions work by using WinOldAp interface. WinOldAp
22 (WINOLDAP.MOD) is a Microsoft Windows extension supporting
23 "old" (character-mode) application access to Dynamic Data Exchange,
24 menus, and the Windows clipboard. */
25
26/* Written by Dale P. Smith <dpsm@en.com> */
27/* Adapted to DJGPP v1 by Eli Zaretskii <eliz@is.elta.co.il> */
28
29#ifdef MSDOS
30
31#include <config.h>
32#include <string.h>
33#include <dpmi.h>
34#include <go32.h>
35#include <sys/farptr.h>
36#include "lisp.h"
37#include "dispextern.h" /* frame.h seems to want this */
38#include "frame.h" /* Need this to get the X window of selected_frame */
39#include "blockinput.h"
583f5d53
EZ
40#include "buffer.h"
41#include "charset.h"
42#include "coding.h"
21cfcccf
EZ
43
44/* If ever some function outside this file will need to call any
45 clipboard-related function, the following prototypes and constants
46 should be put on a header file. Right now, nobody else uses them. */
47
48#define CF_TEXT 0x01
49#define CF_BITMAP 0x02
50#define CF_METAFILE 0x03
51#define CF_SYLK 0x04
52#define CF_DIF 0x05
53#define CF_TIFF 0x06
54#define CF_OEMTEXT 0x07
55#define CF_DIBBITMAP 0x08
56#define CF_WINWRITE 0x80
57#define CF_DSPTEXT 0x81
58#define CF_DSPBITMAP 0x82
59
60unsigned identify_winoldap_version (void);
61unsigned open_clipboard (void);
62unsigned empty_clipboard (void);
583f5d53 63unsigned set_clipboard_data (unsigned, void *, unsigned, int);
21cfcccf 64unsigned get_clipboard_data_size (unsigned);
583f5d53 65unsigned get_clipboard_data (unsigned, void *, unsigned, int);
21cfcccf
EZ
66unsigned close_clipboard (void);
67unsigned clipboard_compact (unsigned);
68
69Lisp_Object QCLIPBOARD, QPRIMARY;
70
583f5d53
EZ
71/* Coding system for communicating with other Windows programs via the
72 clipboard. */
199c7c44 73static Lisp_Object Vselection_coding_system;
583f5d53 74
9963e859
EZ
75/* Coding system for the next communicating with other Windows programs. */
76static Lisp_Object Vnext_selection_coding_system;
77
21cfcccf
EZ
78/* The segment address and the size of the buffer in low
79 memory used to move data between us and WinOldAp module. */
21cfcccf
EZ
80static struct {
81 unsigned long size;
82 unsigned short rm_segment;
83} clipboard_xfer_buf_info;
5033894e
EZ
84
85/* The last text we put into the clipboard. This is used to prevent
86 passing back our own text from the clipboard, instead of using the
87 kill ring. The former is undesirable because the clipboard data
88 could be MULEtilated by inappropriately chosen
89 (next-)selection-coding-system. For this reason, we must store the
90 text *after* it was encoded/Unix-to-DOS-converted. */
91static unsigned char *last_clipboard_text;
92
93/* The size of allocated storage for storing the clipboard data. */
94static size_t clipboard_storage_size;
21cfcccf
EZ
95\f
96/* Emulation of `__dpmi_int' and friends for DJGPP v1.x */
97
98#if __DJGPP__ < 2
99
100typedef _go32_dpmi_registers __dpmi_regs;
101#define __tb _go32_info_block.linear_address_of_transfer_buffer
102#define _dos_ds _go32_info_block.selector_for_linear_memory
103
104static int
105__dpmi_int (intno, regs)
106 int intno;
107 __dpmi_regs *regs;
108{
109 regs->x.ss = regs->x.sp = regs->x.flags = 0;
110 return _go32_dpmi_simulate_int (intno, regs);
111}
112
113#endif /* __DJGPP__ < 2 */
114\f
115/* C functions to access the Windows 3.1x clipboard from DOS apps.
116
117 The information was obtained from the Microsoft Knowledge Base,
118 article Q67675 and can be found at:
119 http://www.microsoft.com/kb/developr/win_dk/q67675.htm */
120
121/* See also Ralf Brown's Interrupt List.
122
123 I also seem to remember reading about this in Dr. Dobbs Journal a
124 while ago, but if you knew my memory... :-)
125
126 Dale P. Smith <dpsm@en.com> */
127
128/* Return the WinOldAp support version, or 0x1700 if not supported. */
129unsigned
130identify_winoldap_version ()
131{
132 __dpmi_regs regs;
133
134 /* Calls Int 2Fh/AX=1700h
135 Return Values AX == 1700H: Clipboard functions not available
136 <> 1700H: AL = Major version number
137 AH = Minor version number */
138 regs.x.ax = 0x1700;
139 __dpmi_int(0x2f, &regs);
140 return regs.x.ax;
141}
142
143/* Open the clipboard, return non-zero if successfull. */
144unsigned
145open_clipboard ()
146{
147 __dpmi_regs regs;
148
149 /* Is WINOLDAP supported? */
150 /* Kludge alert!! If WinOldAp is not supported, we return a 0,
151 which is the same as ``Clipboard already open''. Currently,
152 this is taken as an error by all the functions that use
153 `open_clipboard', but if somebody someday will use that ``open''
154 clipboard, they will have interesting time debugging it... */
155 if (identify_winoldap_version () == 0x1700)
156 return 0;
157
158 /* Calls Int 2Fh/AX=1701h
159 Return Values AX == 0: Clipboard already open
160 <> 0: Clipboard opened */
161 regs.x.ax = 0x1701;
162 __dpmi_int(0x2f, &regs);
163 return regs.x.ax;
164}
165
166/* Empty clipboard, return non-zero if successfull. */
167unsigned
168empty_clipboard ()
169{
170 __dpmi_regs regs;
8de1855e 171
21cfcccf
EZ
172 /* Calls Int 2Fh/AX=1702h
173 Return Values AX == 0: Error occurred
174 <> 0: OK, Clipboard emptied */
175 regs.x.ax = 0x1702;
176 __dpmi_int(0x2f, &regs);
177 return regs.x.ax;
178}
179
180/* Ensure we have a buffer in low memory with enough memory for data
181 of size WANT_SIZE. Return the linear address of the buffer. */
182static unsigned long
183alloc_xfer_buf (want_size)
184 unsigned want_size;
185{
186 __dpmi_regs regs;
187
188 /* If the usual DJGPP transfer buffer is large enough, use that. */
189 if (want_size <= _go32_info_block.size_of_transfer_buffer)
190 return __tb & 0xfffff;
191
767079a8
EZ
192 /* Don't even try to allocate more than 1MB of memory: DOS cannot
193 possibly handle that (it will overflow the BX register below). */
194 if (want_size > 0xfffff)
195 return 0;
196
21cfcccf
EZ
197 /* Need size rounded up to the nearest paragraph, and in
198 paragraph units (1 paragraph = 16 bytes). */
199 clipboard_xfer_buf_info.size = (want_size + 15) >> 4;
200
201 /* The NT DPMI host crashes us if we free DOS memory via the
202 DPMI service. Work around by calling DOS allocate/free block. */
203 regs.h.ah = 0x48;
204 regs.x.bx = clipboard_xfer_buf_info.size;
205 __dpmi_int (0x21, &regs);
206 if (regs.x.flags & 1)
207 {
208 clipboard_xfer_buf_info.size = 0;
209 return 0;
210 }
211
212 clipboard_xfer_buf_info.rm_segment = regs.x.ax;
213 return (((int)clipboard_xfer_buf_info.rm_segment) << 4) & 0xfffff;
214}
215
216/* Free our clipboard buffer. We always free it after use, because
217 keeping it leaves less free conventional memory for subprocesses.
218 The clipboard buffer tends to be large in size, because for small
219 clipboard data sizes we use the DJGPP transfer buffer. */
220static void
221free_xfer_buf ()
222{
223 /* If the size is 0, we used DJGPP transfer buffer, so don't free. */
224 if (clipboard_xfer_buf_info.size)
225 {
226 __dpmi_regs regs;
227
228 /* The NT DPMI host crashes us if we free DOS memory via
229 the DPMI service. Work around by calling DOS free block. */
230 regs.h.ah = 0x49;
231 regs.x.es = clipboard_xfer_buf_info.rm_segment;
232 __dpmi_int (0x21, &regs);
233 clipboard_xfer_buf_info.size = 0;
234 }
235}
236
0265f89f 237/* Copy data into the clipboard, return zero if successfull. */
21cfcccf 238unsigned
583f5d53 239set_clipboard_data (Format, Data, Size, Raw)
21cfcccf
EZ
240 unsigned Format;
241 void *Data;
242 unsigned Size;
583f5d53 243 int Raw;
21cfcccf
EZ
244{
245 __dpmi_regs regs;
246 unsigned truelen;
247 unsigned long xbuf_addr, buf_offset;
248 unsigned char *dp = Data, *dstart = dp;
249
538d05bb 250 if (Format != CF_OEMTEXT)
aae41d97 251 return 3;
21cfcccf
EZ
252
253 /* need to know final size after '\r' chars are inserted (the
538d05bb 254 standard CF_OEMTEXT clipboard format uses CRLF line endings,
21cfcccf 255 while Emacs uses just LF internally). */
0265f89f 256 truelen = Size + 1; /* +1 for the terminating null */
583f5d53
EZ
257
258 if (!Raw)
21cfcccf 259 {
583f5d53
EZ
260 /* avoid using strchr because it recomputes the length everytime */
261 while ((dp = memchr (dp, '\n', Size - (dp - dstart))) != 0)
262 {
263 truelen++;
264 dp++;
265 }
21cfcccf
EZ
266 }
267
268 if (clipboard_compact (truelen) < truelen)
aae41d97 269 return 1;
21cfcccf
EZ
270
271 if ((xbuf_addr = alloc_xfer_buf (truelen)) == 0)
aae41d97 272 return 1;
21cfcccf 273
583f5d53
EZ
274 /* Move the buffer into the low memory, convert LF into CR-LF if needed. */
275 if (Raw)
0236e3f1
EZ
276 {
277 dosmemput (Data, Size, xbuf_addr);
278
279 /* Terminate with a null, otherwise Windows does strange things
280 when the text size is an integral multiple of 32 bytes. */
281 _farpokeb (_dos_ds, xbuf_addr + Size, '\0');
282 }
583f5d53 283 else
21cfcccf 284 {
583f5d53
EZ
285 dp = Data;
286 buf_offset = xbuf_addr;
287 _farsetsel (_dos_ds);
288 while (Size--)
289 {
0265f89f
EZ
290 /* Don't allow them to put binary data into the clipboard, since
291 it will cause yanked data to be truncated at the first null. */
292 if (*dp == '\0')
293 return 2;
583f5d53
EZ
294 if (*dp == '\n')
295 _farnspokeb (buf_offset++, '\r');
296 _farnspokeb (buf_offset++, *dp++);
297 }
21cfcccf 298
0236e3f1
EZ
299 /* Terminate with a null, otherwise Windows does strange things
300 when the text size is an integral multiple of 32 bytes. */
301 _farnspokeb (buf_offset, '\0');
302 }
0265f89f 303
5033894e
EZ
304 /* Stash away the data we are about to put into the clipboard, so we
305 could later check inside get_clipboard_data whether the clipboard
306 still holds our data. */
307 if (clipboard_storage_size < truelen)
308 {
309 clipboard_storage_size = truelen + 100;
310 last_clipboard_text =
311 (char *) xrealloc (last_clipboard_text, clipboard_storage_size);
312 }
313 if (last_clipboard_text)
314 dosmemget (xbuf_addr, truelen, last_clipboard_text);
315
21cfcccf
EZ
316 /* Calls Int 2Fh/AX=1703h with:
317 DX = WinOldAp-Supported Clipboard format
318 ES:BX = Pointer to data
319 SI:CX = Size of data in bytes
320 Return Values AX == 0: Error occurred
321 <> 0: OK. Data copied into the Clipboard. */
322 regs.x.ax = 0x1703;
323 regs.x.dx = Format;
324 regs.x.si = truelen >> 16;
325 regs.x.cx = truelen & 0xffff;
326 regs.x.es = xbuf_addr >> 4;
327 regs.x.bx = xbuf_addr & 15;
328 __dpmi_int(0x2f, &regs);
329
330 free_xfer_buf ();
331
5033894e
EZ
332 /* If the above failed, invalidate the local copy of the clipboard. */
333 if (regs.x.ax == 0)
334 *last_clipboard_text = '\0';
335
aae41d97
EZ
336 /* Zero means success, otherwise (1, 2, or 3) it's an error. */
337 return regs.x.ax > 0 ? 0 : 3;
21cfcccf
EZ
338}
339
340/* Return the size of the clipboard data of format FORMAT. */
341unsigned
342get_clipboard_data_size (Format)
343 unsigned Format;
344{
345 __dpmi_regs regs;
346
347 /* Calls Int 2Fh/AX=1704h with:
348 DX = WinOldAp-Supported Clipboard format
349 Return Values DX:AX == Size of the data in bytes, including any
350 headers.
351 == 0 If data in this format is not in
352 the clipboard. */
353 regs.x.ax = 0x1704;
354 regs.x.dx = Format;
355 __dpmi_int(0x2f, &regs);
356 return ( (((unsigned)regs.x.dx) << 16) | regs.x.ax);
357}
358
359/* Get clipboard data, return its length.
360 Warning: this doesn't check whether DATA has enough space to hold
361 SIZE bytes. */
362unsigned
583f5d53 363get_clipboard_data (Format, Data, Size, Raw)
21cfcccf
EZ
364 unsigned Format;
365 void *Data;
366 unsigned Size;
583f5d53 367 int Raw;
21cfcccf
EZ
368{
369 __dpmi_regs regs;
21cfcccf
EZ
370 unsigned long xbuf_addr;
371 unsigned char *dp = Data;
372
538d05bb 373 if (Format != CF_OEMTEXT)
21cfcccf
EZ
374 return 0;
375
376 if (Size == 0)
377 return 0;
378
379 if ((xbuf_addr = alloc_xfer_buf (Size)) == 0)
380 return 0;
381
382 /* Calls Int 2Fh/AX=1705h with:
383 DX = WinOldAp-Supported Clipboard format
384 ES:BX = Pointer to data buffer to hold data
385 Return Values AX == 0: Error occurred (or data in this format is not
386 in the clipboard)
387 <> 0: OK */
388 regs.x.ax = 0x1705;
389 regs.x.dx = Format;
390 regs.x.es = xbuf_addr >> 4;
391 regs.x.bx = xbuf_addr & 15;
392 __dpmi_int(0x2f, &regs);
393 if (regs.x.ax != 0)
394 {
5033894e
EZ
395 unsigned char null_char = '\0';
396 unsigned long xbuf_beg = xbuf_addr;
397
398 /* If last_clipboard_text is NULL, we don't want to slow down
399 the next loop by an additional test. */
400 register unsigned char *lcdp =
401 last_clipboard_text == NULL ? &null_char : last_clipboard_text;
8de1855e 402
583f5d53
EZ
403 /* Copy data from low memory, remove CR
404 characters before LF if needed. */
21cfcccf
EZ
405 _farsetsel (_dos_ds);
406 while (Size--)
407 {
408 register unsigned char c = _farnspeekb (xbuf_addr++);
409
5033894e
EZ
410 if (*lcdp == c)
411 lcdp++;
412
583f5d53 413 if ((*dp++ = c) == '\r' && !Raw && _farnspeekb (xbuf_addr) == '\n')
21cfcccf
EZ
414 {
415 dp--;
416 *dp++ = '\n';
417 xbuf_addr++;
5033894e
EZ
418 if (*lcdp == '\n')
419 lcdp++;
21cfcccf
EZ
420 }
421 /* Windows reportedly rounds up the size of clipboard data
4029384b
EZ
422 (passed in SIZE) to a multiple of 32, and removes trailing
423 spaces from each line without updating SIZE. We therefore
424 bail out when we see the first null character. */
425 else if (c == '\0')
0265f89f 426 break;
21cfcccf 427 }
5033894e
EZ
428
429 /* If the text in clipboard is identical to what we put there
430 last time set_clipboard_data was called, pretend there's no
431 data in the clipboard. This is so we don't pass our own text
4029384b
EZ
432 from the clipboard (which might be troublesome if the killed
433 text includes null characters). */
5033894e
EZ
434 if (last_clipboard_text &&
435 xbuf_addr - xbuf_beg == (long)(lcdp - last_clipboard_text))
436 dp = (unsigned char *)Data + 1;
21cfcccf
EZ
437 }
438
439 free_xfer_buf ();
440
0265f89f 441 return (unsigned) (dp - (unsigned char *)Data - 1);
21cfcccf
EZ
442}
443
444/* Close clipboard, return non-zero if successfull. */
445unsigned
446close_clipboard ()
447{
448 __dpmi_regs regs;
449
450 /* Calls Int 2Fh/AX=1708h
451 Return Values AX == 0: Error occurred
452 <> 0: OK */
453 regs.x.ax = 0x1708;
454 __dpmi_int(0x2f, &regs);
455 return regs.x.ax;
456}
457
458/* Compact clipboard data so that at least SIZE bytes is available. */
459unsigned
460clipboard_compact (Size)
461 unsigned Size;
462{
463 __dpmi_regs regs;
464
465 /* Calls Int 2Fh/AX=1709H with:
466 SI:CX = Desired memory size in bytes.
467 Return Values DX:AX == Number of bytes of largest block of free memory.
468 == 0 if error or no memory */
469 regs.x.ax = 0x1709;
470 regs.x.si = Size >> 16;
471 regs.x.cx = Size & 0xffff;
472 __dpmi_int(0x2f, &regs);
473 return ((unsigned)regs.x.dx << 16) | regs.x.ax;
474}
475\f
476static char no_mem_msg[] =
477 "(Not enough DOS memory to put saved text into clipboard.)";
0265f89f
EZ
478static char binary_msg[] =
479 "(Binary characters in saved text; clipboard data not set.)";
aae41d97
EZ
480static char system_error_msg[] =
481 "(Clipboard interface failure; clipboard data not set.)";
21cfcccf 482
767079a8 483DEFUN ("w16-set-clipboard-data", Fw16_set_clipboard_data, Sw16_set_clipboard_data, 1, 2, 0,
70da46c3
PJ
484 doc: /* This sets the clipboard data to the given text. */)
485 (string, frame)
486 Lisp_Object string, frame;
21cfcccf 487{
0265f89f 488 unsigned ok = 1, put_status = 0;
8de1855e 489 int nbytes, charset_info, no_crlf_conversion;
583f5d53 490 unsigned char *src, *dst = NULL;
21cfcccf 491
b7826503 492 CHECK_STRING (string);
3276b4fe 493
21cfcccf
EZ
494 if (NILP (frame))
495 frame = Fselected_frame ();
496
b7826503 497 CHECK_LIVE_FRAME (frame);
21cfcccf
EZ
498 if ( !FRAME_MSDOS_P (XFRAME (frame)))
499 goto done;
3276b4fe 500
21cfcccf
EZ
501 BLOCK_INPUT;
502
199c7c44 503 nbytes = STRING_BYTES (XSTRING (string));
21cfcccf 504 src = XSTRING (string)->data;
583f5d53
EZ
505
506 /* Since we are now handling multilingual text, we must consider
507 encoding text for the clipboard. */
b34cf36c
KH
508 charset_info = find_charset_in_text (src, XSTRING (string)->size, nbytes,
509 NULL, Qnil);
510
511 if (charset_info == 0)
583f5d53
EZ
512 {
513 /* No multibyte character in OBJ. We need not encode it, but we
514 will have to convert it to DOS CR-LF style. */
515 no_crlf_conversion = 0;
516 }
517 else
518 {
519 /* We must encode contents of STRING according to what
520 clipboard-coding-system specifies. */
521 int bufsize;
522 struct coding_system coding;
523 unsigned char *htext2;
524
9963e859
EZ
525 if (NILP (Vnext_selection_coding_system))
526 Vnext_selection_coding_system = Vselection_coding_system;
583f5d53 527 setup_coding_system
9963e859 528 (Fcheck_coding_system (Vnext_selection_coding_system), &coding);
3276b4fe
EZ
529 if (SYMBOLP (coding.pre_write_conversion)
530 && !NILP (Ffboundp (coding.pre_write_conversion)))
531 {
532 string = run_pre_post_conversion_on_str (string, &coding, 1);
533 src = XSTRING (string)->data;
534 nbytes = STRING_BYTES (XSTRING (string));
535 }
1eed3a76
EZ
536 coding.src_multibyte = 1;
537 coding.dst_multibyte = 0;
9963e859 538 Vnext_selection_coding_system = Qnil;
583f5d53
EZ
539 coding.mode |= CODING_MODE_LAST_BLOCK;
540 Vlast_coding_system_used = coding.symbol;
541 bufsize = encoding_buffer_size (&coding, nbytes);
542 dst = (unsigned char *) xmalloc (bufsize);
543 encode_coding (&coding, src, dst, nbytes, bufsize);
544 no_crlf_conversion = 1;
c7594627 545 nbytes = coding.produced;
ba92a470 546 src = dst;
583f5d53
EZ
547 }
548
21cfcccf
EZ
549 if (!open_clipboard ())
550 goto error;
3276b4fe 551
583f5d53 552 ok = empty_clipboard ()
0265f89f 553 && ((put_status
ba92a470 554 = set_clipboard_data (CF_OEMTEXT, src, nbytes, no_crlf_conversion))
0265f89f 555 == 0);
583f5d53
EZ
556
557 if (!no_crlf_conversion)
558 Vlast_coding_system_used = Qraw_text;
21cfcccf 559 close_clipboard ();
3276b4fe 560
31354c30 561 if (ok) goto unblock;
21cfcccf
EZ
562
563 error:
3276b4fe 564
21cfcccf
EZ
565 ok = 0;
566
31354c30 567 unblock:
583f5d53
EZ
568 if (dst)
569 xfree (dst);
31354c30
EZ
570 UNBLOCK_INPUT;
571
21cfcccf
EZ
572 /* Notify user if the text is too large to fit into DOS memory.
573 (This will happen somewhere after 600K bytes (470K in DJGPP v1.x),
574 depending on user system configuration.) If we just silently
575 fail the function, people might wonder why their text sometimes
576 doesn't make it to the clipboard. */
0265f89f 577 if (put_status)
21cfcccf 578 {
0265f89f
EZ
579 switch (put_status)
580 {
581 case 1:
582 message2 (no_mem_msg, sizeof (no_mem_msg) - 1, 0);
583 break;
584 case 2:
585 message2 (binary_msg, sizeof (binary_msg) - 1, 0);
586 break;
aae41d97
EZ
587 case 3:
588 message2 (system_error_msg, sizeof (system_error_msg) - 1, 0);
589 break;
0265f89f 590 }
ad66baa4 591 sit_for (2, 0, 0, 1, 1);
21cfcccf 592 }
3276b4fe 593
21cfcccf 594 done:
21cfcccf 595
0265f89f 596 return (ok && put_status == 0 ? string : Qnil);
21cfcccf
EZ
597}
598
767079a8 599DEFUN ("w16-get-clipboard-data", Fw16_get_clipboard_data, Sw16_get_clipboard_data, 0, 1, 0,
70da46c3 600 doc: /* This gets the clipboard data in text format. */)
21cfcccf
EZ
601 (frame)
602 Lisp_Object frame;
603{
604 unsigned data_size, truelen;
605 unsigned char *htext;
606 Lisp_Object ret = Qnil;
8de1855e 607 int no_crlf_conversion, require_encoding = 0;
583f5d53 608
21cfcccf
EZ
609 if (NILP (frame))
610 frame = Fselected_frame ();
611
b7826503 612 CHECK_LIVE_FRAME (frame);
21cfcccf
EZ
613 if ( !FRAME_MSDOS_P (XFRAME (frame)))
614 goto done;
3276b4fe 615
21cfcccf 616 BLOCK_INPUT;
3276b4fe 617
21cfcccf 618 if (!open_clipboard ())
31354c30 619 goto unblock;
21cfcccf 620
538d05bb 621 if ((data_size = get_clipboard_data_size (CF_OEMTEXT)) == 0 ||
21cfcccf
EZ
622 (htext = (unsigned char *)xmalloc (data_size)) == 0)
623 goto closeclip;
624
625 /* need to know final size after '\r' chars are removed because
626 we can't change the string size manually, and doing an extra
627 copy is silly */
538d05bb 628 if ((truelen = get_clipboard_data (CF_OEMTEXT, htext, data_size, 0)) == 0)
21cfcccf
EZ
629 goto closeclip;
630
583f5d53 631 /* Do we need to decode it? */
3276b4fe
EZ
632 {
633 /* If the clipboard data contains any 8-bit Latin-1 code, we
634 need to decode it. */
635 int i;
636
637 for (i = 0; i < truelen; i++)
638 {
639 if (htext[i] >= 0x80)
640 {
641 require_encoding = 1;
642 break;
643 }
644 }
645 }
583f5d53
EZ
646 if (require_encoding)
647 {
648 int bufsize;
649 unsigned char *buf;
650 struct coding_system coding;
651
9963e859
EZ
652 if (NILP (Vnext_selection_coding_system))
653 Vnext_selection_coding_system = Vselection_coding_system;
583f5d53 654 setup_coding_system
9963e859 655 (Fcheck_coding_system (Vnext_selection_coding_system), &coding);
b34cf36c
KH
656 coding.src_multibyte = 0;
657 coding.dst_multibyte = 1;
9963e859 658 Vnext_selection_coding_system = Qnil;
583f5d53 659 coding.mode |= CODING_MODE_LAST_BLOCK;
ee826e00
KH
660 /* We explicitely disable composition handling because selection
661 data should not contain any composition sequence. */
662 coding.composing = COMPOSITION_DISABLED;
538d05bb 663 truelen = get_clipboard_data (CF_OEMTEXT, htext, data_size, 1);
583f5d53
EZ
664 bufsize = decoding_buffer_size (&coding, truelen);
665 buf = (unsigned char *) xmalloc (bufsize);
666 decode_coding (&coding, htext, buf, truelen, bufsize);
b34cf36c
KH
667 ret = make_string_from_bytes ((char *) buf,
668 coding.produced_char, coding.produced);
583f5d53 669 xfree (buf);
3276b4fe
EZ
670 if (SYMBOLP (coding.post_read_conversion)
671 && !NILP (Ffboundp (coding.post_read_conversion)))
b72d9870 672 ret = run_pre_post_conversion_on_str (ret, &coding, 0);
583f5d53
EZ
673 Vlast_coding_system_used = coding.symbol;
674 }
675 else
676 {
677 ret = make_unibyte_string ((char *) htext, truelen);
678 Vlast_coding_system_used = Qraw_text;
679 }
680
21cfcccf
EZ
681 xfree (htext);
682
683 closeclip:
684 close_clipboard ();
31354c30
EZ
685
686 unblock:
687 UNBLOCK_INPUT;
8de1855e 688
21cfcccf 689 done:
8de1855e 690
21cfcccf
EZ
691 return (ret);
692}
693
694/* Support checking for a clipboard selection. */
695
696DEFUN ("x-selection-exists-p", Fx_selection_exists_p, Sx_selection_exists_p,
70da46c3
PJ
697 0, 1, 0,
698 doc: /* Whether there is an owner for the given X Selection.
699The arg should be the name of the selection in question, typically one of
700the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.
701\(Those are literal upper-case symbol names, since that's what X expects.)
702For convenience, the symbol nil is the same as `PRIMARY',
703and t is the same as `SECONDARY'. */)
704 (selection)
21cfcccf
EZ
705 Lisp_Object selection;
706{
b7826503 707 CHECK_SYMBOL (selection);
21cfcccf
EZ
708
709 /* Return nil for SECONDARY selection. For PRIMARY (or nil)
710 selection, check if there is some text on the kill-ring;
711 for CLIPBOARD, check if the clipboard currently has valid
712 text format contents.
713
714 The test for killed text on the kill-ring emulates the Emacs
715 behavior on X, where killed text is also put into X selection
716 by the X interface code. (On MSDOS, killed text is only put
717 into the clipboard if we run under Windows, so we cannot check
718 the clipboard alone.) */
719 if ((EQ (selection, Qnil) || EQ (selection, QPRIMARY))
a97569cb
GM
720 && ! NILP (SYMBOL_VALUE (Fintern_soft (build_string ("kill-ring"),
721 Qnil))))
21cfcccf
EZ
722 return Qt;
723
724 if (EQ (selection, QCLIPBOARD))
725 {
726 Lisp_Object val = Qnil;
727
728 if (open_clipboard ())
729 {
538d05bb 730 if (get_clipboard_data_size (CF_OEMTEXT))
21cfcccf
EZ
731 val = Qt;
732 close_clipboard ();
733 }
734 return val;
735 }
736 return Qnil;
737}
738
8de1855e 739void
21cfcccf
EZ
740syms_of_win16select ()
741{
767079a8
EZ
742 defsubr (&Sw16_set_clipboard_data);
743 defsubr (&Sw16_get_clipboard_data);
21cfcccf
EZ
744 defsubr (&Sx_selection_exists_p);
745
199c7c44 746 DEFVAR_LISP ("selection-coding-system", &Vselection_coding_system,
70da46c3
PJ
747 doc: /* Coding system for communicating with other X clients.
748When sending or receiving text via cut_buffer, selection, and clipboard,
749the text is encoded or decoded by this coding system.
750A default value is `iso-latin-1-dos'. */);
199c7c44 751 Vselection_coding_system=intern ("iso-latin-1-dos");
9963e859
EZ
752
753 DEFVAR_LISP ("next-selection-coding-system", &Vnext_selection_coding_system,
70da46c3
PJ
754 doc: /* Coding system for the next communication with other X clients.
755Usually, `selection-coding-system' is used for communicating with
756other X clients. But, if this variable is set, it is used for the
757next communication only. After the communication, this variable is
758set to nil. */);
9963e859 759 Vnext_selection_coding_system = Qnil;
583f5d53 760
21cfcccf
EZ
761 QPRIMARY = intern ("PRIMARY"); staticpro (&QPRIMARY);
762 QCLIPBOARD = intern ("CLIPBOARD"); staticpro (&QCLIPBOARD);
763}
764
765#endif /* MSDOS */