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