w16select.c 22.1 KB
Newer Older
1
/* 16-bit Windows Selection processing for emacs on MS-Windows
2
   Copyright (C) 1996, 1997, 2001 Free Software Foundation.
Eli Zaretskii's avatar
Eli Zaretskii committed
3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39
   
This file is part of GNU Emacs.

GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */

/* These functions work by using WinOldAp interface.  WinOldAp
   (WINOLDAP.MOD) is a Microsoft Windows extension supporting
   "old" (character-mode) application access to Dynamic Data Exchange,
   menus, and the Windows clipboard.  */

/* Written by Dale P. Smith <dpsm@en.com>  */
/* Adapted to DJGPP v1 by Eli Zaretskii <eliz@is.elta.co.il>  */

#ifdef MSDOS

#include <config.h>
#include <string.h>
#include <dpmi.h>
#include <go32.h>
#include <sys/farptr.h>
#include "lisp.h"
#include "dispextern.h"	/* frame.h seems to want this */
#include "frame.h"	/* Need this to get the X window of selected_frame */
#include "blockinput.h"
40 41 42
#include "buffer.h"
#include "charset.h"
#include "coding.h"
Eli Zaretskii's avatar
Eli Zaretskii committed
43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62

/* If ever some function outside this file will need to call any
   clipboard-related function, the following prototypes and constants
   should be put on a header file.  Right now, nobody else uses them.  */

#define CF_TEXT      0x01
#define CF_BITMAP    0x02
#define CF_METAFILE  0x03
#define CF_SYLK	     0x04
#define CF_DIF	     0x05
#define CF_TIFF	     0x06
#define CF_OEMTEXT   0x07
#define CF_DIBBITMAP 0x08
#define CF_WINWRITE  0x80
#define CF_DSPTEXT   0x81
#define CF_DSPBITMAP 0x82

unsigned identify_winoldap_version (void);
unsigned open_clipboard (void);
unsigned empty_clipboard (void);
63
unsigned set_clipboard_data (unsigned, void *, unsigned, int);
Eli Zaretskii's avatar
Eli Zaretskii committed
64
unsigned get_clipboard_data_size (unsigned);
65
unsigned get_clipboard_data (unsigned, void *, unsigned, int);
Eli Zaretskii's avatar
Eli Zaretskii committed
66 67 68 69 70
unsigned close_clipboard (void);
unsigned clipboard_compact (unsigned);

Lisp_Object QCLIPBOARD, QPRIMARY;

71 72
/* Coding system for communicating with other Windows programs via the
   clipboard.  */
73
static Lisp_Object Vselection_coding_system;
74

75 76 77
/* Coding system for the next communicating with other Windows programs.  */
static Lisp_Object Vnext_selection_coding_system;

Eli Zaretskii's avatar
Eli Zaretskii committed
78 79 80 81 82 83
/* The segment address and the size of the buffer in low
   memory used to move data between us and WinOldAp module.  */
static struct {
  unsigned long size;
  unsigned short rm_segment;
} clipboard_xfer_buf_info;
84 85 86 87 88 89 90 91 92 93 94

/* The last text we put into the clipboard.  This is used to prevent
   passing back our own text from the clipboard, instead of using the
   kill ring.  The former is undesirable because the clipboard data
   could be MULEtilated by inappropriately chosen
   (next-)selection-coding-system.  For this reason, we must store the
   text *after* it was encoded/Unix-to-DOS-converted.  */
static unsigned char *last_clipboard_text;

/* The size of allocated storage for storing the clipboard data.  */
static size_t clipboard_storage_size;
Eli Zaretskii's avatar
Eli Zaretskii committed
95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191

/* Emulation of `__dpmi_int' and friends for DJGPP v1.x  */

#if __DJGPP__ < 2

typedef _go32_dpmi_registers __dpmi_regs;
#define __tb      _go32_info_block.linear_address_of_transfer_buffer
#define _dos_ds	  _go32_info_block.selector_for_linear_memory

