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