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 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, or (at your option)
  10 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; 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.  */
  21
  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.  */
  26
  27 /* Written by Dale P. Smith <dpsm@en.com>  */
  28 /* Adapted to DJGPP v1 by Eli Zaretskii <eliz@is.elta.co.il>  */
  29
  30 #ifdef MSDOS
  31
  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"
  45
  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.  */
  49
  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
  61
  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);
  70
  71 Lisp_Object QCLIPBOARD, QPRIMARY;
  72
  73 /* Coding system for communicating with other Windows programs via the
  74    clipboard.  */
  75 static Lisp_Object Vselection_coding_system;
  76
  77 /* Coding system for the next communicating with other Windows programs.  */
  78 static Lisp_Object Vnext_selection_coding_system;
  79
  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;
  86
  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;
  94
  95 /* The size of allocated storage for storing the clipboard data.  */
  96 static size_t clipboard_storage_size;
  97 \f
  98 /* Emulation of `__dpmi_int' and friends for DJGPP v1.x  */
  99
 100 #if __DJGPP__ < 2
 101
 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
 105
 106 static int
 107 __dpmi_int (intno, regs)
 108      int intno;
 109      __dpmi_regs *regs;
 110 {
 111   regs->x.ss = regs->x.sp = regs->x.flags = 0;
 112   return _go32_dpmi_simulate_int (intno, regs);
 113 }
 114
 115 #endif /* __DJGPP__ < 2 */
 116 \f
 117 /* C functions to access the Windows 3.1x clipboard from DOS apps.
 118
 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  */
 122
 123 /* See also Ralf Brown's Interrupt List.
 124
 125    I also seem to remember reading about this in Dr. Dobbs Journal a
 126    while ago, but if you knew my memory...  :-)
 127
 128    Dale P. Smith <dpsm@en.com> */
 129
 130 /* Return the WinOldAp support version, or 0x1700 if not supported.  */
 131 unsigned
 132 identify_winoldap_version ()
 133 {
 134   __dpmi_regs regs;
 135
 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;
 143 }
 144
 145 /* Open the clipboard, return non-zero if successfull.  */
 146 unsigned
 147 open_clipboard ()
 148 {
 149   __dpmi_regs regs;
 150
 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;
 159
 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;
 166 }
 167
 168 /* Empty clipboard, return non-zero if successfull.  */
 169 unsigned
 170 empty_clipboard ()
 171 {
 172   __dpmi_regs regs;
 173
 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;
 180 }
 181
 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;
 187 {
 188   __dpmi_regs regs;
 189
 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;
 193
 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;
 198
 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;
 202
 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)
 209     {
 210       clipboard_xfer_buf_info.size = 0;
 211       return 0;
 212     }
 213
 214   clipboard_xfer_buf_info.rm_segment = regs.x.ax;
 215   return (((int)clipboard_xfer_buf_info.rm_segment) << 4) & 0xfffff;
 216 }
 217
 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 ()
 224 {
 225   /* If the size is 0, we used DJGPP transfer buffer, so don't free.  */
 226   if (clipboard_xfer_buf_info.size)
 227     {
 228       __dpmi_regs regs;
 229
 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;
 236     }
 237 }
 238
 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;
 246 {
 247   __dpmi_regs regs;
 248   unsigned truelen;
 249   unsigned long xbuf_addr, buf_offset;
 250   unsigned char *dp = Data, *dstart = dp;
 251
 252   if (Format != CF_OEMTEXT)
 253     return 3;
 254
 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 */
 259
 260   if (!Raw)
 261     {
 262       /* avoid using strchr because it recomputes the length everytime */
 263       while ((dp = memchr (dp, '\n', Size - (dp - dstart))) != 0)
 264         {
 265           truelen++;
 266           dp++;
 267         }
 268     }
 269
 270   if (clipboard_compact (truelen) < truelen)
 271     return 1;
 272
 273   if ((xbuf_addr = alloc_xfer_buf (truelen)) == 0)
 274     return 1;
 275
 276   /* Move the buffer into the low memory, convert LF into CR-LF if needed.  */
 277   if (Raw)
 278     {
 279       dosmemput (Data, Size, xbuf_addr);
 280
 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');
 284     }
 285   else
 286     {
 287       dp = Data;
 288       buf_offset = xbuf_addr;
 289       _farsetsel (_dos_ds);
 290       while (Size--)
 291         {
 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++);
 299         }
 300
 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');
 304     }
 305
 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)
 310     {
 311       clipboard_storage_size = truelen + 100;
 312       last_clipboard_text =
 313         (char *) xrealloc (last_clipboard_text, clipboard_storage_size);
 314     }
 315   if (last_clipboard_text)
 316     dosmemget (xbuf_addr, truelen, last_clipboard_text);
 317
 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);
 331
 332   free_xfer_buf ();
 333
 334   /* If the above failed, invalidate the local copy of the clipboard.  */
 335   if (regs.x.ax == 0)
 336     *last_clipboard_text = '\0';
 337
 338   /* Zero means success, otherwise (1, 2, or 3) it's an error.  */
 339   return regs.x.ax > 0 ? 0 : 3;
 340 }
 341
 342 /* Return the size of the clipboard data of format FORMAT.  */
 343 unsigned
 344 get_clipboard_data_size (Format)
 345      unsigned Format;
 346 {
 347   __dpmi_regs regs;
 348
 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);
 359 }
 360
 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;
 370 {
 371   __dpmi_regs regs;
 372   unsigned long xbuf_addr;
 373   unsigned char *dp = Data;
 374
 375   if (Format != CF_OEMTEXT)
 376     return 0;
 377
 378   if (Size == 0)
 379     return 0;
 380
 381   if ((xbuf_addr = alloc_xfer_buf (Size)) == 0)
 382     return 0;
 383
 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)
 396     {
 397       unsigned char null_char = '\0';
 398       unsigned long xbuf_beg = xbuf_addr;
 399
 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;
 404
 405       /* Copy data from low memory, remove CR
 406          characters before LF if needed.  */
 407       _farsetsel (_dos_ds);
 408       while (Size--)
 409         {
 410           register unsigned char c = _farnspeekb (xbuf_addr++);
 411
 412           if (*lcdp == c)
 413             lcdp++;
 414
 415           if ((*dp++ = c) == '\r' && !Raw && _farnspeekb (xbuf_addr) == '\n')
 416             {
 417               dp--;
 418               *dp++ = '\n';
 419               xbuf_addr++;
 420               if (*lcdp == '\n')
 421                 lcdp++;
 422             }
 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;
 429         }
 430
 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;
 439     }
 440
 441   free_xfer_buf ();
 442
 443   return (unsigned) (dp - (unsigned char *)Data - 1);
 444 }
 445
 446 /* Close clipboard, return non-zero if successfull.  */
 447 unsigned
 448 close_clipboard ()
 449 {
 450   __dpmi_regs regs;
 451
 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;
 458 }
 459
 460 /* Compact clipboard data so that at least SIZE bytes is available.  */
 461 unsigned
 462 clipboard_compact (Size)
 463      unsigned Size;
 464 {
 465   __dpmi_regs regs;
 466
 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;
 476 }
 477 \f
 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.)";
 484
 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;
 489 {
 490   unsigned ok = 1, put_status = 0;
 491   int nbytes, charset_info, no_crlf_conversion;
 492   unsigned char *src, *dst = NULL;
 493
 494   CHECK_STRING (string);
 495
 496   if (NILP (frame))
 497     frame = Fselected_frame ();
 498
 499   CHECK_LIVE_FRAME (frame);
 500   if ( !FRAME_MSDOS_P (XFRAME (frame)))
 501     goto done;
 502
 503   BLOCK_INPUT;
 504
 505   nbytes = SBYTES (string);
 506   src = SDATA (string);
 507
 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);
 512
 513   if (charset_info == 0)
 514     {
 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;
 518     }
 519   else
 520     {
 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;
 526
 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)))
 533         {
 534           string = run_pre_post_conversion_on_str (string, &coding, 1);
 535           src = SDATA (string);
 536           nbytes = SBYTES (string);
 537         }
 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;
 549     }
 550
 551   if (!open_clipboard ())
 552     goto error;
 553
 554   ok = empty_clipboard ()
 555     && ((put_status
 556          = set_clipboard_data (CF_OEMTEXT, src, nbytes, no_crlf_conversion))
 557         == 0);
 558
 559   if (!no_crlf_conversion)
 560     Vlast_coding_system_used = Qraw_text;
 561   close_clipboard ();
 562
 563   if (ok) goto unblock;
 564
 565  error:
 566
 567   ok = 0;
 568
 569  unblock:
 570   if (dst)
 571     xfree (dst);
 572   UNBLOCK_INPUT;
 573
 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)
 580     {
 581       switch (put_status)
 582         {
 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;
 592         }
 593       sit_for (make_number (2), 0, 2);
 594     }
 595
 596  done:
 597
 598   return (ok && put_status == 0 ? string : Qnil);
 599 }
 600
 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;
 605 {
 606   unsigned data_size, truelen;
 607   unsigned char *htext;
 608   Lisp_Object ret = Qnil;
 609   int no_crlf_conversion, require_encoding = 0;
 610
 611   if (NILP (frame))
 612     frame = Fselected_frame ();
 613
 614   CHECK_LIVE_FRAME (frame);
 615   if ( !FRAME_MSDOS_P (XFRAME (frame)))
 616     goto done;
 617
 618   BLOCK_INPUT;
 619
 620   if (!open_clipboard ())
 621     goto unblock;
 622
 623   if ((data_size = get_clipboard_data_size (CF_OEMTEXT)) == 0 ||
 624       (htext = (unsigned char *)xmalloc (data_size)) == 0)
 625     goto closeclip;
 626
 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;
 632
 633   /* Do we need to decode it?  */
 634   {
 635     /* If the clipboard data contains any 8-bit Latin-1 code, we
 636        need to decode it.  */
 637     int i;
 638
 639     for (i = 0; i < truelen; i++)
 640       {
 641         if (htext[i] >= 0x80)
 642           {
 643             require_encoding = 1;
 644             break;
 645           }
 646       }
 647   }
 648   if (require_encoding)
 649     {
 650       int bufsize;
 651       unsigned char *buf;
 652       struct coding_system coding;
 653
 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;
 676     }
 677   else
 678     {
 679       ret = make_unibyte_string ((char *) htext, truelen);
 680       Vlast_coding_system_used = Qraw_text;
 681     }
 682
 683   xfree (htext);
 684
 685  closeclip:
 686   close_clipboard ();
 687
 688  unblock:
 689   UNBLOCK_INPUT;
 690
 691  done:
 692
 693   return (ret);
 694 }
 695
 696 /* Support checking for a clipboard selection. */
 697
 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;
 708 {
 709   CHECK_SYMBOL (selection);
 710
 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.
 715
 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;
 725
 726   if (EQ (selection, QCLIPBOARD))
 727     {
 728       Lisp_Object val = Qnil;
 729
 730       if (open_clipboard ())
 731         {
 732           if (get_clipboard_data_size (CF_OEMTEXT))
 733             val = Qt;
 734           close_clipboard ();
 735         }
 736       return val;
 737     }
 738   return Qnil;
 739 }
 740
 741 void
 742 syms_of_win16select ()
 743 {
 744   defsubr (&Sw16_set_clipboard_data);
 745   defsubr (&Sw16_get_clipboard_data);
 746   defsubr (&Sx_selection_exists_p);
 747
 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");
 754
 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;
 762
 763   QPRIMARY   = intern ("PRIMARY");      staticpro (&QPRIMARY);
 764   QCLIPBOARD = intern ("CLIPBOARD");    staticpro (&QCLIPBOARD);
 765 }
 766
 767 #endif /* MSDOS */
 768
 769 /* arch-tag: 085a22c8-7324-436e-a6da-102464ce95d8
 770    (do not change this comment) */