static int
__dpmi_int (intno, regs)
     int intno;
     __dpmi_regs *regs;
{
  regs->x.ss = regs->x.sp = regs->x.flags = 0;
  return _go32_dpmi_simulate_int (intno, regs);
}

#endif /* __DJGPP__ < 2 */

/* C functions to access the Windows 3.1x clipboard from DOS apps.

   The information was obtained from the Microsoft Knowledge Base,
   article Q67675 and can be found at:
   http://www.microsoft.com/kb/developr/win_dk/q67675.htm  */

/* See also Ralf Brown's Interrupt List.

   I also seem to remember reading about this in Dr. Dobbs Journal a
   while ago, but if you knew my memory...  :-)

   Dale P. Smith <dpsm@en.com> */

/* Return the WinOldAp support version, or 0x1700 if not supported.  */
unsigned
identify_winoldap_version ()
{
  __dpmi_regs regs;

  /* Calls Int 2Fh/AX=1700h
     Return Values   AX == 1700H: Clipboard functions not available
                        <> 1700H: AL = Major version number
				  AH = Minor version number */
  regs.x.ax = 0x1700;
  __dpmi_int(0x2f, &regs);
  return regs.x.ax;
}

/* Open the clipboard, return non-zero if successfull.  */
unsigned
open_clipboard ()
{
  __dpmi_regs regs;

  /* Is WINOLDAP supported?  */
  /* Kludge alert!!  If WinOldAp is not supported, we return a 0,
     which is the same as ``Clipboard already open''.  Currently,
     this is taken as an error by all the functions that use
     `open_clipboard', but if somebody someday will use that ``open''
     clipboard, they will have interesting time debugging it...  */
  if (identify_winoldap_version () == 0x1700)
    return 0;

  /* Calls Int 2Fh/AX=1701h
     Return Values   AX == 0: Clipboard already open
			<> 0: Clipboard opened */
  regs.x.ax = 0x1701;
  __dpmi_int(0x2f, &regs);
  return regs.x.ax;
}

/* Empty clipboard, return non-zero if successfull.  */
unsigned
empty_clipboard ()
{
  __dpmi_regs regs;
  
  /* Calls Int 2Fh/AX=1702h
     Return Values   AX == 0: Error occurred
			<> 0: OK, Clipboard emptied */
  regs.x.ax = 0x1702;
  __dpmi_int(0x2f, &regs);
  return regs.x.ax;
}

/* Ensure we have a buffer in low memory with enough memory for data
   of size WANT_SIZE.  Return the linear address of the buffer.  */
static unsigned long
alloc_xfer_buf (want_size)
     unsigned want_size;
{
  __dpmi_regs regs;

  /* If the usual DJGPP transfer buffer is large enough, use that.  */
  if (want_size <= _go32_info_block.size_of_transfer_buffer)
    return __tb & 0xfffff;

192 193 194 195 196
  /* Don't even try to allocate more than 1MB of memory: DOS cannot
     possibly handle that (it will overflow the BX register below).  */
  if (want_size > 0xfffff)
    return 0;

Eli Zaretskii's avatar
Eli Zaretskii committed
197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236
  /* Need size rounded up to the nearest paragraph, and in
     paragraph units (1 paragraph = 16 bytes).  */
  clipboard_xfer_buf_info.size = (want_size + 15) >> 4;

  /* The NT DPMI host crashes us if we free DOS memory via the
     DPMI service.  Work around by calling DOS allocate/free block.  */
  regs.h.ah = 0x48;
  regs.x.bx = clipboard_xfer_buf_info.size;
  __dpmi_int (0x21, &regs);
  if (regs.x.flags & 1)
    {
      clipboard_xfer_buf_info.size = 0;
      return 0;
    }

  clipboard_xfer_buf_info.rm_segment = regs.x.ax;
  return (((int)clipboard_xfer_buf_info.rm_segment) << 4) & 0xfffff;
}

