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 "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 X clients.  */
static Lisp_Object Vnext_selection_coding_system;

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

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

  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,
       "This empties the clipboard and assigns ownership to the window which opened the clipboard.")
     ()
{
  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,
       "This closes 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,
       "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, 0);

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

  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 compound text format.
	   The format is compatible with what the target `STRING'
	   expects if OBJ contains only ASCII and Latin-1
	   characters.  */
	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;
	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);

 done:
  UNBLOCK_INPUT;

  return (ok ? string : Qnil);
}

DEFUN ("w32-get-clipboard-data", Fw32_get_clipboard_data, Sw32_get_clipboard_data, 0, 1, 0,
       "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, 0);

  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 (
#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,
  "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 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,
    "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 `compound-text'");
  Vselection_coding_system=intern ("iso-latin-1-dos");

  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;

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