(5x5-new-game): Set up the buffer even if not interactive.
[emacs.git] / src / w16select.c
blob7fb0534f36d7dbf3f713e5bbb4139aad64d91369
1 /* 16-bit Windows Selection processing for emacs on MS-Windows
2 Copyright (C) 1996, 1997, 2001 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)
9 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; 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 /* 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. */
26 /* Written by Dale P. Smith <dpsm@en.com> */
27 /* Adapted to DJGPP v1 by Eli Zaretskii <eliz@is.elta.co.il> */
29 #ifdef MSDOS
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"
40 #include "buffer.h"
41 #include "charset.h"
42 #include "coding.h"
43 #include "composite.h"
45 /* If ever some function outside this file will need to call any
46 clipboard-related function, the following prototypes and constants
47 should be put on a header file. Right now, nobody else uses them. */
49 #define CF_TEXT 0x01
50 #define CF_BITMAP 0x02
51 #define CF_METAFILE 0x03
52 #define CF_SYLK 0x04
53 #define CF_DIF 0x05
54 #define CF_TIFF 0x06
55 #define CF_OEMTEXT 0x07
56 #define CF_DIBBITMAP 0x08
57 #define CF_WINWRITE 0x80
58 #define CF_DSPTEXT 0x81
59 #define CF_DSPBITMAP 0x82
61 unsigned identify_winoldap_version (void);
62 unsigned open_clipboard (void);
63 unsigned empty_clipboard (void);
64 unsigned set_clipboard_data (unsigned, void *, unsigned, int);
65 unsigned get_clipboard_data_size (unsigned);
66 unsigned get_clipboard_data (unsigned, void *, unsigned, int);
67 unsigned close_clipboard (void);
68 unsigned clipboard_compact (unsigned);
70 Lisp_Object QCLIPBOARD, QPRIMARY;
72 /* Coding system for communicating with other Windows programs via the
73 clipboard. */
74 static Lisp_Object Vselection_coding_system;
76 /* Coding system for the next communicating with other Windows programs. */
77 static Lisp_Object Vnext_selection_coding_system;
79 /* The segment address and the size of the buffer in low
80 memory used to move data between us and WinOldAp module. */
81 static struct {
82 unsigned long size;
83 unsigned short rm_segment;
84 } clipboard_xfer_buf_info;
86 /* The last text we put into the clipboard. This is used to prevent
87 passing back our own text from the clipboard, instead of using the
88 kill ring. The former is undesirable because the clipboard data
89 could be MULEtilated by inappropriately chosen
90 (next-)selection-coding-system. For this reason, we must store the
91 text *after* it was encoded/Unix-to-DOS-converted. */
92 static unsigned char *last_clipboard_text;
94 /* The size of allocated storage for storing the clipboard data. */
95 static size_t clipboard_storage_size;
97 /* Emulation of `__dpmi_int' and friends for DJGPP v1.x */
99 #if __DJGPP__ < 2
101 typedef _go32_dpmi_registers __dpmi_regs;
102 #define __tb _go32_info_block.linear_address_of_transfer_buffer
103 #define _dos_ds _go32_info_block.selector_for_linear_memory
105 static int
106 __dpmi_int (intno, regs)
107 int intno;
108 __dpmi_regs *regs;
110 regs->x.ss = regs->x.sp = regs->x.flags = 0;
111 return _go32_dpmi_simulate_int (intno, regs);
114 #endif /* __DJGPP__ < 2 */
116 /* C functions to access the Windows 3.1x clipboard from DOS apps.
118 The information was obtained from the Microsoft Knowledge Base,
119 article Q67675 and can be found at:
120 http://www.microsoft.com/kb/developr/win_dk/q67675.htm */
122 /* See also Ralf Brown's Interrupt List.
124 I also seem to remember reading about this in Dr. Dobbs Journal a
125 while ago, but if you knew my memory... :-)
127 Dale P. Smith <dpsm@en.com> */
129 /* Return the WinOldAp support version, or 0x1700 if not supported. */
130 unsigned
131 identify_winoldap_version ()
133 __dpmi_regs regs;
135 /* Calls Int 2Fh/AX=1700h
136 Return Values AX == 1700H: Clipboard functions not available
137 <> 1700H: AL = Major version number
138 AH = Minor version number */
139 regs.x.ax = 0x1700;
140 __dpmi_int(0x2f, &regs);
141 return regs.x.ax;
144 /* Open the clipboard, return non-zero if successfull. */
145 unsigned
146 open_clipboard ()
148 __dpmi_regs regs;
150 /* Is WINOLDAP supported? */
151 /* Kludge alert!! If WinOldAp is not supported, we return a 0,
152 which is the same as ``Clipboard already open''. Currently,
153 this is taken as an error by all the functions that use
154 `open_clipboard', but if somebody someday will use that ``open''
155 clipboard, they will have interesting time debugging it... */
156 if (identify_winoldap_version () == 0x1700)
157 return 0;
159 /* Calls Int 2Fh/AX=1701h
160 Return Values AX == 0: Clipboard already open
161 <> 0: Clipboard opened */
162 regs.x.ax = 0x1701;
163 __dpmi_int(0x2f, &regs);
164 return regs.x.ax;
167 /* Empty clipboard, return non-zero if successfull. */
168 unsigned
169 empty_clipboard ()
171 __dpmi_regs regs;
173 /* Calls Int 2Fh/AX=1702h
174 Return Values AX == 0: Error occurred
175 <> 0: OK, Clipboard emptied */
176 regs.x.ax = 0x1702;
177 __dpmi_int(0x2f, &regs);
178 return regs.x.ax;
181 /* Ensure we have a buffer in low memory with enough memory for data
182 of size WANT_SIZE. Return the linear address of the buffer. */
183 static unsigned long
184 alloc_xfer_buf (want_size)
185 unsigned want_size;
187 __dpmi_regs regs;
189 /* If the usual DJGPP transfer buffer is large enough, use that. */
190 if (want_size <= _go32_info_block.size_of_transfer_buffer)
191 return __tb & 0xfffff;
193 /* Don't even try to allocate more than 1MB of memory: DOS cannot
194 possibly handle that (it will overflow the BX register below). */
195 if (want_size > 0xfffff)
196 return 0;
198 /* Need size rounded up to the nearest paragraph, and in
199 paragraph units (1 paragraph = 16 bytes). */
200 clipboard_xfer_buf_info.size = (want_size + 15) >> 4;
202 /* The NT DPMI host crashes us if we free DOS memory via the
203 DPMI service. Work around by calling DOS allocate/free block. */
204 regs.h.ah = 0x48;
205 regs.x.bx = clipboard_xfer_buf_info.size;
206 __dpmi_int (0x21, &regs);
207 if (regs.x.flags & 1)
209 clipboard_xfer_buf_info.size = 0;
210 return 0;
213 clipboard_xfer_buf_info.rm_segment = regs.x.ax;
214 return (((int)clipboard_xfer_buf_info.rm_segment) << 4) & 0xfffff;
217 /* Free our clipboard buffer. We always free it after use, because
218 keeping it leaves less free conventional memory for subprocesses.
219 The clipboard buffer tends to be large in size, because for small
220 clipboard data sizes we use the DJGPP transfer buffer. */
221 static void
222 free_xfer_buf ()
224 /* If the size is 0, we used DJGPP transfer buffer, so don't free. */
225 if (clipboard_xfer_buf_info.size)
227 __dpmi_regs regs;
229 /* The NT DPMI host crashes us if we free DOS memory via
230 the DPMI service. Work around by calling DOS free block. */
231 regs.h.ah = 0x49;
232 regs.x.es = clipboard_xfer_buf_info.rm_segment;
233 __dpmi_int (0x21, &regs);
234 clipboard_xfer_buf_info.size = 0;
238 /* Copy data into the clipboard, return zero if successfull. */
239 unsigned
240 set_clipboard_data (Format, Data, Size, Raw)
241 unsigned Format;
242 void *Data;
243 unsigned Size;
244 int Raw;
246 __dpmi_regs regs;
247 unsigned truelen;
248 unsigned long xbuf_addr, buf_offset;
249 unsigned char *dp = Data, *dstart = dp;
251 if (Format != CF_OEMTEXT)
252 return 3;
254 /* need to know final size after '\r' chars are inserted (the
255 standard CF_OEMTEXT clipboard format uses CRLF line endings,
256 while Emacs uses just LF internally). */
257 truelen = Size + 1; /* +1 for the terminating null */
259 if (!Raw)
261 /* avoid using strchr because it recomputes the length everytime */
262 while ((dp = memchr (dp, '\n', Size - (dp - dstart))) != 0)
264 truelen++;
265 dp++;
269 if (clipboard_compact (truelen) < truelen)
270 return 1;
272 if ((xbuf_addr = alloc_xfer_buf (truelen)) == 0)
273 return 1;
275 /* Move the buffer into the low memory, convert LF into CR-LF if needed. */
276 if (Raw)
278 dosmemput (Data, Size, xbuf_addr);
280 /* Terminate with a null, otherwise Windows does strange things
281 when the text size is an integral multiple of 32 bytes. */
282 _farpokeb (_dos_ds, xbuf_addr + Size, '\0');
284 else
286 dp = Data;
287 buf_offset = xbuf_addr;
288 _farsetsel (_dos_ds);
289 while (Size--)
291 /* Don't allow them to put binary data into the clipboard, since
292 it will cause yanked data to be truncated at the first null. */
293 if (*dp == '\0')
294 return 2;
295 if (*dp == '\n')
296 _farnspokeb (buf_offset++, '\r');
297 _farnspokeb (buf_offset++, *dp++);
300 /* Terminate with a null, otherwise Windows does strange things
301 when the text size is an integral multiple of 32 bytes. */
302 _farnspokeb (buf_offset, '\0');
305 /* Stash away the data we are about to put into the clipboard, so we
306 could later check inside get_clipboard_data whether the clipboard
307 still holds our data. */
308 if (clipboard_storage_size < truelen)
310 clipboard_storage_size = truelen + 100;
311 last_clipboard_text =
312 (char *) xrealloc (last_clipboard_text, clipboard_storage_size);
314 if (last_clipboard_text)
315 dosmemget (xbuf_addr, truelen, last_clipboard_text);
317 /* Calls Int 2Fh/AX=1703h with:
318 DX = WinOldAp-Supported Clipboard format
319 ES:BX = Pointer to data
320 SI:CX = Size of data in bytes
321 Return Values AX == 0: Error occurred
322 <> 0: OK. Data copied into the Clipboard. */
323 regs.x.ax = 0x1703;
324 regs.x.dx = Format;
325 regs.x.si = truelen >> 16;
326 regs.x.cx = truelen & 0xffff;
327 regs.x.es = xbuf_addr >> 4;
328 regs.x.bx = xbuf_addr & 15;
329 __dpmi_int(0x2f, &regs);
331 free_xfer_buf ();
333 /* If the above failed, invalidate the local copy of the clipboard. */
334 if (regs.x.ax == 0)
335 *last_clipboard_text = '\0';
337 /* Zero means success, otherwise (1, 2, or 3) it's an error. */
338 return regs.x.ax > 0 ? 0 : 3;
341 /* Return the size of the clipboard data of format FORMAT. */
342 unsigned
343 get_clipboard_data_size (Format)
344 unsigned Format;
346 __dpmi_regs regs;
348 /* Calls Int 2Fh/AX=1704h with:
349 DX = WinOldAp-Supported Clipboard format
350 Return Values DX:AX == Size of the data in bytes, including any
351 headers.
352 == 0 If data in this format is not in
353 the clipboard. */
354 regs.x.ax = 0x1704;
355 regs.x.dx = Format;
356 __dpmi_int(0x2f, &regs);
357 return ( (((unsigned)regs.x.dx) << 16) | regs.x.ax);
360 /* Get clipboard data, return its length.
361 Warning: this doesn't check whether DATA has enough space to hold
362 SIZE bytes. */
363 unsigned
364 get_clipboard_data (Format, Data, Size, Raw)
365 unsigned Format;
366 void *Data;
367 unsigned Size;
368 int Raw;
370 __dpmi_regs regs;
371 unsigned long xbuf_addr;
372 unsigned char *dp = Data;
374 if (Format != CF_OEMTEXT)
375 return 0;
377 if (Size == 0)
378 return 0;
380 if ((xbuf_addr = alloc_xfer_buf (Size)) == 0)
381 return 0;
383 /* Calls Int 2Fh/AX=1705h with:
384 DX = WinOldAp-Supported Clipboard format
385 ES:BX = Pointer to data buffer to hold data
386 Return Values AX == 0: Error occurred (or data in this format is not
387 in the clipboard)
388 <> 0: OK */
389 regs.x.ax = 0x1705;
390 regs.x.dx = Format;
391 regs.x.es = xbuf_addr >> 4;
392 regs.x.bx = xbuf_addr & 15;
393 __dpmi_int(0x2f, &regs);
394 if (regs.x.ax != 0)
396 unsigned char null_char = '\0';
397 unsigned long xbuf_beg = xbuf_addr;
399 /* If last_clipboard_text is NULL, we don't want to slow down
400 the next loop by an additional test. */
401 register unsigned char *lcdp =
402 last_clipboard_text == NULL ? &null_char : last_clipboard_text;
404 /* Copy data from low memory, remove CR
405 characters before LF if needed. */
406 _farsetsel (_dos_ds);
407 while (Size--)
409 register unsigned char c = _farnspeekb (xbuf_addr++);
411 if (*lcdp == c)
412 lcdp++;
414 if ((*dp++ = c) == '\r' && !Raw && _farnspeekb (xbuf_addr) == '\n')
416 dp--;
417 *dp++ = '\n';
418 xbuf_addr++;
419 if (*lcdp == '\n')
420 lcdp++;
422 /* Windows reportedly rounds up the size of clipboard data
423 (passed in SIZE) to a multiple of 32, and removes trailing
424 spaces from each line without updating SIZE. We therefore
425 bail out when we see the first null character. */
426 else if (c == '\0')
427 break;
430 /* If the text in clipboard is identical to what we put there
431 last time set_clipboard_data was called, pretend there's no
432 data in the clipboard. This is so we don't pass our own text
433 from the clipboard (which might be troublesome if the killed
434 text includes null characters). */
435 if (last_clipboard_text &&
436 xbuf_addr - xbuf_beg == (long)(lcdp - last_clipboard_text))
437 dp = (unsigned char *)Data + 1;
440 free_xfer_buf ();
442 return (unsigned) (dp - (unsigned char *)Data - 1);
445 /* Close clipboard, return non-zero if successfull. */
446 unsigned
447 close_clipboard ()
449 __dpmi_regs regs;
451 /* Calls Int 2Fh/AX=1708h
452 Return Values AX == 0: Error occurred
453 <> 0: OK */
454 regs.x.ax = 0x1708;
455 __dpmi_int(0x2f, &regs);
456 return regs.x.ax;
459 /* Compact clipboard data so that at least SIZE bytes is available. */
460 unsigned
461 clipboard_compact (Size)
462 unsigned Size;
464 __dpmi_regs regs;
466 /* Calls Int 2Fh/AX=1709H with:
467 SI:CX = Desired memory size in bytes.
468 Return Values DX:AX == Number of bytes of largest block of free memory.
469 == 0 if error or no memory */
470 regs.x.ax = 0x1709;
471 regs.x.si = Size >> 16;
472 regs.x.cx = Size & 0xffff;
473 __dpmi_int(0x2f, &regs);
474 return ((unsigned)regs.x.dx << 16) | regs.x.ax;
477 static char no_mem_msg[] =
478 "(Not enough DOS memory to put saved text into clipboard.)";
479 static char binary_msg[] =
480 "(Binary characters in saved text; clipboard data not set.)";
481 static char system_error_msg[] =
482 "(Clipboard interface failure; clipboard data not set.)";
484 DEFUN ("w16-set-clipboard-data", Fw16_set_clipboard_data, Sw16_set_clipboard_data, 1, 2, 0,
485 doc: /* This sets the clipboard data to the given text. */)
486 (string, frame)
487 Lisp_Object string, frame;
489 unsigned ok = 1, put_status = 0;
490 int nbytes, charset_info, no_crlf_conversion;
491 unsigned char *src, *dst = NULL;
493 CHECK_STRING (string);
495 if (NILP (frame))
496 frame = Fselected_frame ();
498 CHECK_LIVE_FRAME (frame);
499 if ( !FRAME_MSDOS_P (XFRAME (frame)))
500 goto done;
502 BLOCK_INPUT;
504 nbytes = SBYTES (string);
505 src = SDATA (string);
507 /* Since we are now handling multilingual text, we must consider
508 encoding text for the clipboard. */
509 charset_info = find_charset_in_text (src, SCHARS (string), nbytes,
510 NULL, Qnil);
512 if (charset_info == 0)
514 /* No multibyte character in OBJ. We need not encode it, but we
515 will have to convert it to DOS CR-LF style. */
516 no_crlf_conversion = 0;
518 else
520 /* We must encode contents of STRING according to what
521 clipboard-coding-system specifies. */
522 int bufsize;
523 struct coding_system coding;
524 unsigned char *htext2;
526 if (NILP (Vnext_selection_coding_system))
527 Vnext_selection_coding_system = Vselection_coding_system;
528 setup_coding_system
529 (Fcheck_coding_system (Vnext_selection_coding_system), &coding);
530 if (SYMBOLP (coding.pre_write_conversion)
531 && !NILP (Ffboundp (coding.pre_write_conversion)))
533 string = run_pre_post_conversion_on_str (string, &coding, 1);
534 src = SDATA (string);
535 nbytes = SBYTES (string);
537 coding.src_multibyte = 1;
538 coding.dst_multibyte = 0;
539 Vnext_selection_coding_system = Qnil;
540 coding.mode |= CODING_MODE_LAST_BLOCK;
541 Vlast_coding_system_used = coding.symbol;
542 bufsize = encoding_buffer_size (&coding, nbytes);
543 dst = (unsigned char *) xmalloc (bufsize);
544 encode_coding (&coding, src, dst, nbytes, bufsize);
545 no_crlf_conversion = 1;
546 nbytes = coding.produced;
547 src = dst;
550 if (!open_clipboard ())
551 goto error;
553 ok = empty_clipboard ()
554 && ((put_status
555 = set_clipboard_data (CF_OEMTEXT, src, nbytes, no_crlf_conversion))
556 == 0);
558 if (!no_crlf_conversion)
559 Vlast_coding_system_used = Qraw_text;
560 close_clipboard ();
562 if (ok) goto unblock;
564 error:
566 ok = 0;
568 unblock:
569 if (dst)
570 xfree (dst);
571 UNBLOCK_INPUT;
573 /* Notify user if the text is too large to fit into DOS memory.
574 (This will happen somewhere after 600K bytes (470K in DJGPP v1.x),
575 depending on user system configuration.) If we just silently
576 fail the function, people might wonder why their text sometimes
577 doesn't make it to the clipboard. */
578 if (put_status)
580 switch (put_status)
582 case 1:
583 message2 (no_mem_msg, sizeof (no_mem_msg) - 1, 0);
584 break;
585 case 2:
586 message2 (binary_msg, sizeof (binary_msg) - 1, 0);
587 break;
588 case 3:
589 message2 (system_error_msg, sizeof (system_error_msg) - 1, 0);
590 break;
592 sit_for (2, 0, 0, 1, 1);
595 done:
597 return (ok && put_status == 0 ? string : Qnil);
600 DEFUN ("w16-get-clipboard-data", Fw16_get_clipboard_data, Sw16_get_clipboard_data, 0, 1, 0,
601 doc: /* This gets the clipboard data in text format. */)
602 (frame)
603 Lisp_Object frame;
605 unsigned data_size, truelen;
606 unsigned char *htext;
607 Lisp_Object ret = Qnil;
608 int no_crlf_conversion, require_encoding = 0;
610 if (NILP (frame))
611 frame = Fselected_frame ();
613 CHECK_LIVE_FRAME (frame);
614 if ( !FRAME_MSDOS_P (XFRAME (frame)))
615 goto done;
617 BLOCK_INPUT;
619 if (!open_clipboard ())
620 goto unblock;
622 if ((data_size = get_clipboard_data_size (CF_OEMTEXT)) == 0 ||
623 (htext = (unsigned char *)xmalloc (data_size)) == 0)
624 goto closeclip;
626 /* need to know final size after '\r' chars are removed because
627 we can't change the string size manually, and doing an extra
628 copy is silly */
629 if ((truelen = get_clipboard_data (CF_OEMTEXT, htext, data_size, 0)) == 0)
630 goto closeclip;
632 /* Do we need to decode it? */
634 /* If the clipboard data contains any 8-bit Latin-1 code, we
635 need to decode it. */
636 int i;
638 for (i = 0; i < truelen; i++)
640 if (htext[i] >= 0x80)
642 require_encoding = 1;
643 break;
647 if (require_encoding)
649 int bufsize;
650 unsigned char *buf;
651 struct coding_system coding;
653 if (NILP (Vnext_selection_coding_system))
654 Vnext_selection_coding_system = Vselection_coding_system;
655 setup_coding_system
656 (Fcheck_coding_system (Vnext_selection_coding_system), &coding);
657 coding.src_multibyte = 0;
658 coding.dst_multibyte = 1;
659 Vnext_selection_coding_system = Qnil;
660 coding.mode |= CODING_MODE_LAST_BLOCK;
661 /* We explicitely disable composition handling because selection
662 data should not contain any composition sequence. */
663 coding.composing = COMPOSITION_DISABLED;
664 truelen = get_clipboard_data (CF_OEMTEXT, htext, data_size, 1);
665 bufsize = decoding_buffer_size (&coding, truelen);
666 buf = (unsigned char *) xmalloc (bufsize);
667 decode_coding (&coding, htext, buf, truelen, bufsize);
668 ret = make_string_from_bytes ((char *) buf,
669 coding.produced_char, coding.produced);
670 xfree (buf);
671 if (SYMBOLP (coding.post_read_conversion)
672 && !NILP (Ffboundp (coding.post_read_conversion)))
673 ret = run_pre_post_conversion_on_str (ret, &coding, 0);
674 Vlast_coding_system_used = coding.symbol;
676 else
678 ret = make_unibyte_string ((char *) htext, truelen);
679 Vlast_coding_system_used = Qraw_text;
682 xfree (htext);
684 closeclip:
685 close_clipboard ();
687 unblock:
688 UNBLOCK_INPUT;
690 done:
692 return (ret);
695 /* Support checking for a clipboard selection. */
697 DEFUN ("x-selection-exists-p", Fx_selection_exists_p, Sx_selection_exists_p,
698 0, 1, 0,
699 doc: /* Whether there is an owner for the given X Selection.
700 The arg should be the name of the selection in question, typically one of
701 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.
702 \(Those are literal upper-case symbol names, since that's what X expects.)
703 For convenience, the symbol nil is the same as `PRIMARY',
704 and t is the same as `SECONDARY'. */)
705 (selection)
706 Lisp_Object selection;
708 CHECK_SYMBOL (selection);
710 /* Return nil for SECONDARY selection. For PRIMARY (or nil)
711 selection, check if there is some text on the kill-ring;
712 for CLIPBOARD, check if the clipboard currently has valid
713 text format contents.
715 The test for killed text on the kill-ring emulates the Emacs
716 behavior on X, where killed text is also put into X selection
717 by the X interface code. (On MSDOS, killed text is only put
718 into the clipboard if we run under Windows, so we cannot check
719 the clipboard alone.) */
720 if ((EQ (selection, Qnil) || EQ (selection, QPRIMARY))
721 && ! NILP (SYMBOL_VALUE (Fintern_soft (build_string ("kill-ring"),
722 Qnil))))
723 return Qt;
725 if (EQ (selection, QCLIPBOARD))
727 Lisp_Object val = Qnil;
729 if (open_clipboard ())
731 if (get_clipboard_data_size (CF_OEMTEXT))
732 val = Qt;
733 close_clipboard ();
735 return val;
737 return Qnil;
740 void
741 syms_of_win16select ()
743 defsubr (&Sw16_set_clipboard_data);
744 defsubr (&Sw16_get_clipboard_data);
745 defsubr (&Sx_selection_exists_p);
747 DEFVAR_LISP ("selection-coding-system", &Vselection_coding_system,
748 doc: /* Coding system for communicating with other X clients.
749 When sending or receiving text via cut_buffer, selection, and clipboard,
750 the text is encoded or decoded by this coding system.
751 The default value is `iso-latin-1-dos'. */);
752 Vselection_coding_system = intern ("iso-latin-1-dos");
754 DEFVAR_LISP ("next-selection-coding-system", &Vnext_selection_coding_system,
755 doc: /* Coding system for the next communication with other X clients.
756 Usually, `selection-coding-system' is used for communicating with
757 other X clients. But, if this variable is set, it is used for the
758 next communication only. After the communication, this variable is
759 set to nil. */);
760 Vnext_selection_coding_system = Qnil;
762 QPRIMARY = intern ("PRIMARY"); staticpro (&QPRIMARY);
763 QCLIPBOARD = intern ("CLIPBOARD"); staticpro (&QCLIPBOARD);
766 #endif /* MSDOS */
768 /* arch-tag: 085a22c8-7324-436e-a6da-102464ce95d8
769 (do not change this comment) */