src/w32select.c

/* Selection processing for Emacs on the Microsoft W32 API.
   Copyright (C) 1993, 1994 Free Software Foundation.

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.  */

/* Written by Kevin Gallo */

#include <config.h>
#include "lisp.h"
#include "w32term.h"	/* for all of the w32 includes */
#include "dispextern.h"	/* frame.h seems to want this */
#include "keyboard.h"
#include "frame.h"	/* Need this to get the X window of selected_frame */
#include "blockinput.h"
#include "buffer.h"
#include "charset.h"
#include "coding.h"

Lisp_Object QCLIPBOARD;

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

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

/* 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 = NULL;
static size_t clipboard_storage_size = 0;

#if 0
DEFUN ("w32-open-clipboard", Fw32_open_clipboard, Sw32_open_clipboard, 0, 1, 0,
       doc: /* This opens the clipboard with the given frame pointer.  */)
     (frame)
     Lisp_Object frame;
{
  BOOL ok = FALSE;

  if (!NILP (frame))
    CHECK_LIVE_FRAME (frame);

  BLOCK_INPUT;

  ok = OpenClipboard ((!NILP (frame) && FRAME_W32_P (XFRAME (frame))) ? FRAME_W32_WINDOW (XFRAME (frame)) : NULL);

  UNBLOCK_INPUT;

  return (ok ? frame : Qnil);
}

DEFUN ("w32-empty-clipboard", Fw32_empty_clipboard,
       Sw32_empty_clipboard, 0, 0, 0,
       doc: /* Empty the clipboard.
Assigns ownership of the clipboard to the window which opened it.  */)
     ()
{
  BOOL ok = FALSE;

  BLOCK_INPUT;

  ok = EmptyClipboard ();

  UNBLOCK_INPUT;

  return (ok ? Qt : Qnil);
}

DEFUN ("w32-close-clipboard", Fw32_close_clipboard,
       Sw32_close_clipboard, 0, 0, 0,
       doc: /* Close the clipboard.  */)
     ()
{
  BOOL ok = FALSE;

  BLOCK_INPUT;

  ok = CloseClipboard ();

  UNBLOCK_INPUT;

  return (ok ? Qt : Qnil);
}

#endif