/* Free our clipboard buffer.  We always free it after use, because
   keeping it leaves less free conventional memory for subprocesses.
   The clipboard buffer tends to be large in size, because for small
   clipboard data sizes we use the DJGPP transfer buffer.  */
static void
free_xfer_buf ()
{
  /* If the size is 0, we used DJGPP transfer buffer, so don't free.  */
  if (clipboard_xfer_buf_info.size)
    {
      __dpmi_regs regs;

      /* The NT DPMI host crashes us if we free DOS memory via
	 the DPMI service.  Work around by calling DOS free block.  */
      regs.h.ah = 0x49;
      regs.x.es = clipboard_xfer_buf_info.rm_segment;
      __dpmi_int (0x21, &regs);
      clipboard_xfer_buf_info.size = 0;
    }
}

237
/* Copy data into the clipboard, return zero if successfull.  */
Eli Zaretskii's avatar
Eli Zaretskii committed
238
unsigned
239
set_clipboard_data (Format, Data, Size, Raw)
Eli Zaretskii's avatar
Eli Zaretskii committed
240 241 242
     unsigned Format;
     void *Data;
     unsigned Size;
243
     int Raw;
Eli Zaretskii's avatar
Eli Zaretskii committed
244 245 246 247 248 249
{
  __dpmi_regs regs;
  unsigned truelen;
  unsigned long xbuf_addr, buf_offset;
  unsigned char *dp = Data, *dstart = dp;

250
  if (Format != CF_OEMTEXT)
251
    return 3;
Eli Zaretskii's avatar
Eli Zaretskii committed
252 253

  /* need to know final size after '\r' chars are inserted (the
254
     standard CF_OEMTEXT clipboard format uses CRLF line endings,
Eli Zaretskii's avatar
Eli Zaretskii committed
255
     while Emacs uses just LF internally).  */
256
  truelen = Size + 1;		/* +1 for the terminating null */
257 258

  if (!Raw)
Eli Zaretskii's avatar
Eli Zaretskii committed
259
    {
260 261 262 263 264 265
      /* avoid using strchr because it recomputes the length everytime */
      while ((dp = memchr (dp, '\n', Size - (dp - dstart))) != 0)
	{
	  truelen++;
	  dp++;
	}
Eli Zaretskii's avatar
Eli Zaretskii committed
266 267 268
    }

  if (clipboard_compact (truelen) < truelen)
269
    return 1;
Eli Zaretskii's avatar
Eli Zaretskii committed
270 271

  if ((xbuf_addr = alloc_xfer_buf (truelen)) == 0)
272
    return 1;
Eli Zaretskii's avatar
Eli Zaretskii committed
273

274 275
  /* Move the buffer into the low memory, convert LF into CR-LF if needed.  */
  if (Raw)
276 277 278 279 280 281 282
    {
      dosmemput (Data, Size, xbuf_addr);

      /* Terminate with a null, otherwise Windows does strange things
	 when the text size is an integral multiple of 32 bytes. */
      _farpokeb (_dos_ds, xbuf_addr + Size, '\0');
    }
283
  else
Eli Zaretskii's avatar
Eli Zaretskii committed
284
    {
285 286 287 288 289
      dp = Data;
      buf_offset = xbuf_addr;
      _farsetsel (_dos_ds);
      while (Size--)
	{
290 291 292 293
	  /* Don't allow them to put binary data into the clipboard, since
	     it will cause yanked data to be truncated at the first null.  */
	  if (*dp == '\0')
	    return 2;
294 295 296 297
	  if (*dp == '\n')
	    _farnspokeb (buf_offset++, '\r');
	  _farnspokeb (buf_offset++, *dp++);
	}
Eli Zaretskii's avatar
Eli Zaretskii committed
298

299 300 301 302
      /* Terminate with a null, otherwise Windows does strange things
	 when the text size is an integral multiple of 32 bytes. */
      _farnspokeb (buf_offset, '\0');
    }
303

304 305 306 307 308 309 310 311 312 313 314 315
  /* Stash away the data we are about to put into the clipboard, so we
     could later check inside get_clipboard_data whether the clipboard
     still holds our data.  */
  if (clipboard_storage_size < truelen)
    {
      clipboard_storage_size = truelen + 100;
      last_clipboard_text =
	(char *) xrealloc (last_clipboard_text, clipboard_storage_size);
    }
  if (last_clipboard_text)
    dosmemget (xbuf_addr, truelen, last_clipboard_text);

Eli Zaretskii's avatar
Eli Zaretskii committed
316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331
  /* Calls Int 2Fh/AX=1703h with:
	             DX = WinOldAp-Supported Clipboard format
                     ES:BX = Pointer to data
                     SI:CX = Size of data in bytes
     Return Values   AX == 0: Error occurred
			<> 0: OK.  Data copied into the Clipboard.  */
  regs.x.ax = 0x1703;
  regs.x.dx = Format;
  regs.x.si = truelen >> 16;
  regs.x.cx = truelen & 0xffff;
  regs.x.es = xbuf_addr >> 4;
  regs.x.bx = xbuf_addr & 15;
  __dpmi_int(0x2f, &regs);

  free_xfer_buf ();

332 333 334 335
  /* If the above failed, invalidate the local copy of the clipboard.  */
  if (regs.x.ax == 0)
    *last_clipboard_text = '\0';

336 337
  /* Zero means success, otherwise (1, 2, or 3) it's an error.  */
  return regs.x.ax > 0 ? 0 : 3;
Eli Zaretskii's avatar
Eli Zaretskii committed
338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362
}

