1 /* MS-DOS specific C utilities. -*- coding: raw-text -*-
2 Copyright (C) 1993, 94, 95, 96, 97, 1999 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Contributed by Morten Welinder */
22 /* New display, keyboard, and mouse control by Kim F. Storm */
24 /* Note: some of the stuff here was taken from end of sysdep.c in demacs. */
33 #include <sys/param.h>
37 #include <string.h> /* for bzero and string functions */
38 #include <sys/stat.h> /* for _fixpath */
39 #include <unistd.h> /* for chdir, dup, dup2, etc. */
42 #include <io.h> /* for setmode */
43 #include <dpmi.h> /* for __dpmi_xxx stuff */
44 #include <sys/farptr.h> /* for _farsetsel, _farnspokeb */
45 #include <libc/dosio.h> /* for _USE_LFN */
46 #include <conio.h> /* for cputs */
51 #include "termhooks.h"
53 #include "dispextern.h"
63 #include "blockinput.h"
68 /* #include <process.h> */
69 /* Damn that local process.h! Instead we can define P_WAIT ourselves. */
77 #define _dos_ds _go32_info_block.selector_for_linear_memory
83 #include "syssignal.h"
89 /* If other `malloc' than ours is used, force our `sbrk' behave like
90 Unix programs expect (resize memory blocks to keep them contiguous).
91 If `sbrk' from `ralloc.c' is NOT used, also zero-out sbrk'ed memory,
92 because that's what `gmalloc' expects to get. */
96 int _crt0_startup_flags
= _CRT0_FLAG_UNIX_SBRK
;
97 #else /* not REL_ALLOC */
98 int _crt0_startup_flags
= (_CRT0_FLAG_UNIX_SBRK
| _CRT0_FLAG_FILL_SBRK_MEMORY
);
99 #endif /* not REL_ALLOC */
100 #endif /* GNU_MALLOC */
102 #endif /* not SYSTEM_MALLOC */
103 #endif /* __DJGPP__ > 1 */
122 /* ------------------------ Mouse control ---------------------------
124 * Coordinates are in screen positions and zero based.
125 * Mouse buttons are numbered from left to right and also zero based.
128 /* This used to be in termhooks.h, but mainstream Emacs code no longer
129 uses it, and it was removed... */
130 #define NUM_MOUSE_BUTTONS (5)
132 int have_mouse
; /* 0: no, 1: enabled, -1: disabled */
133 static int mouse_visible
;
135 static int mouse_last_x
;
136 static int mouse_last_y
;
138 static int mouse_button_translate
[NUM_MOUSE_BUTTONS
];
139 static int mouse_button_count
;
146 if (have_mouse
> 0 && !mouse_visible
)
149 fprintf (termscript
, "<M_ON>");
151 int86 (0x33, ®s
, ®s
);
161 if (have_mouse
> 0 && mouse_visible
)
164 fprintf (termscript
, "<M_OFF>");
166 int86 (0x33, ®s
, ®s
);
172 mouse_setup_buttons (int n_buttons
)
176 mouse_button_count
= 3;
177 mouse_button_translate
[0] = 0; /* Left */
178 mouse_button_translate
[1] = 2; /* Middle */
179 mouse_button_translate
[2] = 1; /* Right */
181 else /* two, what else? */
183 mouse_button_count
= 2;
184 mouse_button_translate
[0] = 0;
185 mouse_button_translate
[1] = 1;
189 DEFUN ("msdos-set-mouse-buttons", Fmsdos_set_mouse_buttons
, Smsdos_set_mouse_buttons
,
190 1, 1, "NSet number of mouse buttons to: ",
191 "Set the number of mouse buttons to use by Emacs.\n\
192 This is useful with mice that report the number of buttons inconsistently,\n\
193 e.g., if the number of buttons is reported as 3, but Emacs only sees 2 of\n\
194 them. This happens with wheeled mice on Windows 9X, for example.")
196 Lisp_Object nbuttons
;
198 CHECK_NUMBER (nbuttons
, 0);
199 mouse_setup_buttons (XINT (nbuttons
));
204 mouse_get_xy (int *x
, int *y
)
209 int86 (0x33, ®s
, ®s
);
221 fprintf (termscript
, "<M_XY=%dx%d>", x
, y
);
223 mouse_last_x
= regs
.x
.cx
= x
* 8;
224 mouse_last_y
= regs
.x
.dx
= y
* 8;
225 int86 (0x33, ®s
, ®s
);
229 mouse_pressed (b
, xp
, yp
)
234 if (b
>= mouse_button_count
)
237 regs
.x
.bx
= mouse_button_translate
[b
];
238 int86 (0x33, ®s
, ®s
);
240 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
241 return (regs
.x
.bx
!= 0);
245 mouse_released (b
, xp
, yp
)
250 if (b
>= mouse_button_count
)
253 regs
.x
.bx
= mouse_button_translate
[b
];
254 int86 (0x33, ®s
, ®s
);
256 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
257 return (regs
.x
.bx
!= 0);
261 mouse_button_depressed (b
, xp
, yp
)
266 if (b
>= mouse_button_count
)
269 int86 (0x33, ®s
, ®s
);
270 if ((regs
.x
.bx
& (1 << mouse_button_translate
[b
])) != 0)
280 mouse_get_pos (f
, insist
, bar_window
, part
, x
, y
, time
)
283 Lisp_Object
*bar_window
, *x
, *y
;
284 enum scroll_bar_part
*part
;
288 Lisp_Object frame
, tail
;
290 /* Clear the mouse-moved flag for every frame on this display. */
291 FOR_EACH_FRAME (tail
, frame
)
292 XFRAME (frame
)->mouse_moved
= 0;
294 *f
= SELECTED_FRAME();
296 mouse_get_xy (&ix
, &iy
);
297 *time
= event_timestamp ();
298 *x
= make_number (mouse_last_x
= ix
);
299 *y
= make_number (mouse_last_y
= iy
);
307 mouse_get_xy (&x
, &y
);
308 SELECTED_FRAME()->mouse_moved
|= (x
!= mouse_last_x
|| y
!= mouse_last_y
);
313 /* Force the mouse driver to ``forget'' about any button clicks until
316 mouse_clear_clicks (void)
320 for (b
= 0; b
< mouse_button_count
; b
++)
322 int dummy_x
, dummy_y
;
324 (void) mouse_pressed (b
, &dummy_x
, &dummy_y
);
325 (void) mouse_released (b
, &dummy_x
, &dummy_y
);
335 fprintf (termscript
, "<M_INIT>");
338 int86 (0x33, ®s
, ®s
);
340 /* Reset the mouse last press/release info. It seems that Windows
341 doesn't do that automatically when function 21h is called, which
342 causes Emacs to ``remember'' the click that switched focus to the
343 window just before Emacs was started from that window. */
344 mouse_clear_clicks ();
348 regs
.x
.dx
= 8 * (ScreenCols () - 1);
349 int86 (0x33, ®s
, ®s
);
353 regs
.x
.dx
= 8 * (ScreenRows () - 1);
354 int86 (0x33, ®s
, ®s
);
360 /* ------------------------- Screen control ----------------------
364 static int internal_terminal
= 0;
366 #ifndef HAVE_X_WINDOWS
367 extern unsigned char ScreenAttrib
;
368 static int screen_face
;
369 static int highlight
;
371 static int screen_size_X
;
372 static int screen_size_Y
;
373 static int screen_size
;
375 static int current_pos_X
;
376 static int current_pos_Y
;
377 static int new_pos_X
;
378 static int new_pos_Y
;
380 static void *startup_screen_buffer
;
381 static int startup_screen_size_X
;
382 static int startup_screen_size_Y
;
383 static int startup_pos_X
;
384 static int startup_pos_Y
;
385 static unsigned char startup_screen_attrib
;
387 static clock_t startup_time
;
389 static int term_setup_done
;
391 static unsigned short outside_cursor
;
393 /* Similar to the_only_frame. */
394 struct x_output the_only_x_display
;
396 /* Support for DOS/V (allows Japanese characters to be displayed on
397 standard, non-Japanese, ATs). Only supported for DJGPP v2 and later. */
399 /* Holds the address of the text-mode screen buffer. */
400 static unsigned long screen_old_address
= 0;
401 /* Segment and offset of the virtual screen. If 0, DOS/V is NOT loaded. */
402 static unsigned short screen_virtual_segment
= 0;
403 static unsigned short screen_virtual_offset
= 0;
404 /* A flag to control how to display unibyte 8-bit characters. */
405 extern int unibyte_display_via_language_environment
;
410 /* Update the screen from a part of relocated DOS/V screen buffer which
411 begins at OFFSET and includes COUNT characters. */
413 dosv_refresh_virtual_screen (int offset
, int count
)
417 if (offset
< 0 || count
< 0) /* paranoia; invalid values crash DOS/V */
420 regs
.h
.ah
= 0xff; /* update relocated screen */
421 regs
.x
.es
= screen_virtual_segment
;
422 regs
.x
.di
= screen_virtual_offset
+ offset
;
424 __dpmi_int (0x10, ®s
);
429 dos_direct_output (y
, x
, buf
, len
)
435 int t0
= 2 * (x
+ y
* screen_size_X
);
436 int t
= t0
+ (int) ScreenPrimary
;
441 dosmemput (buf
++, 1, t
);
445 /* This is faster. */
446 for (_farsetsel (_dos_ds
); --len
>= 0; t
+= 2, buf
++)
447 _farnspokeb (t
, *buf
);
449 if (screen_virtual_segment
)
450 dosv_refresh_virtual_screen (t0
, l0
);
455 /* Flash the screen as a substitute for BEEPs. */
459 do_visible_bell (xorattr
)
460 unsigned char xorattr
;
465 movl _ScreenPrimary,%%eax
472 xorb %%al,%%gs:(%%ebx)
488 : "m" (xorattr
), "g" (screen_size
)
489 : "%eax", "%ebx", /* "%gs",*/ "%ecx", "%edx");
493 ScreenVisualBell (void)
495 /* This creates an xor-mask that will swap the default fore- and
496 background colors. */
497 do_visible_bell (((the_only_x_display
.foreground_pixel
498 ^ the_only_x_display
.background_pixel
)
503 #ifndef HAVE_X_WINDOWS
505 static int blink_bit
= -1; /* the state of the blink bit at startup */
507 /* Enable bright background colors. */
513 /* Remember the original state of the blink/bright-background bit.
514 It is stored at 0040:0065h in the BIOS data area. */
516 blink_bit
= (_farpeekb (_dos_ds
, 0x465) & 0x20) == 0x20;
520 int86 (0x10, ®s
, ®s
);
523 /* Disable bright background colors (and enable blinking) if we found
524 the video system in that state at startup. */
526 maybe_enable_blinking (void)
534 int86 (0x10, ®s
, ®s
);
538 /* Return non-zero if the system has a VGA adapter. */
545 int86 (0x10, ®s
, ®s
);
546 if (regs
.h
.al
== 0x1a && regs
.h
.bl
> 5 && regs
.h
.bl
< 13)
551 /* Set the screen dimensions so that it can show no less than
552 ROWS x COLS frame. */
555 dos_set_window_size (rows
, cols
)
559 Lisp_Object video_mode
;
560 int video_mode_value
;
563 int current_rows
= ScreenRows (), current_cols
= ScreenCols ();
565 if (*rows
== current_rows
&& *cols
== current_cols
)
569 have_vga
= vga_installed ();
571 /* If the user specified a special video mode for these dimensions,
573 sprintf (video_name
, "screen-dimensions-%dx%d", *rows
, *cols
);
574 video_mode
= XSYMBOL (Fintern_soft (build_string (video_name
),
577 if (INTEGERP (video_mode
)
578 && (video_mode_value
= XINT (video_mode
)) > 0)
580 regs
.x
.ax
= video_mode_value
;
581 int86 (0x10, ®s
, ®s
);
585 /* Must hardware-reset the mouse, or else it won't update
586 its notion of screen dimensions for some non-standard
587 video modes. This is *painfully* slow... */
589 int86 (0x33, ®s
, ®s
);
593 /* Find one of the dimensions supported by standard EGA/VGA
594 which gives us at least the required dimensions. */
603 } std_dimension
[] = {
613 while (i
< sizeof (std_dimension
) / sizeof (std_dimension
[0]))
615 if (std_dimension
[i
].need_vga
<= have_vga
616 && std_dimension
[i
].rows
>= *rows
)
618 if (std_dimension
[i
].rows
!= current_rows
619 || *cols
!= current_cols
)
620 _set_screen_lines (std_dimension
[i
].rows
);
627 #else /* not __DJGPP__ > 1 */
629 else if (*rows
<= 25)
631 if (current_rows
!= 25 || current_cols
!= 80)
634 int86 (0x10, ®s
, ®s
);
637 int86 (0x10, ®s
, ®s
);
640 int86 (0x10, ®s
, ®s
);
642 int86 (0x10, ®s
, ®s
);
645 else if (*rows
<= 50)
646 if (have_vga
&& (current_rows
!= 50 || current_cols
!= 80)
647 || *rows
<= 43 && (current_rows
!= 43 || current_cols
!= 80))
650 int86 (0x10, ®s
, ®s
);
653 int86 (0x10, ®s
, ®s
);
656 int86 (0x10, ®s
, ®s
);
659 int86 (0x10, ®s
, ®s
);
661 #endif /* not __DJGPP__ > 1 */
669 /* Tell the caller what dimensions have been REALLY set. */
670 *rows
= ScreenRows ();
671 *cols
= ScreenCols ();
674 /* If the dimensions changed, the mouse highlight info is invalid. */
675 if (current_rows
!= *rows
|| current_cols
!= *cols
)
677 struct frame
*f
= SELECTED_FRAME();
678 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
679 Lisp_Object window
= dpyinfo
->mouse_face_window
;
681 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
683 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
684 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
685 dpyinfo
->mouse_face_window
= Qnil
;
690 /* Enable bright background colors. */
693 /* FIXME: I'm not sure the above will run at all on DOS/V. But let's
694 be defensive anyway. */
695 if (screen_virtual_segment
)
696 dosv_refresh_virtual_screen (0, *cols
* *rows
);
699 /* If we write a character in the position where the mouse is,
700 the mouse cursor may need to be refreshed. */
710 mouse_get_xy (&x
, &y
);
711 if (y
!= new_pos_Y
|| x
< new_pos_X
)
717 #define DEFAULT_CURSOR_START (-1)
718 #define DEFAULT_CURSOR_WIDTH (-1)
719 #define BOX_CURSOR_WIDTH (-32)
721 /* Set cursor to begin at scan line START_LINE in the character cell
722 and extend for WIDTH scan lines. Scan lines are counted from top
723 of the character cell, starting from zero. */
725 msdos_set_cursor_shape (struct frame
*f
, int start_line
, int width
)
728 unsigned desired_cursor
;
730 int max_line
, top_line
, bot_line
;
732 /* Avoid the costly BIOS call if F isn't the currently selected
733 frame. Allow for NULL as unconditionally meaning the selected
735 if (f
&& f
!= SELECTED_FRAME())
738 /* The character cell size in scan lines is stored at 40:85 in the
740 max_line
= _farpeekw (_dos_ds
, 0x485) - 1;
743 default: /* this relies on CGA cursor emulation being ON! */
760 if (width
== BOX_CURSOR_WIDTH
)
765 else if (start_line
!= DEFAULT_CURSOR_START
)
767 top_line
= start_line
;
768 bot_line
= top_line
- width
- 1;
770 else if (width
!= DEFAULT_CURSOR_WIDTH
)
773 bot_line
= -1 - width
;
776 top_line
= bot_line
+ 1;
780 /* [31, 0] seems to DTRT for all screen sizes. */
784 else /* WIDTH is positive */
786 if (start_line
!= DEFAULT_CURSOR_START
)
787 bot_line
= start_line
;
788 top_line
= bot_line
- (width
- 1);
791 /* If the current cursor shape is already what they want, we are
793 desired_cursor
= ((top_line
& 0x1f) << 8) | (bot_line
& 0x1f);
794 if (desired_cursor
== _farpeekw (_dos_ds
, 0x460))
798 regs
.x
.cx
= desired_cursor
;
799 __dpmi_int (0x10, ®s
);
800 #endif /* __DJGPP__ > 1 */
804 IT_set_cursor_type (struct frame
*f
, Lisp_Object cursor_type
)
806 if (EQ (cursor_type
, Qbar
))
808 /* Just BAR means the normal EGA/VGA cursor. */
809 msdos_set_cursor_shape (f
, DEFAULT_CURSOR_START
, DEFAULT_CURSOR_WIDTH
);
811 else if (CONSP (cursor_type
) && EQ (XCAR (cursor_type
), Qbar
))
813 Lisp_Object bar_parms
= XCDR (cursor_type
);
816 if (INTEGERP (bar_parms
))
818 /* Feature: negative WIDTH means cursor at the top
819 of the character cell, zero means invisible cursor. */
820 width
= XINT (bar_parms
);
821 msdos_set_cursor_shape (f
, width
>= 0 ? DEFAULT_CURSOR_START
: 0,
824 else if (CONSP (bar_parms
)
825 && INTEGERP (XCAR (bar_parms
))
826 && INTEGERP (XCDR (bar_parms
)))
828 int start_line
= XINT (XCDR (bar_parms
));
830 width
= XINT (XCAR (bar_parms
));
831 msdos_set_cursor_shape (f
, start_line
, width
);
835 /* Treat anything unknown as "box cursor". This includes nil, so
836 that a frame which doesn't specify a cursor type gets a box,
837 which is the default in Emacs. */
838 msdos_set_cursor_shape (f
, 0, BOX_CURSOR_WIDTH
);
851 union REGS inregs
, outregs
;
854 intdos (&inregs
, &outregs
);
858 /* Given a face id FACE, extract the face parameters to be used for
859 display until the face changes. The face parameters (actually, its
860 color) are used to construct the video attribute byte for each
861 glyph during the construction of the buffer that is then blitted to
864 IT_set_face (int face
)
866 struct frame
*sf
= SELECTED_FRAME();
867 struct face
*fp
= FACE_FROM_ID (sf
, face
);
868 unsigned long fg
, bg
;
872 fp
= FACE_FROM_ID (sf
, DEFAULT_FACE_ID
);
873 /* The default face for the frame should always be realized and
882 /* Don't use invalid colors. In particular, FACE_TTY_DEFAULT_*
883 colors mean use the colors of the default face, except that if
884 highlight is on, invert the foreground and the background. Note
885 that we assume all 16 colors to be available for the background,
886 since Emacs switches on this mode (and loses the blinking
887 attribute) at startup. */
888 if (fg
== FACE_TTY_DEFAULT_COLOR
|| fg
== FACE_TTY_DEFAULT_FG_COLOR
)
889 fg
= FRAME_FOREGROUND_PIXEL (sf
);
890 else if (fg
== FACE_TTY_DEFAULT_BG_COLOR
)
891 fg
= FRAME_BACKGROUND_PIXEL (sf
);
892 if (bg
== FACE_TTY_DEFAULT_COLOR
|| bg
== FACE_TTY_DEFAULT_BG_COLOR
)
893 bg
= FRAME_BACKGROUND_PIXEL (sf
);
894 else if (bg
== FACE_TTY_DEFAULT_FG_COLOR
)
895 bg
= FRAME_FOREGROUND_PIXEL (sf
);
897 /* Make sure highlighted lines really stand out, come what may. */
898 if ((highlight
|| fp
->tty_reverse_p
)
899 && (fg
== FRAME_FOREGROUND_PIXEL (sf
)
900 && bg
== FRAME_BACKGROUND_PIXEL (sf
)))
902 unsigned long tem
= fg
;
908 fprintf (termscript
, "<FACE %d%s: %d/%d[FG:%d/BG:%d]>", face
,
909 highlight
? "H" : "", fp
->foreground
, fp
->background
, fg
, bg
);
910 if (fg
>= 0 && fg
< 16)
912 ScreenAttrib
&= 0xf0;
915 if (bg
>= 0 && bg
< 16)
917 ScreenAttrib
&= 0x0f;
918 ScreenAttrib
|= ((bg
& 0x0f) << 4);
922 Lisp_Object Vdos_unsupported_char_glyph
;
925 IT_write_glyphs (struct glyph
*str
, int str_len
)
927 unsigned char *screen_buf
, *screen_bp
, *screen_buf_end
, *bp
;
928 int unsupported_face
= FAST_GLYPH_FACE (Vdos_unsupported_char_glyph
);
929 unsigned unsupported_char
= FAST_GLYPH_CHAR (Vdos_unsupported_char_glyph
);
930 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
931 register int sl
= str_len
;
932 register int tlen
= GLYPH_TABLE_LENGTH
;
933 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
935 /* If terminal_coding does any conversion, use it, otherwise use
936 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
937 because it always returns 1 if terminal_coding.src_multibyte is 1. */
938 struct coding_system
*coding
=
939 (terminal_coding
.common_flags
& CODING_REQUIRE_ENCODING_MASK
941 : &safe_terminal_coding
);
944 /* Do we need to consider conversion of unibyte characters to
946 int convert_unibyte_characters
947 = (NILP (current_buffer
->enable_multibyte_characters
)
948 && unibyte_display_via_language_environment
);
950 unsigned char conversion_buffer
[256];
951 int conversion_buffer_size
= sizeof conversion_buffer
;
953 if (str_len
<= 0) return;
955 screen_buf
= screen_bp
= alloca (str_len
* 2);
956 screen_buf_end
= screen_buf
+ str_len
* 2;
957 sf
= SELECTED_FRAME();
959 /* Since faces get cached and uncached behind our back, we can't
960 rely on their indices in the cache being consistent across
961 invocations. So always reset the screen face to the default
962 face of the frame, before writing glyphs, and let the glyphs
963 set the right face if it's different from the default. */
964 IT_set_face (DEFAULT_FACE_ID
);
966 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
968 terminal_coding
.mode
&= ~CODING_MODE_LAST_BLOCK
;
971 int cf
, chlen
, enclen
;
972 unsigned char workbuf
[MAX_MULTIBYTE_LENGTH
], *buf
;
975 /* Glyphs with GLYPH_MASK_PADDING bit set are actually there
976 only for the redisplay code to know how many columns does
977 this character occupy on the screen. Skip padding glyphs. */
978 if (CHAR_GLYPH_PADDING_P (*str
))
985 register GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*str
);
986 int glyph_not_in_table
= 0;
988 if (g
< 0 || g
>= tlen
)
990 /* This glyph doesn't have an entry in Vglyph_table. */
992 glyph_not_in_table
= 1;
996 /* This glyph has an entry in Vglyph_table, so process
997 any aliases before testing for simpleness. */
998 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
999 ch
= FAST_GLYPH_CHAR (g
);
1002 /* Convert the character code to multibyte, if they
1003 requested display via language environment. We only want
1004 to convert unibyte characters to multibyte in unibyte
1005 buffers! Otherwise, the 8-bit value in CH came from the
1006 display table set up to display foreign characters. */
1007 if (SINGLE_BYTE_CHAR_P (ch
) && convert_unibyte_characters
1009 || (ch
>= 0200 && !NILP (Vnonascii_translation_table
))))
1010 ch
= unibyte_char_to_multibyte (ch
);
1012 /* Invalid characters are displayed with a special glyph. */
1013 if (! CHAR_VALID_P (ch
, 0))
1015 g
= !NILP (Vdos_unsupported_char_glyph
)
1016 ? Vdos_unsupported_char_glyph
1017 : MAKE_GLYPH (sf
, '\177', GLYPH_FACE (sf
, g
));
1018 ch
= FAST_GLYPH_CHAR (g
);
1021 /* If the face of this glyph is different from the current
1022 screen face, update the screen attribute byte. */
1023 cf
= FAST_GLYPH_FACE (g
);
1024 if (cf
!= screen_face
)
1025 IT_set_face (cf
); /* handles invalid faces gracefully */
1027 if (glyph_not_in_table
|| GLYPH_SIMPLE_P (tbase
, tlen
, g
))
1029 /* We generate the multi-byte form of CH in WORKBUF. */
1030 chlen
= CHAR_STRING (ch
, workbuf
);
1035 /* We have a string in Vglyph_table. */
1036 chlen
= GLYPH_LENGTH (tbase
, g
);
1037 buf
= GLYPH_STRING (tbase
, g
);
1040 /* If the character is not multibyte, don't bother converting it. */
1043 *conversion_buffer
= (unsigned char)ch
;
1049 coding
->src_multibyte
= 1;
1050 encode_coding (coding
, buf
, conversion_buffer
, chlen
,
1051 conversion_buffer_size
);
1052 chlen
-= coding
->consumed
;
1053 enclen
= coding
->produced
;
1055 /* Replace glyph codes that cannot be converted by
1056 terminal_coding with Vdos_unsupported_char_glyph. */
1057 if (*conversion_buffer
== '?')
1059 unsigned char *cbp
= conversion_buffer
;
1061 while (cbp
< conversion_buffer
+ enclen
&& *cbp
== '?')
1062 *cbp
++ = unsupported_char
;
1063 if (unsupported_face
!= screen_face
)
1064 IT_set_face (unsupported_face
);
1068 if (enclen
+ chlen
> screen_buf_end
- screen_bp
)
1070 /* The allocated buffer for screen writes is too small.
1071 Flush it and loop again without incrementing STR, so
1072 that the next loop will begin with the same glyph. */
1073 int nbytes
= screen_bp
- screen_buf
;
1076 dosmemput (screen_buf
, nbytes
, (int)ScreenPrimary
+ offset
);
1077 if (screen_virtual_segment
)
1078 dosv_refresh_virtual_screen (offset
, nbytes
/ 2);
1079 new_pos_X
+= nbytes
/ 2;
1082 /* Prepare to reuse the same buffer again. */
1083 screen_bp
= screen_buf
;
1087 /* There's enough place in the allocated buffer to add
1088 the encoding of this glyph. */
1090 /* First, copy the encoded bytes. */
1091 for (bp
= conversion_buffer
; enclen
--; bp
++)
1093 *screen_bp
++ = (unsigned char)*bp
;
1094 *screen_bp
++ = ScreenAttrib
;
1096 fputc (*bp
, termscript
);
1099 /* Now copy the bytes not consumed by the encoding. */
1102 buf
+= coding
->consumed
;
1106 fputc (*buf
, termscript
);
1107 *screen_bp
++ = (unsigned char)*buf
++;
1108 *screen_bp
++ = ScreenAttrib
;
1112 /* Update STR and its remaining length. */
1119 /* Dump whatever is left in the screen buffer. */
1121 dosmemput (screen_buf
, screen_bp
- screen_buf
, (int)ScreenPrimary
+ offset
);
1122 if (screen_virtual_segment
)
1123 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1124 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1126 /* We may have to output some codes to terminate the writing. */
1127 if (CODING_REQUIRE_FLUSHING (coding
))
1129 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
1130 encode_coding (coding
, "", conversion_buffer
, 0, conversion_buffer_size
);
1131 if (coding
->produced
> 0)
1133 screen_buf
= alloca (coding
->produced
* 2);
1134 for (screen_bp
= screen_buf
, bp
= conversion_buffer
;
1135 coding
->produced
--; bp
++)
1137 *screen_bp
++ = (unsigned char)*bp
;
1138 *screen_bp
++ = ScreenAttrib
;
1140 fputc (*bp
, termscript
);
1142 offset
+= screen_bp
- screen_buf
;
1144 dosmemput (screen_buf
, screen_bp
- screen_buf
,
1145 (int)ScreenPrimary
+ offset
);
1146 if (screen_virtual_segment
)
1147 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1148 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1153 /************************************************************************
1154 Mouse Highlight (and friends..)
1155 ************************************************************************/
1157 /* This is used for debugging, to turn off note_mouse_highlight. */
1158 int disable_mouse_highlight
;
1160 /* If non-nil, dos_rawgetc generates an event to display that string.
1161 (The display is done in keyboard.c:read_char, by calling
1163 static Lisp_Object help_echo
;
1164 static Lisp_Object previous_help_echo
; /* a helper temporary variable */
1166 /* These record the window, the object and the position where the help
1167 echo string was generated. */
1168 static Lisp_Object help_echo_window
;
1169 static Lisp_Object help_echo_object
;
1170 static int help_echo_pos
;
1172 static int mouse_preempted
= 0; /* non-zero when XMenu gobbles mouse events */
1174 /* Set the mouse pointer shape according to whether it is in the
1175 area where the mouse highlight is in effect. */
1177 IT_set_mouse_pointer (int mode
)
1179 /* A no-op for now. DOS text-mode mouse pointer doesn't offer too
1180 many possibilities to change its shape, and the available
1181 functionality pretty much sucks (e.g., almost every reasonable
1182 shape will conceal the character it is on). Since the color of
1183 the pointer changes in the highlighted area, it is not clear to
1184 me whether anything else is required, anyway. */
1187 /* Display the active region described by mouse_face_*
1188 in its mouse-face if HL > 0, in its normal face if HL = 0. */
1190 show_mouse_face (struct display_info
*dpyinfo
, int hl
)
1192 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
1193 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1198 /* If window is in the process of being destroyed, don't bother
1200 if (w
->current_matrix
== NULL
)
1201 goto set_cursor_shape
;
1203 /* Recognize when we are called to operate on rows that don't exist
1204 anymore. This can happen when a window is split. */
1205 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
1206 goto set_cursor_shape
;
1208 /* There's no sense to do anything if the mouse face isn't realized. */
1211 fp
= FACE_FROM_ID (SELECTED_FRAME(), dpyinfo
->mouse_face_face_id
);
1213 goto set_cursor_shape
;
1216 /* Note that mouse_face_beg_row etc. are window relative. */
1217 for (i
= dpyinfo
->mouse_face_beg_row
;
1218 i
<= dpyinfo
->mouse_face_end_row
;
1221 int start_hpos
, end_hpos
;
1222 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
1224 /* Don't do anything if row doesn't have valid contents. */
1225 if (!row
->enabled_p
)
1228 /* For all but the first row, the highlight starts at column 0. */
1229 if (i
== dpyinfo
->mouse_face_beg_row
)
1230 start_hpos
= dpyinfo
->mouse_face_beg_col
;
1234 if (i
== dpyinfo
->mouse_face_end_row
)
1235 end_hpos
= dpyinfo
->mouse_face_end_col
;
1237 end_hpos
= row
->used
[TEXT_AREA
];
1239 if (end_hpos
<= start_hpos
)
1241 /* Record that some glyphs of this row are displayed in
1243 row
->mouse_face_p
= hl
> 0;
1246 int vpos
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1247 int kstart
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1248 int nglyphs
= end_hpos
- start_hpos
;
1249 int offset
= ScreenPrimary
+ 2*(vpos
*screen_size_X
+ kstart
) + 1;
1250 int start_offset
= offset
;
1253 fprintf (termscript
, "\n<MH+ %d-%d:%d>",
1254 kstart
, kstart
+ nglyphs
- 1, vpos
);
1257 IT_set_face (dpyinfo
->mouse_face_face_id
);
1258 /* Since we are going to change only the _colors_ of the
1259 displayed text, there's no need to go through all the
1260 pain of generating and encoding the text from the glyphs.
1261 Instead, we simply poke the attribute byte of each
1262 affected position in video memory with the colors
1263 computed by IT_set_face! */
1264 _farsetsel (_dos_ds
);
1267 _farnspokeb (offset
, ScreenAttrib
);
1270 if (screen_virtual_segment
)
1271 dosv_refresh_virtual_screen (start_offset
, end_hpos
- start_hpos
);
1276 /* We are removing a previously-drawn mouse highlight. The
1277 safest way to do so is to redraw the glyphs anew, since
1278 all kinds of faces and display tables could have changed
1280 int nglyphs
= end_hpos
- start_hpos
;
1281 int save_x
= new_pos_X
, save_y
= new_pos_Y
;
1283 if (end_hpos
>= row
->used
[TEXT_AREA
])
1284 nglyphs
= row
->used
[TEXT_AREA
] - start_hpos
;
1286 /* IT_write_glyphs writes at cursor position, so we need to
1287 temporarily move cursor coordinates to the beginning of
1288 the highlight region. */
1289 new_pos_X
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1290 new_pos_Y
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1293 fprintf (termscript
, "<MH- %d-%d:%d>",
1294 new_pos_X
, new_pos_X
+ nglyphs
- 1, new_pos_Y
);
1295 IT_write_glyphs (row
->glyphs
[TEXT_AREA
] + start_hpos
, nglyphs
);
1297 fputs ("\n", termscript
);
1305 /* Change the mouse pointer shape. */
1306 IT_set_mouse_pointer (hl
);
1309 /* Clear out the mouse-highlighted active region.
1310 Redraw it un-highlighted first. */
1312 clear_mouse_face (struct display_info
*dpyinfo
)
1314 if (! NILP (dpyinfo
->mouse_face_window
))
1315 show_mouse_face (dpyinfo
, 0);
1317 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
1318 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
1319 dpyinfo
->mouse_face_window
= Qnil
;
1322 /* Find the glyph matrix position of buffer position POS in window W.
1323 *HPOS and *VPOS are set to the positions found. W's current glyphs
1324 must be up to date. If POS is above window start return (0, 0).
1325 If POS is after end of W, return end of last line in W. */
1327 fast_find_position (struct window
*w
, int pos
, int *hpos
, int *vpos
)
1331 int maybe_next_line_p
= 0;
1332 int line_start_position
;
1333 int yb
= window_text_bottom_y (w
);
1334 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
1335 struct glyph_row
*best_row
= row
;
1339 if (row
->used
[TEXT_AREA
])
1340 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
1342 line_start_position
= 0;
1344 if (line_start_position
> pos
)
1346 /* If the position sought is the end of the buffer,
1347 don't include the blank lines at the bottom of the window. */
1348 else if (line_start_position
== pos
1349 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
1351 maybe_next_line_p
= 1;
1354 else if (line_start_position
> 0)
1360 /* Find the right column within BEST_ROW. */
1363 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
1365 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + i
;
1368 charpos
= glyph
->charpos
;
1375 else if (charpos
> pos
)
1377 else if (charpos
> 0)
1381 /* If we're looking for the end of the buffer,
1382 and we didn't find it in the line we scanned,
1383 use the start of the following line. */
1384 if (maybe_next_line_p
)
1391 *hpos
= lastcol
+ 1;
1395 /* Take proper action when mouse has moved to the mode or top line of
1396 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
1397 mode line. X is relative to the start of the text display area of
1398 W, so the width of bitmap areas and scroll bars must be subtracted
1399 to get a position relative to the start of the mode line. */
1401 IT_note_mode_line_highlight (struct window
*w
, int x
, int mode_line_p
)
1403 struct frame
*f
= XFRAME (w
->frame
);
1404 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1405 struct glyph_row
*row
;
1408 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1410 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1414 extern Lisp_Object Qhelp_echo
;
1415 struct glyph
*glyph
, *end
;
1416 Lisp_Object help
, map
;
1418 /* Find the glyph under X. */
1419 glyph
= row
->glyphs
[TEXT_AREA
]
1420 + x
- FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
1421 end
= glyph
+ row
->used
[TEXT_AREA
];
1423 && STRINGP (glyph
->object
)
1424 && XSTRING (glyph
->object
)->intervals
1425 && glyph
->charpos
>= 0
1426 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1428 /* If we're on a string with `help-echo' text property,
1429 arrange for the help to be displayed. This is done by
1430 setting the global variable help_echo to the help string. */
1431 help
= Fget_text_property (make_number (glyph
->charpos
),
1432 Qhelp_echo
, glyph
->object
);
1436 XSETWINDOW (help_echo_window
, w
);
1437 help_echo_object
= glyph
->object
;
1438 help_echo_pos
= glyph
->charpos
;
1444 /* Take proper action when the mouse has moved to position X, Y on
1445 frame F as regards highlighting characters that have mouse-face
1446 properties. Also de-highlighting chars where the mouse was before.
1447 X and Y can be negative or out of range. */
1449 IT_note_mouse_highlight (struct frame
*f
, int x
, int y
)
1451 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1456 /* When a menu is active, don't highlight because this looks odd. */
1457 if (mouse_preempted
)
1460 if (disable_mouse_highlight
1461 || !f
->glyphs_initialized_p
)
1464 dpyinfo
->mouse_face_mouse_x
= x
;
1465 dpyinfo
->mouse_face_mouse_y
= y
;
1466 dpyinfo
->mouse_face_mouse_frame
= f
;
1468 if (dpyinfo
->mouse_face_defer
)
1473 dpyinfo
->mouse_face_deferred_gc
= 1;
1477 /* Which window is that in? */
1478 window
= window_from_coordinates (f
, x
, y
, &portion
, 0);
1480 /* If we were displaying active text in another window, clear that. */
1481 if (! EQ (window
, dpyinfo
->mouse_face_window
))
1482 clear_mouse_face (dpyinfo
);
1484 /* Not on a window -> return. */
1485 if (!WINDOWP (window
))
1488 /* Convert to window-relative coordinates. */
1489 w
= XWINDOW (window
);
1490 x
-= WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1491 y
-= WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1493 if (portion
== 1 || portion
== 3)
1495 /* Mouse is on the mode or top line. */
1496 IT_note_mode_line_highlight (w
, x
, portion
== 1);
1500 IT_set_mouse_pointer (0);
1502 /* Are we in a window whose display is up to date?
1503 And verify the buffer's text has not changed. */
1504 if (/* Within text portion of the window. */
1506 && EQ (w
->window_end_valid
, w
->buffer
)
1507 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
1508 && (XFASTINT (w
->last_overlay_modified
)
1509 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
1512 struct glyph_row
*row
;
1513 struct glyph
*glyph
;
1515 /* Find the glyph under X/Y. */
1517 if (y
< w
->current_matrix
->nrows
)
1519 row
= MATRIX_ROW (w
->current_matrix
, y
);
1521 && row
->displays_text_p
1522 && x
< window_box_width (w
, TEXT_AREA
))
1524 glyph
= row
->glyphs
[TEXT_AREA
];
1525 if (x
>= row
->used
[TEXT_AREA
])
1530 if (!BUFFERP (glyph
->object
))
1536 /* Clear mouse face if X/Y not over text. */
1539 clear_mouse_face (dpyinfo
);
1543 if (!BUFFERP (glyph
->object
))
1545 pos
= glyph
->charpos
;
1547 /* Check for mouse-face and help-echo. */
1549 extern Lisp_Object Qmouse_face
;
1550 Lisp_Object mouse_face
, overlay
, position
;
1551 Lisp_Object
*overlay_vec
;
1553 struct buffer
*obuf
;
1556 /* If we get an out-of-range value, return now; avoid an error. */
1557 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1560 /* Make the window's buffer temporarily current for
1561 overlays_at and compute_char_face. */
1562 obuf
= current_buffer
;
1563 current_buffer
= XBUFFER (w
->buffer
);
1569 /* Is this char mouse-active or does it have help-echo? */
1570 XSETINT (position
, pos
);
1572 /* Put all the overlays we want in a vector in overlay_vec.
1573 Store the length in len. If there are more than 10, make
1574 enough space for all, and try again. */
1576 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1577 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
1578 if (noverlays
> len
)
1581 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1582 noverlays
= overlays_at (pos
,
1583 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
1586 /* Sort overlays into increasing priority order. */
1587 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1589 /* Check mouse-face highlighting. */
1590 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
1591 && y
>= dpyinfo
->mouse_face_beg_row
1592 && y
<= dpyinfo
->mouse_face_end_row
1593 && (y
> dpyinfo
->mouse_face_beg_row
1594 || x
>= dpyinfo
->mouse_face_beg_col
)
1595 && (y
< dpyinfo
->mouse_face_end_row
1596 || x
< dpyinfo
->mouse_face_end_col
1597 || dpyinfo
->mouse_face_past_end
)))
1599 /* Clear the display of the old active region, if any. */
1600 clear_mouse_face (dpyinfo
);
1602 /* Find highest priority overlay that has a mouse-face prop. */
1604 for (i
= noverlays
- 1; i
>= 0; --i
)
1606 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1607 if (!NILP (mouse_face
))
1609 overlay
= overlay_vec
[i
];
1614 /* If no overlay applies, get a text property. */
1616 mouse_face
= Fget_text_property (position
, Qmouse_face
,
1619 /* Handle the overlay case. */
1620 if (! NILP (overlay
))
1622 /* Find the range of text around this char that
1623 should be active. */
1624 Lisp_Object before
, after
;
1627 before
= Foverlay_start (overlay
);
1628 after
= Foverlay_end (overlay
);
1629 /* Record this as the current active region. */
1630 fast_find_position (w
, XFASTINT (before
),
1631 &dpyinfo
->mouse_face_beg_col
,
1632 &dpyinfo
->mouse_face_beg_row
);
1633 dpyinfo
->mouse_face_past_end
1634 = !fast_find_position (w
, XFASTINT (after
),
1635 &dpyinfo
->mouse_face_end_col
,
1636 &dpyinfo
->mouse_face_end_row
);
1637 dpyinfo
->mouse_face_window
= window
;
1638 dpyinfo
->mouse_face_face_id
1639 = face_at_buffer_position (w
, pos
, 0, 0,
1640 &ignore
, pos
+ 1, 1);
1642 /* Display it as active. */
1643 show_mouse_face (dpyinfo
, 1);
1645 /* Handle the text property case. */
1646 else if (! NILP (mouse_face
))
1648 /* Find the range of text around this char that
1649 should be active. */
1650 Lisp_Object before
, after
, beginning
, end
;
1653 beginning
= Fmarker_position (w
->start
);
1654 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
1655 - XFASTINT (w
->window_end_pos
)));
1657 = Fprevious_single_property_change (make_number (pos
+ 1),
1659 w
->buffer
, beginning
);
1661 = Fnext_single_property_change (position
, Qmouse_face
,
1663 /* Record this as the current active region. */
1664 fast_find_position (w
, XFASTINT (before
),
1665 &dpyinfo
->mouse_face_beg_col
,
1666 &dpyinfo
->mouse_face_beg_row
);
1667 dpyinfo
->mouse_face_past_end
1668 = !fast_find_position (w
, XFASTINT (after
),
1669 &dpyinfo
->mouse_face_end_col
,
1670 &dpyinfo
->mouse_face_end_row
);
1671 dpyinfo
->mouse_face_window
= window
;
1672 dpyinfo
->mouse_face_face_id
1673 = face_at_buffer_position (w
, pos
, 0, 0,
1674 &ignore
, pos
+ 1, 1);
1676 /* Display it as active. */
1677 show_mouse_face (dpyinfo
, 1);
1681 /* Look for a `help-echo' property. */
1684 extern Lisp_Object Qhelp_echo
;
1686 /* Check overlays first. */
1688 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
1690 overlay
= overlay_vec
[i
];
1691 help
= Foverlay_get (overlay
, Qhelp_echo
);
1697 help_echo_window
= window
;
1698 help_echo_object
= overlay
;
1699 help_echo_pos
= pos
;
1701 /* Try text properties. */
1702 else if (NILP (help
)
1703 && ((STRINGP (glyph
->object
)
1704 && glyph
->charpos
>= 0
1705 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1706 || (BUFFERP (glyph
->object
)
1707 && glyph
->charpos
>= BEGV
1708 && glyph
->charpos
< ZV
)))
1710 help
= Fget_text_property (make_number (glyph
->charpos
),
1711 Qhelp_echo
, glyph
->object
);
1715 help_echo_window
= window
;
1716 help_echo_object
= glyph
->object
;
1717 help_echo_pos
= glyph
->charpos
;
1724 current_buffer
= obuf
;
1730 IT_clear_end_of_line (int first_unused
)
1734 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
1735 extern int fatal_error_in_progress
;
1737 if (new_pos_X
>= first_unused
|| fatal_error_in_progress
)
1741 i
= (j
= first_unused
- new_pos_X
) * 2;
1743 fprintf (termscript
, "<CLR:EOL[%d..%d)>", new_pos_X
, first_unused
);
1744 spaces
= sp
= alloca (i
);
1749 *sp
++ = ScreenAttrib
;
1753 dosmemput (spaces
, i
, (int)ScreenPrimary
+ offset
);
1754 if (screen_virtual_segment
)
1755 dosv_refresh_virtual_screen (offset
, i
/ 2);
1757 /* clear_end_of_line_raw on term.c leaves the cursor at first_unused.
1758 Let's follow their lead, in case someone relies on this. */
1759 new_pos_X
= first_unused
;
1763 IT_clear_screen (void)
1766 fprintf (termscript
, "<CLR:SCR>");
1770 if (screen_virtual_segment
)
1771 dosv_refresh_virtual_screen (0, screen_size
);
1772 new_pos_X
= new_pos_Y
= 0;
1776 IT_clear_to_end (void)
1779 fprintf (termscript
, "<CLR:EOS>");
1781 while (new_pos_Y
< screen_size_Y
) {
1783 IT_clear_end_of_line (screen_size_X
);
1789 IT_cursor_to (int y
, int x
)
1792 fprintf (termscript
, "\n<XY=%dx%d>", x
, y
);
1797 static int cursor_cleared
;
1800 IT_display_cursor (int on
)
1802 if (on
&& cursor_cleared
)
1804 ScreenSetCursor (current_pos_Y
, current_pos_X
);
1807 else if (!on
&& !cursor_cleared
)
1809 ScreenSetCursor (-1, -1);
1814 /* Emacs calls cursor-movement functions a lot when it updates the
1815 display (probably a legacy of old terminals where you cannot
1816 update a screen line without first moving the cursor there).
1817 However, cursor movement is expensive on MSDOS (it calls a slow
1818 BIOS function and requires 2 mode switches), while actual screen
1819 updates access the video memory directly and don't depend on
1820 cursor position. To avoid slowing down the redisplay, we cheat:
1821 all functions that move the cursor only set internal variables
1822 which record the cursor position, whereas the cursor is only
1823 moved to its final position whenever screen update is complete.
1825 `IT_cmgoto' is called from the keyboard reading loop and when the
1826 frame update is complete. This means that we are ready for user
1827 input, so we update the cursor position to show where the point is,
1828 and also make the mouse pointer visible.
1830 Special treatment is required when the cursor is in the echo area,
1831 to put the cursor at the end of the text displayed there. */
1834 IT_cmgoto (FRAME_PTR f
)
1836 /* Only set the cursor to where it should be if the display is
1837 already in sync with the window contents. */
1838 int update_cursor_pos
= 1; /* MODIFF == unchanged_modified; */
1840 /* FIXME: This needs to be rewritten for the new redisplay, or
1843 static int previous_pos_X
= -1;
1845 update_cursor_pos
= 1; /* temporary!!! */
1847 /* If the display is in sync, forget any previous knowledge about
1848 cursor position. This is primarily for unexpected events like
1849 C-g in the minibuffer. */
1850 if (update_cursor_pos
&& previous_pos_X
>= 0)
1851 previous_pos_X
= -1;
1852 /* If we are in the echo area, put the cursor at the
1853 end of the echo area message. */
1854 if (!update_cursor_pos
1855 && XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
) <= new_pos_Y
)
1857 int tem_X
= current_pos_X
, dummy
;
1859 if (echo_area_glyphs
)
1861 tem_X
= echo_area_glyphs_length
;
1862 /* Save current cursor position, to be restored after the
1863 echo area message is erased. Only remember one level
1864 of previous cursor position. */
1865 if (previous_pos_X
== -1)
1866 ScreenGetCursor (&dummy
, &previous_pos_X
);
1868 else if (previous_pos_X
>= 0)
1870 /* We wind up here after the echo area message is erased.
1871 Restore the cursor position we remembered above. */
1872 tem_X
= previous_pos_X
;
1873 previous_pos_X
= -1;
1876 if (current_pos_X
!= tem_X
)
1879 update_cursor_pos
= 1;
1884 if (update_cursor_pos
1885 && (current_pos_X
!= new_pos_X
|| current_pos_Y
!= new_pos_Y
))
1887 ScreenSetCursor (current_pos_Y
= new_pos_Y
, current_pos_X
= new_pos_X
);
1889 fprintf (termscript
, "\n<CURSOR:%dx%d>", current_pos_X
, current_pos_Y
);
1892 /* Maybe cursor is invisible, so make it visible. */
1893 IT_display_cursor (1);
1895 /* Mouse pointer should be always visible if we are waiting for
1902 IT_reassert_line_highlight (int new, int vpos
)
1908 IT_change_line_highlight (int new_highlight
, int y
, int vpos
, int first_unused_hpos
)
1910 highlight
= new_highlight
;
1911 IT_cursor_to (vpos
, 0);
1912 IT_clear_end_of_line (first_unused_hpos
);
1916 IT_update_begin (struct frame
*f
)
1918 struct display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
1919 struct frame
*mouse_face_frame
= display_info
->mouse_face_mouse_frame
;
1925 if (f
&& f
== mouse_face_frame
)
1927 /* Don't do highlighting for mouse motion during the update. */
1928 display_info
->mouse_face_defer
= 1;
1930 /* If F needs to be redrawn, simply forget about any prior mouse
1932 if (FRAME_GARBAGED_P (f
))
1933 display_info
->mouse_face_window
= Qnil
;
1935 /* Can we tell that this update does not affect the window
1936 where the mouse highlight is? If so, no need to turn off.
1937 Likewise, don't do anything if none of the enabled rows
1938 contains glyphs highlighted in mouse face. */
1939 if (!NILP (display_info
->mouse_face_window
)
1940 && WINDOWP (display_info
->mouse_face_window
))
1942 struct window
*w
= XWINDOW (display_info
->mouse_face_window
);
1945 /* If the mouse highlight is in the window that was deleted
1946 (e.g., if it was popped by completion), clear highlight
1948 if (NILP (w
->buffer
))
1949 display_info
->mouse_face_window
= Qnil
;
1952 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
1953 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
)
1954 && MATRIX_ROW (w
->current_matrix
, i
)->mouse_face_p
)
1958 if (NILP (w
->buffer
) || i
< w
->desired_matrix
->nrows
)
1959 clear_mouse_face (display_info
);
1962 else if (mouse_face_frame
&& !FRAME_LIVE_P (mouse_face_frame
))
1964 /* If the frame with mouse highlight was deleted, invalidate the
1966 display_info
->mouse_face_beg_row
= display_info
->mouse_face_beg_col
= -1;
1967 display_info
->mouse_face_end_row
= display_info
->mouse_face_end_col
= -1;
1968 display_info
->mouse_face_window
= Qnil
;
1969 display_info
->mouse_face_deferred_gc
= 0;
1970 display_info
->mouse_face_mouse_frame
= NULL
;
1977 IT_update_end (struct frame
*f
)
1980 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
1983 Lisp_Object Qcursor_type
;
1986 IT_frame_up_to_date (struct frame
*f
)
1988 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1989 Lisp_Object new_cursor
, frame_desired_cursor
;
1992 if (dpyinfo
->mouse_face_deferred_gc
1993 || (f
&& f
== dpyinfo
->mouse_face_mouse_frame
))
1996 if (dpyinfo
->mouse_face_mouse_frame
)
1997 IT_note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
1998 dpyinfo
->mouse_face_mouse_x
,
1999 dpyinfo
->mouse_face_mouse_y
);
2000 dpyinfo
->mouse_face_deferred_gc
= 0;
2004 /* Set the cursor type to whatever they wanted. In a minibuffer
2005 window, we want the cursor to appear only if we are reading input
2006 from this window, and we want the cursor to be taken from the
2007 frame parameters. For the selected window, we use either its
2008 buffer-local value or the value from the frame parameters if the
2009 buffer doesn't define its local value for the cursor type. */
2010 sw
= XWINDOW (f
->selected_window
);
2011 frame_desired_cursor
= Fcdr (Fassq (Qcursor_type
, f
->param_alist
));
2012 if (cursor_in_echo_area
2013 && FRAME_HAS_MINIBUF_P (f
)
2014 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
)
2015 && sw
== XWINDOW (echo_area_window
))
2016 new_cursor
= frame_desired_cursor
;
2019 struct buffer
*b
= XBUFFER (sw
->buffer
);
2021 if (EQ (b
->cursor_type
, Qt
))
2022 new_cursor
= frame_desired_cursor
;
2023 else if (NILP (b
->cursor_type
)) /* nil means no cursor */
2024 new_cursor
= Fcons (Qbar
, make_number (0));
2026 new_cursor
= b
->cursor_type
;
2029 IT_set_cursor_type (f
, new_cursor
);
2031 IT_cmgoto (f
); /* position cursor when update is done */
2034 /* Copy LEN glyphs displayed on a single line whose vertical position
2035 is YPOS, beginning at horizontal position XFROM to horizontal
2036 position XTO, by moving blocks in the video memory. Used by
2037 functions that insert and delete glyphs. */
2039 IT_copy_glyphs (int xfrom
, int xto
, size_t len
, int ypos
)
2041 /* The offsets of source and destination relative to the
2042 conventional memorty selector. */
2043 int from
= 2 * (xfrom
+ screen_size_X
* ypos
) + ScreenPrimary
;
2044 int to
= 2 * (xto
+ screen_size_X
* ypos
) + ScreenPrimary
;
2046 if (from
== to
|| len
<= 0)
2049 _farsetsel (_dos_ds
);
2051 /* The source and destination might overlap, so we need to move
2052 glyphs non-destructively. */
2055 for ( ; len
; from
+= 2, to
+= 2, len
--)
2056 _farnspokew (to
, _farnspeekw (from
));
2060 from
+= (len
- 1) * 2;
2061 to
+= (len
- 1) * 2;
2062 for ( ; len
; from
-= 2, to
-= 2, len
--)
2063 _farnspokew (to
, _farnspeekw (from
));
2065 if (screen_virtual_segment
)
2066 dosv_refresh_virtual_screen (ypos
* screen_size_X
* 2, screen_size_X
);
2069 /* Insert and delete glyphs. */
2071 IT_insert_glyphs (start
, len
)
2072 register struct glyph
*start
;
2075 int shift_by_width
= screen_size_X
- (new_pos_X
+ len
);
2077 /* Shift right the glyphs from the nominal cursor position to the
2078 end of this line. */
2079 IT_copy_glyphs (new_pos_X
, new_pos_X
+ len
, shift_by_width
, new_pos_Y
);
2081 /* Now write the glyphs to be inserted. */
2082 IT_write_glyphs (start
, len
);
2086 IT_delete_glyphs (n
)
2092 /* set-window-configuration on window.c needs this. */
2094 x_set_menu_bar_lines (f
, value
, oldval
)
2096 Lisp_Object value
, oldval
;
2098 set_menu_bar_lines (f
, value
, oldval
);
2101 /* This was copied from xfaces.c */
2103 extern Lisp_Object Qbackground_color
;
2104 extern Lisp_Object Qforeground_color
;
2105 Lisp_Object Qreverse
;
2106 extern Lisp_Object Qtitle
;
2108 /* IT_set_terminal_modes is called when emacs is started,
2109 resumed, and whenever the screen is redrawn! */
2112 IT_set_terminal_modes (void)
2115 fprintf (termscript
, "\n<SET_TERM>");
2118 screen_size_X
= ScreenCols ();
2119 screen_size_Y
= ScreenRows ();
2120 screen_size
= screen_size_X
* screen_size_Y
;
2122 new_pos_X
= new_pos_Y
= 0;
2123 current_pos_X
= current_pos_Y
= -1;
2125 if (term_setup_done
)
2127 term_setup_done
= 1;
2129 startup_screen_size_X
= screen_size_X
;
2130 startup_screen_size_Y
= screen_size_Y
;
2131 startup_screen_attrib
= ScreenAttrib
;
2134 /* Is DOS/V (or any other RSIS software which relocates
2135 the screen) installed? */
2137 unsigned short es_value
;
2140 regs
.h
.ah
= 0xfe; /* get relocated screen address */
2141 if (ScreenPrimary
== 0xb0000UL
|| ScreenPrimary
== 0xb8000UL
)
2142 regs
.x
.es
= (ScreenPrimary
>> 4) & 0xffff;
2143 else if (screen_old_address
) /* already switched to Japanese mode once */
2144 regs
.x
.es
= (screen_old_address
>> 4) & 0xffff;
2146 regs
.x
.es
= ScreenMode () == 7 ? 0xb000 : 0xb800;
2148 es_value
= regs
.x
.es
;
2149 __dpmi_int (0x10, ®s
);
2151 if (regs
.x
.es
!= es_value
)
2153 /* screen_old_address is only set if ScreenPrimary does NOT
2154 already point to the relocated buffer address returned by
2155 the Int 10h/AX=FEh call above. DJGPP v2.02 and later sets
2156 ScreenPrimary to that address at startup under DOS/V. */
2157 if (regs
.x
.es
!= (ScreenPrimary
>> 4) & 0xffff)
2158 screen_old_address
= ScreenPrimary
;
2159 screen_virtual_segment
= regs
.x
.es
;
2160 screen_virtual_offset
= regs
.x
.di
;
2161 ScreenPrimary
= (screen_virtual_segment
<< 4) + screen_virtual_offset
;
2164 #endif /* __DJGPP__ > 1 */
2166 ScreenGetCursor (&startup_pos_Y
, &startup_pos_X
);
2167 ScreenRetrieve (startup_screen_buffer
= xmalloc (screen_size
* 2));
2170 fprintf (termscript
, "<SCREEN SAVED (dimensions=%dx%d)>\n",
2171 screen_size_X
, screen_size_Y
);
2176 /* IT_reset_terminal_modes is called when emacs is
2177 suspended or killed. */
2180 IT_reset_terminal_modes (void)
2182 int display_row_start
= (int) ScreenPrimary
;
2183 int saved_row_len
= startup_screen_size_X
* 2;
2184 int update_row_len
= ScreenCols () * 2;
2185 int current_rows
= ScreenRows ();
2186 int to_next_row
= update_row_len
;
2187 unsigned char *saved_row
= startup_screen_buffer
;
2188 int cursor_pos_X
= ScreenCols () - 1;
2189 int cursor_pos_Y
= ScreenRows () - 1;
2192 fprintf (termscript
, "\n<RESET_TERM>");
2196 if (!term_setup_done
)
2201 /* Leave the video system in the same state as we found it,
2202 as far as the blink/bright-background bit is concerned. */
2203 maybe_enable_blinking ();
2205 /* We have a situation here.
2206 We cannot just do ScreenUpdate(startup_screen_buffer) because
2207 the luser could have changed screen dimensions inside Emacs
2208 and failed (or didn't want) to restore them before killing
2209 Emacs. ScreenUpdate() uses the *current* screen dimensions and
2210 thus will happily use memory outside what was allocated for
2211 `startup_screen_buffer'.
2212 Thus we only restore as much as the current screen dimensions
2213 can hold, and clear the rest (if the saved screen is smaller than
2214 the current) with the color attribute saved at startup. The cursor
2215 is also restored within the visible dimensions. */
2217 ScreenAttrib
= startup_screen_attrib
;
2219 /* Don't restore the screen if we are exiting less than 2 seconds
2220 after startup: we might be crashing, and the screen might show
2221 some vital clues to what's wrong. */
2222 if (clock () - startup_time
>= 2*CLOCKS_PER_SEC
)
2225 if (screen_virtual_segment
)
2226 dosv_refresh_virtual_screen (0, screen_size
);
2228 if (update_row_len
> saved_row_len
)
2229 update_row_len
= saved_row_len
;
2230 if (current_rows
> startup_screen_size_Y
)
2231 current_rows
= startup_screen_size_Y
;
2234 fprintf (termscript
, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
2235 update_row_len
/ 2, current_rows
);
2237 while (current_rows
--)
2239 dosmemput (saved_row
, update_row_len
, display_row_start
);
2240 if (screen_virtual_segment
)
2241 dosv_refresh_virtual_screen (display_row_start
- ScreenPrimary
,
2242 update_row_len
/ 2);
2243 saved_row
+= saved_row_len
;
2244 display_row_start
+= to_next_row
;
2247 if (startup_pos_X
< cursor_pos_X
)
2248 cursor_pos_X
= startup_pos_X
;
2249 if (startup_pos_Y
< cursor_pos_Y
)
2250 cursor_pos_Y
= startup_pos_Y
;
2252 ScreenSetCursor (cursor_pos_Y
, cursor_pos_X
);
2253 xfree (startup_screen_buffer
);
2255 term_setup_done
= 0;
2259 IT_set_terminal_window (int foo
)
2263 /* Remember the screen colors of the curent frame, to serve as the
2264 default colors for newly-created frames. */
2266 static int initial_screen_colors
[2];
2268 DEFUN ("msdos-remember-default-colors", Fmsdos_remember_default_colors
,
2269 Smsdos_remember_default_colors
, 1, 1, 0,
2270 "Remember the screen colors of the current frame.")
2277 CHECK_FRAME (frame
, 0);
2279 reverse
= EQ (Fcdr (Fassq (intern ("reverse"), f
->param_alist
)), Qt
);
2281 initial_screen_colors
[0]
2282 = reverse
? FRAME_BACKGROUND_PIXEL (f
) : FRAME_FOREGROUND_PIXEL (f
);
2283 initial_screen_colors
[1]
2284 = reverse
? FRAME_FOREGROUND_PIXEL (f
) : FRAME_BACKGROUND_PIXEL (f
);
2288 IT_set_frame_parameters (f
, alist
)
2293 int length
= XINT (Flength (alist
));
2296 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2298 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2299 /* Do we have to reverse the foreground and background colors? */
2300 int reverse
= EQ (Fcdr (Fassq (Qreverse
, f
->param_alist
)), Qt
);
2301 int was_reverse
= reverse
;
2302 int redraw
= 0, fg_set
= 0, bg_set
= 0;
2303 unsigned long orig_fg
;
2304 unsigned long orig_bg
;
2306 /* If we are creating a new frame, begin with the original screen colors
2307 used for the initial frame. */
2308 if (alist
== Vdefault_frame_alist
2309 && initial_screen_colors
[0] != -1 && initial_screen_colors
[1] != -1)
2311 FRAME_FOREGROUND_PIXEL (f
) = initial_screen_colors
[0];
2312 FRAME_BACKGROUND_PIXEL (f
) = initial_screen_colors
[1];
2314 orig_fg
= FRAME_FOREGROUND_PIXEL (f
);
2315 orig_bg
= FRAME_BACKGROUND_PIXEL (f
);
2317 /* Extract parm names and values into those vectors. */
2319 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2324 parms
[i
] = Fcar (elt
);
2325 CHECK_SYMBOL (parms
[i
], 1);
2326 values
[i
] = Fcdr (elt
);
2332 for (i
= 0; i
< j
; i
++)
2334 Lisp_Object prop
, val
;
2339 if (EQ (prop
, Qreverse
))
2340 reverse
= EQ (val
, Qt
);
2343 if (termscript
&& reverse
&& !was_reverse
)
2344 fprintf (termscript
, "<INVERSE-VIDEO>\n");
2346 /* Now process the alist elements in reverse of specified order. */
2347 for (i
--; i
>= 0; i
--)
2349 extern Lisp_Object Qdefault
, QCforeground
, QCbackground
;
2350 Lisp_Object prop
, val
;
2356 if (EQ (prop
, Qforeground_color
))
2358 unsigned long new_color
= load_color (f
, NULL
, val
, reverse
2359 ? LFACE_BACKGROUND_INDEX
2360 : LFACE_FOREGROUND_INDEX
);
2361 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2362 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2363 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2365 /* Make sure the foreground of the default face for this
2366 frame is changed as well. */
2367 XSETFRAME (frame
, f
);
2370 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2371 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2376 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2377 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2383 fprintf (termscript
, "<FGCOLOR %lu>\n", new_color
);
2386 else if (EQ (prop
, Qbackground_color
))
2388 unsigned long new_color
= load_color (f
, NULL
, val
, reverse
2389 ? LFACE_FOREGROUND_INDEX
2390 : LFACE_BACKGROUND_INDEX
);
2391 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2392 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2393 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2395 /* Make sure the background of the default face for this
2396 frame is changed as well. */
2397 XSETFRAME (frame
, f
);
2400 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2401 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2406 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2407 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2413 fprintf (termscript
, "<BGCOLOR %lu>\n", new_color
);
2416 else if (EQ (prop
, Qtitle
))
2418 x_set_title (f
, val
);
2420 fprintf (termscript
, "<TITLE: %s>\n", XSTRING (val
)->data
);
2422 else if (EQ (prop
, Qcursor_type
))
2424 IT_set_cursor_type (f
, val
);
2426 fprintf (termscript
, "<CTYPE: %s>\n",
2427 EQ (val
, Qbar
) || CONSP (val
) && EQ (XCAR (val
), Qbar
)
2430 store_frame_param (f
, prop
, val
);
2433 /* If they specified "reverse", but not the colors, we need to swap
2434 the current frame colors. */
2435 if (reverse
&& !was_reverse
)
2441 FRAME_BACKGROUND_PIXEL (f
) = orig_fg
;
2442 XSETFRAME (frame
, f
);
2443 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2444 tty_color_name (orig_fg
), frame
);
2449 FRAME_FOREGROUND_PIXEL (f
) = orig_bg
;
2450 XSETFRAME (frame
, f
);
2451 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2452 tty_color_name (orig_bg
), frame
);
2459 face_change_count
++; /* forces xdisp.c to recompute basic faces */
2460 if (f
== SELECTED_FRAME())
2465 extern void init_frame_faces (FRAME_PTR
);
2467 #endif /* !HAVE_X_WINDOWS */
2470 /* Do we need the internal terminal? */
2473 internal_terminal_init ()
2475 char *term
= getenv ("TERM");
2477 struct frame
*sf
= SELECTED_FRAME();
2479 #ifdef HAVE_X_WINDOWS
2480 if (!inhibit_window_system
)
2485 = (!noninteractive
) && term
&& !strcmp (term
, "internal");
2487 if (getenv ("EMACSTEST"))
2488 termscript
= fopen (getenv ("EMACSTEST"), "wt");
2490 #ifndef HAVE_X_WINDOWS
2491 if (!internal_terminal
|| inhibit_window_system
)
2493 sf
->output_method
= output_termcap
;
2497 Vwindow_system
= intern ("pc");
2498 Vwindow_system_version
= make_number (1);
2499 sf
->output_method
= output_msdos_raw
;
2501 /* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
2502 screen_old_address
= 0;
2504 /* Forget the stale screen colors as well. */
2505 initial_screen_colors
[0] = initial_screen_colors
[1] = -1;
2507 bzero (&the_only_x_display
, sizeof the_only_x_display
);
2508 the_only_x_display
.background_pixel
= 7; /* White */
2509 the_only_x_display
.foreground_pixel
= 0; /* Black */
2511 colors
= getenv ("EMACSCOLORS");
2512 if (colors
&& strlen (colors
) >= 2)
2514 /* The colors use 4 bits each (we enable bright background). */
2515 if (isdigit (colors
[0]))
2517 else if (isxdigit (colors
[0]))
2518 colors
[0] -= (isupper (colors
[0]) ? 'A' : 'a') - 10;
2519 if (colors
[0] >= 0 && colors
[0] < 16)
2520 the_only_x_display
.foreground_pixel
= colors
[0];
2521 if (isdigit (colors
[1]))
2523 else if (isxdigit (colors
[1]))
2524 colors
[1] -= (isupper (colors
[1]) ? 'A' : 'a') - 10;
2525 if (colors
[1] >= 0 && colors
[1] < 16)
2526 the_only_x_display
.background_pixel
= colors
[1];
2528 the_only_x_display
.line_height
= 1;
2529 the_only_x_display
.font
= (XFontStruct
*)1; /* must *not* be zero */
2530 the_only_x_display
.display_info
.mouse_face_mouse_frame
= NULL
;
2531 the_only_x_display
.display_info
.mouse_face_deferred_gc
= 0;
2532 the_only_x_display
.display_info
.mouse_face_beg_row
=
2533 the_only_x_display
.display_info
.mouse_face_beg_col
= -1;
2534 the_only_x_display
.display_info
.mouse_face_end_row
=
2535 the_only_x_display
.display_info
.mouse_face_end_col
= -1;
2536 the_only_x_display
.display_info
.mouse_face_face_id
= DEFAULT_FACE_ID
;
2537 the_only_x_display
.display_info
.mouse_face_window
= Qnil
;
2538 the_only_x_display
.display_info
.mouse_face_mouse_x
=
2539 the_only_x_display
.display_info
.mouse_face_mouse_y
= 0;
2540 the_only_x_display
.display_info
.mouse_face_defer
= 0;
2542 init_frame_faces (sf
);
2544 ring_bell_hook
= IT_ring_bell
;
2545 insert_glyphs_hook
= IT_insert_glyphs
;
2546 delete_glyphs_hook
= IT_delete_glyphs
;
2547 write_glyphs_hook
= IT_write_glyphs
;
2548 cursor_to_hook
= raw_cursor_to_hook
= IT_cursor_to
;
2549 clear_to_end_hook
= IT_clear_to_end
;
2550 clear_end_of_line_hook
= IT_clear_end_of_line
;
2551 clear_frame_hook
= IT_clear_screen
;
2552 change_line_highlight_hook
= IT_change_line_highlight
;
2553 update_begin_hook
= IT_update_begin
;
2554 update_end_hook
= IT_update_end
;
2555 reassert_line_highlight_hook
= IT_reassert_line_highlight
;
2556 frame_up_to_date_hook
= IT_frame_up_to_date
;
2558 /* These hooks are called by term.c without being checked. */
2559 set_terminal_modes_hook
= IT_set_terminal_modes
;
2560 reset_terminal_modes_hook
= IT_reset_terminal_modes
;
2561 set_terminal_window_hook
= IT_set_terminal_window
;
2562 char_ins_del_ok
= 0;
2566 dos_get_saved_screen (screen
, rows
, cols
)
2571 #ifndef HAVE_X_WINDOWS
2572 *screen
= startup_screen_buffer
;
2573 *cols
= startup_screen_size_X
;
2574 *rows
= startup_screen_size_Y
;
2575 return *screen
!= (char *)0;
2581 #ifndef HAVE_X_WINDOWS
2583 /* We are not X, but we can emulate it well enough for our needs... */
2587 if (! FRAME_MSDOS_P (SELECTED_FRAME()))
2588 error ("Not running under a window system");
2594 /* ----------------------- Keyboard control ----------------------
2596 * Keymaps reflect the following keyboard layout:
2598 * 0 1 2 3 4 5 6 7 8 9 10 11 12 BS
2599 * TAB 15 16 17 18 19 20 21 22 23 24 25 26 (41)
2600 * CLOK 30 31 32 33 34 35 36 37 38 39 40 (41) RET
2601 * SH () 45 46 47 48 49 50 51 52 53 54 SHIFT
2605 #define Ignore 0x0000
2606 #define Normal 0x0000 /* normal key - alt changes scan-code */
2607 #define FctKey 0x1000 /* func key if c == 0, else c */
2608 #define Special 0x2000 /* func key even if c != 0 */
2609 #define ModFct 0x3000 /* special if mod-keys, else 'c' */
2610 #define Map 0x4000 /* alt scan-code, map to unshift/shift key */
2611 #define KeyPad 0x5000 /* map to insert/kp-0 depending on c == 0xe0 */
2612 #define Grey 0x6000 /* Grey keypad key */
2614 #define Alt 0x0100 /* alt scan-code */
2615 #define Ctrl 0x0200 /* ctrl scan-code */
2616 #define Shift 0x0400 /* shift scan-code */
2618 static int extended_kbd
; /* 101 (102) keyboard present. */
2620 struct kbd_translate
{
2623 unsigned short code
;
2626 struct dos_keyboard_map
2631 struct kbd_translate
*translate_table
;
2635 static struct dos_keyboard_map us_keyboard
= {
2637 /* 01234567890123456789012345678901234567890 12345678901234 */
2638 "`1234567890-= qwertyuiop[] asdfghjkl;'\\ zxcvbnm,./ ",
2639 /* 0123456789012345678901234567890123456789 012345678901234 */
2640 "~!@#$%^&*()_+ QWERTYUIOP{} ASDFGHJKL:\"| ZXCVBNM<>? ",
2641 0, /* no Alt-Gr key */
2642 0 /* no translate table */
2645 static struct dos_keyboard_map fr_keyboard
= {
2647 /* 012 3456789012345678901234567890123456789012345678901234 */
2648 "ý&\82\",(-\8a_\80\85)= azertyuiop^$ qsdfghjklm\97* wxcvbnm;:! ",
2649 /* 0123456789012345678901234567890123456789012345678901234 */
2650 " 1234567890ø+ AZERTYUIOPù\9c QSDFGHJKLM%æ WXCVBN?./õ ",
2651 /* 01234567 89012345678901234567890123456789012345678901234 */
2653 0 /* no translate table */
2657 * Italian keyboard support, country code 39.
2660 * added also {,},` as, respectively, AltGr-8, AltGr-9, AltGr-'
2661 * Donated by Stefano Brozzi <brozzis@mag00.cedi.unipr.it>
2664 static struct kbd_translate it_kbd_translate_table
[] = {
2665 { 0x56, 0x3c, Normal
| 13 },
2666 { 0x56, 0x3e, Normal
| 27 },
2669 static struct dos_keyboard_map it_keyboard
= {
2671 /* 0 123456789012345678901234567890123456789012345678901234 */
2672 "\\1234567890'\8d< qwertyuiop\8a+> asdfghjkl\95\85\97 zxcvbnm,.- ",
2673 /* 01 23456789012345678901234567890123456789012345678901234 */
2674 "|!\"\9c$%&/()=?^> QWERTYUIOP\82* ASDFGHJKL\87øõ ZXCVBNM;:_ ",
2675 /* 0123456789012345678901234567890123456789012345678901234 */
2677 it_kbd_translate_table
2680 static struct dos_keyboard_map dk_keyboard
= {
2682 /* 0123456789012345678901234567890123456789012345678901234 */
2683 "«1234567890+| qwertyuiop\86~ asdfghjkl\91\9b' zxcvbnm,.- ",
2684 /* 01 23456789012345678901234567890123456789012345678901234 */
2685 "õ!\"#$%&/()=?` QWERTYUIOP\8f^ ASDFGHJKL\92\9d* ZXCVBNM;:_ ",
2686 /* 0123456789012345678901234567890123456789012345678901234 */
2688 0 /* no translate table */
2691 static struct kbd_translate jp_kbd_translate_table
[] = {
2692 { 0x73, 0x5c, Normal
| 0 },
2693 { 0x73, 0x5f, Normal
| 0 },
2694 { 0x73, 0x1c, Map
| 0 },
2695 { 0x7d, 0x5c, Normal
| 13 },
2696 { 0x7d, 0x7c, Normal
| 13 },
2697 { 0x7d, 0x1c, Map
| 13 },
2700 static struct dos_keyboard_map jp_keyboard
= {
2702 /* 0123456789012 345678901234567890123456789012345678901234 */
2703 "\\1234567890-^\\ qwertyuiop@[ asdfghjkl;:] zxcvbnm,./ ",
2704 /* 01 23456789012345678901234567890123456789012345678901234 */
2705 "_!\"#$%&'()~=~| QWERTYUIOP`{ ASDFGHJKL+*} ZXCVBNM<>? ",
2706 0, /* no Alt-Gr key */
2707 jp_kbd_translate_table
2710 static struct keyboard_layout_list
2713 struct dos_keyboard_map
*keyboard_map
;
2714 } keyboard_layout_list
[] =
2723 static struct dos_keyboard_map
*keyboard
;
2724 static int keyboard_map_all
;
2725 static int international_keyboard
;
2728 dos_set_keyboard (code
, always
)
2733 _go32_dpmi_registers regs
;
2735 /* See if Keyb.Com is installed (for international keyboard support).
2736 Note: calling Int 2Fh via int86 wedges the DOS box on some versions
2737 of Windows 9X! So don't do that! */
2739 regs
.x
.ss
= regs
.x
.sp
= regs
.x
.flags
= 0;
2740 _go32_dpmi_simulate_int (0x2f, ®s
);
2741 if (regs
.h
.al
== 0xff)
2742 international_keyboard
= 1;
2744 /* Initialize to US settings, for countries that don't have their own. */
2745 keyboard
= keyboard_layout_list
[0].keyboard_map
;
2746 keyboard_map_all
= always
;
2747 dos_keyboard_layout
= 1;
2749 for (i
= 0; i
< (sizeof (keyboard_layout_list
)/sizeof (struct keyboard_layout_list
)); i
++)
2750 if (code
== keyboard_layout_list
[i
].country_code
)
2752 keyboard
= keyboard_layout_list
[i
].keyboard_map
;
2753 keyboard_map_all
= always
;
2754 dos_keyboard_layout
= code
;
2762 unsigned char char_code
; /* normal code */
2763 unsigned char meta_code
; /* M- code */
2764 unsigned char keypad_code
; /* keypad code */
2765 unsigned char editkey_code
; /* edit key */
2766 } keypad_translate_map
[] = {
2767 '0', '0', 0xb0, /* kp-0 */ 0x63, /* insert */
2768 '1', '1', 0xb1, /* kp-1 */ 0x57, /* end */
2769 '2', '2', 0xb2, /* kp-2 */ 0x54, /* down */
2770 '3', '3', 0xb3, /* kp-3 */ 0x56, /* next */
2771 '4', '4', 0xb4, /* kp-4 */ 0x51, /* left */
2772 '5', '5', 0xb5, /* kp-5 */ 0xb5, /* kp-5 */
2773 '6', '6', 0xb6, /* kp-6 */ 0x53, /* right */
2774 '7', '7', 0xb7, /* kp-7 */ 0x50, /* home */
2775 '8', '8', 0xb8, /* kp-8 */ 0x52, /* up */
2776 '9', '9', 0xb9, /* kp-9 */ 0x55, /* prior */
2777 '.', '-', 0xae, /* kp-decimal */ 0xff /* delete */
2782 unsigned char char_code
; /* normal code */
2783 unsigned char keypad_code
; /* keypad code */
2784 } grey_key_translate_map
[] = {
2785 '/', 0xaf, /* kp-decimal */
2786 '*', 0xaa, /* kp-multiply */
2787 '-', 0xad, /* kp-subtract */
2788 '+', 0xab, /* kp-add */
2789 '\r', 0x8d /* kp-enter */
2792 static unsigned short
2793 ibmpc_translate_map
[] =
2795 /* --------------- 00 to 0f --------------- */
2796 Normal
| 0xff, /* Ctrl Break + Alt-NNN */
2797 Alt
| ModFct
| 0x1b, /* Escape */
2798 Normal
| 1, /* '1' */
2799 Normal
| 2, /* '2' */
2800 Normal
| 3, /* '3' */
2801 Normal
| 4, /* '4' */
2802 Normal
| 5, /* '5' */
2803 Normal
| 6, /* '6' */
2804 Normal
| 7, /* '7' */
2805 Normal
| 8, /* '8' */
2806 Normal
| 9, /* '9' */
2807 Normal
| 10, /* '0' */
2808 Normal
| 11, /* '-' */
2809 Normal
| 12, /* '=' */
2810 Special
| 0x08, /* Backspace */
2811 ModFct
| 0x74, /* Tab/Backtab */
2813 /* --------------- 10 to 1f --------------- */
2826 ModFct
| 0x0d, /* Return */
2831 /* --------------- 20 to 2f --------------- */
2840 Map
| 40, /* '\'' */
2842 Ignore
, /* Left shift */
2843 Map
| 41, /* '\\' */
2849 /* --------------- 30 to 3f --------------- */
2856 Ignore
, /* Right shift */
2857 Grey
| 1, /* Grey * */
2859 Normal
| 55, /* ' ' */
2860 Ignore
, /* Caps Lock */
2861 FctKey
| 0xbe, /* F1 */
2862 FctKey
| 0xbf, /* F2 */
2863 FctKey
| 0xc0, /* F3 */
2864 FctKey
| 0xc1, /* F4 */
2865 FctKey
| 0xc2, /* F5 */
2867 /* --------------- 40 to 4f --------------- */
2868 FctKey
| 0xc3, /* F6 */
2869 FctKey
| 0xc4, /* F7 */
2870 FctKey
| 0xc5, /* F8 */
2871 FctKey
| 0xc6, /* F9 */
2872 FctKey
| 0xc7, /* F10 */
2873 Ignore
, /* Num Lock */
2874 Ignore
, /* Scroll Lock */
2875 KeyPad
| 7, /* Home */
2876 KeyPad
| 8, /* Up */
2877 KeyPad
| 9, /* Page Up */
2878 Grey
| 2, /* Grey - */
2879 KeyPad
| 4, /* Left */
2880 KeyPad
| 5, /* Keypad 5 */
2881 KeyPad
| 6, /* Right */
2882 Grey
| 3, /* Grey + */
2883 KeyPad
| 1, /* End */
2885 /* --------------- 50 to 5f --------------- */
2886 KeyPad
| 2, /* Down */
2887 KeyPad
| 3, /* Page Down */
2888 KeyPad
| 0, /* Insert */
2889 KeyPad
| 10, /* Delete */
2890 Shift
| FctKey
| 0xbe, /* (Shift) F1 */
2891 Shift
| FctKey
| 0xbf, /* (Shift) F2 */
2892 Shift
| FctKey
| 0xc0, /* (Shift) F3 */
2893 Shift
| FctKey
| 0xc1, /* (Shift) F4 */
2894 Shift
| FctKey
| 0xc2, /* (Shift) F5 */
2895 Shift
| FctKey
| 0xc3, /* (Shift) F6 */
2896 Shift
| FctKey
| 0xc4, /* (Shift) F7 */
2897 Shift
| FctKey
| 0xc5, /* (Shift) F8 */
2898 Shift
| FctKey
| 0xc6, /* (Shift) F9 */
2899 Shift
| FctKey
| 0xc7, /* (Shift) F10 */
2900 Ctrl
| FctKey
| 0xbe, /* (Ctrl) F1 */
2901 Ctrl
| FctKey
| 0xbf, /* (Ctrl) F2 */
2903 /* --------------- 60 to 6f --------------- */
2904 Ctrl
| FctKey
| 0xc0, /* (Ctrl) F3 */
2905 Ctrl
| FctKey
| 0xc1, /* (Ctrl) F4 */
2906 Ctrl
| FctKey
| 0xc2, /* (Ctrl) F5 */
2907 Ctrl
| FctKey
| 0xc3, /* (Ctrl) F6 */
2908 Ctrl
| FctKey
| 0xc4, /* (Ctrl) F7 */
2909 Ctrl
| FctKey
| 0xc5, /* (Ctrl) F8 */
2910 Ctrl
| FctKey
| 0xc6, /* (Ctrl) F9 */
2911 Ctrl
| FctKey
| 0xc7, /* (Ctrl) F10 */
2912 Alt
| FctKey
| 0xbe, /* (Alt) F1 */
2913 Alt
| FctKey
| 0xbf, /* (Alt) F2 */
2914 Alt
| FctKey
| 0xc0, /* (Alt) F3 */
2915 Alt
| FctKey
| 0xc1, /* (Alt) F4 */
2916 Alt
| FctKey
| 0xc2, /* (Alt) F5 */
2917 Alt
| FctKey
| 0xc3, /* (Alt) F6 */
2918 Alt
| FctKey
| 0xc4, /* (Alt) F7 */
2919 Alt
| FctKey
| 0xc5, /* (Alt) F8 */
2921 /* --------------- 70 to 7f --------------- */
2922 Alt
| FctKey
| 0xc6, /* (Alt) F9 */
2923 Alt
| FctKey
| 0xc7, /* (Alt) F10 */
2924 Ctrl
| FctKey
| 0x6d, /* (Ctrl) Sys Rq */
2925 Ctrl
| KeyPad
| 4, /* (Ctrl) Left */
2926 Ctrl
| KeyPad
| 6, /* (Ctrl) Right */
2927 Ctrl
| KeyPad
| 1, /* (Ctrl) End */
2928 Ctrl
| KeyPad
| 3, /* (Ctrl) Page Down */
2929 Ctrl
| KeyPad
| 7, /* (Ctrl) Home */
2930 Alt
| Map
| 1, /* '1' */
2931 Alt
| Map
| 2, /* '2' */
2932 Alt
| Map
| 3, /* '3' */
2933 Alt
| Map
| 4, /* '4' */
2934 Alt
| Map
| 5, /* '5' */
2935 Alt
| Map
| 6, /* '6' */
2936 Alt
| Map
| 7, /* '7' */
2937 Alt
| Map
| 8, /* '8' */
2939 /* --------------- 80 to 8f --------------- */
2940 Alt
| Map
| 9, /* '9' */
2941 Alt
| Map
| 10, /* '0' */
2942 Alt
| Map
| 11, /* '-' */
2943 Alt
| Map
| 12, /* '=' */
2944 Ctrl
| KeyPad
| 9, /* (Ctrl) Page Up */
2945 FctKey
| 0xc8, /* F11 */
2946 FctKey
| 0xc9, /* F12 */
2947 Shift
| FctKey
| 0xc8, /* (Shift) F11 */
2948 Shift
| FctKey
| 0xc9, /* (Shift) F12 */
2949 Ctrl
| FctKey
| 0xc8, /* (Ctrl) F11 */
2950 Ctrl
| FctKey
| 0xc9, /* (Ctrl) F12 */
2951 Alt
| FctKey
| 0xc8, /* (Alt) F11 */
2952 Alt
| FctKey
| 0xc9, /* (Alt) F12 */
2953 Ctrl
| KeyPad
| 8, /* (Ctrl) Up */
2954 Ctrl
| Grey
| 2, /* (Ctrl) Grey - */
2955 Ctrl
| KeyPad
| 5, /* (Ctrl) Keypad 5 */
2957 /* --------------- 90 to 9f --------------- */
2958 Ctrl
| Grey
| 3, /* (Ctrl) Grey + */
2959 Ctrl
| KeyPad
| 2, /* (Ctrl) Down */
2960 Ctrl
| KeyPad
| 0, /* (Ctrl) Insert */
2961 Ctrl
| KeyPad
| 10, /* (Ctrl) Delete */
2962 Ctrl
| FctKey
| 0x09, /* (Ctrl) Tab */
2963 Ctrl
| Grey
| 0, /* (Ctrl) Grey / */
2964 Ctrl
| Grey
| 1, /* (Ctrl) Grey * */
2965 Alt
| FctKey
| 0x50, /* (Alt) Home */
2966 Alt
| FctKey
| 0x52, /* (Alt) Up */
2967 Alt
| FctKey
| 0x55, /* (Alt) Page Up */
2968 Ignore
, /* NO KEY */
2969 Alt
| FctKey
| 0x51, /* (Alt) Left */
2970 Ignore
, /* NO KEY */
2971 Alt
| FctKey
| 0x53, /* (Alt) Right */
2972 Ignore
, /* NO KEY */
2973 Alt
| FctKey
| 0x57, /* (Alt) End */
2975 /* --------------- a0 to af --------------- */
2976 Alt
| KeyPad
| 2, /* (Alt) Down */
2977 Alt
| KeyPad
| 3, /* (Alt) Page Down */
2978 Alt
| KeyPad
| 0, /* (Alt) Insert */
2979 Alt
| KeyPad
| 10, /* (Alt) Delete */
2980 Alt
| Grey
| 0, /* (Alt) Grey / */
2981 Alt
| FctKey
| 0x09, /* (Alt) Tab */
2982 Alt
| Grey
| 4 /* (Alt) Keypad Enter */
2985 /* These bit-positions corresponds to values returned by BIOS */
2986 #define SHIFT_P 0x0003 /* two bits! */
2987 #define CTRL_P 0x0004
2988 #define ALT_P 0x0008
2989 #define SCRLOCK_P 0x0010
2990 #define NUMLOCK_P 0x0020
2991 #define CAPSLOCK_P 0x0040
2992 #define ALT_GR_P 0x0800
2993 #define SUPER_P 0x4000 /* pseudo */
2994 #define HYPER_P 0x8000 /* pseudo */
2997 dos_get_modifiers (keymask
)
3004 /* Calculate modifier bits */
3005 regs
.h
.ah
= extended_kbd
? 0x12 : 0x02;
3006 int86 (0x16, ®s
, ®s
);
3010 mask
= regs
.h
.al
& (SHIFT_P
| CTRL_P
| ALT_P
|
3011 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
3015 mask
= regs
.h
.al
& (SHIFT_P
|
3016 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
3018 /* Do not break international keyboard support. */
3019 /* When Keyb.Com is loaded, the right Alt key is */
3020 /* used for accessing characters like { and } */
3021 if (regs
.h
.ah
& 2) /* Left ALT pressed ? */
3024 if ((regs
.h
.ah
& 8) != 0) /* Right ALT pressed ? */
3027 if (dos_hyper_key
== 1)
3030 modifiers
|= hyper_modifier
;
3032 else if (dos_super_key
== 1)
3035 modifiers
|= super_modifier
;
3037 else if (!international_keyboard
)
3039 /* If Keyb.Com is NOT installed, let Right Alt behave
3040 like the Left Alt. */
3046 if (regs
.h
.ah
& 1) /* Left CTRL pressed ? */
3049 if (regs
.h
.ah
& 4) /* Right CTRL pressed ? */
3051 if (dos_hyper_key
== 2)
3054 modifiers
|= hyper_modifier
;
3056 else if (dos_super_key
== 2)
3059 modifiers
|= super_modifier
;
3067 modifiers
|= shift_modifier
;
3069 modifiers
|= ctrl_modifier
;
3071 modifiers
|= meta_modifier
;
3078 #define NUM_RECENT_DOSKEYS (100)
3079 int recent_doskeys_index
; /* Index for storing next element into recent_doskeys */
3080 int total_doskeys
; /* Total number of elements stored into recent_doskeys */
3081 Lisp_Object recent_doskeys
; /* A vector, holding the last 100 keystrokes */
3083 DEFUN ("recent-doskeys", Frecent_doskeys
, Srecent_doskeys
, 0, 0, 0,
3084 "Return vector of last 100 keyboard input values seen in dos_rawgetc.\n\
3085 Each input key receives two values in this vector: first the ASCII code,\n\
3086 and then the scan code.")
3089 Lisp_Object
*keys
= XVECTOR (recent_doskeys
)->contents
;
3092 if (total_doskeys
< NUM_RECENT_DOSKEYS
)
3093 return Fvector (total_doskeys
, keys
);
3096 val
= Fvector (NUM_RECENT_DOSKEYS
, keys
);
3097 bcopy (keys
+ recent_doskeys_index
,
3098 XVECTOR (val
)->contents
,
3099 (NUM_RECENT_DOSKEYS
- recent_doskeys_index
) * sizeof (Lisp_Object
));
3101 XVECTOR (val
)->contents
+ NUM_RECENT_DOSKEYS
- recent_doskeys_index
,
3102 recent_doskeys_index
* sizeof (Lisp_Object
));
3107 /* Get a char from keyboard. Function keys are put into the event queue. */
3111 struct input_event event
;
3114 #ifndef HAVE_X_WINDOWS
3115 /* Maybe put the cursor where it should be. */
3116 IT_cmgoto (SELECTED_FRAME());
3119 /* The following condition is equivalent to `kbhit ()', except that
3120 it uses the bios to do its job. This pleases DESQview/X. */
3121 while ((regs
.h
.ah
= extended_kbd
? 0x11 : 0x01),
3122 int86 (0x16, ®s
, ®s
),
3123 (regs
.x
.flags
& 0x40) == 0)
3126 register unsigned char c
;
3127 int sc
, code
= -1, mask
, kp_mode
;
3130 regs
.h
.ah
= extended_kbd
? 0x10 : 0x00;
3131 int86 (0x16, ®s
, ®s
);
3136 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3138 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3139 recent_doskeys_index
= 0;
3140 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3142 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3143 recent_doskeys_index
= 0;
3145 modifiers
= dos_get_modifiers (&mask
);
3147 #ifndef HAVE_X_WINDOWS
3148 if (!NILP (Vdos_display_scancodes
))
3151 sprintf (buf
, "%02x:%02x*%04x",
3152 (unsigned) (sc
&0xff), (unsigned) c
, mask
);
3153 dos_direct_output (screen_size_Y
- 2, screen_size_X
- 12, buf
, 10);
3161 case 10: /* Ctrl Grey Enter */
3162 code
= Ctrl
| Grey
| 4;
3164 case 13: /* Grey Enter */
3167 case '/': /* Grey / */
3177 /* Try the keyboard-private translation table first. */
3178 if (keyboard
->translate_table
)
3180 struct kbd_translate
*p
= keyboard
->translate_table
;
3184 if (p
->sc
== sc
&& p
->ch
== c
)
3192 /* If the private table didn't translate it, use the general
3196 if (sc
>= (sizeof (ibmpc_translate_map
) / sizeof (short)))
3198 if ((code
= ibmpc_translate_map
[sc
]) == Ignore
)
3205 /* We only look at the keyboard Ctrl/Shift/Alt keys when
3206 Emacs is ready to read a key. Therefore, if they press
3207 `Alt-x' when Emacs is busy, by the time we get to
3208 `dos_get_modifiers', they might have already released the
3209 Alt key, and Emacs gets just `x', which is BAD.
3210 However, for keys with the `Map' property set, the ASCII
3211 code returns zero iff Alt is pressed. So, when we DON'T
3212 have to support international_keyboard, we don't have to
3213 distinguish between the left and right Alt keys, and we
3214 can set the META modifier for any keys with the `Map'
3215 property if they return zero ASCII code (c = 0). */
3217 || ( (code
& 0xf000) == Map
&& !international_keyboard
))
3218 modifiers
|= meta_modifier
;
3220 modifiers
|= ctrl_modifier
;
3222 modifiers
|= shift_modifier
;
3225 switch (code
& 0xf000)
3228 if (c
&& !(mask
& (SHIFT_P
| ALT_P
| CTRL_P
| HYPER_P
| SUPER_P
)))
3230 c
= 0; /* Special */
3243 if (c
== 0) /* ctrl-break */
3245 return c
; /* ALT-nnn */
3247 if (!keyboard_map_all
)
3256 if (c
&& !(mask
& ALT_P
) && !((mask
& SHIFT_P
) && (mask
& CTRL_P
)))
3257 if (!keyboard_map_all
)
3261 if (mask
& ALT_P
&& code
<= 10 && code
> 0 && dos_keypad_mode
& 0x200)
3262 mask
|= SHIFT_P
; /* ALT-1 => M-! etc. */
3266 code
= keyboard
->shifted
[code
];
3268 modifiers
&= ~shift_modifier
;
3271 if ((mask
& ALT_GR_P
) && keyboard
->alt_gr
&& keyboard
->alt_gr
[code
] != ' ')
3272 code
= keyboard
->alt_gr
[code
];
3274 code
= keyboard
->unshifted
[code
];
3279 if (c
== 0xe0) /* edit key */
3282 if ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) /* numlock on */
3283 kp_mode
= dos_keypad_mode
& 0x03;
3285 kp_mode
= (dos_keypad_mode
>> 4) & 0x03;
3290 if (code
== 10 && dos_decimal_point
)
3291 return dos_decimal_point
;
3292 return keypad_translate_map
[code
].char_code
;
3295 code
= 0xff00 | keypad_translate_map
[code
].keypad_code
;
3299 code
= keypad_translate_map
[code
].meta_code
;
3300 modifiers
= meta_modifier
;
3304 code
= 0xff00 | keypad_translate_map
[code
].editkey_code
;
3311 kp_mode
= ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) ? 0x04 : 0x40;
3312 if (dos_keypad_mode
& kp_mode
)
3313 code
= 0xff00 | grey_key_translate_map
[code
].keypad_code
;
3315 code
= grey_key_translate_map
[code
].char_code
;
3324 event
.kind
= non_ascii_keystroke
;
3326 event
.kind
= ascii_keystroke
;
3328 event
.modifiers
= modifiers
;
3329 event
.frame_or_window
= selected_frame
;
3331 event
.timestamp
= event_timestamp ();
3332 kbd_buffer_store_event (&event
);
3335 if (have_mouse
> 0 && !mouse_preempted
)
3337 int but
, press
, x
, y
, ok
;
3338 int mouse_prev_x
= mouse_last_x
, mouse_prev_y
= mouse_last_y
;
3340 /* Check for mouse movement *before* buttons. */
3341 mouse_check_moved ();
3343 /* If the mouse moved from the spot of its last sighting, we
3344 might need to update mouse highlight. */
3345 if (mouse_last_x
!= mouse_prev_x
|| mouse_last_y
!= mouse_prev_y
)
3347 previous_help_echo
= help_echo
;
3348 help_echo
= help_echo_object
= help_echo_window
= Qnil
;
3350 IT_note_mouse_highlight (SELECTED_FRAME(),
3351 mouse_last_x
, mouse_last_y
);
3352 /* If the contents of the global variable help_echo has
3353 changed, generate a HELP_EVENT. */
3354 if (!NILP (help_echo
) || !NILP (previous_help_echo
))
3356 /* HELP_EVENT takes 2 events in the event loop. */
3357 event
.kind
= HELP_EVENT
;
3358 event
.frame_or_window
= selected_frame
;
3359 event
.arg
= help_echo_object
;
3360 event
.x
= make_number (help_echo_pos
);
3361 event
.timestamp
= event_timestamp ();
3363 kbd_buffer_store_event (&event
);
3364 if (WINDOWP (help_echo_window
))
3365 event
.frame_or_window
= help_echo_window
;
3366 event
.arg
= help_echo
;
3368 kbd_buffer_store_event (&event
);
3372 for (but
= 0; but
< NUM_MOUSE_BUTTONS
; but
++)
3373 for (press
= 0; press
< 2; press
++)
3375 int button_num
= but
;
3378 ok
= mouse_pressed (but
, &x
, &y
);
3380 ok
= mouse_released (but
, &x
, &y
);
3383 /* Allow a simultaneous press/release of Mouse-1 and
3384 Mouse-2 to simulate Mouse-3 on two-button mice. */
3385 if (mouse_button_count
== 2 && but
< 2)
3387 int x2
, y2
; /* don't clobber original coordinates */
3389 /* If only one button is pressed, wait 100 msec and
3390 check again. This way, Speedy Gonzales isn't
3391 punished, while the slow get their chance. */
3392 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3393 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3398 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3399 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3404 event
.kind
= mouse_click
;
3405 event
.code
= button_num
;
3406 event
.modifiers
= dos_get_modifiers (0)
3407 | (press
? down_modifier
: up_modifier
);
3410 event
.frame_or_window
= selected_frame
;
3412 event
.timestamp
= event_timestamp ();
3413 kbd_buffer_store_event (&event
);
3421 static int prev_get_char
= -1;
3423 /* Return 1 if a key is ready to be read without suspending execution. */
3427 if (prev_get_char
!= -1)
3430 return ((prev_get_char
= dos_rawgetc ()) != -1);
3433 /* Read a key. Return -1 if no key is ready. */
3437 if (prev_get_char
!= -1)
3439 int c
= prev_get_char
;
3444 return dos_rawgetc ();
3447 #ifndef HAVE_X_WINDOWS
3448 /* See xterm.c for more info. */
3450 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
3452 register int pix_x
, pix_y
;
3453 register int *x
, *y
;
3457 if (bounds
) abort ();
3459 /* Ignore clipping. */
3466 glyph_to_pixel_coords (f
, x
, y
, pix_x
, pix_y
)
3469 register int *pix_x
, *pix_y
;
3475 /* Simulation of X's menus. Nothing too fancy here -- just make it work
3478 Actually, I don't know the meaning of all the parameters of the functions
3479 here -- I only know how they are called by xmenu.c. I could of course
3480 grab the nearest Xlib manual (down the hall, second-to-last door on the
3481 left), but I don't think it's worth the effort. */
3483 /* These hold text of the current and the previous menu help messages. */
3484 static char *menu_help_message
, *prev_menu_help_message
;
3485 /* Pane number and item number of the menu item which generated the
3486 last menu help message. */
3487 static int menu_help_paneno
, menu_help_itemno
;
3494 menu
= (XMenu
*) xmalloc (sizeof (XMenu
));
3495 menu
->allocated
= menu
->count
= menu
->panecount
= menu
->width
= 0;
3499 /* Allocate some (more) memory for MENU ensuring that there is room for one
3503 IT_menu_make_room (XMenu
*menu
)
3505 if (menu
->allocated
== 0)
3507 int count
= menu
->allocated
= 10;
3508 menu
->text
= (char **) xmalloc (count
* sizeof (char *));
3509 menu
->submenu
= (XMenu
**) xmalloc (count
* sizeof (XMenu
*));
3510 menu
->panenumber
= (int *) xmalloc (count
* sizeof (int));
3511 menu
->help_text
= (char **) xmalloc (count
* sizeof (char *));
3513 else if (menu
->allocated
== menu
->count
)
3515 int count
= menu
->allocated
= menu
->allocated
+ 10;
3517 = (char **) xrealloc (menu
->text
, count
* sizeof (char *));
3519 = (XMenu
**) xrealloc (menu
->submenu
, count
* sizeof (XMenu
*));
3521 = (int *) xrealloc (menu
->panenumber
, count
* sizeof (int));
3523 = (char **) xrealloc (menu
->help_text
, count
* sizeof (char *));
3527 /* Search the given menu structure for a given pane number. */
3530 IT_menu_search_pane (XMenu
*menu
, int pane
)
3535 for (i
= 0; i
< menu
->count
; i
++)
3536 if (menu
->submenu
[i
])
3538 if (pane
== menu
->panenumber
[i
])
3539 return menu
->submenu
[i
];
3540 if ((try = IT_menu_search_pane (menu
->submenu
[i
], pane
)))
3546 /* Determine how much screen space a given menu needs. */
3549 IT_menu_calc_size (XMenu
*menu
, int *width
, int *height
)
3551 int i
, h2
, w2
, maxsubwidth
, maxheight
;
3554 maxheight
= menu
->count
;
3555 for (i
= 0; i
< menu
->count
; i
++)
3557 if (menu
->submenu
[i
])
3559 IT_menu_calc_size (menu
->submenu
[i
], &w2
, &h2
);
3560 if (w2
> maxsubwidth
) maxsubwidth
= w2
;
3561 if (i
+ h2
> maxheight
) maxheight
= i
+ h2
;
3564 *width
= menu
->width
+ maxsubwidth
;
3565 *height
= maxheight
;
3568 /* Display MENU at (X,Y) using FACES. */
3571 IT_menu_display (XMenu
*menu
, int y
, int x
, int pn
, int *faces
, int disp_help
)
3573 int i
, j
, face
, width
;
3574 struct glyph
*text
, *p
;
3577 int enabled
, mousehere
;
3579 struct frame
*sf
= SELECTED_FRAME();
3581 menu_help_message
= NULL
;
3583 width
= menu
->width
;
3584 text
= (struct glyph
*) xmalloc ((width
+ 2) * sizeof (struct glyph
));
3585 ScreenGetCursor (&row
, &col
);
3586 mouse_get_xy (&mx
, &my
);
3587 IT_update_begin (sf
);
3588 for (i
= 0; i
< menu
->count
; i
++)
3590 int max_width
= width
+ 2;
3592 IT_cursor_to (y
+ i
, x
);
3594 = (!menu
->submenu
[i
] && menu
->panenumber
[i
]) || (menu
->submenu
[i
]);
3595 mousehere
= (y
+ i
== my
&& x
<= mx
&& mx
< x
+ width
+ 2);
3596 face
= faces
[enabled
+ mousehere
* 2];
3597 /* The following if clause means that we display the menu help
3598 strings even if the menu item is currently disabled. */
3599 if (disp_help
&& enabled
+ mousehere
* 2 >= 2)
3601 menu_help_message
= menu
->help_text
[i
];
3602 menu_help_paneno
= pn
- 1;
3603 menu_help_itemno
= i
;
3606 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3608 for (j
= 0, q
= menu
->text
[i
]; *q
; j
++)
3612 SET_CHAR_GLYPH (*p
, *q
++, face
, 0);
3615 else /* make '^x' */
3617 SET_CHAR_GLYPH (*p
, '^', face
, 0);
3620 SET_CHAR_GLYPH (*p
, *q
++ + 64, face
, 0);
3624 /* Don't let the menu text overflow into the next screen row. */
3625 if (x
+ max_width
> screen_size_X
)
3627 max_width
= screen_size_X
- x
;
3628 text
[max_width
- 1].u
.ch
= '$'; /* indicate it's truncated */
3630 for (; j
< max_width
- 2; j
++, p
++)
3631 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3633 SET_CHAR_GLYPH (*p
, menu
->submenu
[i
] ? 16 : ' ', face
, 0);
3635 IT_write_glyphs (text
, max_width
);
3638 IT_cursor_to (row
, col
);
3642 /* --------------------------- X Menu emulation ---------------------- */
3644 /* Report availability of menus. */
3652 /* Create a brand new menu structure. */
3655 XMenuCreate (Display
*foo1
, Window foo2
, char *foo3
)
3657 return IT_menu_create ();
3660 /* Create a new pane and place it on the outer-most level. It is not
3661 clear that it should be placed out there, but I don't know what else
3665 XMenuAddPane (Display
*foo
, XMenu
*menu
, char *txt
, int enable
)
3673 IT_menu_make_room (menu
);
3674 menu
->submenu
[menu
->count
] = IT_menu_create ();
3675 menu
->text
[menu
->count
] = txt
;
3676 menu
->panenumber
[menu
->count
] = ++menu
->panecount
;
3677 menu
->help_text
[menu
->count
] = NULL
;
3680 /* Adjust length for possible control characters (which will
3681 be written as ^x). */
3682 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3686 if (len
> menu
->width
)
3689 return menu
->panecount
;
3692 /* Create a new item in a menu pane. */
3695 XMenuAddSelection (Display
*bar
, XMenu
*menu
, int pane
,
3696 int foo
, char *txt
, int enable
, char *help_text
)
3702 if (!(menu
= IT_menu_search_pane (menu
, pane
)))
3704 IT_menu_make_room (menu
);
3705 menu
->submenu
[menu
->count
] = (XMenu
*) 0;
3706 menu
->text
[menu
->count
] = txt
;
3707 menu
->panenumber
[menu
->count
] = enable
;
3708 menu
->help_text
[menu
->count
] = help_text
;
3711 /* Adjust length for possible control characters (which will
3712 be written as ^x). */
3713 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3717 if (len
> menu
->width
)
3723 /* Decide where the menu would be placed if requested at (X,Y). */
3726 XMenuLocate (Display
*foo0
, XMenu
*menu
, int foo1
, int foo2
, int x
, int y
,
3727 int *ulx
, int *uly
, int *width
, int *height
)
3729 IT_menu_calc_size (menu
, width
, height
);
3735 struct IT_menu_state
3737 void *screen_behind
;
3744 /* Display menu, wait for user's response, and return that response. */
3747 XMenuActivate (Display
*foo
, XMenu
*menu
, int *pane
, int *selidx
,
3748 int x0
, int y0
, unsigned ButtonMask
, char **txt
,
3749 void (*help_callback
)(char *, int, int))
3751 struct IT_menu_state
*state
;
3756 Lisp_Object selectface
;
3757 int leave
, result
, onepane
;
3758 int title_faces
[4]; /* face to display the menu title */
3759 int buffers_num_deleted
= 0;
3760 struct frame
*sf
= SELECTED_FRAME();
3761 Lisp_Object saved_echo_area_message
;
3763 /* Just in case we got here without a mouse present... */
3764 if (have_mouse
<= 0)
3765 return XM_IA_SELECT
;
3766 /* Don't allow non-positive x0 and y0, lest the menu will wrap
3767 around the display. */
3773 /* We will process all the mouse events directly, so we had
3774 better prevent dos_rawgetc from stealing them from us. */
3777 state
= alloca (menu
->panecount
* sizeof (struct IT_menu_state
));
3778 screensize
= screen_size
* 2;
3780 = lookup_derived_face (sf
, intern ("msdos-menu-passive-face"),
3781 0, DEFAULT_FACE_ID
);
3783 = lookup_derived_face (sf
, intern ("msdos-menu-active-face"),
3784 0, DEFAULT_FACE_ID
);
3785 selectface
= intern ("msdos-menu-select-face");
3786 faces
[2] = lookup_derived_face (sf
, selectface
,
3788 faces
[3] = lookup_derived_face (sf
, selectface
,
3791 /* Make sure the menu title is always displayed with
3792 `msdos-menu-active-face', no matter where the mouse pointer is. */
3793 for (i
= 0; i
< 4; i
++)
3794 title_faces
[i
] = faces
[3];
3798 /* Don't let the title for the "Buffers" popup menu include a
3799 digit (which is ugly).
3801 This is a terrible kludge, but I think the "Buffers" case is
3802 the only one where the title includes a number, so it doesn't
3803 seem to be necessary to make this more general. */
3804 if (strncmp (menu
->text
[0], "Buffers 1", 9) == 0)
3806 menu
->text
[0][7] = '\0';
3807 buffers_num_deleted
= 1;
3810 /* We need to save the current echo area message, so that we could
3811 restore it below, before we exit. See the commentary below,
3812 before the call to message_with_string. */
3813 saved_echo_area_message
= Fcurrent_message ();
3814 state
[0].menu
= menu
;
3816 ScreenRetrieve (state
[0].screen_behind
= xmalloc (screensize
));
3818 /* Turn off the cursor. Otherwise it shows through the menu
3819 panes, which is ugly. */
3820 IT_display_cursor (0);
3822 /* Display the menu title. */
3823 IT_menu_display (menu
, y0
- 1, x0
- 1, 1, title_faces
, 0);
3824 if (buffers_num_deleted
)
3825 menu
->text
[0][7] = ' ';
3826 if ((onepane
= menu
->count
== 1 && menu
->submenu
[0]))
3828 menu
->width
= menu
->submenu
[0]->width
;
3829 state
[0].menu
= menu
->submenu
[0];
3833 state
[0].menu
= menu
;
3835 state
[0].x
= x0
- 1;
3837 state
[0].pane
= onepane
;
3839 mouse_last_x
= -1; /* A hack that forces display. */
3843 if (!mouse_visible
) mouse_on ();
3844 mouse_check_moved ();
3845 if (sf
->mouse_moved
)
3847 sf
->mouse_moved
= 0;
3848 result
= XM_IA_SELECT
;
3849 mouse_get_xy (&x
, &y
);
3850 for (i
= 0; i
< statecount
; i
++)
3851 if (state
[i
].x
<= x
&& x
< state
[i
].x
+ state
[i
].menu
->width
+ 2)
3853 int dy
= y
- state
[i
].y
;
3854 if (0 <= dy
&& dy
< state
[i
].menu
->count
)
3856 if (!state
[i
].menu
->submenu
[dy
])
3857 if (state
[i
].menu
->panenumber
[dy
])
3858 result
= XM_SUCCESS
;
3860 result
= XM_IA_SELECT
;
3861 *pane
= state
[i
].pane
- 1;
3863 /* We hit some part of a menu, so drop extra menus that
3864 have been opened. That does not include an open and
3866 if (i
!= statecount
- 2
3867 || state
[i
].menu
->submenu
[dy
] != state
[i
+1].menu
)
3868 while (i
!= statecount
- 1)
3872 ScreenUpdate (state
[statecount
].screen_behind
);
3873 if (screen_virtual_segment
)
3874 dosv_refresh_virtual_screen (0, screen_size
);
3875 xfree (state
[statecount
].screen_behind
);
3877 if (i
== statecount
- 1 && state
[i
].menu
->submenu
[dy
])
3879 IT_menu_display (state
[i
].menu
,
3884 state
[statecount
].menu
= state
[i
].menu
->submenu
[dy
];
3885 state
[statecount
].pane
= state
[i
].menu
->panenumber
[dy
];
3887 ScreenRetrieve (state
[statecount
].screen_behind
3888 = xmalloc (screensize
));
3890 = state
[i
].x
+ state
[i
].menu
->width
+ 2;
3891 state
[statecount
].y
= y
;
3896 IT_menu_display (state
[statecount
- 1].menu
,
3897 state
[statecount
- 1].y
,
3898 state
[statecount
- 1].x
,
3899 state
[statecount
- 1].pane
,
3904 if ((menu_help_message
|| prev_menu_help_message
)
3905 && menu_help_message
!= prev_menu_help_message
)
3907 help_callback (menu_help_message
,
3908 menu_help_paneno
, menu_help_itemno
);
3909 IT_display_cursor (0);
3910 prev_menu_help_message
= menu_help_message
;
3912 /* We are busy-waiting for the mouse to move, so let's be nice
3913 to other Windows applications by releasing our time slice. */
3916 for (b
= 0; b
< mouse_button_count
&& !leave
; b
++)
3918 /* Only leave if user both pressed and released the mouse, and in
3919 that order. This avoids popping down the menu pane unless
3920 the user is really done with it. */
3921 if (mouse_pressed (b
, &x
, &y
))
3923 while (mouse_button_depressed (b
, &x
, &y
))
3927 (void) mouse_released (b
, &x
, &y
);
3932 ScreenUpdate (state
[0].screen_behind
);
3933 if (screen_virtual_segment
)
3934 dosv_refresh_virtual_screen (0, screen_size
);
3936 /* We have a situation here. ScreenUpdate has just restored the
3937 screen contents as it was before we started drawing this menu.
3938 That includes any echo area message that could have been
3939 displayed back then. (In reality, that echo area message will
3940 almost always be the ``keystroke echo'' that echoes the sequence
3941 of menu items chosen by the user.) However, if the menu had some
3942 help messages, then displaying those messages caused Emacs to
3943 forget about the original echo area message. So when
3944 ScreenUpdate restored it, it created a discrepancy between the
3945 actual screen contents and what Emacs internal data structures
3948 To avoid this conflict, we force Emacs to restore the original
3949 echo area message as we found it when we entered this function.
3950 The irony of this is that we then erase the restored message
3951 right away, so the only purpose of restoring it is so that
3952 erasing it works correctly... */
3953 if (! NILP (saved_echo_area_message
))
3954 message_with_string ("%s", saved_echo_area_message
, 0);
3956 while (statecount
--)
3957 xfree (state
[statecount
].screen_behind
);
3958 IT_display_cursor (1); /* turn cursor back on */
3959 /* Clean up any mouse events that are waiting inside Emacs event queue.
3960 These events are likely to be generated before the menu was even
3961 displayed, probably because the user pressed and released the button
3962 (which invoked the menu) too quickly. If we don't remove these events,
3963 Emacs will process them after we return and surprise the user. */
3964 discard_mouse_events ();
3965 mouse_clear_clicks ();
3966 if (!kbd_buffer_events_waiting (1))
3967 clear_input_pending ();
3968 /* Allow mouse events generation by dos_rawgetc. */
3973 /* Dispose of a menu. */
3976 XMenuDestroy (Display
*foo
, XMenu
*menu
)
3979 if (menu
->allocated
)
3981 for (i
= 0; i
< menu
->count
; i
++)
3982 if (menu
->submenu
[i
])
3983 XMenuDestroy (foo
, menu
->submenu
[i
]);
3985 xfree (menu
->submenu
);
3986 xfree (menu
->panenumber
);
3987 xfree (menu
->help_text
);
3990 menu_help_message
= prev_menu_help_message
= NULL
;
3994 x_pixel_width (struct frame
*f
)
3996 return FRAME_WIDTH (f
);
4000 x_pixel_height (struct frame
*f
)
4002 return FRAME_HEIGHT (f
);
4004 #endif /* !HAVE_X_WINDOWS */
4006 /* ----------------------- DOS / UNIX conversion --------------------- */
4008 void msdos_downcase_filename (unsigned char *);
4010 /* Destructively turn backslashes into slashes. */
4013 dostounix_filename (p
)
4016 msdos_downcase_filename (p
);
4026 /* Destructively turn slashes into backslashes. */
4029 unixtodos_filename (p
)
4032 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4046 /* Get the default directory for a given drive. 0=def, 1=A, 2=B, ... */
4049 getdefdir (drive
, dst
)
4053 char in_path
[4], *p
= in_path
;
4056 /* Generate "X:." (when drive is X) or "." (when drive is 0). */
4059 *p
++ = drive
+ 'A' - 1;
4066 _fixpath (in_path
, dst
);
4067 /* _fixpath can set errno to ENOSYS on non-LFN systems because
4068 it queries the LFN support, so ignore that error. */
4069 if ((errno
&& errno
!= ENOSYS
) || *dst
== '\0')
4072 msdos_downcase_filename (dst
);
4078 /* Remove all CR's that are followed by a LF. */
4083 register unsigned char *buf
;
4085 unsigned char *np
= buf
;
4086 unsigned char *startp
= buf
;
4087 unsigned char *endp
= buf
+ n
;
4091 while (buf
< endp
- 1)
4095 if (*(++buf
) != 0x0a)
4106 #if defined(__DJGPP__) && __DJGPP__ == 2 && __DJGPP_MINOR__ == 0
4108 /* In DJGPP v2.0, library `write' can call `malloc', which might
4109 cause relocation of the buffer whose address we get in ADDR.
4110 Here is a version of `write' that avoids calling `malloc',
4111 to serve us until such time as the library is fixed.
4112 Actually, what we define here is called `__write', because
4113 `write' is a stub that just jmp's to `__write' (to be
4114 POSIXLY-correct with respect to the global name-space). */
4116 #include <io.h> /* for _write */
4117 #include <libc/dosio.h> /* for __file_handle_modes[] */
4119 static char xbuf
[64 * 1024]; /* DOS cannot write more in one chunk */
4121 #define XBUF_END (xbuf + sizeof (xbuf) - 1)
4124 __write (int handle
, const void *buffer
, size_t count
)
4129 if(__file_handle_modes
[handle
] & O_BINARY
)
4130 return _write (handle
, buffer
, count
);
4134 const char *bp
= buffer
;
4135 int total_written
= 0;
4136 int nmoved
= 0, ncr
= 0;
4140 /* The next test makes sure there's space for at least 2 more
4141 characters in xbuf[], so both CR and LF can be put there. */
4153 if (xbp
>= XBUF_END
|| !count
)
4155 size_t to_write
= nmoved
+ ncr
;
4156 int written
= _write (handle
, xbuf
, to_write
);
4161 total_written
+= nmoved
; /* CRs aren't counted in ret value */
4163 /* If some, but not all were written (disk full?), return
4164 an estimate of the total written bytes not counting CRs. */
4165 if (written
< to_write
)
4166 return total_written
- (to_write
- written
) * nmoved
/to_write
;
4173 return total_written
;
4177 /* A low-level file-renaming function which works around Windows 95 bug.
4178 This is pulled directly out of DJGPP v2.01 library sources, and only
4179 used when you compile with DJGPP v2.0. */
4183 int _rename(const char *old
, const char *new)
4186 int olen
= strlen(old
) + 1;
4188 int use_lfn
= _USE_LFN
;
4189 char tempfile
[FILENAME_MAX
];
4190 const char *orig
= old
;
4193 r
.x
.dx
= __tb_offset
;
4194 r
.x
.di
= __tb_offset
+ olen
;
4195 r
.x
.ds
= r
.x
.es
= __tb_segment
;
4199 /* Windows 95 bug: for some filenames, when you rename
4200 file -> file~ (as in Emacs, to leave a backup), the
4201 short 8+3 alias doesn't change, which effectively
4202 makes OLD and NEW the same file. We must rename
4203 through a temporary file to work around this. */
4205 char *pbase
= 0, *p
;
4206 static char try_char
[] = "abcdefghijklmnopqrstuvwxyz012345789";
4207 int idx
= sizeof(try_char
) - 1;
4209 /* Generate a temporary name. Can't use `tmpnam', since $TMPDIR
4210 might point to another drive, which will fail the DOS call. */
4211 strcpy(tempfile
, old
);
4212 for (p
= tempfile
; *p
; p
++) /* ensure temporary is on the same drive */
4213 if (*p
== '/' || *p
== '\\' || *p
== ':')
4219 strcpy(pbase
, "X$$djren$$.$$temp$$");
4225 *pbase
= try_char
[--idx
];
4226 } while (_chmod(tempfile
, 0) != -1);
4229 _put_path2(tempfile
, olen
);
4231 __dpmi_int(0x21, &r
);
4234 errno
= __doserr_to_errno(r
.x
.ax
);
4238 /* Now create a file with the original name. This will
4239 ensure that NEW will always have a 8+3 alias
4240 different from that of OLD. (Seems to be required
4241 when NameNumericTail in the Registry is set to 0.) */
4242 lfn_fd
= _creat(old
, 0);
4244 olen
= strlen(tempfile
) + 1;
4246 r
.x
.di
= __tb_offset
+ olen
;
4255 _put_path2(new, olen
);
4257 __dpmi_int(0x21, &r
);
4260 if (r
.x
.ax
== 5 && i
== 0) /* access denied */
4261 remove(new); /* and try again */
4264 errno
= __doserr_to_errno(r
.x
.ax
);
4266 /* Restore to original name if we renamed it to temporary. */
4274 _put_path2(orig
, olen
);
4275 _put_path(tempfile
);
4277 __dpmi_int(0x21, &r
);
4286 /* Success. Delete the file possibly created to work
4287 around the Windows 95 bug. */
4289 return (_close (lfn_fd
) == 0) ? remove (orig
) : -1;
4293 #endif /* __DJGPP__ == 2 && __DJGPP_MINOR__ == 0 */
4295 DEFUN ("msdos-long-file-names", Fmsdos_long_file_names
, Smsdos_long_file_names
,
4297 "Return non-nil if long file names are supported on MSDOS.")
4300 return (_USE_LFN
? Qt
: Qnil
);
4303 /* Convert alphabetic characters in a filename to lower-case. */
4306 msdos_downcase_filename (p
)
4307 register unsigned char *p
;
4309 /* Always lower-case drive letters a-z, even if the filesystem
4310 preserves case in filenames.
4311 This is so MSDOS filenames could be compared by string comparison
4312 functions that are case-sensitive. Even case-preserving filesystems
4313 do not distinguish case in drive letters. */
4314 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4320 /* Under LFN we expect to get pathnames in their true case. */
4321 if (NILP (Fmsdos_long_file_names ()))
4323 if (*p
>= 'A' && *p
<= 'Z')
4327 DEFUN ("msdos-downcase-filename", Fmsdos_downcase_filename
, Smsdos_downcase_filename
,
4329 "Convert alphabetic characters in FILENAME to lower case and return that.\n\
4330 When long filenames are supported, doesn't change FILENAME.\n\
4331 If FILENAME is not a string, returns nil.\n\
4332 The argument object is never altered--the value is a copy.")
4334 Lisp_Object filename
;
4338 if (! STRINGP (filename
))
4341 tem
= Fcopy_sequence (filename
);
4342 msdos_downcase_filename (XSTRING (tem
)->data
);
4346 /* The Emacs root directory as determined by init_environment. */
4348 static char emacsroot
[MAXPATHLEN
];
4351 rootrelativepath (rel
)
4354 static char result
[MAXPATHLEN
+ 10];
4356 strcpy (result
, emacsroot
);
4357 strcat (result
, "/");
4358 strcat (result
, rel
);
4362 /* Define a lot of environment variables if not already defined. Don't
4363 remove anything unless you know what you're doing -- lots of code will
4364 break if one or more of these are missing. */
4367 init_environment (argc
, argv
, skip_args
)
4374 static const char * const tempdirs
[] = {
4375 "$TMPDIR", "$TEMP", "$TMP", "c:/"
4378 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
4380 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
4381 temporary files and assume "/tmp" if $TMPDIR is unset, which
4382 will break on DOS/Windows. Refuse to work if we cannot find
4383 a directory, not even "c:/", usable for that purpose. */
4384 for (i
= 0; i
< imax
; i
++)
4386 const char *tmp
= tempdirs
[i
];
4389 tmp
= getenv (tmp
+ 1);
4390 /* Note that `access' can lie to us if the directory resides on a
4391 read-only filesystem, like CD-ROM or a write-protected floppy.
4392 The only way to be really sure is to actually create a file and
4393 see if it succeeds. But I think that's too much to ask. */
4394 if (tmp
&& access (tmp
, D_OK
) == 0)
4396 setenv ("TMPDIR", tmp
, 1);
4403 Fcons (build_string ("no usable temporary directories found!!"),
4405 "While setting TMPDIR: ");
4407 /* Note the startup time, so we know not to clear the screen if we
4408 exit immediately; see IT_reset_terminal_modes.
4409 (Yes, I know `clock' returns zero the first time it's called, but
4410 I do this anyway, in case some wiseguy changes that at some point.) */
4411 startup_time
= clock ();
4413 /* Find our root from argv[0]. Assuming argv[0] is, say,
4414 "c:/emacs/bin/emacs.exe" our root will be "c:/emacs". */
4415 root
= alloca (MAXPATHLEN
+ 20);
4416 _fixpath (argv
[0], root
);
4417 msdos_downcase_filename (root
);
4418 len
= strlen (root
);
4419 while (len
> 0 && root
[len
] != '/' && root
[len
] != ':')
4423 && (strcmp (root
+ len
- 4, "/bin") == 0
4424 || strcmp (root
+ len
- 4, "/src") == 0)) /* under a debugger */
4425 root
[len
- 4] = '\0';
4427 strcpy (root
, "c:/emacs"); /* let's be defensive */
4428 len
= strlen (root
);
4429 strcpy (emacsroot
, root
);
4431 /* We default HOME to our root. */
4432 setenv ("HOME", root
, 0);
4434 /* We default EMACSPATH to root + "/bin". */
4435 strcpy (root
+ len
, "/bin");
4436 setenv ("EMACSPATH", root
, 0);
4438 /* I don't expect anybody to ever use other terminals so the internal
4439 terminal is the default. */
4440 setenv ("TERM", "internal", 0);
4442 #ifdef HAVE_X_WINDOWS
4443 /* Emacs expects DISPLAY to be set. */
4444 setenv ("DISPLAY", "unix:0.0", 0);
4447 /* SHELL is a bit tricky -- COMSPEC is the closest we come, but we must
4448 downcase it and mirror the backslashes. */
4449 s
= getenv ("COMSPEC");
4450 if (!s
) s
= "c:/command.com";
4451 t
= alloca (strlen (s
) + 1);
4453 dostounix_filename (t
);
4454 setenv ("SHELL", t
, 0);
4456 /* PATH is also downcased and backslashes mirrored. */
4457 s
= getenv ("PATH");
4459 t
= alloca (strlen (s
) + 3);
4460 /* Current directory is always considered part of MsDos's path but it is
4461 not normally mentioned. Now it is. */
4462 strcat (strcpy (t
, ".;"), s
);
4463 dostounix_filename (t
); /* Not a single file name, but this should work. */
4464 setenv ("PATH", t
, 1);
4466 /* In some sense all dos users have root privileges, so... */
4467 setenv ("USER", "root", 0);
4468 setenv ("NAME", getenv ("USER"), 0);
4470 /* Time zone determined from country code. To make this possible, the
4471 country code may not span more than one time zone. In other words,
4472 in the USA, you lose. */
4474 switch (dos_country_code
)
4476 case 31: /* Belgium */
4477 case 32: /* The Netherlands */
4478 case 33: /* France */
4479 case 34: /* Spain */
4480 case 36: /* Hungary */
4481 case 38: /* Yugoslavia (or what's left of it?) */
4482 case 39: /* Italy */
4483 case 41: /* Switzerland */
4484 case 42: /* Tjekia */
4485 case 45: /* Denmark */
4486 case 46: /* Sweden */
4487 case 47: /* Norway */
4488 case 48: /* Poland */
4489 case 49: /* Germany */
4490 /* Daylight saving from last Sunday in March to last Sunday in
4491 September, both at 2AM. */
4492 setenv ("TZ", "MET-01METDST-02,M3.5.0/02:00,M9.5.0/02:00", 0);
4494 case 44: /* United Kingdom */
4495 case 351: /* Portugal */
4496 case 354: /* Iceland */
4497 setenv ("TZ", "GMT+00", 0);
4499 case 81: /* Japan */
4500 case 82: /* Korea */
4501 setenv ("TZ", "JST-09", 0);
4503 case 90: /* Turkey */
4504 case 358: /* Finland */
4505 setenv ("TZ", "EET-02", 0);
4507 case 972: /* Israel */
4508 /* This is an approximation. (For exact rules, use the
4509 `zoneinfo/israel' file which comes with DJGPP, but you need
4510 to install it in `/usr/share/zoneinfo/' directory first.) */
4511 setenv ("TZ", "IST-02IDT-03,M4.1.6/00:00,M9.5.6/01:00", 0);
4519 static int break_stat
; /* BREAK check mode status. */
4520 static int stdin_stat
; /* stdin IOCTL status. */
4524 /* These must be global. */
4525 static _go32_dpmi_seginfo ctrl_break_vector
;
4526 static _go32_dpmi_registers ctrl_break_regs
;
4527 static int ctrlbreakinstalled
= 0;
4529 /* Interrupt level detection of Ctrl-Break. Don't do anything fancy here! */
4532 ctrl_break_func (regs
)
4533 _go32_dpmi_registers
*regs
;
4539 install_ctrl_break_check ()
4541 if (!ctrlbreakinstalled
)
4543 /* Don't press Ctrl-Break if you don't have either DPMI or Emacs
4544 was compiler with Djgpp 1.11 maintenance level 5 or later! */
4545 ctrlbreakinstalled
= 1;
4546 ctrl_break_vector
.pm_offset
= (int) ctrl_break_func
;
4547 _go32_dpmi_allocate_real_mode_callback_iret (&ctrl_break_vector
,
4549 _go32_dpmi_set_real_mode_interrupt_vector (0x1b, &ctrl_break_vector
);
4553 #endif /* __DJGPP__ < 2 */
4555 /* Turn off Dos' Ctrl-C checking and inhibit interpretation of
4556 control chars by DOS. Determine the keyboard type. */
4561 union REGS inregs
, outregs
;
4562 static int first_time
= 1;
4564 break_stat
= getcbrk ();
4567 install_ctrl_break_check ();
4573 int86 (0x15, &inregs
, &outregs
);
4574 extended_kbd
= (!outregs
.x
.cflag
) && (outregs
.h
.ah
== 0);
4578 if (internal_terminal
4579 #ifdef HAVE_X_WINDOWS
4580 && inhibit_window_system
4584 inregs
.x
.ax
= 0x0021;
4585 int86 (0x33, &inregs
, &outregs
);
4586 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4589 /* Reportedly, the above doesn't work for some mouse drivers. There
4590 is an additional detection method that should work, but might be
4591 a little slower. Use that as an alternative. */
4592 inregs
.x
.ax
= 0x0000;
4593 int86 (0x33, &inregs
, &outregs
);
4594 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4599 have_mouse
= 1; /* enable mouse */
4601 mouse_setup_buttons (outregs
.x
.bx
);
4602 mouse_position_hook
= &mouse_get_pos
;
4606 #ifndef HAVE_X_WINDOWS
4608 /* Save the cursor shape used outside Emacs. */
4609 outside_cursor
= _farpeekw (_dos_ds
, 0x460);
4618 stdin_stat
= setmode (fileno (stdin
), O_BINARY
);
4619 return (stdin_stat
!= -1);
4622 return (setmode (fileno (stdin
), O_BINARY
) != -1);
4624 #else /* __DJGPP__ < 2 */
4628 /* I think it is wrong to overwrite `stdin_stat' every time
4629 but the first one this function is called, but I don't
4630 want to change the way it used to work in v1.x.--EZ */
4632 inregs
.x
.ax
= 0x4400; /* Get IOCTL status. */
4633 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4634 intdos (&inregs
, &outregs
);
4635 stdin_stat
= outregs
.h
.dl
;
4637 inregs
.x
.dx
= stdin_stat
| 0x0020; /* raw mode */
4638 inregs
.x
.ax
= 0x4401; /* Set IOCTL status */
4639 intdos (&inregs
, &outregs
);
4640 return !outregs
.x
.cflag
;
4642 #endif /* __DJGPP__ < 2 */
4645 /* Restore status of standard input and Ctrl-C checking. */
4650 union REGS inregs
, outregs
;
4652 setcbrk (break_stat
);
4657 #ifndef HAVE_X_WINDOWS
4658 /* Restore the cursor shape we found on startup. */
4662 inregs
.x
.cx
= outside_cursor
;
4663 int86 (0x10, &inregs
, &outregs
);
4667 return (setmode (fileno (stdin
), stdin_stat
) != -1);
4669 #else /* not __DJGPP__ >= 2 */
4671 inregs
.x
.ax
= 0x4401; /* Set IOCTL status. */
4672 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4673 inregs
.x
.dx
= stdin_stat
;
4674 intdos (&inregs
, &outregs
);
4675 return !outregs
.x
.cflag
;
4677 #endif /* not __DJGPP__ >= 2 */
4681 /* Run command as specified by ARGV in directory DIR.
4682 The command is run with input from TEMPIN, output to
4683 file TEMPOUT and stderr to TEMPERR. */
4686 run_msdos_command (argv
, working_dir
, tempin
, tempout
, temperr
, envv
)
4687 unsigned char **argv
;
4688 const char *working_dir
;
4689 int tempin
, tempout
, temperr
;
4692 char *saveargv1
, *saveargv2
, *lowcase_argv0
, *pa
, *pl
;
4693 char oldwd
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
4694 int msshell
, result
= -1;
4695 int inbak
, outbak
, errbak
;
4699 /* Get current directory as MSDOS cwd is not per-process. */
4702 /* If argv[0] is the shell, it might come in any lettercase.
4703 Since `Fmember' is case-sensitive, we need to downcase
4704 argv[0], even if we are on case-preserving filesystems. */
4705 lowcase_argv0
= alloca (strlen (argv
[0]) + 1);
4706 for (pa
= argv
[0], pl
= lowcase_argv0
; *pa
; pl
++)
4709 if (*pl
>= 'A' && *pl
<= 'Z')
4714 cmd
= Ffile_name_nondirectory (build_string (lowcase_argv0
));
4715 msshell
= !NILP (Fmember (cmd
, Fsymbol_value (intern ("msdos-shells"))))
4716 && !strcmp ("-c", argv
[1]);
4719 saveargv1
= argv
[1];
4720 saveargv2
= argv
[2];
4722 /* We only need to mirror slashes if a DOS shell will be invoked
4723 not via `system' (which does the mirroring itself). Yes, that
4724 means DJGPP v1.x will lose here. */
4725 if (argv
[2] && argv
[3])
4727 char *p
= alloca (strlen (argv
[2]) + 1);
4729 strcpy (argv
[2] = p
, saveargv2
);
4730 while (*p
&& isspace (*p
))
4742 chdir (working_dir
);
4746 if (inbak
< 0 || outbak
< 0 || errbak
< 0)
4747 goto done
; /* Allocation might fail due to lack of descriptors. */
4750 mouse_get_xy (&x
, &y
);
4752 dos_ttcooked (); /* do it here while 0 = stdin */
4760 if (msshell
&& !argv
[3])
4762 /* MS-DOS native shells are too restrictive. For starters, they
4763 cannot grok commands longer than 126 characters. In DJGPP v2
4764 and later, `system' is much smarter, so we'll call it instead. */
4768 /* A shell gets a single argument--its full command
4769 line--whose original was saved in `saveargv2'. */
4771 /* Don't let them pass empty command lines to `system', since
4772 with some shells it will try to invoke an interactive shell,
4773 which will hang Emacs. */
4774 for (cmnd
= saveargv2
; *cmnd
&& isspace (*cmnd
); cmnd
++)
4778 extern char **environ
;
4779 char **save_env
= environ
;
4780 int save_system_flags
= __system_flags
;
4782 /* Request the most powerful version of `system'. We need
4783 all the help we can get to avoid calling stock DOS shells. */
4784 __system_flags
= (__system_redirect
4785 | __system_use_shell
4786 | __system_allow_multiple_cmds
4787 | __system_allow_long_cmds
4788 | __system_handle_null_commands
4789 | __system_emulate_chdir
);
4792 result
= system (cmnd
);
4793 __system_flags
= save_system_flags
;
4797 result
= 0; /* emulate Unixy shell behavior with empty cmd line */
4801 #endif /* __DJGPP__ > 1 */
4803 result
= spawnve (P_WAIT
, argv
[0], argv
, envv
);
4808 emacs_close (inbak
);
4809 emacs_close (outbak
);
4810 emacs_close (errbak
);
4816 mouse_moveto (x
, y
);
4819 /* Some programs might change the meaning of the highest bit of the
4820 text attribute byte, so we get blinking characters instead of the
4821 bright background colors. Restore that. */
4828 argv
[1] = saveargv1
;
4829 argv
[2] = saveargv2
;
4837 fprintf (stderr
, "%s not yet implemented\r\n", badfunc
);
4844 /* ------------------------- Compatibility functions -------------------
4849 /* Hostnames for a pc are not really funny,
4850 but they are used in change log so we emulate the best we can. */
4852 gethostname (p
, size
)
4856 char *q
= egetenv ("HOSTNAME");
4863 /* When time zones are set from Ms-Dos too many C-libraries are playing
4864 tricks with time values. We solve this by defining our own version
4865 of `gettimeofday' bypassing GO32. Our version needs to be initialized
4866 once and after each call to `tzset' with TZ changed. That is
4867 accomplished by aliasing tzset to init_gettimeofday. */
4869 static struct tm time_rec
;
4872 gettimeofday (struct timeval
*tp
, struct timezone
*tzp
)
4880 if (t
.ti_hour
< time_rec
.tm_hour
) /* midnight wrap */
4884 time_rec
.tm_year
= d
.da_year
- 1900;
4885 time_rec
.tm_mon
= d
.da_mon
- 1;
4886 time_rec
.tm_mday
= d
.da_day
;
4889 time_rec
.tm_hour
= t
.ti_hour
;
4890 time_rec
.tm_min
= t
.ti_min
;
4891 time_rec
.tm_sec
= t
.ti_sec
;
4894 tm
.tm_gmtoff
= dos_timezone_offset
;
4896 tp
->tv_sec
= mktime (&tm
); /* may modify tm */
4897 tp
->tv_usec
= t
.ti_hund
* (1000000 / 100);
4899 /* Ignore tzp; it's obsolescent. */
4903 #endif /* __DJGPP__ < 2 */
4906 * A list of unimplemented functions that we silently ignore.
4910 unsigned alarm (s
) unsigned s
; {}
4911 fork () { return 0; }
4912 int kill (x
, y
) int x
, y
; { return -1; }
4914 void volatile pause () {}
4915 sigsetmask (x
) int x
; { return 0; }
4916 sigblock (mask
) int mask
; { return 0; }
4919 void request_sigio (void) {}
4920 setpgrp () {return 0; }
4921 setpriority (x
,y
,z
) int x
,y
,z
; { return 0; }
4922 void unrequest_sigio (void) {}
4926 #ifdef POSIX_SIGNALS
4928 /* Augment DJGPP library POSIX signal functions. This is needed
4929 as of DJGPP v2.01, but might be in the library in later releases. */
4931 #include <libc/bss.h>
4933 /* A counter to know when to re-initialize the static sets. */
4934 static int sigprocmask_count
= -1;
4936 /* Which signals are currently blocked (initially none). */
4937 static sigset_t current_mask
;
4939 /* Which signals are pending (initially none). */
4940 static sigset_t pending_signals
;
4942 /* Previous handlers to restore when the blocked signals are unblocked. */
4943 typedef void (*sighandler_t
)(int);
4944 static sighandler_t prev_handlers
[320];
4946 /* A signal handler which just records that a signal occured
4947 (it will be raised later, if and when the signal is unblocked). */
4949 sig_suspender (signo
)
4952 sigaddset (&pending_signals
, signo
);
4956 sigprocmask (how
, new_set
, old_set
)
4958 const sigset_t
*new_set
;
4964 /* If called for the first time, initialize. */
4965 if (sigprocmask_count
!= __bss_count
)
4967 sigprocmask_count
= __bss_count
;
4968 sigemptyset (&pending_signals
);
4969 sigemptyset (¤t_mask
);
4970 for (signo
= 0; signo
< 320; signo
++)
4971 prev_handlers
[signo
] = SIG_ERR
;
4975 *old_set
= current_mask
;
4980 if (how
!= SIG_BLOCK
&& how
!= SIG_UNBLOCK
&& how
!= SIG_SETMASK
)
4986 sigemptyset (&new_mask
);
4988 /* DJGPP supports upto 320 signals. */
4989 for (signo
= 0; signo
< 320; signo
++)
4991 if (sigismember (¤t_mask
, signo
))
4992 sigaddset (&new_mask
, signo
);
4993 else if (sigismember (new_set
, signo
) && how
!= SIG_UNBLOCK
)
4995 sigaddset (&new_mask
, signo
);
4997 /* SIGKILL is silently ignored, as on other platforms. */
4998 if (signo
!= SIGKILL
&& prev_handlers
[signo
] == SIG_ERR
)
4999 prev_handlers
[signo
] = signal (signo
, sig_suspender
);
5001 if (( how
== SIG_UNBLOCK
5002 && sigismember (&new_mask
, signo
)
5003 && sigismember (new_set
, signo
))
5004 || (how
== SIG_SETMASK
5005 && sigismember (&new_mask
, signo
)
5006 && !sigismember (new_set
, signo
)))
5008 sigdelset (&new_mask
, signo
);
5009 if (prev_handlers
[signo
] != SIG_ERR
)
5011 signal (signo
, prev_handlers
[signo
]);
5012 prev_handlers
[signo
] = SIG_ERR
;
5014 if (sigismember (&pending_signals
, signo
))
5016 sigdelset (&pending_signals
, signo
);
5021 current_mask
= new_mask
;
5025 #else /* not POSIX_SIGNALS */
5027 sigsetmask (x
) int x
; { return 0; }
5028 sigblock (mask
) int mask
; { return 0; }
5030 #endif /* not POSIX_SIGNALS */
5031 #endif /* __DJGPP__ > 1 */
5034 #include "sysselect.h"
5036 #ifndef EMACS_TIME_ZERO_OR_NEG_P
5037 #define EMACS_TIME_ZERO_OR_NEG_P(time) \
5038 ((long)(time).tv_sec < 0 \
5039 || ((time).tv_sec == 0 \
5040 && (long)(time).tv_usec <= 0))
5043 /* This yields the rest of the current time slice to the task manager.
5044 It should be called by any code which knows that it has nothing
5045 useful to do except idle.
5047 I don't use __dpmi_yield here, since versions of library before 2.02
5048 called Int 2Fh/AX=1680h there in a way that would wedge the DOS box
5049 on some versions of Windows 9X. */
5052 dos_yield_time_slice (void)
5054 _go32_dpmi_registers r
;
5057 r
.x
.ss
= r
.x
.sp
= r
.x
.flags
= 0;
5058 _go32_dpmi_simulate_int (0x2f, &r
);
5063 /* Only event queue is checked. */
5064 /* We don't have to call timer_check here
5065 because wait_reading_process_input takes care of that. */
5067 sys_select (nfds
, rfds
, wfds
, efds
, timeout
)
5069 SELECT_TYPE
*rfds
, *wfds
, *efds
;
5070 EMACS_TIME
*timeout
;
5078 check_input
= FD_ISSET (0, rfds
);
5089 /* If we are looking only for the terminal, with no timeout,
5090 just read it and wait -- that's more efficient. */
5093 while (!detect_input_pending ())
5095 dos_yield_time_slice ();
5100 EMACS_TIME clnow
, cllast
, cldiff
;
5103 EMACS_SET_SECS_USECS (cllast
, t
.ti_sec
, t
.ti_hund
* 10000L);
5105 while (!check_input
|| !detect_input_pending ())
5108 EMACS_SET_SECS_USECS (clnow
, t
.ti_sec
, t
.ti_hund
* 10000L);
5109 EMACS_SUB_TIME (cldiff
, clnow
, cllast
);
5111 /* When seconds wrap around, we assume that no more than
5112 1 minute passed since last `gettime'. */
5113 if (EMACS_TIME_NEG_P (cldiff
))
5114 EMACS_SET_SECS (cldiff
, EMACS_SECS (cldiff
) + 60);
5115 EMACS_SUB_TIME (*timeout
, *timeout
, cldiff
);
5117 /* Stop when timeout value crosses zero. */
5118 if (EMACS_TIME_ZERO_OR_NEG_P (*timeout
))
5121 dos_yield_time_slice ();
5131 * Define overlaid functions:
5133 * chdir -> sys_chdir
5134 * tzset -> init_gettimeofday
5135 * abort -> dos_abort
5140 extern int chdir ();
5146 int len
= strlen (path
);
5147 char *tmp
= (char *)path
;
5149 if (*tmp
&& tmp
[1] == ':')
5151 if (getdisk () != tolower (tmp
[0]) - 'a')
5152 setdisk (tolower (tmp
[0]) - 'a');
5153 tmp
+= 2; /* strip drive: KFS 1995-07-06 */
5157 if (len
> 1 && (tmp
[len
- 1] == '/'))
5159 char *tmp1
= (char *) alloca (len
+ 1);
5170 extern void tzset (void);
5173 init_gettimeofday ()
5179 ltm
= gtm
= time (NULL
);
5180 ltm
= mktime (lstm
= localtime (<m
));
5181 gtm
= mktime (gmtime (>m
));
5182 time_rec
.tm_hour
= 99; /* force gettimeofday to get date */
5183 time_rec
.tm_isdst
= lstm
->tm_isdst
;
5184 dos_timezone_offset
= time_rec
.tm_gmtoff
= (int)(gtm
- ltm
) / 60;
5191 dos_abort (file
, line
)
5195 char buffer1
[200], buffer2
[400];
5198 sprintf (buffer1
, "<EMACS FATAL ERROR IN %s LINE %d>", file
, line
);
5199 for (i
= j
= 0; buffer1
[i
]; i
++) {
5200 buffer2
[j
++] = buffer1
[i
];
5201 buffer2
[j
++] = 0x70;
5203 dosmemput (buffer2
, j
, (int)ScreenPrimary
);
5204 ScreenSetCursor (2, 0);
5212 ScreenSetCursor (10, 0);
5213 cputs ("\r\n\nEmacs aborted!\r\n");
5215 #if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
5216 if (screen_virtual_segment
)
5217 dosv_refresh_virtual_screen (2 * 10 * screen_size_X
, 4 * screen_size_X
);
5218 /* Generate traceback, so we could tell whodunit. */
5219 signal (SIGINT
, SIG_DFL
);
5220 __asm__
__volatile__ ("movb $0x1b,%al;call ___djgpp_hw_exception");
5221 #else /* __DJGPP_MINOR__ >= 2 */
5223 #endif /* __DJGPP_MINOR__ >= 2 */
5229 /* The following variables are required so that cus-start.el won't
5230 complain about unbound variables. */
5231 #ifndef HAVE_X_WINDOWS
5232 /* Search path for bitmap files (xfns.c). */
5233 Lisp_Object Vx_bitmap_file_path
;
5234 int x_stretch_cursor_p
;
5236 #ifndef subprocesses
5237 /* Nonzero means delete a process right away if it exits (process.c). */
5238 static int delete_exited_processes
;
5243 recent_doskeys
= Fmake_vector (make_number (NUM_RECENT_DOSKEYS
), Qnil
);
5244 staticpro (&recent_doskeys
);
5245 #ifndef HAVE_X_WINDOWS
5247 staticpro (&help_echo
);
5248 help_echo_object
= Qnil
;
5249 staticpro (&help_echo_object
);
5250 help_echo_window
= Qnil
;
5251 staticpro (&help_echo_window
);
5252 previous_help_echo
= Qnil
;
5253 staticpro (&previous_help_echo
);
5256 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
5257 "List of directories to search for bitmap files for X.");
5258 Vx_bitmap_file_path
= decode_env_path ((char *) 0, ".");
5260 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
5261 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
5262 For example, if a block cursor is over a tab, it will be drawn as\n\
5263 wide as that tab on the display. (No effect on MS-DOS.)");
5264 x_stretch_cursor_p
= 0;
5266 /* The following two are from xfns.c: */
5267 Qbar
= intern ("bar");
5269 Qcursor_type
= intern ("cursor-type");
5270 staticpro (&Qcursor_type
);
5271 Qreverse
= intern ("reverse");
5272 staticpro (&Qreverse
);
5274 DEFVAR_LISP ("dos-unsupported-char-glyph", &Vdos_unsupported_char_glyph
,
5275 "*Glyph to display instead of chars not supported by current codepage.\n\
5277 This variable is used only by MSDOS terminals.");
5278 Vdos_unsupported_char_glyph
= '\177';
5280 #ifndef subprocesses
5281 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
5282 "*Non-nil means delete processes immediately when they exit.\n\
5283 nil means don't delete them until `list-processes' is run.");
5284 delete_exited_processes
= 0;
5287 defsubr (&Srecent_doskeys
);
5288 defsubr (&Smsdos_long_file_names
);
5289 defsubr (&Smsdos_downcase_filename
);
5290 defsubr (&Smsdos_remember_default_colors
);
5291 defsubr (&Smsdos_set_mouse_buttons
);