DEFUN ("w32-set-clipboard-data", Fw32_set_clipboard_data,
       Sw32_set_clipboard_data, 1, 2, 0,
       doc: /* This sets the clipboard data to the given text.  */)
    (string, frame)
    Lisp_Object string, frame;
{
  BOOL ok = TRUE;
  HANDLE htext;
  int nbytes;
  int truelen, nlines = 0;
  unsigned char *src;
  unsigned char *dst;

  CHECK_STRING (string);

  if (!NILP (frame))
    CHECK_LIVE_FRAME (frame);

  BLOCK_INPUT;

  nbytes = STRING_BYTES (XSTRING (string)) + 1;
  src = XSTRING (string)->data;
  dst = src;

  /* We need to know how many lines there are, since we need CRLF line
     termination for compatibility with other Windows Programs.
     avoid using strchr because it recomputes the length every time */
  while ((dst = memchr (dst, '\n', nbytes - (dst - src))) != NULL)
    {
      nlines++;
      dst++;
    }

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

    if (charset_info == 0)
      {
	/* No multibyte character in OBJ.  We need not encode it.  */

	/* Need to know final size after CR chars are inserted (the
	   standard CF_TEXT clipboard format uses CRLF line endings,
	   while Emacs uses just LF internally).  */

	truelen = nbytes + nlines;

	if ((htext = GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE, truelen)) == NULL)
	  goto error;

	if ((dst = (unsigned char *) GlobalLock (htext)) == NULL)
	  goto error;

	/* convert to CRLF line endings expected by clipboard */
	while (1)
	  {
	    unsigned char *next;
	    /* copy next line or remaining bytes including '\0' */
	    next = _memccpy (dst, src, '\n', nbytes);
	    if (next)
	      {
		/* copied one line ending with '\n' */
		int copied = next - dst;
		nbytes -= copied;
		src += copied;
		/* insert '\r' before '\n' */
		next[-1] = '\r';
		next[0] = '\n';
		dst = next + 1;
	      }
	    else
	      /* copied remaining partial line -> now finished */
	      break;
	  }

	GlobalUnlock (htext);

	Vlast_coding_system_used = Qraw_text;
      }
    else
      {
	/* We must encode contents of OBJ to the selection coding
           system. */
	int bufsize;
	struct coding_system coding;
	HANDLE htext2;

	if (NILP (Vnext_selection_coding_system))
	  Vnext_selection_coding_system = Vselection_coding_system;
	setup_coding_system
	  (Fcheck_coding_system (Vnext_selection_coding_system), &coding);
	coding.src_multibyte = 1;
	coding.dst_multibyte = 0;
	Vnext_selection_coding_system = Qnil;
	coding.mode |= CODING_MODE_LAST_BLOCK;
	bufsize = encoding_buffer_size (&coding, nbytes);
	if ((htext = GlobalAlloc (GMEM_MOVEABLE | GMEM_DDESHARE, bufsize)) == NULL)
	  goto error;
	if ((dst = (unsigned char *) GlobalLock (htext)) == NULL)
	  goto error;
	encode_coding (&coding, src, dst, nbytes, bufsize);
	Vlast_coding_system_used = coding.symbol;

        /* Stash away the data we are about to put into the clipboard, so we
           could later check inside Fw32_get_clipboard_data whether
           the clipboard still holds our data.  */
        if (clipboard_storage_size < coding.produced)
          {
            clipboard_storage_size = coding.produced + 100;
            last_clipboard_text = (char *) xrealloc (last_clipboard_text,
                                                     clipboard_storage_size);
          }
        if (last_clipboard_text)
          memcpy (last_clipboard_text, dst, coding.produced);

	GlobalUnlock (htext);

	/* Shrink data block to actual size.  */
	htext2 = GlobalReAlloc (htext, coding.produced,
                                GMEM_MOVEABLE | GMEM_DDESHARE);
	if (htext2 != NULL) htext = htext2;
      }
  }

  if (!OpenClipboard ((!NILP (frame) && FRAME_W32_P (XFRAME (frame))) ? FRAME_W32_WINDOW (XFRAME (frame)) : NULL))
    goto error;

  ok = EmptyClipboard () && SetClipboardData (CF_TEXT, htext);

  CloseClipboard ();

  if (ok) goto done;

 error:

  ok = FALSE;
  if (htext) GlobalFree (htext);
  if (last_clipboard_text)
    *last_clipboard_text = '\0';

 done:
  UNBLOCK_INPUT;

  return (ok ? string : Qnil);
}

