src/w16select.c

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