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