21709
|
1 /* 16-bit Windows Selection processing for emacs on MS-Windows
|
39584
|
2 Copyright (C) 1996, 1997, 2001 Free Software Foundation.
|
45333
|
3
|
17451
|
4 This file is part of GNU Emacs.
|
|
5
|
|
6 GNU Emacs is free software; you can redistribute it and/or modify
|
|
7 it under the terms of the GNU General Public License as published by
|
|
8 the Free Software Foundation; either version 2, or (at your option)
|
|
9 any later version.
|
|
10
|
|
11 GNU Emacs is distributed in the hope that it will be useful,
|
|
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
14 GNU General Public License for more details.
|
|
15
|
|
16 You should have received a copy of the GNU General Public License
|
|
17 along with GNU Emacs; see the file COPYING. If not, write to
|
|
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
|
|
19 Boston, MA 02111-1307, USA. */
|
|
20
|
|
21 /* These functions work by using WinOldAp interface. WinOldAp
|
|
22 (WINOLDAP.MOD) is a Microsoft Windows extension supporting
|
|
23 "old" (character-mode) application access to Dynamic Data Exchange,
|
|
24 menus, and the Windows clipboard. */
|
|
25
|
|
26 /* Written by Dale P. Smith <dpsm@en.com> */
|
|
27 /* Adapted to DJGPP v1 by Eli Zaretskii <eliz@is.elta.co.il> */
|
|
28
|
|
29 #ifdef MSDOS
|
|
30
|
|
31 #include <config.h>
|
|
32 #include <string.h>
|
|
33 #include <dpmi.h>
|
|
34 #include <go32.h>
|
|
35 #include <sys/farptr.h>
|
|
36 #include "lisp.h"
|
|
37 #include "dispextern.h" /* frame.h seems to want this */
|
|
38 #include "frame.h" /* Need this to get the X window of selected_frame */
|
|
39 #include "blockinput.h"
|
22729
|
40 #include "buffer.h"
|
|
41 #include "charset.h"
|
|
42 #include "coding.h"
|
45988
|
43 #include "composite.h"
|
17451
|
44
|
|
45 /* If ever some function outside this file will need to call any
|
|
46 clipboard-related function, the following prototypes and constants
|
|
47 should be put on a header file. Right now, nobody else uses them. */
|
|
48
|
|
49 #define CF_TEXT 0x01
|
|
50 #define CF_BITMAP 0x02
|
|
51 #define CF_METAFILE 0x03
|
|
52 #define CF_SYLK 0x04
|
|
53 #define CF_DIF 0x05
|
|
54 #define CF_TIFF 0x06
|
|
55 #define CF_OEMTEXT 0x07
|
|
56 #define CF_DIBBITMAP 0x08
|
|
57 #define CF_WINWRITE 0x80
|
|
58 #define CF_DSPTEXT 0x81
|
|
59 #define CF_DSPBITMAP 0x82
|
|
60
|
|
61 unsigned identify_winoldap_version (void);
|
|
62 unsigned open_clipboard (void);
|
|
63 unsigned empty_clipboard (void);
|
22729
|
64 unsigned set_clipboard_data (unsigned, void *, unsigned, int);
|
17451
|
65 unsigned get_clipboard_data_size (unsigned);
|
22729
|
66 unsigned get_clipboard_data (unsigned, void *, unsigned, int);
|
17451
|
67 unsigned close_clipboard (void);
|
|
68 unsigned clipboard_compact (unsigned);
|
|
69
|
|
70 Lisp_Object QCLIPBOARD, QPRIMARY;
|
|
71
|
22729
|
72 /* Coding system for communicating with other Windows programs via the
|
|
73 clipboard. */
|
22904
37738fa8626a
(Fw16_set_clipboard_data, Fw16_get_clipboard_data, syms_of_win16select):
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
74 static Lisp_Object Vselection_coding_system;
|
22729
|
75
|
23164
|
76 /* Coding system for the next communicating with other Windows programs. */
|
|
77 static Lisp_Object Vnext_selection_coding_system;
|
|
78
|
17451
|
79 /* The segment address and the size of the buffer in low
|
|
80 memory used to move data between us and WinOldAp module. */
|
|
81 static struct {
|
|
82 unsigned long size;
|
|
83 unsigned short rm_segment;
|
|
84 } clipboard_xfer_buf_info;
|
24260
|
85
|
|
86 /* The last text we put into the clipboard. This is used to prevent
|
|
87 passing back our own text from the clipboard, instead of using the
|
|
88 kill ring. The former is undesirable because the clipboard data
|
|
89 could be MULEtilated by inappropriately chosen
|
|
90 (next-)selection-coding-system. For this reason, we must store the
|
|
91 text *after* it was encoded/Unix-to-DOS-converted. */
|
|
92 static unsigned char *last_clipboard_text;
|
|
93
|
|
94 /* The size of allocated storage for storing the clipboard data. */
|
|
95 static size_t clipboard_storage_size;
|
17451
|
96
|
|
97 /* Emulation of `__dpmi_int' and friends for DJGPP v1.x */
|
|
98
|
|
99 #if __DJGPP__ < 2
|
|
100
|
|
101 typedef _go32_dpmi_registers __dpmi_regs;
|
|
102 #define __tb _go32_info_block.linear_address_of_transfer_buffer
|
|
103 #define _dos_ds _go32_info_block.selector_for_linear_memory
|
|
104
|
|
105 static int
|
|
106 __dpmi_int (intno, regs)
|
|
107 int intno;
|
|
108 __dpmi_regs *regs;
|
|
109 {
|
|
110 regs->x.ss = regs->x.sp = regs->x.flags = 0;
|
|
111 return _go32_dpmi_simulate_int (intno, regs);
|
|
112 }
|
|
113
|
|
114 #endif /* __DJGPP__ < 2 */
|
|
115
|
|
116 /* C functions to access the Windows 3.1x clipboard from DOS apps.
|
|
117
|
|
118 The information was obtained from the Microsoft Knowledge Base,
|
|
119 article Q67675 and can be found at:
|
|
120 http://www.microsoft.com/kb/developr/win_dk/q67675.htm */
|
|
121
|
|
122 /* See also Ralf Brown's Interrupt List.
|
|
123
|
|
124 I also seem to remember reading about this in Dr. Dobbs Journal a
|
|
125 while ago, but if you knew my memory... :-)
|
|
126
|
|
127 Dale P. Smith <dpsm@en.com> */
|
|
128
|
|
129 /* Return the WinOldAp support version, or 0x1700 if not supported. */
|
|
130 unsigned
|
|
131 identify_winoldap_version ()
|
|
132 {
|
|
133 __dpmi_regs regs;
|
|
134
|
|
135 /* Calls Int 2Fh/AX=1700h
|
|
136 Return Values AX == 1700H: Clipboard functions not available
|
|
137 <> 1700H: AL = Major version number
|
|
138 AH = Minor version number */
|
|
139 regs.x.ax = 0x1700;
|
|
140 __dpmi_int(0x2f, ®s);
|
|
141 return regs.x.ax;
|
|
142 }
|
|
143
|
|
144 /* Open the clipboard, return non-zero if successfull. */
|
|
145 unsigned
|
|
146 open_clipboard ()
|
|
147 {
|
|
148 __dpmi_regs regs;
|
|
149
|
|
150 /* Is WINOLDAP supported? */
|
|
151 /* Kludge alert!! If WinOldAp is not supported, we return a 0,
|
|
152 which is the same as ``Clipboard already open''. Currently,
|
|
153 this is taken as an error by all the functions that use
|
|
154 `open_clipboard', but if somebody someday will use that ``open''
|
|
155 clipboard, they will have interesting time debugging it... */
|
|
156 if (identify_winoldap_version () == 0x1700)
|
|
157 return 0;
|
|
158
|
|
159 /* Calls Int 2Fh/AX=1701h
|
|
160 Return Values AX == 0: Clipboard already open
|
|
161 <> 0: Clipboard opened */
|
|
162 regs.x.ax = 0x1701;
|
|
163 __dpmi_int(0x2f, ®s);
|
|
164 return regs.x.ax;
|
|
165 }
|
|
166
|
|
167 /* Empty clipboard, return non-zero if successfull. */
|
|
168 unsigned
|
|
169 empty_clipboard ()
|
|
170 {
|
|
171 __dpmi_regs regs;
|
45333
|
172
|
17451
|
173 /* Calls Int 2Fh/AX=1702h
|
|
174 Return Values AX == 0: Error occurred
|
|
175 <> 0: OK, Clipboard emptied */
|
|
176 regs.x.ax = 0x1702;
|
|
177 __dpmi_int(0x2f, ®s);
|
|
178 return regs.x.ax;
|
|
179 }
|
|
180
|
|
181 /* Ensure we have a buffer in low memory with enough memory for data
|
|
182 of size WANT_SIZE. Return the linear address of the buffer. */
|
|
183 static unsigned long
|
|
184 alloc_xfer_buf (want_size)
|
|
185 unsigned want_size;
|
|
186 {
|
|
187 __dpmi_regs regs;
|
|
188
|
|
189 /* If the usual DJGPP transfer buffer is large enough, use that. */
|
|
190 if (want_size <= _go32_info_block.size_of_transfer_buffer)
|
|
191 return __tb & 0xfffff;
|
|
192
|
21709
|
193 /* Don't even try to allocate more than 1MB of memory: DOS cannot
|
|
194 possibly handle that (it will overflow the BX register below). */
|
|
195 if (want_size > 0xfffff)
|
|
196 return 0;
|
|
197
|
17451
|
198 /* Need size rounded up to the nearest paragraph, and in
|
|
199 paragraph units (1 paragraph = 16 bytes). */
|
|
200 clipboard_xfer_buf_info.size = (want_size + 15) >> 4;
|
|
201
|
|
202 /* The NT DPMI host crashes us if we free DOS memory via the
|
|
203 DPMI service. Work around by calling DOS allocate/free block. */
|
|
204 regs.h.ah = 0x48;
|
|
205 regs.x.bx = clipboard_xfer_buf_info.size;
|
|
206 __dpmi_int (0x21, ®s);
|
|
207 if (regs.x.flags & 1)
|
|
208 {
|
|
209 clipboard_xfer_buf_info.size = 0;
|
|
210 return 0;
|
|
211 }
|
|
212
|
|
213 clipboard_xfer_buf_info.rm_segment = regs.x.ax;
|
|
214 return (((int)clipboard_xfer_buf_info.rm_segment) << 4) & 0xfffff;
|
|
215 }
|
|
216
|
|
217 /* Free our clipboard buffer. We always free it after use, because
|
|
218 keeping it leaves less free conventional memory for subprocesses.
|
|
219 The clipboard buffer tends to be large in size, because for small
|
|
220 clipboard data sizes we use the DJGPP transfer buffer. */
|
|
221 static void
|
|
222 free_xfer_buf ()
|
|
223 {
|
|
224 /* If the size is 0, we used DJGPP transfer buffer, so don't free. */
|
|
225 if (clipboard_xfer_buf_info.size)
|
|
226 {
|
|
227 __dpmi_regs regs;
|
|
228
|
|
229 /* The NT DPMI host crashes us if we free DOS memory via
|
|
230 the DPMI service. Work around by calling DOS free block. */
|
|
231 regs.h.ah = 0x49;
|
|
232 regs.x.es = clipboard_xfer_buf_info.rm_segment;
|
|
233 __dpmi_int (0x21, ®s);
|
|
234 clipboard_xfer_buf_info.size = 0;
|
|
235 }
|
|
236 }
|
|
237
|
24003
|
238 /* Copy data into the clipboard, return zero if successfull. */
|
17451
|
239 unsigned
|
22729
|
240 set_clipboard_data (Format, Data, Size, Raw)
|
17451
|
241 unsigned Format;
|
|
242 void *Data;
|
|
243 unsigned Size;
|
22729
|
244 int Raw;
|
17451
|
245 {
|
|
246 __dpmi_regs regs;
|
|
247 unsigned truelen;
|
|
248 unsigned long xbuf_addr, buf_offset;
|
|
249 unsigned char *dp = Data, *dstart = dp;
|
|
250
|
22749
|
251 if (Format != CF_OEMTEXT)
|
30900
|
252 return 3;
|
17451
|
253
|
|
254 /* need to know final size after '\r' chars are inserted (the
|
22749
|
255 standard CF_OEMTEXT clipboard format uses CRLF line endings,
|
17451
|
256 while Emacs uses just LF internally). */
|
24003
|
257 truelen = Size + 1; /* +1 for the terminating null */
|
22729
|
258
|
|
259 if (!Raw)
|
17451
|
260 {
|
22729
|
261 /* avoid using strchr because it recomputes the length everytime */
|
|
262 while ((dp = memchr (dp, '\n', Size - (dp - dstart))) != 0)
|
|
263 {
|
|
264 truelen++;
|
|
265 dp++;
|
|
266 }
|
17451
|
267 }
|
|
268
|
|
269 if (clipboard_compact (truelen) < truelen)
|
30900
|
270 return 1;
|
17451
|
271
|
|
272 if ((xbuf_addr = alloc_xfer_buf (truelen)) == 0)
|
30900
|
273 return 1;
|
17451
|
274
|
22729
|
275 /* Move the buffer into the low memory, convert LF into CR-LF if needed. */
|
|
276 if (Raw)
|
24251
|
277 {
|
|
278 dosmemput (Data, Size, xbuf_addr);
|
|
279
|
|
280 /* Terminate with a null, otherwise Windows does strange things
|
|
281 when the text size is an integral multiple of 32 bytes. */
|
|
282 _farpokeb (_dos_ds, xbuf_addr + Size, '\0');
|
|
283 }
|
22729
|
284 else
|
17451
|
285 {
|
22729
|
286 dp = Data;
|
|
287 buf_offset = xbuf_addr;
|
|
288 _farsetsel (_dos_ds);
|
|
289 while (Size--)
|
|
290 {
|
24003
|
291 /* Don't allow them to put binary data into the clipboard, since
|
|
292 it will cause yanked data to be truncated at the first null. */
|
|
293 if (*dp == '\0')
|
|
294 return 2;
|
22729
|
295 if (*dp == '\n')
|
|
296 _farnspokeb (buf_offset++, '\r');
|
|
297 _farnspokeb (buf_offset++, *dp++);
|
|
298 }
|
24251
|
299
|
|
300 /* Terminate with a null, otherwise Windows does strange things
|
|
301 when the text size is an integral multiple of 32 bytes. */
|
|
302 _farnspokeb (buf_offset, '\0');
|
17451
|
303 }
|
|
304
|
24260
|
305 /* Stash away the data we are about to put into the clipboard, so we
|
|
306 could later check inside get_clipboard_data whether the clipboard
|
|
307 still holds our data. */
|
|
308 if (clipboard_storage_size < truelen)
|
|
309 {
|
|
310 clipboard_storage_size = truelen + 100;
|
|
311 last_clipboard_text =
|
|
312 (char *) xrealloc (last_clipboard_text, clipboard_storage_size);
|
|
313 }
|
|
314 if (last_clipboard_text)
|
|
315 dosmemget (xbuf_addr, truelen, last_clipboard_text);
|
|
316
|
17451
|
317 /* Calls Int 2Fh/AX=1703h with:
|
|
318 DX = WinOldAp-Supported Clipboard format
|
|
319 ES:BX = Pointer to data
|
|
320 SI:CX = Size of data in bytes
|
|
321 Return Values AX == 0: Error occurred
|
|
322 <> 0: OK. Data copied into the Clipboard. */
|
|
323 regs.x.ax = 0x1703;
|
|
324 regs.x.dx = Format;
|
|
325 regs.x.si = truelen >> 16;
|
|
326 regs.x.cx = truelen & 0xffff;
|
|
327 regs.x.es = xbuf_addr >> 4;
|
|
328 regs.x.bx = xbuf_addr & 15;
|
|
329 __dpmi_int(0x2f, ®s);
|
|
330
|
|
331 free_xfer_buf ();
|
|
332
|
24260
|
333 /* If the above failed, invalidate the local copy of the clipboard. */
|
|
334 if (regs.x.ax == 0)
|
|
335 *last_clipboard_text = '\0';
|
|
336
|
30900
|
337 /* Zero means success, otherwise (1, 2, or 3) it's an error. */
|
|
338 return regs.x.ax > 0 ? 0 : 3;
|
17451
|
339 }
|
|
340
|
|
341 /* Return the size of the clipboard data of format FORMAT. */
|
|
342 unsigned
|
|
343 get_clipboard_data_size (Format)
|
|
344 unsigned Format;
|
|
345 {
|
|
346 __dpmi_regs regs;
|
|
347
|
|
348 /* Calls Int 2Fh/AX=1704h with:
|
|
349 DX = WinOldAp-Supported Clipboard format
|
|
350 Return Values DX:AX == Size of the data in bytes, including any
|
|
351 headers.
|
|
352 == 0 If data in this format is not in
|
|
353 the clipboard. */
|
|
354 regs.x.ax = 0x1704;
|
|
355 regs.x.dx = Format;
|
|
356 __dpmi_int(0x2f, ®s);
|
|
357 return ( (((unsigned)regs.x.dx) << 16) | regs.x.ax);
|
|
358 }
|
|
359
|
|
360 /* Get clipboard data, return its length.
|
|
361 Warning: this doesn't check whether DATA has enough space to hold
|
|
362 SIZE bytes. */
|
|
363 unsigned
|
22729
|
364 get_clipboard_data (Format, Data, Size, Raw)
|
17451
|
365 unsigned Format;
|
|
366 void *Data;
|
|
367 unsigned Size;
|
22729
|
368 int Raw;
|
17451
|
369 {
|
|
370 __dpmi_regs regs;
|
|
371 unsigned long xbuf_addr;
|
|
372 unsigned char *dp = Data;
|
|
373
|
22749
|
374 if (Format != CF_OEMTEXT)
|
17451
|
375 return 0;
|
|
376
|
|
377 if (Size == 0)
|
|
378 return 0;
|
|
379
|
|
380 if ((xbuf_addr = alloc_xfer_buf (Size)) == 0)
|
|
381 return 0;
|
|
382
|
|
383 /* Calls Int 2Fh/AX=1705h with:
|
|
384 DX = WinOldAp-Supported Clipboard format
|
|
385 ES:BX = Pointer to data buffer to hold data
|
|
386 Return Values AX == 0: Error occurred (or data in this format is not
|
|
387 in the clipboard)
|
|
388 <> 0: OK */
|
|
389 regs.x.ax = 0x1705;
|
|
390 regs.x.dx = Format;
|
|
391 regs.x.es = xbuf_addr >> 4;
|
|
392 regs.x.bx = xbuf_addr & 15;
|
|
393 __dpmi_int(0x2f, ®s);
|
|
394 if (regs.x.ax != 0)
|
|
395 {
|
24260
|
396 unsigned char null_char = '\0';
|
|
397 unsigned long xbuf_beg = xbuf_addr;
|
|
398
|
|
399 /* If last_clipboard_text is NULL, we don't want to slow down
|
|
400 the next loop by an additional test. */
|
|
401 register unsigned char *lcdp =
|
|
402 last_clipboard_text == NULL ? &null_char : last_clipboard_text;
|
45333
|
403
|
22729
|
404 /* Copy data from low memory, remove CR
|
|
405 characters before LF if needed. */
|
17451
|
406 _farsetsel (_dos_ds);
|
|
407 while (Size--)
|
|
408 {
|
|
409 register unsigned char c = _farnspeekb (xbuf_addr++);
|
|
410
|
24260
|
411 if (*lcdp == c)
|
|
412 lcdp++;
|
|
413
|
22729
|
414 if ((*dp++ = c) == '\r' && !Raw && _farnspeekb (xbuf_addr) == '\n')
|
17451
|
415 {
|
|
416 dp--;
|
|
417 *dp++ = '\n';
|
|
418 xbuf_addr++;
|
24260
|
419 if (*lcdp == '\n')
|
|
420 lcdp++;
|
17451
|
421 }
|
|
422 /* Windows reportedly rounds up the size of clipboard data
|
24428
|
423 (passed in SIZE) to a multiple of 32, and removes trailing
|
|
424 spaces from each line without updating SIZE. We therefore
|
|
425 bail out when we see the first null character. */
|
|
426 else if (c == '\0')
|
24003
|
427 break;
|
17451
|
428 }
|
24260
|
429
|
|
430 /* If the text in clipboard is identical to what we put there
|
|
431 last time set_clipboard_data was called, pretend there's no
|
|
432 data in the clipboard. This is so we don't pass our own text
|
24428
|
433 from the clipboard (which might be troublesome if the killed
|
|
434 text includes null characters). */
|
24260
|
435 if (last_clipboard_text &&
|
|
436 xbuf_addr - xbuf_beg == (long)(lcdp - last_clipboard_text))
|
|
437 dp = (unsigned char *)Data + 1;
|
17451
|
438 }
|
|
439
|
|
440 free_xfer_buf ();
|
|
441
|
24003
|
442 return (unsigned) (dp - (unsigned char *)Data - 1);
|
17451
|
443 }
|
|
444
|
|
445 /* Close clipboard, return non-zero if successfull. */
|
|
446 unsigned
|
|
447 close_clipboard ()
|
|
448 {
|
|
449 __dpmi_regs regs;
|
|
450
|
|
451 /* Calls Int 2Fh/AX=1708h
|
|
452 Return Values AX == 0: Error occurred
|
|
453 <> 0: OK */
|
|
454 regs.x.ax = 0x1708;
|
|
455 __dpmi_int(0x2f, ®s);
|
|
456 return regs.x.ax;
|
|
457 }
|
|
458
|
|
459 /* Compact clipboard data so that at least SIZE bytes is available. */
|
|
460 unsigned
|
|
461 clipboard_compact (Size)
|
|
462 unsigned Size;
|
|
463 {
|
|
464 __dpmi_regs regs;
|
|
465
|
|
466 /* Calls Int 2Fh/AX=1709H with:
|
|
467 SI:CX = Desired memory size in bytes.
|
|
468 Return Values DX:AX == Number of bytes of largest block of free memory.
|
|
469 == 0 if error or no memory */
|
|
470 regs.x.ax = 0x1709;
|
|
471 regs.x.si = Size >> 16;
|
|
472 regs.x.cx = Size & 0xffff;
|
|
473 __dpmi_int(0x2f, ®s);
|
|
474 return ((unsigned)regs.x.dx << 16) | regs.x.ax;
|
|
475 }
|
|
476
|
|
477 static char no_mem_msg[] =
|
|
478 "(Not enough DOS memory to put saved text into clipboard.)";
|
24003
|
479 static char binary_msg[] =
|
|
480 "(Binary characters in saved text; clipboard data not set.)";
|
30900
|
481 static char system_error_msg[] =
|
|
482 "(Clipboard interface failure; clipboard data not set.)";
|
17451
|
483
|
21709
|
484 DEFUN ("w16-set-clipboard-data", Fw16_set_clipboard_data, Sw16_set_clipboard_data, 1, 2, 0,
|
41940
|
485 doc: /* This sets the clipboard data to the given text. */)
|
|
486 (string, frame)
|
|
487 Lisp_Object string, frame;
|
17451
|
488 {
|
24003
|
489 unsigned ok = 1, put_status = 0;
|
45333
|
490 int nbytes, charset_info, no_crlf_conversion;
|
22729
|
491 unsigned char *src, *dst = NULL;
|
17451
|
492
|
40656
|
493 CHECK_STRING (string);
|
43460
|
494
|
17451
|
495 if (NILP (frame))
|
|
496 frame = Fselected_frame ();
|
|
497
|
40656
|
498 CHECK_LIVE_FRAME (frame);
|
17451
|
499 if ( !FRAME_MSDOS_P (XFRAME (frame)))
|
|
500 goto done;
|
43460
|
501
|
17451
|
502 BLOCK_INPUT;
|
|
503
|
46370
40db0673e6f0
Most uses of XSTRING combined with STRING_BYTES or indirection changed to
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
504 nbytes = SBYTES (string);
|
40db0673e6f0
Most uses of XSTRING combined with STRING_BYTES or indirection changed to
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
505 src = SDATA (string);
|
22729
|
506
|
|
507 /* Since we are now handling multilingual text, we must consider
|
|
508 encoding text for the clipboard. */
|
46370
40db0673e6f0
Most uses of XSTRING combined with STRING_BYTES or indirection changed to
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
509 charset_info = find_charset_in_text (src, SCHARS (string), nbytes,
|
29020
|
510 NULL, Qnil);
|
22729
|
511
|
29020
|
512 if (charset_info == 0)
|
22729
|
513 {
|
|
514 /* No multibyte character in OBJ. We need not encode it, but we
|
|
515 will have to convert it to DOS CR-LF style. */
|
|
516 no_crlf_conversion = 0;
|
|
517 }
|
|
518 else
|
|
519 {
|
|
520 /* We must encode contents of STRING according to what
|
|
521 clipboard-coding-system specifies. */
|
|
522 int bufsize;
|
|
523 struct coding_system coding;
|
|
524 unsigned char *htext2;
|
|
525
|
23164
|
526 if (NILP (Vnext_selection_coding_system))
|
|
527 Vnext_selection_coding_system = Vselection_coding_system;
|
22729
|
528 setup_coding_system
|
23164
|
529 (Fcheck_coding_system (Vnext_selection_coding_system), &coding);
|
43460
|
530 if (SYMBOLP (coding.pre_write_conversion)
|
|
531 && !NILP (Ffboundp (coding.pre_write_conversion)))
|
|
532 {
|
|
533 string = run_pre_post_conversion_on_str (string, &coding, 1);
|
46370
40db0673e6f0
Most uses of XSTRING combined with STRING_BYTES or indirection changed to
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
534 src = SDATA (string);
|
40db0673e6f0
Most uses of XSTRING combined with STRING_BYTES or indirection changed to
Ken Raeburn <raeburn@raeburn.org>
diff
changeset
|
535 nbytes = SBYTES (string);
|
43460
|
536 }
|
29179
|
537 coding.src_multibyte = 1;
|
|
538 coding.dst_multibyte = 0;
|
23164
|
539 Vnext_selection_coding_system = Qnil;
|
22729
|
540 coding.mode |= CODING_MODE_LAST_BLOCK;
|
|
541 Vlast_coding_system_used = coding.symbol;
|
|
542 bufsize = encoding_buffer_size (&coding, nbytes);
|
|
543 dst = (unsigned char *) xmalloc (bufsize);
|
|
544 encode_coding (&coding, src, dst, nbytes, bufsize);
|
|
545 no_crlf_conversion = 1;
|
24257
|
546 nbytes = coding.produced;
|
24258
|
547 src = dst;
|
22729
|
548 }
|
|
549
|
17451
|
550 if (!open_clipboard ())
|
|
551 goto error;
|
43460
|
552
|
22729
|
553 ok = empty_clipboard ()
|
24003
|
554 && ((put_status
|
24258
|
555 = set_clipboard_data (CF_OEMTEXT, src, nbytes, no_crlf_conversion))
|
24003
|
556 == 0);
|
22729
|
557
|
|
558 if (!no_crlf_conversion)
|
|
559 Vlast_coding_system_used = Qraw_text;
|
17451
|
560 close_clipboard ();
|
43460
|
561
|
21707
7b76832ac019
(Fwin16_set_clipboard_data): Call UNBLOCK_INPUT before calling sit_for.
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
562 if (ok) goto unblock;
|
17451
|
563
|
|
564 error:
|
43460
|
565
|
17451
|
566 ok = 0;
|
|
567
|
21707
7b76832ac019
(Fwin16_set_clipboard_data): Call UNBLOCK_INPUT before calling sit_for.
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
568 unblock:
|
22729
|
569 if (dst)
|
|
570 xfree (dst);
|
21707
7b76832ac019
(Fwin16_set_clipboard_data): Call UNBLOCK_INPUT before calling sit_for.
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
571 UNBLOCK_INPUT;
|
7b76832ac019
(Fwin16_set_clipboard_data): Call UNBLOCK_INPUT before calling sit_for.
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
572
|
17451
|
573 /* Notify user if the text is too large to fit into DOS memory.
|
|
574 (This will happen somewhere after 600K bytes (470K in DJGPP v1.x),
|
|
575 depending on user system configuration.) If we just silently
|
|
576 fail the function, people might wonder why their text sometimes
|
|
577 doesn't make it to the clipboard. */
|
24003
|
578 if (put_status)
|
17451
|
579 {
|
24003
|
580 switch (put_status)
|
|
581 {
|
|
582 case 1:
|
|
583 message2 (no_mem_msg, sizeof (no_mem_msg) - 1, 0);
|
|
584 break;
|
|
585 case 2:
|
|
586 message2 (binary_msg, sizeof (binary_msg) - 1, 0);
|
|
587 break;
|
30900
|
588 case 3:
|
|
589 message2 (system_error_msg, sizeof (system_error_msg) - 1, 0);
|
|
590 break;
|
24003
|
591 }
|
17960
|
592 sit_for (2, 0, 0, 1, 1);
|
17451
|
593 }
|
43460
|
594
|
17451
|
595 done:
|
|
596
|
24003
|
597 return (ok && put_status == 0 ? string : Qnil);
|
17451
|
598 }
|
|
599
|
21709
|
600 DEFUN ("w16-get-clipboard-data", Fw16_get_clipboard_data, Sw16_get_clipboard_data, 0, 1, 0,
|
41940
|
601 doc: /* This gets the clipboard data in text format. */)
|
17451
|
602 (frame)
|
|
603 Lisp_Object frame;
|
|
604 {
|
|
605 unsigned data_size, truelen;
|
|
606 unsigned char *htext;
|
|
607 Lisp_Object ret = Qnil;
|
45333
|
608 int no_crlf_conversion, require_encoding = 0;
|
22729
|
609
|
17451
|
610 if (NILP (frame))
|
|
611 frame = Fselected_frame ();
|
|
612
|
40656
|
613 CHECK_LIVE_FRAME (frame);
|
17451
|
614 if ( !FRAME_MSDOS_P (XFRAME (frame)))
|
|
615 goto done;
|
43460
|
616
|
17451
|
617 BLOCK_INPUT;
|
43460
|
618
|
17451
|
619 if (!open_clipboard ())
|
21707
7b76832ac019
(Fwin16_set_clipboard_data): Call UNBLOCK_INPUT before calling sit_for.
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
620 goto unblock;
|
17451
|
621
|
22749
|
622 if ((data_size = get_clipboard_data_size (CF_OEMTEXT)) == 0 ||
|
17451
|
623 (htext = (unsigned char *)xmalloc (data_size)) == 0)
|
|
624 goto closeclip;
|
|
625
|
|
626 /* need to know final size after '\r' chars are removed because
|
|
627 we can't change the string size manually, and doing an extra
|
|
628 copy is silly */
|
22749
|
629 if ((truelen = get_clipboard_data (CF_OEMTEXT, htext, data_size, 0)) == 0)
|
17451
|
630 goto closeclip;
|
|
631
|
22729
|
632 /* Do we need to decode it? */
|
43460
|
633 {
|
|
634 /* If the clipboard data contains any 8-bit Latin-1 code, we
|
|
635 need to decode it. */
|
|
636 int i;
|
22729
|
637
|
43460
|
638 for (i = 0; i < truelen; i++)
|
|
639 {
|
|
640 if (htext[i] >= 0x80)
|
|
641 {
|
|
642 require_encoding = 1;
|
|
643 break;
|
|
644 }
|
|
645 }
|
|
646 }
|
22729
|
647 if (require_encoding)
|
|
648 {
|
|
649 int bufsize;
|
|
650 unsigned char *buf;
|
|
651 struct coding_system coding;
|
|
652
|
23164
|
653 if (NILP (Vnext_selection_coding_system))
|
|
654 Vnext_selection_coding_system = Vselection_coding_system;
|
22729
|
655 setup_coding_system
|
23164
|
656 (Fcheck_coding_system (Vnext_selection_coding_system), &coding);
|
29020
|
657 coding.src_multibyte = 0;
|
|
658 coding.dst_multibyte = 1;
|
23164
|
659 Vnext_selection_coding_system = Qnil;
|
22729
|
660 coding.mode |= CODING_MODE_LAST_BLOCK;
|
45982
|
661 /* We explicitely disable composition handling because selection
|
|
662 data should not contain any composition sequence. */
|
|
663 coding.composing = COMPOSITION_DISABLED;
|
22749
|
664 truelen = get_clipboard_data (CF_OEMTEXT, htext, data_size, 1);
|
22729
|
665 bufsize = decoding_buffer_size (&coding, truelen);
|
|
666 buf = (unsigned char *) xmalloc (bufsize);
|
|
667 decode_coding (&coding, htext, buf, truelen, bufsize);
|
29020
|
668 ret = make_string_from_bytes ((char *) buf,
|
|
669 coding.produced_char, coding.produced);
|
22729
|
670 xfree (buf);
|
43460
|
671 if (SYMBOLP (coding.post_read_conversion)
|
|
672 && !NILP (Ffboundp (coding.post_read_conversion)))
|
43475
|
673 ret = run_pre_post_conversion_on_str (ret, &coding, 0);
|
22729
|
674 Vlast_coding_system_used = coding.symbol;
|
|
675 }
|
|
676 else
|
|
677 {
|
|
678 ret = make_unibyte_string ((char *) htext, truelen);
|
|
679 Vlast_coding_system_used = Qraw_text;
|
|
680 }
|
|
681
|
17451
|
682 xfree (htext);
|
|
683
|
|
684 closeclip:
|
|
685 close_clipboard ();
|
21707
7b76832ac019
(Fwin16_set_clipboard_data): Call UNBLOCK_INPUT before calling sit_for.
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
686
|
7b76832ac019
(Fwin16_set_clipboard_data): Call UNBLOCK_INPUT before calling sit_for.
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
687 unblock:
|
7b76832ac019
(Fwin16_set_clipboard_data): Call UNBLOCK_INPUT before calling sit_for.
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
688 UNBLOCK_INPUT;
|
45333
|
689
|
17451
|
690 done:
|
45333
|
691
|
17451
|
692 return (ret);
|
|
693 }
|
|
694
|
|
695 /* Support checking for a clipboard selection. */
|
|
696
|
|
697 DEFUN ("x-selection-exists-p", Fx_selection_exists_p, Sx_selection_exists_p,
|
41940
|
698 0, 1, 0,
|
|
699 doc: /* Whether there is an owner for the given X Selection.
|
|
700 The arg should be the name of the selection in question, typically one of
|
|
701 the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.
|
|
702 \(Those are literal upper-case symbol names, since that's what X expects.)
|
|
703 For convenience, the symbol nil is the same as `PRIMARY',
|
|
704 and t is the same as `SECONDARY'. */)
|
|
705 (selection)
|
17451
|
706 Lisp_Object selection;
|
|
707 {
|
40656
|
708 CHECK_SYMBOL (selection);
|
17451
|
709
|
|
710 /* Return nil for SECONDARY selection. For PRIMARY (or nil)
|
|
711 selection, check if there is some text on the kill-ring;
|
|
712 for CLIPBOARD, check if the clipboard currently has valid
|
|
713 text format contents.
|
|
714
|
|
715 The test for killed text on the kill-ring emulates the Emacs
|
|
716 behavior on X, where killed text is also put into X selection
|
|
717 by the X interface code. (On MSDOS, killed text is only put
|
|
718 into the clipboard if we run under Windows, so we cannot check
|
|
719 the clipboard alone.) */
|
|
720 if ((EQ (selection, Qnil) || EQ (selection, QPRIMARY))
|
39584
|
721 && ! NILP (SYMBOL_VALUE (Fintern_soft (build_string ("kill-ring"),
|
|
722 Qnil))))
|
17451
|
723 return Qt;
|
|
724
|
|
725 if (EQ (selection, QCLIPBOARD))
|
|
726 {
|
|
727 Lisp_Object val = Qnil;
|
|
728
|
|
729 if (open_clipboard ())
|
|
730 {
|
22749
|
731 if (get_clipboard_data_size (CF_OEMTEXT))
|
17451
|
732 val = Qt;
|
|
733 close_clipboard ();
|
|
734 }
|
|
735 return val;
|
|
736 }
|
|
737 return Qnil;
|
|
738 }
|
|
739
|
45333
|
740 void
|
17451
|
741 syms_of_win16select ()
|
|
742 {
|
21709
|
743 defsubr (&Sw16_set_clipboard_data);
|
|
744 defsubr (&Sw16_get_clipboard_data);
|
17451
|
745 defsubr (&Sx_selection_exists_p);
|
|
746
|
22904
37738fa8626a
(Fw16_set_clipboard_data, Fw16_get_clipboard_data, syms_of_win16select):
Eli Zaretskii <eliz@gnu.org>
diff
changeset
|
747 DEFVAR_LISP ("selection-coding-system", &Vselection_coding_system,
|
41940
|
748 doc: /* Coding system for communicating with other X clients.
|
|
749 When sending or receiving text via cut_buffer, selection, and clipboard,
|
|
750 the text is encoded or decoded by this coding system.
|
47878
be195e2a4bfb
(syms_of_win16select): Fix docstring for `selection-coding-system'.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
751 The default value is `iso-latin-1-dos'. */);
|
be195e2a4bfb
(syms_of_win16select): Fix docstring for `selection-coding-system'.
Juanma Barranquero <lekktu@gmail.com>
diff
changeset
|
752 Vselection_coding_system = intern ("iso-latin-1-dos");
|
23164
|
753
|
|
754 DEFVAR_LISP ("next-selection-coding-system", &Vnext_selection_coding_system,
|
41940
|
755 doc: /* Coding system for the next communication with other X clients.
|
|
756 Usually, `selection-coding-system' is used for communicating with
|
47279
|
757 other X clients. But, if this variable is set, it is used for the
|
|
758 next communication only. After the communication, this variable is
|
41940
|
759 set to nil. */);
|
23164
|
760 Vnext_selection_coding_system = Qnil;
|
22729
|
761
|
17451
|
762 QPRIMARY = intern ("PRIMARY"); staticpro (&QPRIMARY);
|
|
763 QCLIPBOARD = intern ("CLIPBOARD"); staticpro (&QCLIPBOARD);
|
|
764 }
|
|
765
|
|
766 #endif /* MSDOS */
|
52401
|
767
|
|
768 /* arch-tag: 085a22c8-7324-436e-a6da-102464ce95d8
|
|
769 (do not change this comment) */
|