/* Return the size of the clipboard data of format FORMAT.  */
unsigned
get_clipboard_data_size (Format)
     unsigned Format;
{
  __dpmi_regs regs;

  /* Calls Int 2Fh/AX=1704h with:
		     DX = WinOldAp-Supported Clipboard format
     Return Values   DX:AX == Size of the data in bytes, including any
                              headers.
                           == 0 If data in this format is not in
			   the clipboard.  */
  regs.x.ax = 0x1704;
  regs.x.dx = Format;
  __dpmi_int(0x2f, &regs);
  return ( (((unsigned)regs.x.dx) << 16) | regs.x.ax);
}

/* Get clipboard data, return its length.
   Warning: this doesn't check whether DATA has enough space to hold
   SIZE bytes.  */
unsigned
363
get_clipboard_data (Format, Data, Size, Raw)
Eli Zaretskii's avatar
Eli Zaretskii committed
364 365 366
     unsigned Format;
     void *Data;
     unsigned Size;
367
     int Raw;
Eli Zaretskii's avatar
Eli Zaretskii committed
368 369 370 371 372
{
  __dpmi_regs regs;
  unsigned long xbuf_addr;
  unsigned char *dp = Data;

373
  if (Format != CF_OEMTEXT)
Eli Zaretskii's avatar
Eli Zaretskii committed
374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391 392 393 394
    return 0;

  if (Size == 0)
    return 0;

  if ((xbuf_addr = alloc_xfer_buf (Size)) == 0)
    return 0;

  /* Calls Int 2Fh/AX=1705h with:
		     DX = WinOldAp-Supported Clipboard format
		     ES:BX = Pointer to data buffer to hold data
     Return Values   AX == 0: Error occurred (or data in this format is not
                              in the clipboard)
                        <> 0: OK  */
  regs.x.ax = 0x1705;
  regs.x.dx = Format;
  regs.x.es = xbuf_addr >> 4;
  regs.x.bx = xbuf_addr & 15;
  __dpmi_int(0x2f, &regs);
  if (regs.x.ax != 0)
    {
395 396 397 398 399 400 401 402
      unsigned char null_char = '\0';
      unsigned long xbuf_beg = xbuf_addr;

      /* If last_clipboard_text is NULL, we don't want to slow down
	 the next loop by an additional test.  */
      register unsigned char *lcdp =
	last_clipboard_text == NULL ? &null_char : last_clipboard_text;
	
403 404
      /* Copy data from low memory, remove CR
	 characters before LF if needed.  */
Eli Zaretskii's avatar
Eli Zaretskii committed
405 406 407 408 409
      _farsetsel (_dos_ds);
      while (Size--)
	{
	  register unsigned char c = _farnspeekb (xbuf_addr++);

410 411 412
	  if (*lcdp == c)
	    lcdp++;

413
	  if ((*dp++ = c) == '\r' && !Raw && _farnspeekb (xbuf_addr) == '\n')
Eli Zaretskii's avatar
Eli Zaretskii committed
414 415 416 417
	    {
	      dp--;
	      *dp++ = '\n';
	      xbuf_addr++;
418 419
	      if (*lcdp == '\n')
		lcdp++;
Eli Zaretskii's avatar
Eli Zaretskii committed
420 421
	    }
	  /* Windows reportedly rounds up the size of clipboard data
422 423 424 425
	     (passed in SIZE) to a multiple of 32, and removes trailing
	     spaces from each line without updating SIZE.  We therefore
	     bail out when we see the first null character.  */
	  else if (c == '\0')
426
	    break;
Eli Zaretskii's avatar
Eli Zaretskii committed
427
	}
428 429 430 431

      /* If the text in clipboard is identical to what we put there
	 last time set_clipboard_data was called, pretend there's no
	 data in the clipboard.  This is so we don't pass our own text
432 433
	 from the clipboard (which might be troublesome if the killed
	 text includes null characters).  */
434 435 436
      if (last_clipboard_text &&
	  xbuf_addr - xbuf_beg == (long)(lcdp - last_clipboard_text))
	dp = (unsigned char *)Data + 1;
Eli Zaretskii's avatar
Eli Zaretskii committed
437 438 439 440
    }

  free_xfer_buf ();

441
  return (unsigned) (dp - (unsigned char *)Data - 1);
Eli Zaretskii's avatar
Eli Zaretskii committed
442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469 470 471 472 473 474 475 476 477
}

