src/w16select.c

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