Commit | Line | Data |
---|---|---|
767079a8 | 1 | /* 16-bit Windows Selection processing for emacs on MS-Windows |
21cfcccf EZ |
2 | Copyright (C) 1996, 1997 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 | /* 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" | |
583f5d53 EZ |
40 | #include "buffer.h" |
41 | #include "charset.h" | |
42 | #include "coding.h" | |
21cfcccf EZ |
43 | |
44 | /* If ever some function outside this file will need to call any | |
45 | clipboard-related function, the following prototypes and constants | |
46 | should be put on a header file. Right now, nobody else uses them. */ | |
47 | ||
48 | #define CF_TEXT 0x01 | |
49 | #define CF_BITMAP 0x02 | |
50 | #define CF_METAFILE 0x03 | |
51 | #define CF_SYLK 0x04 | |
52 | #define CF_DIF 0x05 | |
53 | #define CF_TIFF 0x06 | |
54 | #define CF_OEMTEXT 0x07 | |
55 | #define CF_DIBBITMAP 0x08 | |
56 | #define CF_WINWRITE 0x80 | |
57 | #define CF_DSPTEXT 0x81 | |
58 | #define CF_DSPBITMAP 0x82 | |
59 | ||
60 | unsigned identify_winoldap_version (void); | |
61 | unsigned open_clipboard (void); | |
62 | unsigned empty_clipboard (void); | |
583f5d53 | 63 | unsigned set_clipboard_data (unsigned, void *, unsigned, int); |
21cfcccf | 64 | unsigned get_clipboard_data_size (unsigned); |
583f5d53 | 65 | unsigned get_clipboard_data (unsigned, void *, unsigned, int); |
21cfcccf EZ |
66 | unsigned close_clipboard (void); |
67 | unsigned clipboard_compact (unsigned); | |
68 | ||
69 | Lisp_Object QCLIPBOARD, QPRIMARY; | |
70 | ||
583f5d53 EZ |
71 | /* Coding system for communicating with other Windows programs via the |
72 | clipboard. */ | |
199c7c44 | 73 | static Lisp_Object Vselection_coding_system; |
583f5d53 | 74 | |
9963e859 EZ |
75 | /* Coding system for the next communicating with other Windows programs. */ |
76 | static Lisp_Object Vnext_selection_coding_system; | |
77 | ||
21cfcccf EZ |
78 | /* The segment address and the size of the buffer in low |
79 | memory used to move data between us and WinOldAp module. */ | |
80 | ||
81 | static struct { | |
82 | unsigned long size; | |
83 | unsigned short rm_segment; | |
84 | } clipboard_xfer_buf_info; | |
85 | \f | |
86 | /* Emulation of `__dpmi_int' and friends for DJGPP v1.x */ | |
87 | ||
88 | #if __DJGPP__ < 2 | |
89 | ||
90 | typedef _go32_dpmi_registers __dpmi_regs; | |
91 | #define __tb _go32_info_block.linear_address_of_transfer_buffer | |
92 | #define _dos_ds _go32_info_block.selector_for_linear_memory | |
93 | ||
94 | static int | |
95 | __dpmi_int (intno, regs) | |
96 | int intno; | |
97 | __dpmi_regs *regs; | |
98 | { | |
99 | regs->x.ss = regs->x.sp = regs->x.flags = 0; | |
100 | return _go32_dpmi_simulate_int (intno, regs); | |
101 | } | |
102 | ||
103 | #endif /* __DJGPP__ < 2 */ | |
104 | \f | |
105 | /* C functions to access the Windows 3.1x clipboard from DOS apps. | |
106 | ||
107 | The information was obtained from the Microsoft Knowledge Base, | |
108 | article Q67675 and can be found at: | |
109 | http://www.microsoft.com/kb/developr/win_dk/q67675.htm */ | |
110 | ||
111 | /* See also Ralf Brown's Interrupt List. | |
112 | ||
113 | I also seem to remember reading about this in Dr. Dobbs Journal a | |
114 | while ago, but if you knew my memory... :-) | |
115 | ||
116 | Dale P. Smith <dpsm@en.com> */ | |
117 | ||
118 | /* Return the WinOldAp support version, or 0x1700 if not supported. */ | |
119 | unsigned | |
120 | identify_winoldap_version () | |
121 | { | |
122 | __dpmi_regs regs; | |
123 | ||
124 | /* Calls Int 2Fh/AX=1700h | |
125 | Return Values AX == 1700H: Clipboard functions not available | |
126 | <> 1700H: AL = Major version number | |
127 | AH = Minor version number */ | |
128 | regs.x.ax = 0x1700; | |
129 | __dpmi_int(0x2f, ®s); | |
130 | return regs.x.ax; | |
131 | } | |
132 | ||
133 | /* Open the clipboard, return non-zero if successfull. */ | |
134 | unsigned | |
135 | open_clipboard () | |
136 | { | |
137 | __dpmi_regs regs; | |
138 | ||
139 | /* Is WINOLDAP supported? */ | |
140 | /* Kludge alert!! If WinOldAp is not supported, we return a 0, | |
141 | which is the same as ``Clipboard already open''. Currently, | |
142 | this is taken as an error by all the functions that use | |
143 | `open_clipboard', but if somebody someday will use that ``open'' | |
144 | clipboard, they will have interesting time debugging it... */ | |
145 | if (identify_winoldap_version () == 0x1700) | |
146 | return 0; | |
147 | ||
148 | /* Calls Int 2Fh/AX=1701h | |
149 | Return Values AX == 0: Clipboard already open | |
150 | <> 0: Clipboard opened */ | |
151 | regs.x.ax = 0x1701; | |
152 | __dpmi_int(0x2f, ®s); | |
153 | return regs.x.ax; | |
154 | } | |
155 | ||
156 | /* Empty clipboard, return non-zero if successfull. */ | |
157 | unsigned | |
158 | empty_clipboard () | |
159 | { | |
160 | __dpmi_regs regs; | |
161 | ||
162 | /* Calls Int 2Fh/AX=1702h | |
163 | Return Values AX == 0: Error occurred | |
164 | <> 0: OK, Clipboard emptied */ | |
165 | regs.x.ax = 0x1702; | |
166 | __dpmi_int(0x2f, ®s); | |
167 | return regs.x.ax; | |
168 | } | |
169 | ||
170 | /* Ensure we have a buffer in low memory with enough memory for data | |
171 | of size WANT_SIZE. Return the linear address of the buffer. */ | |
172 | static unsigned long | |
173 | alloc_xfer_buf (want_size) | |
174 | unsigned want_size; | |
175 | { | |
176 | __dpmi_regs regs; | |
177 | ||
178 | /* If the usual DJGPP transfer buffer is large enough, use that. */ | |
179 | if (want_size <= _go32_info_block.size_of_transfer_buffer) | |
180 | return __tb & 0xfffff; | |
181 | ||
767079a8 EZ |
182 | /* Don't even try to allocate more than 1MB of memory: DOS cannot |
183 | possibly handle that (it will overflow the BX register below). */ | |
184 | if (want_size > 0xfffff) | |
185 | return 0; | |
186 | ||
21cfcccf EZ |
187 | /* Need size rounded up to the nearest paragraph, and in |
188 | paragraph units (1 paragraph = 16 bytes). */ | |
189 | clipboard_xfer_buf_info.size = (want_size + 15) >> 4; | |
190 | ||
191 | /* The NT DPMI host crashes us if we free DOS memory via the | |
192 | DPMI service. Work around by calling DOS allocate/free block. */ | |
193 | regs.h.ah = 0x48; | |
194 | regs.x.bx = clipboard_xfer_buf_info.size; | |
195 | __dpmi_int (0x21, ®s); | |
196 | if (regs.x.flags & 1) | |
197 | { | |
198 | clipboard_xfer_buf_info.size = 0; | |
199 | return 0; | |
200 | } | |
201 | ||
202 | clipboard_xfer_buf_info.rm_segment = regs.x.ax; | |
203 | return (((int)clipboard_xfer_buf_info.rm_segment) << 4) & 0xfffff; | |
204 | } | |
205 | ||
206 | /* Free our clipboard buffer. We always free it after use, because | |
207 | keeping it leaves less free conventional memory for subprocesses. | |
208 | The clipboard buffer tends to be large in size, because for small | |
209 | clipboard data sizes we use the DJGPP transfer buffer. */ | |
210 | static void | |
211 | free_xfer_buf () | |
212 | { | |
213 | /* If the size is 0, we used DJGPP transfer buffer, so don't free. */ | |
214 | if (clipboard_xfer_buf_info.size) | |
215 | { | |
216 | __dpmi_regs regs; | |
217 | ||
218 | /* The NT DPMI host crashes us if we free DOS memory via | |
219 | the DPMI service. Work around by calling DOS free block. */ | |
220 | regs.h.ah = 0x49; | |
221 | regs.x.es = clipboard_xfer_buf_info.rm_segment; | |
222 | __dpmi_int (0x21, ®s); | |
223 | clipboard_xfer_buf_info.size = 0; | |
224 | } | |
225 | } | |
226 | ||
0265f89f | 227 | /* Copy data into the clipboard, return zero if successfull. */ |
21cfcccf | 228 | unsigned |
583f5d53 | 229 | set_clipboard_data (Format, Data, Size, Raw) |
21cfcccf EZ |
230 | unsigned Format; |
231 | void *Data; | |
232 | unsigned Size; | |
583f5d53 | 233 | int Raw; |
21cfcccf EZ |
234 | { |
235 | __dpmi_regs regs; | |
236 | unsigned truelen; | |
237 | unsigned long xbuf_addr, buf_offset; | |
238 | unsigned char *dp = Data, *dstart = dp; | |
239 | ||
538d05bb | 240 | if (Format != CF_OEMTEXT) |
21cfcccf EZ |
241 | return 0; |
242 | ||
243 | /* need to know final size after '\r' chars are inserted (the | |
538d05bb | 244 | standard CF_OEMTEXT clipboard format uses CRLF line endings, |
21cfcccf | 245 | while Emacs uses just LF internally). */ |
0265f89f | 246 | truelen = Size + 1; /* +1 for the terminating null */ |
583f5d53 EZ |
247 | |
248 | if (!Raw) | |
21cfcccf | 249 | { |
583f5d53 EZ |
250 | /* avoid using strchr because it recomputes the length everytime */ |
251 | while ((dp = memchr (dp, '\n', Size - (dp - dstart))) != 0) | |
252 | { | |
253 | truelen++; | |
254 | dp++; | |
255 | } | |
21cfcccf EZ |
256 | } |
257 | ||
258 | if (clipboard_compact (truelen) < truelen) | |
259 | return 0; | |
260 | ||
261 | if ((xbuf_addr = alloc_xfer_buf (truelen)) == 0) | |
262 | return 0; | |
263 | ||
583f5d53 EZ |
264 | /* Move the buffer into the low memory, convert LF into CR-LF if needed. */ |
265 | if (Raw) | |
0236e3f1 EZ |
266 | { |
267 | dosmemput (Data, Size, xbuf_addr); | |
268 | ||
269 | /* Terminate with a null, otherwise Windows does strange things | |
270 | when the text size is an integral multiple of 32 bytes. */ | |
271 | _farpokeb (_dos_ds, xbuf_addr + Size, '\0'); | |
272 | } | |
583f5d53 | 273 | else |
21cfcccf | 274 | { |
583f5d53 EZ |
275 | dp = Data; |
276 | buf_offset = xbuf_addr; | |
277 | _farsetsel (_dos_ds); | |
278 | while (Size--) | |
279 | { | |
0265f89f EZ |
280 | /* Don't allow them to put binary data into the clipboard, since |
281 | it will cause yanked data to be truncated at the first null. */ | |
282 | if (*dp == '\0') | |
283 | return 2; | |
583f5d53 EZ |
284 | if (*dp == '\n') |
285 | _farnspokeb (buf_offset++, '\r'); | |
286 | _farnspokeb (buf_offset++, *dp++); | |
287 | } | |
21cfcccf | 288 | |
0236e3f1 EZ |
289 | /* Terminate with a null, otherwise Windows does strange things |
290 | when the text size is an integral multiple of 32 bytes. */ | |
291 | _farnspokeb (buf_offset, '\0'); | |
292 | } | |
0265f89f | 293 | |
21cfcccf EZ |
294 | /* Calls Int 2Fh/AX=1703h with: |
295 | DX = WinOldAp-Supported Clipboard format | |
296 | ES:BX = Pointer to data | |
297 | SI:CX = Size of data in bytes | |
298 | Return Values AX == 0: Error occurred | |
299 | <> 0: OK. Data copied into the Clipboard. */ | |
300 | regs.x.ax = 0x1703; | |
301 | regs.x.dx = Format; | |
302 | regs.x.si = truelen >> 16; | |
303 | regs.x.cx = truelen & 0xffff; | |
304 | regs.x.es = xbuf_addr >> 4; | |
305 | regs.x.bx = xbuf_addr & 15; | |
306 | __dpmi_int(0x2f, ®s); | |
307 | ||
308 | free_xfer_buf (); | |
309 | ||
0265f89f EZ |
310 | /* Zero means success, otherwise (1 or 2) it's an error. */ |
311 | return regs.x.ax > 0 ? 0 : 1; | |
21cfcccf EZ |
312 | } |
313 | ||
314 | /* Return the size of the clipboard data of format FORMAT. */ | |
315 | unsigned | |
316 | get_clipboard_data_size (Format) | |
317 | unsigned Format; | |
318 | { | |
319 | __dpmi_regs regs; | |
320 | ||
321 | /* Calls Int 2Fh/AX=1704h with: | |
322 | DX = WinOldAp-Supported Clipboard format | |
323 | Return Values DX:AX == Size of the data in bytes, including any | |
324 | headers. | |
325 | == 0 If data in this format is not in | |
326 | the clipboard. */ | |
327 | regs.x.ax = 0x1704; | |
328 | regs.x.dx = Format; | |
329 | __dpmi_int(0x2f, ®s); | |
330 | return ( (((unsigned)regs.x.dx) << 16) | regs.x.ax); | |
331 | } | |
332 | ||
333 | /* Get clipboard data, return its length. | |
334 | Warning: this doesn't check whether DATA has enough space to hold | |
335 | SIZE bytes. */ | |
336 | unsigned | |
583f5d53 | 337 | get_clipboard_data (Format, Data, Size, Raw) |
21cfcccf EZ |
338 | unsigned Format; |
339 | void *Data; | |
340 | unsigned Size; | |
583f5d53 | 341 | int Raw; |
21cfcccf EZ |
342 | { |
343 | __dpmi_regs regs; | |
21cfcccf EZ |
344 | unsigned long xbuf_addr; |
345 | unsigned char *dp = Data; | |
0265f89f EZ |
346 | /* The last 32-byte aligned block of data. See commentary below. */ |
347 | unsigned char *last_block = dp + ((Size & 0x1f) | |
348 | ? (Size & 0x20) | |
349 | : Size - 0x20); | |
21cfcccf | 350 | |
538d05bb | 351 | if (Format != CF_OEMTEXT) |
21cfcccf EZ |
352 | return 0; |
353 | ||
354 | if (Size == 0) | |
355 | return 0; | |
356 | ||
357 | if ((xbuf_addr = alloc_xfer_buf (Size)) == 0) | |
358 | return 0; | |
359 | ||
360 | /* Calls Int 2Fh/AX=1705h with: | |
361 | DX = WinOldAp-Supported Clipboard format | |
362 | ES:BX = Pointer to data buffer to hold data | |
363 | Return Values AX == 0: Error occurred (or data in this format is not | |
364 | in the clipboard) | |
365 | <> 0: OK */ | |
366 | regs.x.ax = 0x1705; | |
367 | regs.x.dx = Format; | |
368 | regs.x.es = xbuf_addr >> 4; | |
369 | regs.x.bx = xbuf_addr & 15; | |
370 | __dpmi_int(0x2f, ®s); | |
371 | if (regs.x.ax != 0) | |
372 | { | |
583f5d53 EZ |
373 | /* Copy data from low memory, remove CR |
374 | characters before LF if needed. */ | |
21cfcccf EZ |
375 | _farsetsel (_dos_ds); |
376 | while (Size--) | |
377 | { | |
378 | register unsigned char c = _farnspeekb (xbuf_addr++); | |
379 | ||
583f5d53 | 380 | if ((*dp++ = c) == '\r' && !Raw && _farnspeekb (xbuf_addr) == '\n') |
21cfcccf EZ |
381 | { |
382 | dp--; | |
383 | *dp++ = '\n'; | |
384 | xbuf_addr++; | |
0265f89f | 385 | last_block--; /* adjust the beginning of the last 32 bytes */ |
21cfcccf EZ |
386 | } |
387 | /* Windows reportedly rounds up the size of clipboard data | |
388 | (passed in SIZE) to a multiple of 32. We therefore bail | |
0265f89f EZ |
389 | out when we see the first null character in the last 32-byte |
390 | block. */ | |
391 | else if (c == '\0' && dp > last_block) | |
392 | break; | |
21cfcccf EZ |
393 | } |
394 | } | |
395 | ||
396 | free_xfer_buf (); | |
397 | ||
0265f89f | 398 | return (unsigned) (dp - (unsigned char *)Data - 1); |
21cfcccf EZ |
399 | } |
400 | ||
401 | /* Close clipboard, return non-zero if successfull. */ | |
402 | unsigned | |
403 | close_clipboard () | |
404 | { | |
405 | __dpmi_regs regs; | |
406 | ||
407 | /* Calls Int 2Fh/AX=1708h | |
408 | Return Values AX == 0: Error occurred | |
409 | <> 0: OK */ | |
410 | regs.x.ax = 0x1708; | |
411 | __dpmi_int(0x2f, ®s); | |
412 | return regs.x.ax; | |
413 | } | |
414 | ||
415 | /* Compact clipboard data so that at least SIZE bytes is available. */ | |
416 | unsigned | |
417 | clipboard_compact (Size) | |
418 | unsigned Size; | |
419 | { | |
420 | __dpmi_regs regs; | |
421 | ||
422 | /* Calls Int 2Fh/AX=1709H with: | |
423 | SI:CX = Desired memory size in bytes. | |
424 | Return Values DX:AX == Number of bytes of largest block of free memory. | |
425 | == 0 if error or no memory */ | |
426 | regs.x.ax = 0x1709; | |
427 | regs.x.si = Size >> 16; | |
428 | regs.x.cx = Size & 0xffff; | |
429 | __dpmi_int(0x2f, ®s); | |
430 | return ((unsigned)regs.x.dx << 16) | regs.x.ax; | |
431 | } | |
432 | \f | |
433 | static char no_mem_msg[] = | |
434 | "(Not enough DOS memory to put saved text into clipboard.)"; | |
0265f89f EZ |
435 | static char binary_msg[] = |
436 | "(Binary characters in saved text; clipboard data not set.)"; | |
21cfcccf | 437 | |
767079a8 | 438 | DEFUN ("w16-set-clipboard-data", Fw16_set_clipboard_data, Sw16_set_clipboard_data, 1, 2, 0, |
21cfcccf EZ |
439 | "This sets the clipboard data to the given text.") |
440 | (string, frame) | |
441 | Lisp_Object string, frame; | |
442 | { | |
0265f89f | 443 | unsigned ok = 1, put_status = 0; |
21cfcccf | 444 | int nbytes; |
583f5d53 EZ |
445 | unsigned char *src, *dst = NULL; |
446 | int charsets[MAX_CHARSET + 1]; | |
447 | int num; | |
448 | int no_crlf_conversion; | |
21cfcccf EZ |
449 | |
450 | CHECK_STRING (string, 0); | |
451 | ||
452 | if (NILP (frame)) | |
453 | frame = Fselected_frame (); | |
454 | ||
455 | CHECK_LIVE_FRAME (frame, 0); | |
456 | if ( !FRAME_MSDOS_P (XFRAME (frame))) | |
457 | goto done; | |
458 | ||
459 | BLOCK_INPUT; | |
460 | ||
199c7c44 | 461 | nbytes = STRING_BYTES (XSTRING (string)); |
21cfcccf | 462 | src = XSTRING (string)->data; |
583f5d53 EZ |
463 | |
464 | /* Since we are now handling multilingual text, we must consider | |
465 | encoding text for the clipboard. */ | |
583f5d53 | 466 | bzero (charsets, (MAX_CHARSET + 1) * sizeof (int)); |
199c7c44 | 467 | num = ((nbytes <= 1 /* Check the possibility of short cut. */ |
9963e859 EZ |
468 | || !STRING_MULTIBYTE (string) |
469 | || nbytes == XSTRING (string)->size) | |
583f5d53 | 470 | ? 0 |
42912be3 | 471 | : find_charset_in_str (src, nbytes, charsets, Qnil, 0, 1)); |
583f5d53 EZ |
472 | |
473 | if (!num || (num == 1 && charsets[CHARSET_ASCII])) | |
474 | { | |
475 | /* No multibyte character in OBJ. We need not encode it, but we | |
476 | will have to convert it to DOS CR-LF style. */ | |
477 | no_crlf_conversion = 0; | |
478 | } | |
479 | else | |
480 | { | |
481 | /* We must encode contents of STRING according to what | |
482 | clipboard-coding-system specifies. */ | |
483 | int bufsize; | |
484 | struct coding_system coding; | |
485 | unsigned char *htext2; | |
486 | ||
9963e859 EZ |
487 | if (NILP (Vnext_selection_coding_system)) |
488 | Vnext_selection_coding_system = Vselection_coding_system; | |
583f5d53 | 489 | setup_coding_system |
9963e859 EZ |
490 | (Fcheck_coding_system (Vnext_selection_coding_system), &coding); |
491 | Vnext_selection_coding_system = Qnil; | |
583f5d53 EZ |
492 | coding.mode |= CODING_MODE_LAST_BLOCK; |
493 | Vlast_coding_system_used = coding.symbol; | |
494 | bufsize = encoding_buffer_size (&coding, nbytes); | |
495 | dst = (unsigned char *) xmalloc (bufsize); | |
496 | encode_coding (&coding, src, dst, nbytes, bufsize); | |
497 | no_crlf_conversion = 1; | |
c7594627 | 498 | nbytes = coding.produced; |
ba92a470 | 499 | src = dst; |
583f5d53 EZ |
500 | } |
501 | ||
21cfcccf EZ |
502 | if (!open_clipboard ()) |
503 | goto error; | |
504 | ||
583f5d53 | 505 | ok = empty_clipboard () |
0265f89f | 506 | && ((put_status |
ba92a470 | 507 | = set_clipboard_data (CF_OEMTEXT, src, nbytes, no_crlf_conversion)) |
0265f89f | 508 | == 0); |
583f5d53 EZ |
509 | |
510 | if (!no_crlf_conversion) | |
511 | Vlast_coding_system_used = Qraw_text; | |
21cfcccf EZ |
512 | close_clipboard (); |
513 | ||
31354c30 | 514 | if (ok) goto unblock; |
21cfcccf EZ |
515 | |
516 | error: | |
517 | ||
518 | ok = 0; | |
519 | ||
31354c30 | 520 | unblock: |
583f5d53 EZ |
521 | if (dst) |
522 | xfree (dst); | |
31354c30 EZ |
523 | UNBLOCK_INPUT; |
524 | ||
21cfcccf EZ |
525 | /* Notify user if the text is too large to fit into DOS memory. |
526 | (This will happen somewhere after 600K bytes (470K in DJGPP v1.x), | |
527 | depending on user system configuration.) If we just silently | |
528 | fail the function, people might wonder why their text sometimes | |
529 | doesn't make it to the clipboard. */ | |
0265f89f | 530 | if (put_status) |
21cfcccf | 531 | { |
0265f89f EZ |
532 | switch (put_status) |
533 | { | |
534 | case 1: | |
535 | message2 (no_mem_msg, sizeof (no_mem_msg) - 1, 0); | |
536 | break; | |
537 | case 2: | |
538 | message2 (binary_msg, sizeof (binary_msg) - 1, 0); | |
539 | break; | |
540 | } | |
ad66baa4 | 541 | sit_for (2, 0, 0, 1, 1); |
21cfcccf EZ |
542 | } |
543 | ||
544 | done: | |
21cfcccf | 545 | |
0265f89f | 546 | return (ok && put_status == 0 ? string : Qnil); |
21cfcccf EZ |
547 | } |
548 | ||
767079a8 | 549 | DEFUN ("w16-get-clipboard-data", Fw16_get_clipboard_data, Sw16_get_clipboard_data, 0, 1, 0, |
21cfcccf EZ |
550 | "This gets the clipboard data in text format.") |
551 | (frame) | |
552 | Lisp_Object frame; | |
553 | { | |
554 | unsigned data_size, truelen; | |
555 | unsigned char *htext; | |
556 | Lisp_Object ret = Qnil; | |
583f5d53 EZ |
557 | int no_crlf_conversion; |
558 | int require_encoding = 0; | |
559 | ||
21cfcccf EZ |
560 | if (NILP (frame)) |
561 | frame = Fselected_frame (); | |
562 | ||
563 | CHECK_LIVE_FRAME (frame, 0); | |
564 | if ( !FRAME_MSDOS_P (XFRAME (frame))) | |
565 | goto done; | |
566 | ||
567 | BLOCK_INPUT; | |
568 | ||
569 | if (!open_clipboard ()) | |
31354c30 | 570 | goto unblock; |
21cfcccf | 571 | |
538d05bb | 572 | if ((data_size = get_clipboard_data_size (CF_OEMTEXT)) == 0 || |
21cfcccf EZ |
573 | (htext = (unsigned char *)xmalloc (data_size)) == 0) |
574 | goto closeclip; | |
575 | ||
576 | /* need to know final size after '\r' chars are removed because | |
577 | we can't change the string size manually, and doing an extra | |
578 | copy is silly */ | |
538d05bb | 579 | if ((truelen = get_clipboard_data (CF_OEMTEXT, htext, data_size, 0)) == 0) |
21cfcccf EZ |
580 | goto closeclip; |
581 | ||
583f5d53 | 582 | /* Do we need to decode it? */ |
9963e859 EZ |
583 | if ( |
584 | #if 1 | |
585 | 1 | |
586 | #else | |
587 | ! NILP (buffer_defaults.enable_multibyte_characters) | |
588 | #endif | |
589 | ) | |
583f5d53 EZ |
590 | { |
591 | /* If the clipboard data contains any 8-bit Latin-1 code, we | |
592 | need to decode it. */ | |
593 | int i; | |
594 | ||
595 | for (i = 0; i < truelen; i++) | |
596 | { | |
597 | if (htext[i] >= 0x80) | |
598 | { | |
599 | require_encoding = 1; | |
600 | break; | |
601 | } | |
602 | } | |
603 | } | |
604 | if (require_encoding) | |
605 | { | |
606 | int bufsize; | |
607 | unsigned char *buf; | |
608 | struct coding_system coding; | |
609 | ||
9963e859 EZ |
610 | if (NILP (Vnext_selection_coding_system)) |
611 | Vnext_selection_coding_system = Vselection_coding_system; | |
583f5d53 | 612 | setup_coding_system |
9963e859 EZ |
613 | (Fcheck_coding_system (Vnext_selection_coding_system), &coding); |
614 | Vnext_selection_coding_system = Qnil; | |
583f5d53 | 615 | coding.mode |= CODING_MODE_LAST_BLOCK; |
538d05bb | 616 | truelen = get_clipboard_data (CF_OEMTEXT, htext, data_size, 1); |
583f5d53 EZ |
617 | bufsize = decoding_buffer_size (&coding, truelen); |
618 | buf = (unsigned char *) xmalloc (bufsize); | |
619 | decode_coding (&coding, htext, buf, truelen, bufsize); | |
620 | truelen = (coding.fake_multibyte | |
621 | ? multibyte_chars_in_text (buf, coding.produced) | |
622 | : coding.produced_char); | |
623 | ret = make_string_from_bytes ((char *) buf, truelen, coding.produced); | |
624 | xfree (buf); | |
625 | Vlast_coding_system_used = coding.symbol; | |
626 | } | |
627 | else | |
628 | { | |
629 | ret = make_unibyte_string ((char *) htext, truelen); | |
630 | Vlast_coding_system_used = Qraw_text; | |
631 | } | |
632 | ||
21cfcccf EZ |
633 | xfree (htext); |
634 | ||
635 | closeclip: | |
636 | close_clipboard (); | |
31354c30 EZ |
637 | |
638 | unblock: | |
639 | UNBLOCK_INPUT; | |
21cfcccf EZ |
640 | |
641 | done: | |
21cfcccf EZ |
642 | |
643 | return (ret); | |
644 | } | |
645 | ||
646 | /* Support checking for a clipboard selection. */ | |
647 | ||
648 | DEFUN ("x-selection-exists-p", Fx_selection_exists_p, Sx_selection_exists_p, | |
649 | 0, 1, 0, | |
650 | "Whether there is an owner for the given X Selection.\n\ | |
651 | The arg should be the name of the selection in question, typically one of\n\ | |
652 | the symbols `PRIMARY', `SECONDARY', or `CLIPBOARD'.\n\ | |
653 | \(Those are literal upper-case symbol names, since that's what X expects.)\n\ | |
654 | For convenience, the symbol nil is the same as `PRIMARY',\n\ | |
655 | and t is the same as `SECONDARY'.") | |
656 | (selection) | |
657 | Lisp_Object selection; | |
658 | { | |
659 | CHECK_SYMBOL (selection, 0); | |
660 | ||
661 | /* Return nil for SECONDARY selection. For PRIMARY (or nil) | |
662 | selection, check if there is some text on the kill-ring; | |
663 | for CLIPBOARD, check if the clipboard currently has valid | |
664 | text format contents. | |
665 | ||
666 | The test for killed text on the kill-ring emulates the Emacs | |
667 | behavior on X, where killed text is also put into X selection | |
668 | by the X interface code. (On MSDOS, killed text is only put | |
669 | into the clipboard if we run under Windows, so we cannot check | |
670 | the clipboard alone.) */ | |
671 | if ((EQ (selection, Qnil) || EQ (selection, QPRIMARY)) | |
672 | && ! NILP (XSYMBOL (Fintern_soft (build_string ("kill-ring"), | |
673 | Qnil))->value)) | |
674 | return Qt; | |
675 | ||
676 | if (EQ (selection, QCLIPBOARD)) | |
677 | { | |
678 | Lisp_Object val = Qnil; | |
679 | ||
680 | if (open_clipboard ()) | |
681 | { | |
538d05bb | 682 | if (get_clipboard_data_size (CF_OEMTEXT)) |
21cfcccf EZ |
683 | val = Qt; |
684 | close_clipboard (); | |
685 | } | |
686 | return val; | |
687 | } | |
688 | return Qnil; | |
689 | } | |
690 | ||
691 | void | |
692 | syms_of_win16select () | |
693 | { | |
767079a8 EZ |
694 | defsubr (&Sw16_set_clipboard_data); |
695 | defsubr (&Sw16_get_clipboard_data); | |
21cfcccf EZ |
696 | defsubr (&Sx_selection_exists_p); |
697 | ||
199c7c44 | 698 | DEFVAR_LISP ("selection-coding-system", &Vselection_coding_system, |
583f5d53 EZ |
699 | "Coding system for communicating with other X clients.\n\ |
700 | When sending or receiving text via cut_buffer, selection, and clipboard,\n\ | |
701 | the text is encoded or decoded by this coding system.\n\ | |
702 | A default value is `iso-latin-1-dos'"); | |
199c7c44 | 703 | Vselection_coding_system=intern ("iso-latin-1-dos"); |
9963e859 EZ |
704 | |
705 | DEFVAR_LISP ("next-selection-coding-system", &Vnext_selection_coding_system, | |
706 | "Coding system for the next communication with other X clients.\n\ | |
707 | Usually, `selection-coding-system' is used for communicating with\n\ | |
708 | other X clients. But, if this variable is set, it is used for the\n\ | |
709 | next communication only. After the communication, this variable is\n\ | |
710 | set to nil."); | |
711 | Vnext_selection_coding_system = Qnil; | |
583f5d53 | 712 | |
21cfcccf EZ |
713 | QPRIMARY = intern ("PRIMARY"); staticpro (&QPRIMARY); |
714 | QCLIPBOARD = intern ("CLIPBOARD"); staticpro (&QCLIPBOARD); | |
715 | } | |
716 | ||
717 | #endif /* MSDOS */ |