/* Close clipboard, return non-zero if successfull.  */
unsigned
close_clipboard ()
{
  __dpmi_regs regs;

  /* Calls Int 2Fh/AX=1708h
     Return Values   AX == 0: Error occurred
                        <> 0: OK */
  regs.x.ax = 0x1708;
  __dpmi_int(0x2f, &regs);
  return regs.x.ax;
}

/* Compact clipboard data so that at least SIZE bytes is available.  */
unsigned
clipboard_compact (Size)
     unsigned Size;
{
  __dpmi_regs regs;

  /* Calls Int 2Fh/AX=1709H with:
                     SI:CX = Desired memory size in bytes.
     Return Values   DX:AX == Number of bytes of largest block of free memory.
                           == 0 if error or no memory  */
  regs.x.ax = 0x1709;
  regs.x.si = Size >> 16;
  regs.x.cx = Size & 0xffff;
  __dpmi_int(0x2f, &regs);
  return ((unsigned)regs.x.dx << 16) | regs.x.ax;
}

static char no_mem_msg[] =
  "(Not enough DOS memory to put saved text into clipboard.)";
478 479
static char binary_msg[] =
  "(Binary characters in saved text; clipboard data not set.)";
480 481
static char system_error_msg[] =
  "(Clipboard interface failure; clipboard data not set.)";
Eli Zaretskii's avatar
Eli Zaretskii committed
482

