1 /* MS-DOS specific C utilities. -*- coding: raw-text -*-
2 Copyright (C) 1993, 94, 95, 96, 97, 1999, 2000, 2001
3 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs; see the file COPYING. If not, write to
19 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
20 Boston, MA 02111-1307, USA. */
22 /* Contributed by Morten Welinder */
23 /* New display, keyboard, and mouse control by Kim F. Storm */
25 /* Note: some of the stuff here was taken from end of sysdep.c in demacs. */
34 #include <sys/param.h>
38 #include <string.h> /* for bzero and string functions */
39 #include <sys/stat.h> /* for _fixpath */
40 #include <unistd.h> /* for chdir, dup, dup2, etc. */
41 #include <dir.h> /* for getdisk */
44 #include <io.h> /* for setmode */
45 #include <dpmi.h> /* for __dpmi_xxx stuff */
46 #include <sys/farptr.h> /* for _farsetsel, _farnspokeb */
47 #include <libc/dosio.h> /* for _USE_LFN */
48 #include <conio.h> /* for cputs */
53 #include "termhooks.h"
55 #include "dispextern.h"
65 #include "blockinput.h"
70 /* #include <process.h> */
71 /* Damn that local process.h! Instead we can define P_WAIT ourselves. */
79 #define _dos_ds _go32_info_block.selector_for_linear_memory
85 #include "syssignal.h"
91 /* If other `malloc' than ours is used, force our `sbrk' behave like
92 Unix programs expect (resize memory blocks to keep them contiguous).
93 If `sbrk' from `ralloc.c' is NOT used, also zero-out sbrk'ed memory,
94 because that's what `gmalloc' expects to get. */
98 int _crt0_startup_flags
= _CRT0_FLAG_UNIX_SBRK
;
99 #else /* not REL_ALLOC */
100 int _crt0_startup_flags
= (_CRT0_FLAG_UNIX_SBRK
| _CRT0_FLAG_FILL_SBRK_MEMORY
);
101 #endif /* not REL_ALLOC */
102 #endif /* GNU_MALLOC */
104 #endif /* not SYSTEM_MALLOC */
105 #endif /* __DJGPP__ > 1 */
124 /* ------------------------ Mouse control ---------------------------
126 * Coordinates are in screen positions and zero based.
127 * Mouse buttons are numbered from left to right and also zero based.
130 /* This used to be in termhooks.h, but mainstream Emacs code no longer
131 uses it, and it was removed... */
132 #define NUM_MOUSE_BUTTONS (5)
134 int have_mouse
; /* 0: no, 1: enabled, -1: disabled */
135 static int mouse_visible
;
137 static int mouse_last_x
;
138 static int mouse_last_y
;
140 static int mouse_button_translate
[NUM_MOUSE_BUTTONS
];
141 static int mouse_button_count
;
148 if (have_mouse
> 0 && !mouse_visible
)
151 fprintf (termscript
, "<M_ON>");
153 int86 (0x33, ®s
, ®s
);
163 if (have_mouse
> 0 && mouse_visible
)
166 fprintf (termscript
, "<M_OFF>");
168 int86 (0x33, ®s
, ®s
);
174 mouse_setup_buttons (int n_buttons
)
178 mouse_button_count
= 3;
179 mouse_button_translate
[0] = 0; /* Left */
180 mouse_button_translate
[1] = 2; /* Middle */
181 mouse_button_translate
[2] = 1; /* Right */
183 else /* two, what else? */
185 mouse_button_count
= 2;
186 mouse_button_translate
[0] = 0;
187 mouse_button_translate
[1] = 1;
191 DEFUN ("msdos-set-mouse-buttons", Fmsdos_set_mouse_buttons
, Smsdos_set_mouse_buttons
,
192 1, 1, "NSet number of mouse buttons to: ",
193 doc
: /* Set the number of mouse buttons to use by Emacs.
194 This is useful with mice that report the number of buttons inconsistently,
195 e.g., if the number of buttons is reported as 3, but Emacs only sees 2 of
196 them. This happens with wheeled mice on Windows 9X, for example. */)
198 Lisp_Object nbuttons
;
202 CHECK_NUMBER (nbuttons
);
205 Fsignal (Qargs_out_of_range
,
206 Fcons (build_string ("only 2 or 3 mouse buttons are supported"),
207 Fcons (nbuttons
, Qnil
)));
208 mouse_setup_buttons (n
);
213 mouse_get_xy (int *x
, int *y
)
218 int86 (0x33, ®s
, ®s
);
230 fprintf (termscript
, "<M_XY=%dx%d>", x
, y
);
232 mouse_last_x
= regs
.x
.cx
= x
* 8;
233 mouse_last_y
= regs
.x
.dx
= y
* 8;
234 int86 (0x33, ®s
, ®s
);
238 mouse_pressed (b
, xp
, yp
)
243 if (b
>= mouse_button_count
)
246 regs
.x
.bx
= mouse_button_translate
[b
];
247 int86 (0x33, ®s
, ®s
);
249 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
250 return (regs
.x
.bx
!= 0);
254 mouse_released (b
, xp
, yp
)
259 if (b
>= mouse_button_count
)
262 regs
.x
.bx
= mouse_button_translate
[b
];
263 int86 (0x33, ®s
, ®s
);
265 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
266 return (regs
.x
.bx
!= 0);
270 mouse_button_depressed (b
, xp
, yp
)
275 if (b
>= mouse_button_count
)
278 int86 (0x33, ®s
, ®s
);
279 if ((regs
.x
.bx
& (1 << mouse_button_translate
[b
])) != 0)
289 mouse_get_pos (f
, insist
, bar_window
, part
, x
, y
, time
)
292 Lisp_Object
*bar_window
, *x
, *y
;
293 enum scroll_bar_part
*part
;
297 Lisp_Object frame
, tail
;
299 /* Clear the mouse-moved flag for every frame on this display. */
300 FOR_EACH_FRAME (tail
, frame
)
301 XFRAME (frame
)->mouse_moved
= 0;
303 *f
= SELECTED_FRAME();
305 mouse_get_xy (&ix
, &iy
);
306 *time
= event_timestamp ();
307 *x
= make_number (mouse_last_x
= ix
);
308 *y
= make_number (mouse_last_y
= iy
);
316 mouse_get_xy (&x
, &y
);
317 SELECTED_FRAME()->mouse_moved
|= (x
!= mouse_last_x
|| y
!= mouse_last_y
);
322 /* Force the mouse driver to ``forget'' about any button clicks until
325 mouse_clear_clicks (void)
329 for (b
= 0; b
< mouse_button_count
; b
++)
331 int dummy_x
, dummy_y
;
333 (void) mouse_pressed (b
, &dummy_x
, &dummy_y
);
334 (void) mouse_released (b
, &dummy_x
, &dummy_y
);
344 fprintf (termscript
, "<M_INIT>");
347 int86 (0x33, ®s
, ®s
);
349 /* Reset the mouse last press/release info. It seems that Windows
350 doesn't do that automatically when function 21h is called, which
351 causes Emacs to ``remember'' the click that switched focus to the
352 window just before Emacs was started from that window. */
353 mouse_clear_clicks ();
357 regs
.x
.dx
= 8 * (ScreenCols () - 1);
358 int86 (0x33, ®s
, ®s
);
362 regs
.x
.dx
= 8 * (ScreenRows () - 1);
363 int86 (0x33, ®s
, ®s
);
369 /* ------------------------- Screen control ----------------------
373 static int internal_terminal
= 0;
375 #ifndef HAVE_X_WINDOWS
376 extern unsigned char ScreenAttrib
;
377 static int screen_face
;
379 static int screen_size_X
;
380 static int screen_size_Y
;
381 static int screen_size
;
383 static int current_pos_X
;
384 static int current_pos_Y
;
385 static int new_pos_X
;
386 static int new_pos_Y
;
388 static void *startup_screen_buffer
;
389 static int startup_screen_size_X
;
390 static int startup_screen_size_Y
;
391 static int startup_pos_X
;
392 static int startup_pos_Y
;
393 static unsigned char startup_screen_attrib
;
395 static clock_t startup_time
;
397 static int term_setup_done
;
399 static unsigned short outside_cursor
;
401 /* Similar to the_only_frame. */
402 struct x_output the_only_x_display
;
404 /* Support for DOS/V (allows Japanese characters to be displayed on
405 standard, non-Japanese, ATs). Only supported for DJGPP v2 and later. */
407 /* Holds the address of the text-mode screen buffer. */
408 static unsigned long screen_old_address
= 0;
409 /* Segment and offset of the virtual screen. If 0, DOS/V is NOT loaded. */
410 static unsigned short screen_virtual_segment
= 0;
411 static unsigned short screen_virtual_offset
= 0;
412 /* A flag to control how to display unibyte 8-bit characters. */
413 extern int unibyte_display_via_language_environment
;
417 /* The screen colors of the curent frame, which serve as the default
418 colors for newly-created frames. */
419 static int initial_screen_colors
[2];
422 /* Update the screen from a part of relocated DOS/V screen buffer which
423 begins at OFFSET and includes COUNT characters. */
425 dosv_refresh_virtual_screen (int offset
, int count
)
429 if (offset
< 0 || count
< 0) /* paranoia; invalid values crash DOS/V */
432 regs
.h
.ah
= 0xff; /* update relocated screen */
433 regs
.x
.es
= screen_virtual_segment
;
434 regs
.x
.di
= screen_virtual_offset
+ offset
;
436 __dpmi_int (0x10, ®s
);
441 dos_direct_output (y
, x
, buf
, len
)
447 int t0
= 2 * (x
+ y
* screen_size_X
);
448 int t
= t0
+ (int) ScreenPrimary
;
453 dosmemput (buf
++, 1, t
);
457 /* This is faster. */
458 for (_farsetsel (_dos_ds
); --len
>= 0; t
+= 2, buf
++)
459 _farnspokeb (t
, *buf
);
461 if (screen_virtual_segment
)
462 dosv_refresh_virtual_screen (t0
, l0
);
467 /* Flash the screen as a substitute for BEEPs. */
471 do_visible_bell (xorattr
)
472 unsigned char xorattr
;
477 movl _ScreenPrimary,%%eax \n\
484 xorb %%al,%%gs:(%%ebx) \n\
487 jne visible_bell_1 \n\
489 jne visible_bell_3 \n\
491 movzwl %%ax,%%eax \n\
492 movzwl %%ax,%%eax \n\
493 movzwl %%ax,%%eax \n\
494 movzwl %%ax,%%eax \n\
496 jne visible_bell_2 \n\
497 jmp visible_bell_0 \n\
500 : "m" (xorattr
), "g" (screen_size
)
501 : "%eax", "%ebx", /* "%gs",*/ "%ecx", "%edx");
505 ScreenVisualBell (void)
507 /* This creates an xor-mask that will swap the default fore- and
508 background colors. */
509 do_visible_bell (((the_only_x_display
.foreground_pixel
510 ^ the_only_x_display
.background_pixel
)
515 #ifndef HAVE_X_WINDOWS
517 static int blink_bit
= -1; /* the state of the blink bit at startup */
519 /* Enable bright background colors. */
525 /* Remember the original state of the blink/bright-background bit.
526 It is stored at 0040:0065h in the BIOS data area. */
528 blink_bit
= (_farpeekb (_dos_ds
, 0x465) & 0x20) == 0x20;
532 int86 (0x10, ®s
, ®s
);
535 /* Disable bright background colors (and enable blinking) if we found
536 the video system in that state at startup. */
538 maybe_enable_blinking (void)
546 int86 (0x10, ®s
, ®s
);
550 /* Return non-zero if the system has a VGA adapter. */
557 int86 (0x10, ®s
, ®s
);
558 if (regs
.h
.al
== 0x1a && regs
.h
.bl
> 5 && regs
.h
.bl
< 13)
563 /* Set the screen dimensions so that it can show no less than
564 ROWS x COLS frame. */
567 dos_set_window_size (rows
, cols
)
571 Lisp_Object video_mode
;
572 int video_mode_value
;
575 int current_rows
= ScreenRows (), current_cols
= ScreenCols ();
577 if (*rows
== current_rows
&& *cols
== current_cols
)
581 have_vga
= vga_installed ();
583 /* If the user specified a special video mode for these dimensions,
585 sprintf (video_name
, "screen-dimensions-%dx%d", *rows
, *cols
);
586 video_mode
= XSYMBOL (Fintern_soft (build_string (video_name
),
589 if (INTEGERP (video_mode
)
590 && (video_mode_value
= XINT (video_mode
)) > 0)
592 regs
.x
.ax
= video_mode_value
;
593 int86 (0x10, ®s
, ®s
);
597 /* Must hardware-reset the mouse, or else it won't update
598 its notion of screen dimensions for some non-standard
599 video modes. This is *painfully* slow... */
601 int86 (0x33, ®s
, ®s
);
605 /* Find one of the dimensions supported by standard EGA/VGA
606 which gives us at least the required dimensions. */
615 } std_dimension
[] = {
625 while (i
< sizeof (std_dimension
) / sizeof (std_dimension
[0]))
627 if (std_dimension
[i
].need_vga
<= have_vga
628 && std_dimension
[i
].rows
>= *rows
)
630 if (std_dimension
[i
].rows
!= current_rows
631 || *cols
!= current_cols
)
632 _set_screen_lines (std_dimension
[i
].rows
);
639 #else /* not __DJGPP__ > 1 */
641 else if (*rows
<= 25)
643 if (current_rows
!= 25 || current_cols
!= 80)
646 int86 (0x10, ®s
, ®s
);
649 int86 (0x10, ®s
, ®s
);
652 int86 (0x10, ®s
, ®s
);
654 int86 (0x10, ®s
, ®s
);
657 else if (*rows
<= 50)
658 if (have_vga
&& (current_rows
!= 50 || current_cols
!= 80)
659 || *rows
<= 43 && (current_rows
!= 43 || current_cols
!= 80))
662 int86 (0x10, ®s
, ®s
);
665 int86 (0x10, ®s
, ®s
);
668 int86 (0x10, ®s
, ®s
);
671 int86 (0x10, ®s
, ®s
);
673 #endif /* not __DJGPP__ > 1 */
681 /* Tell the caller what dimensions have been REALLY set. */
682 *rows
= ScreenRows ();
683 *cols
= ScreenCols ();
685 /* Update Emacs' notion of screen dimensions. */
686 screen_size_X
= *cols
;
687 screen_size_Y
= *rows
;
688 screen_size
= *cols
* *rows
;
691 /* If the dimensions changed, the mouse highlight info is invalid. */
692 if (current_rows
!= *rows
|| current_cols
!= *cols
)
694 struct frame
*f
= SELECTED_FRAME();
695 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
696 Lisp_Object window
= dpyinfo
->mouse_face_window
;
698 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
700 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
701 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
702 dpyinfo
->mouse_face_window
= Qnil
;
707 /* Enable bright background colors. */
710 /* FIXME: I'm not sure the above will run at all on DOS/V. But let's
711 be defensive anyway. */
712 if (screen_virtual_segment
)
713 dosv_refresh_virtual_screen (0, *cols
* *rows
);
716 /* If we write a character in the position where the mouse is,
717 the mouse cursor may need to be refreshed. */
727 mouse_get_xy (&x
, &y
);
728 if (y
!= new_pos_Y
|| x
< new_pos_X
)
734 #define DEFAULT_CURSOR_START (-1)
735 #define DEFAULT_CURSOR_WIDTH (-1)
736 #define BOX_CURSOR_WIDTH (-32)
738 /* Set cursor to begin at scan line START_LINE in the character cell
739 and extend for WIDTH scan lines. Scan lines are counted from top
740 of the character cell, starting from zero. */
742 msdos_set_cursor_shape (struct frame
*f
, int start_line
, int width
)
745 unsigned desired_cursor
;
747 int max_line
, top_line
, bot_line
;
749 /* Avoid the costly BIOS call if F isn't the currently selected
750 frame. Allow for NULL as unconditionally meaning the selected
752 if (f
&& f
!= SELECTED_FRAME())
755 /* The character cell size in scan lines is stored at 40:85 in the
757 max_line
= _farpeekw (_dos_ds
, 0x485) - 1;
760 default: /* this relies on CGA cursor emulation being ON! */
777 if (width
== BOX_CURSOR_WIDTH
)
782 else if (start_line
!= DEFAULT_CURSOR_START
)
784 top_line
= start_line
;
785 bot_line
= top_line
- width
- 1;
787 else if (width
!= DEFAULT_CURSOR_WIDTH
)
790 bot_line
= -1 - width
;
793 top_line
= bot_line
+ 1;
797 /* [31, 0] seems to DTRT for all screen sizes. */
801 else /* WIDTH is positive */
803 if (start_line
!= DEFAULT_CURSOR_START
)
804 bot_line
= start_line
;
805 top_line
= bot_line
- (width
- 1);
808 /* If the current cursor shape is already what they want, we are
810 desired_cursor
= ((top_line
& 0x1f) << 8) | (bot_line
& 0x1f);
811 if (desired_cursor
== _farpeekw (_dos_ds
, 0x460))
815 regs
.x
.cx
= desired_cursor
;
816 __dpmi_int (0x10, ®s
);
817 #endif /* __DJGPP__ > 1 */
821 IT_set_cursor_type (struct frame
*f
, Lisp_Object cursor_type
)
823 if (EQ (cursor_type
, Qbar
))
825 /* Just BAR means the normal EGA/VGA cursor. */
826 msdos_set_cursor_shape (f
, DEFAULT_CURSOR_START
, DEFAULT_CURSOR_WIDTH
);
828 else if (CONSP (cursor_type
) && EQ (XCAR (cursor_type
), Qbar
))
830 Lisp_Object bar_parms
= XCDR (cursor_type
);
833 if (INTEGERP (bar_parms
))
835 /* Feature: negative WIDTH means cursor at the top
836 of the character cell, zero means invisible cursor. */
837 width
= XINT (bar_parms
);
838 msdos_set_cursor_shape (f
, width
>= 0 ? DEFAULT_CURSOR_START
: 0,
841 else if (CONSP (bar_parms
)
842 && INTEGERP (XCAR (bar_parms
))
843 && INTEGERP (XCDR (bar_parms
)))
845 int start_line
= XINT (XCDR (bar_parms
));
847 width
= XINT (XCAR (bar_parms
));
848 msdos_set_cursor_shape (f
, start_line
, width
);
852 /* Treat anything unknown as "box cursor". This includes nil, so
853 that a frame which doesn't specify a cursor type gets a box,
854 which is the default in Emacs. */
855 msdos_set_cursor_shape (f
, 0, BOX_CURSOR_WIDTH
);
868 union REGS inregs
, outregs
;
871 intdos (&inregs
, &outregs
);
875 /* Given a face id FACE, extract the face parameters to be used for
876 display until the face changes. The face parameters (actually, its
877 color) are used to construct the video attribute byte for each
878 glyph during the construction of the buffer that is then blitted to
881 IT_set_face (int face
)
883 struct frame
*sf
= SELECTED_FRAME();
884 struct face
*fp
= FACE_FROM_ID (sf
, face
);
885 struct face
*dfp
= FACE_FROM_ID (sf
, DEFAULT_FACE_ID
);
886 unsigned long fg
, bg
, dflt_fg
, dflt_bg
;
891 /* The default face for the frame should always be realized and
899 dflt_fg
= dfp
->foreground
;
900 dflt_bg
= dfp
->background
;
902 /* Don't use invalid colors. In particular, FACE_TTY_DEFAULT_* colors
903 mean use the colors of the default face. Note that we assume all
904 16 colors to be available for the background, since Emacs switches
905 on this mode (and loses the blinking attribute) at startup. */
906 if (fg
== FACE_TTY_DEFAULT_COLOR
|| fg
== FACE_TTY_DEFAULT_FG_COLOR
)
907 fg
= FRAME_FOREGROUND_PIXEL (sf
);
908 else if (fg
== FACE_TTY_DEFAULT_BG_COLOR
)
909 fg
= FRAME_BACKGROUND_PIXEL (sf
);
910 if (bg
== FACE_TTY_DEFAULT_COLOR
|| bg
== FACE_TTY_DEFAULT_BG_COLOR
)
911 bg
= FRAME_BACKGROUND_PIXEL (sf
);
912 else if (bg
== FACE_TTY_DEFAULT_FG_COLOR
)
913 bg
= FRAME_FOREGROUND_PIXEL (sf
);
915 /* Make sure highlighted lines really stand out, come what may. */
916 if (fp
->tty_reverse_p
&& (fg
== dflt_fg
&& bg
== dflt_bg
))
918 unsigned long tem
= fg
;
923 /* If the user requested inverse video, obey. */
926 unsigned long tem2
= fg
;
932 fprintf (termscript
, "<FACE %d: %d/%d[FG:%d/BG:%d]>", face
,
933 fp
->foreground
, fp
->background
, fg
, bg
);
934 if (fg
>= 0 && fg
< 16)
936 ScreenAttrib
&= 0xf0;
939 if (bg
>= 0 && bg
< 16)
941 ScreenAttrib
&= 0x0f;
942 ScreenAttrib
|= ((bg
& 0x0f) << 4);
946 Lisp_Object Vdos_unsupported_char_glyph
;
949 IT_write_glyphs (struct glyph
*str
, int str_len
)
951 unsigned char *screen_buf
, *screen_bp
, *screen_buf_end
, *bp
;
952 int unsupported_face
= FAST_GLYPH_FACE (Vdos_unsupported_char_glyph
);
953 unsigned unsupported_char
= FAST_GLYPH_CHAR (Vdos_unsupported_char_glyph
);
954 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
955 register int sl
= str_len
;
956 register int tlen
= GLYPH_TABLE_LENGTH
;
957 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
959 /* If terminal_coding does any conversion, use it, otherwise use
960 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
961 because it always returns 1 if terminal_coding.src_multibyte is 1. */
962 struct coding_system
*coding
=
963 (terminal_coding
.common_flags
& CODING_REQUIRE_ENCODING_MASK
965 : &safe_terminal_coding
);
968 /* Do we need to consider conversion of unibyte characters to
970 int convert_unibyte_characters
971 = (NILP (current_buffer
->enable_multibyte_characters
)
972 && unibyte_display_via_language_environment
);
974 unsigned char conversion_buffer
[256];
975 int conversion_buffer_size
= sizeof conversion_buffer
;
977 if (str_len
<= 0) return;
979 screen_buf
= screen_bp
= alloca (str_len
* 2);
980 screen_buf_end
= screen_buf
+ str_len
* 2;
981 sf
= SELECTED_FRAME();
983 /* Since faces get cached and uncached behind our back, we can't
984 rely on their indices in the cache being consistent across
985 invocations. So always reset the screen face to the default
986 face of the frame, before writing glyphs, and let the glyphs
987 set the right face if it's different from the default. */
988 IT_set_face (DEFAULT_FACE_ID
);
990 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
992 terminal_coding
.mode
&= ~CODING_MODE_LAST_BLOCK
;
995 int cf
, chlen
, enclen
;
996 unsigned char workbuf
[MAX_MULTIBYTE_LENGTH
], *buf
;
999 /* Glyphs with GLYPH_MASK_PADDING bit set are actually there
1000 only for the redisplay code to know how many columns does
1001 this character occupy on the screen. Skip padding glyphs. */
1002 if (CHAR_GLYPH_PADDING_P (*str
))
1009 register GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*str
);
1010 int glyph_not_in_table
= 0;
1012 /* If g is negative, it means we have a multibyte character
1013 in *str. That's what GLYPH_FROM_CHAR_GLYPH returns for
1014 multibyte characters. */
1015 if (g
< 0 || g
>= tlen
)
1017 /* This glyph doesn't have an entry in Vglyph_table. */
1019 glyph_not_in_table
= 1;
1023 /* This glyph has an entry in Vglyph_table, so process
1024 any aliases before testing for simpleness. */
1025 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
1026 ch
= FAST_GLYPH_CHAR (g
);
1029 /* Convert the character code to multibyte, if they
1030 requested display via language environment. We only want
1031 to convert unibyte characters to multibyte in unibyte
1032 buffers! Otherwise, the 8-bit value in CH came from the
1033 display table set up to display foreign characters. */
1034 if (SINGLE_BYTE_CHAR_P (ch
) && convert_unibyte_characters
1036 || (ch
>= 0200 && !NILP (Vnonascii_translation_table
))))
1037 ch
= unibyte_char_to_multibyte (ch
);
1039 /* Invalid characters are displayed with a special glyph. */
1040 if (! CHAR_VALID_P (ch
, 0))
1042 g
= !NILP (Vdos_unsupported_char_glyph
)
1043 ? Vdos_unsupported_char_glyph
1044 : MAKE_GLYPH (sf
, '\177', GLYPH_FACE (sf
, g
));
1045 ch
= FAST_GLYPH_CHAR (g
);
1048 /* If the face of this glyph is different from the current
1049 screen face, update the screen attribute byte. */
1051 if (cf
!= screen_face
)
1052 IT_set_face (cf
); /* handles invalid faces gracefully */
1054 if (glyph_not_in_table
|| GLYPH_SIMPLE_P (tbase
, tlen
, g
))
1056 /* We generate the multi-byte form of CH in WORKBUF. */
1057 chlen
= CHAR_STRING (ch
, workbuf
);
1062 /* We have a string in Vglyph_table. */
1063 chlen
= GLYPH_LENGTH (tbase
, g
);
1064 buf
= GLYPH_STRING (tbase
, g
);
1067 /* If the character is not multibyte, don't bother converting it. */
1070 *conversion_buffer
= (unsigned char)ch
;
1076 coding
->src_multibyte
= 1;
1077 encode_coding (coding
, buf
, conversion_buffer
, chlen
,
1078 conversion_buffer_size
);
1079 chlen
-= coding
->consumed
;
1080 enclen
= coding
->produced
;
1082 /* Replace glyph codes that cannot be converted by
1083 terminal_coding with Vdos_unsupported_char_glyph. */
1084 if (*conversion_buffer
== '?')
1086 unsigned char *cbp
= conversion_buffer
;
1088 while (cbp
< conversion_buffer
+ enclen
&& *cbp
== '?')
1089 *cbp
++ = unsupported_char
;
1090 if (unsupported_face
!= screen_face
)
1091 IT_set_face (unsupported_face
);
1095 if (enclen
+ chlen
> screen_buf_end
- screen_bp
)
1097 /* The allocated buffer for screen writes is too small.
1098 Flush it and loop again without incrementing STR, so
1099 that the next loop will begin with the same glyph. */
1100 int nbytes
= screen_bp
- screen_buf
;
1103 dosmemput (screen_buf
, nbytes
, (int)ScreenPrimary
+ offset
);
1104 if (screen_virtual_segment
)
1105 dosv_refresh_virtual_screen (offset
, nbytes
/ 2);
1106 new_pos_X
+= nbytes
/ 2;
1109 /* Prepare to reuse the same buffer again. */
1110 screen_bp
= screen_buf
;
1114 /* There's enough place in the allocated buffer to add
1115 the encoding of this glyph. */
1117 /* First, copy the encoded bytes. */
1118 for (bp
= conversion_buffer
; enclen
--; bp
++)
1120 *screen_bp
++ = (unsigned char)*bp
;
1121 *screen_bp
++ = ScreenAttrib
;
1123 fputc (*bp
, termscript
);
1126 /* Now copy the bytes not consumed by the encoding. */
1129 buf
+= coding
->consumed
;
1133 fputc (*buf
, termscript
);
1134 *screen_bp
++ = (unsigned char)*buf
++;
1135 *screen_bp
++ = ScreenAttrib
;
1139 /* Update STR and its remaining length. */
1146 /* Dump whatever is left in the screen buffer. */
1148 dosmemput (screen_buf
, screen_bp
- screen_buf
, (int)ScreenPrimary
+ offset
);
1149 if (screen_virtual_segment
)
1150 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1151 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1153 /* We may have to output some codes to terminate the writing. */
1154 if (CODING_REQUIRE_FLUSHING (coding
))
1156 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
1157 encode_coding (coding
, "", conversion_buffer
, 0, conversion_buffer_size
);
1158 if (coding
->produced
> 0)
1160 screen_buf
= alloca (coding
->produced
* 2);
1161 for (screen_bp
= screen_buf
, bp
= conversion_buffer
;
1162 coding
->produced
--; bp
++)
1164 *screen_bp
++ = (unsigned char)*bp
;
1165 *screen_bp
++ = ScreenAttrib
;
1167 fputc (*bp
, termscript
);
1169 offset
+= screen_bp
- screen_buf
;
1171 dosmemput (screen_buf
, screen_bp
- screen_buf
,
1172 (int)ScreenPrimary
+ offset
);
1173 if (screen_virtual_segment
)
1174 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1175 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1180 /************************************************************************
1181 Mouse Highlight (and friends..)
1182 ************************************************************************/
1184 /* This is used for debugging, to turn off note_mouse_highlight. */
1185 int disable_mouse_highlight
;
1187 /* If non-nil, dos_rawgetc generates an event to display that string.
1188 (The display is done in keyboard.c:read_char, by calling
1190 static Lisp_Object help_echo
;
1191 static Lisp_Object previous_help_echo
; /* a helper temporary variable */
1193 /* These record the window, the object and the position where the help
1194 echo string was generated. */
1195 static Lisp_Object help_echo_window
;
1196 static Lisp_Object help_echo_object
;
1197 static int help_echo_pos
;
1199 static int mouse_preempted
= 0; /* non-zero when XMenu gobbles mouse events */
1201 /* Set the mouse pointer shape according to whether it is in the
1202 area where the mouse highlight is in effect. */
1204 IT_set_mouse_pointer (int mode
)
1206 /* A no-op for now. DOS text-mode mouse pointer doesn't offer too
1207 many possibilities to change its shape, and the available
1208 functionality pretty much sucks (e.g., almost every reasonable
1209 shape will conceal the character it is on). Since the color of
1210 the pointer changes in the highlighted area, it is not clear to
1211 me whether anything else is required, anyway. */
1214 /* Display the active region described by mouse_face_*
1215 in its mouse-face if HL > 0, in its normal face if HL = 0. */
1217 show_mouse_face (struct display_info
*dpyinfo
, int hl
)
1219 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
1220 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1225 /* If window is in the process of being destroyed, don't bother
1227 if (w
->current_matrix
== NULL
)
1228 goto set_cursor_shape
;
1230 /* Recognize when we are called to operate on rows that don't exist
1231 anymore. This can happen when a window is split. */
1232 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
1233 goto set_cursor_shape
;
1235 /* There's no sense to do anything if the mouse face isn't realized. */
1238 fp
= FACE_FROM_ID (SELECTED_FRAME(), dpyinfo
->mouse_face_face_id
);
1240 goto set_cursor_shape
;
1243 /* Note that mouse_face_beg_row etc. are window relative. */
1244 for (i
= dpyinfo
->mouse_face_beg_row
;
1245 i
<= dpyinfo
->mouse_face_end_row
;
1248 int start_hpos
, end_hpos
;
1249 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
1251 /* Don't do anything if row doesn't have valid contents. */
1252 if (!row
->enabled_p
)
1255 /* For all but the first row, the highlight starts at column 0. */
1256 if (i
== dpyinfo
->mouse_face_beg_row
)
1257 start_hpos
= dpyinfo
->mouse_face_beg_col
;
1261 if (i
== dpyinfo
->mouse_face_end_row
)
1262 end_hpos
= dpyinfo
->mouse_face_end_col
;
1264 end_hpos
= row
->used
[TEXT_AREA
];
1266 if (end_hpos
<= start_hpos
)
1268 /* Record that some glyphs of this row are displayed in
1270 row
->mouse_face_p
= hl
> 0;
1273 int vpos
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1274 int kstart
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1275 int nglyphs
= end_hpos
- start_hpos
;
1276 int offset
= ScreenPrimary
+ 2*(vpos
*screen_size_X
+ kstart
) + 1;
1277 int start_offset
= offset
;
1280 fprintf (termscript
, "\n<MH+ %d-%d:%d>",
1281 kstart
, kstart
+ nglyphs
- 1, vpos
);
1284 IT_set_face (dpyinfo
->mouse_face_face_id
);
1285 /* Since we are going to change only the _colors_ of the
1286 displayed text, there's no need to go through all the
1287 pain of generating and encoding the text from the glyphs.
1288 Instead, we simply poke the attribute byte of each
1289 affected position in video memory with the colors
1290 computed by IT_set_face! */
1291 _farsetsel (_dos_ds
);
1294 _farnspokeb (offset
, ScreenAttrib
);
1297 if (screen_virtual_segment
)
1298 dosv_refresh_virtual_screen (start_offset
, end_hpos
- start_hpos
);
1303 /* We are removing a previously-drawn mouse highlight. The
1304 safest way to do so is to redraw the glyphs anew, since
1305 all kinds of faces and display tables could have changed
1307 int nglyphs
= end_hpos
- start_hpos
;
1308 int save_x
= new_pos_X
, save_y
= new_pos_Y
;
1310 if (end_hpos
>= row
->used
[TEXT_AREA
])
1311 nglyphs
= row
->used
[TEXT_AREA
] - start_hpos
;
1313 /* IT_write_glyphs writes at cursor position, so we need to
1314 temporarily move cursor coordinates to the beginning of
1315 the highlight region. */
1316 new_pos_X
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1317 new_pos_Y
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1320 fprintf (termscript
, "<MH- %d-%d:%d>",
1321 new_pos_X
, new_pos_X
+ nglyphs
- 1, new_pos_Y
);
1322 IT_write_glyphs (row
->glyphs
[TEXT_AREA
] + start_hpos
, nglyphs
);
1324 fputs ("\n", termscript
);
1332 /* Change the mouse pointer shape. */
1333 IT_set_mouse_pointer (hl
);
1336 /* Clear out the mouse-highlighted active region.
1337 Redraw it un-highlighted first. */
1339 clear_mouse_face (struct display_info
*dpyinfo
)
1341 if (! NILP (dpyinfo
->mouse_face_window
))
1342 show_mouse_face (dpyinfo
, 0);
1344 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
1345 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
1346 dpyinfo
->mouse_face_window
= Qnil
;
1349 /* Find the glyph matrix position of buffer position POS in window W.
1350 *HPOS and *VPOS are set to the positions found. W's current glyphs
1351 must be up to date. If POS is above window start return (0, 0).
1352 If POS is after end of W, return end of last line in W. */
1354 fast_find_position (struct window
*w
, int pos
, int *hpos
, int *vpos
)
1358 int maybe_next_line_p
= 0;
1359 int line_start_position
;
1360 int yb
= window_text_bottom_y (w
);
1361 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
1362 struct glyph_row
*best_row
= row
;
1366 if (row
->used
[TEXT_AREA
])
1367 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
1369 line_start_position
= 0;
1371 if (line_start_position
> pos
)
1373 /* If the position sought is the end of the buffer,
1374 don't include the blank lines at the bottom of the window. */
1375 else if (line_start_position
== pos
1376 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
1378 maybe_next_line_p
= 1;
1381 else if (line_start_position
> 0)
1384 /* Don't overstep the last matrix row, lest we get into the
1385 never-never land... */
1386 if (row
->y
+ 1 >= yb
)
1392 /* Find the right column within BEST_ROW. */
1395 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
1397 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + i
;
1400 charpos
= glyph
->charpos
;
1407 else if (charpos
> pos
)
1409 else if (charpos
> 0)
1413 /* If we're looking for the end of the buffer,
1414 and we didn't find it in the line we scanned,
1415 use the start of the following line. */
1416 if (maybe_next_line_p
)
1423 *hpos
= lastcol
+ 1;
1427 /* Take proper action when mouse has moved to the mode or top line of
1428 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
1429 mode line. X is relative to the start of the text display area of
1430 W, so the width of fringes and scroll bars must be subtracted
1431 to get a position relative to the start of the mode line. */
1433 IT_note_mode_line_highlight (struct window
*w
, int x
, int mode_line_p
)
1435 struct frame
*f
= XFRAME (w
->frame
);
1436 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1437 struct glyph_row
*row
;
1440 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1442 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1446 extern Lisp_Object Qhelp_echo
;
1447 struct glyph
*glyph
, *end
;
1448 Lisp_Object help
, map
;
1450 /* Find the glyph under X. */
1451 glyph
= row
->glyphs
[TEXT_AREA
]
1452 + x
- FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
1453 end
= glyph
+ row
->used
[TEXT_AREA
];
1455 && STRINGP (glyph
->object
)
1456 && XSTRING (glyph
->object
)->intervals
1457 && glyph
->charpos
>= 0
1458 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1460 /* If we're on a string with `help-echo' text property,
1461 arrange for the help to be displayed. This is done by
1462 setting the global variable help_echo to the help string. */
1463 help
= Fget_text_property (make_number (glyph
->charpos
),
1464 Qhelp_echo
, glyph
->object
);
1468 XSETWINDOW (help_echo_window
, w
);
1469 help_echo_object
= glyph
->object
;
1470 help_echo_pos
= glyph
->charpos
;
1476 /* Take proper action when the mouse has moved to position X, Y on
1477 frame F as regards highlighting characters that have mouse-face
1478 properties. Also de-highlighting chars where the mouse was before.
1479 X and Y can be negative or out of range. */
1481 IT_note_mouse_highlight (struct frame
*f
, int x
, int y
)
1483 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1488 /* When a menu is active, don't highlight because this looks odd. */
1489 if (mouse_preempted
)
1492 if (disable_mouse_highlight
1493 || !f
->glyphs_initialized_p
)
1496 dpyinfo
->mouse_face_mouse_x
= x
;
1497 dpyinfo
->mouse_face_mouse_y
= y
;
1498 dpyinfo
->mouse_face_mouse_frame
= f
;
1500 if (dpyinfo
->mouse_face_defer
)
1505 dpyinfo
->mouse_face_deferred_gc
= 1;
1509 /* Which window is that in? */
1510 window
= window_from_coordinates (f
, x
, y
, &portion
, 0);
1512 /* If we were displaying active text in another window, clear that. */
1513 if (! EQ (window
, dpyinfo
->mouse_face_window
))
1514 clear_mouse_face (dpyinfo
);
1516 /* Not on a window -> return. */
1517 if (!WINDOWP (window
))
1520 /* Convert to window-relative coordinates. */
1521 w
= XWINDOW (window
);
1522 x
-= WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1523 y
-= WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1525 if (portion
== 1 || portion
== 3)
1527 /* Mouse is on the mode or top line. */
1528 IT_note_mode_line_highlight (w
, x
, portion
== 1);
1532 IT_set_mouse_pointer (0);
1534 /* Are we in a window whose display is up to date?
1535 And verify the buffer's text has not changed. */
1536 if (/* Within text portion of the window. */
1538 && EQ (w
->window_end_valid
, w
->buffer
)
1539 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
1540 && (XFASTINT (w
->last_overlay_modified
)
1541 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
1544 struct glyph_row
*row
;
1545 struct glyph
*glyph
;
1546 int nrows
= w
->current_matrix
->nrows
;
1548 /* Find the glyph under X/Y. */
1550 if (y
>= 0 && y
< nrows
)
1552 row
= MATRIX_ROW (w
->current_matrix
, y
);
1553 /* Give up if some row before the one we are looking for is
1555 for (i
= 0; i
<= y
; i
++)
1556 if (!MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
)
1558 if (i
> y
/* all rows upto and including the one at Y are enabled */
1559 && row
->displays_text_p
1560 && x
< window_box_width (w
, TEXT_AREA
))
1562 glyph
= row
->glyphs
[TEXT_AREA
];
1563 if (x
>= row
->used
[TEXT_AREA
])
1568 if (!BUFFERP (glyph
->object
))
1574 /* Clear mouse face if X/Y not over text. */
1577 clear_mouse_face (dpyinfo
);
1581 if (!BUFFERP (glyph
->object
))
1583 pos
= glyph
->charpos
;
1585 /* Check for mouse-face and help-echo. */
1587 extern Lisp_Object Qmouse_face
;
1588 Lisp_Object mouse_face
, overlay
, position
;
1589 Lisp_Object
*overlay_vec
;
1591 struct buffer
*obuf
;
1594 /* If we get an out-of-range value, return now; avoid an error. */
1595 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1598 /* Make the window's buffer temporarily current for
1599 overlays_at and compute_char_face. */
1600 obuf
= current_buffer
;
1601 current_buffer
= XBUFFER (w
->buffer
);
1607 /* Is this char mouse-active or does it have help-echo? */
1608 XSETINT (position
, pos
);
1610 /* Put all the overlays we want in a vector in overlay_vec.
1611 Store the length in len. If there are more than 10, make
1612 enough space for all, and try again. */
1614 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1615 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
1616 if (noverlays
> len
)
1619 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1620 noverlays
= overlays_at (pos
,
1621 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
1624 /* Sort overlays into increasing priority order. */
1625 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1627 /* Check mouse-face highlighting. */
1628 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
1629 && y
>= dpyinfo
->mouse_face_beg_row
1630 && y
<= dpyinfo
->mouse_face_end_row
1631 && (y
> dpyinfo
->mouse_face_beg_row
1632 || x
>= dpyinfo
->mouse_face_beg_col
)
1633 && (y
< dpyinfo
->mouse_face_end_row
1634 || x
< dpyinfo
->mouse_face_end_col
1635 || dpyinfo
->mouse_face_past_end
)))
1637 /* Clear the display of the old active region, if any. */
1638 clear_mouse_face (dpyinfo
);
1640 /* Find highest priority overlay that has a mouse-face prop. */
1642 for (i
= noverlays
- 1; i
>= 0; --i
)
1644 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1645 if (!NILP (mouse_face
))
1647 overlay
= overlay_vec
[i
];
1652 /* If no overlay applies, get a text property. */
1654 mouse_face
= Fget_text_property (position
, Qmouse_face
,
1657 /* Handle the overlay case. */
1658 if (! NILP (overlay
))
1660 /* Find the range of text around this char that
1661 should be active. */
1662 Lisp_Object before
, after
;
1665 before
= Foverlay_start (overlay
);
1666 after
= Foverlay_end (overlay
);
1667 /* Record this as the current active region. */
1668 fast_find_position (w
, XFASTINT (before
),
1669 &dpyinfo
->mouse_face_beg_col
,
1670 &dpyinfo
->mouse_face_beg_row
);
1671 dpyinfo
->mouse_face_past_end
1672 = !fast_find_position (w
, XFASTINT (after
),
1673 &dpyinfo
->mouse_face_end_col
,
1674 &dpyinfo
->mouse_face_end_row
);
1675 dpyinfo
->mouse_face_window
= window
;
1676 dpyinfo
->mouse_face_face_id
1677 = face_at_buffer_position (w
, pos
, 0, 0,
1678 &ignore
, pos
+ 1, 1);
1680 /* Display it as active. */
1681 show_mouse_face (dpyinfo
, 1);
1683 /* Handle the text property case. */
1684 else if (! NILP (mouse_face
))
1686 /* Find the range of text around this char that
1687 should be active. */
1688 Lisp_Object before
, after
, beginning
, end
;
1691 beginning
= Fmarker_position (w
->start
);
1692 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
1693 - XFASTINT (w
->window_end_pos
)));
1695 = Fprevious_single_property_change (make_number (pos
+ 1),
1697 w
->buffer
, beginning
);
1699 = Fnext_single_property_change (position
, Qmouse_face
,
1701 /* Record this as the current active region. */
1702 fast_find_position (w
, XFASTINT (before
),
1703 &dpyinfo
->mouse_face_beg_col
,
1704 &dpyinfo
->mouse_face_beg_row
);
1705 dpyinfo
->mouse_face_past_end
1706 = !fast_find_position (w
, XFASTINT (after
),
1707 &dpyinfo
->mouse_face_end_col
,
1708 &dpyinfo
->mouse_face_end_row
);
1709 dpyinfo
->mouse_face_window
= window
;
1710 dpyinfo
->mouse_face_face_id
1711 = face_at_buffer_position (w
, pos
, 0, 0,
1712 &ignore
, pos
+ 1, 1);
1714 /* Display it as active. */
1715 show_mouse_face (dpyinfo
, 1);
1719 /* Look for a `help-echo' property. */
1722 extern Lisp_Object Qhelp_echo
;
1724 /* Check overlays first. */
1726 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
1728 overlay
= overlay_vec
[i
];
1729 help
= Foverlay_get (overlay
, Qhelp_echo
);
1735 help_echo_window
= window
;
1736 help_echo_object
= overlay
;
1737 help_echo_pos
= pos
;
1739 /* Try text properties. */
1740 else if (NILP (help
)
1741 && ((STRINGP (glyph
->object
)
1742 && glyph
->charpos
>= 0
1743 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1744 || (BUFFERP (glyph
->object
)
1745 && glyph
->charpos
>= BEGV
1746 && glyph
->charpos
< ZV
)))
1748 help
= Fget_text_property (make_number (glyph
->charpos
),
1749 Qhelp_echo
, glyph
->object
);
1753 help_echo_window
= window
;
1754 help_echo_object
= glyph
->object
;
1755 help_echo_pos
= glyph
->charpos
;
1762 current_buffer
= obuf
;
1768 IT_clear_end_of_line (int first_unused
)
1772 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
1773 extern int fatal_error_in_progress
;
1775 if (new_pos_X
>= first_unused
|| fatal_error_in_progress
)
1779 i
= (j
= first_unused
- new_pos_X
) * 2;
1781 fprintf (termscript
, "<CLR:EOL[%d..%d)>", new_pos_X
, first_unused
);
1782 spaces
= sp
= alloca (i
);
1787 *sp
++ = ScreenAttrib
;
1791 dosmemput (spaces
, i
, (int)ScreenPrimary
+ offset
);
1792 if (screen_virtual_segment
)
1793 dosv_refresh_virtual_screen (offset
, i
/ 2);
1795 /* clear_end_of_line_raw on term.c leaves the cursor at first_unused.
1796 Let's follow their lead, in case someone relies on this. */
1797 new_pos_X
= first_unused
;
1801 IT_clear_screen (void)
1804 fprintf (termscript
, "<CLR:SCR>");
1805 /* We are sometimes called (from clear_garbaged_frames) when a new
1806 frame is being created, but its faces are not yet realized. In
1807 such a case we cannot call IT_set_face, since it will fail to find
1808 any valid faces and will abort. Instead, use the initial screen
1809 colors; that should mimic what a Unix tty does, which simply clears
1810 the screen with whatever default colors are in use. */
1811 if (FACE_FROM_ID (SELECTED_FRAME (), DEFAULT_FACE_ID
) == NULL
)
1812 ScreenAttrib
= (initial_screen_colors
[0] << 4) | initial_screen_colors
[1];
1817 if (screen_virtual_segment
)
1818 dosv_refresh_virtual_screen (0, screen_size
);
1819 new_pos_X
= new_pos_Y
= 0;
1823 IT_clear_to_end (void)
1826 fprintf (termscript
, "<CLR:EOS>");
1828 while (new_pos_Y
< screen_size_Y
) {
1830 IT_clear_end_of_line (screen_size_X
);
1836 IT_cursor_to (int y
, int x
)
1839 fprintf (termscript
, "\n<XY=%dx%d>", x
, y
);
1844 static int cursor_cleared
;
1847 IT_display_cursor (int on
)
1849 if (on
&& cursor_cleared
)
1851 ScreenSetCursor (current_pos_Y
, current_pos_X
);
1854 else if (!on
&& !cursor_cleared
)
1856 ScreenSetCursor (-1, -1);
1861 /* Emacs calls cursor-movement functions a lot when it updates the
1862 display (probably a legacy of old terminals where you cannot
1863 update a screen line without first moving the cursor there).
1864 However, cursor movement is expensive on MSDOS (it calls a slow
1865 BIOS function and requires 2 mode switches), while actual screen
1866 updates access the video memory directly and don't depend on
1867 cursor position. To avoid slowing down the redisplay, we cheat:
1868 all functions that move the cursor only set internal variables
1869 which record the cursor position, whereas the cursor is only
1870 moved to its final position whenever screen update is complete.
1872 `IT_cmgoto' is called from the keyboard reading loop and when the
1873 frame update is complete. This means that we are ready for user
1874 input, so we update the cursor position to show where the point is,
1875 and also make the mouse pointer visible.
1877 Special treatment is required when the cursor is in the echo area,
1878 to put the cursor at the end of the text displayed there. */
1881 IT_cmgoto (FRAME_PTR f
)
1883 /* Only set the cursor to where it should be if the display is
1884 already in sync with the window contents. */
1885 int update_cursor_pos
= 1; /* MODIFF == unchanged_modified; */
1887 /* FIXME: This needs to be rewritten for the new redisplay, or
1890 static int previous_pos_X
= -1;
1892 update_cursor_pos
= 1; /* temporary!!! */
1894 /* If the display is in sync, forget any previous knowledge about
1895 cursor position. This is primarily for unexpected events like
1896 C-g in the minibuffer. */
1897 if (update_cursor_pos
&& previous_pos_X
>= 0)
1898 previous_pos_X
= -1;
1899 /* If we are in the echo area, put the cursor at the
1900 end of the echo area message. */
1901 if (!update_cursor_pos
1902 && XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
) <= new_pos_Y
)
1904 int tem_X
= current_pos_X
, dummy
;
1906 if (echo_area_glyphs
)
1908 tem_X
= echo_area_glyphs_length
;
1909 /* Save current cursor position, to be restored after the
1910 echo area message is erased. Only remember one level
1911 of previous cursor position. */
1912 if (previous_pos_X
== -1)
1913 ScreenGetCursor (&dummy
, &previous_pos_X
);
1915 else if (previous_pos_X
>= 0)
1917 /* We wind up here after the echo area message is erased.
1918 Restore the cursor position we remembered above. */
1919 tem_X
= previous_pos_X
;
1920 previous_pos_X
= -1;
1923 if (current_pos_X
!= tem_X
)
1926 update_cursor_pos
= 1;
1931 if (update_cursor_pos
1932 && (current_pos_X
!= new_pos_X
|| current_pos_Y
!= new_pos_Y
))
1934 ScreenSetCursor (current_pos_Y
= new_pos_Y
, current_pos_X
= new_pos_X
);
1936 fprintf (termscript
, "\n<CURSOR:%dx%d>", current_pos_X
, current_pos_Y
);
1939 /* Maybe cursor is invisible, so make it visible. */
1940 IT_display_cursor (1);
1942 /* Mouse pointer should be always visible if we are waiting for
1949 IT_update_begin (struct frame
*f
)
1951 struct display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
1952 struct frame
*mouse_face_frame
= display_info
->mouse_face_mouse_frame
;
1956 if (f
&& f
== mouse_face_frame
)
1958 /* Don't do highlighting for mouse motion during the update. */
1959 display_info
->mouse_face_defer
= 1;
1961 /* If F needs to be redrawn, simply forget about any prior mouse
1963 if (FRAME_GARBAGED_P (f
))
1964 display_info
->mouse_face_window
= Qnil
;
1966 /* Can we tell that this update does not affect the window
1967 where the mouse highlight is? If so, no need to turn off.
1968 Likewise, don't do anything if none of the enabled rows
1969 contains glyphs highlighted in mouse face. */
1970 if (!NILP (display_info
->mouse_face_window
)
1971 && WINDOWP (display_info
->mouse_face_window
))
1973 struct window
*w
= XWINDOW (display_info
->mouse_face_window
);
1976 /* If the mouse highlight is in the window that was deleted
1977 (e.g., if it was popped by completion), clear highlight
1979 if (NILP (w
->buffer
))
1980 display_info
->mouse_face_window
= Qnil
;
1983 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
1984 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
)
1985 && MATRIX_ROW (w
->current_matrix
, i
)->mouse_face_p
)
1989 if (NILP (w
->buffer
) || i
< w
->desired_matrix
->nrows
)
1990 clear_mouse_face (display_info
);
1993 else if (mouse_face_frame
&& !FRAME_LIVE_P (mouse_face_frame
))
1995 /* If the frame with mouse highlight was deleted, invalidate the
1997 display_info
->mouse_face_beg_row
= display_info
->mouse_face_beg_col
= -1;
1998 display_info
->mouse_face_end_row
= display_info
->mouse_face_end_col
= -1;
1999 display_info
->mouse_face_window
= Qnil
;
2000 display_info
->mouse_face_deferred_gc
= 0;
2001 display_info
->mouse_face_mouse_frame
= NULL
;
2008 IT_update_end (struct frame
*f
)
2010 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
2013 Lisp_Object Qcursor_type
;
2016 IT_frame_up_to_date (struct frame
*f
)
2018 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2019 Lisp_Object new_cursor
, frame_desired_cursor
;
2022 if (dpyinfo
->mouse_face_deferred_gc
2023 || (f
&& f
== dpyinfo
->mouse_face_mouse_frame
))
2026 if (dpyinfo
->mouse_face_mouse_frame
)
2027 IT_note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
2028 dpyinfo
->mouse_face_mouse_x
,
2029 dpyinfo
->mouse_face_mouse_y
);
2030 dpyinfo
->mouse_face_deferred_gc
= 0;
2034 /* Set the cursor type to whatever they wanted. In a minibuffer
2035 window, we want the cursor to appear only if we are reading input
2036 from this window, and we want the cursor to be taken from the
2037 frame parameters. For the selected window, we use either its
2038 buffer-local value or the value from the frame parameters if the
2039 buffer doesn't define its local value for the cursor type. */
2040 sw
= XWINDOW (f
->selected_window
);
2041 frame_desired_cursor
= Fcdr (Fassq (Qcursor_type
, f
->param_alist
));
2042 if (cursor_in_echo_area
2043 && FRAME_HAS_MINIBUF_P (f
)
2044 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
)
2045 && sw
== XWINDOW (echo_area_window
))
2046 new_cursor
= frame_desired_cursor
;
2049 struct buffer
*b
= XBUFFER (sw
->buffer
);
2051 if (EQ (b
->cursor_type
, Qt
))
2052 new_cursor
= frame_desired_cursor
;
2053 else if (NILP (b
->cursor_type
)) /* nil means no cursor */
2054 new_cursor
= Fcons (Qbar
, make_number (0));
2056 new_cursor
= b
->cursor_type
;
2059 IT_set_cursor_type (f
, new_cursor
);
2061 IT_cmgoto (f
); /* position cursor when update is done */
2064 /* Copy LEN glyphs displayed on a single line whose vertical position
2065 is YPOS, beginning at horizontal position XFROM to horizontal
2066 position XTO, by moving blocks in the video memory. Used by
2067 functions that insert and delete glyphs. */
2069 IT_copy_glyphs (int xfrom
, int xto
, size_t len
, int ypos
)
2071 /* The offsets of source and destination relative to the
2072 conventional memorty selector. */
2073 int from
= 2 * (xfrom
+ screen_size_X
* ypos
) + ScreenPrimary
;
2074 int to
= 2 * (xto
+ screen_size_X
* ypos
) + ScreenPrimary
;
2076 if (from
== to
|| len
<= 0)
2079 _farsetsel (_dos_ds
);
2081 /* The source and destination might overlap, so we need to move
2082 glyphs non-destructively. */
2085 for ( ; len
; from
+= 2, to
+= 2, len
--)
2086 _farnspokew (to
, _farnspeekw (from
));
2090 from
+= (len
- 1) * 2;
2091 to
+= (len
- 1) * 2;
2092 for ( ; len
; from
-= 2, to
-= 2, len
--)
2093 _farnspokew (to
, _farnspeekw (from
));
2095 if (screen_virtual_segment
)
2096 dosv_refresh_virtual_screen (ypos
* screen_size_X
* 2, screen_size_X
);
2099 /* Insert and delete glyphs. */
2101 IT_insert_glyphs (start
, len
)
2102 register struct glyph
*start
;
2105 int shift_by_width
= screen_size_X
- (new_pos_X
+ len
);
2107 /* Shift right the glyphs from the nominal cursor position to the
2108 end of this line. */
2109 IT_copy_glyphs (new_pos_X
, new_pos_X
+ len
, shift_by_width
, new_pos_Y
);
2111 /* Now write the glyphs to be inserted. */
2112 IT_write_glyphs (start
, len
);
2116 IT_delete_glyphs (n
)
2122 /* set-window-configuration on window.c needs this. */
2124 x_set_menu_bar_lines (f
, value
, oldval
)
2126 Lisp_Object value
, oldval
;
2128 set_menu_bar_lines (f
, value
, oldval
);
2131 /* This was copied from xfaces.c */
2133 extern Lisp_Object Qbackground_color
;
2134 extern Lisp_Object Qforeground_color
;
2135 Lisp_Object Qreverse
;
2136 extern Lisp_Object Qtitle
;
2138 /* IT_set_terminal_modes is called when emacs is started,
2139 resumed, and whenever the screen is redrawn! */
2142 IT_set_terminal_modes (void)
2145 fprintf (termscript
, "\n<SET_TERM>");
2147 screen_size_X
= ScreenCols ();
2148 screen_size_Y
= ScreenRows ();
2149 screen_size
= screen_size_X
* screen_size_Y
;
2151 new_pos_X
= new_pos_Y
= 0;
2152 current_pos_X
= current_pos_Y
= -1;
2154 if (term_setup_done
)
2156 term_setup_done
= 1;
2158 startup_screen_size_X
= screen_size_X
;
2159 startup_screen_size_Y
= screen_size_Y
;
2160 startup_screen_attrib
= ScreenAttrib
;
2163 /* Is DOS/V (or any other RSIS software which relocates
2164 the screen) installed? */
2166 unsigned short es_value
;
2169 regs
.h
.ah
= 0xfe; /* get relocated screen address */
2170 if (ScreenPrimary
== 0xb0000UL
|| ScreenPrimary
== 0xb8000UL
)
2171 regs
.x
.es
= (ScreenPrimary
>> 4) & 0xffff;
2172 else if (screen_old_address
) /* already switched to Japanese mode once */
2173 regs
.x
.es
= (screen_old_address
>> 4) & 0xffff;
2175 regs
.x
.es
= ScreenMode () == 7 ? 0xb000 : 0xb800;
2177 es_value
= regs
.x
.es
;
2178 __dpmi_int (0x10, ®s
);
2180 if (regs
.x
.es
!= es_value
)
2182 /* screen_old_address is only set if ScreenPrimary does NOT
2183 already point to the relocated buffer address returned by
2184 the Int 10h/AX=FEh call above. DJGPP v2.02 and later sets
2185 ScreenPrimary to that address at startup under DOS/V. */
2186 if (regs
.x
.es
!= (ScreenPrimary
>> 4) & 0xffff)
2187 screen_old_address
= ScreenPrimary
;
2188 screen_virtual_segment
= regs
.x
.es
;
2189 screen_virtual_offset
= regs
.x
.di
;
2190 ScreenPrimary
= (screen_virtual_segment
<< 4) + screen_virtual_offset
;
2193 #endif /* __DJGPP__ > 1 */
2195 ScreenGetCursor (&startup_pos_Y
, &startup_pos_X
);
2196 ScreenRetrieve (startup_screen_buffer
= xmalloc (screen_size
* 2));
2199 fprintf (termscript
, "<SCREEN SAVED (dimensions=%dx%d)>\n",
2200 screen_size_X
, screen_size_Y
);
2205 /* IT_reset_terminal_modes is called when emacs is
2206 suspended or killed. */
2209 IT_reset_terminal_modes (void)
2211 int display_row_start
= (int) ScreenPrimary
;
2212 int saved_row_len
= startup_screen_size_X
* 2;
2213 int update_row_len
= ScreenCols () * 2;
2214 int current_rows
= ScreenRows ();
2215 int to_next_row
= update_row_len
;
2216 unsigned char *saved_row
= startup_screen_buffer
;
2217 int cursor_pos_X
= ScreenCols () - 1;
2218 int cursor_pos_Y
= ScreenRows () - 1;
2221 fprintf (termscript
, "\n<RESET_TERM>");
2223 if (!term_setup_done
)
2228 /* Leave the video system in the same state as we found it,
2229 as far as the blink/bright-background bit is concerned. */
2230 maybe_enable_blinking ();
2232 /* We have a situation here.
2233 We cannot just do ScreenUpdate(startup_screen_buffer) because
2234 the luser could have changed screen dimensions inside Emacs
2235 and failed (or didn't want) to restore them before killing
2236 Emacs. ScreenUpdate() uses the *current* screen dimensions and
2237 thus will happily use memory outside what was allocated for
2238 `startup_screen_buffer'.
2239 Thus we only restore as much as the current screen dimensions
2240 can hold, and clear the rest (if the saved screen is smaller than
2241 the current) with the color attribute saved at startup. The cursor
2242 is also restored within the visible dimensions. */
2244 ScreenAttrib
= startup_screen_attrib
;
2246 /* Don't restore the screen if we are exiting less than 2 seconds
2247 after startup: we might be crashing, and the screen might show
2248 some vital clues to what's wrong. */
2249 if (clock () - startup_time
>= 2*CLOCKS_PER_SEC
)
2252 if (screen_virtual_segment
)
2253 dosv_refresh_virtual_screen (0, screen_size
);
2255 if (update_row_len
> saved_row_len
)
2256 update_row_len
= saved_row_len
;
2257 if (current_rows
> startup_screen_size_Y
)
2258 current_rows
= startup_screen_size_Y
;
2261 fprintf (termscript
, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
2262 update_row_len
/ 2, current_rows
);
2264 while (current_rows
--)
2266 dosmemput (saved_row
, update_row_len
, display_row_start
);
2267 if (screen_virtual_segment
)
2268 dosv_refresh_virtual_screen (display_row_start
- ScreenPrimary
,
2269 update_row_len
/ 2);
2270 saved_row
+= saved_row_len
;
2271 display_row_start
+= to_next_row
;
2274 if (startup_pos_X
< cursor_pos_X
)
2275 cursor_pos_X
= startup_pos_X
;
2276 if (startup_pos_Y
< cursor_pos_Y
)
2277 cursor_pos_Y
= startup_pos_Y
;
2279 ScreenSetCursor (cursor_pos_Y
, cursor_pos_X
);
2280 xfree (startup_screen_buffer
);
2282 term_setup_done
= 0;
2286 IT_set_terminal_window (int foo
)
2290 /* Remember the screen colors of the curent frame, to serve as the
2291 default colors for newly-created frames. */
2292 DEFUN ("msdos-remember-default-colors", Fmsdos_remember_default_colors
,
2293 Smsdos_remember_default_colors
, 1, 1, 0,
2294 doc
: /* Remember the screen colors of the current frame. */)
2300 CHECK_FRAME (frame
);
2303 /* This function is called after applying default-frame-alist to the
2304 initial frame. At that time, if reverse-colors option was
2305 specified in default-frame-alist, it was already applied, and
2306 frame colors are reversed. We need to account for that. */
2307 if (EQ (Fcdr (Fassq (Qreverse
, f
->param_alist
)), Qt
))
2309 initial_screen_colors
[0] = FRAME_BACKGROUND_PIXEL (f
);
2310 initial_screen_colors
[1] = FRAME_FOREGROUND_PIXEL (f
);
2314 initial_screen_colors
[0] = FRAME_FOREGROUND_PIXEL (f
);
2315 initial_screen_colors
[1] = FRAME_BACKGROUND_PIXEL (f
);
2320 IT_set_frame_parameters (f
, alist
)
2325 int length
= XINT (Flength (alist
));
2328 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2330 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2331 /* Do we have to reverse the foreground and background colors? */
2332 int reverse
= EQ (Fcdr (Fassq (Qreverse
, f
->param_alist
)), Qt
);
2333 int was_reverse
= reverse
;
2334 int redraw
= 0, fg_set
= 0, bg_set
= 0;
2335 int need_to_reverse
;
2336 unsigned long orig_fg
;
2337 unsigned long orig_bg
;
2338 Lisp_Object frame_bg
, frame_fg
;
2339 extern Lisp_Object Qdefault
, QCforeground
, QCbackground
;
2341 /* If we are creating a new frame, begin with the original screen colors
2342 used for the initial frame. */
2343 if (alist
== Vdefault_frame_alist
2344 && initial_screen_colors
[0] != -1 && initial_screen_colors
[1] != -1)
2346 FRAME_FOREGROUND_PIXEL (f
) = initial_screen_colors
[0];
2347 FRAME_BACKGROUND_PIXEL (f
) = initial_screen_colors
[1];
2349 orig_fg
= FRAME_FOREGROUND_PIXEL (f
);
2350 orig_bg
= FRAME_BACKGROUND_PIXEL (f
);
2351 frame_fg
= Fcdr (Fassq (Qforeground_color
, f
->param_alist
));
2352 frame_bg
= Fcdr (Fassq (Qbackground_color
, f
->param_alist
));
2353 /* frame_fg and frame_bg could be nil if, for example,
2354 f->param_alist is nil, e.g. if we are called from
2355 Fmake_terminal_frame. */
2356 if (NILP (frame_fg
))
2357 frame_fg
= build_string (unspecified_fg
);
2358 if (NILP (frame_bg
))
2359 frame_bg
= build_string (unspecified_bg
);
2361 /* Extract parm names and values into those vectors. */
2363 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2368 parms
[i
] = Fcar (elt
);
2369 CHECK_SYMBOL (parms
[i
]);
2370 values
[i
] = Fcdr (elt
);
2376 for (i
= 0; i
< j
; i
++)
2378 Lisp_Object prop
, val
;
2383 if (EQ (prop
, Qreverse
))
2384 reverse
= EQ (val
, Qt
);
2387 need_to_reverse
= reverse
&& !was_reverse
;
2388 if (termscript
&& need_to_reverse
)
2389 fprintf (termscript
, "<INVERSE-VIDEO>\n");
2391 /* Now process the alist elements in reverse of specified order. */
2392 for (i
--; i
>= 0; i
--)
2394 Lisp_Object prop
, val
;
2400 if (EQ (prop
, Qforeground_color
))
2402 unsigned long new_color
= load_color (f
, NULL
, val
, need_to_reverse
2403 ? LFACE_BACKGROUND_INDEX
2404 : LFACE_FOREGROUND_INDEX
);
2405 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2406 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2407 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2409 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2410 /* Make sure the foreground of the default face for this
2411 frame is changed as well. */
2412 XSETFRAME (frame
, f
);
2413 if (need_to_reverse
)
2415 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2417 prop
= Qbackground_color
;
2422 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2428 fprintf (termscript
, "<FGCOLOR %lu>\n", new_color
);
2431 else if (EQ (prop
, Qbackground_color
))
2433 unsigned long new_color
= load_color (f
, NULL
, val
, need_to_reverse
2434 ? LFACE_FOREGROUND_INDEX
2435 : LFACE_BACKGROUND_INDEX
);
2436 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2437 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2438 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2440 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2441 /* Make sure the background of the default face for this
2442 frame is changed as well. */
2443 XSETFRAME (frame
, f
);
2444 if (need_to_reverse
)
2446 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2448 prop
= Qforeground_color
;
2453 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2459 fprintf (termscript
, "<BGCOLOR %lu>\n", new_color
);
2462 else if (EQ (prop
, Qtitle
))
2464 x_set_title (f
, val
);
2466 fprintf (termscript
, "<TITLE: %s>\n", XSTRING (val
)->data
);
2468 else if (EQ (prop
, Qcursor_type
))
2470 IT_set_cursor_type (f
, val
);
2472 fprintf (termscript
, "<CTYPE: %s>\n",
2473 EQ (val
, Qbar
) || CONSP (val
) && EQ (XCAR (val
), Qbar
)
2476 store_frame_param (f
, prop
, val
);
2479 /* If they specified "reverse", but not the colors, we need to swap
2480 the current frame colors. */
2481 if (need_to_reverse
)
2487 XSETFRAME (frame
, f
);
2488 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2489 tty_color_name (f
, orig_bg
),
2495 XSETFRAME (frame
, f
);
2496 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2497 tty_color_name (f
, orig_fg
),
2505 face_change_count
++; /* forces xdisp.c to recompute basic faces */
2506 if (f
== SELECTED_FRAME())
2511 extern void init_frame_faces (FRAME_PTR
);
2513 #endif /* !HAVE_X_WINDOWS */
2516 /* Do we need the internal terminal? */
2519 internal_terminal_init ()
2521 char *term
= getenv ("TERM");
2523 struct frame
*sf
= SELECTED_FRAME();
2525 #ifdef HAVE_X_WINDOWS
2526 if (!inhibit_window_system
)
2531 = (!noninteractive
) && term
&& !strcmp (term
, "internal");
2533 if (getenv ("EMACSTEST"))
2534 termscript
= fopen (getenv ("EMACSTEST"), "wt");
2536 #ifndef HAVE_X_WINDOWS
2537 if (!internal_terminal
|| inhibit_window_system
)
2539 sf
->output_method
= output_termcap
;
2543 Vwindow_system
= intern ("pc");
2544 Vwindow_system_version
= make_number (1);
2545 sf
->output_method
= output_msdos_raw
;
2547 /* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
2548 screen_old_address
= 0;
2550 /* Forget the stale screen colors as well. */
2551 initial_screen_colors
[0] = initial_screen_colors
[1] = -1;
2553 bzero (&the_only_x_display
, sizeof the_only_x_display
);
2554 the_only_x_display
.background_pixel
= 7; /* White */
2555 the_only_x_display
.foreground_pixel
= 0; /* Black */
2557 colors
= getenv ("EMACSCOLORS");
2558 if (colors
&& strlen (colors
) >= 2)
2560 /* The colors use 4 bits each (we enable bright background). */
2561 if (isdigit (colors
[0]))
2563 else if (isxdigit (colors
[0]))
2564 colors
[0] -= (isupper (colors
[0]) ? 'A' : 'a') - 10;
2565 if (colors
[0] >= 0 && colors
[0] < 16)
2566 the_only_x_display
.foreground_pixel
= colors
[0];
2567 if (isdigit (colors
[1]))
2569 else if (isxdigit (colors
[1]))
2570 colors
[1] -= (isupper (colors
[1]) ? 'A' : 'a') - 10;
2571 if (colors
[1] >= 0 && colors
[1] < 16)
2572 the_only_x_display
.background_pixel
= colors
[1];
2574 the_only_x_display
.line_height
= 1;
2575 the_only_x_display
.font
= (XFontStruct
*)1; /* must *not* be zero */
2576 the_only_x_display
.display_info
.mouse_face_mouse_frame
= NULL
;
2577 the_only_x_display
.display_info
.mouse_face_deferred_gc
= 0;
2578 the_only_x_display
.display_info
.mouse_face_beg_row
=
2579 the_only_x_display
.display_info
.mouse_face_beg_col
= -1;
2580 the_only_x_display
.display_info
.mouse_face_end_row
=
2581 the_only_x_display
.display_info
.mouse_face_end_col
= -1;
2582 the_only_x_display
.display_info
.mouse_face_face_id
= DEFAULT_FACE_ID
;
2583 the_only_x_display
.display_info
.mouse_face_window
= Qnil
;
2584 the_only_x_display
.display_info
.mouse_face_mouse_x
=
2585 the_only_x_display
.display_info
.mouse_face_mouse_y
= 0;
2586 the_only_x_display
.display_info
.mouse_face_defer
= 0;
2588 init_frame_faces (sf
);
2590 ring_bell_hook
= IT_ring_bell
;
2591 insert_glyphs_hook
= IT_insert_glyphs
;
2592 delete_glyphs_hook
= IT_delete_glyphs
;
2593 write_glyphs_hook
= IT_write_glyphs
;
2594 cursor_to_hook
= raw_cursor_to_hook
= IT_cursor_to
;
2595 clear_to_end_hook
= IT_clear_to_end
;
2596 clear_end_of_line_hook
= IT_clear_end_of_line
;
2597 clear_frame_hook
= IT_clear_screen
;
2598 update_begin_hook
= IT_update_begin
;
2599 update_end_hook
= IT_update_end
;
2600 frame_up_to_date_hook
= IT_frame_up_to_date
;
2602 /* These hooks are called by term.c without being checked. */
2603 set_terminal_modes_hook
= IT_set_terminal_modes
;
2604 reset_terminal_modes_hook
= IT_reset_terminal_modes
;
2605 set_terminal_window_hook
= IT_set_terminal_window
;
2606 char_ins_del_ok
= 0;
2610 dos_get_saved_screen (screen
, rows
, cols
)
2615 #ifndef HAVE_X_WINDOWS
2616 *screen
= startup_screen_buffer
;
2617 *cols
= startup_screen_size_X
;
2618 *rows
= startup_screen_size_Y
;
2619 return *screen
!= (char *)0;
2625 #ifndef HAVE_X_WINDOWS
2627 /* We are not X, but we can emulate it well enough for our needs... */
2631 if (! FRAME_MSDOS_P (SELECTED_FRAME()))
2632 error ("Not running under a window system");
2638 /* ----------------------- Keyboard control ----------------------
2640 * Keymaps reflect the following keyboard layout:
2642 * 0 1 2 3 4 5 6 7 8 9 10 11 12 BS
2643 * TAB 15 16 17 18 19 20 21 22 23 24 25 26 (41)
2644 * CLOK 30 31 32 33 34 35 36 37 38 39 40 (41) RET
2645 * SH () 45 46 47 48 49 50 51 52 53 54 SHIFT
2649 #define Ignore 0x0000
2650 #define Normal 0x0000 /* normal key - alt changes scan-code */
2651 #define FctKey 0x1000 /* func key if c == 0, else c */
2652 #define Special 0x2000 /* func key even if c != 0 */
2653 #define ModFct 0x3000 /* special if mod-keys, else 'c' */
2654 #define Map 0x4000 /* alt scan-code, map to unshift/shift key */
2655 #define KeyPad 0x5000 /* map to insert/kp-0 depending on c == 0xe0 */
2656 #define Grey 0x6000 /* Grey keypad key */
2658 #define Alt 0x0100 /* alt scan-code */
2659 #define Ctrl 0x0200 /* ctrl scan-code */
2660 #define Shift 0x0400 /* shift scan-code */
2662 static int extended_kbd
; /* 101 (102) keyboard present. */
2664 struct kbd_translate
{
2667 unsigned short code
;
2670 struct dos_keyboard_map
2675 struct kbd_translate
*translate_table
;
2679 static struct dos_keyboard_map us_keyboard
= {
2681 /* 01234567890123456789012345678901234567890 12345678901234 */
2682 "`1234567890-= qwertyuiop[] asdfghjkl;'\\ zxcvbnm,./ ",
2683 /* 0123456789012345678901234567890123456789 012345678901234 */
2684 "~!@#$%^&*()_+ QWERTYUIOP{} ASDFGHJKL:\"| ZXCVBNM<>? ",
2685 0, /* no Alt-Gr key */
2686 0 /* no translate table */
2689 static struct dos_keyboard_map fr_keyboard
= {
2691 /* 012 3456789012345678901234567890123456789012345678901234 */
2692 "ý&‚\",(-Š_€…)= azertyuiop^$ qsdfghjklm—* wxcvbnm;:! ",
2693 /* 0123456789012345678901234567890123456789012345678901234 */
2694 " 1234567890ø+ AZERTYUIOPùœ QSDFGHJKLM%æ WXCVBN?./õ ",
2695 /* 01234567 89012345678901234567890123456789012345678901234 */
2697 0 /* no translate table */
2701 * Italian keyboard support, country code 39.
2704 * added also {,},` as, respectively, AltGr-8, AltGr-9, AltGr-'
2705 * Donated by Stefano Brozzi <brozzis@mag00.cedi.unipr.it>
2708 static struct kbd_translate it_kbd_translate_table
[] = {
2709 { 0x56, 0x3c, Normal
| 13 },
2710 { 0x56, 0x3e, Normal
| 27 },
2713 static struct dos_keyboard_map it_keyboard
= {
2715 /* 0 123456789012345678901234567890123456789012345678901234 */
2716 "\\1234567890'�< qwertyuiopŠ+> asdfghjkl•…— zxcvbnm,.- ",
2717 /* 01 23456789012345678901234567890123456789012345678901234 */
2718 "|!\"œ$%&/()=?^> QWERTYUIOP‚* ASDFGHJKL‡øõ ZXCVBNM;:_ ",
2719 /* 0123456789012345678901234567890123456789012345678901234 */
2721 it_kbd_translate_table
2724 static struct dos_keyboard_map dk_keyboard
= {
2726 /* 0123456789012345678901234567890123456789012345678901234 */
2727 "«1234567890+| qwertyuiop†~ asdfghjkl‘›' zxcvbnm,.- ",
2728 /* 01 23456789012345678901234567890123456789012345678901234 */
2729 "õ!\"#$%&/()=?` QWERTYUIOP�^ ASDFGHJKL’�* ZXCVBNM;:_ ",
2730 /* 0123456789012345678901234567890123456789012345678901234 */
2732 0 /* no translate table */
2735 static struct kbd_translate jp_kbd_translate_table
[] = {
2736 { 0x73, 0x5c, Normal
| 0 },
2737 { 0x73, 0x5f, Normal
| 0 },
2738 { 0x73, 0x1c, Map
| 0 },
2739 { 0x7d, 0x5c, Normal
| 13 },
2740 { 0x7d, 0x7c, Normal
| 13 },
2741 { 0x7d, 0x1c, Map
| 13 },
2744 static struct dos_keyboard_map jp_keyboard
= {
2746 /* 0123456789012 345678901234567890123456789012345678901234 */
2747 "\\1234567890-^\\ qwertyuiop@[ asdfghjkl;:] zxcvbnm,./ ",
2748 /* 01 23456789012345678901234567890123456789012345678901234 */
2749 "_!\"#$%&'()~=~| QWERTYUIOP`{ ASDFGHJKL+*} ZXCVBNM<>? ",
2750 0, /* no Alt-Gr key */
2751 jp_kbd_translate_table
2754 static struct keyboard_layout_list
2757 struct dos_keyboard_map
*keyboard_map
;
2758 } keyboard_layout_list
[] =
2767 static struct dos_keyboard_map
*keyboard
;
2768 static int keyboard_map_all
;
2769 static int international_keyboard
;
2772 dos_set_keyboard (code
, always
)
2777 _go32_dpmi_registers regs
;
2779 /* See if Keyb.Com is installed (for international keyboard support).
2780 Note: calling Int 2Fh via int86 wedges the DOS box on some versions
2781 of Windows 9X! So don't do that! */
2783 regs
.x
.ss
= regs
.x
.sp
= regs
.x
.flags
= 0;
2784 _go32_dpmi_simulate_int (0x2f, ®s
);
2785 if (regs
.h
.al
== 0xff)
2786 international_keyboard
= 1;
2788 /* Initialize to US settings, for countries that don't have their own. */
2789 keyboard
= keyboard_layout_list
[0].keyboard_map
;
2790 keyboard_map_all
= always
;
2791 dos_keyboard_layout
= 1;
2793 for (i
= 0; i
< (sizeof (keyboard_layout_list
)/sizeof (struct keyboard_layout_list
)); i
++)
2794 if (code
== keyboard_layout_list
[i
].country_code
)
2796 keyboard
= keyboard_layout_list
[i
].keyboard_map
;
2797 keyboard_map_all
= always
;
2798 dos_keyboard_layout
= code
;
2806 unsigned char char_code
; /* normal code */
2807 unsigned char meta_code
; /* M- code */
2808 unsigned char keypad_code
; /* keypad code */
2809 unsigned char editkey_code
; /* edit key */
2810 } keypad_translate_map
[] = {
2811 '0', '0', 0xb0, /* kp-0 */ 0x63, /* insert */
2812 '1', '1', 0xb1, /* kp-1 */ 0x57, /* end */
2813 '2', '2', 0xb2, /* kp-2 */ 0x54, /* down */
2814 '3', '3', 0xb3, /* kp-3 */ 0x56, /* next */
2815 '4', '4', 0xb4, /* kp-4 */ 0x51, /* left */
2816 '5', '5', 0xb5, /* kp-5 */ 0xb5, /* kp-5 */
2817 '6', '6', 0xb6, /* kp-6 */ 0x53, /* right */
2818 '7', '7', 0xb7, /* kp-7 */ 0x50, /* home */
2819 '8', '8', 0xb8, /* kp-8 */ 0x52, /* up */
2820 '9', '9', 0xb9, /* kp-9 */ 0x55, /* prior */
2821 '.', '-', 0xae, /* kp-decimal */ 0xff /* delete */
2826 unsigned char char_code
; /* normal code */
2827 unsigned char keypad_code
; /* keypad code */
2828 } grey_key_translate_map
[] = {
2829 '/', 0xaf, /* kp-decimal */
2830 '*', 0xaa, /* kp-multiply */
2831 '-', 0xad, /* kp-subtract */
2832 '+', 0xab, /* kp-add */
2833 '\r', 0x8d /* kp-enter */
2836 static unsigned short
2837 ibmpc_translate_map
[] =
2839 /* --------------- 00 to 0f --------------- */
2840 Normal
| 0xff, /* Ctrl Break + Alt-NNN */
2841 Alt
| ModFct
| 0x1b, /* Escape */
2842 Normal
| 1, /* '1' */
2843 Normal
| 2, /* '2' */
2844 Normal
| 3, /* '3' */
2845 Normal
| 4, /* '4' */
2846 Normal
| 5, /* '5' */
2847 Normal
| 6, /* '6' */
2848 Normal
| 7, /* '7' */
2849 Normal
| 8, /* '8' */
2850 Normal
| 9, /* '9' */
2851 Normal
| 10, /* '0' */
2852 Normal
| 11, /* '-' */
2853 Normal
| 12, /* '=' */
2854 Special
| 0x08, /* Backspace */
2855 ModFct
| 0x74, /* Tab/Backtab */
2857 /* --------------- 10 to 1f --------------- */
2870 ModFct
| 0x0d, /* Return */
2875 /* --------------- 20 to 2f --------------- */
2884 Map
| 40, /* '\'' */
2886 Ignore
, /* Left shift */
2887 Map
| 41, /* '\\' */
2893 /* --------------- 30 to 3f --------------- */
2900 Ignore
, /* Right shift */
2901 Grey
| 1, /* Grey * */
2903 Normal
| 55, /* ' ' */
2904 Ignore
, /* Caps Lock */
2905 FctKey
| 0xbe, /* F1 */
2906 FctKey
| 0xbf, /* F2 */
2907 FctKey
| 0xc0, /* F3 */
2908 FctKey
| 0xc1, /* F4 */
2909 FctKey
| 0xc2, /* F5 */
2911 /* --------------- 40 to 4f --------------- */
2912 FctKey
| 0xc3, /* F6 */
2913 FctKey
| 0xc4, /* F7 */
2914 FctKey
| 0xc5, /* F8 */
2915 FctKey
| 0xc6, /* F9 */
2916 FctKey
| 0xc7, /* F10 */
2917 Ignore
, /* Num Lock */
2918 Ignore
, /* Scroll Lock */
2919 KeyPad
| 7, /* Home */
2920 KeyPad
| 8, /* Up */
2921 KeyPad
| 9, /* Page Up */
2922 Grey
| 2, /* Grey - */
2923 KeyPad
| 4, /* Left */
2924 KeyPad
| 5, /* Keypad 5 */
2925 KeyPad
| 6, /* Right */
2926 Grey
| 3, /* Grey + */
2927 KeyPad
| 1, /* End */
2929 /* --------------- 50 to 5f --------------- */
2930 KeyPad
| 2, /* Down */
2931 KeyPad
| 3, /* Page Down */
2932 KeyPad
| 0, /* Insert */
2933 KeyPad
| 10, /* Delete */
2934 Shift
| FctKey
| 0xbe, /* (Shift) F1 */
2935 Shift
| FctKey
| 0xbf, /* (Shift) F2 */
2936 Shift
| FctKey
| 0xc0, /* (Shift) F3 */
2937 Shift
| FctKey
| 0xc1, /* (Shift) F4 */
2938 Shift
| FctKey
| 0xc2, /* (Shift) F5 */
2939 Shift
| FctKey
| 0xc3, /* (Shift) F6 */
2940 Shift
| FctKey
| 0xc4, /* (Shift) F7 */
2941 Shift
| FctKey
| 0xc5, /* (Shift) F8 */
2942 Shift
| FctKey
| 0xc6, /* (Shift) F9 */
2943 Shift
| FctKey
| 0xc7, /* (Shift) F10 */
2944 Ctrl
| FctKey
| 0xbe, /* (Ctrl) F1 */
2945 Ctrl
| FctKey
| 0xbf, /* (Ctrl) F2 */
2947 /* --------------- 60 to 6f --------------- */
2948 Ctrl
| FctKey
| 0xc0, /* (Ctrl) F3 */
2949 Ctrl
| FctKey
| 0xc1, /* (Ctrl) F4 */
2950 Ctrl
| FctKey
| 0xc2, /* (Ctrl) F5 */
2951 Ctrl
| FctKey
| 0xc3, /* (Ctrl) F6 */
2952 Ctrl
| FctKey
| 0xc4, /* (Ctrl) F7 */
2953 Ctrl
| FctKey
| 0xc5, /* (Ctrl) F8 */
2954 Ctrl
| FctKey
| 0xc6, /* (Ctrl) F9 */
2955 Ctrl
| FctKey
| 0xc7, /* (Ctrl) F10 */
2956 Alt
| FctKey
| 0xbe, /* (Alt) F1 */
2957 Alt
| FctKey
| 0xbf, /* (Alt) F2 */
2958 Alt
| FctKey
| 0xc0, /* (Alt) F3 */
2959 Alt
| FctKey
| 0xc1, /* (Alt) F4 */
2960 Alt
| FctKey
| 0xc2, /* (Alt) F5 */
2961 Alt
| FctKey
| 0xc3, /* (Alt) F6 */
2962 Alt
| FctKey
| 0xc4, /* (Alt) F7 */
2963 Alt
| FctKey
| 0xc5, /* (Alt) F8 */
2965 /* --------------- 70 to 7f --------------- */
2966 Alt
| FctKey
| 0xc6, /* (Alt) F9 */
2967 Alt
| FctKey
| 0xc7, /* (Alt) F10 */
2968 Ctrl
| FctKey
| 0x6d, /* (Ctrl) Sys Rq */
2969 Ctrl
| KeyPad
| 4, /* (Ctrl) Left */
2970 Ctrl
| KeyPad
| 6, /* (Ctrl) Right */
2971 Ctrl
| KeyPad
| 1, /* (Ctrl) End */
2972 Ctrl
| KeyPad
| 3, /* (Ctrl) Page Down */
2973 Ctrl
| KeyPad
| 7, /* (Ctrl) Home */
2974 Alt
| Map
| 1, /* '1' */
2975 Alt
| Map
| 2, /* '2' */
2976 Alt
| Map
| 3, /* '3' */
2977 Alt
| Map
| 4, /* '4' */
2978 Alt
| Map
| 5, /* '5' */
2979 Alt
| Map
| 6, /* '6' */
2980 Alt
| Map
| 7, /* '7' */
2981 Alt
| Map
| 8, /* '8' */
2983 /* --------------- 80 to 8f --------------- */
2984 Alt
| Map
| 9, /* '9' */
2985 Alt
| Map
| 10, /* '0' */
2986 Alt
| Map
| 11, /* '-' */
2987 Alt
| Map
| 12, /* '=' */
2988 Ctrl
| KeyPad
| 9, /* (Ctrl) Page Up */
2989 FctKey
| 0xc8, /* F11 */
2990 FctKey
| 0xc9, /* F12 */
2991 Shift
| FctKey
| 0xc8, /* (Shift) F11 */
2992 Shift
| FctKey
| 0xc9, /* (Shift) F12 */
2993 Ctrl
| FctKey
| 0xc8, /* (Ctrl) F11 */
2994 Ctrl
| FctKey
| 0xc9, /* (Ctrl) F12 */
2995 Alt
| FctKey
| 0xc8, /* (Alt) F11 */
2996 Alt
| FctKey
| 0xc9, /* (Alt) F12 */
2997 Ctrl
| KeyPad
| 8, /* (Ctrl) Up */
2998 Ctrl
| Grey
| 2, /* (Ctrl) Grey - */
2999 Ctrl
| KeyPad
| 5, /* (Ctrl) Keypad 5 */
3001 /* --------------- 90 to 9f --------------- */
3002 Ctrl
| Grey
| 3, /* (Ctrl) Grey + */
3003 Ctrl
| KeyPad
| 2, /* (Ctrl) Down */
3004 Ctrl
| KeyPad
| 0, /* (Ctrl) Insert */
3005 Ctrl
| KeyPad
| 10, /* (Ctrl) Delete */
3006 Ctrl
| FctKey
| 0x09, /* (Ctrl) Tab */
3007 Ctrl
| Grey
| 0, /* (Ctrl) Grey / */
3008 Ctrl
| Grey
| 1, /* (Ctrl) Grey * */
3009 Alt
| FctKey
| 0x50, /* (Alt) Home */
3010 Alt
| FctKey
| 0x52, /* (Alt) Up */
3011 Alt
| FctKey
| 0x55, /* (Alt) Page Up */
3012 Ignore
, /* NO KEY */
3013 Alt
| FctKey
| 0x51, /* (Alt) Left */
3014 Ignore
, /* NO KEY */
3015 Alt
| FctKey
| 0x53, /* (Alt) Right */
3016 Ignore
, /* NO KEY */
3017 Alt
| FctKey
| 0x57, /* (Alt) End */
3019 /* --------------- a0 to af --------------- */
3020 Alt
| KeyPad
| 2, /* (Alt) Down */
3021 Alt
| KeyPad
| 3, /* (Alt) Page Down */
3022 Alt
| KeyPad
| 0, /* (Alt) Insert */
3023 Alt
| KeyPad
| 10, /* (Alt) Delete */
3024 Alt
| Grey
| 0, /* (Alt) Grey / */
3025 Alt
| FctKey
| 0x09, /* (Alt) Tab */
3026 Alt
| Grey
| 4 /* (Alt) Keypad Enter */
3029 /* These bit-positions corresponds to values returned by BIOS */
3030 #define SHIFT_P 0x0003 /* two bits! */
3031 #define CTRL_P 0x0004
3032 #define ALT_P 0x0008
3033 #define SCRLOCK_P 0x0010
3034 #define NUMLOCK_P 0x0020
3035 #define CAPSLOCK_P 0x0040
3036 #define ALT_GR_P 0x0800
3037 #define SUPER_P 0x4000 /* pseudo */
3038 #define HYPER_P 0x8000 /* pseudo */
3041 dos_get_modifiers (keymask
)
3048 /* Calculate modifier bits */
3049 regs
.h
.ah
= extended_kbd
? 0x12 : 0x02;
3050 int86 (0x16, ®s
, ®s
);
3054 mask
= regs
.h
.al
& (SHIFT_P
| CTRL_P
| ALT_P
|
3055 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
3059 mask
= regs
.h
.al
& (SHIFT_P
|
3060 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
3062 /* Do not break international keyboard support. */
3063 /* When Keyb.Com is loaded, the right Alt key is */
3064 /* used for accessing characters like { and } */
3065 if (regs
.h
.ah
& 2) /* Left ALT pressed ? */
3068 if ((regs
.h
.ah
& 8) != 0) /* Right ALT pressed ? */
3071 if (dos_hyper_key
== 1)
3074 modifiers
|= hyper_modifier
;
3076 else if (dos_super_key
== 1)
3079 modifiers
|= super_modifier
;
3081 else if (!international_keyboard
)
3083 /* If Keyb.Com is NOT installed, let Right Alt behave
3084 like the Left Alt. */
3090 if (regs
.h
.ah
& 1) /* Left CTRL pressed ? */
3093 if (regs
.h
.ah
& 4) /* Right CTRL pressed ? */
3095 if (dos_hyper_key
== 2)
3098 modifiers
|= hyper_modifier
;
3100 else if (dos_super_key
== 2)
3103 modifiers
|= super_modifier
;
3111 modifiers
|= shift_modifier
;
3113 modifiers
|= ctrl_modifier
;
3115 modifiers
|= meta_modifier
;
3122 #define NUM_RECENT_DOSKEYS (100)
3123 int recent_doskeys_index
; /* Index for storing next element into recent_doskeys */
3124 int total_doskeys
; /* Total number of elements stored into recent_doskeys */
3125 Lisp_Object recent_doskeys
; /* A vector, holding the last 100 keystrokes */
3127 DEFUN ("recent-doskeys", Frecent_doskeys
, Srecent_doskeys
, 0, 0, 0,
3128 doc
: /* Return vector of last 100 keyboard input values seen in dos_rawgetc.
3129 Each input key receives two values in this vector: first the ASCII code,
3130 and then the scan code. */)
3133 Lisp_Object
*keys
= XVECTOR (recent_doskeys
)->contents
;
3136 if (total_doskeys
< NUM_RECENT_DOSKEYS
)
3137 return Fvector (total_doskeys
, keys
);
3140 val
= Fvector (NUM_RECENT_DOSKEYS
, keys
);
3141 bcopy (keys
+ recent_doskeys_index
,
3142 XVECTOR (val
)->contents
,
3143 (NUM_RECENT_DOSKEYS
- recent_doskeys_index
) * sizeof (Lisp_Object
));
3145 XVECTOR (val
)->contents
+ NUM_RECENT_DOSKEYS
- recent_doskeys_index
,
3146 recent_doskeys_index
* sizeof (Lisp_Object
));
3151 /* Get a char from keyboard. Function keys are put into the event queue. */
3155 struct input_event event
;
3158 #ifndef HAVE_X_WINDOWS
3159 /* Maybe put the cursor where it should be. */
3160 IT_cmgoto (SELECTED_FRAME());
3163 /* The following condition is equivalent to `kbhit ()', except that
3164 it uses the bios to do its job. This pleases DESQview/X. */
3165 while ((regs
.h
.ah
= extended_kbd
? 0x11 : 0x01),
3166 int86 (0x16, ®s
, ®s
),
3167 (regs
.x
.flags
& 0x40) == 0)
3170 register unsigned char c
;
3171 int sc
, code
= -1, mask
, kp_mode
;
3174 regs
.h
.ah
= extended_kbd
? 0x10 : 0x00;
3175 int86 (0x16, ®s
, ®s
);
3180 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3182 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3183 recent_doskeys_index
= 0;
3184 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3186 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3187 recent_doskeys_index
= 0;
3189 modifiers
= dos_get_modifiers (&mask
);
3191 #ifndef HAVE_X_WINDOWS
3192 if (!NILP (Vdos_display_scancodes
))
3195 sprintf (buf
, "%02x:%02x*%04x",
3196 (unsigned) (sc
&0xff), (unsigned) c
, mask
);
3197 dos_direct_output (screen_size_Y
- 2, screen_size_X
- 12, buf
, 10);
3205 case 10: /* Ctrl Grey Enter */
3206 code
= Ctrl
| Grey
| 4;
3208 case 13: /* Grey Enter */
3211 case '/': /* Grey / */
3221 /* Try the keyboard-private translation table first. */
3222 if (keyboard
->translate_table
)
3224 struct kbd_translate
*p
= keyboard
->translate_table
;
3228 if (p
->sc
== sc
&& p
->ch
== c
)
3236 /* If the private table didn't translate it, use the general
3240 if (sc
>= (sizeof (ibmpc_translate_map
) / sizeof (short)))
3242 if ((code
= ibmpc_translate_map
[sc
]) == Ignore
)
3249 /* We only look at the keyboard Ctrl/Shift/Alt keys when
3250 Emacs is ready to read a key. Therefore, if they press
3251 `Alt-x' when Emacs is busy, by the time we get to
3252 `dos_get_modifiers', they might have already released the
3253 Alt key, and Emacs gets just `x', which is BAD.
3254 However, for keys with the `Map' property set, the ASCII
3255 code returns zero iff Alt is pressed. So, when we DON'T
3256 have to support international_keyboard, we don't have to
3257 distinguish between the left and right Alt keys, and we
3258 can set the META modifier for any keys with the `Map'
3259 property if they return zero ASCII code (c = 0). */
3261 || ( (code
& 0xf000) == Map
&& !international_keyboard
))
3262 modifiers
|= meta_modifier
;
3264 modifiers
|= ctrl_modifier
;
3266 modifiers
|= shift_modifier
;
3269 switch (code
& 0xf000)
3272 if (c
&& !(mask
& (SHIFT_P
| ALT_P
| CTRL_P
| HYPER_P
| SUPER_P
)))
3274 c
= 0; /* Special */
3287 if (c
== 0) /* ctrl-break */
3289 return c
; /* ALT-nnn */
3291 if (!keyboard_map_all
)
3300 if (c
&& !(mask
& ALT_P
) && !((mask
& SHIFT_P
) && (mask
& CTRL_P
)))
3301 if (!keyboard_map_all
)
3305 if (mask
& ALT_P
&& code
<= 10 && code
> 0 && dos_keypad_mode
& 0x200)
3306 mask
|= SHIFT_P
; /* ALT-1 => M-! etc. */
3310 code
= keyboard
->shifted
[code
];
3312 modifiers
&= ~shift_modifier
;
3315 if ((mask
& ALT_GR_P
) && keyboard
->alt_gr
&& keyboard
->alt_gr
[code
] != ' ')
3316 code
= keyboard
->alt_gr
[code
];
3318 code
= keyboard
->unshifted
[code
];
3323 if (c
== 0xe0) /* edit key */
3326 if ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) /* numlock on */
3327 kp_mode
= dos_keypad_mode
& 0x03;
3329 kp_mode
= (dos_keypad_mode
>> 4) & 0x03;
3334 if (code
== 10 && dos_decimal_point
)
3335 return dos_decimal_point
;
3336 return keypad_translate_map
[code
].char_code
;
3339 code
= 0xff00 | keypad_translate_map
[code
].keypad_code
;
3343 code
= keypad_translate_map
[code
].meta_code
;
3344 modifiers
= meta_modifier
;
3348 code
= 0xff00 | keypad_translate_map
[code
].editkey_code
;
3355 kp_mode
= ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) ? 0x04 : 0x40;
3356 if (dos_keypad_mode
& kp_mode
)
3357 code
= 0xff00 | grey_key_translate_map
[code
].keypad_code
;
3359 code
= grey_key_translate_map
[code
].char_code
;
3368 event
.kind
= non_ascii_keystroke
;
3370 event
.kind
= ascii_keystroke
;
3372 event
.modifiers
= modifiers
;
3373 event
.frame_or_window
= selected_frame
;
3375 event
.timestamp
= event_timestamp ();
3376 kbd_buffer_store_event (&event
);
3379 if (have_mouse
> 0 && !mouse_preempted
)
3381 int but
, press
, x
, y
, ok
;
3382 int mouse_prev_x
= mouse_last_x
, mouse_prev_y
= mouse_last_y
;
3384 /* Check for mouse movement *before* buttons. */
3385 mouse_check_moved ();
3387 /* If the mouse moved from the spot of its last sighting, we
3388 might need to update mouse highlight. */
3389 if (mouse_last_x
!= mouse_prev_x
|| mouse_last_y
!= mouse_prev_y
)
3391 previous_help_echo
= help_echo
;
3392 help_echo
= help_echo_object
= help_echo_window
= Qnil
;
3394 IT_note_mouse_highlight (SELECTED_FRAME(),
3395 mouse_last_x
, mouse_last_y
);
3396 /* If the contents of the global variable help_echo has
3397 changed, generate a HELP_EVENT. */
3398 if (!NILP (help_echo
) || !NILP (previous_help_echo
))
3400 /* HELP_EVENT takes 2 events in the event loop. */
3401 event
.kind
= HELP_EVENT
;
3402 event
.frame_or_window
= selected_frame
;
3403 event
.arg
= help_echo_object
;
3404 event
.x
= make_number (help_echo_pos
);
3405 event
.timestamp
= event_timestamp ();
3407 kbd_buffer_store_event (&event
);
3408 if (WINDOWP (help_echo_window
))
3409 event
.frame_or_window
= help_echo_window
;
3410 event
.arg
= help_echo
;
3412 kbd_buffer_store_event (&event
);
3416 for (but
= 0; but
< NUM_MOUSE_BUTTONS
; but
++)
3417 for (press
= 0; press
< 2; press
++)
3419 int button_num
= but
;
3422 ok
= mouse_pressed (but
, &x
, &y
);
3424 ok
= mouse_released (but
, &x
, &y
);
3427 /* Allow a simultaneous press/release of Mouse-1 and
3428 Mouse-2 to simulate Mouse-3 on two-button mice. */
3429 if (mouse_button_count
== 2 && but
< 2)
3431 int x2
, y2
; /* don't clobber original coordinates */
3433 /* If only one button is pressed, wait 100 msec and
3434 check again. This way, Speedy Gonzales isn't
3435 punished, while the slow get their chance. */
3436 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3437 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3442 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3443 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3448 event
.kind
= mouse_click
;
3449 event
.code
= button_num
;
3450 event
.modifiers
= dos_get_modifiers (0)
3451 | (press
? down_modifier
: up_modifier
);
3454 event
.frame_or_window
= selected_frame
;
3456 event
.timestamp
= event_timestamp ();
3457 kbd_buffer_store_event (&event
);
3465 static int prev_get_char
= -1;
3467 /* Return 1 if a key is ready to be read without suspending execution. */
3471 if (prev_get_char
!= -1)
3474 return ((prev_get_char
= dos_rawgetc ()) != -1);
3477 /* Read a key. Return -1 if no key is ready. */
3481 if (prev_get_char
!= -1)
3483 int c
= prev_get_char
;
3488 return dos_rawgetc ();
3491 #ifndef HAVE_X_WINDOWS
3492 /* See xterm.c for more info. */
3494 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
3496 register int pix_x
, pix_y
;
3497 register int *x
, *y
;
3501 if (bounds
) abort ();
3503 /* Ignore clipping. */
3510 glyph_to_pixel_coords (f
, x
, y
, pix_x
, pix_y
)
3513 register int *pix_x
, *pix_y
;
3519 /* Simulation of X's menus. Nothing too fancy here -- just make it work
3522 Actually, I don't know the meaning of all the parameters of the functions
3523 here -- I only know how they are called by xmenu.c. I could of course
3524 grab the nearest Xlib manual (down the hall, second-to-last door on the
3525 left), but I don't think it's worth the effort. */
3527 /* These hold text of the current and the previous menu help messages. */
3528 static char *menu_help_message
, *prev_menu_help_message
;
3529 /* Pane number and item number of the menu item which generated the
3530 last menu help message. */
3531 static int menu_help_paneno
, menu_help_itemno
;
3538 menu
= (XMenu
*) xmalloc (sizeof (XMenu
));
3539 menu
->allocated
= menu
->count
= menu
->panecount
= menu
->width
= 0;
3543 /* Allocate some (more) memory for MENU ensuring that there is room for one
3547 IT_menu_make_room (XMenu
*menu
)
3549 if (menu
->allocated
== 0)
3551 int count
= menu
->allocated
= 10;
3552 menu
->text
= (char **) xmalloc (count
* sizeof (char *));
3553 menu
->submenu
= (XMenu
**) xmalloc (count
* sizeof (XMenu
*));
3554 menu
->panenumber
= (int *) xmalloc (count
* sizeof (int));
3555 menu
->help_text
= (char **) xmalloc (count
* sizeof (char *));
3557 else if (menu
->allocated
== menu
->count
)
3559 int count
= menu
->allocated
= menu
->allocated
+ 10;
3561 = (char **) xrealloc (menu
->text
, count
* sizeof (char *));
3563 = (XMenu
**) xrealloc (menu
->submenu
, count
* sizeof (XMenu
*));
3565 = (int *) xrealloc (menu
->panenumber
, count
* sizeof (int));
3567 = (char **) xrealloc (menu
->help_text
, count
* sizeof (char *));
3571 /* Search the given menu structure for a given pane number. */
3574 IT_menu_search_pane (XMenu
*menu
, int pane
)
3579 for (i
= 0; i
< menu
->count
; i
++)
3580 if (menu
->submenu
[i
])
3582 if (pane
== menu
->panenumber
[i
])
3583 return menu
->submenu
[i
];
3584 if ((try = IT_menu_search_pane (menu
->submenu
[i
], pane
)))
3590 /* Determine how much screen space a given menu needs. */
3593 IT_menu_calc_size (XMenu
*menu
, int *width
, int *height
)
3595 int i
, h2
, w2
, maxsubwidth
, maxheight
;
3598 maxheight
= menu
->count
;
3599 for (i
= 0; i
< menu
->count
; i
++)
3601 if (menu
->submenu
[i
])
3603 IT_menu_calc_size (menu
->submenu
[i
], &w2
, &h2
);
3604 if (w2
> maxsubwidth
) maxsubwidth
= w2
;
3605 if (i
+ h2
> maxheight
) maxheight
= i
+ h2
;
3608 *width
= menu
->width
+ maxsubwidth
;
3609 *height
= maxheight
;
3612 /* Display MENU at (X,Y) using FACES. */
3615 IT_menu_display (XMenu
*menu
, int y
, int x
, int pn
, int *faces
, int disp_help
)
3617 int i
, j
, face
, width
;
3618 struct glyph
*text
, *p
;
3621 int enabled
, mousehere
;
3623 struct frame
*sf
= SELECTED_FRAME();
3625 menu_help_message
= NULL
;
3627 width
= menu
->width
;
3628 text
= (struct glyph
*) xmalloc ((width
+ 2) * sizeof (struct glyph
));
3629 ScreenGetCursor (&row
, &col
);
3630 mouse_get_xy (&mx
, &my
);
3631 IT_update_begin (sf
);
3632 for (i
= 0; i
< menu
->count
; i
++)
3634 int max_width
= width
+ 2;
3636 IT_cursor_to (y
+ i
, x
);
3638 = (!menu
->submenu
[i
] && menu
->panenumber
[i
]) || (menu
->submenu
[i
]);
3639 mousehere
= (y
+ i
== my
&& x
<= mx
&& mx
< x
+ width
+ 2);
3640 face
= faces
[enabled
+ mousehere
* 2];
3641 /* The following if clause means that we display the menu help
3642 strings even if the menu item is currently disabled. */
3643 if (disp_help
&& enabled
+ mousehere
* 2 >= 2)
3645 menu_help_message
= menu
->help_text
[i
];
3646 menu_help_paneno
= pn
- 1;
3647 menu_help_itemno
= i
;
3650 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3652 for (j
= 0, q
= menu
->text
[i
]; *q
; j
++)
3656 SET_CHAR_GLYPH (*p
, *q
++, face
, 0);
3659 else /* make '^x' */
3661 SET_CHAR_GLYPH (*p
, '^', face
, 0);
3664 SET_CHAR_GLYPH (*p
, *q
++ + 64, face
, 0);
3668 /* Don't let the menu text overflow into the next screen row. */
3669 if (x
+ max_width
> screen_size_X
)
3671 max_width
= screen_size_X
- x
;
3672 text
[max_width
- 1].u
.ch
= '$'; /* indicate it's truncated */
3674 for (; j
< max_width
- 2; j
++, p
++)
3675 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3677 SET_CHAR_GLYPH (*p
, menu
->submenu
[i
] ? 16 : ' ', face
, 0);
3679 IT_write_glyphs (text
, max_width
);
3682 IT_cursor_to (row
, col
);
3686 /* --------------------------- X Menu emulation ---------------------- */
3688 /* Report availability of menus. */
3696 /* Create a brand new menu structure. */
3699 XMenuCreate (Display
*foo1
, Window foo2
, char *foo3
)
3701 return IT_menu_create ();
3704 /* Create a new pane and place it on the outer-most level. It is not
3705 clear that it should be placed out there, but I don't know what else
3709 XMenuAddPane (Display
*foo
, XMenu
*menu
, char *txt
, int enable
)
3717 IT_menu_make_room (menu
);
3718 menu
->submenu
[menu
->count
] = IT_menu_create ();
3719 menu
->text
[menu
->count
] = txt
;
3720 menu
->panenumber
[menu
->count
] = ++menu
->panecount
;
3721 menu
->help_text
[menu
->count
] = NULL
;
3724 /* Adjust length for possible control characters (which will
3725 be written as ^x). */
3726 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3730 if (len
> menu
->width
)
3733 return menu
->panecount
;
3736 /* Create a new item in a menu pane. */
3739 XMenuAddSelection (Display
*bar
, XMenu
*menu
, int pane
,
3740 int foo
, char *txt
, int enable
, char *help_text
)
3746 if (!(menu
= IT_menu_search_pane (menu
, pane
)))
3748 IT_menu_make_room (menu
);
3749 menu
->submenu
[menu
->count
] = (XMenu
*) 0;
3750 menu
->text
[menu
->count
] = txt
;
3751 menu
->panenumber
[menu
->count
] = enable
;
3752 menu
->help_text
[menu
->count
] = help_text
;
3755 /* Adjust length for possible control characters (which will
3756 be written as ^x). */
3757 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3761 if (len
> menu
->width
)
3767 /* Decide where the menu would be placed if requested at (X,Y). */
3770 XMenuLocate (Display
*foo0
, XMenu
*menu
, int foo1
, int foo2
, int x
, int y
,
3771 int *ulx
, int *uly
, int *width
, int *height
)
3773 IT_menu_calc_size (menu
, width
, height
);
3779 struct IT_menu_state
3781 void *screen_behind
;
3788 /* Display menu, wait for user's response, and return that response. */
3791 XMenuActivate (Display
*foo
, XMenu
*menu
, int *pane
, int *selidx
,
3792 int x0
, int y0
, unsigned ButtonMask
, char **txt
,
3793 void (*help_callback
)(char *, int, int))
3795 struct IT_menu_state
*state
;
3800 Lisp_Object selectface
;
3801 int leave
, result
, onepane
;
3802 int title_faces
[4]; /* face to display the menu title */
3803 int buffers_num_deleted
= 0;
3804 struct frame
*sf
= SELECTED_FRAME();
3805 Lisp_Object saved_echo_area_message
;
3807 /* Just in case we got here without a mouse present... */
3808 if (have_mouse
<= 0)
3809 return XM_IA_SELECT
;
3810 /* Don't allow non-positive x0 and y0, lest the menu will wrap
3811 around the display. */
3817 /* We will process all the mouse events directly, so we had
3818 better prevent dos_rawgetc from stealing them from us. */
3821 state
= alloca (menu
->panecount
* sizeof (struct IT_menu_state
));
3822 screensize
= screen_size
* 2;
3824 = lookup_derived_face (sf
, intern ("msdos-menu-passive-face"),
3825 0, DEFAULT_FACE_ID
);
3827 = lookup_derived_face (sf
, intern ("msdos-menu-active-face"),
3828 0, DEFAULT_FACE_ID
);
3829 selectface
= intern ("msdos-menu-select-face");
3830 faces
[2] = lookup_derived_face (sf
, selectface
,
3832 faces
[3] = lookup_derived_face (sf
, selectface
,
3835 /* Make sure the menu title is always displayed with
3836 `msdos-menu-active-face', no matter where the mouse pointer is. */
3837 for (i
= 0; i
< 4; i
++)
3838 title_faces
[i
] = faces
[3];
3842 /* Don't let the title for the "Buffers" popup menu include a
3843 digit (which is ugly).
3845 This is a terrible kludge, but I think the "Buffers" case is
3846 the only one where the title includes a number, so it doesn't
3847 seem to be necessary to make this more general. */
3848 if (strncmp (menu
->text
[0], "Buffers 1", 9) == 0)
3850 menu
->text
[0][7] = '\0';
3851 buffers_num_deleted
= 1;
3854 /* We need to save the current echo area message, so that we could
3855 restore it below, before we exit. See the commentary below,
3856 before the call to message_with_string. */
3857 saved_echo_area_message
= Fcurrent_message ();
3858 state
[0].menu
= menu
;
3860 ScreenRetrieve (state
[0].screen_behind
= xmalloc (screensize
));
3862 /* Turn off the cursor. Otherwise it shows through the menu
3863 panes, which is ugly. */
3864 IT_display_cursor (0);
3866 /* Display the menu title. */
3867 IT_menu_display (menu
, y0
- 1, x0
- 1, 1, title_faces
, 0);
3868 if (buffers_num_deleted
)
3869 menu
->text
[0][7] = ' ';
3870 if ((onepane
= menu
->count
== 1 && menu
->submenu
[0]))
3872 menu
->width
= menu
->submenu
[0]->width
;
3873 state
[0].menu
= menu
->submenu
[0];
3877 state
[0].menu
= menu
;
3879 state
[0].x
= x0
- 1;
3881 state
[0].pane
= onepane
;
3883 mouse_last_x
= -1; /* A hack that forces display. */
3887 if (!mouse_visible
) mouse_on ();
3888 mouse_check_moved ();
3889 if (sf
->mouse_moved
)
3891 sf
->mouse_moved
= 0;
3892 result
= XM_IA_SELECT
;
3893 mouse_get_xy (&x
, &y
);
3894 for (i
= 0; i
< statecount
; i
++)
3895 if (state
[i
].x
<= x
&& x
< state
[i
].x
+ state
[i
].menu
->width
+ 2)
3897 int dy
= y
- state
[i
].y
;
3898 if (0 <= dy
&& dy
< state
[i
].menu
->count
)
3900 if (!state
[i
].menu
->submenu
[dy
])
3901 if (state
[i
].menu
->panenumber
[dy
])
3902 result
= XM_SUCCESS
;
3904 result
= XM_IA_SELECT
;
3905 *pane
= state
[i
].pane
- 1;
3907 /* We hit some part of a menu, so drop extra menus that
3908 have been opened. That does not include an open and
3910 if (i
!= statecount
- 2
3911 || state
[i
].menu
->submenu
[dy
] != state
[i
+1].menu
)
3912 while (i
!= statecount
- 1)
3916 ScreenUpdate (state
[statecount
].screen_behind
);
3917 if (screen_virtual_segment
)
3918 dosv_refresh_virtual_screen (0, screen_size
);
3919 xfree (state
[statecount
].screen_behind
);
3921 if (i
== statecount
- 1 && state
[i
].menu
->submenu
[dy
])
3923 IT_menu_display (state
[i
].menu
,
3928 state
[statecount
].menu
= state
[i
].menu
->submenu
[dy
];
3929 state
[statecount
].pane
= state
[i
].menu
->panenumber
[dy
];
3931 ScreenRetrieve (state
[statecount
].screen_behind
3932 = xmalloc (screensize
));
3934 = state
[i
].x
+ state
[i
].menu
->width
+ 2;
3935 state
[statecount
].y
= y
;
3940 IT_menu_display (state
[statecount
- 1].menu
,
3941 state
[statecount
- 1].y
,
3942 state
[statecount
- 1].x
,
3943 state
[statecount
- 1].pane
,
3948 if ((menu_help_message
|| prev_menu_help_message
)
3949 && menu_help_message
!= prev_menu_help_message
)
3951 help_callback (menu_help_message
,
3952 menu_help_paneno
, menu_help_itemno
);
3953 IT_display_cursor (0);
3954 prev_menu_help_message
= menu_help_message
;
3956 /* We are busy-waiting for the mouse to move, so let's be nice
3957 to other Windows applications by releasing our time slice. */
3960 for (b
= 0; b
< mouse_button_count
&& !leave
; b
++)
3962 /* Only leave if user both pressed and released the mouse, and in
3963 that order. This avoids popping down the menu pane unless
3964 the user is really done with it. */
3965 if (mouse_pressed (b
, &x
, &y
))
3967 while (mouse_button_depressed (b
, &x
, &y
))
3971 (void) mouse_released (b
, &x
, &y
);
3976 ScreenUpdate (state
[0].screen_behind
);
3977 if (screen_virtual_segment
)
3978 dosv_refresh_virtual_screen (0, screen_size
);
3980 /* We have a situation here. ScreenUpdate has just restored the
3981 screen contents as it was before we started drawing this menu.
3982 That includes any echo area message that could have been
3983 displayed back then. (In reality, that echo area message will
3984 almost always be the ``keystroke echo'' that echoes the sequence
3985 of menu items chosen by the user.) However, if the menu had some
3986 help messages, then displaying those messages caused Emacs to
3987 forget about the original echo area message. So when
3988 ScreenUpdate restored it, it created a discrepancy between the
3989 actual screen contents and what Emacs internal data structures
3992 To avoid this conflict, we force Emacs to restore the original
3993 echo area message as we found it when we entered this function.
3994 The irony of this is that we then erase the restored message
3995 right away, so the only purpose of restoring it is so that
3996 erasing it works correctly... */
3997 if (! NILP (saved_echo_area_message
))
3998 message_with_string ("%s", saved_echo_area_message
, 0);
4000 while (statecount
--)
4001 xfree (state
[statecount
].screen_behind
);
4002 IT_display_cursor (1); /* turn cursor back on */
4003 /* Clean up any mouse events that are waiting inside Emacs event queue.
4004 These events are likely to be generated before the menu was even
4005 displayed, probably because the user pressed and released the button
4006 (which invoked the menu) too quickly. If we don't remove these events,
4007 Emacs will process them after we return and surprise the user. */
4008 discard_mouse_events ();
4009 mouse_clear_clicks ();
4010 if (!kbd_buffer_events_waiting (1))
4011 clear_input_pending ();
4012 /* Allow mouse events generation by dos_rawgetc. */
4017 /* Dispose of a menu. */
4020 XMenuDestroy (Display
*foo
, XMenu
*menu
)
4023 if (menu
->allocated
)
4025 for (i
= 0; i
< menu
->count
; i
++)
4026 if (menu
->submenu
[i
])
4027 XMenuDestroy (foo
, menu
->submenu
[i
]);
4029 xfree (menu
->submenu
);
4030 xfree (menu
->panenumber
);
4031 xfree (menu
->help_text
);
4034 menu_help_message
= prev_menu_help_message
= NULL
;
4038 x_pixel_width (struct frame
*f
)
4040 return FRAME_WIDTH (f
);
4044 x_pixel_height (struct frame
*f
)
4046 return FRAME_HEIGHT (f
);
4048 #endif /* !HAVE_X_WINDOWS */
4050 /* ----------------------- DOS / UNIX conversion --------------------- */
4052 void msdos_downcase_filename (unsigned char *);
4054 /* Destructively turn backslashes into slashes. */
4057 dostounix_filename (p
)
4060 msdos_downcase_filename (p
);
4070 /* Destructively turn slashes into backslashes. */
4073 unixtodos_filename (p
)
4076 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4090 /* Get the default directory for a given drive. 0=def, 1=A, 2=B, ... */
4093 getdefdir (drive
, dst
)
4097 char in_path
[4], *p
= in_path
;
4100 /* Generate "X:." (when drive is X) or "." (when drive is 0). */
4103 *p
++ = drive
+ 'A' - 1;
4110 _fixpath (in_path
, dst
);
4111 /* _fixpath can set errno to ENOSYS on non-LFN systems because
4112 it queries the LFN support, so ignore that error. */
4113 if ((errno
&& errno
!= ENOSYS
) || *dst
== '\0')
4116 msdos_downcase_filename (dst
);
4123 emacs_root_dir (void)
4125 static char root_dir
[4];
4127 sprintf (root_dir
, "%c:/", 'A' + getdisk ());
4128 root_dir
[0] = tolower (root_dir
[0]);
4132 /* Remove all CR's that are followed by a LF. */
4137 register unsigned char *buf
;
4139 unsigned char *np
= buf
;
4140 unsigned char *startp
= buf
;
4141 unsigned char *endp
= buf
+ n
;
4145 while (buf
< endp
- 1)
4149 if (*(++buf
) != 0x0a)
4160 #if defined(__DJGPP__) && __DJGPP__ == 2 && __DJGPP_MINOR__ == 0
4162 /* In DJGPP v2.0, library `write' can call `malloc', which might
4163 cause relocation of the buffer whose address we get in ADDR.
4164 Here is a version of `write' that avoids calling `malloc',
4165 to serve us until such time as the library is fixed.
4166 Actually, what we define here is called `__write', because
4167 `write' is a stub that just jmp's to `__write' (to be
4168 POSIXLY-correct with respect to the global name-space). */
4170 #include <io.h> /* for _write */
4171 #include <libc/dosio.h> /* for __file_handle_modes[] */
4173 static char xbuf
[64 * 1024]; /* DOS cannot write more in one chunk */
4175 #define XBUF_END (xbuf + sizeof (xbuf) - 1)
4178 __write (int handle
, const void *buffer
, size_t count
)
4183 if(__file_handle_modes
[handle
] & O_BINARY
)
4184 return _write (handle
, buffer
, count
);
4188 const char *bp
= buffer
;
4189 int total_written
= 0;
4190 int nmoved
= 0, ncr
= 0;
4194 /* The next test makes sure there's space for at least 2 more
4195 characters in xbuf[], so both CR and LF can be put there. */
4207 if (xbp
>= XBUF_END
|| !count
)
4209 size_t to_write
= nmoved
+ ncr
;
4210 int written
= _write (handle
, xbuf
, to_write
);
4215 total_written
+= nmoved
; /* CRs aren't counted in ret value */
4217 /* If some, but not all were written (disk full?), return
4218 an estimate of the total written bytes not counting CRs. */
4219 if (written
< to_write
)
4220 return total_written
- (to_write
- written
) * nmoved
/to_write
;
4227 return total_written
;
4231 /* A low-level file-renaming function which works around Windows 95 bug.
4232 This is pulled directly out of DJGPP v2.01 library sources, and only
4233 used when you compile with DJGPP v2.0. */
4237 int _rename(const char *old
, const char *new)
4240 int olen
= strlen(old
) + 1;
4242 int use_lfn
= _USE_LFN
;
4243 char tempfile
[FILENAME_MAX
];
4244 const char *orig
= old
;
4247 r
.x
.dx
= __tb_offset
;
4248 r
.x
.di
= __tb_offset
+ olen
;
4249 r
.x
.ds
= r
.x
.es
= __tb_segment
;
4253 /* Windows 95 bug: for some filenames, when you rename
4254 file -> file~ (as in Emacs, to leave a backup), the
4255 short 8+3 alias doesn't change, which effectively
4256 makes OLD and NEW the same file. We must rename
4257 through a temporary file to work around this. */
4259 char *pbase
= 0, *p
;
4260 static char try_char
[] = "abcdefghijklmnopqrstuvwxyz012345789";
4261 int idx
= sizeof(try_char
) - 1;
4263 /* Generate a temporary name. Can't use `tmpnam', since $TMPDIR
4264 might point to another drive, which will fail the DOS call. */
4265 strcpy(tempfile
, old
);
4266 for (p
= tempfile
; *p
; p
++) /* ensure temporary is on the same drive */
4267 if (*p
== '/' || *p
== '\\' || *p
== ':')
4273 strcpy(pbase
, "X$$djren$$.$$temp$$");
4279 *pbase
= try_char
[--idx
];
4280 } while (_chmod(tempfile
, 0) != -1);
4283 _put_path2(tempfile
, olen
);
4285 __dpmi_int(0x21, &r
);
4288 errno
= __doserr_to_errno(r
.x
.ax
);
4292 /* Now create a file with the original name. This will
4293 ensure that NEW will always have a 8+3 alias
4294 different from that of OLD. (Seems to be required
4295 when NameNumericTail in the Registry is set to 0.) */
4296 lfn_fd
= _creat(old
, 0);
4298 olen
= strlen(tempfile
) + 1;
4300 r
.x
.di
= __tb_offset
+ olen
;
4309 _put_path2(new, olen
);
4311 __dpmi_int(0x21, &r
);
4314 if (r
.x
.ax
== 5 && i
== 0) /* access denied */
4315 remove(new); /* and try again */
4318 errno
= __doserr_to_errno(r
.x
.ax
);
4320 /* Restore to original name if we renamed it to temporary. */
4328 _put_path2(orig
, olen
);
4329 _put_path(tempfile
);
4331 __dpmi_int(0x21, &r
);
4340 /* Success. Delete the file possibly created to work
4341 around the Windows 95 bug. */
4343 return (_close (lfn_fd
) == 0) ? remove (orig
) : -1;
4347 #endif /* __DJGPP__ == 2 && __DJGPP_MINOR__ == 0 */
4349 DEFUN ("msdos-long-file-names", Fmsdos_long_file_names
, Smsdos_long_file_names
,
4351 doc
: /* Return non-nil if long file names are supported on MSDOS. */)
4354 return (_USE_LFN
? Qt
: Qnil
);
4357 /* Convert alphabetic characters in a filename to lower-case. */
4360 msdos_downcase_filename (p
)
4361 register unsigned char *p
;
4363 /* Always lower-case drive letters a-z, even if the filesystem
4364 preserves case in filenames.
4365 This is so MSDOS filenames could be compared by string comparison
4366 functions that are case-sensitive. Even case-preserving filesystems
4367 do not distinguish case in drive letters. */
4368 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4374 /* Under LFN we expect to get pathnames in their true case. */
4375 if (NILP (Fmsdos_long_file_names ()))
4377 if (*p
>= 'A' && *p
<= 'Z')
4381 DEFUN ("msdos-downcase-filename", Fmsdos_downcase_filename
, Smsdos_downcase_filename
,
4383 doc
: /* Convert alphabetic characters in FILENAME to lower case and return that.
4384 When long filenames are supported, doesn't change FILENAME.
4385 If FILENAME is not a string, returns nil.
4386 The argument object is never altered--the value is a copy. */)
4388 Lisp_Object filename
;
4392 if (! STRINGP (filename
))
4395 tem
= Fcopy_sequence (filename
);
4396 msdos_downcase_filename (XSTRING (tem
)->data
);
4400 /* The Emacs root directory as determined by init_environment. */
4402 static char emacsroot
[MAXPATHLEN
];
4405 rootrelativepath (rel
)
4408 static char result
[MAXPATHLEN
+ 10];
4410 strcpy (result
, emacsroot
);
4411 strcat (result
, "/");
4412 strcat (result
, rel
);
4416 /* Define a lot of environment variables if not already defined. Don't
4417 remove anything unless you know what you're doing -- lots of code will
4418 break if one or more of these are missing. */
4421 init_environment (argc
, argv
, skip_args
)
4428 static const char * const tempdirs
[] = {
4429 "$TMPDIR", "$TEMP", "$TMP", "c:/"
4432 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
4434 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
4435 temporary files and assume "/tmp" if $TMPDIR is unset, which
4436 will break on DOS/Windows. Refuse to work if we cannot find
4437 a directory, not even "c:/", usable for that purpose. */
4438 for (i
= 0; i
< imax
; i
++)
4440 const char *tmp
= tempdirs
[i
];
4443 tmp
= getenv (tmp
+ 1);
4444 /* Note that `access' can lie to us if the directory resides on a
4445 read-only filesystem, like CD-ROM or a write-protected floppy.
4446 The only way to be really sure is to actually create a file and
4447 see if it succeeds. But I think that's too much to ask. */
4448 if (tmp
&& access (tmp
, D_OK
) == 0)
4450 setenv ("TMPDIR", tmp
, 1);
4457 Fcons (build_string ("no usable temporary directories found!!"),
4459 "While setting TMPDIR: ");
4461 /* Note the startup time, so we know not to clear the screen if we
4462 exit immediately; see IT_reset_terminal_modes.
4463 (Yes, I know `clock' returns zero the first time it's called, but
4464 I do this anyway, in case some wiseguy changes that at some point.) */
4465 startup_time
= clock ();
4467 /* Find our root from argv[0]. Assuming argv[0] is, say,
4468 "c:/emacs/bin/emacs.exe" our root will be "c:/emacs". */
4469 root
= alloca (MAXPATHLEN
+ 20);
4470 _fixpath (argv
[0], root
);
4471 msdos_downcase_filename (root
);
4472 len
= strlen (root
);
4473 while (len
> 0 && root
[len
] != '/' && root
[len
] != ':')
4477 && (strcmp (root
+ len
- 4, "/bin") == 0
4478 || strcmp (root
+ len
- 4, "/src") == 0)) /* under a debugger */
4479 root
[len
- 4] = '\0';
4481 strcpy (root
, "c:/emacs"); /* let's be defensive */
4482 len
= strlen (root
);
4483 strcpy (emacsroot
, root
);
4485 /* We default HOME to our root. */
4486 setenv ("HOME", root
, 0);
4488 /* We default EMACSPATH to root + "/bin". */
4489 strcpy (root
+ len
, "/bin");
4490 setenv ("EMACSPATH", root
, 0);
4492 /* I don't expect anybody to ever use other terminals so the internal
4493 terminal is the default. */
4494 setenv ("TERM", "internal", 0);
4496 #ifdef HAVE_X_WINDOWS
4497 /* Emacs expects DISPLAY to be set. */
4498 setenv ("DISPLAY", "unix:0.0", 0);
4501 /* SHELL is a bit tricky -- COMSPEC is the closest we come, but we must
4502 downcase it and mirror the backslashes. */
4503 s
= getenv ("COMSPEC");
4504 if (!s
) s
= "c:/command.com";
4505 t
= alloca (strlen (s
) + 1);
4507 dostounix_filename (t
);
4508 setenv ("SHELL", t
, 0);
4510 /* PATH is also downcased and backslashes mirrored. */
4511 s
= getenv ("PATH");
4513 t
= alloca (strlen (s
) + 3);
4514 /* Current directory is always considered part of MsDos's path but it is
4515 not normally mentioned. Now it is. */
4516 strcat (strcpy (t
, ".;"), s
);
4517 dostounix_filename (t
); /* Not a single file name, but this should work. */
4518 setenv ("PATH", t
, 1);
4520 /* In some sense all dos users have root privileges, so... */
4521 setenv ("USER", "root", 0);
4522 setenv ("NAME", getenv ("USER"), 0);
4524 /* Time zone determined from country code. To make this possible, the
4525 country code may not span more than one time zone. In other words,
4526 in the USA, you lose. */
4528 switch (dos_country_code
)
4530 case 31: /* Belgium */
4531 case 32: /* The Netherlands */
4532 case 33: /* France */
4533 case 34: /* Spain */
4534 case 36: /* Hungary */
4535 case 38: /* Yugoslavia (or what's left of it?) */
4536 case 39: /* Italy */
4537 case 41: /* Switzerland */
4538 case 42: /* Tjekia */
4539 case 45: /* Denmark */
4540 case 46: /* Sweden */
4541 case 47: /* Norway */
4542 case 48: /* Poland */
4543 case 49: /* Germany */
4544 /* Daylight saving from last Sunday in March to last Sunday in
4545 September, both at 2AM. */
4546 setenv ("TZ", "MET-01METDST-02,M3.5.0/02:00,M9.5.0/02:00", 0);
4548 case 44: /* United Kingdom */
4549 case 351: /* Portugal */
4550 case 354: /* Iceland */
4551 setenv ("TZ", "GMT+00", 0);
4553 case 81: /* Japan */
4554 case 82: /* Korea */
4555 setenv ("TZ", "JST-09", 0);
4557 case 90: /* Turkey */
4558 case 358: /* Finland */
4559 setenv ("TZ", "EET-02", 0);
4561 case 972: /* Israel */
4562 /* This is an approximation. (For exact rules, use the
4563 `zoneinfo/israel' file which comes with DJGPP, but you need
4564 to install it in `/usr/share/zoneinfo/' directory first.) */
4565 setenv ("TZ", "IST-02IDT-03,M4.1.6/00:00,M9.5.6/01:00", 0);
4573 static int break_stat
; /* BREAK check mode status. */
4574 static int stdin_stat
; /* stdin IOCTL status. */
4578 /* These must be global. */
4579 static _go32_dpmi_seginfo ctrl_break_vector
;
4580 static _go32_dpmi_registers ctrl_break_regs
;
4581 static int ctrlbreakinstalled
= 0;
4583 /* Interrupt level detection of Ctrl-Break. Don't do anything fancy here! */
4586 ctrl_break_func (regs
)
4587 _go32_dpmi_registers
*regs
;
4593 install_ctrl_break_check ()
4595 if (!ctrlbreakinstalled
)
4597 /* Don't press Ctrl-Break if you don't have either DPMI or Emacs
4598 was compiler with Djgpp 1.11 maintenance level 5 or later! */
4599 ctrlbreakinstalled
= 1;
4600 ctrl_break_vector
.pm_offset
= (int) ctrl_break_func
;
4601 _go32_dpmi_allocate_real_mode_callback_iret (&ctrl_break_vector
,
4603 _go32_dpmi_set_real_mode_interrupt_vector (0x1b, &ctrl_break_vector
);
4607 #endif /* __DJGPP__ < 2 */
4609 /* Turn off Dos' Ctrl-C checking and inhibit interpretation of
4610 control chars by DOS. Determine the keyboard type. */
4615 union REGS inregs
, outregs
;
4616 static int first_time
= 1;
4618 break_stat
= getcbrk ();
4621 install_ctrl_break_check ();
4627 int86 (0x15, &inregs
, &outregs
);
4628 extended_kbd
= (!outregs
.x
.cflag
) && (outregs
.h
.ah
== 0);
4632 if (internal_terminal
4633 #ifdef HAVE_X_WINDOWS
4634 && inhibit_window_system
4638 inregs
.x
.ax
= 0x0021;
4639 int86 (0x33, &inregs
, &outregs
);
4640 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4643 /* Reportedly, the above doesn't work for some mouse drivers. There
4644 is an additional detection method that should work, but might be
4645 a little slower. Use that as an alternative. */
4646 inregs
.x
.ax
= 0x0000;
4647 int86 (0x33, &inregs
, &outregs
);
4648 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4653 have_mouse
= 1; /* enable mouse */
4655 mouse_setup_buttons (outregs
.x
.bx
);
4656 mouse_position_hook
= &mouse_get_pos
;
4660 #ifndef HAVE_X_WINDOWS
4662 /* Save the cursor shape used outside Emacs. */
4663 outside_cursor
= _farpeekw (_dos_ds
, 0x460);
4672 stdin_stat
= setmode (fileno (stdin
), O_BINARY
);
4673 return (stdin_stat
!= -1);
4676 return (setmode (fileno (stdin
), O_BINARY
) != -1);
4678 #else /* __DJGPP__ < 2 */
4682 /* I think it is wrong to overwrite `stdin_stat' every time
4683 but the first one this function is called, but I don't
4684 want to change the way it used to work in v1.x.--EZ */
4686 inregs
.x
.ax
= 0x4400; /* Get IOCTL status. */
4687 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4688 intdos (&inregs
, &outregs
);
4689 stdin_stat
= outregs
.h
.dl
;
4691 inregs
.x
.dx
= stdin_stat
| 0x0020; /* raw mode */
4692 inregs
.x
.ax
= 0x4401; /* Set IOCTL status */
4693 intdos (&inregs
, &outregs
);
4694 return !outregs
.x
.cflag
;
4696 #endif /* __DJGPP__ < 2 */
4699 /* Restore status of standard input and Ctrl-C checking. */
4704 union REGS inregs
, outregs
;
4706 setcbrk (break_stat
);
4711 #ifndef HAVE_X_WINDOWS
4712 /* Restore the cursor shape we found on startup. */
4716 inregs
.x
.cx
= outside_cursor
;
4717 int86 (0x10, &inregs
, &outregs
);
4721 return (setmode (fileno (stdin
), stdin_stat
) != -1);
4723 #else /* not __DJGPP__ >= 2 */
4725 inregs
.x
.ax
= 0x4401; /* Set IOCTL status. */
4726 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4727 inregs
.x
.dx
= stdin_stat
;
4728 intdos (&inregs
, &outregs
);
4729 return !outregs
.x
.cflag
;
4731 #endif /* not __DJGPP__ >= 2 */
4735 /* Run command as specified by ARGV in directory DIR.
4736 The command is run with input from TEMPIN, output to
4737 file TEMPOUT and stderr to TEMPERR. */
4740 run_msdos_command (argv
, working_dir
, tempin
, tempout
, temperr
, envv
)
4741 unsigned char **argv
;
4742 const char *working_dir
;
4743 int tempin
, tempout
, temperr
;
4746 char *saveargv1
, *saveargv2
, *lowcase_argv0
, *pa
, *pl
;
4747 char oldwd
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
4748 int msshell
, result
= -1;
4749 int inbak
, outbak
, errbak
;
4753 /* Get current directory as MSDOS cwd is not per-process. */
4756 /* If argv[0] is the shell, it might come in any lettercase.
4757 Since `Fmember' is case-sensitive, we need to downcase
4758 argv[0], even if we are on case-preserving filesystems. */
4759 lowcase_argv0
= alloca (strlen (argv
[0]) + 1);
4760 for (pa
= argv
[0], pl
= lowcase_argv0
; *pa
; pl
++)
4763 if (*pl
>= 'A' && *pl
<= 'Z')
4768 cmd
= Ffile_name_nondirectory (build_string (lowcase_argv0
));
4769 msshell
= !NILP (Fmember (cmd
, Fsymbol_value (intern ("msdos-shells"))))
4770 && !strcmp ("-c", argv
[1]);
4773 saveargv1
= argv
[1];
4774 saveargv2
= argv
[2];
4776 /* We only need to mirror slashes if a DOS shell will be invoked
4777 not via `system' (which does the mirroring itself). Yes, that
4778 means DJGPP v1.x will lose here. */
4779 if (argv
[2] && argv
[3])
4781 char *p
= alloca (strlen (argv
[2]) + 1);
4783 strcpy (argv
[2] = p
, saveargv2
);
4784 while (*p
&& isspace (*p
))
4796 chdir (working_dir
);
4800 if (inbak
< 0 || outbak
< 0 || errbak
< 0)
4801 goto done
; /* Allocation might fail due to lack of descriptors. */
4804 mouse_get_xy (&x
, &y
);
4806 dos_ttcooked (); /* do it here while 0 = stdin */
4814 if (msshell
&& !argv
[3])
4816 /* MS-DOS native shells are too restrictive. For starters, they
4817 cannot grok commands longer than 126 characters. In DJGPP v2
4818 and later, `system' is much smarter, so we'll call it instead. */
4822 /* A shell gets a single argument--its full command
4823 line--whose original was saved in `saveargv2'. */
4825 /* Don't let them pass empty command lines to `system', since
4826 with some shells it will try to invoke an interactive shell,
4827 which will hang Emacs. */
4828 for (cmnd
= saveargv2
; *cmnd
&& isspace (*cmnd
); cmnd
++)
4832 extern char **environ
;
4833 char **save_env
= environ
;
4834 int save_system_flags
= __system_flags
;
4836 /* Request the most powerful version of `system'. We need
4837 all the help we can get to avoid calling stock DOS shells. */
4838 __system_flags
= (__system_redirect
4839 | __system_use_shell
4840 | __system_allow_multiple_cmds
4841 | __system_allow_long_cmds
4842 | __system_handle_null_commands
4843 | __system_emulate_chdir
);
4846 result
= system (cmnd
);
4847 __system_flags
= save_system_flags
;
4851 result
= 0; /* emulate Unixy shell behavior with empty cmd line */
4855 #endif /* __DJGPP__ > 1 */
4857 result
= spawnve (P_WAIT
, argv
[0], argv
, envv
);
4862 emacs_close (inbak
);
4863 emacs_close (outbak
);
4864 emacs_close (errbak
);
4870 mouse_moveto (x
, y
);
4873 /* Some programs might change the meaning of the highest bit of the
4874 text attribute byte, so we get blinking characters instead of the
4875 bright background colors. Restore that. */
4882 argv
[1] = saveargv1
;
4883 argv
[2] = saveargv2
;
4891 fprintf (stderr
, "%s not yet implemented\r\n", badfunc
);
4898 /* ------------------------- Compatibility functions -------------------
4903 /* Hostnames for a pc are not really funny,
4904 but they are used in change log so we emulate the best we can. */
4906 gethostname (p
, size
)
4910 char *q
= egetenv ("HOSTNAME");
4917 /* When time zones are set from Ms-Dos too many C-libraries are playing
4918 tricks with time values. We solve this by defining our own version
4919 of `gettimeofday' bypassing GO32. Our version needs to be initialized
4920 once and after each call to `tzset' with TZ changed. That is
4921 accomplished by aliasing tzset to init_gettimeofday. */
4923 static struct tm time_rec
;
4926 gettimeofday (struct timeval
*tp
, struct timezone
*tzp
)
4934 if (t
.ti_hour
< time_rec
.tm_hour
) /* midnight wrap */
4938 time_rec
.tm_year
= d
.da_year
- 1900;
4939 time_rec
.tm_mon
= d
.da_mon
- 1;
4940 time_rec
.tm_mday
= d
.da_day
;
4943 time_rec
.tm_hour
= t
.ti_hour
;
4944 time_rec
.tm_min
= t
.ti_min
;
4945 time_rec
.tm_sec
= t
.ti_sec
;
4948 tm
.tm_gmtoff
= dos_timezone_offset
;
4950 tp
->tv_sec
= mktime (&tm
); /* may modify tm */
4951 tp
->tv_usec
= t
.ti_hund
* (1000000 / 100);
4953 /* Ignore tzp; it's obsolescent. */
4957 #endif /* __DJGPP__ < 2 */
4960 * A list of unimplemented functions that we silently ignore.
4964 unsigned alarm (s
) unsigned s
; {}
4965 fork () { return 0; }
4966 int kill (x
, y
) int x
, y
; { return -1; }
4968 void volatile pause () {}
4969 sigsetmask (x
) int x
; { return 0; }
4970 sigblock (mask
) int mask
; { return 0; }
4973 void request_sigio (void) {}
4974 setpgrp () {return 0; }
4975 setpriority (x
,y
,z
) int x
,y
,z
; { return 0; }
4976 void unrequest_sigio (void) {}
4980 #ifdef POSIX_SIGNALS
4982 /* Augment DJGPP library POSIX signal functions. This is needed
4983 as of DJGPP v2.01, but might be in the library in later releases. */
4985 #include <libc/bss.h>
4987 /* A counter to know when to re-initialize the static sets. */
4988 static int sigprocmask_count
= -1;
4990 /* Which signals are currently blocked (initially none). */
4991 static sigset_t current_mask
;
4993 /* Which signals are pending (initially none). */
4994 static sigset_t pending_signals
;
4996 /* Previous handlers to restore when the blocked signals are unblocked. */
4997 typedef void (*sighandler_t
)(int);
4998 static sighandler_t prev_handlers
[320];
5000 /* A signal handler which just records that a signal occured
5001 (it will be raised later, if and when the signal is unblocked). */
5003 sig_suspender (signo
)
5006 sigaddset (&pending_signals
, signo
);
5010 sigprocmask (how
, new_set
, old_set
)
5012 const sigset_t
*new_set
;
5018 /* If called for the first time, initialize. */
5019 if (sigprocmask_count
!= __bss_count
)
5021 sigprocmask_count
= __bss_count
;
5022 sigemptyset (&pending_signals
);
5023 sigemptyset (¤t_mask
);
5024 for (signo
= 0; signo
< 320; signo
++)
5025 prev_handlers
[signo
] = SIG_ERR
;
5029 *old_set
= current_mask
;
5034 if (how
!= SIG_BLOCK
&& how
!= SIG_UNBLOCK
&& how
!= SIG_SETMASK
)
5040 sigemptyset (&new_mask
);
5042 /* DJGPP supports upto 320 signals. */
5043 for (signo
= 0; signo
< 320; signo
++)
5045 if (sigismember (¤t_mask
, signo
))
5046 sigaddset (&new_mask
, signo
);
5047 else if (sigismember (new_set
, signo
) && how
!= SIG_UNBLOCK
)
5049 sigaddset (&new_mask
, signo
);
5051 /* SIGKILL is silently ignored, as on other platforms. */
5052 if (signo
!= SIGKILL
&& prev_handlers
[signo
] == SIG_ERR
)
5053 prev_handlers
[signo
] = signal (signo
, sig_suspender
);
5055 if (( how
== SIG_UNBLOCK
5056 && sigismember (&new_mask
, signo
)
5057 && sigismember (new_set
, signo
))
5058 || (how
== SIG_SETMASK
5059 && sigismember (&new_mask
, signo
)
5060 && !sigismember (new_set
, signo
)))
5062 sigdelset (&new_mask
, signo
);
5063 if (prev_handlers
[signo
] != SIG_ERR
)
5065 signal (signo
, prev_handlers
[signo
]);
5066 prev_handlers
[signo
] = SIG_ERR
;
5068 if (sigismember (&pending_signals
, signo
))
5070 sigdelset (&pending_signals
, signo
);
5075 current_mask
= new_mask
;
5079 #else /* not POSIX_SIGNALS */
5081 sigsetmask (x
) int x
; { return 0; }
5082 sigblock (mask
) int mask
; { return 0; }
5084 #endif /* not POSIX_SIGNALS */
5085 #endif /* __DJGPP__ > 1 */
5088 #include "sysselect.h"
5090 #ifndef EMACS_TIME_ZERO_OR_NEG_P
5091 #define EMACS_TIME_ZERO_OR_NEG_P(time) \
5092 ((long)(time).tv_sec < 0 \
5093 || ((time).tv_sec == 0 \
5094 && (long)(time).tv_usec <= 0))
5097 /* This yields the rest of the current time slice to the task manager.
5098 It should be called by any code which knows that it has nothing
5099 useful to do except idle.
5101 I don't use __dpmi_yield here, since versions of library before 2.02
5102 called Int 2Fh/AX=1680h there in a way that would wedge the DOS box
5103 on some versions of Windows 9X. */
5106 dos_yield_time_slice (void)
5108 _go32_dpmi_registers r
;
5111 r
.x
.ss
= r
.x
.sp
= r
.x
.flags
= 0;
5112 _go32_dpmi_simulate_int (0x2f, &r
);
5117 /* Only event queue is checked. */
5118 /* We don't have to call timer_check here
5119 because wait_reading_process_input takes care of that. */
5121 sys_select (nfds
, rfds
, wfds
, efds
, timeout
)
5123 SELECT_TYPE
*rfds
, *wfds
, *efds
;
5124 EMACS_TIME
*timeout
;
5132 check_input
= FD_ISSET (0, rfds
);
5143 /* If we are looking only for the terminal, with no timeout,
5144 just read it and wait -- that's more efficient. */
5147 while (!detect_input_pending ())
5149 dos_yield_time_slice ();
5154 EMACS_TIME clnow
, cllast
, cldiff
;
5157 EMACS_SET_SECS_USECS (cllast
, t
.ti_sec
, t
.ti_hund
* 10000L);
5159 while (!check_input
|| !detect_input_pending ())
5162 EMACS_SET_SECS_USECS (clnow
, t
.ti_sec
, t
.ti_hund
* 10000L);
5163 EMACS_SUB_TIME (cldiff
, clnow
, cllast
);
5165 /* When seconds wrap around, we assume that no more than
5166 1 minute passed since last `gettime'. */
5167 if (EMACS_TIME_NEG_P (cldiff
))
5168 EMACS_SET_SECS (cldiff
, EMACS_SECS (cldiff
) + 60);
5169 EMACS_SUB_TIME (*timeout
, *timeout
, cldiff
);
5171 /* Stop when timeout value crosses zero. */
5172 if (EMACS_TIME_ZERO_OR_NEG_P (*timeout
))
5175 dos_yield_time_slice ();
5185 * Define overlaid functions:
5187 * chdir -> sys_chdir
5188 * tzset -> init_gettimeofday
5189 * abort -> dos_abort
5194 extern int chdir ();
5200 int len
= strlen (path
);
5201 char *tmp
= (char *)path
;
5203 if (*tmp
&& tmp
[1] == ':')
5205 if (getdisk () != tolower (tmp
[0]) - 'a')
5206 setdisk (tolower (tmp
[0]) - 'a');
5207 tmp
+= 2; /* strip drive: KFS 1995-07-06 */
5211 if (len
> 1 && (tmp
[len
- 1] == '/'))
5213 char *tmp1
= (char *) alloca (len
+ 1);
5224 extern void tzset (void);
5227 init_gettimeofday ()
5233 ltm
= gtm
= time (NULL
);
5234 ltm
= mktime (lstm
= localtime (<m
));
5235 gtm
= mktime (gmtime (>m
));
5236 time_rec
.tm_hour
= 99; /* force gettimeofday to get date */
5237 time_rec
.tm_isdst
= lstm
->tm_isdst
;
5238 dos_timezone_offset
= time_rec
.tm_gmtoff
= (int)(gtm
- ltm
) / 60;
5245 dos_abort (file
, line
)
5249 char buffer1
[200], buffer2
[400];
5252 sprintf (buffer1
, "<EMACS FATAL ERROR IN %s LINE %d>", file
, line
);
5253 for (i
= j
= 0; buffer1
[i
]; i
++) {
5254 buffer2
[j
++] = buffer1
[i
];
5255 buffer2
[j
++] = 0x70;
5257 dosmemput (buffer2
, j
, (int)ScreenPrimary
);
5258 ScreenSetCursor (2, 0);
5266 ScreenSetCursor (10, 0);
5267 cputs ("\r\n\nEmacs aborted!\r\n");
5269 #if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
5270 if (screen_virtual_segment
)
5271 dosv_refresh_virtual_screen (2 * 10 * screen_size_X
, 4 * screen_size_X
);
5272 /* Generate traceback, so we could tell whodunit. */
5273 signal (SIGINT
, SIG_DFL
);
5274 __asm__
__volatile__ ("movb $0x1b,%al;call ___djgpp_hw_exception");
5275 #else /* __DJGPP_MINOR__ >= 2 */
5277 #endif /* __DJGPP_MINOR__ >= 2 */
5283 /* The following variables are required so that cus-start.el won't
5284 complain about unbound variables. */
5285 #ifndef subprocesses
5286 /* Nonzero means delete a process right away if it exits (process.c). */
5287 static int delete_exited_processes
;
5292 recent_doskeys
= Fmake_vector (make_number (NUM_RECENT_DOSKEYS
), Qnil
);
5293 staticpro (&recent_doskeys
);
5294 #ifndef HAVE_X_WINDOWS
5296 staticpro (&help_echo
);
5297 help_echo_object
= Qnil
;
5298 staticpro (&help_echo_object
);
5299 help_echo_window
= Qnil
;
5300 staticpro (&help_echo_window
);
5301 previous_help_echo
= Qnil
;
5302 staticpro (&previous_help_echo
);
5305 /* The following two are from xfns.c: */
5306 Qbar
= intern ("bar");
5308 Qcursor_type
= intern ("cursor-type");
5309 staticpro (&Qcursor_type
);
5310 Qreverse
= intern ("reverse");
5311 staticpro (&Qreverse
);
5313 DEFVAR_LISP ("dos-unsupported-char-glyph", &Vdos_unsupported_char_glyph
,
5314 doc
: /* *Glyph to display instead of chars not supported by current codepage.
5316 This variable is used only by MSDOS terminals. */);
5317 Vdos_unsupported_char_glyph
= '\177';
5319 #ifndef subprocesses
5320 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
5321 doc
: /* *Non-nil means delete processes immediately when they exit.
5322 nil means don't delete them until `list-processes' is run. */);
5323 delete_exited_processes
= 0;
5326 defsubr (&Srecent_doskeys
);
5327 defsubr (&Smsdos_long_file_names
);
5328 defsubr (&Smsdos_downcase_filename
);
5329 defsubr (&Smsdos_remember_default_colors
);
5330 defsubr (&Smsdos_set_mouse_buttons
);