DEFUN ("w32-get-clipboard-data", Fw32_get_clipboard_data,
       Sw32_get_clipboard_data, 0, 1, 0,
       doc: /* This gets the clipboard data in text format.  */)
     (frame)
     Lisp_Object frame;
{
  HANDLE htext;
  Lisp_Object ret = Qnil;

  if (!NILP (frame))
    CHECK_LIVE_FRAME (frame);

  BLOCK_INPUT;

  if (!OpenClipboard ((!NILP (frame) && FRAME_W32_P (XFRAME (frame))) ? FRAME_W32_WINDOW (XFRAME (frame)) : NULL))
    goto done;

  if ((htext = GetClipboardData (CF_TEXT)) == NULL)
    goto closeclip;

  {
    unsigned char *src;
    unsigned char *dst;
    int nbytes;
    int truelen;
    int require_decoding = 0;

    if ((src = (unsigned char *) GlobalLock (htext)) == NULL)
      goto closeclip;

    nbytes = strlen (src);

    /* If the text in clipboard is identical to what we put there
       last time w32_set_clipboard_data was called, pretend there's no
       data in the clipboard.  This is so we don't pass our own text
       from the clipboard (which might be troublesome if the killed
       text includes null characters).  */
    if (last_clipboard_text
        && clipboard_storage_size >= nbytes
        && memcmp(last_clipboard_text, src, nbytes) == 0)
      goto closeclip;

    if (
#if 1
	1
#else
	! NILP (buffer_defaults.enable_multibyte_characters)
#endif
	)
      {
	/* If the clipboard data contains any non-ascii code, we
	   need to decode it.  */
	int i;

	for (i = 0; i < nbytes; i++)
	  {
	    if (src[i] >= 0x80)
	      {
		require_decoding = 1;
		break;
	      }
	  }
      }

    if (require_decoding)
      {
	int bufsize;
	unsigned char *buf;
	struct coding_system coding;

	if (NILP (Vnext_selection_coding_system))
	  Vnext_selection_coding_system = Vselection_coding_system;
	setup_coding_system
	  (Fcheck_coding_system (Vnext_selection_coding_system), &coding);
	coding.src_multibyte = 0;
	coding.dst_multibyte = 1;
	Vnext_selection_coding_system = Qnil;
	coding.mode |= CODING_MODE_LAST_BLOCK;
	bufsize = decoding_buffer_size (&coding, nbytes);
	buf = (unsigned char *) xmalloc (bufsize);
	decode_coding (&coding, src, buf, nbytes, bufsize);
	Vlast_coding_system_used = coding.symbol;
        ret = make_string_from_bytes ((char *) buf,
                                      coding.produced_char, coding.produced);
	xfree (buf);
      }
    else
      {
	/* Need to know final size after CR chars are removed because we
	   can't change the string size manually, and doing an extra
	   copy is silly.  Note that we only remove CR when it appears
	   as part of CRLF.  */

	truelen = nbytes;
	dst = src;
	/* avoid using strchr because it recomputes the length everytime */
	while ((dst = memchr (dst, '\r', nbytes - (dst - src))) != NULL)
	  {
	    if (dst[1] == '\n')	/* safe because of trailing '\0' */
	      truelen--;
	    dst++;
	  }

	ret = make_uninit_string (truelen);

	/* Convert CRLF line endings (the standard CF_TEXT clipboard
	   format) to LF endings as used internally by Emacs.  */

	dst = XSTRING (ret)->data;
	while (1)
	  {
	    unsigned char *next;
	    /* copy next line or remaining bytes excluding '\0' */
	    next = _memccpy (dst, src, '\r', nbytes);
	    if (next)
	      {
		/* copied one line ending with '\r' */
		int copied = next - dst;
		nbytes -= copied;
		dst += copied;
		src += copied;
		if (*src == '\n')
		  dst--;	/* overwrite '\r' with '\n' */
	      }
	    else
	      /* copied remaining partial line -> now finished */
	      break;
	  }

	Vlast_coding_system_used = Qraw_text;
      }

    GlobalUnlock (htext);
  }

 closeclip:
  CloseClipboard ();

 done:
  UNBLOCK_INPUT;

  return (ret);
}

/* Support checking for a clipboard selection. */

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

  /* Return nil for PRIMARY and SECONDARY selections; for CLIPBOARD, check
     if the clipboard currently has valid text format contents. */

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

      if (OpenClipboard (NULL))
	{
	  int format = 0;
	  while (format = EnumClipboardFormats (format))
	    if (format == CF_TEXT)
	      {
		val = Qt;
		break;
	      }
	  CloseClipboard ();
	}
      return val;
    }
  return Qnil;
}