483
DEFUN ("w16-set-clipboard-data", Fw16_set_clipboard_data, Sw16_set_clipboard_data, 1, 2, 0,
Eli Zaretskii's avatar
Eli Zaretskii committed
484 485 486 487
       "This sets the clipboard data to the given text.")
    (string, frame)
    Lisp_Object string, frame;
{
488
  unsigned ok = 1, put_status = 0;
Eli Zaretskii's avatar
Eli Zaretskii committed
489
  int nbytes;
490
  unsigned char *src, *dst = NULL;
491
  int charset_info;
492
  int no_crlf_conversion;
Eli Zaretskii's avatar
Eli Zaretskii committed
493 494 495 496 497 498 499 500 501 502 503 504

  CHECK_STRING (string, 0);
  
  if (NILP (frame))
    frame = Fselected_frame ();

  CHECK_LIVE_FRAME (frame, 0);
  if ( !FRAME_MSDOS_P (XFRAME (frame)))
    goto done;
  
  BLOCK_INPUT;

505
  nbytes = STRING_BYTES (XSTRING (string));
Eli Zaretskii's avatar
Eli Zaretskii committed
506
  src = XSTRING (string)->data;
507 508 509

  /* Since we are now handling multilingual text, we must consider
     encoding text for the clipboard.  */
510 511 512 513
  charset_info = find_charset_in_text (src, XSTRING (string)->size, nbytes,
				       NULL, Qnil);

  if (charset_info == 0)
514 515 516 517 518 519 520 521 522 523 524 525 526
    {
      /* No multibyte character in OBJ.  We need not encode it, but we
	 will have to convert it to DOS CR-LF style.  */
      no_crlf_conversion = 0;
    }
  else
    {
      /* We must encode contents of STRING according to what
	 clipboard-coding-system specifies.  */
      int bufsize;
      struct coding_system coding;
      unsigned char *htext2;

527 528
      if (NILP (Vnext_selection_coding_system))
	Vnext_selection_coding_system = Vselection_coding_system;
529
      setup_coding_system
530
	(Fcheck_coding_system (Vnext_selection_coding_system), &coding);
531 532
      coding.src_multibyte = 1;
      coding.dst_multibyte = 0;
533
      Vnext_selection_coding_system = Qnil;
534 535 536 537 538 539
      coding.mode |= CODING_MODE_LAST_BLOCK;
      Vlast_coding_system_used = coding.symbol;
      bufsize = encoding_buffer_size (&coding, nbytes);
      dst = (unsigned char *) xmalloc (bufsize);
      encode_coding (&coding, src, dst, nbytes, bufsize);
      no_crlf_conversion = 1;
540
      nbytes = coding.produced;
Eli Zaretskii's avatar
Eli Zaretskii committed
541
      src = dst;
542 543
    }

Eli Zaretskii's avatar
Eli Zaretskii committed
544 545 546
  if (!open_clipboard ())
    goto error;
  
547
  ok = empty_clipboard ()
548
    && ((put_status
Eli Zaretskii's avatar
Eli Zaretskii committed
549
	 = set_clipboard_data (CF_OEMTEXT, src, nbytes, no_crlf_conversion))
550
	== 0);
551 552 553

  if (!no_crlf_conversion)
    Vlast_coding_system_used = Qraw_text;
Eli Zaretskii's avatar
Eli Zaretskii committed
554 555
  close_clipboard ();
  
556
  if (ok) goto unblock;
Eli Zaretskii's avatar
Eli Zaretskii committed
557 558 559 560 561

 error:
  
  ok = 0;

562
 unblock:
563 564
  if (dst)
    xfree (dst);
565 566
  UNBLOCK_INPUT;

Eli Zaretskii's avatar
Eli Zaretskii committed
567 568 569 570 571
  /* Notify user if the text is too large to fit into DOS memory.
     (This will happen somewhere after 600K bytes (470K in DJGPP v1.x),
     depending on user system configuration.)  If we just silently
     fail the function, people might wonder why their text sometimes
     doesn't make it to the clipboard.  */
572
  if (put_status)
Eli Zaretskii's avatar
Eli Zaretskii committed
573
    {
574 575 576 577 578 579 580 581
      switch (put_status)
	{
	  case 1:
	    message2 (no_mem_msg, sizeof (no_mem_msg) - 1, 0);
	    break;
	  case 2:
	    message2 (binary_msg, sizeof (binary_msg) - 1, 0);
	    break;
582 583 584
	  case 3:
	    message2 (system_error_msg, sizeof (system_error_msg) - 1, 0);
	    break;
585
	}
586
      sit_for (2, 0, 0, 1, 1);
Eli Zaretskii's avatar
Eli Zaretskii committed
587 588 589 590
    }
  
 done:

591
  return (ok && put_status == 0 ? string : Qnil);
Eli Zaretskii's avatar
Eli Zaretskii committed
592 593
}

