src/w32select.c

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