void
syms_of_w32select ()
{
#if 0
  defsubr (&Sw32_open_clipboard);
  defsubr (&Sw32_empty_clipboard);
  defsubr (&Sw32_close_clipboard);
#endif
  defsubr (&Sw32_set_clipboard_data);
  defsubr (&Sw32_get_clipboard_data);
  defsubr (&Sx_selection_exists_p);

  DEFVAR_LISP ("selection-coding-system", &Vselection_coding_system,
	       doc: /* Coding system for communicating with other programs.
When sending or receiving text via cut_buffer, selection, and clipboard,
the text is encoded or decoded by this coding system.  */);
  Vselection_coding_system=intern ("iso-latin-1-dos");

  DEFVAR_LISP ("next-selection-coding-system", &Vnext_selection_coding_system,
	       doc: /* Coding system for the next communication with other programs.
Usually, `selection-coding-system' is used for communicating with
other programs.   But, if this variable is set, it is used for the
next communication only.   After the communication, this variable is
set to nil.  */);
  Vnext_selection_coding_system = Qnil;

  QCLIPBOARD = intern ("CLIPBOARD");	staticpro (&QCLIPBOARD);
}
Commit	Line	Data
	1	/* Selection processing for Emacs on the Microsoft W32 API.
	2	Copyright (C) 1993, 1994 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	/* Written by Kevin Gallo */
	22
	23	#include <config.h>
	24	#include "lisp.h"
	25	#include "w32term.h" /* for all of the w32 includes */
	26	#include "dispextern.h" /* frame.h seems to want this */
	27	#include "keyboard.h"
	28	#include "frame.h" /* Need this to get the X window of selected_frame */
	29	#include "blockinput.h"
	30	#include "buffer.h"
	31	#include "charset.h"
	32	#include "coding.h"
	33
	34	Lisp_Object QCLIPBOARD;
	35
	36	/* Coding system for communicating with other Windows programs via the
	37	clipboard. */
	38	static Lisp_Object Vselection_coding_system;
	39
	40	/* Coding system for the next communicating with other Windows programs. */
	41	static Lisp_Object Vnext_selection_coding_system;
	42
	43	/* The last text we put into the clipboard. This is used to prevent
	44	passing back our own text from the clipboard, instead of using the
	45	kill ring. The former is undesirable because the clipboard data
	46	could be MULEtilated by inappropriately chosen
	47	(next-)selection-coding-system. For this reason, we must store the
	48	text after it was encoded/Unix-to-DOS-converted. */
	49	static unsigned char *last_clipboard_text = NULL;
	50	static size_t clipboard_storage_size = 0;
	51
	52	#if 0
	53	DEFUN ("w32-open-clipboard", Fw32_open_clipboard, Sw32_open_clipboard, 0, 1, 0,
	54	doc: /* This opens the clipboard with the given frame pointer. */)
	55	(frame)
	56	Lisp_Object frame;
	57	{
	58	BOOL ok = FALSE;
	59
	60	if (!NILP (frame))
	61	CHECK_LIVE_FRAME (frame);
	62
	63	BLOCK_INPUT;
	64
	65	ok = OpenClipboard ((!NILP (frame) && FRAME_W32_P (XFRAME (frame))) ? FRAME_W32_WINDOW (XFRAME (frame)) : NULL);
	66
	67	UNBLOCK_INPUT;
	68
	69	return (ok ? frame : Qnil);
	70	}
	71
	72	DEFUN ("w32-empty-clipboard", Fw32_empty_clipboard,
	73	Sw32_empty_clipboard, 0, 0, 0,
	74	doc: /* Empty the clipboard.
	75	Assigns ownership of the clipboard to the window which opened it. */)
	76	()
	77	{
	78	BOOL ok = FALSE;
	79
	80	BLOCK_INPUT;
	81
	82	ok = EmptyClipboard ();
	83
	84	UNBLOCK_INPUT;
	85
	86	return (ok ? Qt : Qnil);
	87	}
	88
	89	DEFUN ("w32-close-clipboard", Fw32_close_clipboard,
	90	Sw32_close_clipboard, 0, 0, 0,
	91	doc: /* Close the clipboard. */)
	92	()
	93	{
	94	BOOL ok = FALSE;
	95
	96	BLOCK_INPUT;
	97
	98	ok = CloseClipboard ();
	99
	100	UNBLOCK_INPUT;
	101
	102	return (ok ? Qt : Qnil);
	103	}
	104
	105	#endif
	106
	107	DEFUN ("w32-set-clipboard-data", Fw32_set_clipboard_data,
	108	Sw32_set_clipboard_data, 1, 2, 0,
	109	doc: /* This sets the clipboard data to the given text. */)
	110	(string, frame)
	111	Lisp_Object string, frame;
	112	{
	113	BOOL ok = TRUE;
	114	HANDLE htext;
	115	int nbytes;
	116	int truelen, nlines = 0;
	117	unsigned char *src;
	118	unsigned char *dst;
	119
	120	CHECK_STRING (string);
	121
	122	if (!NILP (frame))
	123	CHECK_LIVE_FRAME (frame);
	124
	125	BLOCK_INPUT;
	126
	127	nbytes = STRING_BYTES (XSTRING (string)) + 1;
	128	src = XSTRING (string)->data;
	129	dst = src;
	130
	131	/* We need to know how many lines there are, since we need CRLF line
	132	termination for compatibility with other Windows Programs.
	133	avoid using strchr because it recomputes the length every time */
	134	while ((dst = memchr (dst, '\n', nbytes - (dst - src))) != NULL)
	135	{
	136	nlines++;
	137	dst++;
	138	}
	139
	140	{
	141	/* Since we are now handling multilingual text, we must consider
	142	encoding text for the clipboard. */
	143	int charset_info = find_charset_in_text (src, XSTRING (string)->size,
	144	nbytes, NULL, Qnil);
	145
	146	if (charset_info == 0)
	147	{
	148	/* No multibyte character in OBJ. We need not encode it. */
	149
	150	/* Need to know final size after CR chars are inserted (the
	151	standard CF_TEXT clipboard format uses CRLF line endings,
	152	while Emacs uses just LF internally). */
	153
	154	truelen = nbytes + nlines;
	155
	156	if ((htext = GlobalAlloc (GMEM_MOVEABLE \| GMEM_DDESHARE, truelen)) == NULL)
	157	goto error;
	158
	159	if ((dst = (unsigned char *) GlobalLock (htext)) == NULL)
	160	goto error;
	161
	162	/* convert to CRLF line endings expected by clipboard */
	163	while (1)
	164	{
	165	unsigned char *next;
	166	/* copy next line or remaining bytes including '\0' */
	167	next = _memccpy (dst, src, '\n', nbytes);
	168	if (next)
	169	{
	170	/* copied one line ending with '\n' */
	171	int copied = next - dst;
	172	nbytes -= copied;
	173	src += copied;
	174	/* insert '\r' before '\n' */
	175	next[-1] = '\r';
	176	next[0] = '\n';
	177	dst = next + 1;
	178	}
	179	else
	180	/* copied remaining partial line -> now finished */
	181	break;
	182	}
	183
	184	GlobalUnlock (htext);
	185
	186	Vlast_coding_system_used = Qraw_text;
	187	}
	188	else
	189	{
	190	/* We must encode contents of OBJ to the selection coding
	191	system. */
	192	int bufsize;
	193	struct coding_system coding;
	194	HANDLE htext2;
	195
	196	if (NILP (Vnext_selection_coding_system))
	197	Vnext_selection_coding_system = Vselection_coding_system;
	198	setup_coding_system
	199	(Fcheck_coding_system (Vnext_selection_coding_system), &coding);
	200	coding.src_multibyte = 1;
	201	coding.dst_multibyte = 0;
	202	Vnext_selection_coding_system = Qnil;
	203	coding.mode \|= CODING_MODE_LAST_BLOCK;
	204	bufsize = encoding_buffer_size (&coding, nbytes);
	205	if ((htext = GlobalAlloc (GMEM_MOVEABLE \| GMEM_DDESHARE, bufsize)) == NULL)
	206	goto error;
	207	if ((dst = (unsigned char *) GlobalLock (htext)) == NULL)
	208	goto error;
	209	encode_coding (&coding, src, dst, nbytes, bufsize);
	210	Vlast_coding_system_used = coding.symbol;
	211
	212	/* Stash away the data we are about to put into the clipboard, so we
	213	could later check inside Fw32_get_clipboard_data whether
	214	the clipboard still holds our data. */
	215	if (clipboard_storage_size < coding.produced)
	216	{
	217	clipboard_storage_size = coding.produced + 100;
	218	last_clipboard_text = (char *) xrealloc (last_clipboard_text,
	219	clipboard_storage_size);
	220	}
	221	if (last_clipboard_text)
	222	memcpy (last_clipboard_text, dst, coding.produced);
	223
	224	GlobalUnlock (htext);
	225
	226	/* Shrink data block to actual size. */
	227	htext2 = GlobalReAlloc (htext, coding.produced,
	228	GMEM_MOVEABLE \| GMEM_DDESHARE);
	229	if (htext2 != NULL) htext = htext2;
	230	}
	231	}
	232
	233	if (!OpenClipboard ((!NILP (frame) && FRAME_W32_P (XFRAME (frame))) ? FRAME_W32_WINDOW (XFRAME (frame)) : NULL))
	234	goto error;
	235
	236	ok = EmptyClipboard () && SetClipboardData (CF_TEXT, htext);
	237
	238	CloseClipboard ();
	239
	240	if (ok) goto done;
	241
	242	error:
	243
	244	ok = FALSE;
	245	if (htext) GlobalFree (htext);
	246	if (last_clipboard_text)
	247	*last_clipboard_text = '\0';
	248
	249	done:
	250	UNBLOCK_INPUT;
	251
	252	return (ok ? string : Qnil);
	253	}
	254
	255	DEFUN ("w32-get-clipboard-data", Fw32_get_clipboard_data,
	256	Sw32_get_clipboard_data, 0, 1, 0,
	257	doc: /* This gets the clipboard data in text format. */)
	258	(frame)
	259	Lisp_Object frame;
	260	{
	261	HANDLE htext;
	262	Lisp_Object ret = Qnil;
	263
	264	if (!NILP (frame))
	265	CHECK_LIVE_FRAME (frame);
	266
	267	BLOCK_INPUT;
	268
	269	if (!OpenClipboard ((!NILP (frame) && FRAME_W32_P (XFRAME (frame))) ? FRAME_W32_WINDOW (XFRAME (frame)) : NULL))
	270	goto done;
	271
	272	if ((htext = GetClipboardData (CF_TEXT)) == NULL)
	273	goto closeclip;
	274
	275	{
	276	unsigned char *src;
	277	unsigned char *dst;
	278	int nbytes;
	279	int truelen;
	280	int require_decoding = 0;
	281
	282	if ((src = (unsigned char *) GlobalLock (htext)) == NULL)
	283	goto closeclip;
	284
	285	nbytes = strlen (src);
	286
	287	/* If the text in clipboard is identical to what we put there
	288	last time w32_set_clipboard_data was called, pretend there's no
	289	data in the clipboard. This is so we don't pass our own text
	290	from the clipboard (which might be troublesome if the killed
	291	text includes null characters). */
	292	if (last_clipboard_text
	293	&& clipboard_storage_size >= nbytes
	294	&& memcmp(last_clipboard_text, src, nbytes) == 0)
	295	goto closeclip;
	296
	297	if (
	298	#if 1
	299	1
	300	#else
	301	! NILP (buffer_defaults.enable_multibyte_characters)
	302	#endif
	303	)
	304	{
	305	/* If the clipboard data contains any non-ascii code, we
	306	need to decode it. */
	307	int i;
	308
	309	for (i = 0; i < nbytes; i++)
	310	{
	311	if (src[i] >= 0x80)
	312	{
	313	require_decoding = 1;
	314	break;
	315	}
	316	}
	317	}
	318
	319	if (require_decoding)
	320	{
	321	int bufsize;
	322	unsigned char *buf;
	323	struct coding_system coding;
	324
	325	if (NILP (Vnext_selection_coding_system))
	326	Vnext_selection_coding_system = Vselection_coding_system;
	327	setup_coding_system
	328	(Fcheck_coding_system (Vnext_selection_coding_system), &coding);
	329	coding.src_multibyte = 0;
	330	coding.dst_multibyte = 1;
	331	Vnext_selection_coding_system = Qnil;
	332	coding.mode \|= CODING_MODE_LAST_BLOCK;
	333	bufsize = decoding_buffer_size (&coding, nbytes);
	334	buf = (unsigned char *) xmalloc (bufsize);
	335	decode_coding (&coding, src, buf, nbytes, bufsize);
	336	Vlast_coding_system_used = coding.symbol;
	337	ret = make_string_from_bytes ((char *) buf,
	338	coding.produced_char, coding.produced);
	339	xfree (buf);
	340	}
	341	else
	342	{
	343	/* Need to know final size after CR chars are removed because we
	344	can't change the string size manually, and doing an extra
	345	copy is silly. Note that we only remove CR when it appears
	346	as part of CRLF. */
	347
	348	truelen = nbytes;
	349	dst = src;
	350	/* avoid using strchr because it recomputes the length everytime */
	351	while ((dst = memchr (dst, '\r', nbytes - (dst - src))) != NULL)
	352	{
	353	if (dst[1] == '\n') /* safe because of trailing '\0' */
	354	truelen--;
	355	dst++;
	356	}
	357
	358	ret = make_uninit_string (truelen);
	359
	360	/* Convert CRLF line endings (the standard CF_TEXT clipboard
	361	format) to LF endings as used internally by Emacs. */
	362
	363	dst = XSTRING (ret)->data;
	364	while (1)
	365	{
	366	unsigned char *next;
	367	/* copy next line or remaining bytes excluding '\0' */
	368	next = _memccpy (dst, src, '\r', nbytes);
	369	if (next)
	370	{
	371	/* copied one line ending with '\r' */
	372	int copied = next - dst;
	373	nbytes -= copied;
	374	dst += copied;
	375	src += copied;
	376	if (*src == '\n')
	377	dst--; /* overwrite '\r' with '\n' */
	378	}
	379	else
	380	/* copied remaining partial line -> now finished */
	381	break;
	382	}
	383
	384	Vlast_coding_system_used = Qraw_text;
	385	}
	386
	387	GlobalUnlock (htext);
	388	}
	389
	390	closeclip:
	391	CloseClipboard ();
	392
	393	done:
	394	UNBLOCK_INPUT;
	395
	396	return (ret);
	397	}
	398
	399	/* Support checking for a clipboard selection. */
	400
	401	DEFUN ("x-selection-exists-p", Fx_selection_exists_p, Sx_selection_exists_p,
	402	0, 1, 0,
	403	doc: /* Whether there is an owner for the given X Selection.
	404	The arg should be the name of the selection in question, typically one of
	405	the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.
	406	\(Those are literal upper-case symbol names, since that's what X expects.)
	407	For convenience, the symbol nil is the same as `PRIMARY',
	408	and t is the same as `SECONDARY'. */)
	409	(selection)
	410	Lisp_Object selection;
	411	{
	412	CHECK_SYMBOL (selection);
	413
	414	/* Return nil for PRIMARY and SECONDARY selections; for CLIPBOARD, check
	415	if the clipboard currently has valid text format contents. */
	416
	417	if (EQ (selection, QCLIPBOARD))
	418	{
	419	Lisp_Object val = Qnil;
	420
	421	if (OpenClipboard (NULL))
	422	{
	423	int format = 0;
	424	while (format = EnumClipboardFormats (format))
	425	if (format == CF_TEXT)
	426	{
	427	val = Qt;
	428	break;
	429	}
	430	CloseClipboard ();
	431	}
	432	return val;
	433	}
	434	return Qnil;
	435	}
	436
	437	void
	438	syms_of_w32select ()
	439	{
	440	#if 0
	441	defsubr (&Sw32_open_clipboard);
	442	defsubr (&Sw32_empty_clipboard);
	443	defsubr (&Sw32_close_clipboard);
	444	#endif
	445	defsubr (&Sw32_set_clipboard_data);
	446	defsubr (&Sw32_get_clipboard_data);
	447	defsubr (&Sx_selection_exists_p);
	448
	449	DEFVAR_LISP ("selection-coding-system", &Vselection_coding_system,
	450	doc: /* Coding system for communicating with other programs.
	451	When sending or receiving text via cut_buffer, selection, and clipboard,
	452	the text is encoded or decoded by this coding system. */);
	453	Vselection_coding_system=intern ("iso-latin-1-dos");
	454
	455	DEFVAR_LISP ("next-selection-coding-system", &Vnext_selection_coding_system,
	456	doc: /* Coding system for the next communication with other programs.
	457	Usually, `selection-coding-system' is used for communicating with
	458	other programs. But, if this variable is set, it is used for the
	459	next communication only. After the communication, this variable is
	460	set to nil. */);
	461	Vnext_selection_coding_system = Qnil;
	462
	463	QCLIPBOARD = intern ("CLIPBOARD"); staticpro (&QCLIPBOARD);
	464	}