594
DEFUN ("w16-get-clipboard-data", Fw16_get_clipboard_data, Sw16_get_clipboard_data, 0, 1, 0,
Eli Zaretskii's avatar
Eli Zaretskii committed
595 596 597 598 599 600 601
       "This gets the clipboard data in text format.")
     (frame)
     Lisp_Object frame;
{
  unsigned data_size, truelen;
  unsigned char *htext;
  Lisp_Object ret = Qnil;
602 603 604
  int no_crlf_conversion;
  int require_encoding = 0;

Eli Zaretskii's avatar
Eli Zaretskii committed
605 606 607 608 609 610 611 612 613 614
  if (NILP (frame))
    frame = Fselected_frame ();

  CHECK_LIVE_FRAME (frame, 0);
  if ( !FRAME_MSDOS_P (XFRAME (frame)))
    goto done;
  
  BLOCK_INPUT;
  
  if (!open_clipboard ())
615
    goto unblock;
Eli Zaretskii's avatar
Eli Zaretskii committed
616

617
  if ((data_size = get_clipboard_data_size (CF_OEMTEXT)) == 0 ||
Eli Zaretskii's avatar
Eli Zaretskii committed
618 619 620 621 622 623
      (htext = (unsigned char *)xmalloc (data_size)) == 0)
    goto closeclip;

  /* need to know final size after '\r' chars are removed because
     we can't change the string size manually, and doing an extra
     copy is silly */
624
  if ((truelen = get_clipboard_data (CF_OEMTEXT, htext, data_size, 0)) == 0)
Eli Zaretskii's avatar
Eli Zaretskii committed
625 626
    goto closeclip;

627
  /* Do we need to decode it?  */
628 629 630 631 632 633 634
  if (
#if 1
      1
#else
      ! NILP (buffer_defaults.enable_multibyte_characters)
#endif
      )
635 636 637 638 639 640 641 642 643 644 645 646 647 648 649 650 651 652 653 654
    {
      /* If the clipboard data contains any 8-bit Latin-1 code, we
	 need to decode it.  */
      int i;

      for (i = 0; i < truelen; i++)
	{
	  if (htext[i] >= 0x80)
	    {
	      require_encoding = 1;
	      break;
	    }
	}
    }
  if (require_encoding)
    {
      int bufsize;
      unsigned char *buf;
      struct coding_system coding;

655 656
      if (NILP (Vnext_selection_coding_system))
	Vnext_selection_coding_system = Vselection_coding_system;
657
      setup_coding_system
658
	(Fcheck_coding_system (Vnext_selection_coding_system), &coding);
659 660
      coding.src_multibyte = 0;
      coding.dst_multibyte = 1;
661
      Vnext_selection_coding_system = Qnil;
662
      coding.mode |= CODING_MODE_LAST_BLOCK;
663
      truelen = get_clipboard_data (CF_OEMTEXT, htext, data_size, 1);
664 665 666
      bufsize = decoding_buffer_size (&coding, truelen);
      buf = (unsigned char *) xmalloc (bufsize);
      decode_coding (&coding, htext, buf, truelen, bufsize);
667 668
      ret = make_string_from_bytes ((char *) buf,
				    coding.produced_char, coding.produced);
669 670 671 672 673 674 675 676 677
      xfree (buf);
      Vlast_coding_system_used = coding.symbol;
    }
  else
    {
      ret = make_unibyte_string ((char *) htext, truelen);
      Vlast_coding_system_used = Qraw_text;
    }

Eli Zaretskii's avatar
Eli Zaretskii committed
678 679 680 681
  xfree (htext);

 closeclip:
  close_clipboard ();
682 683 684

 unblock:
  UNBLOCK_INPUT;
Eli Zaretskii's avatar
Eli Zaretskii committed
685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704 705 706 707 708 709 710 711 712 713 714 715 716
  
 done:
  
  return (ret);
}

