1 /* MS-DOS specific C utilities. -*- coding: raw-text -*-
2 Copyright (C) 1993, 94, 95, 96, 97, 1999, 2000, 01, 2003
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
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
9 the Free Software Foundation; either version 2, or (at your option)
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.
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
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* Contributed by Morten Welinder */
23 /* New display, keyboard, and mouse control by Kim F. Storm */
25 /* Note: some of the stuff here was taken from end of sysdep.c in demacs. */
34 #include <sys/param.h>
38 #include <string.h> /* for bzero and string functions */
39 #include <sys/stat.h> /* for _fixpath */
40 #include <unistd.h> /* for chdir, dup, dup2, etc. */
41 #include <dir.h> /* for getdisk */
43 #pragma pack(0) /* dir.h does a pack(4), which isn't GCC's default */
45 #include <io.h> /* for setmode */
46 #include <dpmi.h> /* for __dpmi_xxx stuff */
47 #include <sys/farptr.h> /* for _farsetsel, _farnspokeb */
48 #include <libc/dosio.h> /* for _USE_LFN */
49 #include <conio.h> /* for cputs */
54 #include "termhooks.h"
56 #include "dispextern.h"
66 #include "blockinput.h"
68 #include "intervals.h"
72 /* #include <process.h> */
73 /* Damn that local process.h! Instead we can define P_WAIT ourselves. */
81 #define _dos_ds _go32_info_block.selector_for_linear_memory
87 #include "syssignal.h"
93 /* If other `malloc' than ours is used, force our `sbrk' behave like
94 Unix programs expect (resize memory blocks to keep them contiguous).
95 If `sbrk' from `ralloc.c' is NOT used, also zero-out sbrk'ed memory,
96 because that's what `gmalloc' expects to get. */
100 int _crt0_startup_flags
= _CRT0_FLAG_UNIX_SBRK
;
101 #else /* not REL_ALLOC */
102 int _crt0_startup_flags
= (_CRT0_FLAG_UNIX_SBRK
| _CRT0_FLAG_FILL_SBRK_MEMORY
);
103 #endif /* not REL_ALLOC */
104 #endif /* GNU_MALLOC */
106 #endif /* not SYSTEM_MALLOC */
107 #endif /* __DJGPP__ > 1 */
126 /* ------------------------ Mouse control ---------------------------
128 * Coordinates are in screen positions and zero based.
129 * Mouse buttons are numbered from left to right and also zero based.
132 /* This used to be in termhooks.h, but mainstream Emacs code no longer
133 uses it, and it was removed... */
134 #define NUM_MOUSE_BUTTONS (5)
136 int have_mouse
; /* 0: no, 1: enabled, -1: disabled */
137 static int mouse_visible
;
139 static int mouse_last_x
;
140 static int mouse_last_y
;
142 static int mouse_button_translate
[NUM_MOUSE_BUTTONS
];
143 static int mouse_button_count
;
150 if (have_mouse
> 0 && !mouse_visible
)
153 fprintf (termscript
, "<M_ON>");
155 int86 (0x33, ®s
, ®s
);
165 if (have_mouse
> 0 && mouse_visible
)
168 fprintf (termscript
, "<M_OFF>");
170 int86 (0x33, ®s
, ®s
);
176 mouse_setup_buttons (int n_buttons
)
180 mouse_button_count
= 3;
181 mouse_button_translate
[0] = 0; /* Left */
182 mouse_button_translate
[1] = 2; /* Middle */
183 mouse_button_translate
[2] = 1; /* Right */
185 else /* two, what else? */
187 mouse_button_count
= 2;
188 mouse_button_translate
[0] = 0;
189 mouse_button_translate
[1] = 1;
193 DEFUN ("msdos-set-mouse-buttons", Fmsdos_set_mouse_buttons
, Smsdos_set_mouse_buttons
,
194 1, 1, "NSet number of mouse buttons to: ",
195 doc
: /* Set the number of mouse buttons to use by Emacs.
196 This is useful with mice that report the number of buttons inconsistently,
197 e.g., if the number of buttons is reported as 3, but Emacs only sees 2 of
198 them. This happens with wheeled mice on Windows 9X, for example. */)
200 Lisp_Object nbuttons
;
204 CHECK_NUMBER (nbuttons
);
207 Fsignal (Qargs_out_of_range
,
208 Fcons (build_string ("only 2 or 3 mouse buttons are supported"),
209 Fcons (nbuttons
, Qnil
)));
210 mouse_setup_buttons (n
);
215 mouse_get_xy (int *x
, int *y
)
220 int86 (0x33, ®s
, ®s
);
232 fprintf (termscript
, "<M_XY=%dx%d>", x
, y
);
234 mouse_last_x
= regs
.x
.cx
= x
* 8;
235 mouse_last_y
= regs
.x
.dx
= y
* 8;
236 int86 (0x33, ®s
, ®s
);
240 mouse_pressed (b
, xp
, yp
)
245 if (b
>= mouse_button_count
)
248 regs
.x
.bx
= mouse_button_translate
[b
];
249 int86 (0x33, ®s
, ®s
);
251 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
252 return (regs
.x
.bx
!= 0);
256 mouse_released (b
, xp
, yp
)
261 if (b
>= mouse_button_count
)
264 regs
.x
.bx
= mouse_button_translate
[b
];
265 int86 (0x33, ®s
, ®s
);
267 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
268 return (regs
.x
.bx
!= 0);
272 mouse_button_depressed (b
, xp
, yp
)
277 if (b
>= mouse_button_count
)
280 int86 (0x33, ®s
, ®s
);
281 if ((regs
.x
.bx
& (1 << mouse_button_translate
[b
])) != 0)
291 mouse_get_pos (f
, insist
, bar_window
, part
, x
, y
, time
)
294 Lisp_Object
*bar_window
, *x
, *y
;
295 enum scroll_bar_part
*part
;
299 Lisp_Object frame
, tail
;
301 /* Clear the mouse-moved flag for every frame on this display. */
302 FOR_EACH_FRAME (tail
, frame
)
303 XFRAME (frame
)->mouse_moved
= 0;
305 *f
= SELECTED_FRAME();
307 mouse_get_xy (&ix
, &iy
);
308 *time
= event_timestamp ();
309 *x
= make_number (mouse_last_x
= ix
);
310 *y
= make_number (mouse_last_y
= iy
);
318 mouse_get_xy (&x
, &y
);
319 SELECTED_FRAME()->mouse_moved
|= (x
!= mouse_last_x
|| y
!= mouse_last_y
);
324 /* Force the mouse driver to ``forget'' about any button clicks until
327 mouse_clear_clicks (void)
331 for (b
= 0; b
< mouse_button_count
; b
++)
333 int dummy_x
, dummy_y
;
335 (void) mouse_pressed (b
, &dummy_x
, &dummy_y
);
336 (void) mouse_released (b
, &dummy_x
, &dummy_y
);
346 fprintf (termscript
, "<M_INIT>");
349 int86 (0x33, ®s
, ®s
);
351 /* Reset the mouse last press/release info. It seems that Windows
352 doesn't do that automatically when function 21h is called, which
353 causes Emacs to ``remember'' the click that switched focus to the
354 window just before Emacs was started from that window. */
355 mouse_clear_clicks ();
359 regs
.x
.dx
= 8 * (ScreenCols () - 1);
360 int86 (0x33, ®s
, ®s
);
364 regs
.x
.dx
= 8 * (ScreenRows () - 1);
365 int86 (0x33, ®s
, ®s
);
371 /* ------------------------- Screen control ----------------------
375 static int internal_terminal
= 0;
377 #ifndef HAVE_X_WINDOWS
378 extern unsigned char ScreenAttrib
;
379 static int screen_face
;
381 static int screen_size_X
;
382 static int screen_size_Y
;
383 static int screen_size
;
385 static int current_pos_X
;
386 static int current_pos_Y
;
387 static int new_pos_X
;
388 static int new_pos_Y
;
390 static void *startup_screen_buffer
;
391 static int startup_screen_size_X
;
392 static int startup_screen_size_Y
;
393 static int startup_pos_X
;
394 static int startup_pos_Y
;
395 static unsigned char startup_screen_attrib
;
397 static clock_t startup_time
;
399 static int term_setup_done
;
401 static unsigned short outside_cursor
;
403 /* Similar to the_only_frame. */
404 struct x_output the_only_x_display
;
406 /* Support for DOS/V (allows Japanese characters to be displayed on
407 standard, non-Japanese, ATs). Only supported for DJGPP v2 and later. */
409 /* Holds the address of the text-mode screen buffer. */
410 static unsigned long screen_old_address
= 0;
411 /* Segment and offset of the virtual screen. If 0, DOS/V is NOT loaded. */
412 static unsigned short screen_virtual_segment
= 0;
413 static unsigned short screen_virtual_offset
= 0;
414 /* A flag to control how to display unibyte 8-bit characters. */
415 extern int unibyte_display_via_language_environment
;
417 extern Lisp_Object Qcursor_type
;
418 extern Lisp_Object Qbar
, Qhbar
;
420 /* The screen colors of the current frame, which serve as the default
421 colors for newly-created frames. */
422 static int initial_screen_colors
[2];
425 /* Update the screen from a part of relocated DOS/V screen buffer which
426 begins at OFFSET and includes COUNT characters. */
428 dosv_refresh_virtual_screen (int offset
, int count
)
432 if (offset
< 0 || count
< 0) /* paranoia; invalid values crash DOS/V */
435 regs
.h
.ah
= 0xff; /* update relocated screen */
436 regs
.x
.es
= screen_virtual_segment
;
437 regs
.x
.di
= screen_virtual_offset
+ offset
;
439 __dpmi_int (0x10, ®s
);
444 dos_direct_output (y
, x
, buf
, len
)
449 int t0
= 2 * (x
+ y
* screen_size_X
);
450 int t
= t0
+ (int) ScreenPrimary
;
455 dosmemput (buf
++, 1, t
);
459 /* This is faster. */
460 for (_farsetsel (_dos_ds
); --len
>= 0; t
+= 2, buf
++)
461 _farnspokeb (t
, *buf
);
463 if (screen_virtual_segment
)
464 dosv_refresh_virtual_screen (t0
, l0
);
469 /* Flash the screen as a substitute for BEEPs. */
473 do_visible_bell (xorattr
)
474 unsigned char xorattr
;
479 movl _ScreenPrimary,%%eax \n\
486 xorb %%al,%%gs:(%%ebx) \n\
489 jne visible_bell_1 \n\
491 jne visible_bell_3 \n\
493 movzwl %%ax,%%eax \n\
494 movzwl %%ax,%%eax \n\
495 movzwl %%ax,%%eax \n\
496 movzwl %%ax,%%eax \n\
498 jne visible_bell_2 \n\
499 jmp visible_bell_0 \n\
502 : "m" (xorattr
), "g" (screen_size
)
503 : "%eax", "%ebx", /* "%gs",*/ "%ecx", "%edx");
507 ScreenVisualBell (void)
509 /* This creates an xor-mask that will swap the default fore- and
510 background colors. */
511 do_visible_bell (((the_only_x_display
.foreground_pixel
512 ^ the_only_x_display
.background_pixel
)
517 #ifndef HAVE_X_WINDOWS
519 static int blink_bit
= -1; /* the state of the blink bit at startup */
521 /* Enable bright background colors. */
527 /* Remember the original state of the blink/bright-background bit.
528 It is stored at 0040:0065h in the BIOS data area. */
530 blink_bit
= (_farpeekb (_dos_ds
, 0x465) & 0x20) == 0x20;
534 int86 (0x10, ®s
, ®s
);
537 /* Disable bright background colors (and enable blinking) if we found
538 the video system in that state at startup. */
540 maybe_enable_blinking (void)
548 int86 (0x10, ®s
, ®s
);
552 /* Return non-zero if the system has a VGA adapter. */
559 int86 (0x10, ®s
, ®s
);
560 if (regs
.h
.al
== 0x1a && regs
.h
.bl
> 5 && regs
.h
.bl
< 13)
565 /* Set the screen dimensions so that it can show no less than
566 ROWS x COLS frame. */
569 dos_set_window_size (rows
, cols
)
574 Lisp_Object video_mode
;
575 int video_mode_value
, have_vga
= 0;
576 int current_rows
= ScreenRows (), current_cols
= ScreenCols ();
578 if (*rows
== current_rows
&& *cols
== current_cols
)
582 have_vga
= vga_installed ();
584 /* If the user specified a special video mode for these dimensions,
586 sprintf (video_name
, "screen-dimensions-%dx%d", *rows
, *cols
);
587 video_mode
= XSYMBOL (Fintern_soft (build_string (video_name
),
590 if (INTEGERP (video_mode
)
591 && (video_mode_value
= XINT (video_mode
)) > 0)
593 regs
.x
.ax
= video_mode_value
;
594 int86 (0x10, ®s
, ®s
);
598 /* Must hardware-reset the mouse, or else it won't update
599 its notion of screen dimensions for some non-standard
600 video modes. This is *painfully* slow... */
602 int86 (0x33, ®s
, ®s
);
606 /* Find one of the dimensions supported by standard EGA/VGA
607 which gives us at least the required dimensions. */
615 } std_dimension
[] = {
625 while (i
< sizeof (std_dimension
) / sizeof (std_dimension
[0]))
627 if (std_dimension
[i
].need_vga
<= have_vga
628 && std_dimension
[i
].rows
>= *rows
)
630 if (std_dimension
[i
].rows
!= current_rows
631 || *cols
!= current_cols
)
632 _set_screen_lines (std_dimension
[i
].rows
);
639 #else /* not __DJGPP__ > 1 */
641 else if (*rows
<= 25)
643 if (current_rows
!= 25 || current_cols
!= 80)
646 int86 (0x10, ®s
, ®s
);
649 int86 (0x10, ®s
, ®s
);
652 int86 (0x10, ®s
, ®s
);
654 int86 (0x10, ®s
, ®s
);
657 else if (*rows
<= 50)
658 if (have_vga
&& (current_rows
!= 50 || current_cols
!= 80)
659 || *rows
<= 43 && (current_rows
!= 43 || current_cols
!= 80))
662 int86 (0x10, ®s
, ®s
);
665 int86 (0x10, ®s
, ®s
);
668 int86 (0x10, ®s
, ®s
);
671 int86 (0x10, ®s
, ®s
);
673 #endif /* not __DJGPP__ > 1 */
681 /* Tell the caller what dimensions have been REALLY set. */
682 *rows
= ScreenRows ();
683 *cols
= ScreenCols ();
685 /* Update Emacs' notion of screen dimensions. */
686 screen_size_X
= *cols
;
687 screen_size_Y
= *rows
;
688 screen_size
= *cols
* *rows
;
691 /* If the dimensions changed, the mouse highlight info is invalid. */
692 if (current_rows
!= *rows
|| current_cols
!= *cols
)
694 struct frame
*f
= SELECTED_FRAME();
695 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
696 Lisp_Object window
= dpyinfo
->mouse_face_window
;
698 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
700 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
701 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
702 dpyinfo
->mouse_face_window
= Qnil
;
707 /* Enable bright background colors. */
710 /* FIXME: I'm not sure the above will run at all on DOS/V. But let's
711 be defensive anyway. */
712 if (screen_virtual_segment
)
713 dosv_refresh_virtual_screen (0, *cols
* *rows
);
716 /* If we write a character in the position where the mouse is,
717 the mouse cursor may need to be refreshed. */
727 mouse_get_xy (&x
, &y
);
728 if (y
!= new_pos_Y
|| x
< new_pos_X
)
734 #define DEFAULT_CURSOR_START (-1)
735 #define DEFAULT_CURSOR_WIDTH (-1)
736 #define BOX_CURSOR_WIDTH (-32)
738 /* Set cursor to begin at scan line START_LINE in the character cell
739 and extend for WIDTH scan lines. Scan lines are counted from top
740 of the character cell, starting from zero. */
742 msdos_set_cursor_shape (struct frame
*f
, int start_line
, int width
)
745 unsigned desired_cursor
;
747 int max_line
, top_line
, bot_line
;
749 /* Avoid the costly BIOS call if F isn't the currently selected
750 frame. Allow for NULL as unconditionally meaning the selected
752 if (f
&& f
!= SELECTED_FRAME())
755 /* The character cell size in scan lines is stored at 40:85 in the
757 max_line
= _farpeekw (_dos_ds
, 0x485) - 1;
760 default: /* this relies on CGA cursor emulation being ON! */
777 if (width
== BOX_CURSOR_WIDTH
)
782 else if (start_line
!= DEFAULT_CURSOR_START
)
784 top_line
= start_line
;
785 bot_line
= top_line
- width
- 1;
787 else if (width
!= DEFAULT_CURSOR_WIDTH
)
790 bot_line
= -1 - width
;
793 top_line
= bot_line
+ 1;
797 /* [31, 0] seems to DTRT for all screen sizes. */
801 else /* WIDTH is positive */
803 if (start_line
!= DEFAULT_CURSOR_START
)
804 bot_line
= start_line
;
805 top_line
= bot_line
- (width
- 1);
808 /* If the current cursor shape is already what they want, we are
810 desired_cursor
= ((top_line
& 0x1f) << 8) | (bot_line
& 0x1f);
811 if (desired_cursor
== _farpeekw (_dos_ds
, 0x460))
815 regs
.x
.cx
= desired_cursor
;
816 __dpmi_int (0x10, ®s
);
817 #endif /* __DJGPP__ > 1 */
821 IT_set_cursor_type (struct frame
*f
, Lisp_Object cursor_type
)
823 if (EQ (cursor_type
, Qbar
) || EQ (cursor_type
, Qhbar
))
825 /* Just BAR means the normal EGA/VGA cursor. */
826 msdos_set_cursor_shape (f
, DEFAULT_CURSOR_START
, DEFAULT_CURSOR_WIDTH
);
828 else if (CONSP (cursor_type
)
829 && (EQ (XCAR (cursor_type
), Qbar
)
830 || EQ (XCAR (cursor_type
), Qhbar
)))
832 Lisp_Object bar_parms
= XCDR (cursor_type
);
835 if (INTEGERP (bar_parms
))
837 /* Feature: negative WIDTH means cursor at the top
838 of the character cell, zero means invisible cursor. */
839 width
= XINT (bar_parms
);
840 msdos_set_cursor_shape (f
, width
>= 0 ? DEFAULT_CURSOR_START
: 0,
843 else if (CONSP (bar_parms
)
844 && INTEGERP (XCAR (bar_parms
))
845 && INTEGERP (XCDR (bar_parms
)))
847 int start_line
= XINT (XCDR (bar_parms
));
849 width
= XINT (XCAR (bar_parms
));
850 msdos_set_cursor_shape (f
, start_line
, width
);
854 /* Treat anything unknown as "box cursor". This includes nil, so
855 that a frame which doesn't specify a cursor type gets a box,
856 which is the default in Emacs. */
857 msdos_set_cursor_shape (f
, 0, BOX_CURSOR_WIDTH
);
870 union REGS inregs
, outregs
;
873 intdos (&inregs
, &outregs
);
877 /* Given a face id FACE, extract the face parameters to be used for
878 display until the face changes. The face parameters (actually, its
879 color) are used to construct the video attribute byte for each
880 glyph during the construction of the buffer that is then blitted to
883 IT_set_face (int face
)
885 struct frame
*sf
= SELECTED_FRAME();
886 struct face
*fp
= FACE_FROM_ID (sf
, face
);
887 struct face
*dfp
= FACE_FROM_ID (sf
, DEFAULT_FACE_ID
);
888 unsigned long fg
, bg
, dflt_fg
, dflt_bg
;
893 /* The default face for the frame should always be realized and
901 dflt_fg
= dfp
->foreground
;
902 dflt_bg
= dfp
->background
;
904 /* Don't use invalid colors. In particular, FACE_TTY_DEFAULT_* colors
905 mean use the colors of the default face. Note that we assume all
906 16 colors to be available for the background, since Emacs switches
907 on this mode (and loses the blinking attribute) at startup. */
908 if (fg
== FACE_TTY_DEFAULT_COLOR
|| fg
== FACE_TTY_DEFAULT_FG_COLOR
)
909 fg
= FRAME_FOREGROUND_PIXEL (sf
);
910 else if (fg
== FACE_TTY_DEFAULT_BG_COLOR
)
911 fg
= FRAME_BACKGROUND_PIXEL (sf
);
912 if (bg
== FACE_TTY_DEFAULT_COLOR
|| bg
== FACE_TTY_DEFAULT_BG_COLOR
)
913 bg
= FRAME_BACKGROUND_PIXEL (sf
);
914 else if (bg
== FACE_TTY_DEFAULT_FG_COLOR
)
915 bg
= FRAME_FOREGROUND_PIXEL (sf
);
917 /* Make sure highlighted lines really stand out, come what may. */
918 if (fp
->tty_reverse_p
&& (fg
== dflt_fg
&& bg
== dflt_bg
))
920 unsigned long tem
= fg
;
925 /* If the user requested inverse video, obey. */
928 unsigned long tem2
= fg
;
934 fprintf (termscript
, "<FACE %d: %d/%d[FG:%d/BG:%d]>", face
,
935 fp
->foreground
, fp
->background
, fg
, bg
);
936 if (fg
>= 0 && fg
< 16)
938 ScreenAttrib
&= 0xf0;
941 if (bg
>= 0 && bg
< 16)
943 ScreenAttrib
&= 0x0f;
944 ScreenAttrib
|= ((bg
& 0x0f) << 4);
948 Lisp_Object Vdos_unsupported_char_glyph
;
951 IT_write_glyphs (struct glyph
*str
, int str_len
)
953 unsigned char *screen_buf
, *screen_bp
, *screen_buf_end
, *bp
;
954 int unsupported_face
= FAST_GLYPH_FACE (Vdos_unsupported_char_glyph
);
955 unsigned unsupported_char
= FAST_GLYPH_CHAR (Vdos_unsupported_char_glyph
);
956 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
957 register int sl
= str_len
;
958 register int tlen
= GLYPH_TABLE_LENGTH
;
959 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
961 /* If terminal_coding does any conversion, use it, otherwise use
962 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
963 because it always returns 1 if terminal_coding.src_multibyte is 1. */
964 struct coding_system
*coding
=
965 (terminal_coding
.common_flags
& CODING_REQUIRE_ENCODING_MASK
967 : &safe_terminal_coding
);
970 /* Do we need to consider conversion of unibyte characters to
972 int convert_unibyte_characters
973 = (NILP (current_buffer
->enable_multibyte_characters
)
974 && unibyte_display_via_language_environment
);
976 unsigned char conversion_buffer
[256];
977 int conversion_buffer_size
= sizeof conversion_buffer
;
979 if (str_len
<= 0) return;
981 screen_buf
= screen_bp
= alloca (str_len
* 2);
982 screen_buf_end
= screen_buf
+ str_len
* 2;
983 sf
= SELECTED_FRAME();
985 /* Since faces get cached and uncached behind our back, we can't
986 rely on their indices in the cache being consistent across
987 invocations. So always reset the screen face to the default
988 face of the frame, before writing glyphs, and let the glyphs
989 set the right face if it's different from the default. */
990 IT_set_face (DEFAULT_FACE_ID
);
992 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
994 terminal_coding
.mode
&= ~CODING_MODE_LAST_BLOCK
;
997 int cf
, chlen
, enclen
;
998 unsigned char workbuf
[MAX_MULTIBYTE_LENGTH
], *buf
;
1001 /* Glyphs with GLYPH_MASK_PADDING bit set are actually there
1002 only for the redisplay code to know how many columns does
1003 this character occupy on the screen. Skip padding glyphs. */
1004 if (CHAR_GLYPH_PADDING_P (*str
))
1011 register GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*str
);
1012 int glyph_not_in_table
= 0;
1014 /* If g is negative, it means we have a multibyte character
1015 in *str. That's what GLYPH_FROM_CHAR_GLYPH returns for
1016 multibyte characters. */
1017 if (g
< 0 || g
>= tlen
)
1019 /* This glyph doesn't have an entry in Vglyph_table. */
1021 glyph_not_in_table
= 1;
1025 /* This glyph has an entry in Vglyph_table, so process
1026 any aliases before testing for simpleness. */
1027 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
1028 ch
= FAST_GLYPH_CHAR (g
);
1031 /* Convert the character code to multibyte, if they
1032 requested display via language environment. We only want
1033 to convert unibyte characters to multibyte in unibyte
1034 buffers! Otherwise, the 8-bit value in CH came from the
1035 display table set up to display foreign characters. */
1036 if (SINGLE_BYTE_CHAR_P (ch
) && convert_unibyte_characters
1038 || (ch
>= 0200 && !NILP (Vnonascii_translation_table
))))
1039 ch
= unibyte_char_to_multibyte (ch
);
1041 /* Invalid characters are displayed with a special glyph. */
1042 if (! CHAR_VALID_P (ch
, 0))
1044 g
= !NILP (Vdos_unsupported_char_glyph
)
1045 ? Vdos_unsupported_char_glyph
1046 : MAKE_GLYPH (sf
, '\177', GLYPH_FACE (sf
, g
));
1047 ch
= FAST_GLYPH_CHAR (g
);
1050 /* If the face of this glyph is different from the current
1051 screen face, update the screen attribute byte. */
1053 if (cf
!= screen_face
)
1054 IT_set_face (cf
); /* handles invalid faces gracefully */
1056 if (glyph_not_in_table
|| GLYPH_SIMPLE_P (tbase
, tlen
, g
))
1058 /* We generate the multi-byte form of CH in WORKBUF. */
1059 chlen
= CHAR_STRING (ch
, workbuf
);
1064 /* We have a string in Vglyph_table. */
1065 chlen
= GLYPH_LENGTH (tbase
, g
);
1066 buf
= GLYPH_STRING (tbase
, g
);
1069 /* If the character is not multibyte, don't bother converting it. */
1072 *conversion_buffer
= (unsigned char)ch
;
1078 coding
->src_multibyte
= 1;
1079 encode_coding (coding
, buf
, conversion_buffer
, chlen
,
1080 conversion_buffer_size
);
1081 chlen
-= coding
->consumed
;
1082 enclen
= coding
->produced
;
1084 /* Replace glyph codes that cannot be converted by
1085 terminal_coding with Vdos_unsupported_char_glyph. */
1086 if (*conversion_buffer
== '?')
1088 unsigned char *cbp
= conversion_buffer
;
1090 while (cbp
< conversion_buffer
+ enclen
&& *cbp
== '?')
1091 *cbp
++ = unsupported_char
;
1092 if (unsupported_face
!= screen_face
)
1093 IT_set_face (unsupported_face
);
1097 if (enclen
+ chlen
> screen_buf_end
- screen_bp
)
1099 /* The allocated buffer for screen writes is too small.
1100 Flush it and loop again without incrementing STR, so
1101 that the next loop will begin with the same glyph. */
1102 int nbytes
= screen_bp
- screen_buf
;
1105 dosmemput (screen_buf
, nbytes
, (int)ScreenPrimary
+ offset
);
1106 if (screen_virtual_segment
)
1107 dosv_refresh_virtual_screen (offset
, nbytes
/ 2);
1108 new_pos_X
+= nbytes
/ 2;
1111 /* Prepare to reuse the same buffer again. */
1112 screen_bp
= screen_buf
;
1116 /* There's enough place in the allocated buffer to add
1117 the encoding of this glyph. */
1119 /* First, copy the encoded bytes. */
1120 for (bp
= conversion_buffer
; enclen
--; bp
++)
1122 *screen_bp
++ = (unsigned char)*bp
;
1123 *screen_bp
++ = ScreenAttrib
;
1125 fputc (*bp
, termscript
);
1128 /* Now copy the bytes not consumed by the encoding. */
1131 buf
+= coding
->consumed
;
1135 fputc (*buf
, termscript
);
1136 *screen_bp
++ = (unsigned char)*buf
++;
1137 *screen_bp
++ = ScreenAttrib
;
1141 /* Update STR and its remaining length. */
1148 /* Dump whatever is left in the screen buffer. */
1150 dosmemput (screen_buf
, screen_bp
- screen_buf
, (int)ScreenPrimary
+ offset
);
1151 if (screen_virtual_segment
)
1152 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1153 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1155 /* We may have to output some codes to terminate the writing. */
1156 if (CODING_REQUIRE_FLUSHING (coding
))
1158 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
1159 encode_coding (coding
, "", conversion_buffer
, 0, conversion_buffer_size
);
1160 if (coding
->produced
> 0)
1162 screen_buf
= alloca (coding
->produced
* 2);
1163 for (screen_bp
= screen_buf
, bp
= conversion_buffer
;
1164 coding
->produced
--; bp
++)
1166 *screen_bp
++ = (unsigned char)*bp
;
1167 *screen_bp
++ = ScreenAttrib
;
1169 fputc (*bp
, termscript
);
1171 offset
+= screen_bp
- screen_buf
;
1173 dosmemput (screen_buf
, screen_bp
- screen_buf
,
1174 (int)ScreenPrimary
+ offset
);
1175 if (screen_virtual_segment
)
1176 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1177 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1182 /************************************************************************
1183 Mouse Highlight (and friends..)
1184 ************************************************************************/
1186 /* Last window where we saw the mouse. Used by mouse-autoselect-window. */
1187 static Lisp_Object last_mouse_window
;
1189 static int mouse_preempted
= 0; /* non-zero when XMenu gobbles mouse events */
1191 /* Set the mouse pointer shape according to whether it is in the
1192 area where the mouse highlight is in effect. */
1194 IT_set_mouse_pointer (int mode
)
1196 /* A no-op for now. DOS text-mode mouse pointer doesn't offer too
1197 many possibilities to change its shape, and the available
1198 functionality pretty much sucks (e.g., almost every reasonable
1199 shape will conceal the character it is on). Since the color of
1200 the pointer changes in the highlighted area, it is not clear to
1201 me whether anything else is required, anyway. */
1204 /* Display the active region described by mouse_face_*
1205 in its mouse-face if HL > 0, in its normal face if HL = 0. */
1207 show_mouse_face (struct display_info
*dpyinfo
, int hl
)
1209 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
1210 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1215 /* If window is in the process of being destroyed, don't bother
1217 if (w
->current_matrix
== NULL
)
1218 goto set_cursor_shape
;
1220 /* Recognize when we are called to operate on rows that don't exist
1221 anymore. This can happen when a window is split. */
1222 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
1223 goto set_cursor_shape
;
1225 /* There's no sense to do anything if the mouse face isn't realized. */
1228 if (dpyinfo
->mouse_face_hidden
)
1229 goto set_cursor_shape
;
1231 fp
= FACE_FROM_ID (SELECTED_FRAME(), dpyinfo
->mouse_face_face_id
);
1233 goto set_cursor_shape
;
1236 /* Note that mouse_face_beg_row etc. are window relative. */
1237 for (i
= dpyinfo
->mouse_face_beg_row
;
1238 i
<= dpyinfo
->mouse_face_end_row
;
1241 int start_hpos
, end_hpos
;
1242 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
1244 /* Don't do anything if row doesn't have valid contents. */
1245 if (!row
->enabled_p
)
1248 /* For all but the first row, the highlight starts at column 0. */
1249 if (i
== dpyinfo
->mouse_face_beg_row
)
1250 start_hpos
= dpyinfo
->mouse_face_beg_col
;
1254 if (i
== dpyinfo
->mouse_face_end_row
)
1255 end_hpos
= dpyinfo
->mouse_face_end_col
;
1257 end_hpos
= row
->used
[TEXT_AREA
];
1259 if (end_hpos
<= start_hpos
)
1261 /* Record that some glyphs of this row are displayed in
1263 row
->mouse_face_p
= hl
> 0;
1266 int vpos
= row
->y
+ WINDOW_TOP_EDGE_Y (w
);
1267 int kstart
= start_hpos
+ WINDOW_LEFT_EDGE_X (w
);
1268 int nglyphs
= end_hpos
- start_hpos
;
1269 int offset
= ScreenPrimary
+ 2*(vpos
*screen_size_X
+ kstart
) + 1;
1270 int start_offset
= offset
;
1273 fprintf (termscript
, "\n<MH+ %d-%d:%d>",
1274 kstart
, kstart
+ nglyphs
- 1, vpos
);
1277 IT_set_face (dpyinfo
->mouse_face_face_id
);
1278 /* Since we are going to change only the _colors_ of the
1279 displayed text, there's no need to go through all the
1280 pain of generating and encoding the text from the glyphs.
1281 Instead, we simply poke the attribute byte of each
1282 affected position in video memory with the colors
1283 computed by IT_set_face! */
1284 _farsetsel (_dos_ds
);
1287 _farnspokeb (offset
, ScreenAttrib
);
1290 if (screen_virtual_segment
)
1291 dosv_refresh_virtual_screen (start_offset
, end_hpos
- start_hpos
);
1296 /* We are removing a previously-drawn mouse highlight. The
1297 safest way to do so is to redraw the glyphs anew, since
1298 all kinds of faces and display tables could have changed
1300 int nglyphs
= end_hpos
- start_hpos
;
1301 int save_x
= new_pos_X
, save_y
= new_pos_Y
;
1303 if (end_hpos
>= row
->used
[TEXT_AREA
])
1304 nglyphs
= row
->used
[TEXT_AREA
] - start_hpos
;
1306 /* IT_write_glyphs writes at cursor position, so we need to
1307 temporarily move cursor coordinates to the beginning of
1308 the highlight region. */
1309 new_pos_X
= start_hpos
+ WINDOW_LEFT_EDGE_X (w
);
1310 new_pos_Y
= row
->y
+ WINDOW_TOP_EDGE_Y (w
);
1313 fprintf (termscript
, "<MH- %d-%d:%d>",
1314 new_pos_X
, new_pos_X
+ nglyphs
- 1, new_pos_Y
);
1315 IT_write_glyphs (row
->glyphs
[TEXT_AREA
] + start_hpos
, nglyphs
);
1317 fputs ("\n", termscript
);
1324 /* Change the mouse pointer shape. */
1325 IT_set_mouse_pointer (hl
);
1328 /* Clear out the mouse-highlighted active region.
1329 Redraw it un-highlighted first. */
1331 clear_mouse_face (struct display_info
*dpyinfo
)
1333 if (!dpyinfo
->mouse_face_hidden
&& ! NILP (dpyinfo
->mouse_face_window
))
1334 show_mouse_face (dpyinfo
, 0);
1336 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
1337 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
1338 dpyinfo
->mouse_face_window
= Qnil
;
1341 /* Find the glyph matrix position of buffer position POS in window W.
1342 *HPOS and *VPOS are set to the positions found. W's current glyphs
1343 must be up to date. If POS is above window start return (0, 0).
1344 If POS is after end of W, return end of last line in W. */
1346 fast_find_position (struct window
*w
, int pos
, int *hpos
, int *vpos
)
1348 int i
, lastcol
, line_start_position
, maybe_next_line_p
= 0;
1349 int yb
= window_text_bottom_y (w
);
1350 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0), *best_row
= row
;
1354 if (row
->used
[TEXT_AREA
])
1355 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
1357 line_start_position
= 0;
1359 if (line_start_position
> pos
)
1361 /* If the position sought is the end of the buffer,
1362 don't include the blank lines at the bottom of the window. */
1363 else if (line_start_position
== pos
1364 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
1366 maybe_next_line_p
= 1;
1369 else if (line_start_position
> 0)
1372 /* Don't overstep the last matrix row, lest we get into the
1373 never-never land... */
1374 if (row
->y
+ 1 >= yb
)
1380 /* Find the right column within BEST_ROW. */
1383 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
1385 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + i
;
1388 charpos
= glyph
->charpos
;
1395 else if (charpos
> pos
)
1397 else if (charpos
> 0)
1401 /* If we're looking for the end of the buffer,
1402 and we didn't find it in the line we scanned,
1403 use the start of the following line. */
1404 if (maybe_next_line_p
)
1411 *hpos
= lastcol
+ 1;
1415 /* Take proper action when mouse has moved to the mode or top line of
1416 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
1417 mode line. X is relative to the start of the text display area of
1418 W, so the width of fringes and scroll bars must be subtracted
1419 to get a position relative to the start of the mode line. */
1421 IT_note_mode_line_highlight (struct window
*w
, int x
, int mode_line_p
)
1423 struct frame
*f
= XFRAME (w
->frame
);
1424 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1425 struct glyph_row
*row
;
1428 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1430 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1434 extern Lisp_Object Qhelp_echo
;
1435 struct glyph
*glyph
, *end
;
1436 Lisp_Object help
, map
;
1438 /* Find the glyph under X. */
1439 glyph
= (row
->glyphs
[TEXT_AREA
]
1441 /* in case someone implements scroll bars some day... */
1442 - WINDOW_LEFT_SCROLL_BAR_AREA_WIDTH (w
));
1443 end
= glyph
+ row
->used
[TEXT_AREA
];
1445 && STRINGP (glyph
->object
)
1446 && STRING_INTERVALS (glyph
->object
)
1447 && glyph
->charpos
>= 0
1448 && glyph
->charpos
< SCHARS (glyph
->object
))
1450 /* If we're on a string with `help-echo' text property,
1451 arrange for the help to be displayed. This is done by
1452 setting the global variable help_echo to the help string. */
1453 help
= Fget_text_property (make_number (glyph
->charpos
),
1454 Qhelp_echo
, glyph
->object
);
1457 help_echo_string
= help
;
1458 XSETWINDOW (help_echo_window
, w
);
1459 help_echo_object
= glyph
->object
;
1460 help_echo_pos
= glyph
->charpos
;
1466 /* Take proper action when the mouse has moved to position X, Y on
1467 frame F as regards highlighting characters that have mouse-face
1468 properties. Also de-highlighting chars where the mouse was before.
1469 X and Y can be negative or out of range. */
1471 IT_note_mouse_highlight (struct frame
*f
, int x
, int y
)
1473 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1474 enum window_part part
= ON_NOTHING
;
1478 /* When a menu is active, don't highlight because this looks odd. */
1479 if (mouse_preempted
)
1482 if (NILP (Vmouse_highlight
)
1483 || !f
->glyphs_initialized_p
)
1486 dpyinfo
->mouse_face_mouse_x
= x
;
1487 dpyinfo
->mouse_face_mouse_y
= y
;
1488 dpyinfo
->mouse_face_mouse_frame
= f
;
1490 if (dpyinfo
->mouse_face_defer
)
1495 dpyinfo
->mouse_face_deferred_gc
= 1;
1499 /* Which window is that in? */
1500 window
= window_from_coordinates (f
, x
, y
, &part
, &x
, &y
, 0);
1502 /* If we were displaying active text in another window, clear that. */
1503 if (! EQ (window
, dpyinfo
->mouse_face_window
))
1504 clear_mouse_face (dpyinfo
);
1506 /* Not on a window -> return. */
1507 if (!WINDOWP (window
))
1510 /* Convert to window-relative coordinates. */
1511 w
= XWINDOW (window
);
1513 if (part
== ON_MODE_LINE
|| part
== ON_HEADER_LINE
)
1515 /* Mouse is on the mode or top line. */
1516 IT_note_mode_line_highlight (w
, x
, part
== ON_MODE_LINE
);
1520 IT_set_mouse_pointer (0);
1522 /* Are we in a window whose display is up to date?
1523 And verify the buffer's text has not changed. */
1525 && EQ (w
->window_end_valid
, w
->buffer
)
1526 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
1527 && (XFASTINT (w
->last_overlay_modified
)
1528 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
1530 int pos
, i
, nrows
= w
->current_matrix
->nrows
;
1531 struct glyph_row
*row
;
1532 struct glyph
*glyph
;
1534 /* Find the glyph under X/Y. */
1536 if (y
>= 0 && y
< nrows
)
1538 row
= MATRIX_ROW (w
->current_matrix
, y
);
1539 /* Give up if some row before the one we are looking for is
1541 for (i
= 0; i
<= y
; i
++)
1542 if (!MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
)
1544 if (i
> y
/* all rows upto and including the one at Y are enabled */
1545 && row
->displays_text_p
1546 && x
< window_box_width (w
, TEXT_AREA
))
1548 glyph
= row
->glyphs
[TEXT_AREA
];
1549 if (x
>= row
->used
[TEXT_AREA
])
1554 if (!BUFFERP (glyph
->object
))
1560 /* Clear mouse face if X/Y not over text. */
1563 clear_mouse_face (dpyinfo
);
1567 if (!BUFFERP (glyph
->object
))
1569 pos
= glyph
->charpos
;
1571 /* Check for mouse-face and help-echo. */
1573 extern Lisp_Object Qmouse_face
;
1574 Lisp_Object mouse_face
, overlay
, position
, *overlay_vec
;
1575 int len
, noverlays
, obegv
, ozv
;;
1576 struct buffer
*obuf
;
1578 /* If we get an out-of-range value, return now; avoid an error. */
1579 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1582 /* Make the window's buffer temporarily current for
1583 overlays_at and compute_char_face. */
1584 obuf
= current_buffer
;
1585 current_buffer
= XBUFFER (w
->buffer
);
1591 /* Is this char mouse-active or does it have help-echo? */
1592 XSETINT (position
, pos
);
1594 /* Put all the overlays we want in a vector in overlay_vec.
1595 Store the length in len. If there are more than 10, make
1596 enough space for all, and try again. */
1598 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1599 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
1600 if (noverlays
> len
)
1603 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1604 noverlays
= overlays_at (pos
,
1605 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
1608 /* Sort overlays into increasing priority order. */
1609 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1611 /* Check mouse-face highlighting. */
1612 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
1613 && y
>= dpyinfo
->mouse_face_beg_row
1614 && y
<= dpyinfo
->mouse_face_end_row
1615 && (y
> dpyinfo
->mouse_face_beg_row
1616 || x
>= dpyinfo
->mouse_face_beg_col
)
1617 && (y
< dpyinfo
->mouse_face_end_row
1618 || x
< dpyinfo
->mouse_face_end_col
1619 || dpyinfo
->mouse_face_past_end
)))
1621 /* Clear the display of the old active region, if any. */
1622 clear_mouse_face (dpyinfo
);
1624 /* Find highest priority overlay that has a mouse-face prop. */
1626 for (i
= noverlays
- 1; i
>= 0; --i
)
1628 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1629 if (!NILP (mouse_face
))
1631 overlay
= overlay_vec
[i
];
1636 /* If no overlay applies, get a text property. */
1638 mouse_face
= Fget_text_property (position
, Qmouse_face
,
1641 /* Handle the overlay case. */
1642 if (! NILP (overlay
))
1644 /* Find the range of text around this char that
1645 should be active. */
1646 Lisp_Object before
, after
;
1649 before
= Foverlay_start (overlay
);
1650 after
= Foverlay_end (overlay
);
1651 /* Record this as the current active region. */
1652 fast_find_position (w
, XFASTINT (before
),
1653 &dpyinfo
->mouse_face_beg_col
,
1654 &dpyinfo
->mouse_face_beg_row
);
1655 dpyinfo
->mouse_face_past_end
1656 = !fast_find_position (w
, XFASTINT (after
),
1657 &dpyinfo
->mouse_face_end_col
,
1658 &dpyinfo
->mouse_face_end_row
);
1659 dpyinfo
->mouse_face_window
= window
;
1660 dpyinfo
->mouse_face_face_id
1661 = face_at_buffer_position (w
, pos
, 0, 0,
1663 !dpyinfo
->mouse_face_hidden
);
1665 /* Display it as active. */
1666 show_mouse_face (dpyinfo
, 1);
1668 /* Handle the text property case. */
1669 else if (! NILP (mouse_face
))
1671 /* Find the range of text around this char that
1672 should be active. */
1673 Lisp_Object before
, after
, beginning
, end
;
1676 beginning
= Fmarker_position (w
->start
);
1677 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
1678 - XFASTINT (w
->window_end_pos
)));
1680 = Fprevious_single_property_change (make_number (pos
+ 1),
1682 w
->buffer
, beginning
);
1684 = Fnext_single_property_change (position
, Qmouse_face
,
1686 /* Record this as the current active region. */
1687 fast_find_position (w
, XFASTINT (before
),
1688 &dpyinfo
->mouse_face_beg_col
,
1689 &dpyinfo
->mouse_face_beg_row
);
1690 dpyinfo
->mouse_face_past_end
1691 = !fast_find_position (w
, XFASTINT (after
),
1692 &dpyinfo
->mouse_face_end_col
,
1693 &dpyinfo
->mouse_face_end_row
);
1694 dpyinfo
->mouse_face_window
= window
;
1695 dpyinfo
->mouse_face_face_id
1696 = face_at_buffer_position (w
, pos
, 0, 0,
1698 !dpyinfo
->mouse_face_hidden
);
1700 /* Display it as active. */
1701 show_mouse_face (dpyinfo
, 1);
1705 /* Look for a `help-echo' property. */
1708 extern Lisp_Object Qhelp_echo
;
1710 /* Check overlays first. */
1712 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
1714 overlay
= overlay_vec
[i
];
1715 help
= Foverlay_get (overlay
, Qhelp_echo
);
1720 help_echo_string
= help
;
1721 help_echo_window
= window
;
1722 help_echo_object
= overlay
;
1723 help_echo_pos
= pos
;
1725 /* Try text properties. */
1726 else if (NILP (help
)
1727 && ((STRINGP (glyph
->object
)
1728 && glyph
->charpos
>= 0
1729 && glyph
->charpos
< SCHARS (glyph
->object
))
1730 || (BUFFERP (glyph
->object
)
1731 && glyph
->charpos
>= BEGV
1732 && glyph
->charpos
< ZV
)))
1734 help
= Fget_text_property (make_number (glyph
->charpos
),
1735 Qhelp_echo
, glyph
->object
);
1738 help_echo_string
= help
;
1739 help_echo_window
= window
;
1740 help_echo_object
= glyph
->object
;
1741 help_echo_pos
= glyph
->charpos
;
1748 current_buffer
= obuf
;
1754 IT_clear_end_of_line (int first_unused
)
1757 int i
, j
, offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
1758 extern int fatal_error_in_progress
;
1760 if (new_pos_X
>= first_unused
|| fatal_error_in_progress
)
1764 i
= (j
= first_unused
- new_pos_X
) * 2;
1766 fprintf (termscript
, "<CLR:EOL[%d..%d)>", new_pos_X
, first_unused
);
1767 spaces
= sp
= alloca (i
);
1772 *sp
++ = ScreenAttrib
;
1776 dosmemput (spaces
, i
, (int)ScreenPrimary
+ offset
);
1777 if (screen_virtual_segment
)
1778 dosv_refresh_virtual_screen (offset
, i
/ 2);
1780 /* clear_end_of_line_raw on term.c leaves the cursor at first_unused.
1781 Let's follow their lead, in case someone relies on this. */
1782 new_pos_X
= first_unused
;
1786 IT_clear_screen (void)
1789 fprintf (termscript
, "<CLR:SCR>");
1790 /* We are sometimes called (from clear_garbaged_frames) when a new
1791 frame is being created, but its faces are not yet realized. In
1792 such a case we cannot call IT_set_face, since it will fail to find
1793 any valid faces and will abort. Instead, use the initial screen
1794 colors; that should mimic what a Unix tty does, which simply clears
1795 the screen with whatever default colors are in use. */
1796 if (FACE_FROM_ID (SELECTED_FRAME (), DEFAULT_FACE_ID
) == NULL
)
1797 ScreenAttrib
= (initial_screen_colors
[0] << 4) | initial_screen_colors
[1];
1802 if (screen_virtual_segment
)
1803 dosv_refresh_virtual_screen (0, screen_size
);
1804 new_pos_X
= new_pos_Y
= 0;
1808 IT_clear_to_end (void)
1811 fprintf (termscript
, "<CLR:EOS>");
1813 while (new_pos_Y
< screen_size_Y
) {
1815 IT_clear_end_of_line (screen_size_X
);
1821 IT_cursor_to (int y
, int x
)
1824 fprintf (termscript
, "\n<XY=%dx%d>", x
, y
);
1829 static int cursor_cleared
;
1832 IT_display_cursor (int on
)
1834 if (on
&& cursor_cleared
)
1836 ScreenSetCursor (current_pos_Y
, current_pos_X
);
1839 else if (!on
&& !cursor_cleared
)
1841 ScreenSetCursor (-1, -1);
1846 /* Emacs calls cursor-movement functions a lot when it updates the
1847 display (probably a legacy of old terminals where you cannot
1848 update a screen line without first moving the cursor there).
1849 However, cursor movement is expensive on MSDOS (it calls a slow
1850 BIOS function and requires 2 mode switches), while actual screen
1851 updates access the video memory directly and don't depend on
1852 cursor position. To avoid slowing down the redisplay, we cheat:
1853 all functions that move the cursor only set internal variables
1854 which record the cursor position, whereas the cursor is only
1855 moved to its final position whenever screen update is complete.
1857 `IT_cmgoto' is called from the keyboard reading loop and when the
1858 frame update is complete. This means that we are ready for user
1859 input, so we update the cursor position to show where the point is,
1860 and also make the mouse pointer visible.
1862 Special treatment is required when the cursor is in the echo area,
1863 to put the cursor at the end of the text displayed there. */
1866 IT_cmgoto (FRAME_PTR f
)
1868 /* Only set the cursor to where it should be if the display is
1869 already in sync with the window contents. */
1870 int update_cursor_pos
= 1; /* MODIFF == unchanged_modified; */
1872 /* FIXME: This needs to be rewritten for the new redisplay, or
1875 static int previous_pos_X
= -1;
1877 update_cursor_pos
= 1; /* temporary!!! */
1879 /* If the display is in sync, forget any previous knowledge about
1880 cursor position. This is primarily for unexpected events like
1881 C-g in the minibuffer. */
1882 if (update_cursor_pos
&& previous_pos_X
>= 0)
1883 previous_pos_X
= -1;
1884 /* If we are in the echo area, put the cursor at the
1885 end of the echo area message. */
1886 if (!update_cursor_pos
1887 && WINDOW_TOP_EDGE_LINE (XWINDOW (FRAME_MINIBUF_WINDOW (f
))) <= new_pos_Y
)
1889 int tem_X
= current_pos_X
, dummy
;
1891 if (echo_area_glyphs
)
1893 tem_X
= echo_area_glyphs_length
;
1894 /* Save current cursor position, to be restored after the
1895 echo area message is erased. Only remember one level
1896 of previous cursor position. */
1897 if (previous_pos_X
== -1)
1898 ScreenGetCursor (&dummy
, &previous_pos_X
);
1900 else if (previous_pos_X
>= 0)
1902 /* We wind up here after the echo area message is erased.
1903 Restore the cursor position we remembered above. */
1904 tem_X
= previous_pos_X
;
1905 previous_pos_X
= -1;
1908 if (current_pos_X
!= tem_X
)
1911 update_cursor_pos
= 1;
1916 if (update_cursor_pos
1917 && (current_pos_X
!= new_pos_X
|| current_pos_Y
!= new_pos_Y
))
1919 ScreenSetCursor (current_pos_Y
= new_pos_Y
, current_pos_X
= new_pos_X
);
1921 fprintf (termscript
, "\n<CURSOR:%dx%d>", current_pos_X
, current_pos_Y
);
1924 /* Maybe cursor is invisible, so make it visible. */
1925 IT_display_cursor (1);
1927 /* Mouse pointer should be always visible if we are waiting for
1934 IT_update_begin (struct frame
*f
)
1936 struct display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
1937 struct frame
*mouse_face_frame
= display_info
->mouse_face_mouse_frame
;
1941 if (f
&& f
== mouse_face_frame
)
1943 /* Don't do highlighting for mouse motion during the update. */
1944 display_info
->mouse_face_defer
= 1;
1946 /* If F needs to be redrawn, simply forget about any prior mouse
1948 if (FRAME_GARBAGED_P (f
))
1949 display_info
->mouse_face_window
= Qnil
;
1951 /* Can we tell that this update does not affect the window
1952 where the mouse highlight is? If so, no need to turn off.
1953 Likewise, don't do anything if none of the enabled rows
1954 contains glyphs highlighted in mouse face. */
1955 if (!NILP (display_info
->mouse_face_window
)
1956 && WINDOWP (display_info
->mouse_face_window
))
1958 struct window
*w
= XWINDOW (display_info
->mouse_face_window
);
1961 /* If the mouse highlight is in the window that was deleted
1962 (e.g., if it was popped by completion), clear highlight
1964 if (NILP (w
->buffer
))
1965 display_info
->mouse_face_window
= Qnil
;
1968 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
1969 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
)
1970 && MATRIX_ROW (w
->current_matrix
, i
)->mouse_face_p
)
1974 if (NILP (w
->buffer
) || i
< w
->desired_matrix
->nrows
)
1975 clear_mouse_face (display_info
);
1978 else if (mouse_face_frame
&& !FRAME_LIVE_P (mouse_face_frame
))
1980 /* If the frame with mouse highlight was deleted, invalidate the
1982 display_info
->mouse_face_beg_row
= display_info
->mouse_face_beg_col
= -1;
1983 display_info
->mouse_face_end_row
= display_info
->mouse_face_end_col
= -1;
1984 display_info
->mouse_face_window
= Qnil
;
1985 display_info
->mouse_face_deferred_gc
= 0;
1986 display_info
->mouse_face_mouse_frame
= NULL
;
1993 IT_update_end (struct frame
*f
)
1995 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
1999 IT_frame_up_to_date (struct frame
*f
)
2001 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2002 Lisp_Object new_cursor
, frame_desired_cursor
;
2005 if (dpyinfo
->mouse_face_deferred_gc
2006 || (f
&& f
== dpyinfo
->mouse_face_mouse_frame
))
2009 if (dpyinfo
->mouse_face_mouse_frame
)
2010 IT_note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
2011 dpyinfo
->mouse_face_mouse_x
,
2012 dpyinfo
->mouse_face_mouse_y
);
2013 dpyinfo
->mouse_face_deferred_gc
= 0;
2017 /* Set the cursor type to whatever they wanted. In a minibuffer
2018 window, we want the cursor to appear only if we are reading input
2019 from this window, and we want the cursor to be taken from the
2020 frame parameters. For the selected window, we use either its
2021 buffer-local value or the value from the frame parameters if the
2022 buffer doesn't define its local value for the cursor type. */
2023 sw
= XWINDOW (f
->selected_window
);
2024 frame_desired_cursor
= Fcdr (Fassq (Qcursor_type
, f
->param_alist
));
2025 if (cursor_in_echo_area
2026 && FRAME_HAS_MINIBUF_P (f
)
2027 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
)
2028 && sw
== XWINDOW (echo_area_window
))
2029 new_cursor
= frame_desired_cursor
;
2032 struct buffer
*b
= XBUFFER (sw
->buffer
);
2034 if (EQ (b
->cursor_type
, Qt
))
2035 new_cursor
= frame_desired_cursor
;
2036 else if (NILP (b
->cursor_type
)) /* nil means no cursor */
2037 new_cursor
= Fcons (Qbar
, make_number (0));
2039 new_cursor
= b
->cursor_type
;
2042 IT_set_cursor_type (f
, new_cursor
);
2044 IT_cmgoto (f
); /* position cursor when update is done */
2047 /* Copy LEN glyphs displayed on a single line whose vertical position
2048 is YPOS, beginning at horizontal position XFROM to horizontal
2049 position XTO, by moving blocks in the video memory. Used by
2050 functions that insert and delete glyphs. */
2052 IT_copy_glyphs (int xfrom
, int xto
, size_t len
, int ypos
)
2054 /* The offsets of source and destination relative to the
2055 conventional memorty selector. */
2056 int from
= 2 * (xfrom
+ screen_size_X
* ypos
) + ScreenPrimary
;
2057 int to
= 2 * (xto
+ screen_size_X
* ypos
) + ScreenPrimary
;
2059 if (from
== to
|| len
<= 0)
2062 _farsetsel (_dos_ds
);
2064 /* The source and destination might overlap, so we need to move
2065 glyphs non-destructively. */
2068 for ( ; len
; from
+= 2, to
+= 2, len
--)
2069 _farnspokew (to
, _farnspeekw (from
));
2073 from
+= (len
- 1) * 2;
2074 to
+= (len
- 1) * 2;
2075 for ( ; len
; from
-= 2, to
-= 2, len
--)
2076 _farnspokew (to
, _farnspeekw (from
));
2078 if (screen_virtual_segment
)
2079 dosv_refresh_virtual_screen (ypos
* screen_size_X
* 2, screen_size_X
);
2082 /* Insert and delete glyphs. */
2084 IT_insert_glyphs (start
, len
)
2085 register struct glyph
*start
;
2088 int shift_by_width
= screen_size_X
- (new_pos_X
+ len
);
2090 /* Shift right the glyphs from the nominal cursor position to the
2091 end of this line. */
2092 IT_copy_glyphs (new_pos_X
, new_pos_X
+ len
, shift_by_width
, new_pos_Y
);
2094 /* Now write the glyphs to be inserted. */
2095 IT_write_glyphs (start
, len
);
2099 IT_delete_glyphs (n
)
2105 /* set-window-configuration on window.c needs this. */
2107 x_set_menu_bar_lines (f
, value
, oldval
)
2109 Lisp_Object value
, oldval
;
2111 set_menu_bar_lines (f
, value
, oldval
);
2114 /* This was copied from xfaces.c */
2116 extern Lisp_Object Qbackground_color
;
2117 extern Lisp_Object Qforeground_color
;
2118 Lisp_Object Qreverse
;
2119 extern Lisp_Object Qtitle
;
2121 /* IT_set_terminal_modes is called when emacs is started,
2122 resumed, and whenever the screen is redrawn! */
2125 IT_set_terminal_modes (void)
2128 fprintf (termscript
, "\n<SET_TERM>");
2130 screen_size_X
= ScreenCols ();
2131 screen_size_Y
= ScreenRows ();
2132 screen_size
= screen_size_X
* screen_size_Y
;
2134 new_pos_X
= new_pos_Y
= 0;
2135 current_pos_X
= current_pos_Y
= -1;
2137 if (term_setup_done
)
2139 term_setup_done
= 1;
2141 startup_screen_size_X
= screen_size_X
;
2142 startup_screen_size_Y
= screen_size_Y
;
2143 startup_screen_attrib
= ScreenAttrib
;
2146 /* Is DOS/V (or any other RSIS software which relocates
2147 the screen) installed? */
2149 unsigned short es_value
;
2152 regs
.h
.ah
= 0xfe; /* get relocated screen address */
2153 if (ScreenPrimary
== 0xb0000UL
|| ScreenPrimary
== 0xb8000UL
)
2154 regs
.x
.es
= (ScreenPrimary
>> 4) & 0xffff;
2155 else if (screen_old_address
) /* already switched to Japanese mode once */
2156 regs
.x
.es
= (screen_old_address
>> 4) & 0xffff;
2158 regs
.x
.es
= ScreenMode () == 7 ? 0xb000 : 0xb800;
2160 es_value
= regs
.x
.es
;
2161 __dpmi_int (0x10, ®s
);
2163 if (regs
.x
.es
!= es_value
)
2165 /* screen_old_address is only set if ScreenPrimary does NOT
2166 already point to the relocated buffer address returned by
2167 the Int 10h/AX=FEh call above. DJGPP v2.02 and later sets
2168 ScreenPrimary to that address at startup under DOS/V. */
2169 if (regs
.x
.es
!= (ScreenPrimary
>> 4) & 0xffff)
2170 screen_old_address
= ScreenPrimary
;
2171 screen_virtual_segment
= regs
.x
.es
;
2172 screen_virtual_offset
= regs
.x
.di
;
2173 ScreenPrimary
= (screen_virtual_segment
<< 4) + screen_virtual_offset
;
2176 #endif /* __DJGPP__ > 1 */
2178 ScreenGetCursor (&startup_pos_Y
, &startup_pos_X
);
2179 ScreenRetrieve (startup_screen_buffer
= xmalloc (screen_size
* 2));
2182 fprintf (termscript
, "<SCREEN SAVED (dimensions=%dx%d)>\n",
2183 screen_size_X
, screen_size_Y
);
2188 /* IT_reset_terminal_modes is called when emacs is
2189 suspended or killed. */
2192 IT_reset_terminal_modes (void)
2194 int display_row_start
= (int) ScreenPrimary
;
2195 int saved_row_len
= startup_screen_size_X
* 2;
2196 int update_row_len
= ScreenCols () * 2, current_rows
= ScreenRows ();
2197 int to_next_row
= update_row_len
;
2198 unsigned char *saved_row
= startup_screen_buffer
;
2199 int cursor_pos_X
= ScreenCols () - 1, cursor_pos_Y
= ScreenRows () - 1;
2202 fprintf (termscript
, "\n<RESET_TERM>");
2204 if (!term_setup_done
)
2209 /* Leave the video system in the same state as we found it,
2210 as far as the blink/bright-background bit is concerned. */
2211 maybe_enable_blinking ();
2213 /* We have a situation here.
2214 We cannot just do ScreenUpdate(startup_screen_buffer) because
2215 the luser could have changed screen dimensions inside Emacs
2216 and failed (or didn't want) to restore them before killing
2217 Emacs. ScreenUpdate() uses the *current* screen dimensions and
2218 thus will happily use memory outside what was allocated for
2219 `startup_screen_buffer'.
2220 Thus we only restore as much as the current screen dimensions
2221 can hold, and clear the rest (if the saved screen is smaller than
2222 the current) with the color attribute saved at startup. The cursor
2223 is also restored within the visible dimensions. */
2225 ScreenAttrib
= startup_screen_attrib
;
2227 /* Don't restore the screen if we are exiting less than 2 seconds
2228 after startup: we might be crashing, and the screen might show
2229 some vital clues to what's wrong. */
2230 if (clock () - startup_time
>= 2*CLOCKS_PER_SEC
)
2233 if (screen_virtual_segment
)
2234 dosv_refresh_virtual_screen (0, screen_size
);
2236 if (update_row_len
> saved_row_len
)
2237 update_row_len
= saved_row_len
;
2238 if (current_rows
> startup_screen_size_Y
)
2239 current_rows
= startup_screen_size_Y
;
2242 fprintf (termscript
, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
2243 update_row_len
/ 2, current_rows
);
2245 while (current_rows
--)
2247 dosmemput (saved_row
, update_row_len
, display_row_start
);
2248 if (screen_virtual_segment
)
2249 dosv_refresh_virtual_screen (display_row_start
- ScreenPrimary
,
2250 update_row_len
/ 2);
2251 saved_row
+= saved_row_len
;
2252 display_row_start
+= to_next_row
;
2255 if (startup_pos_X
< cursor_pos_X
)
2256 cursor_pos_X
= startup_pos_X
;
2257 if (startup_pos_Y
< cursor_pos_Y
)
2258 cursor_pos_Y
= startup_pos_Y
;
2260 ScreenSetCursor (cursor_pos_Y
, cursor_pos_X
);
2261 xfree (startup_screen_buffer
);
2263 term_setup_done
= 0;
2267 IT_set_terminal_window (int foo
)
2271 /* Remember the screen colors of the curent frame, to serve as the
2272 default colors for newly-created frames. */
2273 DEFUN ("msdos-remember-default-colors", Fmsdos_remember_default_colors
,
2274 Smsdos_remember_default_colors
, 1, 1, 0,
2275 doc
: /* Remember the screen colors of the current frame. */)
2281 CHECK_FRAME (frame
);
2284 /* This function is called after applying default-frame-alist to the
2285 initial frame. At that time, if reverse-colors option was
2286 specified in default-frame-alist, it was already applied, and
2287 frame colors are reversed. We need to account for that. */
2288 if (EQ (Fcdr (Fassq (Qreverse
, f
->param_alist
)), Qt
))
2290 initial_screen_colors
[0] = FRAME_BACKGROUND_PIXEL (f
);
2291 initial_screen_colors
[1] = FRAME_FOREGROUND_PIXEL (f
);
2295 initial_screen_colors
[0] = FRAME_FOREGROUND_PIXEL (f
);
2296 initial_screen_colors
[1] = FRAME_BACKGROUND_PIXEL (f
);
2301 IT_set_frame_parameters (f
, alist
)
2306 int i
, j
, length
= XINT (Flength (alist
));
2308 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2310 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2311 /* Do we have to reverse the foreground and background colors? */
2312 int reverse
= EQ (Fcdr (Fassq (Qreverse
, f
->param_alist
)), Qt
);
2313 int need_to_reverse
, was_reverse
= reverse
;
2314 int redraw
= 0, fg_set
= 0, bg_set
= 0;
2315 unsigned long orig_fg
, orig_bg
;
2316 Lisp_Object frame_bg
, frame_fg
;
2317 extern Lisp_Object Qdefault
, QCforeground
, QCbackground
;
2319 /* If we are creating a new frame, begin with the original screen colors
2320 used for the initial frame. */
2321 if (alist
== Vdefault_frame_alist
2322 && initial_screen_colors
[0] != -1 && initial_screen_colors
[1] != -1)
2324 FRAME_FOREGROUND_PIXEL (f
) = initial_screen_colors
[0];
2325 FRAME_BACKGROUND_PIXEL (f
) = initial_screen_colors
[1];
2327 orig_fg
= FRAME_FOREGROUND_PIXEL (f
);
2328 orig_bg
= FRAME_BACKGROUND_PIXEL (f
);
2329 frame_fg
= Fcdr (Fassq (Qforeground_color
, f
->param_alist
));
2330 frame_bg
= Fcdr (Fassq (Qbackground_color
, f
->param_alist
));
2331 /* frame_fg and frame_bg could be nil if, for example,
2332 f->param_alist is nil, e.g. if we are called from
2333 Fmake_terminal_frame. */
2334 if (NILP (frame_fg
))
2335 frame_fg
= build_string (unspecified_fg
);
2336 if (NILP (frame_bg
))
2337 frame_bg
= build_string (unspecified_bg
);
2339 /* Extract parm names and values into those vectors. */
2341 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2346 parms
[i
] = Fcar (elt
);
2347 CHECK_SYMBOL (parms
[i
]);
2348 values
[i
] = Fcdr (elt
);
2354 for (i
= 0; i
< j
; i
++)
2356 Lisp_Object prop
, val
;
2361 if (EQ (prop
, Qreverse
))
2362 reverse
= EQ (val
, Qt
);
2365 need_to_reverse
= reverse
&& !was_reverse
;
2366 if (termscript
&& need_to_reverse
)
2367 fprintf (termscript
, "<INVERSE-VIDEO>\n");
2369 /* Now process the alist elements in reverse of specified order. */
2370 for (i
--; i
>= 0; i
--)
2372 Lisp_Object prop
, val
, frame
;
2377 if (EQ (prop
, Qforeground_color
))
2379 unsigned long new_color
= load_color (f
, NULL
, val
, need_to_reverse
2380 ? LFACE_BACKGROUND_INDEX
2381 : LFACE_FOREGROUND_INDEX
);
2382 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2383 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2384 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2386 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2387 /* Make sure the foreground of the default face for this
2388 frame is changed as well. */
2389 XSETFRAME (frame
, f
);
2390 if (need_to_reverse
)
2392 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2394 prop
= Qbackground_color
;
2399 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2405 fprintf (termscript
, "<FGCOLOR %lu>\n", new_color
);
2408 else if (EQ (prop
, Qbackground_color
))
2410 unsigned long new_color
= load_color (f
, NULL
, val
, need_to_reverse
2411 ? LFACE_FOREGROUND_INDEX
2412 : LFACE_BACKGROUND_INDEX
);
2413 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2414 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2415 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2417 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2418 /* Make sure the background of the default face for this
2419 frame is changed as well. */
2420 XSETFRAME (frame
, f
);
2421 if (need_to_reverse
)
2423 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2425 prop
= Qforeground_color
;
2430 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2436 fprintf (termscript
, "<BGCOLOR %lu>\n", new_color
);
2439 else if (EQ (prop
, Qtitle
))
2441 x_set_title (f
, val
);
2443 fprintf (termscript
, "<TITLE: %s>\n", SDATA (val
));
2445 else if (EQ (prop
, Qcursor_type
))
2447 IT_set_cursor_type (f
, val
);
2449 fprintf (termscript
, "<CTYPE: %s>\n",
2450 EQ (val
, Qbar
) || EQ (val
, Qhbar
)
2451 || CONSP (val
) && (EQ (XCAR (val
), Qbar
)
2452 || EQ (XCAR (val
), Qhbar
))
2455 store_frame_param (f
, prop
, val
);
2458 /* If they specified "reverse", but not the colors, we need to swap
2459 the current frame colors. */
2460 if (need_to_reverse
)
2466 XSETFRAME (frame
, f
);
2467 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2468 tty_color_name (f
, orig_bg
),
2474 XSETFRAME (frame
, f
);
2475 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2476 tty_color_name (f
, orig_fg
),
2484 face_change_count
++; /* forces xdisp.c to recompute basic faces */
2485 if (f
== SELECTED_FRAME())
2490 extern void init_frame_faces (FRAME_PTR
);
2492 #endif /* !HAVE_X_WINDOWS */
2495 /* Do we need the internal terminal? */
2498 internal_terminal_init ()
2500 char *term
= getenv ("TERM"), *colors
;
2501 struct frame
*sf
= SELECTED_FRAME();
2503 #ifdef HAVE_X_WINDOWS
2504 if (!inhibit_window_system
)
2509 = (!noninteractive
) && term
&& !strcmp (term
, "internal");
2511 if (getenv ("EMACSTEST"))
2512 termscript
= fopen (getenv ("EMACSTEST"), "wt");
2514 #ifndef HAVE_X_WINDOWS
2515 if (!internal_terminal
|| inhibit_window_system
)
2517 sf
->output_method
= output_termcap
;
2521 Vwindow_system
= intern ("pc");
2522 Vwindow_system_version
= make_number (1);
2523 sf
->output_method
= output_msdos_raw
;
2525 /* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
2526 screen_old_address
= 0;
2528 /* Forget the stale screen colors as well. */
2529 initial_screen_colors
[0] = initial_screen_colors
[1] = -1;
2531 bzero (&the_only_x_display
, sizeof the_only_x_display
);
2532 the_only_x_display
.background_pixel
= 7; /* White */
2533 the_only_x_display
.foreground_pixel
= 0; /* Black */
2535 colors
= getenv ("EMACSCOLORS");
2536 if (colors
&& strlen (colors
) >= 2)
2538 /* The colors use 4 bits each (we enable bright background). */
2539 if (isdigit (colors
[0]))
2541 else if (isxdigit (colors
[0]))
2542 colors
[0] -= (isupper (colors
[0]) ? 'A' : 'a') - 10;
2543 if (colors
[0] >= 0 && colors
[0] < 16)
2544 the_only_x_display
.foreground_pixel
= colors
[0];
2545 if (isdigit (colors
[1]))
2547 else if (isxdigit (colors
[1]))
2548 colors
[1] -= (isupper (colors
[1]) ? 'A' : 'a') - 10;
2549 if (colors
[1] >= 0 && colors
[1] < 16)
2550 the_only_x_display
.background_pixel
= colors
[1];
2552 the_only_x_display
.font
= (XFontStruct
*)1; /* must *not* be zero */
2553 the_only_x_display
.display_info
.mouse_face_mouse_frame
= NULL
;
2554 the_only_x_display
.display_info
.mouse_face_deferred_gc
= 0;
2555 the_only_x_display
.display_info
.mouse_face_beg_row
=
2556 the_only_x_display
.display_info
.mouse_face_beg_col
= -1;
2557 the_only_x_display
.display_info
.mouse_face_end_row
=
2558 the_only_x_display
.display_info
.mouse_face_end_col
= -1;
2559 the_only_x_display
.display_info
.mouse_face_face_id
= DEFAULT_FACE_ID
;
2560 the_only_x_display
.display_info
.mouse_face_window
= Qnil
;
2561 the_only_x_display
.display_info
.mouse_face_mouse_x
=
2562 the_only_x_display
.display_info
.mouse_face_mouse_y
= 0;
2563 the_only_x_display
.display_info
.mouse_face_defer
= 0;
2564 the_only_x_display
.display_info
.mouse_face_hidden
= 0;
2566 init_frame_faces (sf
);
2568 ring_bell_hook
= IT_ring_bell
;
2569 insert_glyphs_hook
= IT_insert_glyphs
;
2570 delete_glyphs_hook
= IT_delete_glyphs
;
2571 write_glyphs_hook
= IT_write_glyphs
;
2572 cursor_to_hook
= raw_cursor_to_hook
= IT_cursor_to
;
2573 clear_to_end_hook
= IT_clear_to_end
;
2574 clear_end_of_line_hook
= IT_clear_end_of_line
;
2575 clear_frame_hook
= IT_clear_screen
;
2576 update_begin_hook
= IT_update_begin
;
2577 update_end_hook
= IT_update_end
;
2578 frame_up_to_date_hook
= IT_frame_up_to_date
;
2580 /* These hooks are called by term.c without being checked. */
2581 set_terminal_modes_hook
= IT_set_terminal_modes
;
2582 reset_terminal_modes_hook
= IT_reset_terminal_modes
;
2583 set_terminal_window_hook
= IT_set_terminal_window
;
2584 char_ins_del_ok
= 0;
2588 dos_get_saved_screen (screen
, rows
, cols
)
2593 #ifndef HAVE_X_WINDOWS
2594 *screen
= startup_screen_buffer
;
2595 *cols
= startup_screen_size_X
;
2596 *rows
= startup_screen_size_Y
;
2597 return *screen
!= (char *)0;
2603 #ifndef HAVE_X_WINDOWS
2605 /* We are not X, but we can emulate it well enough for our needs... */
2609 if (! FRAME_MSDOS_P (SELECTED_FRAME()))
2610 error ("Not running under a window system");
2616 /* ----------------------- Keyboard control ----------------------
2618 * Keymaps reflect the following keyboard layout:
2620 * 0 1 2 3 4 5 6 7 8 9 10 11 12 BS
2621 * TAB 15 16 17 18 19 20 21 22 23 24 25 26 (41)
2622 * CLOK 30 31 32 33 34 35 36 37 38 39 40 (41) RET
2623 * SH () 45 46 47 48 49 50 51 52 53 54 SHIFT
2627 #define Ignore 0x0000
2628 #define Normal 0x0000 /* normal key - alt changes scan-code */
2629 #define FctKey 0x1000 /* func key if c == 0, else c */
2630 #define Special 0x2000 /* func key even if c != 0 */
2631 #define ModFct 0x3000 /* special if mod-keys, else 'c' */
2632 #define Map 0x4000 /* alt scan-code, map to unshift/shift key */
2633 #define KeyPad 0x5000 /* map to insert/kp-0 depending on c == 0xe0 */
2634 #define Grey 0x6000 /* Grey keypad key */
2636 #define Alt 0x0100 /* alt scan-code */
2637 #define Ctrl 0x0200 /* ctrl scan-code */
2638 #define Shift 0x0400 /* shift scan-code */
2640 static int extended_kbd
; /* 101 (102) keyboard present. */
2642 struct kbd_translate
{
2645 unsigned short code
;
2648 struct dos_keyboard_map
2653 struct kbd_translate
*translate_table
;
2657 static struct dos_keyboard_map us_keyboard
= {
2659 /* 01234567890123456789012345678901234567890 12345678901234 */
2660 "`1234567890-= qwertyuiop[] asdfghjkl;'\\ zxcvbnm,./ ",
2661 /* 0123456789012345678901234567890123456789 012345678901234 */
2662 "~!@#$%^&*()_+ QWERTYUIOP{} ASDFGHJKL:\"| ZXCVBNM<>? ",
2663 0, /* no Alt-Gr key */
2664 0 /* no translate table */
2667 static struct dos_keyboard_map fr_keyboard
= {
2669 /* 012 3456789012345678901234567890123456789012345678901234 */
2670 "ý&\82\",(-\8a_\80\85)= azertyuiop^$ qsdfghjklm\97* wxcvbnm;:! ",
2671 /* 0123456789012345678901234567890123456789012345678901234 */
2672 " 1234567890ø+ AZERTYUIOPù\9c QSDFGHJKLM%æ WXCVBN?./õ ",
2673 /* 01234567 89012345678901234567890123456789012345678901234 */
2675 0 /* no translate table */
2679 * Italian keyboard support, country code 39.
2682 * added also {,},` as, respectively, AltGr-8, AltGr-9, AltGr-'
2683 * Donated by Stefano Brozzi <brozzis@mag00.cedi.unipr.it>
2686 static struct kbd_translate it_kbd_translate_table
[] = {
2687 { 0x56, 0x3c, Normal
| 13 },
2688 { 0x56, 0x3e, Normal
| 27 },
2691 static struct dos_keyboard_map it_keyboard
= {
2693 /* 0 123456789012345678901234567890123456789012345678901234 */
2694 "\\1234567890'\8d< qwertyuiop\8a+> asdfghjkl\95\85\97 zxcvbnm,.- ",
2695 /* 01 23456789012345678901234567890123456789012345678901234 */
2696 "|!\"\9c$%&/()=?^> QWERTYUIOP\82* ASDFGHJKL\87øõ ZXCVBNM;:_ ",
2697 /* 0123456789012345678901234567890123456789012345678901234 */
2699 it_kbd_translate_table
2702 static struct dos_keyboard_map dk_keyboard
= {
2704 /* 0123456789012345678901234567890123456789012345678901234 */
2705 "«1234567890+| qwertyuiop\86~ asdfghjkl\91\9b' zxcvbnm,.- ",
2706 /* 01 23456789012345678901234567890123456789012345678901234 */
2707 "õ!\"#$%&/()=?` QWERTYUIOP\8f^ ASDFGHJKL\92\9d* ZXCVBNM;:_ ",
2708 /* 0123456789012345678901234567890123456789012345678901234 */
2710 0 /* no translate table */
2713 static struct kbd_translate jp_kbd_translate_table
[] = {
2714 { 0x73, 0x5c, Normal
| 0 },
2715 { 0x73, 0x5f, Normal
| 0 },
2716 { 0x73, 0x1c, Map
| 0 },
2717 { 0x7d, 0x5c, Normal
| 13 },
2718 { 0x7d, 0x7c, Normal
| 13 },
2719 { 0x7d, 0x1c, Map
| 13 },
2722 static struct dos_keyboard_map jp_keyboard
= {
2724 /* 0123456789012 345678901234567890123456789012345678901234 */
2725 "\\1234567890-^\\ qwertyuiop@[ asdfghjkl;:] zxcvbnm,./ ",
2726 /* 01 23456789012345678901234567890123456789012345678901234 */
2727 "_!\"#$%&'()~=~| QWERTYUIOP`{ ASDFGHJKL+*} ZXCVBNM<>? ",
2728 0, /* no Alt-Gr key */
2729 jp_kbd_translate_table
2732 static struct keyboard_layout_list
2735 struct dos_keyboard_map
*keyboard_map
;
2736 } keyboard_layout_list
[] =
2745 static struct dos_keyboard_map
*keyboard
;
2746 static int keyboard_map_all
;
2747 static int international_keyboard
;
2750 dos_set_keyboard (code
, always
)
2755 _go32_dpmi_registers regs
;
2757 /* See if Keyb.Com is installed (for international keyboard support).
2758 Note: calling Int 2Fh via int86 wedges the DOS box on some versions
2759 of Windows 9X! So don't do that! */
2761 regs
.x
.ss
= regs
.x
.sp
= regs
.x
.flags
= 0;
2762 _go32_dpmi_simulate_int (0x2f, ®s
);
2763 if (regs
.h
.al
== 0xff)
2764 international_keyboard
= 1;
2766 /* Initialize to US settings, for countries that don't have their own. */
2767 keyboard
= keyboard_layout_list
[0].keyboard_map
;
2768 keyboard_map_all
= always
;
2769 dos_keyboard_layout
= 1;
2771 for (i
= 0; i
< (sizeof (keyboard_layout_list
)/sizeof (struct keyboard_layout_list
)); i
++)
2772 if (code
== keyboard_layout_list
[i
].country_code
)
2774 keyboard
= keyboard_layout_list
[i
].keyboard_map
;
2775 keyboard_map_all
= always
;
2776 dos_keyboard_layout
= code
;
2784 unsigned char char_code
; /* normal code */
2785 unsigned char meta_code
; /* M- code */
2786 unsigned char keypad_code
; /* keypad code */
2787 unsigned char editkey_code
; /* edit key */
2788 } keypad_translate_map
[] = {
2789 '0', '0', 0xb0, /* kp-0 */ 0x63, /* insert */
2790 '1', '1', 0xb1, /* kp-1 */ 0x57, /* end */
2791 '2', '2', 0xb2, /* kp-2 */ 0x54, /* down */
2792 '3', '3', 0xb3, /* kp-3 */ 0x56, /* next */
2793 '4', '4', 0xb4, /* kp-4 */ 0x51, /* left */
2794 '5', '5', 0xb5, /* kp-5 */ 0xb5, /* kp-5 */
2795 '6', '6', 0xb6, /* kp-6 */ 0x53, /* right */
2796 '7', '7', 0xb7, /* kp-7 */ 0x50, /* home */
2797 '8', '8', 0xb8, /* kp-8 */ 0x52, /* up */
2798 '9', '9', 0xb9, /* kp-9 */ 0x55, /* prior */
2799 '.', '-', 0xae, /* kp-decimal */ 0xff /* delete */
2804 unsigned char char_code
; /* normal code */
2805 unsigned char keypad_code
; /* keypad code */
2806 } grey_key_translate_map
[] = {
2807 '/', 0xaf, /* kp-decimal */
2808 '*', 0xaa, /* kp-multiply */
2809 '-', 0xad, /* kp-subtract */
2810 '+', 0xab, /* kp-add */
2811 '\r', 0x8d /* kp-enter */
2814 static unsigned short
2815 ibmpc_translate_map
[] =
2817 /* --------------- 00 to 0f --------------- */
2818 Normal
| 0xff, /* Ctrl Break + Alt-NNN */
2819 Alt
| ModFct
| 0x1b, /* Escape */
2820 Normal
| 1, /* '1' */
2821 Normal
| 2, /* '2' */
2822 Normal
| 3, /* '3' */
2823 Normal
| 4, /* '4' */
2824 Normal
| 5, /* '5' */
2825 Normal
| 6, /* '6' */
2826 Normal
| 7, /* '7' */
2827 Normal
| 8, /* '8' */
2828 Normal
| 9, /* '9' */
2829 Normal
| 10, /* '0' */
2830 Normal
| 11, /* '-' */
2831 Normal
| 12, /* '=' */
2832 Special
| 0x08, /* Backspace */
2833 ModFct
| 0x74, /* Tab/Backtab */
2835 /* --------------- 10 to 1f --------------- */
2848 ModFct
| 0x0d, /* Return */
2853 /* --------------- 20 to 2f --------------- */
2862 Map
| 40, /* '\'' */
2864 Ignore
, /* Left shift */
2865 Map
| 41, /* '\\' */
2871 /* --------------- 30 to 3f --------------- */
2878 Ignore
, /* Right shift */
2879 Grey
| 1, /* Grey * */
2881 Normal
| 55, /* ' ' */
2882 Ignore
, /* Caps Lock */
2883 FctKey
| 0xbe, /* F1 */
2884 FctKey
| 0xbf, /* F2 */
2885 FctKey
| 0xc0, /* F3 */
2886 FctKey
| 0xc1, /* F4 */
2887 FctKey
| 0xc2, /* F5 */
2889 /* --------------- 40 to 4f --------------- */
2890 FctKey
| 0xc3, /* F6 */
2891 FctKey
| 0xc4, /* F7 */
2892 FctKey
| 0xc5, /* F8 */
2893 FctKey
| 0xc6, /* F9 */
2894 FctKey
| 0xc7, /* F10 */
2895 Ignore
, /* Num Lock */
2896 Ignore
, /* Scroll Lock */
2897 KeyPad
| 7, /* Home */
2898 KeyPad
| 8, /* Up */
2899 KeyPad
| 9, /* Page Up */
2900 Grey
| 2, /* Grey - */
2901 KeyPad
| 4, /* Left */
2902 KeyPad
| 5, /* Keypad 5 */
2903 KeyPad
| 6, /* Right */
2904 Grey
| 3, /* Grey + */
2905 KeyPad
| 1, /* End */
2907 /* --------------- 50 to 5f --------------- */
2908 KeyPad
| 2, /* Down */
2909 KeyPad
| 3, /* Page Down */
2910 KeyPad
| 0, /* Insert */
2911 KeyPad
| 10, /* Delete */
2912 Shift
| FctKey
| 0xbe, /* (Shift) F1 */
2913 Shift
| FctKey
| 0xbf, /* (Shift) F2 */
2914 Shift
| FctKey
| 0xc0, /* (Shift) F3 */
2915 Shift
| FctKey
| 0xc1, /* (Shift) F4 */
2916 Shift
| FctKey
| 0xc2, /* (Shift) F5 */
2917 Shift
| FctKey
| 0xc3, /* (Shift) F6 */
2918 Shift
| FctKey
| 0xc4, /* (Shift) F7 */
2919 Shift
| FctKey
| 0xc5, /* (Shift) F8 */
2920 Shift
| FctKey
| 0xc6, /* (Shift) F9 */
2921 Shift
| FctKey
| 0xc7, /* (Shift) F10 */
2922 Ctrl
| FctKey
| 0xbe, /* (Ctrl) F1 */
2923 Ctrl
| FctKey
| 0xbf, /* (Ctrl) F2 */
2925 /* --------------- 60 to 6f --------------- */
2926 Ctrl
| FctKey
| 0xc0, /* (Ctrl) F3 */
2927 Ctrl
| FctKey
| 0xc1, /* (Ctrl) F4 */
2928 Ctrl
| FctKey
| 0xc2, /* (Ctrl) F5 */
2929 Ctrl
| FctKey
| 0xc3, /* (Ctrl) F6 */
2930 Ctrl
| FctKey
| 0xc4, /* (Ctrl) F7 */
2931 Ctrl
| FctKey
| 0xc5, /* (Ctrl) F8 */
2932 Ctrl
| FctKey
| 0xc6, /* (Ctrl) F9 */
2933 Ctrl
| FctKey
| 0xc7, /* (Ctrl) F10 */
2934 Alt
| FctKey
| 0xbe, /* (Alt) F1 */
2935 Alt
| FctKey
| 0xbf, /* (Alt) F2 */
2936 Alt
| FctKey
| 0xc0, /* (Alt) F3 */
2937 Alt
| FctKey
| 0xc1, /* (Alt) F4 */
2938 Alt
| FctKey
| 0xc2, /* (Alt) F5 */
2939 Alt
| FctKey
| 0xc3, /* (Alt) F6 */
2940 Alt
| FctKey
| 0xc4, /* (Alt) F7 */
2941 Alt
| FctKey
| 0xc5, /* (Alt) F8 */
2943 /* --------------- 70 to 7f --------------- */
2944 Alt
| FctKey
| 0xc6, /* (Alt) F9 */
2945 Alt
| FctKey
| 0xc7, /* (Alt) F10 */
2946 Ctrl
| FctKey
| 0x6d, /* (Ctrl) Sys Rq */
2947 Ctrl
| KeyPad
| 4, /* (Ctrl) Left */
2948 Ctrl
| KeyPad
| 6, /* (Ctrl) Right */
2949 Ctrl
| KeyPad
| 1, /* (Ctrl) End */
2950 Ctrl
| KeyPad
| 3, /* (Ctrl) Page Down */
2951 Ctrl
| KeyPad
| 7, /* (Ctrl) Home */
2952 Alt
| Map
| 1, /* '1' */
2953 Alt
| Map
| 2, /* '2' */
2954 Alt
| Map
| 3, /* '3' */
2955 Alt
| Map
| 4, /* '4' */
2956 Alt
| Map
| 5, /* '5' */
2957 Alt
| Map
| 6, /* '6' */
2958 Alt
| Map
| 7, /* '7' */
2959 Alt
| Map
| 8, /* '8' */
2961 /* --------------- 80 to 8f --------------- */
2962 Alt
| Map
| 9, /* '9' */
2963 Alt
| Map
| 10, /* '0' */
2964 Alt
| Map
| 11, /* '-' */
2965 Alt
| Map
| 12, /* '=' */
2966 Ctrl
| KeyPad
| 9, /* (Ctrl) Page Up */
2967 FctKey
| 0xc8, /* F11 */
2968 FctKey
| 0xc9, /* F12 */
2969 Shift
| FctKey
| 0xc8, /* (Shift) F11 */
2970 Shift
| FctKey
| 0xc9, /* (Shift) F12 */
2971 Ctrl
| FctKey
| 0xc8, /* (Ctrl) F11 */
2972 Ctrl
| FctKey
| 0xc9, /* (Ctrl) F12 */
2973 Alt
| FctKey
| 0xc8, /* (Alt) F11 */
2974 Alt
| FctKey
| 0xc9, /* (Alt) F12 */
2975 Ctrl
| KeyPad
| 8, /* (Ctrl) Up */
2976 Ctrl
| Grey
| 2, /* (Ctrl) Grey - */
2977 Ctrl
| KeyPad
| 5, /* (Ctrl) Keypad 5 */
2979 /* --------------- 90 to 9f --------------- */
2980 Ctrl
| Grey
| 3, /* (Ctrl) Grey + */
2981 Ctrl
| KeyPad
| 2, /* (Ctrl) Down */
2982 Ctrl
| KeyPad
| 0, /* (Ctrl) Insert */
2983 Ctrl
| KeyPad
| 10, /* (Ctrl) Delete */
2984 Ctrl
| FctKey
| 0x09, /* (Ctrl) Tab */
2985 Ctrl
| Grey
| 0, /* (Ctrl) Grey / */
2986 Ctrl
| Grey
| 1, /* (Ctrl) Grey * */
2987 Alt
| FctKey
| 0x50, /* (Alt) Home */
2988 Alt
| FctKey
| 0x52, /* (Alt) Up */
2989 Alt
| FctKey
| 0x55, /* (Alt) Page Up */
2990 Ignore
, /* NO KEY */
2991 Alt
| FctKey
| 0x51, /* (Alt) Left */
2992 Ignore
, /* NO KEY */
2993 Alt
| FctKey
| 0x53, /* (Alt) Right */
2994 Ignore
, /* NO KEY */
2995 Alt
| FctKey
| 0x57, /* (Alt) End */
2997 /* --------------- a0 to af --------------- */
2998 Alt
| KeyPad
| 2, /* (Alt) Down */
2999 Alt
| KeyPad
| 3, /* (Alt) Page Down */
3000 Alt
| KeyPad
| 0, /* (Alt) Insert */
3001 Alt
| KeyPad
| 10, /* (Alt) Delete */
3002 Alt
| Grey
| 0, /* (Alt) Grey / */
3003 Alt
| FctKey
| 0x09, /* (Alt) Tab */
3004 Alt
| Grey
| 4 /* (Alt) Keypad Enter */
3007 /* These bit-positions corresponds to values returned by BIOS */
3008 #define SHIFT_P 0x0003 /* two bits! */
3009 #define CTRL_P 0x0004
3010 #define ALT_P 0x0008
3011 #define SCRLOCK_P 0x0010
3012 #define NUMLOCK_P 0x0020
3013 #define CAPSLOCK_P 0x0040
3014 #define ALT_GR_P 0x0800
3015 #define SUPER_P 0x4000 /* pseudo */
3016 #define HYPER_P 0x8000 /* pseudo */
3019 dos_get_modifiers (keymask
)
3023 int mask
, modifiers
= 0;
3025 /* Calculate modifier bits */
3026 regs
.h
.ah
= extended_kbd
? 0x12 : 0x02;
3027 int86 (0x16, ®s
, ®s
);
3031 mask
= regs
.h
.al
& (SHIFT_P
| CTRL_P
| ALT_P
|
3032 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
3036 mask
= regs
.h
.al
& (SHIFT_P
|
3037 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
3039 /* Do not break international keyboard support. */
3040 /* When Keyb.Com is loaded, the right Alt key is */
3041 /* used for accessing characters like { and } */
3042 if (regs
.h
.ah
& 2) /* Left ALT pressed ? */
3045 if ((regs
.h
.ah
& 8) != 0) /* Right ALT pressed ? */
3048 if (dos_hyper_key
== 1)
3051 modifiers
|= hyper_modifier
;
3053 else if (dos_super_key
== 1)
3056 modifiers
|= super_modifier
;
3058 else if (!international_keyboard
)
3060 /* If Keyb.Com is NOT installed, let Right Alt behave
3061 like the Left Alt. */
3067 if (regs
.h
.ah
& 1) /* Left CTRL pressed ? */
3070 if (regs
.h
.ah
& 4) /* Right CTRL pressed ? */
3072 if (dos_hyper_key
== 2)
3075 modifiers
|= hyper_modifier
;
3077 else if (dos_super_key
== 2)
3080 modifiers
|= super_modifier
;
3088 modifiers
|= shift_modifier
;
3090 modifiers
|= ctrl_modifier
;
3092 modifiers
|= meta_modifier
;
3099 #define NUM_RECENT_DOSKEYS (100)
3100 int recent_doskeys_index
; /* Index for storing next element into recent_doskeys */
3101 int total_doskeys
; /* Total number of elements stored into recent_doskeys */
3102 Lisp_Object recent_doskeys
; /* A vector, holding the last 100 keystrokes */
3104 DEFUN ("recent-doskeys", Frecent_doskeys
, Srecent_doskeys
, 0, 0, 0,
3105 doc
: /* Return vector of last 100 keyboard input values seen in dos_rawgetc.
3106 Each input key receives two values in this vector: first the ASCII code,
3107 and then the scan code. */)
3110 Lisp_Object val
, *keys
= XVECTOR (recent_doskeys
)->contents
;
3112 if (total_doskeys
< NUM_RECENT_DOSKEYS
)
3113 return Fvector (total_doskeys
, keys
);
3116 val
= Fvector (NUM_RECENT_DOSKEYS
, keys
);
3117 bcopy (keys
+ recent_doskeys_index
,
3118 XVECTOR (val
)->contents
,
3119 (NUM_RECENT_DOSKEYS
- recent_doskeys_index
) * sizeof (Lisp_Object
));
3121 XVECTOR (val
)->contents
+ NUM_RECENT_DOSKEYS
- recent_doskeys_index
,
3122 recent_doskeys_index
* sizeof (Lisp_Object
));
3127 /* Get a char from keyboard. Function keys are put into the event queue. */
3131 struct input_event event
;
3133 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (SELECTED_FRAME());
3136 #ifndef HAVE_X_WINDOWS
3137 /* Maybe put the cursor where it should be. */
3138 IT_cmgoto (SELECTED_FRAME());
3141 /* The following condition is equivalent to `kbhit ()', except that
3142 it uses the bios to do its job. This pleases DESQview/X. */
3143 while ((regs
.h
.ah
= extended_kbd
? 0x11 : 0x01),
3144 int86 (0x16, ®s
, ®s
),
3145 (regs
.x
.flags
& 0x40) == 0)
3148 register unsigned char c
;
3149 int modifiers
, sc
, code
= -1, mask
, kp_mode
;
3151 regs
.h
.ah
= extended_kbd
? 0x10 : 0x00;
3152 int86 (0x16, ®s
, ®s
);
3157 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3159 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3160 recent_doskeys_index
= 0;
3161 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3163 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3164 recent_doskeys_index
= 0;
3166 modifiers
= dos_get_modifiers (&mask
);
3168 #ifndef HAVE_X_WINDOWS
3169 if (!NILP (Vdos_display_scancodes
))
3172 sprintf (buf
, "%02x:%02x*%04x",
3173 (unsigned) (sc
&0xff), (unsigned) c
, mask
);
3174 dos_direct_output (screen_size_Y
- 2, screen_size_X
- 12, buf
, 10);
3182 case 10: /* Ctrl Grey Enter */
3183 code
= Ctrl
| Grey
| 4;
3185 case 13: /* Grey Enter */
3188 case '/': /* Grey / */
3198 /* Try the keyboard-private translation table first. */
3199 if (keyboard
->translate_table
)
3201 struct kbd_translate
*p
= keyboard
->translate_table
;
3205 if (p
->sc
== sc
&& p
->ch
== c
)
3213 /* If the private table didn't translate it, use the general
3217 if (sc
>= (sizeof (ibmpc_translate_map
) / sizeof (short)))
3219 if ((code
= ibmpc_translate_map
[sc
]) == Ignore
)
3226 /* We only look at the keyboard Ctrl/Shift/Alt keys when
3227 Emacs is ready to read a key. Therefore, if they press
3228 `Alt-x' when Emacs is busy, by the time we get to
3229 `dos_get_modifiers', they might have already released the
3230 Alt key, and Emacs gets just `x', which is BAD.
3231 However, for keys with the `Map' property set, the ASCII
3232 code returns zero iff Alt is pressed. So, when we DON'T
3233 have to support international_keyboard, we don't have to
3234 distinguish between the left and right Alt keys, and we
3235 can set the META modifier for any keys with the `Map'
3236 property if they return zero ASCII code (c = 0). */
3238 || ( (code
& 0xf000) == Map
&& !international_keyboard
))
3239 modifiers
|= meta_modifier
;
3241 modifiers
|= ctrl_modifier
;
3243 modifiers
|= shift_modifier
;
3246 switch (code
& 0xf000)
3249 if (c
&& !(mask
& (SHIFT_P
| ALT_P
| CTRL_P
| HYPER_P
| SUPER_P
)))
3251 c
= 0; /* Special */
3264 if (c
== 0) /* ctrl-break */
3266 return c
; /* ALT-nnn */
3268 if (!keyboard_map_all
)
3277 if (c
&& !(mask
& ALT_P
) && !((mask
& SHIFT_P
) && (mask
& CTRL_P
)))
3278 if (!keyboard_map_all
)
3282 if (mask
& ALT_P
&& code
<= 10 && code
> 0 && dos_keypad_mode
& 0x200)
3283 mask
|= SHIFT_P
; /* ALT-1 => M-! etc. */
3287 code
= keyboard
->shifted
[code
];
3289 modifiers
&= ~shift_modifier
;
3292 if ((mask
& ALT_GR_P
) && keyboard
->alt_gr
&& keyboard
->alt_gr
[code
] != ' ')
3293 code
= keyboard
->alt_gr
[code
];
3295 code
= keyboard
->unshifted
[code
];
3300 if (c
== 0xe0) /* edit key */
3303 if ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) /* numlock on */
3304 kp_mode
= dos_keypad_mode
& 0x03;
3306 kp_mode
= (dos_keypad_mode
>> 4) & 0x03;
3311 if (code
== 10 && dos_decimal_point
)
3312 return dos_decimal_point
;
3313 return keypad_translate_map
[code
].char_code
;
3316 code
= 0xff00 | keypad_translate_map
[code
].keypad_code
;
3320 code
= keypad_translate_map
[code
].meta_code
;
3321 modifiers
= meta_modifier
;
3325 code
= 0xff00 | keypad_translate_map
[code
].editkey_code
;
3332 kp_mode
= ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) ? 0x04 : 0x40;
3333 if (dos_keypad_mode
& kp_mode
)
3334 code
= 0xff00 | grey_key_translate_map
[code
].keypad_code
;
3336 code
= grey_key_translate_map
[code
].char_code
;
3344 if (!dpyinfo
->mouse_face_hidden
&& INTEGERP (Vmouse_highlight
))
3346 clear_mouse_face (dpyinfo
);
3347 dpyinfo
->mouse_face_hidden
= 1;
3351 event
.kind
= NON_ASCII_KEYSTROKE_EVENT
;
3353 event
.kind
= ASCII_KEYSTROKE_EVENT
;
3355 event
.modifiers
= modifiers
;
3356 event
.frame_or_window
= selected_frame
;
3358 event
.timestamp
= event_timestamp ();
3359 kbd_buffer_store_event (&event
);
3362 if (have_mouse
> 0 && !mouse_preempted
)
3364 int but
, press
, x
, y
, ok
;
3365 int mouse_prev_x
= mouse_last_x
, mouse_prev_y
= mouse_last_y
;
3366 Lisp_Object mouse_window
= Qnil
;
3368 /* Check for mouse movement *before* buttons. */
3369 mouse_check_moved ();
3371 /* If the mouse moved from the spot of its last sighting, we
3372 might need to update mouse highlight. */
3373 if (mouse_last_x
!= mouse_prev_x
|| mouse_last_y
!= mouse_prev_y
)
3375 if (dpyinfo
->mouse_face_hidden
)
3377 dpyinfo
->mouse_face_hidden
= 0;
3378 clear_mouse_face (dpyinfo
);
3381 /* Generate SELECT_WINDOW_EVENTs when needed. */
3382 if (mouse_autoselect_window
)
3384 mouse_window
= window_from_coordinates (SELECTED_FRAME(),
3388 /* A window will be selected only when it is not
3389 selected now, and the last mouse movement event was
3390 not in it. A minibuffer window will be selected iff
3392 if (WINDOWP (mouse_window
)
3393 && !EQ (mouse_window
, last_mouse_window
)
3394 && !EQ (mouse_window
, selected_window
))
3396 event
.kind
= SELECT_WINDOW_EVENT
;
3397 event
.frame_or_window
= mouse_window
;
3399 event
.timestamp
= event_timestamp ();
3400 kbd_buffer_store_event (&event
);
3402 last_mouse_window
= mouse_window
;
3405 last_mouse_window
= Qnil
;
3407 previous_help_echo_string
= help_echo_string
;
3408 help_echo_string
= help_echo_object
= help_echo_window
= Qnil
;
3410 IT_note_mouse_highlight (SELECTED_FRAME(),
3411 mouse_last_x
, mouse_last_y
);
3412 /* If the contents of the global variable help_echo has
3413 changed, generate a HELP_EVENT. */
3414 if (!NILP (help_echo_string
) || !NILP (previous_help_echo_string
))
3416 event
.kind
= HELP_EVENT
;
3417 event
.frame_or_window
= selected_frame
;
3418 event
.arg
= help_echo_object
;
3419 event
.x
= WINDOWP (help_echo_window
)
3420 ? help_echo_window
: selected_frame
;
3421 event
.y
= help_echo_string
;
3422 event
.timestamp
= event_timestamp ();
3423 event
.code
= help_echo_pos
;
3424 kbd_buffer_store_event (&event
);
3428 for (but
= 0; but
< NUM_MOUSE_BUTTONS
; but
++)
3429 for (press
= 0; press
< 2; press
++)
3431 int button_num
= but
;
3434 ok
= mouse_pressed (but
, &x
, &y
);
3436 ok
= mouse_released (but
, &x
, &y
);
3439 /* Allow a simultaneous press/release of Mouse-1 and
3440 Mouse-2 to simulate Mouse-3 on two-button mice. */
3441 if (mouse_button_count
== 2 && but
< 2)
3443 int x2
, y2
; /* don't clobber original coordinates */
3445 /* If only one button is pressed, wait 100 msec and
3446 check again. This way, Speedy Gonzales isn't
3447 punished, while the slow get their chance. */
3448 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3449 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3454 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3455 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3460 event
.kind
= MOUSE_CLICK_EVENT
;
3461 event
.code
= button_num
;
3462 event
.modifiers
= dos_get_modifiers (0)
3463 | (press
? down_modifier
: up_modifier
);
3466 event
.frame_or_window
= selected_frame
;
3468 event
.timestamp
= event_timestamp ();
3469 kbd_buffer_store_event (&event
);
3477 static int prev_get_char
= -1;
3479 /* Return 1 if a key is ready to be read without suspending execution. */
3483 if (prev_get_char
!= -1)
3486 return ((prev_get_char
= dos_rawgetc ()) != -1);
3489 /* Read a key. Return -1 if no key is ready. */
3493 if (prev_get_char
!= -1)
3495 int c
= prev_get_char
;
3500 return dos_rawgetc ();
3503 #ifndef HAVE_X_WINDOWS
3505 /* Simulation of X's menus. Nothing too fancy here -- just make it work
3508 Actually, I don't know the meaning of all the parameters of the functions
3509 here -- I only know how they are called by xmenu.c. I could of course
3510 grab the nearest Xlib manual (down the hall, second-to-last door on the
3511 left), but I don't think it's worth the effort. */
3513 /* These hold text of the current and the previous menu help messages. */
3514 static char *menu_help_message
, *prev_menu_help_message
;
3515 /* Pane number and item number of the menu item which generated the
3516 last menu help message. */
3517 static int menu_help_paneno
, menu_help_itemno
;
3524 menu
= (XMenu
*) xmalloc (sizeof (XMenu
));
3525 menu
->allocated
= menu
->count
= menu
->panecount
= menu
->width
= 0;
3529 /* Allocate some (more) memory for MENU ensuring that there is room for one
3533 IT_menu_make_room (XMenu
*menu
)
3535 if (menu
->allocated
== 0)
3537 int count
= menu
->allocated
= 10;
3538 menu
->text
= (char **) xmalloc (count
* sizeof (char *));
3539 menu
->submenu
= (XMenu
**) xmalloc (count
* sizeof (XMenu
*));
3540 menu
->panenumber
= (int *) xmalloc (count
* sizeof (int));
3541 menu
->help_text
= (char **) xmalloc (count
* sizeof (char *));
3543 else if (menu
->allocated
== menu
->count
)
3545 int count
= menu
->allocated
= menu
->allocated
+ 10;
3547 = (char **) xrealloc (menu
->text
, count
* sizeof (char *));
3549 = (XMenu
**) xrealloc (menu
->submenu
, count
* sizeof (XMenu
*));
3551 = (int *) xrealloc (menu
->panenumber
, count
* sizeof (int));
3553 = (char **) xrealloc (menu
->help_text
, count
* sizeof (char *));
3557 /* Search the given menu structure for a given pane number. */
3560 IT_menu_search_pane (XMenu
*menu
, int pane
)
3565 for (i
= 0; i
< menu
->count
; i
++)
3566 if (menu
->submenu
[i
])
3568 if (pane
== menu
->panenumber
[i
])
3569 return menu
->submenu
[i
];
3570 if ((try = IT_menu_search_pane (menu
->submenu
[i
], pane
)))
3576 /* Determine how much screen space a given menu needs. */
3579 IT_menu_calc_size (XMenu
*menu
, int *width
, int *height
)
3581 int i
, h2
, w2
, maxsubwidth
, maxheight
;
3584 maxheight
= menu
->count
;
3585 for (i
= 0; i
< menu
->count
; i
++)
3587 if (menu
->submenu
[i
])
3589 IT_menu_calc_size (menu
->submenu
[i
], &w2
, &h2
);
3590 if (w2
> maxsubwidth
) maxsubwidth
= w2
;
3591 if (i
+ h2
> maxheight
) maxheight
= i
+ h2
;
3594 *width
= menu
->width
+ maxsubwidth
;
3595 *height
= maxheight
;
3598 /* Display MENU at (X,Y) using FACES. */
3601 IT_menu_display (XMenu
*menu
, int y
, int x
, int pn
, int *faces
, int disp_help
)
3603 int i
, j
, face
, width
, mx
, my
, enabled
, mousehere
, row
, col
;
3604 struct glyph
*text
, *p
;
3606 struct frame
*sf
= SELECTED_FRAME();
3608 menu_help_message
= NULL
;
3610 width
= menu
->width
;
3611 text
= (struct glyph
*) xmalloc ((width
+ 2) * sizeof (struct glyph
));
3612 ScreenGetCursor (&row
, &col
);
3613 mouse_get_xy (&mx
, &my
);
3614 IT_update_begin (sf
);
3615 for (i
= 0; i
< menu
->count
; i
++)
3617 int max_width
= width
+ 2;
3619 IT_cursor_to (y
+ i
, x
);
3621 = (!menu
->submenu
[i
] && menu
->panenumber
[i
]) || (menu
->submenu
[i
]);
3622 mousehere
= (y
+ i
== my
&& x
<= mx
&& mx
< x
+ width
+ 2);
3623 face
= faces
[enabled
+ mousehere
* 2];
3624 /* The following if clause means that we display the menu help
3625 strings even if the menu item is currently disabled. */
3626 if (disp_help
&& enabled
+ mousehere
* 2 >= 2)
3628 menu_help_message
= menu
->help_text
[i
];
3629 menu_help_paneno
= pn
- 1;
3630 menu_help_itemno
= i
;
3633 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3635 for (j
= 0, q
= menu
->text
[i
]; *q
; j
++)
3639 SET_CHAR_GLYPH (*p
, *q
++, face
, 0);
3642 else /* make '^x' */
3644 SET_CHAR_GLYPH (*p
, '^', face
, 0);
3647 SET_CHAR_GLYPH (*p
, *q
++ + 64, face
, 0);
3651 /* Don't let the menu text overflow into the next screen row. */
3652 if (x
+ max_width
> screen_size_X
)
3654 max_width
= screen_size_X
- x
;
3655 text
[max_width
- 1].u
.ch
= '$'; /* indicate it's truncated */
3657 for (; j
< max_width
- 2; j
++, p
++)
3658 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3660 SET_CHAR_GLYPH (*p
, menu
->submenu
[i
] ? 16 : ' ', face
, 0);
3662 IT_write_glyphs (text
, max_width
);
3665 IT_cursor_to (row
, col
);
3669 /* --------------------------- X Menu emulation ---------------------- */
3671 /* Report availability of menus. */
3674 have_menus_p () { return 1; }
3676 /* Create a brand new menu structure. */
3679 XMenuCreate (Display
*foo1
, Window foo2
, char *foo3
)
3681 return IT_menu_create ();
3684 /* Create a new pane and place it on the outer-most level. It is not
3685 clear that it should be placed out there, but I don't know what else
3689 XMenuAddPane (Display
*foo
, XMenu
*menu
, char *txt
, int enable
)
3697 IT_menu_make_room (menu
);
3698 menu
->submenu
[menu
->count
] = IT_menu_create ();
3699 menu
->text
[menu
->count
] = txt
;
3700 menu
->panenumber
[menu
->count
] = ++menu
->panecount
;
3701 menu
->help_text
[menu
->count
] = NULL
;
3704 /* Adjust length for possible control characters (which will
3705 be written as ^x). */
3706 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3710 if (len
> menu
->width
)
3713 return menu
->panecount
;
3716 /* Create a new item in a menu pane. */
3719 XMenuAddSelection (Display
*bar
, XMenu
*menu
, int pane
,
3720 int foo
, char *txt
, int enable
, char *help_text
)
3726 if (!(menu
= IT_menu_search_pane (menu
, pane
)))
3728 IT_menu_make_room (menu
);
3729 menu
->submenu
[menu
->count
] = (XMenu
*) 0;
3730 menu
->text
[menu
->count
] = txt
;
3731 menu
->panenumber
[menu
->count
] = enable
;
3732 menu
->help_text
[menu
->count
] = help_text
;
3735 /* Adjust length for possible control characters (which will
3736 be written as ^x). */
3737 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3741 if (len
> menu
->width
)
3747 /* Decide where the menu would be placed if requested at (X,Y). */
3750 XMenuLocate (Display
*foo0
, XMenu
*menu
, int foo1
, int foo2
, int x
, int y
,
3751 int *ulx
, int *uly
, int *width
, int *height
)
3753 IT_menu_calc_size (menu
, width
, height
);
3759 struct IT_menu_state
3761 void *screen_behind
;
3768 /* Display menu, wait for user's response, and return that response. */
3771 XMenuActivate (Display
*foo
, XMenu
*menu
, int *pane
, int *selidx
,
3772 int x0
, int y0
, unsigned ButtonMask
, char **txt
,
3773 void (*help_callback
)(char *, int, int))
3775 struct IT_menu_state
*state
;
3776 int statecount
, x
, y
, i
, b
, screensize
, leave
, result
, onepane
;
3777 int title_faces
[4]; /* face to display the menu title */
3778 int faces
[4], buffers_num_deleted
= 0;
3779 struct frame
*sf
= SELECTED_FRAME();
3780 Lisp_Object saved_echo_area_message
, selectface
;
3782 /* Just in case we got here without a mouse present... */
3783 if (have_mouse
<= 0)
3784 return XM_IA_SELECT
;
3785 /* Don't allow non-positive x0 and y0, lest the menu will wrap
3786 around the display. */
3792 /* We will process all the mouse events directly, so we had
3793 better prevent dos_rawgetc from stealing them from us. */
3796 state
= alloca (menu
->panecount
* sizeof (struct IT_menu_state
));
3797 screensize
= screen_size
* 2;
3799 = lookup_derived_face (sf
, intern ("msdos-menu-passive-face"),
3800 0, DEFAULT_FACE_ID
);
3802 = lookup_derived_face (sf
, intern ("msdos-menu-active-face"),
3803 0, DEFAULT_FACE_ID
);
3804 selectface
= intern ("msdos-menu-select-face");
3805 faces
[2] = lookup_derived_face (sf
, selectface
,
3807 faces
[3] = lookup_derived_face (sf
, selectface
,
3810 /* Make sure the menu title is always displayed with
3811 `msdos-menu-active-face', no matter where the mouse pointer is. */
3812 for (i
= 0; i
< 4; i
++)
3813 title_faces
[i
] = faces
[3];
3817 /* Don't let the title for the "Buffers" popup menu include a
3818 digit (which is ugly).
3820 This is a terrible kludge, but I think the "Buffers" case is
3821 the only one where the title includes a number, so it doesn't
3822 seem to be necessary to make this more general. */
3823 if (strncmp (menu
->text
[0], "Buffers 1", 9) == 0)
3825 menu
->text
[0][7] = '\0';
3826 buffers_num_deleted
= 1;
3829 /* We need to save the current echo area message, so that we could
3830 restore it below, before we exit. See the commentary below,
3831 before the call to message_with_string. */
3832 saved_echo_area_message
= Fcurrent_message ();
3833 state
[0].menu
= menu
;
3835 ScreenRetrieve (state
[0].screen_behind
= xmalloc (screensize
));
3837 /* Turn off the cursor. Otherwise it shows through the menu
3838 panes, which is ugly. */
3839 IT_display_cursor (0);
3841 /* Display the menu title. */
3842 IT_menu_display (menu
, y0
- 1, x0
- 1, 1, title_faces
, 0);
3843 if (buffers_num_deleted
)
3844 menu
->text
[0][7] = ' ';
3845 if ((onepane
= menu
->count
== 1 && menu
->submenu
[0]))
3847 menu
->width
= menu
->submenu
[0]->width
;
3848 state
[0].menu
= menu
->submenu
[0];
3852 state
[0].menu
= menu
;
3854 state
[0].x
= x0
- 1;
3856 state
[0].pane
= onepane
;
3858 mouse_last_x
= -1; /* A hack that forces display. */
3862 if (!mouse_visible
) mouse_on ();
3863 mouse_check_moved ();
3864 if (sf
->mouse_moved
)
3866 sf
->mouse_moved
= 0;
3867 result
= XM_IA_SELECT
;
3868 mouse_get_xy (&x
, &y
);
3869 for (i
= 0; i
< statecount
; i
++)
3870 if (state
[i
].x
<= x
&& x
< state
[i
].x
+ state
[i
].menu
->width
+ 2)
3872 int dy
= y
- state
[i
].y
;
3873 if (0 <= dy
&& dy
< state
[i
].menu
->count
)
3875 if (!state
[i
].menu
->submenu
[dy
])
3876 if (state
[i
].menu
->panenumber
[dy
])
3877 result
= XM_SUCCESS
;
3879 result
= XM_IA_SELECT
;
3880 *pane
= state
[i
].pane
- 1;
3882 /* We hit some part of a menu, so drop extra menus that
3883 have been opened. That does not include an open and
3885 if (i
!= statecount
- 2
3886 || state
[i
].menu
->submenu
[dy
] != state
[i
+1].menu
)
3887 while (i
!= statecount
- 1)
3891 ScreenUpdate (state
[statecount
].screen_behind
);
3892 if (screen_virtual_segment
)
3893 dosv_refresh_virtual_screen (0, screen_size
);
3894 xfree (state
[statecount
].screen_behind
);
3896 if (i
== statecount
- 1 && state
[i
].menu
->submenu
[dy
])
3898 IT_menu_display (state
[i
].menu
,
3903 state
[statecount
].menu
= state
[i
].menu
->submenu
[dy
];
3904 state
[statecount
].pane
= state
[i
].menu
->panenumber
[dy
];
3906 ScreenRetrieve (state
[statecount
].screen_behind
3907 = xmalloc (screensize
));
3909 = state
[i
].x
+ state
[i
].menu
->width
+ 2;
3910 state
[statecount
].y
= y
;
3915 IT_menu_display (state
[statecount
- 1].menu
,
3916 state
[statecount
- 1].y
,
3917 state
[statecount
- 1].x
,
3918 state
[statecount
- 1].pane
,
3923 if ((menu_help_message
|| prev_menu_help_message
)
3924 && menu_help_message
!= prev_menu_help_message
)
3926 help_callback (menu_help_message
,
3927 menu_help_paneno
, menu_help_itemno
);
3928 IT_display_cursor (0);
3929 prev_menu_help_message
= menu_help_message
;
3931 /* We are busy-waiting for the mouse to move, so let's be nice
3932 to other Windows applications by releasing our time slice. */
3935 for (b
= 0; b
< mouse_button_count
&& !leave
; b
++)
3937 /* Only leave if user both pressed and released the mouse, and in
3938 that order. This avoids popping down the menu pane unless
3939 the user is really done with it. */
3940 if (mouse_pressed (b
, &x
, &y
))
3942 while (mouse_button_depressed (b
, &x
, &y
))
3946 (void) mouse_released (b
, &x
, &y
);
3951 ScreenUpdate (state
[0].screen_behind
);
3952 if (screen_virtual_segment
)
3953 dosv_refresh_virtual_screen (0, screen_size
);
3955 /* We have a situation here. ScreenUpdate has just restored the
3956 screen contents as it was before we started drawing this menu.
3957 That includes any echo area message that could have been
3958 displayed back then. (In reality, that echo area message will
3959 almost always be the ``keystroke echo'' that echoes the sequence
3960 of menu items chosen by the user.) However, if the menu had some
3961 help messages, then displaying those messages caused Emacs to
3962 forget about the original echo area message. So when
3963 ScreenUpdate restored it, it created a discrepancy between the
3964 actual screen contents and what Emacs internal data structures
3967 To avoid this conflict, we force Emacs to restore the original
3968 echo area message as we found it when we entered this function.
3969 The irony of this is that we then erase the restored message
3970 right away, so the only purpose of restoring it is so that
3971 erasing it works correctly... */
3972 if (! NILP (saved_echo_area_message
))
3973 message_with_string ("%s", saved_echo_area_message
, 0);
3975 while (statecount
--)
3976 xfree (state
[statecount
].screen_behind
);
3977 IT_display_cursor (1); /* turn cursor back on */
3978 /* Clean up any mouse events that are waiting inside Emacs event queue.
3979 These events are likely to be generated before the menu was even
3980 displayed, probably because the user pressed and released the button
3981 (which invoked the menu) too quickly. If we don't remove these events,
3982 Emacs will process them after we return and surprise the user. */
3983 discard_mouse_events ();
3984 mouse_clear_clicks ();
3985 if (!kbd_buffer_events_waiting (1))
3986 clear_input_pending ();
3987 /* Allow mouse events generation by dos_rawgetc. */
3992 /* Dispose of a menu. */
3995 XMenuDestroy (Display
*foo
, XMenu
*menu
)
3998 if (menu
->allocated
)
4000 for (i
= 0; i
< menu
->count
; i
++)
4001 if (menu
->submenu
[i
])
4002 XMenuDestroy (foo
, menu
->submenu
[i
]);
4004 xfree (menu
->submenu
);
4005 xfree (menu
->panenumber
);
4006 xfree (menu
->help_text
);
4009 menu_help_message
= prev_menu_help_message
= NULL
;
4013 x_pixel_width (struct frame
*f
)
4015 return FRAME_COLS (f
);
4019 x_pixel_height (struct frame
*f
)
4021 return FRAME_LINES (f
);
4023 #endif /* !HAVE_X_WINDOWS */
4025 /* ----------------------- DOS / UNIX conversion --------------------- */
4027 void msdos_downcase_filename (unsigned char *);
4029 /* Destructively turn backslashes into slashes. */
4032 dostounix_filename (p
)
4035 msdos_downcase_filename (p
);
4045 /* Destructively turn slashes into backslashes. */
4048 unixtodos_filename (p
)
4051 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4065 /* Get the default directory for a given drive. 0=def, 1=A, 2=B, ... */
4068 getdefdir (drive
, dst
)
4072 char in_path
[4], *p
= in_path
, e
= errno
;;
4074 /* Generate "X:." (when drive is X) or "." (when drive is 0). */
4077 *p
++ = drive
+ 'A' - 1;
4084 _fixpath (in_path
, dst
);
4085 /* _fixpath can set errno to ENOSYS on non-LFN systems because
4086 it queries the LFN support, so ignore that error. */
4087 if ((errno
&& errno
!= ENOSYS
) || *dst
== '\0')
4090 msdos_downcase_filename (dst
);
4097 emacs_root_dir (void)
4099 static char root_dir
[4];
4101 sprintf (root_dir
, "%c:/", 'A' + getdisk ());
4102 root_dir
[0] = tolower (root_dir
[0]);
4106 /* Remove all CR's that are followed by a LF. */
4111 register unsigned char *buf
;
4113 unsigned char *np
= buf
, *startp
= buf
, *endp
= buf
+ n
;
4117 while (buf
< endp
- 1)
4121 if (*(++buf
) != 0x0a)
4132 #if defined(__DJGPP__) && __DJGPP__ == 2 && __DJGPP_MINOR__ == 0
4134 /* In DJGPP v2.0, library `write' can call `malloc', which might
4135 cause relocation of the buffer whose address we get in ADDR.
4136 Here is a version of `write' that avoids calling `malloc',
4137 to serve us until such time as the library is fixed.
4138 Actually, what we define here is called `__write', because
4139 `write' is a stub that just jmp's to `__write' (to be
4140 POSIXLY-correct with respect to the global name-space). */
4142 #include <io.h> /* for _write */
4143 #include <libc/dosio.h> /* for __file_handle_modes[] */
4145 static char xbuf
[64 * 1024]; /* DOS cannot write more in one chunk */
4147 #define XBUF_END (xbuf + sizeof (xbuf) - 1)
4150 __write (int handle
, const void *buffer
, size_t count
)
4155 if(__file_handle_modes
[handle
] & O_BINARY
)
4156 return _write (handle
, buffer
, count
);
4160 const char *bp
= buffer
;
4161 int total_written
= 0;
4162 int nmoved
= 0, ncr
= 0;
4166 /* The next test makes sure there's space for at least 2 more
4167 characters in xbuf[], so both CR and LF can be put there. */
4179 if (xbp
>= XBUF_END
|| !count
)
4181 size_t to_write
= nmoved
+ ncr
;
4182 int written
= _write (handle
, xbuf
, to_write
);
4187 total_written
+= nmoved
; /* CRs aren't counted in ret value */
4189 /* If some, but not all were written (disk full?), return
4190 an estimate of the total written bytes not counting CRs. */
4191 if (written
< to_write
)
4192 return total_written
- (to_write
- written
) * nmoved
/to_write
;
4199 return total_written
;
4203 /* A low-level file-renaming function which works around Windows 95 bug.
4204 This is pulled directly out of DJGPP v2.01 library sources, and only
4205 used when you compile with DJGPP v2.0. */
4209 int _rename(const char *old
, const char *new)
4212 int olen
= strlen(old
) + 1;
4214 int use_lfn
= _USE_LFN
;
4215 char tempfile
[FILENAME_MAX
];
4216 const char *orig
= old
;
4219 r
.x
.dx
= __tb_offset
;
4220 r
.x
.di
= __tb_offset
+ olen
;
4221 r
.x
.ds
= r
.x
.es
= __tb_segment
;
4225 /* Windows 95 bug: for some filenames, when you rename
4226 file -> file~ (as in Emacs, to leave a backup), the
4227 short 8+3 alias doesn't change, which effectively
4228 makes OLD and NEW the same file. We must rename
4229 through a temporary file to work around this. */
4231 char *pbase
= 0, *p
;
4232 static char try_char
[] = "abcdefghijklmnopqrstuvwxyz012345789";
4233 int idx
= sizeof(try_char
) - 1;
4235 /* Generate a temporary name. Can't use `tmpnam', since $TMPDIR
4236 might point to another drive, which will fail the DOS call. */
4237 strcpy(tempfile
, old
);
4238 for (p
= tempfile
; *p
; p
++) /* ensure temporary is on the same drive */
4239 if (*p
== '/' || *p
== '\\' || *p
== ':')
4245 strcpy(pbase
, "X$$djren$$.$$temp$$");
4251 *pbase
= try_char
[--idx
];
4252 } while (_chmod(tempfile
, 0) != -1);
4255 _put_path2(tempfile
, olen
);
4257 __dpmi_int(0x21, &r
);
4260 errno
= __doserr_to_errno(r
.x
.ax
);
4264 /* Now create a file with the original name. This will
4265 ensure that NEW will always have a 8+3 alias
4266 different from that of OLD. (Seems to be required
4267 when NameNumericTail in the Registry is set to 0.) */
4268 lfn_fd
= _creat(old
, 0);
4270 olen
= strlen(tempfile
) + 1;
4272 r
.x
.di
= __tb_offset
+ olen
;
4281 _put_path2(new, olen
);
4283 __dpmi_int(0x21, &r
);
4286 if (r
.x
.ax
== 5 && i
== 0) /* access denied */
4287 remove(new); /* and try again */
4290 errno
= __doserr_to_errno(r
.x
.ax
);
4292 /* Restore to original name if we renamed it to temporary. */
4300 _put_path2(orig
, olen
);
4301 _put_path(tempfile
);
4303 __dpmi_int(0x21, &r
);
4312 /* Success. Delete the file possibly created to work
4313 around the Windows 95 bug. */
4315 return (_close (lfn_fd
) == 0) ? remove (orig
) : -1;
4319 #endif /* __DJGPP__ == 2 && __DJGPP_MINOR__ == 0 */
4321 DEFUN ("msdos-long-file-names", Fmsdos_long_file_names
, Smsdos_long_file_names
,
4323 doc
: /* Return non-nil if long file names are supported on MSDOS. */)
4326 return (_USE_LFN
? Qt
: Qnil
);
4329 /* Convert alphabetic characters in a filename to lower-case. */
4332 msdos_downcase_filename (p
)
4333 register unsigned char *p
;
4335 /* Always lower-case drive letters a-z, even if the filesystem
4336 preserves case in filenames.
4337 This is so MSDOS filenames could be compared by string comparison
4338 functions that are case-sensitive. Even case-preserving filesystems
4339 do not distinguish case in drive letters. */
4340 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4346 /* Under LFN we expect to get pathnames in their true case. */
4347 if (NILP (Fmsdos_long_file_names ()))
4349 if (*p
>= 'A' && *p
<= 'Z')
4353 DEFUN ("msdos-downcase-filename", Fmsdos_downcase_filename
, Smsdos_downcase_filename
,
4355 doc
: /* Convert alphabetic characters in FILENAME to lower case and return that.
4356 When long filenames are supported, doesn't change FILENAME.
4357 If FILENAME is not a string, returns nil.
4358 The argument object is never altered--the value is a copy. */)
4360 Lisp_Object filename
;
4364 if (! STRINGP (filename
))
4367 tem
= Fcopy_sequence (filename
);
4368 msdos_downcase_filename (SDATA (tem
));
4372 /* The Emacs root directory as determined by init_environment. */
4374 static char emacsroot
[MAXPATHLEN
];
4377 rootrelativepath (rel
)
4380 static char result
[MAXPATHLEN
+ 10];
4382 strcpy (result
, emacsroot
);
4383 strcat (result
, "/");
4384 strcat (result
, rel
);
4388 /* Define a lot of environment variables if not already defined. Don't
4389 remove anything unless you know what you're doing -- lots of code will
4390 break if one or more of these are missing. */
4393 init_environment (argc
, argv
, skip_args
)
4400 static const char * const tempdirs
[] = {
4401 "$TMPDIR", "$TEMP", "$TMP", "c:/"
4403 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
4405 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
4406 temporary files and assume "/tmp" if $TMPDIR is unset, which
4407 will break on DOS/Windows. Refuse to work if we cannot find
4408 a directory, not even "c:/", usable for that purpose. */
4409 for (i
= 0; i
< imax
; i
++)
4411 const char *tmp
= tempdirs
[i
];
4412 char buf
[FILENAME_MAX
];
4418 tmp
= getenv (tmp
+ 1);
4422 /* Some lusers set TMPDIR=e:, probably because some losing
4423 programs cannot handle multiple slashes if they use e:/.
4424 e: fails in `access' below, so we interpret e: as e:/. */
4425 tmp_len
= strlen(tmp
);
4426 if (tmp
[tmp_len
- 1] != '/' && tmp
[tmp_len
- 1] != '\\')
4429 buf
[tmp_len
++] = '/', buf
[tmp_len
] = 0;
4434 /* Note that `access' can lie to us if the directory resides on a
4435 read-only filesystem, like CD-ROM or a write-protected floppy.
4436 The only way to be really sure is to actually create a file and
4437 see if it succeeds. But I think that's too much to ask. */
4438 if (tmp
&& access (tmp
, D_OK
) == 0)
4440 setenv ("TMPDIR", tmp
, 1);
4447 Fcons (build_string ("no usable temporary directories found!!"),
4449 "While setting TMPDIR: ");
4451 /* Note the startup time, so we know not to clear the screen if we
4452 exit immediately; see IT_reset_terminal_modes.
4453 (Yes, I know `clock' returns zero the first time it's called, but
4454 I do this anyway, in case some wiseguy changes that at some point.) */
4455 startup_time
= clock ();
4457 /* Find our root from argv[0]. Assuming argv[0] is, say,
4458 "c:/emacs/bin/emacs.exe" our root will be "c:/emacs". */
4459 root
= alloca (MAXPATHLEN
+ 20);
4460 _fixpath (argv
[0], root
);
4461 msdos_downcase_filename (root
);
4462 len
= strlen (root
);
4463 while (len
> 0 && root
[len
] != '/' && root
[len
] != ':')
4467 && (strcmp (root
+ len
- 4, "/bin") == 0
4468 || strcmp (root
+ len
- 4, "/src") == 0)) /* under a debugger */
4469 root
[len
- 4] = '\0';
4471 strcpy (root
, "c:/emacs"); /* let's be defensive */
4472 len
= strlen (root
);
4473 strcpy (emacsroot
, root
);
4475 /* We default HOME to our root. */
4476 setenv ("HOME", root
, 0);
4478 /* We default EMACSPATH to root + "/bin". */
4479 strcpy (root
+ len
, "/bin");
4480 setenv ("EMACSPATH", root
, 0);
4482 /* I don't expect anybody to ever use other terminals so the internal
4483 terminal is the default. */
4484 setenv ("TERM", "internal", 0);
4486 #ifdef HAVE_X_WINDOWS
4487 /* Emacs expects DISPLAY to be set. */
4488 setenv ("DISPLAY", "unix:0.0", 0);
4491 /* SHELL is a bit tricky -- COMSPEC is the closest we come, but we must
4492 downcase it and mirror the backslashes. */
4493 s
= getenv ("COMSPEC");
4494 if (!s
) s
= "c:/command.com";
4495 t
= alloca (strlen (s
) + 1);
4497 dostounix_filename (t
);
4498 setenv ("SHELL", t
, 0);
4500 /* PATH is also downcased and backslashes mirrored. */
4501 s
= getenv ("PATH");
4503 t
= alloca (strlen (s
) + 3);
4504 /* Current directory is always considered part of MsDos's path but it is
4505 not normally mentioned. Now it is. */
4506 strcat (strcpy (t
, ".;"), s
);
4507 dostounix_filename (t
); /* Not a single file name, but this should work. */
4508 setenv ("PATH", t
, 1);
4510 /* In some sense all dos users have root privileges, so... */
4511 setenv ("USER", "root", 0);
4512 setenv ("NAME", getenv ("USER"), 0);
4514 /* Time zone determined from country code. To make this possible, the
4515 country code may not span more than one time zone. In other words,
4516 in the USA, you lose. */
4518 switch (dos_country_code
)
4520 case 31: /* Belgium */
4521 case 32: /* The Netherlands */
4522 case 33: /* France */
4523 case 34: /* Spain */
4524 case 36: /* Hungary */
4525 case 38: /* Yugoslavia (or what's left of it?) */
4526 case 39: /* Italy */
4527 case 41: /* Switzerland */
4528 case 42: /* Tjekia */
4529 case 45: /* Denmark */
4530 case 46: /* Sweden */
4531 case 47: /* Norway */
4532 case 48: /* Poland */
4533 case 49: /* Germany */
4534 /* Daylight saving from last Sunday in March to last Sunday in
4535 September, both at 2AM. */
4536 setenv ("TZ", "MET-01METDST-02,M3.5.0/02:00,M9.5.0/02:00", 0);
4538 case 44: /* United Kingdom */
4539 case 351: /* Portugal */
4540 case 354: /* Iceland */
4541 setenv ("TZ", "GMT+00", 0);
4543 case 81: /* Japan */
4544 case 82: /* Korea */
4545 setenv ("TZ", "JST-09", 0);
4547 case 90: /* Turkey */
4548 case 358: /* Finland */
4549 setenv ("TZ", "EET-02", 0);
4551 case 972: /* Israel */
4552 /* This is an approximation. (For exact rules, use the
4553 `zoneinfo/israel' file which comes with DJGPP, but you need
4554 to install it in `/usr/share/zoneinfo/' directory first.) */
4555 setenv ("TZ", "IST-02IDT-03,M4.1.6/00:00,M9.5.6/01:00", 0);
4563 static int break_stat
; /* BREAK check mode status. */
4564 static int stdin_stat
; /* stdin IOCTL status. */
4568 /* These must be global. */
4569 static _go32_dpmi_seginfo ctrl_break_vector
;
4570 static _go32_dpmi_registers ctrl_break_regs
;
4571 static int ctrlbreakinstalled
= 0;
4573 /* Interrupt level detection of Ctrl-Break. Don't do anything fancy here! */
4576 ctrl_break_func (regs
)
4577 _go32_dpmi_registers
*regs
;
4583 install_ctrl_break_check ()
4585 if (!ctrlbreakinstalled
)
4587 /* Don't press Ctrl-Break if you don't have either DPMI or Emacs
4588 was compiler with Djgpp 1.11 maintenance level 5 or later! */
4589 ctrlbreakinstalled
= 1;
4590 ctrl_break_vector
.pm_offset
= (int) ctrl_break_func
;
4591 _go32_dpmi_allocate_real_mode_callback_iret (&ctrl_break_vector
,
4593 _go32_dpmi_set_real_mode_interrupt_vector (0x1b, &ctrl_break_vector
);
4597 #endif /* __DJGPP__ < 2 */
4599 /* Turn off Dos' Ctrl-C checking and inhibit interpretation of
4600 control chars by DOS. Determine the keyboard type. */
4605 union REGS inregs
, outregs
;
4606 static int first_time
= 1;
4608 break_stat
= getcbrk ();
4611 install_ctrl_break_check ();
4617 int86 (0x15, &inregs
, &outregs
);
4618 extended_kbd
= (!outregs
.x
.cflag
) && (outregs
.h
.ah
== 0);
4622 if (internal_terminal
4623 #ifdef HAVE_X_WINDOWS
4624 && inhibit_window_system
4628 inregs
.x
.ax
= 0x0021;
4629 int86 (0x33, &inregs
, &outregs
);
4630 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4633 /* Reportedly, the above doesn't work for some mouse drivers. There
4634 is an additional detection method that should work, but might be
4635 a little slower. Use that as an alternative. */
4636 inregs
.x
.ax
= 0x0000;
4637 int86 (0x33, &inregs
, &outregs
);
4638 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4643 have_mouse
= 1; /* enable mouse */
4645 mouse_setup_buttons (outregs
.x
.bx
);
4646 mouse_position_hook
= &mouse_get_pos
;
4650 #ifndef HAVE_X_WINDOWS
4652 /* Save the cursor shape used outside Emacs. */
4653 outside_cursor
= _farpeekw (_dos_ds
, 0x460);
4662 stdin_stat
= setmode (fileno (stdin
), O_BINARY
);
4663 return (stdin_stat
!= -1);
4666 return (setmode (fileno (stdin
), O_BINARY
) != -1);
4668 #else /* __DJGPP__ < 2 */
4672 /* I think it is wrong to overwrite `stdin_stat' every time
4673 but the first one this function is called, but I don't
4674 want to change the way it used to work in v1.x.--EZ */
4676 inregs
.x
.ax
= 0x4400; /* Get IOCTL status. */
4677 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4678 intdos (&inregs
, &outregs
);
4679 stdin_stat
= outregs
.h
.dl
;
4681 inregs
.x
.dx
= stdin_stat
| 0x0020; /* raw mode */
4682 inregs
.x
.ax
= 0x4401; /* Set IOCTL status */
4683 intdos (&inregs
, &outregs
);
4684 return !outregs
.x
.cflag
;
4686 #endif /* __DJGPP__ < 2 */
4689 /* Restore status of standard input and Ctrl-C checking. */
4694 union REGS inregs
, outregs
;
4696 setcbrk (break_stat
);
4701 #ifndef HAVE_X_WINDOWS
4702 /* Restore the cursor shape we found on startup. */
4706 inregs
.x
.cx
= outside_cursor
;
4707 int86 (0x10, &inregs
, &outregs
);
4711 return (setmode (fileno (stdin
), stdin_stat
) != -1);
4713 #else /* not __DJGPP__ >= 2 */
4715 inregs
.x
.ax
= 0x4401; /* Set IOCTL status. */
4716 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4717 inregs
.x
.dx
= stdin_stat
;
4718 intdos (&inregs
, &outregs
);
4719 return !outregs
.x
.cflag
;
4721 #endif /* not __DJGPP__ >= 2 */
4725 /* Run command as specified by ARGV in directory DIR.
4726 The command is run with input from TEMPIN, output to
4727 file TEMPOUT and stderr to TEMPERR. */
4730 run_msdos_command (argv
, working_dir
, tempin
, tempout
, temperr
, envv
)
4731 unsigned char **argv
;
4732 const char *working_dir
;
4733 int tempin
, tempout
, temperr
;
4736 char *saveargv1
, *saveargv2
, *lowcase_argv0
, *pa
, *pl
;
4737 char oldwd
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
4738 int msshell
, result
= -1, inbak
, outbak
, errbak
, x
, y
;
4741 /* Get current directory as MSDOS cwd is not per-process. */
4744 /* If argv[0] is the shell, it might come in any lettercase.
4745 Since `Fmember' is case-sensitive, we need to downcase
4746 argv[0], even if we are on case-preserving filesystems. */
4747 lowcase_argv0
= alloca (strlen (argv
[0]) + 1);
4748 for (pa
= argv
[0], pl
= lowcase_argv0
; *pa
; pl
++)
4751 if (*pl
>= 'A' && *pl
<= 'Z')
4756 cmd
= Ffile_name_nondirectory (build_string (lowcase_argv0
));
4757 msshell
= !NILP (Fmember (cmd
, Fsymbol_value (intern ("msdos-shells"))))
4758 && !strcmp ("-c", argv
[1]);
4761 saveargv1
= argv
[1];
4762 saveargv2
= argv
[2];
4764 /* We only need to mirror slashes if a DOS shell will be invoked
4765 not via `system' (which does the mirroring itself). Yes, that
4766 means DJGPP v1.x will lose here. */
4767 if (argv
[2] && argv
[3])
4769 char *p
= alloca (strlen (argv
[2]) + 1);
4771 strcpy (argv
[2] = p
, saveargv2
);
4772 while (*p
&& isspace (*p
))
4784 chdir (working_dir
);
4788 if (inbak
< 0 || outbak
< 0 || errbak
< 0)
4789 goto done
; /* Allocation might fail due to lack of descriptors. */
4792 mouse_get_xy (&x
, &y
);
4794 dos_ttcooked (); /* do it here while 0 = stdin */
4802 if (msshell
&& !argv
[3])
4804 /* MS-DOS native shells are too restrictive. For starters, they
4805 cannot grok commands longer than 126 characters. In DJGPP v2
4806 and later, `system' is much smarter, so we'll call it instead. */
4810 /* A shell gets a single argument--its full command
4811 line--whose original was saved in `saveargv2'. */
4813 /* Don't let them pass empty command lines to `system', since
4814 with some shells it will try to invoke an interactive shell,
4815 which will hang Emacs. */
4816 for (cmnd
= saveargv2
; *cmnd
&& isspace (*cmnd
); cmnd
++)
4820 extern char **environ
;
4821 char **save_env
= environ
;
4822 int save_system_flags
= __system_flags
;
4824 /* Request the most powerful version of `system'. We need
4825 all the help we can get to avoid calling stock DOS shells. */
4826 __system_flags
= (__system_redirect
4827 | __system_use_shell
4828 | __system_allow_multiple_cmds
4829 | __system_allow_long_cmds
4830 | __system_handle_null_commands
4831 | __system_emulate_chdir
);
4834 result
= system (cmnd
);
4835 __system_flags
= save_system_flags
;
4839 result
= 0; /* emulate Unixy shell behavior with empty cmd line */
4843 #endif /* __DJGPP__ > 1 */
4845 result
= spawnve (P_WAIT
, argv
[0], argv
, envv
);
4850 emacs_close (inbak
);
4851 emacs_close (outbak
);
4852 emacs_close (errbak
);
4858 mouse_moveto (x
, y
);
4861 /* Some programs might change the meaning of the highest bit of the
4862 text attribute byte, so we get blinking characters instead of the
4863 bright background colors. Restore that. */
4870 argv
[1] = saveargv1
;
4871 argv
[2] = saveargv2
;
4880 fprintf (stderr
, "%s not yet implemented\r\n", badfunc
);
4887 /* ------------------------- Compatibility functions -------------------
4892 /* Hostnames for a pc are not really funny,
4893 but they are used in change log so we emulate the best we can. */
4895 gethostname (p
, size
)
4899 char *q
= egetenv ("HOSTNAME");
4906 /* When time zones are set from Ms-Dos too many C-libraries are playing
4907 tricks with time values. We solve this by defining our own version
4908 of `gettimeofday' bypassing GO32. Our version needs to be initialized
4909 once and after each call to `tzset' with TZ changed. That is
4910 accomplished by aliasing tzset to init_gettimeofday. */
4912 static struct tm time_rec
;
4915 gettimeofday (struct timeval
*tp
, struct timezone
*tzp
)
4923 if (t
.ti_hour
< time_rec
.tm_hour
) /* midnight wrap */
4927 time_rec
.tm_year
= d
.da_year
- 1900;
4928 time_rec
.tm_mon
= d
.da_mon
- 1;
4929 time_rec
.tm_mday
= d
.da_day
;
4932 time_rec
.tm_hour
= t
.ti_hour
;
4933 time_rec
.tm_min
= t
.ti_min
;
4934 time_rec
.tm_sec
= t
.ti_sec
;
4937 tm
.tm_gmtoff
= dos_timezone_offset
;
4939 tp
->tv_sec
= mktime (&tm
); /* may modify tm */
4940 tp
->tv_usec
= t
.ti_hund
* (1000000 / 100);
4942 /* Ignore tzp; it's obsolescent. */
4946 #endif /* __DJGPP__ < 2 */
4949 * A list of unimplemented functions that we silently ignore.
4953 unsigned alarm (s
) unsigned s
; {}
4954 fork () { return 0; }
4955 int kill (x
, y
) int x
, y
; { return -1; }
4957 void volatile pause () {}
4958 sigsetmask (x
) int x
; { return 0; }
4959 sigblock (mask
) int mask
; { return 0; }
4962 void request_sigio (void) {}
4963 setpgrp () {return 0; }
4964 setpriority (x
,y
,z
) int x
,y
,z
; { return 0; }
4965 void unrequest_sigio (void) {}
4968 #if __DJGPP_MINOR__ < 2
4970 #ifdef POSIX_SIGNALS
4972 /* Augment DJGPP library POSIX signal functions. This is needed
4973 as of DJGPP v2.01, but might be in the library in later releases. */
4975 #include <libc/bss.h>
4977 /* A counter to know when to re-initialize the static sets. */
4978 static int sigprocmask_count
= -1;
4980 /* Which signals are currently blocked (initially none). */
4981 static sigset_t current_mask
;
4983 /* Which signals are pending (initially none). */
4984 static sigset_t pending_signals
;
4986 /* Previous handlers to restore when the blocked signals are unblocked. */
4987 typedef void (*sighandler_t
)(int);
4988 static sighandler_t prev_handlers
[320];
4990 /* A signal handler which just records that a signal occurred
4991 (it will be raised later, if and when the signal is unblocked). */
4993 sig_suspender (signo
)
4996 sigaddset (&pending_signals
, signo
);
5000 sigprocmask (how
, new_set
, old_set
)
5002 const sigset_t
*new_set
;
5008 /* If called for the first time, initialize. */
5009 if (sigprocmask_count
!= __bss_count
)
5011 sigprocmask_count
= __bss_count
;
5012 sigemptyset (&pending_signals
);
5013 sigemptyset (¤t_mask
);
5014 for (signo
= 0; signo
< 320; signo
++)
5015 prev_handlers
[signo
] = SIG_ERR
;
5019 *old_set
= current_mask
;
5024 if (how
!= SIG_BLOCK
&& how
!= SIG_UNBLOCK
&& how
!= SIG_SETMASK
)
5030 sigemptyset (&new_mask
);
5032 /* DJGPP supports upto 320 signals. */
5033 for (signo
= 0; signo
< 320; signo
++)
5035 if (sigismember (¤t_mask
, signo
))
5036 sigaddset (&new_mask
, signo
);
5037 else if (sigismember (new_set
, signo
) && how
!= SIG_UNBLOCK
)
5039 sigaddset (&new_mask
, signo
);
5041 /* SIGKILL is silently ignored, as on other platforms. */
5042 if (signo
!= SIGKILL
&& prev_handlers
[signo
] == SIG_ERR
)
5043 prev_handlers
[signo
] = signal (signo
, sig_suspender
);
5045 if (( how
== SIG_UNBLOCK
5046 && sigismember (&new_mask
, signo
)
5047 && sigismember (new_set
, signo
))
5048 || (how
== SIG_SETMASK
5049 && sigismember (&new_mask
, signo
)
5050 && !sigismember (new_set
, signo
)))
5052 sigdelset (&new_mask
, signo
);
5053 if (prev_handlers
[signo
] != SIG_ERR
)
5055 signal (signo
, prev_handlers
[signo
]);
5056 prev_handlers
[signo
] = SIG_ERR
;
5058 if (sigismember (&pending_signals
, signo
))
5060 sigdelset (&pending_signals
, signo
);
5065 current_mask
= new_mask
;
5069 #else /* not POSIX_SIGNALS */
5071 sigsetmask (x
) int x
; { return 0; }
5072 sigblock (mask
) int mask
; { return 0; }
5074 #endif /* not POSIX_SIGNALS */
5075 #endif /* not __DJGPP_MINOR__ < 2 */
5076 #endif /* __DJGPP__ > 1 */
5079 #include "sysselect.h"
5081 #ifndef EMACS_TIME_ZERO_OR_NEG_P
5082 #define EMACS_TIME_ZERO_OR_NEG_P(time) \
5083 ((long)(time).tv_sec < 0 \
5084 || ((time).tv_sec == 0 \
5085 && (long)(time).tv_usec <= 0))
5088 /* This yields the rest of the current time slice to the task manager.
5089 It should be called by any code which knows that it has nothing
5090 useful to do except idle.
5092 I don't use __dpmi_yield here, since versions of library before 2.02
5093 called Int 2Fh/AX=1680h there in a way that would wedge the DOS box
5094 on some versions of Windows 9X. */
5097 dos_yield_time_slice (void)
5099 _go32_dpmi_registers r
;
5102 r
.x
.ss
= r
.x
.sp
= r
.x
.flags
= 0;
5103 _go32_dpmi_simulate_int (0x2f, &r
);
5108 /* Only event queue is checked. */
5109 /* We don't have to call timer_check here
5110 because wait_reading_process_input takes care of that. */
5112 sys_select (nfds
, rfds
, wfds
, efds
, timeout
)
5114 SELECT_TYPE
*rfds
, *wfds
, *efds
;
5115 EMACS_TIME
*timeout
;
5123 check_input
= FD_ISSET (0, rfds
);
5134 /* If we are looking only for the terminal, with no timeout,
5135 just read it and wait -- that's more efficient. */
5138 while (!detect_input_pending ())
5140 dos_yield_time_slice ();
5145 EMACS_TIME clnow
, cllast
, cldiff
;
5148 EMACS_SET_SECS_USECS (cllast
, t
.ti_sec
, t
.ti_hund
* 10000L);
5150 while (!check_input
|| !detect_input_pending ())
5153 EMACS_SET_SECS_USECS (clnow
, t
.ti_sec
, t
.ti_hund
* 10000L);
5154 EMACS_SUB_TIME (cldiff
, clnow
, cllast
);
5156 /* When seconds wrap around, we assume that no more than
5157 1 minute passed since last `gettime'. */
5158 if (EMACS_TIME_NEG_P (cldiff
))
5159 EMACS_SET_SECS (cldiff
, EMACS_SECS (cldiff
) + 60);
5160 EMACS_SUB_TIME (*timeout
, *timeout
, cldiff
);
5162 /* Stop when timeout value crosses zero. */
5163 if (EMACS_TIME_ZERO_OR_NEG_P (*timeout
))
5166 dos_yield_time_slice ();
5176 * Define overlaid functions:
5178 * chdir -> sys_chdir
5179 * tzset -> init_gettimeofday
5180 * abort -> dos_abort
5185 extern int chdir ();
5191 int len
= strlen (path
);
5192 char *tmp
= (char *)path
;
5194 if (*tmp
&& tmp
[1] == ':')
5196 if (getdisk () != tolower (tmp
[0]) - 'a')
5197 setdisk (tolower (tmp
[0]) - 'a');
5198 tmp
+= 2; /* strip drive: KFS 1995-07-06 */
5202 if (len
> 1 && (tmp
[len
- 1] == '/'))
5204 char *tmp1
= (char *) alloca (len
+ 1);
5215 extern void tzset (void);
5218 init_gettimeofday ()
5224 ltm
= gtm
= time (NULL
);
5225 ltm
= mktime (lstm
= localtime (<m
));
5226 gtm
= mktime (gmtime (>m
));
5227 time_rec
.tm_hour
= 99; /* force gettimeofday to get date */
5228 time_rec
.tm_isdst
= lstm
->tm_isdst
;
5229 dos_timezone_offset
= time_rec
.tm_gmtoff
= (int)(gtm
- ltm
) / 60;
5236 dos_abort (file
, line
)
5240 char buffer1
[200], buffer2
[400];
5243 sprintf (buffer1
, "<EMACS FATAL ERROR IN %s LINE %d>", file
, line
);
5244 for (i
= j
= 0; buffer1
[i
]; i
++) {
5245 buffer2
[j
++] = buffer1
[i
];
5246 buffer2
[j
++] = 0x70;
5248 dosmemput (buffer2
, j
, (int)ScreenPrimary
);
5249 ScreenSetCursor (2, 0);
5257 ScreenSetCursor (10, 0);
5258 cputs ("\r\n\nEmacs aborted!\r\n");
5260 #if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
5261 if (screen_virtual_segment
)
5262 dosv_refresh_virtual_screen (2 * 10 * screen_size_X
, 4 * screen_size_X
);
5263 /* Generate traceback, so we could tell whodunit. */
5264 signal (SIGINT
, SIG_DFL
);
5265 __asm__
__volatile__ ("movb $0x1b,%al;call ___djgpp_hw_exception");
5266 #else /* __DJGPP_MINOR__ >= 2 */
5268 #endif /* __DJGPP_MINOR__ >= 2 */
5274 /* The following variables are required so that cus-start.el won't
5275 complain about unbound variables. */
5276 #ifndef subprocesses
5277 /* Nonzero means delete a process right away if it exits (process.c). */
5278 static int delete_exited_processes
;
5283 recent_doskeys
= Fmake_vector (make_number (NUM_RECENT_DOSKEYS
), Qnil
);
5284 staticpro (&recent_doskeys
);
5286 #ifndef HAVE_X_WINDOWS
5288 /* The following two are from xfns.c: */
5289 Qreverse
= intern ("reverse");
5290 staticpro (&Qreverse
);
5292 DEFVAR_LISP ("dos-unsupported-char-glyph", &Vdos_unsupported_char_glyph
,
5293 doc
: /* *Glyph to display instead of chars not supported by current codepage.
5294 This variable is used only by MSDOS terminals. */);
5295 Vdos_unsupported_char_glyph
= '\177';
5298 #ifndef subprocesses
5299 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
5300 doc
: /* *Non-nil means delete processes immediately when they exit.
5301 nil means don't delete them until `list-processes' is run. */);
5302 delete_exited_processes
= 0;
5305 defsubr (&Srecent_doskeys
);
5306 defsubr (&Smsdos_long_file_names
);
5307 defsubr (&Smsdos_downcase_filename
);
5308 defsubr (&Smsdos_remember_default_colors
);
5309 defsubr (&Smsdos_set_mouse_buttons
);
5314 /* arch-tag: db404e92-52a5-475f-9eb2-1cb78dd05f30
5315 (do not change this comment) */