/* Support checking for a clipboard selection. */

DEFUN ("x-selection-exists-p", Fx_selection_exists_p, Sx_selection_exists_p,
  0, 1, 0,
  "Whether there is an owner for the given X Selection.\n\
The arg should be the name of the selection in question, typically one of\n\
the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\
\(Those are literal upper-case symbol names, since that's what X expects.)\n\
For convenience, the symbol nil is the same as `PRIMARY',\n\
and t is the same as `SECONDARY'.")
  (selection)
     Lisp_Object selection;
{
  CHECK_SYMBOL (selection, 0);

  /* Return nil for SECONDARY selection.  For PRIMARY (or nil)
     selection, check if there is some text on the kill-ring;
     for CLIPBOARD, check if the clipboard currently has valid
     text format contents.

     The test for killed text on the kill-ring emulates the Emacs
     behavior on X, where killed text is also put into X selection
     by the X interface code.  (On MSDOS, killed text is only put
     into the clipboard if we run under Windows, so we cannot check
     the clipboard alone.)  */
  if ((EQ (selection, Qnil) || EQ (selection, QPRIMARY))
717 718
      && ! NILP (SYMBOL_VALUE (Fintern_soft (build_string ("kill-ring"),
					     Qnil))))
Eli Zaretskii's avatar
Eli Zaretskii committed
719 720 721 722 723 724 725 726
    return Qt;

  if (EQ (selection, QCLIPBOARD))
    {
      Lisp_Object val = Qnil;

      if (open_clipboard ())
	{
727
	  if (get_clipboard_data_size (CF_OEMTEXT))
Eli Zaretskii's avatar
Eli Zaretskii committed
728 729 730 731 732 733 734 735 736 737 738
	    val = Qt;
	  close_clipboard ();
	}
      return val;
    }
  return Qnil;
}

void 
syms_of_win16select ()
{
739 740
  defsubr (&Sw16_set_clipboard_data);
  defsubr (&Sw16_get_clipboard_data);
Eli Zaretskii's avatar
Eli Zaretskii committed
741 742
  defsubr (&Sx_selection_exists_p);

743
  DEFVAR_LISP ("selection-coding-system", &Vselection_coding_system,
744 745 746 747
    "Coding system for communicating with other X clients.\n\
When sending or receiving text via cut_buffer, selection, and clipboard,\n\
the text is encoded or decoded by this coding system.\n\
A default value is `iso-latin-1-dos'");
748
  Vselection_coding_system=intern ("iso-latin-1-dos");
749 750 751 752 753 754 755 756

  DEFVAR_LISP ("next-selection-coding-system", &Vnext_selection_coding_system,
    "Coding system for the next communication with other X clients.\n\
Usually, `selection-coding-system' is used for communicating with\n\
other X clients.   But, if this variable is set, it is used for the\n\
next communication only.   After the communication, this variable is\n\
set to nil.");
  Vnext_selection_coding_system = Qnil;
757

Eli Zaretskii's avatar
Eli Zaretskii committed
758 759 760 761 762
  QPRIMARY   = intern ("PRIMARY");	staticpro (&QPRIMARY);
  QCLIPBOARD = intern ("CLIPBOARD");	staticpro (&QCLIPBOARD);
}

#endif /* MSDOS */