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. */
43 #include <io.h> /* for setmode */
44 #include <dpmi.h> /* for __dpmi_xxx stuff */
45 #include <sys/farptr.h> /* for _farsetsel, _farnspokeb */
46 #include <libc/dosio.h> /* for _USE_LFN */
47 #include <conio.h> /* for cputs */
52 #include "termhooks.h"
54 #include "dispextern.h"
64 #include "blockinput.h"
69 /* #include <process.h> */
70 /* Damn that local process.h! Instead we can define P_WAIT ourselves. */
78 #define _dos_ds _go32_info_block.selector_for_linear_memory
84 #include "syssignal.h"
90 /* If other `malloc' than ours is used, force our `sbrk' behave like
91 Unix programs expect (resize memory blocks to keep them contiguous).
92 If `sbrk' from `ralloc.c' is NOT used, also zero-out sbrk'ed memory,
93 because that's what `gmalloc' expects to get. */
97 int _crt0_startup_flags
= _CRT0_FLAG_UNIX_SBRK
;
98 #else /* not REL_ALLOC */
99 int _crt0_startup_flags
= (_CRT0_FLAG_UNIX_SBRK
| _CRT0_FLAG_FILL_SBRK_MEMORY
);
100 #endif /* not REL_ALLOC */
101 #endif /* GNU_MALLOC */
103 #endif /* not SYSTEM_MALLOC */
104 #endif /* __DJGPP__ > 1 */
123 /* ------------------------ Mouse control ---------------------------
125 * Coordinates are in screen positions and zero based.
126 * Mouse buttons are numbered from left to right and also zero based.
129 /* This used to be in termhooks.h, but mainstream Emacs code no longer
130 uses it, and it was removed... */
131 #define NUM_MOUSE_BUTTONS (5)
133 int have_mouse
; /* 0: no, 1: enabled, -1: disabled */
134 static int mouse_visible
;
136 static int mouse_last_x
;
137 static int mouse_last_y
;
139 static int mouse_button_translate
[NUM_MOUSE_BUTTONS
];
140 static int mouse_button_count
;
147 if (have_mouse
> 0 && !mouse_visible
)
150 fprintf (termscript
, "<M_ON>");
152 int86 (0x33, ®s
, ®s
);
162 if (have_mouse
> 0 && mouse_visible
)
165 fprintf (termscript
, "<M_OFF>");
167 int86 (0x33, ®s
, ®s
);
173 mouse_setup_buttons (int n_buttons
)
177 mouse_button_count
= 3;
178 mouse_button_translate
[0] = 0; /* Left */
179 mouse_button_translate
[1] = 2; /* Middle */
180 mouse_button_translate
[2] = 1; /* Right */
182 else /* two, what else? */
184 mouse_button_count
= 2;
185 mouse_button_translate
[0] = 0;
186 mouse_button_translate
[1] = 1;
190 DEFUN ("msdos-set-mouse-buttons", Fmsdos_set_mouse_buttons
, Smsdos_set_mouse_buttons
,
191 1, 1, "NSet number of mouse buttons to: ",
192 "Set the number of mouse buttons to use by Emacs.\n\
193 This is useful with mice that report the number of buttons inconsistently,\n\
194 e.g., if the number of buttons is reported as 3, but Emacs only sees 2 of\n\
195 them. This happens with wheeled mice on Windows 9X, for example.")
197 Lisp_Object nbuttons
;
201 CHECK_NUMBER (nbuttons
, 0);
204 Fsignal (Qargs_out_of_range
,
205 Fcons (build_string ("only 2 or 3 mouse buttons are supported"),
206 Fcons (nbuttons
, Qnil
)));
207 mouse_setup_buttons (n
);
212 mouse_get_xy (int *x
, int *y
)
217 int86 (0x33, ®s
, ®s
);
229 fprintf (termscript
, "<M_XY=%dx%d>", x
, y
);
231 mouse_last_x
= regs
.x
.cx
= x
* 8;
232 mouse_last_y
= regs
.x
.dx
= y
* 8;
233 int86 (0x33, ®s
, ®s
);
237 mouse_pressed (b
, xp
, yp
)
242 if (b
>= mouse_button_count
)
245 regs
.x
.bx
= mouse_button_translate
[b
];
246 int86 (0x33, ®s
, ®s
);
248 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
249 return (regs
.x
.bx
!= 0);
253 mouse_released (b
, xp
, yp
)
258 if (b
>= mouse_button_count
)
261 regs
.x
.bx
= mouse_button_translate
[b
];
262 int86 (0x33, ®s
, ®s
);
264 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
265 return (regs
.x
.bx
!= 0);
269 mouse_button_depressed (b
, xp
, yp
)
274 if (b
>= mouse_button_count
)
277 int86 (0x33, ®s
, ®s
);
278 if ((regs
.x
.bx
& (1 << mouse_button_translate
[b
])) != 0)
288 mouse_get_pos (f
, insist
, bar_window
, part
, x
, y
, time
)
291 Lisp_Object
*bar_window
, *x
, *y
;
292 enum scroll_bar_part
*part
;
296 Lisp_Object frame
, tail
;
298 /* Clear the mouse-moved flag for every frame on this display. */
299 FOR_EACH_FRAME (tail
, frame
)
300 XFRAME (frame
)->mouse_moved
= 0;
302 *f
= SELECTED_FRAME();
304 mouse_get_xy (&ix
, &iy
);
305 *time
= event_timestamp ();
306 *x
= make_number (mouse_last_x
= ix
);
307 *y
= make_number (mouse_last_y
= iy
);
315 mouse_get_xy (&x
, &y
);
316 SELECTED_FRAME()->mouse_moved
|= (x
!= mouse_last_x
|| y
!= mouse_last_y
);
321 /* Force the mouse driver to ``forget'' about any button clicks until
324 mouse_clear_clicks (void)
328 for (b
= 0; b
< mouse_button_count
; b
++)
330 int dummy_x
, dummy_y
;
332 (void) mouse_pressed (b
, &dummy_x
, &dummy_y
);
333 (void) mouse_released (b
, &dummy_x
, &dummy_y
);
343 fprintf (termscript
, "<M_INIT>");
346 int86 (0x33, ®s
, ®s
);
348 /* Reset the mouse last press/release info. It seems that Windows
349 doesn't do that automatically when function 21h is called, which
350 causes Emacs to ``remember'' the click that switched focus to the
351 window just before Emacs was started from that window. */
352 mouse_clear_clicks ();
356 regs
.x
.dx
= 8 * (ScreenCols () - 1);
357 int86 (0x33, ®s
, ®s
);
361 regs
.x
.dx
= 8 * (ScreenRows () - 1);
362 int86 (0x33, ®s
, ®s
);
368 /* ------------------------- Screen control ----------------------
372 static int internal_terminal
= 0;
374 #ifndef HAVE_X_WINDOWS
375 extern unsigned char ScreenAttrib
;
376 static int screen_face
;
378 static int screen_size_X
;
379 static int screen_size_Y
;
380 static int screen_size
;
382 static int current_pos_X
;
383 static int current_pos_Y
;
384 static int new_pos_X
;
385 static int new_pos_Y
;
387 static void *startup_screen_buffer
;
388 static int startup_screen_size_X
;
389 static int startup_screen_size_Y
;
390 static int startup_pos_X
;
391 static int startup_pos_Y
;
392 static unsigned char startup_screen_attrib
;
394 static clock_t startup_time
;
396 static int term_setup_done
;
398 static unsigned short outside_cursor
;
400 /* Similar to the_only_frame. */
401 struct x_output the_only_x_display
;
403 /* Support for DOS/V (allows Japanese characters to be displayed on
404 standard, non-Japanese, ATs). Only supported for DJGPP v2 and later. */
406 /* Holds the address of the text-mode screen buffer. */
407 static unsigned long screen_old_address
= 0;
408 /* Segment and offset of the virtual screen. If 0, DOS/V is NOT loaded. */
409 static unsigned short screen_virtual_segment
= 0;
410 static unsigned short screen_virtual_offset
= 0;
411 /* A flag to control how to display unibyte 8-bit characters. */
412 extern int unibyte_display_via_language_environment
;
417 /* Update the screen from a part of relocated DOS/V screen buffer which
418 begins at OFFSET and includes COUNT characters. */
420 dosv_refresh_virtual_screen (int offset
, int count
)
424 if (offset
< 0 || count
< 0) /* paranoia; invalid values crash DOS/V */
427 regs
.h
.ah
= 0xff; /* update relocated screen */
428 regs
.x
.es
= screen_virtual_segment
;
429 regs
.x
.di
= screen_virtual_offset
+ offset
;
431 __dpmi_int (0x10, ®s
);
436 dos_direct_output (y
, x
, buf
, len
)
442 int t0
= 2 * (x
+ y
* screen_size_X
);
443 int t
= t0
+ (int) ScreenPrimary
;
448 dosmemput (buf
++, 1, t
);
452 /* This is faster. */
453 for (_farsetsel (_dos_ds
); --len
>= 0; t
+= 2, buf
++)
454 _farnspokeb (t
, *buf
);
456 if (screen_virtual_segment
)
457 dosv_refresh_virtual_screen (t0
, l0
);
462 /* Flash the screen as a substitute for BEEPs. */
466 do_visible_bell (xorattr
)
467 unsigned char xorattr
;
472 movl _ScreenPrimary,%%eax \n\
479 xorb %%al,%%gs:(%%ebx) \n\
482 jne visible_bell_1 \n\
484 jne visible_bell_3 \n\
486 movzwl %%ax,%%eax \n\
487 movzwl %%ax,%%eax \n\
488 movzwl %%ax,%%eax \n\
489 movzwl %%ax,%%eax \n\
491 jne visible_bell_2 \n\
492 jmp visible_bell_0 \n\
495 : "m" (xorattr
), "g" (screen_size
)
496 : "%eax", "%ebx", /* "%gs",*/ "%ecx", "%edx");
500 ScreenVisualBell (void)
502 /* This creates an xor-mask that will swap the default fore- and
503 background colors. */
504 do_visible_bell (((the_only_x_display
.foreground_pixel
505 ^ the_only_x_display
.background_pixel
)
510 #ifndef HAVE_X_WINDOWS
512 static int blink_bit
= -1; /* the state of the blink bit at startup */
514 /* Enable bright background colors. */
520 /* Remember the original state of the blink/bright-background bit.
521 It is stored at 0040:0065h in the BIOS data area. */
523 blink_bit
= (_farpeekb (_dos_ds
, 0x465) & 0x20) == 0x20;
527 int86 (0x10, ®s
, ®s
);
530 /* Disable bright background colors (and enable blinking) if we found
531 the video system in that state at startup. */
533 maybe_enable_blinking (void)
541 int86 (0x10, ®s
, ®s
);
545 /* Return non-zero if the system has a VGA adapter. */
552 int86 (0x10, ®s
, ®s
);
553 if (regs
.h
.al
== 0x1a && regs
.h
.bl
> 5 && regs
.h
.bl
< 13)
558 /* Set the screen dimensions so that it can show no less than
559 ROWS x COLS frame. */
562 dos_set_window_size (rows
, cols
)
566 Lisp_Object video_mode
;
567 int video_mode_value
;
570 int current_rows
= ScreenRows (), current_cols
= ScreenCols ();
572 if (*rows
== current_rows
&& *cols
== current_cols
)
576 have_vga
= vga_installed ();
578 /* If the user specified a special video mode for these dimensions,
580 sprintf (video_name
, "screen-dimensions-%dx%d", *rows
, *cols
);
581 video_mode
= XSYMBOL (Fintern_soft (build_string (video_name
),
584 if (INTEGERP (video_mode
)
585 && (video_mode_value
= XINT (video_mode
)) > 0)
587 regs
.x
.ax
= video_mode_value
;
588 int86 (0x10, ®s
, ®s
);
592 /* Must hardware-reset the mouse, or else it won't update
593 its notion of screen dimensions for some non-standard
594 video modes. This is *painfully* slow... */
596 int86 (0x33, ®s
, ®s
);
600 /* Find one of the dimensions supported by standard EGA/VGA
601 which gives us at least the required dimensions. */
610 } std_dimension
[] = {
620 while (i
< sizeof (std_dimension
) / sizeof (std_dimension
[0]))
622 if (std_dimension
[i
].need_vga
<= have_vga
623 && std_dimension
[i
].rows
>= *rows
)
625 if (std_dimension
[i
].rows
!= current_rows
626 || *cols
!= current_cols
)
627 _set_screen_lines (std_dimension
[i
].rows
);
634 #else /* not __DJGPP__ > 1 */
636 else if (*rows
<= 25)
638 if (current_rows
!= 25 || current_cols
!= 80)
641 int86 (0x10, ®s
, ®s
);
644 int86 (0x10, ®s
, ®s
);
647 int86 (0x10, ®s
, ®s
);
649 int86 (0x10, ®s
, ®s
);
652 else if (*rows
<= 50)
653 if (have_vga
&& (current_rows
!= 50 || current_cols
!= 80)
654 || *rows
<= 43 && (current_rows
!= 43 || current_cols
!= 80))
657 int86 (0x10, ®s
, ®s
);
660 int86 (0x10, ®s
, ®s
);
663 int86 (0x10, ®s
, ®s
);
666 int86 (0x10, ®s
, ®s
);
668 #endif /* not __DJGPP__ > 1 */
676 /* Tell the caller what dimensions have been REALLY set. */
677 *rows
= ScreenRows ();
678 *cols
= ScreenCols ();
680 /* Update Emacs' notion of screen dimensions. */
681 screen_size_X
= *cols
;
682 screen_size_Y
= *rows
;
683 screen_size
= *cols
* *rows
;
686 /* If the dimensions changed, the mouse highlight info is invalid. */
687 if (current_rows
!= *rows
|| current_cols
!= *cols
)
689 struct frame
*f
= SELECTED_FRAME();
690 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
691 Lisp_Object window
= dpyinfo
->mouse_face_window
;
693 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
695 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
696 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
697 dpyinfo
->mouse_face_window
= Qnil
;
702 /* Enable bright background colors. */
705 /* FIXME: I'm not sure the above will run at all on DOS/V. But let's
706 be defensive anyway. */
707 if (screen_virtual_segment
)
708 dosv_refresh_virtual_screen (0, *cols
* *rows
);
711 /* If we write a character in the position where the mouse is,
712 the mouse cursor may need to be refreshed. */
722 mouse_get_xy (&x
, &y
);
723 if (y
!= new_pos_Y
|| x
< new_pos_X
)
729 #define DEFAULT_CURSOR_START (-1)
730 #define DEFAULT_CURSOR_WIDTH (-1)
731 #define BOX_CURSOR_WIDTH (-32)
733 /* Set cursor to begin at scan line START_LINE in the character cell
734 and extend for WIDTH scan lines. Scan lines are counted from top
735 of the character cell, starting from zero. */
737 msdos_set_cursor_shape (struct frame
*f
, int start_line
, int width
)
740 unsigned desired_cursor
;
742 int max_line
, top_line
, bot_line
;
744 /* Avoid the costly BIOS call if F isn't the currently selected
745 frame. Allow for NULL as unconditionally meaning the selected
747 if (f
&& f
!= SELECTED_FRAME())
750 /* The character cell size in scan lines is stored at 40:85 in the
752 max_line
= _farpeekw (_dos_ds
, 0x485) - 1;
755 default: /* this relies on CGA cursor emulation being ON! */
772 if (width
== BOX_CURSOR_WIDTH
)
777 else if (start_line
!= DEFAULT_CURSOR_START
)
779 top_line
= start_line
;
780 bot_line
= top_line
- width
- 1;
782 else if (width
!= DEFAULT_CURSOR_WIDTH
)
785 bot_line
= -1 - width
;
788 top_line
= bot_line
+ 1;
792 /* [31, 0] seems to DTRT for all screen sizes. */
796 else /* WIDTH is positive */
798 if (start_line
!= DEFAULT_CURSOR_START
)
799 bot_line
= start_line
;
800 top_line
= bot_line
- (width
- 1);
803 /* If the current cursor shape is already what they want, we are
805 desired_cursor
= ((top_line
& 0x1f) << 8) | (bot_line
& 0x1f);
806 if (desired_cursor
== _farpeekw (_dos_ds
, 0x460))
810 regs
.x
.cx
= desired_cursor
;
811 __dpmi_int (0x10, ®s
);
812 #endif /* __DJGPP__ > 1 */
816 IT_set_cursor_type (struct frame
*f
, Lisp_Object cursor_type
)
818 if (EQ (cursor_type
, Qbar
))
820 /* Just BAR means the normal EGA/VGA cursor. */
821 msdos_set_cursor_shape (f
, DEFAULT_CURSOR_START
, DEFAULT_CURSOR_WIDTH
);
823 else if (CONSP (cursor_type
) && EQ (XCAR (cursor_type
), Qbar
))
825 Lisp_Object bar_parms
= XCDR (cursor_type
);
828 if (INTEGERP (bar_parms
))
830 /* Feature: negative WIDTH means cursor at the top
831 of the character cell, zero means invisible cursor. */
832 width
= XINT (bar_parms
);
833 msdos_set_cursor_shape (f
, width
>= 0 ? DEFAULT_CURSOR_START
: 0,
836 else if (CONSP (bar_parms
)
837 && INTEGERP (XCAR (bar_parms
))
838 && INTEGERP (XCDR (bar_parms
)))
840 int start_line
= XINT (XCDR (bar_parms
));
842 width
= XINT (XCAR (bar_parms
));
843 msdos_set_cursor_shape (f
, start_line
, width
);
847 /* Treat anything unknown as "box cursor". This includes nil, so
848 that a frame which doesn't specify a cursor type gets a box,
849 which is the default in Emacs. */
850 msdos_set_cursor_shape (f
, 0, BOX_CURSOR_WIDTH
);
863 union REGS inregs
, outregs
;
866 intdos (&inregs
, &outregs
);
870 /* Given a face id FACE, extract the face parameters to be used for
871 display until the face changes. The face parameters (actually, its
872 color) are used to construct the video attribute byte for each
873 glyph during the construction of the buffer that is then blitted to
876 IT_set_face (int face
)
878 struct frame
*sf
= SELECTED_FRAME();
879 struct face
*fp
= FACE_FROM_ID (sf
, face
);
880 struct face
*dfp
= FACE_FROM_ID (sf
, DEFAULT_FACE_ID
);
881 unsigned long fg
, bg
, dflt_fg
, dflt_bg
;
886 /* The default face for the frame should always be realized and
894 dflt_fg
= dfp
->foreground
;
895 dflt_bg
= dfp
->background
;
897 /* Don't use invalid colors. In particular, FACE_TTY_DEFAULT_* colors
898 mean use the colors of the default face. Note that we assume all
899 16 colors to be available for the background, since Emacs switches
900 on this mode (and loses the blinking attribute) at startup. */
901 if (fg
== FACE_TTY_DEFAULT_COLOR
|| fg
== FACE_TTY_DEFAULT_FG_COLOR
)
902 fg
= FRAME_FOREGROUND_PIXEL (sf
);
903 else if (fg
== FACE_TTY_DEFAULT_BG_COLOR
)
904 fg
= FRAME_BACKGROUND_PIXEL (sf
);
905 if (bg
== FACE_TTY_DEFAULT_COLOR
|| bg
== FACE_TTY_DEFAULT_BG_COLOR
)
906 bg
= FRAME_BACKGROUND_PIXEL (sf
);
907 else if (bg
== FACE_TTY_DEFAULT_FG_COLOR
)
908 bg
= FRAME_FOREGROUND_PIXEL (sf
);
910 /* Make sure highlighted lines really stand out, come what may. */
911 if (fp
->tty_reverse_p
&& (fg
== dflt_fg
&& bg
== dflt_bg
))
913 unsigned long tem
= fg
;
918 /* If the user requested inverse video, obey. */
921 unsigned long tem2
= fg
;
927 fprintf (termscript
, "<FACE %d: %d/%d[FG:%d/BG:%d]>", face
,
928 fp
->foreground
, fp
->background
, fg
, bg
);
929 if (fg
>= 0 && fg
< 16)
931 ScreenAttrib
&= 0xf0;
934 if (bg
>= 0 && bg
< 16)
936 ScreenAttrib
&= 0x0f;
937 ScreenAttrib
|= ((bg
& 0x0f) << 4);
941 Lisp_Object Vdos_unsupported_char_glyph
;
944 IT_write_glyphs (struct glyph
*str
, int str_len
)
946 unsigned char *screen_buf
, *screen_bp
, *screen_buf_end
, *bp
;
947 int unsupported_face
= FAST_GLYPH_FACE (Vdos_unsupported_char_glyph
);
948 unsigned unsupported_char
= FAST_GLYPH_CHAR (Vdos_unsupported_char_glyph
);
949 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
950 register int sl
= str_len
;
951 register int tlen
= GLYPH_TABLE_LENGTH
;
952 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
954 /* If terminal_coding does any conversion, use it, otherwise use
955 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
956 because it always returns 1 if terminal_coding.src_multibyte is 1. */
957 struct coding_system
*coding
=
958 (terminal_coding
.common_flags
& CODING_REQUIRE_ENCODING_MASK
960 : &safe_terminal_coding
);
963 /* Do we need to consider conversion of unibyte characters to
965 int convert_unibyte_characters
966 = (NILP (current_buffer
->enable_multibyte_characters
)
967 && unibyte_display_via_language_environment
);
969 unsigned char conversion_buffer
[256];
970 int conversion_buffer_size
= sizeof conversion_buffer
;
972 if (str_len
<= 0) return;
974 screen_buf
= screen_bp
= alloca (str_len
* 2);
975 screen_buf_end
= screen_buf
+ str_len
* 2;
976 sf
= SELECTED_FRAME();
978 /* Since faces get cached and uncached behind our back, we can't
979 rely on their indices in the cache being consistent across
980 invocations. So always reset the screen face to the default
981 face of the frame, before writing glyphs, and let the glyphs
982 set the right face if it's different from the default. */
983 IT_set_face (DEFAULT_FACE_ID
);
985 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
987 terminal_coding
.mode
&= ~CODING_MODE_LAST_BLOCK
;
990 int cf
, chlen
, enclen
;
991 unsigned char workbuf
[MAX_MULTIBYTE_LENGTH
], *buf
;
994 /* Glyphs with GLYPH_MASK_PADDING bit set are actually there
995 only for the redisplay code to know how many columns does
996 this character occupy on the screen. Skip padding glyphs. */
997 if (CHAR_GLYPH_PADDING_P (*str
))
1004 register GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*str
);
1005 int glyph_not_in_table
= 0;
1007 /* If g is negative, it means we have a multibyte character
1008 in *str. That's what GLYPH_FROM_CHAR_GLYPH returns for
1009 multibyte characters. */
1010 if (g
< 0 || g
>= tlen
)
1012 /* This glyph doesn't have an entry in Vglyph_table. */
1014 glyph_not_in_table
= 1;
1018 /* This glyph has an entry in Vglyph_table, so process
1019 any aliases before testing for simpleness. */
1020 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
1021 ch
= FAST_GLYPH_CHAR (g
);
1024 /* Convert the character code to multibyte, if they
1025 requested display via language environment. We only want
1026 to convert unibyte characters to multibyte in unibyte
1027 buffers! Otherwise, the 8-bit value in CH came from the
1028 display table set up to display foreign characters. */
1029 if (SINGLE_BYTE_CHAR_P (ch
) && convert_unibyte_characters
1031 || (ch
>= 0200 && !NILP (Vnonascii_translation_table
))))
1032 ch
= unibyte_char_to_multibyte (ch
);
1034 /* Invalid characters are displayed with a special glyph. */
1035 if (! CHAR_VALID_P (ch
, 0))
1037 g
= !NILP (Vdos_unsupported_char_glyph
)
1038 ? Vdos_unsupported_char_glyph
1039 : MAKE_GLYPH (sf
, '\177', GLYPH_FACE (sf
, g
));
1040 ch
= FAST_GLYPH_CHAR (g
);
1043 /* If the face of this glyph is different from the current
1044 screen face, update the screen attribute byte. */
1046 if (cf
!= screen_face
)
1047 IT_set_face (cf
); /* handles invalid faces gracefully */
1049 if (glyph_not_in_table
|| GLYPH_SIMPLE_P (tbase
, tlen
, g
))
1051 /* We generate the multi-byte form of CH in WORKBUF. */
1052 chlen
= CHAR_STRING (ch
, workbuf
);
1057 /* We have a string in Vglyph_table. */
1058 chlen
= GLYPH_LENGTH (tbase
, g
);
1059 buf
= GLYPH_STRING (tbase
, g
);
1062 /* If the character is not multibyte, don't bother converting it. */
1065 *conversion_buffer
= (unsigned char)ch
;
1071 coding
->src_multibyte
= 1;
1072 encode_coding (coding
, buf
, conversion_buffer
, chlen
,
1073 conversion_buffer_size
);
1074 chlen
-= coding
->consumed
;
1075 enclen
= coding
->produced
;
1077 /* Replace glyph codes that cannot be converted by
1078 terminal_coding with Vdos_unsupported_char_glyph. */
1079 if (*conversion_buffer
== '?')
1081 unsigned char *cbp
= conversion_buffer
;
1083 while (cbp
< conversion_buffer
+ enclen
&& *cbp
== '?')
1084 *cbp
++ = unsupported_char
;
1085 if (unsupported_face
!= screen_face
)
1086 IT_set_face (unsupported_face
);
1090 if (enclen
+ chlen
> screen_buf_end
- screen_bp
)
1092 /* The allocated buffer for screen writes is too small.
1093 Flush it and loop again without incrementing STR, so
1094 that the next loop will begin with the same glyph. */
1095 int nbytes
= screen_bp
- screen_buf
;
1098 dosmemput (screen_buf
, nbytes
, (int)ScreenPrimary
+ offset
);
1099 if (screen_virtual_segment
)
1100 dosv_refresh_virtual_screen (offset
, nbytes
/ 2);
1101 new_pos_X
+= nbytes
/ 2;
1104 /* Prepare to reuse the same buffer again. */
1105 screen_bp
= screen_buf
;
1109 /* There's enough place in the allocated buffer to add
1110 the encoding of this glyph. */
1112 /* First, copy the encoded bytes. */
1113 for (bp
= conversion_buffer
; enclen
--; bp
++)
1115 *screen_bp
++ = (unsigned char)*bp
;
1116 *screen_bp
++ = ScreenAttrib
;
1118 fputc (*bp
, termscript
);
1121 /* Now copy the bytes not consumed by the encoding. */
1124 buf
+= coding
->consumed
;
1128 fputc (*buf
, termscript
);
1129 *screen_bp
++ = (unsigned char)*buf
++;
1130 *screen_bp
++ = ScreenAttrib
;
1134 /* Update STR and its remaining length. */
1141 /* Dump whatever is left in the screen buffer. */
1143 dosmemput (screen_buf
, screen_bp
- screen_buf
, (int)ScreenPrimary
+ offset
);
1144 if (screen_virtual_segment
)
1145 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1146 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1148 /* We may have to output some codes to terminate the writing. */
1149 if (CODING_REQUIRE_FLUSHING (coding
))
1151 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
1152 encode_coding (coding
, "", conversion_buffer
, 0, conversion_buffer_size
);
1153 if (coding
->produced
> 0)
1155 screen_buf
= alloca (coding
->produced
* 2);
1156 for (screen_bp
= screen_buf
, bp
= conversion_buffer
;
1157 coding
->produced
--; bp
++)
1159 *screen_bp
++ = (unsigned char)*bp
;
1160 *screen_bp
++ = ScreenAttrib
;
1162 fputc (*bp
, termscript
);
1164 offset
+= screen_bp
- screen_buf
;
1166 dosmemput (screen_buf
, screen_bp
- screen_buf
,
1167 (int)ScreenPrimary
+ offset
);
1168 if (screen_virtual_segment
)
1169 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
1170 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
1175 /************************************************************************
1176 Mouse Highlight (and friends..)
1177 ************************************************************************/
1179 /* This is used for debugging, to turn off note_mouse_highlight. */
1180 int disable_mouse_highlight
;
1182 /* If non-nil, dos_rawgetc generates an event to display that string.
1183 (The display is done in keyboard.c:read_char, by calling
1185 static Lisp_Object help_echo
;
1186 static Lisp_Object previous_help_echo
; /* a helper temporary variable */
1188 /* These record the window, the object and the position where the help
1189 echo string was generated. */
1190 static Lisp_Object help_echo_window
;
1191 static Lisp_Object help_echo_object
;
1192 static int help_echo_pos
;
1194 static int mouse_preempted
= 0; /* non-zero when XMenu gobbles mouse events */
1196 /* Set the mouse pointer shape according to whether it is in the
1197 area where the mouse highlight is in effect. */
1199 IT_set_mouse_pointer (int mode
)
1201 /* A no-op for now. DOS text-mode mouse pointer doesn't offer too
1202 many possibilities to change its shape, and the available
1203 functionality pretty much sucks (e.g., almost every reasonable
1204 shape will conceal the character it is on). Since the color of
1205 the pointer changes in the highlighted area, it is not clear to
1206 me whether anything else is required, anyway. */
1209 /* Display the active region described by mouse_face_*
1210 in its mouse-face if HL > 0, in its normal face if HL = 0. */
1212 show_mouse_face (struct display_info
*dpyinfo
, int hl
)
1214 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
1215 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1220 /* If window is in the process of being destroyed, don't bother
1222 if (w
->current_matrix
== NULL
)
1223 goto set_cursor_shape
;
1225 /* Recognize when we are called to operate on rows that don't exist
1226 anymore. This can happen when a window is split. */
1227 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
1228 goto set_cursor_shape
;
1230 /* There's no sense to do anything if the mouse face isn't realized. */
1233 fp
= FACE_FROM_ID (SELECTED_FRAME(), dpyinfo
->mouse_face_face_id
);
1235 goto set_cursor_shape
;
1238 /* Note that mouse_face_beg_row etc. are window relative. */
1239 for (i
= dpyinfo
->mouse_face_beg_row
;
1240 i
<= dpyinfo
->mouse_face_end_row
;
1243 int start_hpos
, end_hpos
;
1244 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
1246 /* Don't do anything if row doesn't have valid contents. */
1247 if (!row
->enabled_p
)
1250 /* For all but the first row, the highlight starts at column 0. */
1251 if (i
== dpyinfo
->mouse_face_beg_row
)
1252 start_hpos
= dpyinfo
->mouse_face_beg_col
;
1256 if (i
== dpyinfo
->mouse_face_end_row
)
1257 end_hpos
= dpyinfo
->mouse_face_end_col
;
1259 end_hpos
= row
->used
[TEXT_AREA
];
1261 if (end_hpos
<= start_hpos
)
1263 /* Record that some glyphs of this row are displayed in
1265 row
->mouse_face_p
= hl
> 0;
1268 int vpos
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1269 int kstart
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1270 int nglyphs
= end_hpos
- start_hpos
;
1271 int offset
= ScreenPrimary
+ 2*(vpos
*screen_size_X
+ kstart
) + 1;
1272 int start_offset
= offset
;
1275 fprintf (termscript
, "\n<MH+ %d-%d:%d>",
1276 kstart
, kstart
+ nglyphs
- 1, vpos
);
1279 IT_set_face (dpyinfo
->mouse_face_face_id
);
1280 /* Since we are going to change only the _colors_ of the
1281 displayed text, there's no need to go through all the
1282 pain of generating and encoding the text from the glyphs.
1283 Instead, we simply poke the attribute byte of each
1284 affected position in video memory with the colors
1285 computed by IT_set_face! */
1286 _farsetsel (_dos_ds
);
1289 _farnspokeb (offset
, ScreenAttrib
);
1292 if (screen_virtual_segment
)
1293 dosv_refresh_virtual_screen (start_offset
, end_hpos
- start_hpos
);
1298 /* We are removing a previously-drawn mouse highlight. The
1299 safest way to do so is to redraw the glyphs anew, since
1300 all kinds of faces and display tables could have changed
1302 int nglyphs
= end_hpos
- start_hpos
;
1303 int save_x
= new_pos_X
, save_y
= new_pos_Y
;
1305 if (end_hpos
>= row
->used
[TEXT_AREA
])
1306 nglyphs
= row
->used
[TEXT_AREA
] - start_hpos
;
1308 /* IT_write_glyphs writes at cursor position, so we need to
1309 temporarily move cursor coordinates to the beginning of
1310 the highlight region. */
1311 new_pos_X
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1312 new_pos_Y
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1315 fprintf (termscript
, "<MH- %d-%d:%d>",
1316 new_pos_X
, new_pos_X
+ nglyphs
- 1, new_pos_Y
);
1317 IT_write_glyphs (row
->glyphs
[TEXT_AREA
] + start_hpos
, nglyphs
);
1319 fputs ("\n", termscript
);
1327 /* Change the mouse pointer shape. */
1328 IT_set_mouse_pointer (hl
);
1331 /* Clear out the mouse-highlighted active region.
1332 Redraw it un-highlighted first. */
1334 clear_mouse_face (struct display_info
*dpyinfo
)
1336 if (! NILP (dpyinfo
->mouse_face_window
))
1337 show_mouse_face (dpyinfo
, 0);
1339 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
1340 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
1341 dpyinfo
->mouse_face_window
= Qnil
;
1344 /* Find the glyph matrix position of buffer position POS in window W.
1345 *HPOS and *VPOS are set to the positions found. W's current glyphs
1346 must be up to date. If POS is above window start return (0, 0).
1347 If POS is after end of W, return end of last line in W. */
1349 fast_find_position (struct window
*w
, int pos
, int *hpos
, int *vpos
)
1353 int maybe_next_line_p
= 0;
1354 int line_start_position
;
1355 int yb
= window_text_bottom_y (w
);
1356 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
1357 struct glyph_row
*best_row
= row
;
1361 if (row
->used
[TEXT_AREA
])
1362 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
1364 line_start_position
= 0;
1366 if (line_start_position
> pos
)
1368 /* If the position sought is the end of the buffer,
1369 don't include the blank lines at the bottom of the window. */
1370 else if (line_start_position
== pos
1371 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
1373 maybe_next_line_p
= 1;
1376 else if (line_start_position
> 0)
1379 /* Don't overstep the last matrix row, lest we get into the
1380 never-never land... */
1381 if (row
->y
+ 1 >= yb
)
1387 /* Find the right column within BEST_ROW. */
1390 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
1392 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + i
;
1395 charpos
= glyph
->charpos
;
1402 else if (charpos
> pos
)
1404 else if (charpos
> 0)
1408 /* If we're looking for the end of the buffer,
1409 and we didn't find it in the line we scanned,
1410 use the start of the following line. */
1411 if (maybe_next_line_p
)
1418 *hpos
= lastcol
+ 1;
1422 /* Take proper action when mouse has moved to the mode or top line of
1423 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
1424 mode line. X is relative to the start of the text display area of
1425 W, so the width of bitmap areas and scroll bars must be subtracted
1426 to get a position relative to the start of the mode line. */
1428 IT_note_mode_line_highlight (struct window
*w
, int x
, int mode_line_p
)
1430 struct frame
*f
= XFRAME (w
->frame
);
1431 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1432 struct glyph_row
*row
;
1435 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1437 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1441 extern Lisp_Object Qhelp_echo
;
1442 struct glyph
*glyph
, *end
;
1443 Lisp_Object help
, map
;
1445 /* Find the glyph under X. */
1446 glyph
= row
->glyphs
[TEXT_AREA
]
1447 + x
- FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
1448 end
= glyph
+ row
->used
[TEXT_AREA
];
1450 && STRINGP (glyph
->object
)
1451 && XSTRING (glyph
->object
)->intervals
1452 && glyph
->charpos
>= 0
1453 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1455 /* If we're on a string with `help-echo' text property,
1456 arrange for the help to be displayed. This is done by
1457 setting the global variable help_echo to the help string. */
1458 help
= Fget_text_property (make_number (glyph
->charpos
),
1459 Qhelp_echo
, glyph
->object
);
1463 XSETWINDOW (help_echo_window
, w
);
1464 help_echo_object
= glyph
->object
;
1465 help_echo_pos
= glyph
->charpos
;
1471 /* Take proper action when the mouse has moved to position X, Y on
1472 frame F as regards highlighting characters that have mouse-face
1473 properties. Also de-highlighting chars where the mouse was before.
1474 X and Y can be negative or out of range. */
1476 IT_note_mouse_highlight (struct frame
*f
, int x
, int y
)
1478 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1483 /* When a menu is active, don't highlight because this looks odd. */
1484 if (mouse_preempted
)
1487 if (disable_mouse_highlight
1488 || !f
->glyphs_initialized_p
)
1491 dpyinfo
->mouse_face_mouse_x
= x
;
1492 dpyinfo
->mouse_face_mouse_y
= y
;
1493 dpyinfo
->mouse_face_mouse_frame
= f
;
1495 if (dpyinfo
->mouse_face_defer
)
1500 dpyinfo
->mouse_face_deferred_gc
= 1;
1504 /* Which window is that in? */
1505 window
= window_from_coordinates (f
, x
, y
, &portion
, 0);
1507 /* If we were displaying active text in another window, clear that. */
1508 if (! EQ (window
, dpyinfo
->mouse_face_window
))
1509 clear_mouse_face (dpyinfo
);
1511 /* Not on a window -> return. */
1512 if (!WINDOWP (window
))
1515 /* Convert to window-relative coordinates. */
1516 w
= XWINDOW (window
);
1517 x
-= WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1518 y
-= WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1520 if (portion
== 1 || portion
== 3)
1522 /* Mouse is on the mode or top line. */
1523 IT_note_mode_line_highlight (w
, x
, portion
== 1);
1527 IT_set_mouse_pointer (0);
1529 /* Are we in a window whose display is up to date?
1530 And verify the buffer's text has not changed. */
1531 if (/* Within text portion of the window. */
1533 && EQ (w
->window_end_valid
, w
->buffer
)
1534 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
1535 && (XFASTINT (w
->last_overlay_modified
)
1536 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
1539 struct glyph_row
*row
;
1540 struct glyph
*glyph
;
1541 int nrows
= w
->current_matrix
->nrows
;
1543 /* Find the glyph under X/Y. */
1545 if (y
>= 0 && y
< nrows
)
1547 row
= MATRIX_ROW (w
->current_matrix
, y
);
1548 /* Give up if some row before the one we are looking for is
1550 for (i
= 0; i
<= y
; i
++)
1551 if (!MATRIX_ROW (w
->current_matrix
, i
)->enabled_p
)
1553 if (i
> y
/* all rows upto and including the one at Y are enabled */
1554 && row
->displays_text_p
1555 && x
< window_box_width (w
, TEXT_AREA
))
1557 glyph
= row
->glyphs
[TEXT_AREA
];
1558 if (x
>= row
->used
[TEXT_AREA
])
1563 if (!BUFFERP (glyph
->object
))
1569 /* Clear mouse face if X/Y not over text. */
1572 clear_mouse_face (dpyinfo
);
1576 if (!BUFFERP (glyph
->object
))
1578 pos
= glyph
->charpos
;
1580 /* Check for mouse-face and help-echo. */
1582 extern Lisp_Object Qmouse_face
;
1583 Lisp_Object mouse_face
, overlay
, position
;
1584 Lisp_Object
*overlay_vec
;
1586 struct buffer
*obuf
;
1589 /* If we get an out-of-range value, return now; avoid an error. */
1590 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1593 /* Make the window's buffer temporarily current for
1594 overlays_at and compute_char_face. */
1595 obuf
= current_buffer
;
1596 current_buffer
= XBUFFER (w
->buffer
);
1602 /* Is this char mouse-active or does it have help-echo? */
1603 XSETINT (position
, pos
);
1605 /* Put all the overlays we want in a vector in overlay_vec.
1606 Store the length in len. If there are more than 10, make
1607 enough space for all, and try again. */
1609 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1610 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
1611 if (noverlays
> len
)
1614 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1615 noverlays
= overlays_at (pos
,
1616 0, &overlay_vec
, &len
, NULL
, NULL
, 0);
1619 /* Sort overlays into increasing priority order. */
1620 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1622 /* Check mouse-face highlighting. */
1623 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
1624 && y
>= dpyinfo
->mouse_face_beg_row
1625 && y
<= dpyinfo
->mouse_face_end_row
1626 && (y
> dpyinfo
->mouse_face_beg_row
1627 || x
>= dpyinfo
->mouse_face_beg_col
)
1628 && (y
< dpyinfo
->mouse_face_end_row
1629 || x
< dpyinfo
->mouse_face_end_col
1630 || dpyinfo
->mouse_face_past_end
)))
1632 /* Clear the display of the old active region, if any. */
1633 clear_mouse_face (dpyinfo
);
1635 /* Find highest priority overlay that has a mouse-face prop. */
1637 for (i
= noverlays
- 1; i
>= 0; --i
)
1639 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1640 if (!NILP (mouse_face
))
1642 overlay
= overlay_vec
[i
];
1647 /* If no overlay applies, get a text property. */
1649 mouse_face
= Fget_text_property (position
, Qmouse_face
,
1652 /* Handle the overlay case. */
1653 if (! NILP (overlay
))
1655 /* Find the range of text around this char that
1656 should be active. */
1657 Lisp_Object before
, after
;
1660 before
= Foverlay_start (overlay
);
1661 after
= Foverlay_end (overlay
);
1662 /* Record this as the current active region. */
1663 fast_find_position (w
, XFASTINT (before
),
1664 &dpyinfo
->mouse_face_beg_col
,
1665 &dpyinfo
->mouse_face_beg_row
);
1666 dpyinfo
->mouse_face_past_end
1667 = !fast_find_position (w
, XFASTINT (after
),
1668 &dpyinfo
->mouse_face_end_col
,
1669 &dpyinfo
->mouse_face_end_row
);
1670 dpyinfo
->mouse_face_window
= window
;
1671 dpyinfo
->mouse_face_face_id
1672 = face_at_buffer_position (w
, pos
, 0, 0,
1673 &ignore
, pos
+ 1, 1);
1675 /* Display it as active. */
1676 show_mouse_face (dpyinfo
, 1);
1678 /* Handle the text property case. */
1679 else if (! NILP (mouse_face
))
1681 /* Find the range of text around this char that
1682 should be active. */
1683 Lisp_Object before
, after
, beginning
, end
;
1686 beginning
= Fmarker_position (w
->start
);
1687 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
1688 - XFASTINT (w
->window_end_pos
)));
1690 = Fprevious_single_property_change (make_number (pos
+ 1),
1692 w
->buffer
, beginning
);
1694 = Fnext_single_property_change (position
, Qmouse_face
,
1696 /* Record this as the current active region. */
1697 fast_find_position (w
, XFASTINT (before
),
1698 &dpyinfo
->mouse_face_beg_col
,
1699 &dpyinfo
->mouse_face_beg_row
);
1700 dpyinfo
->mouse_face_past_end
1701 = !fast_find_position (w
, XFASTINT (after
),
1702 &dpyinfo
->mouse_face_end_col
,
1703 &dpyinfo
->mouse_face_end_row
);
1704 dpyinfo
->mouse_face_window
= window
;
1705 dpyinfo
->mouse_face_face_id
1706 = face_at_buffer_position (w
, pos
, 0, 0,
1707 &ignore
, pos
+ 1, 1);
1709 /* Display it as active. */
1710 show_mouse_face (dpyinfo
, 1);
1714 /* Look for a `help-echo' property. */
1717 extern Lisp_Object Qhelp_echo
;
1719 /* Check overlays first. */
1721 for (i
= noverlays
- 1; i
>= 0 && NILP (help
); --i
)
1723 overlay
= overlay_vec
[i
];
1724 help
= Foverlay_get (overlay
, Qhelp_echo
);
1730 help_echo_window
= window
;
1731 help_echo_object
= overlay
;
1732 help_echo_pos
= pos
;
1734 /* Try text properties. */
1735 else if (NILP (help
)
1736 && ((STRINGP (glyph
->object
)
1737 && glyph
->charpos
>= 0
1738 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1739 || (BUFFERP (glyph
->object
)
1740 && glyph
->charpos
>= BEGV
1741 && glyph
->charpos
< ZV
)))
1743 help
= Fget_text_property (make_number (glyph
->charpos
),
1744 Qhelp_echo
, glyph
->object
);
1748 help_echo_window
= window
;
1749 help_echo_object
= glyph
->object
;
1750 help_echo_pos
= glyph
->charpos
;
1757 current_buffer
= obuf
;
1763 IT_clear_end_of_line (int first_unused
)
1767 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
1768 extern int fatal_error_in_progress
;
1770 if (new_pos_X
>= first_unused
|| fatal_error_in_progress
)
1774 i
= (j
= first_unused
- new_pos_X
) * 2;
1776 fprintf (termscript
, "<CLR:EOL[%d..%d)>", new_pos_X
, first_unused
);
1777 spaces
= sp
= alloca (i
);
1782 *sp
++ = ScreenAttrib
;
1786 dosmemput (spaces
, i
, (int)ScreenPrimary
+ offset
);
1787 if (screen_virtual_segment
)
1788 dosv_refresh_virtual_screen (offset
, i
/ 2);
1790 /* clear_end_of_line_raw on term.c leaves the cursor at first_unused.
1791 Let's follow their lead, in case someone relies on this. */
1792 new_pos_X
= first_unused
;
1796 IT_clear_screen (void)
1799 fprintf (termscript
, "<CLR:SCR>");
1803 if (screen_virtual_segment
)
1804 dosv_refresh_virtual_screen (0, screen_size
);
1805 new_pos_X
= new_pos_Y
= 0;
1809 IT_clear_to_end (void)
1812 fprintf (termscript
, "<CLR:EOS>");
1814 while (new_pos_Y
< screen_size_Y
) {
1816 IT_clear_end_of_line (screen_size_X
);
1822 IT_cursor_to (int y
, int x
)
1825 fprintf (termscript
, "\n<XY=%dx%d>", x
, y
);
1830 static int cursor_cleared
;
1833 IT_display_cursor (int on
)
1835 if (on
&& cursor_cleared
)
1837 ScreenSetCursor (current_pos_Y
, current_pos_X
);
1840 else if (!on
&& !cursor_cleared
)
1842 ScreenSetCursor (-1, -1);
1847 /* Emacs calls cursor-movement functions a lot when it updates the
1848 display (probably a legacy of old terminals where you cannot
1849 update a screen line without first moving the cursor there).
1850 However, cursor movement is expensive on MSDOS (it calls a slow
1851 BIOS function and requires 2 mode switches), while actual screen
1852 updates access the video memory directly and don't depend on
1853 cursor position. To avoid slowing down the redisplay, we cheat:
1854 all functions that move the cursor only set internal variables
1855 which record the cursor position, whereas the cursor is only
1856 moved to its final position whenever screen update is complete.
1858 `IT_cmgoto' is called from the keyboard reading loop and when the
1859 frame update is complete. This means that we are ready for user
1860 input, so we update the cursor position to show where the point is,
1861 and also make the mouse pointer visible.
1863 Special treatment is required when the cursor is in the echo area,
1864 to put the cursor at the end of the text displayed there. */
1867 IT_cmgoto (FRAME_PTR f
)
1869 /* Only set the cursor to where it should be if the display is
1870 already in sync with the window contents. */
1871 int update_cursor_pos
= 1; /* MODIFF == unchanged_modified; */
1873 /* FIXME: This needs to be rewritten for the new redisplay, or
1876 static int previous_pos_X
= -1;
1878 update_cursor_pos
= 1; /* temporary!!! */
1880 /* If the display is in sync, forget any previous knowledge about
1881 cursor position. This is primarily for unexpected events like
1882 C-g in the minibuffer. */
1883 if (update_cursor_pos
&& previous_pos_X
>= 0)
1884 previous_pos_X
= -1;
1885 /* If we are in the echo area, put the cursor at the
1886 end of the echo area message. */
1887 if (!update_cursor_pos
1888 && XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
) <= new_pos_Y
)
1890 int tem_X
= current_pos_X
, dummy
;
1892 if (echo_area_glyphs
)
1894 tem_X
= echo_area_glyphs_length
;
1895 /* Save current cursor position, to be restored after the
1896 echo area message is erased. Only remember one level
1897 of previous cursor position. */
1898 if (previous_pos_X
== -1)
1899 ScreenGetCursor (&dummy
, &previous_pos_X
);
1901 else if (previous_pos_X
>= 0)
1903 /* We wind up here after the echo area message is erased.
1904 Restore the cursor position we remembered above. */
1905 tem_X
= previous_pos_X
;
1906 previous_pos_X
= -1;
1909 if (current_pos_X
!= tem_X
)
1912 update_cursor_pos
= 1;
1917 if (update_cursor_pos
1918 && (current_pos_X
!= new_pos_X
|| current_pos_Y
!= new_pos_Y
))
1920 ScreenSetCursor (current_pos_Y
= new_pos_Y
, current_pos_X
= new_pos_X
);
1922 fprintf (termscript
, "\n<CURSOR:%dx%d>", current_pos_X
, current_pos_Y
);
1925 /* Maybe cursor is invisible, so make it visible. */
1926 IT_display_cursor (1);
1928 /* Mouse pointer should be always visible if we are waiting for
1935 IT_update_begin (struct frame
*f
)
1937 struct display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
1938 struct frame
*mouse_face_frame
= display_info
->mouse_face_mouse_frame
;
1942 if (f
&& f
== mouse_face_frame
)
1944 /* Don't do highlighting for mouse motion during the update. */
1945 display_info
->mouse_face_defer
= 1;
1947 /* If F needs to be redrawn, simply forget about any prior mouse
1949 if (FRAME_GARBAGED_P (f
))
1950 display_info
->mouse_face_window
= Qnil
;
1952 /* Can we tell that this update does not affect the window
1953 where the mouse highlight is? If so, no need to turn off.
1954 Likewise, don't do anything if none of the enabled rows
1955 contains glyphs highlighted in mouse face. */
1956 if (!NILP (display_info
->mouse_face_window
)
1957 && WINDOWP (display_info
->mouse_face_window
))
1959 struct window
*w
= XWINDOW (display_info
->mouse_face_window
);
1962 /* If the mouse highlight is in the window that was deleted
1963 (e.g., if it was popped by completion), clear highlight
1965 if (NILP (w
->buffer
))
1966 display_info
->mouse_face_window
= Qnil
;
1969 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
1970 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
)
1971 && MATRIX_ROW (w
->current_matrix
, i
)->mouse_face_p
)
1975 if (NILP (w
->buffer
) || i
< w
->desired_matrix
->nrows
)
1976 clear_mouse_face (display_info
);
1979 else if (mouse_face_frame
&& !FRAME_LIVE_P (mouse_face_frame
))
1981 /* If the frame with mouse highlight was deleted, invalidate the
1983 display_info
->mouse_face_beg_row
= display_info
->mouse_face_beg_col
= -1;
1984 display_info
->mouse_face_end_row
= display_info
->mouse_face_end_col
= -1;
1985 display_info
->mouse_face_window
= Qnil
;
1986 display_info
->mouse_face_deferred_gc
= 0;
1987 display_info
->mouse_face_mouse_frame
= NULL
;
1994 IT_update_end (struct frame
*f
)
1996 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
1999 Lisp_Object Qcursor_type
;
2002 IT_frame_up_to_date (struct frame
*f
)
2004 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
2005 Lisp_Object new_cursor
, frame_desired_cursor
;
2008 if (dpyinfo
->mouse_face_deferred_gc
2009 || (f
&& f
== dpyinfo
->mouse_face_mouse_frame
))
2012 if (dpyinfo
->mouse_face_mouse_frame
)
2013 IT_note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
2014 dpyinfo
->mouse_face_mouse_x
,
2015 dpyinfo
->mouse_face_mouse_y
);
2016 dpyinfo
->mouse_face_deferred_gc
= 0;
2020 /* Set the cursor type to whatever they wanted. In a minibuffer
2021 window, we want the cursor to appear only if we are reading input
2022 from this window, and we want the cursor to be taken from the
2023 frame parameters. For the selected window, we use either its
2024 buffer-local value or the value from the frame parameters if the
2025 buffer doesn't define its local value for the cursor type. */
2026 sw
= XWINDOW (f
->selected_window
);
2027 frame_desired_cursor
= Fcdr (Fassq (Qcursor_type
, f
->param_alist
));
2028 if (cursor_in_echo_area
2029 && FRAME_HAS_MINIBUF_P (f
)
2030 && EQ (FRAME_MINIBUF_WINDOW (f
), echo_area_window
)
2031 && sw
== XWINDOW (echo_area_window
))
2032 new_cursor
= frame_desired_cursor
;
2035 struct buffer
*b
= XBUFFER (sw
->buffer
);
2037 if (EQ (b
->cursor_type
, Qt
))
2038 new_cursor
= frame_desired_cursor
;
2039 else if (NILP (b
->cursor_type
)) /* nil means no cursor */
2040 new_cursor
= Fcons (Qbar
, make_number (0));
2042 new_cursor
= b
->cursor_type
;
2045 IT_set_cursor_type (f
, new_cursor
);
2047 IT_cmgoto (f
); /* position cursor when update is done */
2050 /* Copy LEN glyphs displayed on a single line whose vertical position
2051 is YPOS, beginning at horizontal position XFROM to horizontal
2052 position XTO, by moving blocks in the video memory. Used by
2053 functions that insert and delete glyphs. */
2055 IT_copy_glyphs (int xfrom
, int xto
, size_t len
, int ypos
)
2057 /* The offsets of source and destination relative to the
2058 conventional memorty selector. */
2059 int from
= 2 * (xfrom
+ screen_size_X
* ypos
) + ScreenPrimary
;
2060 int to
= 2 * (xto
+ screen_size_X
* ypos
) + ScreenPrimary
;
2062 if (from
== to
|| len
<= 0)
2065 _farsetsel (_dos_ds
);
2067 /* The source and destination might overlap, so we need to move
2068 glyphs non-destructively. */
2071 for ( ; len
; from
+= 2, to
+= 2, len
--)
2072 _farnspokew (to
, _farnspeekw (from
));
2076 from
+= (len
- 1) * 2;
2077 to
+= (len
- 1) * 2;
2078 for ( ; len
; from
-= 2, to
-= 2, len
--)
2079 _farnspokew (to
, _farnspeekw (from
));
2081 if (screen_virtual_segment
)
2082 dosv_refresh_virtual_screen (ypos
* screen_size_X
* 2, screen_size_X
);
2085 /* Insert and delete glyphs. */
2087 IT_insert_glyphs (start
, len
)
2088 register struct glyph
*start
;
2091 int shift_by_width
= screen_size_X
- (new_pos_X
+ len
);
2093 /* Shift right the glyphs from the nominal cursor position to the
2094 end of this line. */
2095 IT_copy_glyphs (new_pos_X
, new_pos_X
+ len
, shift_by_width
, new_pos_Y
);
2097 /* Now write the glyphs to be inserted. */
2098 IT_write_glyphs (start
, len
);
2102 IT_delete_glyphs (n
)
2108 /* set-window-configuration on window.c needs this. */
2110 x_set_menu_bar_lines (f
, value
, oldval
)
2112 Lisp_Object value
, oldval
;
2114 set_menu_bar_lines (f
, value
, oldval
);
2117 /* This was copied from xfaces.c */
2119 extern Lisp_Object Qbackground_color
;
2120 extern Lisp_Object Qforeground_color
;
2121 Lisp_Object Qreverse
;
2122 extern Lisp_Object Qtitle
;
2124 /* IT_set_terminal_modes is called when emacs is started,
2125 resumed, and whenever the screen is redrawn! */
2128 IT_set_terminal_modes (void)
2131 fprintf (termscript
, "\n<SET_TERM>");
2133 screen_size_X
= ScreenCols ();
2134 screen_size_Y
= ScreenRows ();
2135 screen_size
= screen_size_X
* screen_size_Y
;
2137 new_pos_X
= new_pos_Y
= 0;
2138 current_pos_X
= current_pos_Y
= -1;
2140 if (term_setup_done
)
2142 term_setup_done
= 1;
2144 startup_screen_size_X
= screen_size_X
;
2145 startup_screen_size_Y
= screen_size_Y
;
2146 startup_screen_attrib
= ScreenAttrib
;
2149 /* Is DOS/V (or any other RSIS software which relocates
2150 the screen) installed? */
2152 unsigned short es_value
;
2155 regs
.h
.ah
= 0xfe; /* get relocated screen address */
2156 if (ScreenPrimary
== 0xb0000UL
|| ScreenPrimary
== 0xb8000UL
)
2157 regs
.x
.es
= (ScreenPrimary
>> 4) & 0xffff;
2158 else if (screen_old_address
) /* already switched to Japanese mode once */
2159 regs
.x
.es
= (screen_old_address
>> 4) & 0xffff;
2161 regs
.x
.es
= ScreenMode () == 7 ? 0xb000 : 0xb800;
2163 es_value
= regs
.x
.es
;
2164 __dpmi_int (0x10, ®s
);
2166 if (regs
.x
.es
!= es_value
)
2168 /* screen_old_address is only set if ScreenPrimary does NOT
2169 already point to the relocated buffer address returned by
2170 the Int 10h/AX=FEh call above. DJGPP v2.02 and later sets
2171 ScreenPrimary to that address at startup under DOS/V. */
2172 if (regs
.x
.es
!= (ScreenPrimary
>> 4) & 0xffff)
2173 screen_old_address
= ScreenPrimary
;
2174 screen_virtual_segment
= regs
.x
.es
;
2175 screen_virtual_offset
= regs
.x
.di
;
2176 ScreenPrimary
= (screen_virtual_segment
<< 4) + screen_virtual_offset
;
2179 #endif /* __DJGPP__ > 1 */
2181 ScreenGetCursor (&startup_pos_Y
, &startup_pos_X
);
2182 ScreenRetrieve (startup_screen_buffer
= xmalloc (screen_size
* 2));
2185 fprintf (termscript
, "<SCREEN SAVED (dimensions=%dx%d)>\n",
2186 screen_size_X
, screen_size_Y
);
2191 /* IT_reset_terminal_modes is called when emacs is
2192 suspended or killed. */
2195 IT_reset_terminal_modes (void)
2197 int display_row_start
= (int) ScreenPrimary
;
2198 int saved_row_len
= startup_screen_size_X
* 2;
2199 int update_row_len
= ScreenCols () * 2;
2200 int current_rows
= ScreenRows ();
2201 int to_next_row
= update_row_len
;
2202 unsigned char *saved_row
= startup_screen_buffer
;
2203 int cursor_pos_X
= ScreenCols () - 1;
2204 int cursor_pos_Y
= ScreenRows () - 1;
2207 fprintf (termscript
, "\n<RESET_TERM>");
2209 if (!term_setup_done
)
2214 /* Leave the video system in the same state as we found it,
2215 as far as the blink/bright-background bit is concerned. */
2216 maybe_enable_blinking ();
2218 /* We have a situation here.
2219 We cannot just do ScreenUpdate(startup_screen_buffer) because
2220 the luser could have changed screen dimensions inside Emacs
2221 and failed (or didn't want) to restore them before killing
2222 Emacs. ScreenUpdate() uses the *current* screen dimensions and
2223 thus will happily use memory outside what was allocated for
2224 `startup_screen_buffer'.
2225 Thus we only restore as much as the current screen dimensions
2226 can hold, and clear the rest (if the saved screen is smaller than
2227 the current) with the color attribute saved at startup. The cursor
2228 is also restored within the visible dimensions. */
2230 ScreenAttrib
= startup_screen_attrib
;
2232 /* Don't restore the screen if we are exiting less than 2 seconds
2233 after startup: we might be crashing, and the screen might show
2234 some vital clues to what's wrong. */
2235 if (clock () - startup_time
>= 2*CLOCKS_PER_SEC
)
2238 if (screen_virtual_segment
)
2239 dosv_refresh_virtual_screen (0, screen_size
);
2241 if (update_row_len
> saved_row_len
)
2242 update_row_len
= saved_row_len
;
2243 if (current_rows
> startup_screen_size_Y
)
2244 current_rows
= startup_screen_size_Y
;
2247 fprintf (termscript
, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
2248 update_row_len
/ 2, current_rows
);
2250 while (current_rows
--)
2252 dosmemput (saved_row
, update_row_len
, display_row_start
);
2253 if (screen_virtual_segment
)
2254 dosv_refresh_virtual_screen (display_row_start
- ScreenPrimary
,
2255 update_row_len
/ 2);
2256 saved_row
+= saved_row_len
;
2257 display_row_start
+= to_next_row
;
2260 if (startup_pos_X
< cursor_pos_X
)
2261 cursor_pos_X
= startup_pos_X
;
2262 if (startup_pos_Y
< cursor_pos_Y
)
2263 cursor_pos_Y
= startup_pos_Y
;
2265 ScreenSetCursor (cursor_pos_Y
, cursor_pos_X
);
2266 xfree (startup_screen_buffer
);
2268 term_setup_done
= 0;
2272 IT_set_terminal_window (int foo
)
2276 /* Remember the screen colors of the curent frame, to serve as the
2277 default colors for newly-created frames. */
2279 static int initial_screen_colors
[2];
2281 DEFUN ("msdos-remember-default-colors", Fmsdos_remember_default_colors
,
2282 Smsdos_remember_default_colors
, 1, 1, 0,
2283 "Remember the screen colors of the current frame.")
2289 CHECK_FRAME (frame
, 0);
2292 /* This function is called after applying default-frame-alist to the
2293 initial frame. At that time, if reverse-colors option was
2294 specified in default-frame-alist, it was already applied, and
2295 frame colors are reversed. We need to account for that. */
2296 if (EQ (Fcdr (Fassq (Qreverse
, f
->param_alist
)), Qt
))
2298 initial_screen_colors
[0] = FRAME_BACKGROUND_PIXEL (f
);
2299 initial_screen_colors
[1] = FRAME_FOREGROUND_PIXEL (f
);
2303 initial_screen_colors
[0] = FRAME_FOREGROUND_PIXEL (f
);
2304 initial_screen_colors
[1] = FRAME_BACKGROUND_PIXEL (f
);
2309 IT_set_frame_parameters (f
, alist
)
2314 int length
= XINT (Flength (alist
));
2317 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2319 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2320 /* Do we have to reverse the foreground and background colors? */
2321 int reverse
= EQ (Fcdr (Fassq (Qreverse
, f
->param_alist
)), Qt
);
2322 int was_reverse
= reverse
;
2323 int redraw
= 0, fg_set
= 0, bg_set
= 0;
2324 int need_to_reverse
;
2325 unsigned long orig_fg
;
2326 unsigned long orig_bg
;
2327 Lisp_Object frame_bg
, frame_fg
;
2328 extern Lisp_Object Qdefault
, QCforeground
, QCbackground
;
2330 /* If we are creating a new frame, begin with the original screen colors
2331 used for the initial frame. */
2332 if (alist
== Vdefault_frame_alist
2333 && initial_screen_colors
[0] != -1 && initial_screen_colors
[1] != -1)
2335 FRAME_FOREGROUND_PIXEL (f
) = initial_screen_colors
[0];
2336 FRAME_BACKGROUND_PIXEL (f
) = initial_screen_colors
[1];
2338 orig_fg
= FRAME_FOREGROUND_PIXEL (f
);
2339 orig_bg
= FRAME_BACKGROUND_PIXEL (f
);
2340 frame_fg
= Fcdr (Fassq (Qforeground_color
, f
->param_alist
));
2341 frame_bg
= Fcdr (Fassq (Qbackground_color
, f
->param_alist
));
2342 /* frame_fg and frame_bg could be nil if, for example,
2343 f->param_alist is nil, e.g. if we are called from
2344 Fmake_terminal_frame. */
2345 if (NILP (frame_fg
))
2346 frame_fg
= build_string (unspecified_fg
);
2347 if (NILP (frame_bg
))
2348 frame_bg
= build_string (unspecified_bg
);
2350 /* Extract parm names and values into those vectors. */
2352 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2357 parms
[i
] = Fcar (elt
);
2358 CHECK_SYMBOL (parms
[i
], 1);
2359 values
[i
] = Fcdr (elt
);
2365 for (i
= 0; i
< j
; i
++)
2367 Lisp_Object prop
, val
;
2372 if (EQ (prop
, Qreverse
))
2373 reverse
= EQ (val
, Qt
);
2376 need_to_reverse
= reverse
&& !was_reverse
;
2377 if (termscript
&& need_to_reverse
)
2378 fprintf (termscript
, "<INVERSE-VIDEO>\n");
2380 /* Now process the alist elements in reverse of specified order. */
2381 for (i
--; i
>= 0; i
--)
2383 Lisp_Object prop
, val
;
2389 if (EQ (prop
, Qforeground_color
))
2391 unsigned long new_color
= load_color (f
, NULL
, val
, need_to_reverse
2392 ? LFACE_BACKGROUND_INDEX
2393 : LFACE_FOREGROUND_INDEX
);
2394 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2395 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2396 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2398 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2399 /* Make sure the foreground of the default face for this
2400 frame is changed as well. */
2401 XSETFRAME (frame
, f
);
2402 if (need_to_reverse
)
2404 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2406 prop
= Qbackground_color
;
2411 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2417 fprintf (termscript
, "<FGCOLOR %lu>\n", new_color
);
2420 else if (EQ (prop
, Qbackground_color
))
2422 unsigned long new_color
= load_color (f
, NULL
, val
, need_to_reverse
2423 ? LFACE_FOREGROUND_INDEX
2424 : LFACE_BACKGROUND_INDEX
);
2425 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2426 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2427 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2429 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2430 /* Make sure the background of the default face for this
2431 frame is changed as well. */
2432 XSETFRAME (frame
, f
);
2433 if (need_to_reverse
)
2435 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2437 prop
= Qforeground_color
;
2442 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2448 fprintf (termscript
, "<BGCOLOR %lu>\n", new_color
);
2451 else if (EQ (prop
, Qtitle
))
2453 x_set_title (f
, val
);
2455 fprintf (termscript
, "<TITLE: %s>\n", XSTRING (val
)->data
);
2457 else if (EQ (prop
, Qcursor_type
))
2459 IT_set_cursor_type (f
, val
);
2461 fprintf (termscript
, "<CTYPE: %s>\n",
2462 EQ (val
, Qbar
) || CONSP (val
) && EQ (XCAR (val
), Qbar
)
2465 store_frame_param (f
, prop
, val
);
2468 /* If they specified "reverse", but not the colors, we need to swap
2469 the current frame colors. */
2470 if (need_to_reverse
)
2476 XSETFRAME (frame
, f
);
2477 Finternal_set_lisp_face_attribute (Qdefault
, QCforeground
,
2478 tty_color_name (f
, orig_bg
),
2484 XSETFRAME (frame
, f
);
2485 Finternal_set_lisp_face_attribute (Qdefault
, QCbackground
,
2486 tty_color_name (f
, orig_fg
),
2494 face_change_count
++; /* forces xdisp.c to recompute basic faces */
2495 if (f
== SELECTED_FRAME())
2500 extern void init_frame_faces (FRAME_PTR
);
2502 #endif /* !HAVE_X_WINDOWS */
2505 /* Do we need the internal terminal? */
2508 internal_terminal_init ()
2510 char *term
= getenv ("TERM");
2512 struct frame
*sf
= SELECTED_FRAME();
2514 #ifdef HAVE_X_WINDOWS
2515 if (!inhibit_window_system
)
2520 = (!noninteractive
) && term
&& !strcmp (term
, "internal");
2522 if (getenv ("EMACSTEST"))
2523 termscript
= fopen (getenv ("EMACSTEST"), "wt");
2525 #ifndef HAVE_X_WINDOWS
2526 if (!internal_terminal
|| inhibit_window_system
)
2528 sf
->output_method
= output_termcap
;
2532 Vwindow_system
= intern ("pc");
2533 Vwindow_system_version
= make_number (1);
2534 sf
->output_method
= output_msdos_raw
;
2536 /* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
2537 screen_old_address
= 0;
2539 /* Forget the stale screen colors as well. */
2540 initial_screen_colors
[0] = initial_screen_colors
[1] = -1;
2542 bzero (&the_only_x_display
, sizeof the_only_x_display
);
2543 the_only_x_display
.background_pixel
= 7; /* White */
2544 the_only_x_display
.foreground_pixel
= 0; /* Black */
2546 colors
= getenv ("EMACSCOLORS");
2547 if (colors
&& strlen (colors
) >= 2)
2549 /* The colors use 4 bits each (we enable bright background). */
2550 if (isdigit (colors
[0]))
2552 else if (isxdigit (colors
[0]))
2553 colors
[0] -= (isupper (colors
[0]) ? 'A' : 'a') - 10;
2554 if (colors
[0] >= 0 && colors
[0] < 16)
2555 the_only_x_display
.foreground_pixel
= colors
[0];
2556 if (isdigit (colors
[1]))
2558 else if (isxdigit (colors
[1]))
2559 colors
[1] -= (isupper (colors
[1]) ? 'A' : 'a') - 10;
2560 if (colors
[1] >= 0 && colors
[1] < 16)
2561 the_only_x_display
.background_pixel
= colors
[1];
2563 the_only_x_display
.line_height
= 1;
2564 the_only_x_display
.font
= (XFontStruct
*)1; /* must *not* be zero */
2565 the_only_x_display
.display_info
.mouse_face_mouse_frame
= NULL
;
2566 the_only_x_display
.display_info
.mouse_face_deferred_gc
= 0;
2567 the_only_x_display
.display_info
.mouse_face_beg_row
=
2568 the_only_x_display
.display_info
.mouse_face_beg_col
= -1;
2569 the_only_x_display
.display_info
.mouse_face_end_row
=
2570 the_only_x_display
.display_info
.mouse_face_end_col
= -1;
2571 the_only_x_display
.display_info
.mouse_face_face_id
= DEFAULT_FACE_ID
;
2572 the_only_x_display
.display_info
.mouse_face_window
= Qnil
;
2573 the_only_x_display
.display_info
.mouse_face_mouse_x
=
2574 the_only_x_display
.display_info
.mouse_face_mouse_y
= 0;
2575 the_only_x_display
.display_info
.mouse_face_defer
= 0;
2577 init_frame_faces (sf
);
2579 ring_bell_hook
= IT_ring_bell
;
2580 insert_glyphs_hook
= IT_insert_glyphs
;
2581 delete_glyphs_hook
= IT_delete_glyphs
;
2582 write_glyphs_hook
= IT_write_glyphs
;
2583 cursor_to_hook
= raw_cursor_to_hook
= IT_cursor_to
;
2584 clear_to_end_hook
= IT_clear_to_end
;
2585 clear_end_of_line_hook
= IT_clear_end_of_line
;
2586 clear_frame_hook
= IT_clear_screen
;
2587 update_begin_hook
= IT_update_begin
;
2588 update_end_hook
= IT_update_end
;
2589 frame_up_to_date_hook
= IT_frame_up_to_date
;
2591 /* These hooks are called by term.c without being checked. */
2592 set_terminal_modes_hook
= IT_set_terminal_modes
;
2593 reset_terminal_modes_hook
= IT_reset_terminal_modes
;
2594 set_terminal_window_hook
= IT_set_terminal_window
;
2595 char_ins_del_ok
= 0;
2599 dos_get_saved_screen (screen
, rows
, cols
)
2604 #ifndef HAVE_X_WINDOWS
2605 *screen
= startup_screen_buffer
;
2606 *cols
= startup_screen_size_X
;
2607 *rows
= startup_screen_size_Y
;
2608 return *screen
!= (char *)0;
2614 #ifndef HAVE_X_WINDOWS
2616 /* We are not X, but we can emulate it well enough for our needs... */
2620 if (! FRAME_MSDOS_P (SELECTED_FRAME()))
2621 error ("Not running under a window system");
2627 /* ----------------------- Keyboard control ----------------------
2629 * Keymaps reflect the following keyboard layout:
2631 * 0 1 2 3 4 5 6 7 8 9 10 11 12 BS
2632 * TAB 15 16 17 18 19 20 21 22 23 24 25 26 (41)
2633 * CLOK 30 31 32 33 34 35 36 37 38 39 40 (41) RET
2634 * SH () 45 46 47 48 49 50 51 52 53 54 SHIFT
2638 #define Ignore 0x0000
2639 #define Normal 0x0000 /* normal key - alt changes scan-code */
2640 #define FctKey 0x1000 /* func key if c == 0, else c */
2641 #define Special 0x2000 /* func key even if c != 0 */
2642 #define ModFct 0x3000 /* special if mod-keys, else 'c' */
2643 #define Map 0x4000 /* alt scan-code, map to unshift/shift key */
2644 #define KeyPad 0x5000 /* map to insert/kp-0 depending on c == 0xe0 */
2645 #define Grey 0x6000 /* Grey keypad key */
2647 #define Alt 0x0100 /* alt scan-code */
2648 #define Ctrl 0x0200 /* ctrl scan-code */
2649 #define Shift 0x0400 /* shift scan-code */
2651 static int extended_kbd
; /* 101 (102) keyboard present. */
2653 struct kbd_translate
{
2656 unsigned short code
;
2659 struct dos_keyboard_map
2664 struct kbd_translate
*translate_table
;
2668 static struct dos_keyboard_map us_keyboard
= {
2670 /* 01234567890123456789012345678901234567890 12345678901234 */
2671 "`1234567890-= qwertyuiop[] asdfghjkl;'\\ zxcvbnm,./ ",
2672 /* 0123456789012345678901234567890123456789 012345678901234 */
2673 "~!@#$%^&*()_+ QWERTYUIOP{} ASDFGHJKL:\"| ZXCVBNM<>? ",
2674 0, /* no Alt-Gr key */
2675 0 /* no translate table */
2678 static struct dos_keyboard_map fr_keyboard
= {
2680 /* 012 3456789012345678901234567890123456789012345678901234 */
2681 "ý&\82\",(-\8a_\80\85)= azertyuiop^$ qsdfghjklm\97* wxcvbnm;:! ",
2682 /* 0123456789012345678901234567890123456789012345678901234 */
2683 " 1234567890ø+ AZERTYUIOPù\9c QSDFGHJKLM%æ WXCVBN?./õ ",
2684 /* 01234567 89012345678901234567890123456789012345678901234 */
2686 0 /* no translate table */
2690 * Italian keyboard support, country code 39.
2693 * added also {,},` as, respectively, AltGr-8, AltGr-9, AltGr-'
2694 * Donated by Stefano Brozzi <brozzis@mag00.cedi.unipr.it>
2697 static struct kbd_translate it_kbd_translate_table
[] = {
2698 { 0x56, 0x3c, Normal
| 13 },
2699 { 0x56, 0x3e, Normal
| 27 },
2702 static struct dos_keyboard_map it_keyboard
= {
2704 /* 0 123456789012345678901234567890123456789012345678901234 */
2705 "\\1234567890'\8d< qwertyuiop\8a+> asdfghjkl\95\85\97 zxcvbnm,.- ",
2706 /* 01 23456789012345678901234567890123456789012345678901234 */
2707 "|!\"\9c$%&/()=?^> QWERTYUIOP\82* ASDFGHJKL\87øõ ZXCVBNM;:_ ",
2708 /* 0123456789012345678901234567890123456789012345678901234 */
2710 it_kbd_translate_table
2713 static struct dos_keyboard_map dk_keyboard
= {
2715 /* 0123456789012345678901234567890123456789012345678901234 */
2716 "«1234567890+| qwertyuiop\86~ asdfghjkl\91\9b' zxcvbnm,.- ",
2717 /* 01 23456789012345678901234567890123456789012345678901234 */
2718 "õ!\"#$%&/()=?` QWERTYUIOP\8f^ ASDFGHJKL\92\9d* ZXCVBNM;:_ ",
2719 /* 0123456789012345678901234567890123456789012345678901234 */
2721 0 /* no translate table */
2724 static struct kbd_translate jp_kbd_translate_table
[] = {
2725 { 0x73, 0x5c, Normal
| 0 },
2726 { 0x73, 0x5f, Normal
| 0 },
2727 { 0x73, 0x1c, Map
| 0 },
2728 { 0x7d, 0x5c, Normal
| 13 },
2729 { 0x7d, 0x7c, Normal
| 13 },
2730 { 0x7d, 0x1c, Map
| 13 },
2733 static struct dos_keyboard_map jp_keyboard
= {
2735 /* 0123456789012 345678901234567890123456789012345678901234 */
2736 "\\1234567890-^\\ qwertyuiop@[ asdfghjkl;:] zxcvbnm,./ ",
2737 /* 01 23456789012345678901234567890123456789012345678901234 */
2738 "_!\"#$%&'()~=~| QWERTYUIOP`{ ASDFGHJKL+*} ZXCVBNM<>? ",
2739 0, /* no Alt-Gr key */
2740 jp_kbd_translate_table
2743 static struct keyboard_layout_list
2746 struct dos_keyboard_map
*keyboard_map
;
2747 } keyboard_layout_list
[] =
2756 static struct dos_keyboard_map
*keyboard
;
2757 static int keyboard_map_all
;
2758 static int international_keyboard
;
2761 dos_set_keyboard (code
, always
)
2766 _go32_dpmi_registers regs
;
2768 /* See if Keyb.Com is installed (for international keyboard support).
2769 Note: calling Int 2Fh via int86 wedges the DOS box on some versions
2770 of Windows 9X! So don't do that! */
2772 regs
.x
.ss
= regs
.x
.sp
= regs
.x
.flags
= 0;
2773 _go32_dpmi_simulate_int (0x2f, ®s
);
2774 if (regs
.h
.al
== 0xff)
2775 international_keyboard
= 1;
2777 /* Initialize to US settings, for countries that don't have their own. */
2778 keyboard
= keyboard_layout_list
[0].keyboard_map
;
2779 keyboard_map_all
= always
;
2780 dos_keyboard_layout
= 1;
2782 for (i
= 0; i
< (sizeof (keyboard_layout_list
)/sizeof (struct keyboard_layout_list
)); i
++)
2783 if (code
== keyboard_layout_list
[i
].country_code
)
2785 keyboard
= keyboard_layout_list
[i
].keyboard_map
;
2786 keyboard_map_all
= always
;
2787 dos_keyboard_layout
= code
;
2795 unsigned char char_code
; /* normal code */
2796 unsigned char meta_code
; /* M- code */
2797 unsigned char keypad_code
; /* keypad code */
2798 unsigned char editkey_code
; /* edit key */
2799 } keypad_translate_map
[] = {
2800 '0', '0', 0xb0, /* kp-0 */ 0x63, /* insert */
2801 '1', '1', 0xb1, /* kp-1 */ 0x57, /* end */
2802 '2', '2', 0xb2, /* kp-2 */ 0x54, /* down */
2803 '3', '3', 0xb3, /* kp-3 */ 0x56, /* next */
2804 '4', '4', 0xb4, /* kp-4 */ 0x51, /* left */
2805 '5', '5', 0xb5, /* kp-5 */ 0xb5, /* kp-5 */
2806 '6', '6', 0xb6, /* kp-6 */ 0x53, /* right */
2807 '7', '7', 0xb7, /* kp-7 */ 0x50, /* home */
2808 '8', '8', 0xb8, /* kp-8 */ 0x52, /* up */
2809 '9', '9', 0xb9, /* kp-9 */ 0x55, /* prior */
2810 '.', '-', 0xae, /* kp-decimal */ 0xff /* delete */
2815 unsigned char char_code
; /* normal code */
2816 unsigned char keypad_code
; /* keypad code */
2817 } grey_key_translate_map
[] = {
2818 '/', 0xaf, /* kp-decimal */
2819 '*', 0xaa, /* kp-multiply */
2820 '-', 0xad, /* kp-subtract */
2821 '+', 0xab, /* kp-add */
2822 '\r', 0x8d /* kp-enter */
2825 static unsigned short
2826 ibmpc_translate_map
[] =
2828 /* --------------- 00 to 0f --------------- */
2829 Normal
| 0xff, /* Ctrl Break + Alt-NNN */
2830 Alt
| ModFct
| 0x1b, /* Escape */
2831 Normal
| 1, /* '1' */
2832 Normal
| 2, /* '2' */
2833 Normal
| 3, /* '3' */
2834 Normal
| 4, /* '4' */
2835 Normal
| 5, /* '5' */
2836 Normal
| 6, /* '6' */
2837 Normal
| 7, /* '7' */
2838 Normal
| 8, /* '8' */
2839 Normal
| 9, /* '9' */
2840 Normal
| 10, /* '0' */
2841 Normal
| 11, /* '-' */
2842 Normal
| 12, /* '=' */
2843 Special
| 0x08, /* Backspace */
2844 ModFct
| 0x74, /* Tab/Backtab */
2846 /* --------------- 10 to 1f --------------- */
2859 ModFct
| 0x0d, /* Return */
2864 /* --------------- 20 to 2f --------------- */
2873 Map
| 40, /* '\'' */
2875 Ignore
, /* Left shift */
2876 Map
| 41, /* '\\' */
2882 /* --------------- 30 to 3f --------------- */
2889 Ignore
, /* Right shift */
2890 Grey
| 1, /* Grey * */
2892 Normal
| 55, /* ' ' */
2893 Ignore
, /* Caps Lock */
2894 FctKey
| 0xbe, /* F1 */
2895 FctKey
| 0xbf, /* F2 */
2896 FctKey
| 0xc0, /* F3 */
2897 FctKey
| 0xc1, /* F4 */
2898 FctKey
| 0xc2, /* F5 */
2900 /* --------------- 40 to 4f --------------- */
2901 FctKey
| 0xc3, /* F6 */
2902 FctKey
| 0xc4, /* F7 */
2903 FctKey
| 0xc5, /* F8 */
2904 FctKey
| 0xc6, /* F9 */
2905 FctKey
| 0xc7, /* F10 */
2906 Ignore
, /* Num Lock */
2907 Ignore
, /* Scroll Lock */
2908 KeyPad
| 7, /* Home */
2909 KeyPad
| 8, /* Up */
2910 KeyPad
| 9, /* Page Up */
2911 Grey
| 2, /* Grey - */
2912 KeyPad
| 4, /* Left */
2913 KeyPad
| 5, /* Keypad 5 */
2914 KeyPad
| 6, /* Right */
2915 Grey
| 3, /* Grey + */
2916 KeyPad
| 1, /* End */
2918 /* --------------- 50 to 5f --------------- */
2919 KeyPad
| 2, /* Down */
2920 KeyPad
| 3, /* Page Down */
2921 KeyPad
| 0, /* Insert */
2922 KeyPad
| 10, /* Delete */
2923 Shift
| FctKey
| 0xbe, /* (Shift) F1 */
2924 Shift
| FctKey
| 0xbf, /* (Shift) F2 */
2925 Shift
| FctKey
| 0xc0, /* (Shift) F3 */
2926 Shift
| FctKey
| 0xc1, /* (Shift) F4 */
2927 Shift
| FctKey
| 0xc2, /* (Shift) F5 */
2928 Shift
| FctKey
| 0xc3, /* (Shift) F6 */
2929 Shift
| FctKey
| 0xc4, /* (Shift) F7 */
2930 Shift
| FctKey
| 0xc5, /* (Shift) F8 */
2931 Shift
| FctKey
| 0xc6, /* (Shift) F9 */
2932 Shift
| FctKey
| 0xc7, /* (Shift) F10 */
2933 Ctrl
| FctKey
| 0xbe, /* (Ctrl) F1 */
2934 Ctrl
| FctKey
| 0xbf, /* (Ctrl) F2 */
2936 /* --------------- 60 to 6f --------------- */
2937 Ctrl
| FctKey
| 0xc0, /* (Ctrl) F3 */
2938 Ctrl
| FctKey
| 0xc1, /* (Ctrl) F4 */
2939 Ctrl
| FctKey
| 0xc2, /* (Ctrl) F5 */
2940 Ctrl
| FctKey
| 0xc3, /* (Ctrl) F6 */
2941 Ctrl
| FctKey
| 0xc4, /* (Ctrl) F7 */
2942 Ctrl
| FctKey
| 0xc5, /* (Ctrl) F8 */
2943 Ctrl
| FctKey
| 0xc6, /* (Ctrl) F9 */
2944 Ctrl
| FctKey
| 0xc7, /* (Ctrl) F10 */
2945 Alt
| FctKey
| 0xbe, /* (Alt) F1 */
2946 Alt
| FctKey
| 0xbf, /* (Alt) F2 */
2947 Alt
| FctKey
| 0xc0, /* (Alt) F3 */
2948 Alt
| FctKey
| 0xc1, /* (Alt) F4 */
2949 Alt
| FctKey
| 0xc2, /* (Alt) F5 */
2950 Alt
| FctKey
| 0xc3, /* (Alt) F6 */
2951 Alt
| FctKey
| 0xc4, /* (Alt) F7 */
2952 Alt
| FctKey
| 0xc5, /* (Alt) F8 */
2954 /* --------------- 70 to 7f --------------- */
2955 Alt
| FctKey
| 0xc6, /* (Alt) F9 */
2956 Alt
| FctKey
| 0xc7, /* (Alt) F10 */
2957 Ctrl
| FctKey
| 0x6d, /* (Ctrl) Sys Rq */
2958 Ctrl
| KeyPad
| 4, /* (Ctrl) Left */
2959 Ctrl
| KeyPad
| 6, /* (Ctrl) Right */
2960 Ctrl
| KeyPad
| 1, /* (Ctrl) End */
2961 Ctrl
| KeyPad
| 3, /* (Ctrl) Page Down */
2962 Ctrl
| KeyPad
| 7, /* (Ctrl) Home */
2963 Alt
| Map
| 1, /* '1' */
2964 Alt
| Map
| 2, /* '2' */
2965 Alt
| Map
| 3, /* '3' */
2966 Alt
| Map
| 4, /* '4' */
2967 Alt
| Map
| 5, /* '5' */
2968 Alt
| Map
| 6, /* '6' */
2969 Alt
| Map
| 7, /* '7' */
2970 Alt
| Map
| 8, /* '8' */
2972 /* --------------- 80 to 8f --------------- */
2973 Alt
| Map
| 9, /* '9' */
2974 Alt
| Map
| 10, /* '0' */
2975 Alt
| Map
| 11, /* '-' */
2976 Alt
| Map
| 12, /* '=' */
2977 Ctrl
| KeyPad
| 9, /* (Ctrl) Page Up */
2978 FctKey
| 0xc8, /* F11 */
2979 FctKey
| 0xc9, /* F12 */
2980 Shift
| FctKey
| 0xc8, /* (Shift) F11 */
2981 Shift
| FctKey
| 0xc9, /* (Shift) F12 */
2982 Ctrl
| FctKey
| 0xc8, /* (Ctrl) F11 */
2983 Ctrl
| FctKey
| 0xc9, /* (Ctrl) F12 */
2984 Alt
| FctKey
| 0xc8, /* (Alt) F11 */
2985 Alt
| FctKey
| 0xc9, /* (Alt) F12 */
2986 Ctrl
| KeyPad
| 8, /* (Ctrl) Up */
2987 Ctrl
| Grey
| 2, /* (Ctrl) Grey - */
2988 Ctrl
| KeyPad
| 5, /* (Ctrl) Keypad 5 */
2990 /* --------------- 90 to 9f --------------- */
2991 Ctrl
| Grey
| 3, /* (Ctrl) Grey + */
2992 Ctrl
| KeyPad
| 2, /* (Ctrl) Down */
2993 Ctrl
| KeyPad
| 0, /* (Ctrl) Insert */
2994 Ctrl
| KeyPad
| 10, /* (Ctrl) Delete */
2995 Ctrl
| FctKey
| 0x09, /* (Ctrl) Tab */
2996 Ctrl
| Grey
| 0, /* (Ctrl) Grey / */
2997 Ctrl
| Grey
| 1, /* (Ctrl) Grey * */
2998 Alt
| FctKey
| 0x50, /* (Alt) Home */
2999 Alt
| FctKey
| 0x52, /* (Alt) Up */
3000 Alt
| FctKey
| 0x55, /* (Alt) Page Up */
3001 Ignore
, /* NO KEY */
3002 Alt
| FctKey
| 0x51, /* (Alt) Left */
3003 Ignore
, /* NO KEY */
3004 Alt
| FctKey
| 0x53, /* (Alt) Right */
3005 Ignore
, /* NO KEY */
3006 Alt
| FctKey
| 0x57, /* (Alt) End */
3008 /* --------------- a0 to af --------------- */
3009 Alt
| KeyPad
| 2, /* (Alt) Down */
3010 Alt
| KeyPad
| 3, /* (Alt) Page Down */
3011 Alt
| KeyPad
| 0, /* (Alt) Insert */
3012 Alt
| KeyPad
| 10, /* (Alt) Delete */
3013 Alt
| Grey
| 0, /* (Alt) Grey / */
3014 Alt
| FctKey
| 0x09, /* (Alt) Tab */
3015 Alt
| Grey
| 4 /* (Alt) Keypad Enter */
3018 /* These bit-positions corresponds to values returned by BIOS */
3019 #define SHIFT_P 0x0003 /* two bits! */
3020 #define CTRL_P 0x0004
3021 #define ALT_P 0x0008
3022 #define SCRLOCK_P 0x0010
3023 #define NUMLOCK_P 0x0020
3024 #define CAPSLOCK_P 0x0040
3025 #define ALT_GR_P 0x0800
3026 #define SUPER_P 0x4000 /* pseudo */
3027 #define HYPER_P 0x8000 /* pseudo */
3030 dos_get_modifiers (keymask
)
3037 /* Calculate modifier bits */
3038 regs
.h
.ah
= extended_kbd
? 0x12 : 0x02;
3039 int86 (0x16, ®s
, ®s
);
3043 mask
= regs
.h
.al
& (SHIFT_P
| CTRL_P
| ALT_P
|
3044 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
3048 mask
= regs
.h
.al
& (SHIFT_P
|
3049 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
3051 /* Do not break international keyboard support. */
3052 /* When Keyb.Com is loaded, the right Alt key is */
3053 /* used for accessing characters like { and } */
3054 if (regs
.h
.ah
& 2) /* Left ALT pressed ? */
3057 if ((regs
.h
.ah
& 8) != 0) /* Right ALT pressed ? */
3060 if (dos_hyper_key
== 1)
3063 modifiers
|= hyper_modifier
;
3065 else if (dos_super_key
== 1)
3068 modifiers
|= super_modifier
;
3070 else if (!international_keyboard
)
3072 /* If Keyb.Com is NOT installed, let Right Alt behave
3073 like the Left Alt. */
3079 if (regs
.h
.ah
& 1) /* Left CTRL pressed ? */
3082 if (regs
.h
.ah
& 4) /* Right CTRL pressed ? */
3084 if (dos_hyper_key
== 2)
3087 modifiers
|= hyper_modifier
;
3089 else if (dos_super_key
== 2)
3092 modifiers
|= super_modifier
;
3100 modifiers
|= shift_modifier
;
3102 modifiers
|= ctrl_modifier
;
3104 modifiers
|= meta_modifier
;
3111 #define NUM_RECENT_DOSKEYS (100)
3112 int recent_doskeys_index
; /* Index for storing next element into recent_doskeys */
3113 int total_doskeys
; /* Total number of elements stored into recent_doskeys */
3114 Lisp_Object recent_doskeys
; /* A vector, holding the last 100 keystrokes */
3116 DEFUN ("recent-doskeys", Frecent_doskeys
, Srecent_doskeys
, 0, 0, 0,
3117 "Return vector of last 100 keyboard input values seen in dos_rawgetc.\n\
3118 Each input key receives two values in this vector: first the ASCII code,\n\
3119 and then the scan code.")
3122 Lisp_Object
*keys
= XVECTOR (recent_doskeys
)->contents
;
3125 if (total_doskeys
< NUM_RECENT_DOSKEYS
)
3126 return Fvector (total_doskeys
, keys
);
3129 val
= Fvector (NUM_RECENT_DOSKEYS
, keys
);
3130 bcopy (keys
+ recent_doskeys_index
,
3131 XVECTOR (val
)->contents
,
3132 (NUM_RECENT_DOSKEYS
- recent_doskeys_index
) * sizeof (Lisp_Object
));
3134 XVECTOR (val
)->contents
+ NUM_RECENT_DOSKEYS
- recent_doskeys_index
,
3135 recent_doskeys_index
* sizeof (Lisp_Object
));
3140 /* Get a char from keyboard. Function keys are put into the event queue. */
3144 struct input_event event
;
3147 #ifndef HAVE_X_WINDOWS
3148 /* Maybe put the cursor where it should be. */
3149 IT_cmgoto (SELECTED_FRAME());
3152 /* The following condition is equivalent to `kbhit ()', except that
3153 it uses the bios to do its job. This pleases DESQview/X. */
3154 while ((regs
.h
.ah
= extended_kbd
? 0x11 : 0x01),
3155 int86 (0x16, ®s
, ®s
),
3156 (regs
.x
.flags
& 0x40) == 0)
3159 register unsigned char c
;
3160 int sc
, code
= -1, mask
, kp_mode
;
3163 regs
.h
.ah
= extended_kbd
? 0x10 : 0x00;
3164 int86 (0x16, ®s
, ®s
);
3169 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3171 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3172 recent_doskeys_index
= 0;
3173 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
3175 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
3176 recent_doskeys_index
= 0;
3178 modifiers
= dos_get_modifiers (&mask
);
3180 #ifndef HAVE_X_WINDOWS
3181 if (!NILP (Vdos_display_scancodes
))
3184 sprintf (buf
, "%02x:%02x*%04x",
3185 (unsigned) (sc
&0xff), (unsigned) c
, mask
);
3186 dos_direct_output (screen_size_Y
- 2, screen_size_X
- 12, buf
, 10);
3194 case 10: /* Ctrl Grey Enter */
3195 code
= Ctrl
| Grey
| 4;
3197 case 13: /* Grey Enter */
3200 case '/': /* Grey / */
3210 /* Try the keyboard-private translation table first. */
3211 if (keyboard
->translate_table
)
3213 struct kbd_translate
*p
= keyboard
->translate_table
;
3217 if (p
->sc
== sc
&& p
->ch
== c
)
3225 /* If the private table didn't translate it, use the general
3229 if (sc
>= (sizeof (ibmpc_translate_map
) / sizeof (short)))
3231 if ((code
= ibmpc_translate_map
[sc
]) == Ignore
)
3238 /* We only look at the keyboard Ctrl/Shift/Alt keys when
3239 Emacs is ready to read a key. Therefore, if they press
3240 `Alt-x' when Emacs is busy, by the time we get to
3241 `dos_get_modifiers', they might have already released the
3242 Alt key, and Emacs gets just `x', which is BAD.
3243 However, for keys with the `Map' property set, the ASCII
3244 code returns zero iff Alt is pressed. So, when we DON'T
3245 have to support international_keyboard, we don't have to
3246 distinguish between the left and right Alt keys, and we
3247 can set the META modifier for any keys with the `Map'
3248 property if they return zero ASCII code (c = 0). */
3250 || ( (code
& 0xf000) == Map
&& !international_keyboard
))
3251 modifiers
|= meta_modifier
;
3253 modifiers
|= ctrl_modifier
;
3255 modifiers
|= shift_modifier
;
3258 switch (code
& 0xf000)
3261 if (c
&& !(mask
& (SHIFT_P
| ALT_P
| CTRL_P
| HYPER_P
| SUPER_P
)))
3263 c
= 0; /* Special */
3276 if (c
== 0) /* ctrl-break */
3278 return c
; /* ALT-nnn */
3280 if (!keyboard_map_all
)
3289 if (c
&& !(mask
& ALT_P
) && !((mask
& SHIFT_P
) && (mask
& CTRL_P
)))
3290 if (!keyboard_map_all
)
3294 if (mask
& ALT_P
&& code
<= 10 && code
> 0 && dos_keypad_mode
& 0x200)
3295 mask
|= SHIFT_P
; /* ALT-1 => M-! etc. */
3299 code
= keyboard
->shifted
[code
];
3301 modifiers
&= ~shift_modifier
;
3304 if ((mask
& ALT_GR_P
) && keyboard
->alt_gr
&& keyboard
->alt_gr
[code
] != ' ')
3305 code
= keyboard
->alt_gr
[code
];
3307 code
= keyboard
->unshifted
[code
];
3312 if (c
== 0xe0) /* edit key */
3315 if ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) /* numlock on */
3316 kp_mode
= dos_keypad_mode
& 0x03;
3318 kp_mode
= (dos_keypad_mode
>> 4) & 0x03;
3323 if (code
== 10 && dos_decimal_point
)
3324 return dos_decimal_point
;
3325 return keypad_translate_map
[code
].char_code
;
3328 code
= 0xff00 | keypad_translate_map
[code
].keypad_code
;
3332 code
= keypad_translate_map
[code
].meta_code
;
3333 modifiers
= meta_modifier
;
3337 code
= 0xff00 | keypad_translate_map
[code
].editkey_code
;
3344 kp_mode
= ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) ? 0x04 : 0x40;
3345 if (dos_keypad_mode
& kp_mode
)
3346 code
= 0xff00 | grey_key_translate_map
[code
].keypad_code
;
3348 code
= grey_key_translate_map
[code
].char_code
;
3357 event
.kind
= non_ascii_keystroke
;
3359 event
.kind
= ascii_keystroke
;
3361 event
.modifiers
= modifiers
;
3362 event
.frame_or_window
= selected_frame
;
3364 event
.timestamp
= event_timestamp ();
3365 kbd_buffer_store_event (&event
);
3368 if (have_mouse
> 0 && !mouse_preempted
)
3370 int but
, press
, x
, y
, ok
;
3371 int mouse_prev_x
= mouse_last_x
, mouse_prev_y
= mouse_last_y
;
3373 /* Check for mouse movement *before* buttons. */
3374 mouse_check_moved ();
3376 /* If the mouse moved from the spot of its last sighting, we
3377 might need to update mouse highlight. */
3378 if (mouse_last_x
!= mouse_prev_x
|| mouse_last_y
!= mouse_prev_y
)
3380 previous_help_echo
= help_echo
;
3381 help_echo
= help_echo_object
= help_echo_window
= Qnil
;
3383 IT_note_mouse_highlight (SELECTED_FRAME(),
3384 mouse_last_x
, mouse_last_y
);
3385 /* If the contents of the global variable help_echo has
3386 changed, generate a HELP_EVENT. */
3387 if (!NILP (help_echo
) || !NILP (previous_help_echo
))
3389 /* HELP_EVENT takes 2 events in the event loop. */
3390 event
.kind
= HELP_EVENT
;
3391 event
.frame_or_window
= selected_frame
;
3392 event
.arg
= help_echo_object
;
3393 event
.x
= make_number (help_echo_pos
);
3394 event
.timestamp
= event_timestamp ();
3396 kbd_buffer_store_event (&event
);
3397 if (WINDOWP (help_echo_window
))
3398 event
.frame_or_window
= help_echo_window
;
3399 event
.arg
= help_echo
;
3401 kbd_buffer_store_event (&event
);
3405 for (but
= 0; but
< NUM_MOUSE_BUTTONS
; but
++)
3406 for (press
= 0; press
< 2; press
++)
3408 int button_num
= but
;
3411 ok
= mouse_pressed (but
, &x
, &y
);
3413 ok
= mouse_released (but
, &x
, &y
);
3416 /* Allow a simultaneous press/release of Mouse-1 and
3417 Mouse-2 to simulate Mouse-3 on two-button mice. */
3418 if (mouse_button_count
== 2 && but
< 2)
3420 int x2
, y2
; /* don't clobber original coordinates */
3422 /* If only one button is pressed, wait 100 msec and
3423 check again. This way, Speedy Gonzales isn't
3424 punished, while the slow get their chance. */
3425 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3426 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3431 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3432 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3437 event
.kind
= mouse_click
;
3438 event
.code
= button_num
;
3439 event
.modifiers
= dos_get_modifiers (0)
3440 | (press
? down_modifier
: up_modifier
);
3443 event
.frame_or_window
= selected_frame
;
3445 event
.timestamp
= event_timestamp ();
3446 kbd_buffer_store_event (&event
);
3454 static int prev_get_char
= -1;
3456 /* Return 1 if a key is ready to be read without suspending execution. */
3460 if (prev_get_char
!= -1)
3463 return ((prev_get_char
= dos_rawgetc ()) != -1);
3466 /* Read a key. Return -1 if no key is ready. */
3470 if (prev_get_char
!= -1)
3472 int c
= prev_get_char
;
3477 return dos_rawgetc ();
3480 #ifndef HAVE_X_WINDOWS
3481 /* See xterm.c for more info. */
3483 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
3485 register int pix_x
, pix_y
;
3486 register int *x
, *y
;
3490 if (bounds
) abort ();
3492 /* Ignore clipping. */
3499 glyph_to_pixel_coords (f
, x
, y
, pix_x
, pix_y
)
3502 register int *pix_x
, *pix_y
;
3508 /* Simulation of X's menus. Nothing too fancy here -- just make it work
3511 Actually, I don't know the meaning of all the parameters of the functions
3512 here -- I only know how they are called by xmenu.c. I could of course
3513 grab the nearest Xlib manual (down the hall, second-to-last door on the
3514 left), but I don't think it's worth the effort. */
3516 /* These hold text of the current and the previous menu help messages. */
3517 static char *menu_help_message
, *prev_menu_help_message
;
3518 /* Pane number and item number of the menu item which generated the
3519 last menu help message. */
3520 static int menu_help_paneno
, menu_help_itemno
;
3527 menu
= (XMenu
*) xmalloc (sizeof (XMenu
));
3528 menu
->allocated
= menu
->count
= menu
->panecount
= menu
->width
= 0;
3532 /* Allocate some (more) memory for MENU ensuring that there is room for one
3536 IT_menu_make_room (XMenu
*menu
)
3538 if (menu
->allocated
== 0)
3540 int count
= menu
->allocated
= 10;
3541 menu
->text
= (char **) xmalloc (count
* sizeof (char *));
3542 menu
->submenu
= (XMenu
**) xmalloc (count
* sizeof (XMenu
*));
3543 menu
->panenumber
= (int *) xmalloc (count
* sizeof (int));
3544 menu
->help_text
= (char **) xmalloc (count
* sizeof (char *));
3546 else if (menu
->allocated
== menu
->count
)
3548 int count
= menu
->allocated
= menu
->allocated
+ 10;
3550 = (char **) xrealloc (menu
->text
, count
* sizeof (char *));
3552 = (XMenu
**) xrealloc (menu
->submenu
, count
* sizeof (XMenu
*));
3554 = (int *) xrealloc (menu
->panenumber
, count
* sizeof (int));
3556 = (char **) xrealloc (menu
->help_text
, count
* sizeof (char *));
3560 /* Search the given menu structure for a given pane number. */
3563 IT_menu_search_pane (XMenu
*menu
, int pane
)
3568 for (i
= 0; i
< menu
->count
; i
++)
3569 if (menu
->submenu
[i
])
3571 if (pane
== menu
->panenumber
[i
])
3572 return menu
->submenu
[i
];
3573 if ((try = IT_menu_search_pane (menu
->submenu
[i
], pane
)))
3579 /* Determine how much screen space a given menu needs. */
3582 IT_menu_calc_size (XMenu
*menu
, int *width
, int *height
)
3584 int i
, h2
, w2
, maxsubwidth
, maxheight
;
3587 maxheight
= menu
->count
;
3588 for (i
= 0; i
< menu
->count
; i
++)
3590 if (menu
->submenu
[i
])
3592 IT_menu_calc_size (menu
->submenu
[i
], &w2
, &h2
);
3593 if (w2
> maxsubwidth
) maxsubwidth
= w2
;
3594 if (i
+ h2
> maxheight
) maxheight
= i
+ h2
;
3597 *width
= menu
->width
+ maxsubwidth
;
3598 *height
= maxheight
;
3601 /* Display MENU at (X,Y) using FACES. */
3604 IT_menu_display (XMenu
*menu
, int y
, int x
, int pn
, int *faces
, int disp_help
)
3606 int i
, j
, face
, width
;
3607 struct glyph
*text
, *p
;
3610 int enabled
, mousehere
;
3612 struct frame
*sf
= SELECTED_FRAME();
3614 menu_help_message
= NULL
;
3616 width
= menu
->width
;
3617 text
= (struct glyph
*) xmalloc ((width
+ 2) * sizeof (struct glyph
));
3618 ScreenGetCursor (&row
, &col
);
3619 mouse_get_xy (&mx
, &my
);
3620 IT_update_begin (sf
);
3621 for (i
= 0; i
< menu
->count
; i
++)
3623 int max_width
= width
+ 2;
3625 IT_cursor_to (y
+ i
, x
);
3627 = (!menu
->submenu
[i
] && menu
->panenumber
[i
]) || (menu
->submenu
[i
]);
3628 mousehere
= (y
+ i
== my
&& x
<= mx
&& mx
< x
+ width
+ 2);
3629 face
= faces
[enabled
+ mousehere
* 2];
3630 /* The following if clause means that we display the menu help
3631 strings even if the menu item is currently disabled. */
3632 if (disp_help
&& enabled
+ mousehere
* 2 >= 2)
3634 menu_help_message
= menu
->help_text
[i
];
3635 menu_help_paneno
= pn
- 1;
3636 menu_help_itemno
= i
;
3639 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3641 for (j
= 0, q
= menu
->text
[i
]; *q
; j
++)
3645 SET_CHAR_GLYPH (*p
, *q
++, face
, 0);
3648 else /* make '^x' */
3650 SET_CHAR_GLYPH (*p
, '^', face
, 0);
3653 SET_CHAR_GLYPH (*p
, *q
++ + 64, face
, 0);
3657 /* Don't let the menu text overflow into the next screen row. */
3658 if (x
+ max_width
> screen_size_X
)
3660 max_width
= screen_size_X
- x
;
3661 text
[max_width
- 1].u
.ch
= '$'; /* indicate it's truncated */
3663 for (; j
< max_width
- 2; j
++, p
++)
3664 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3666 SET_CHAR_GLYPH (*p
, menu
->submenu
[i
] ? 16 : ' ', face
, 0);
3668 IT_write_glyphs (text
, max_width
);
3671 IT_cursor_to (row
, col
);
3675 /* --------------------------- X Menu emulation ---------------------- */
3677 /* Report availability of menus. */
3685 /* Create a brand new menu structure. */
3688 XMenuCreate (Display
*foo1
, Window foo2
, char *foo3
)
3690 return IT_menu_create ();
3693 /* Create a new pane and place it on the outer-most level. It is not
3694 clear that it should be placed out there, but I don't know what else
3698 XMenuAddPane (Display
*foo
, XMenu
*menu
, char *txt
, int enable
)
3706 IT_menu_make_room (menu
);
3707 menu
->submenu
[menu
->count
] = IT_menu_create ();
3708 menu
->text
[menu
->count
] = txt
;
3709 menu
->panenumber
[menu
->count
] = ++menu
->panecount
;
3710 menu
->help_text
[menu
->count
] = NULL
;
3713 /* Adjust length for possible control characters (which will
3714 be written as ^x). */
3715 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3719 if (len
> menu
->width
)
3722 return menu
->panecount
;
3725 /* Create a new item in a menu pane. */
3728 XMenuAddSelection (Display
*bar
, XMenu
*menu
, int pane
,
3729 int foo
, char *txt
, int enable
, char *help_text
)
3735 if (!(menu
= IT_menu_search_pane (menu
, pane
)))
3737 IT_menu_make_room (menu
);
3738 menu
->submenu
[menu
->count
] = (XMenu
*) 0;
3739 menu
->text
[menu
->count
] = txt
;
3740 menu
->panenumber
[menu
->count
] = enable
;
3741 menu
->help_text
[menu
->count
] = help_text
;
3744 /* Adjust length for possible control characters (which will
3745 be written as ^x). */
3746 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3750 if (len
> menu
->width
)
3756 /* Decide where the menu would be placed if requested at (X,Y). */
3759 XMenuLocate (Display
*foo0
, XMenu
*menu
, int foo1
, int foo2
, int x
, int y
,
3760 int *ulx
, int *uly
, int *width
, int *height
)
3762 IT_menu_calc_size (menu
, width
, height
);
3768 struct IT_menu_state
3770 void *screen_behind
;
3777 /* Display menu, wait for user's response, and return that response. */
3780 XMenuActivate (Display
*foo
, XMenu
*menu
, int *pane
, int *selidx
,
3781 int x0
, int y0
, unsigned ButtonMask
, char **txt
,
3782 void (*help_callback
)(char *, int, int))
3784 struct IT_menu_state
*state
;
3789 Lisp_Object selectface
;
3790 int leave
, result
, onepane
;
3791 int title_faces
[4]; /* face to display the menu title */
3792 int buffers_num_deleted
= 0;
3793 struct frame
*sf
= SELECTED_FRAME();
3794 Lisp_Object saved_echo_area_message
;
3796 /* Just in case we got here without a mouse present... */
3797 if (have_mouse
<= 0)
3798 return XM_IA_SELECT
;
3799 /* Don't allow non-positive x0 and y0, lest the menu will wrap
3800 around the display. */
3806 /* We will process all the mouse events directly, so we had
3807 better prevent dos_rawgetc from stealing them from us. */
3810 state
= alloca (menu
->panecount
* sizeof (struct IT_menu_state
));
3811 screensize
= screen_size
* 2;
3813 = lookup_derived_face (sf
, intern ("msdos-menu-passive-face"),
3814 0, DEFAULT_FACE_ID
);
3816 = lookup_derived_face (sf
, intern ("msdos-menu-active-face"),
3817 0, DEFAULT_FACE_ID
);
3818 selectface
= intern ("msdos-menu-select-face");
3819 faces
[2] = lookup_derived_face (sf
, selectface
,
3821 faces
[3] = lookup_derived_face (sf
, selectface
,
3824 /* Make sure the menu title is always displayed with
3825 `msdos-menu-active-face', no matter where the mouse pointer is. */
3826 for (i
= 0; i
< 4; i
++)
3827 title_faces
[i
] = faces
[3];
3831 /* Don't let the title for the "Buffers" popup menu include a
3832 digit (which is ugly).
3834 This is a terrible kludge, but I think the "Buffers" case is
3835 the only one where the title includes a number, so it doesn't
3836 seem to be necessary to make this more general. */
3837 if (strncmp (menu
->text
[0], "Buffers 1", 9) == 0)
3839 menu
->text
[0][7] = '\0';
3840 buffers_num_deleted
= 1;
3843 /* We need to save the current echo area message, so that we could
3844 restore it below, before we exit. See the commentary below,
3845 before the call to message_with_string. */
3846 saved_echo_area_message
= Fcurrent_message ();
3847 state
[0].menu
= menu
;
3849 ScreenRetrieve (state
[0].screen_behind
= xmalloc (screensize
));
3851 /* Turn off the cursor. Otherwise it shows through the menu
3852 panes, which is ugly. */
3853 IT_display_cursor (0);
3855 /* Display the menu title. */
3856 IT_menu_display (menu
, y0
- 1, x0
- 1, 1, title_faces
, 0);
3857 if (buffers_num_deleted
)
3858 menu
->text
[0][7] = ' ';
3859 if ((onepane
= menu
->count
== 1 && menu
->submenu
[0]))
3861 menu
->width
= menu
->submenu
[0]->width
;
3862 state
[0].menu
= menu
->submenu
[0];
3866 state
[0].menu
= menu
;
3868 state
[0].x
= x0
- 1;
3870 state
[0].pane
= onepane
;
3872 mouse_last_x
= -1; /* A hack that forces display. */
3876 if (!mouse_visible
) mouse_on ();
3877 mouse_check_moved ();
3878 if (sf
->mouse_moved
)
3880 sf
->mouse_moved
= 0;
3881 result
= XM_IA_SELECT
;
3882 mouse_get_xy (&x
, &y
);
3883 for (i
= 0; i
< statecount
; i
++)
3884 if (state
[i
].x
<= x
&& x
< state
[i
].x
+ state
[i
].menu
->width
+ 2)
3886 int dy
= y
- state
[i
].y
;
3887 if (0 <= dy
&& dy
< state
[i
].menu
->count
)
3889 if (!state
[i
].menu
->submenu
[dy
])
3890 if (state
[i
].menu
->panenumber
[dy
])
3891 result
= XM_SUCCESS
;
3893 result
= XM_IA_SELECT
;
3894 *pane
= state
[i
].pane
- 1;
3896 /* We hit some part of a menu, so drop extra menus that
3897 have been opened. That does not include an open and
3899 if (i
!= statecount
- 2
3900 || state
[i
].menu
->submenu
[dy
] != state
[i
+1].menu
)
3901 while (i
!= statecount
- 1)
3905 ScreenUpdate (state
[statecount
].screen_behind
);
3906 if (screen_virtual_segment
)
3907 dosv_refresh_virtual_screen (0, screen_size
);
3908 xfree (state
[statecount
].screen_behind
);
3910 if (i
== statecount
- 1 && state
[i
].menu
->submenu
[dy
])
3912 IT_menu_display (state
[i
].menu
,
3917 state
[statecount
].menu
= state
[i
].menu
->submenu
[dy
];
3918 state
[statecount
].pane
= state
[i
].menu
->panenumber
[dy
];
3920 ScreenRetrieve (state
[statecount
].screen_behind
3921 = xmalloc (screensize
));
3923 = state
[i
].x
+ state
[i
].menu
->width
+ 2;
3924 state
[statecount
].y
= y
;
3929 IT_menu_display (state
[statecount
- 1].menu
,
3930 state
[statecount
- 1].y
,
3931 state
[statecount
- 1].x
,
3932 state
[statecount
- 1].pane
,
3937 if ((menu_help_message
|| prev_menu_help_message
)
3938 && menu_help_message
!= prev_menu_help_message
)
3940 help_callback (menu_help_message
,
3941 menu_help_paneno
, menu_help_itemno
);
3942 IT_display_cursor (0);
3943 prev_menu_help_message
= menu_help_message
;
3945 /* We are busy-waiting for the mouse to move, so let's be nice
3946 to other Windows applications by releasing our time slice. */
3949 for (b
= 0; b
< mouse_button_count
&& !leave
; b
++)
3951 /* Only leave if user both pressed and released the mouse, and in
3952 that order. This avoids popping down the menu pane unless
3953 the user is really done with it. */
3954 if (mouse_pressed (b
, &x
, &y
))
3956 while (mouse_button_depressed (b
, &x
, &y
))
3960 (void) mouse_released (b
, &x
, &y
);
3965 ScreenUpdate (state
[0].screen_behind
);
3966 if (screen_virtual_segment
)
3967 dosv_refresh_virtual_screen (0, screen_size
);
3969 /* We have a situation here. ScreenUpdate has just restored the
3970 screen contents as it was before we started drawing this menu.
3971 That includes any echo area message that could have been
3972 displayed back then. (In reality, that echo area message will
3973 almost always be the ``keystroke echo'' that echoes the sequence
3974 of menu items chosen by the user.) However, if the menu had some
3975 help messages, then displaying those messages caused Emacs to
3976 forget about the original echo area message. So when
3977 ScreenUpdate restored it, it created a discrepancy between the
3978 actual screen contents and what Emacs internal data structures
3981 To avoid this conflict, we force Emacs to restore the original
3982 echo area message as we found it when we entered this function.
3983 The irony of this is that we then erase the restored message
3984 right away, so the only purpose of restoring it is so that
3985 erasing it works correctly... */
3986 if (! NILP (saved_echo_area_message
))
3987 message_with_string ("%s", saved_echo_area_message
, 0);
3989 while (statecount
--)
3990 xfree (state
[statecount
].screen_behind
);
3991 IT_display_cursor (1); /* turn cursor back on */
3992 /* Clean up any mouse events that are waiting inside Emacs event queue.
3993 These events are likely to be generated before the menu was even
3994 displayed, probably because the user pressed and released the button
3995 (which invoked the menu) too quickly. If we don't remove these events,
3996 Emacs will process them after we return and surprise the user. */
3997 discard_mouse_events ();
3998 mouse_clear_clicks ();
3999 if (!kbd_buffer_events_waiting (1))
4000 clear_input_pending ();
4001 /* Allow mouse events generation by dos_rawgetc. */
4006 /* Dispose of a menu. */
4009 XMenuDestroy (Display
*foo
, XMenu
*menu
)
4012 if (menu
->allocated
)
4014 for (i
= 0; i
< menu
->count
; i
++)
4015 if (menu
->submenu
[i
])
4016 XMenuDestroy (foo
, menu
->submenu
[i
]);
4018 xfree (menu
->submenu
);
4019 xfree (menu
->panenumber
);
4020 xfree (menu
->help_text
);
4023 menu_help_message
= prev_menu_help_message
= NULL
;
4027 x_pixel_width (struct frame
*f
)
4029 return FRAME_WIDTH (f
);
4033 x_pixel_height (struct frame
*f
)
4035 return FRAME_HEIGHT (f
);
4037 #endif /* !HAVE_X_WINDOWS */
4039 /* ----------------------- DOS / UNIX conversion --------------------- */
4041 void msdos_downcase_filename (unsigned char *);
4043 /* Destructively turn backslashes into slashes. */
4046 dostounix_filename (p
)
4049 msdos_downcase_filename (p
);
4059 /* Destructively turn slashes into backslashes. */
4062 unixtodos_filename (p
)
4065 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4079 /* Get the default directory for a given drive. 0=def, 1=A, 2=B, ... */
4082 getdefdir (drive
, dst
)
4086 char in_path
[4], *p
= in_path
;
4089 /* Generate "X:." (when drive is X) or "." (when drive is 0). */
4092 *p
++ = drive
+ 'A' - 1;
4099 _fixpath (in_path
, dst
);
4100 /* _fixpath can set errno to ENOSYS on non-LFN systems because
4101 it queries the LFN support, so ignore that error. */
4102 if ((errno
&& errno
!= ENOSYS
) || *dst
== '\0')
4105 msdos_downcase_filename (dst
);
4111 /* Remove all CR's that are followed by a LF. */
4116 register unsigned char *buf
;
4118 unsigned char *np
= buf
;
4119 unsigned char *startp
= buf
;
4120 unsigned char *endp
= buf
+ n
;
4124 while (buf
< endp
- 1)
4128 if (*(++buf
) != 0x0a)
4139 #if defined(__DJGPP__) && __DJGPP__ == 2 && __DJGPP_MINOR__ == 0
4141 /* In DJGPP v2.0, library `write' can call `malloc', which might
4142 cause relocation of the buffer whose address we get in ADDR.
4143 Here is a version of `write' that avoids calling `malloc',
4144 to serve us until such time as the library is fixed.
4145 Actually, what we define here is called `__write', because
4146 `write' is a stub that just jmp's to `__write' (to be
4147 POSIXLY-correct with respect to the global name-space). */
4149 #include <io.h> /* for _write */
4150 #include <libc/dosio.h> /* for __file_handle_modes[] */
4152 static char xbuf
[64 * 1024]; /* DOS cannot write more in one chunk */
4154 #define XBUF_END (xbuf + sizeof (xbuf) - 1)
4157 __write (int handle
, const void *buffer
, size_t count
)
4162 if(__file_handle_modes
[handle
] & O_BINARY
)
4163 return _write (handle
, buffer
, count
);
4167 const char *bp
= buffer
;
4168 int total_written
= 0;
4169 int nmoved
= 0, ncr
= 0;
4173 /* The next test makes sure there's space for at least 2 more
4174 characters in xbuf[], so both CR and LF can be put there. */
4186 if (xbp
>= XBUF_END
|| !count
)
4188 size_t to_write
= nmoved
+ ncr
;
4189 int written
= _write (handle
, xbuf
, to_write
);
4194 total_written
+= nmoved
; /* CRs aren't counted in ret value */
4196 /* If some, but not all were written (disk full?), return
4197 an estimate of the total written bytes not counting CRs. */
4198 if (written
< to_write
)
4199 return total_written
- (to_write
- written
) * nmoved
/to_write
;
4206 return total_written
;
4210 /* A low-level file-renaming function which works around Windows 95 bug.
4211 This is pulled directly out of DJGPP v2.01 library sources, and only
4212 used when you compile with DJGPP v2.0. */
4216 int _rename(const char *old
, const char *new)
4219 int olen
= strlen(old
) + 1;
4221 int use_lfn
= _USE_LFN
;
4222 char tempfile
[FILENAME_MAX
];
4223 const char *orig
= old
;
4226 r
.x
.dx
= __tb_offset
;
4227 r
.x
.di
= __tb_offset
+ olen
;
4228 r
.x
.ds
= r
.x
.es
= __tb_segment
;
4232 /* Windows 95 bug: for some filenames, when you rename
4233 file -> file~ (as in Emacs, to leave a backup), the
4234 short 8+3 alias doesn't change, which effectively
4235 makes OLD and NEW the same file. We must rename
4236 through a temporary file to work around this. */
4238 char *pbase
= 0, *p
;
4239 static char try_char
[] = "abcdefghijklmnopqrstuvwxyz012345789";
4240 int idx
= sizeof(try_char
) - 1;
4242 /* Generate a temporary name. Can't use `tmpnam', since $TMPDIR
4243 might point to another drive, which will fail the DOS call. */
4244 strcpy(tempfile
, old
);
4245 for (p
= tempfile
; *p
; p
++) /* ensure temporary is on the same drive */
4246 if (*p
== '/' || *p
== '\\' || *p
== ':')
4252 strcpy(pbase
, "X$$djren$$.$$temp$$");
4258 *pbase
= try_char
[--idx
];
4259 } while (_chmod(tempfile
, 0) != -1);
4262 _put_path2(tempfile
, olen
);
4264 __dpmi_int(0x21, &r
);
4267 errno
= __doserr_to_errno(r
.x
.ax
);
4271 /* Now create a file with the original name. This will
4272 ensure that NEW will always have a 8+3 alias
4273 different from that of OLD. (Seems to be required
4274 when NameNumericTail in the Registry is set to 0.) */
4275 lfn_fd
= _creat(old
, 0);
4277 olen
= strlen(tempfile
) + 1;
4279 r
.x
.di
= __tb_offset
+ olen
;
4288 _put_path2(new, olen
);
4290 __dpmi_int(0x21, &r
);
4293 if (r
.x
.ax
== 5 && i
== 0) /* access denied */
4294 remove(new); /* and try again */
4297 errno
= __doserr_to_errno(r
.x
.ax
);
4299 /* Restore to original name if we renamed it to temporary. */
4307 _put_path2(orig
, olen
);
4308 _put_path(tempfile
);
4310 __dpmi_int(0x21, &r
);
4319 /* Success. Delete the file possibly created to work
4320 around the Windows 95 bug. */
4322 return (_close (lfn_fd
) == 0) ? remove (orig
) : -1;
4326 #endif /* __DJGPP__ == 2 && __DJGPP_MINOR__ == 0 */
4328 DEFUN ("msdos-long-file-names", Fmsdos_long_file_names
, Smsdos_long_file_names
,
4330 "Return non-nil if long file names are supported on MSDOS.")
4333 return (_USE_LFN
? Qt
: Qnil
);
4336 /* Convert alphabetic characters in a filename to lower-case. */
4339 msdos_downcase_filename (p
)
4340 register unsigned char *p
;
4342 /* Always lower-case drive letters a-z, even if the filesystem
4343 preserves case in filenames.
4344 This is so MSDOS filenames could be compared by string comparison
4345 functions that are case-sensitive. Even case-preserving filesystems
4346 do not distinguish case in drive letters. */
4347 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
4353 /* Under LFN we expect to get pathnames in their true case. */
4354 if (NILP (Fmsdos_long_file_names ()))
4356 if (*p
>= 'A' && *p
<= 'Z')
4360 DEFUN ("msdos-downcase-filename", Fmsdos_downcase_filename
, Smsdos_downcase_filename
,
4362 "Convert alphabetic characters in FILENAME to lower case and return that.\n\
4363 When long filenames are supported, doesn't change FILENAME.\n\
4364 If FILENAME is not a string, returns nil.\n\
4365 The argument object is never altered--the value is a copy.")
4367 Lisp_Object filename
;
4371 if (! STRINGP (filename
))
4374 tem
= Fcopy_sequence (filename
);
4375 msdos_downcase_filename (XSTRING (tem
)->data
);
4379 /* The Emacs root directory as determined by init_environment. */
4381 static char emacsroot
[MAXPATHLEN
];
4384 rootrelativepath (rel
)
4387 static char result
[MAXPATHLEN
+ 10];
4389 strcpy (result
, emacsroot
);
4390 strcat (result
, "/");
4391 strcat (result
, rel
);
4395 /* Define a lot of environment variables if not already defined. Don't
4396 remove anything unless you know what you're doing -- lots of code will
4397 break if one or more of these are missing. */
4400 init_environment (argc
, argv
, skip_args
)
4407 static const char * const tempdirs
[] = {
4408 "$TMPDIR", "$TEMP", "$TMP", "c:/"
4411 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
4413 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
4414 temporary files and assume "/tmp" if $TMPDIR is unset, which
4415 will break on DOS/Windows. Refuse to work if we cannot find
4416 a directory, not even "c:/", usable for that purpose. */
4417 for (i
= 0; i
< imax
; i
++)
4419 const char *tmp
= tempdirs
[i
];
4422 tmp
= getenv (tmp
+ 1);
4423 /* Note that `access' can lie to us if the directory resides on a
4424 read-only filesystem, like CD-ROM or a write-protected floppy.
4425 The only way to be really sure is to actually create a file and
4426 see if it succeeds. But I think that's too much to ask. */
4427 if (tmp
&& access (tmp
, D_OK
) == 0)
4429 setenv ("TMPDIR", tmp
, 1);
4436 Fcons (build_string ("no usable temporary directories found!!"),
4438 "While setting TMPDIR: ");
4440 /* Note the startup time, so we know not to clear the screen if we
4441 exit immediately; see IT_reset_terminal_modes.
4442 (Yes, I know `clock' returns zero the first time it's called, but
4443 I do this anyway, in case some wiseguy changes that at some point.) */
4444 startup_time
= clock ();
4446 /* Find our root from argv[0]. Assuming argv[0] is, say,
4447 "c:/emacs/bin/emacs.exe" our root will be "c:/emacs". */
4448 root
= alloca (MAXPATHLEN
+ 20);
4449 _fixpath (argv
[0], root
);
4450 msdos_downcase_filename (root
);
4451 len
= strlen (root
);
4452 while (len
> 0 && root
[len
] != '/' && root
[len
] != ':')
4456 && (strcmp (root
+ len
- 4, "/bin") == 0
4457 || strcmp (root
+ len
- 4, "/src") == 0)) /* under a debugger */
4458 root
[len
- 4] = '\0';
4460 strcpy (root
, "c:/emacs"); /* let's be defensive */
4461 len
= strlen (root
);
4462 strcpy (emacsroot
, root
);
4464 /* We default HOME to our root. */
4465 setenv ("HOME", root
, 0);
4467 /* We default EMACSPATH to root + "/bin". */
4468 strcpy (root
+ len
, "/bin");
4469 setenv ("EMACSPATH", root
, 0);
4471 /* I don't expect anybody to ever use other terminals so the internal
4472 terminal is the default. */
4473 setenv ("TERM", "internal", 0);
4475 #ifdef HAVE_X_WINDOWS
4476 /* Emacs expects DISPLAY to be set. */
4477 setenv ("DISPLAY", "unix:0.0", 0);
4480 /* SHELL is a bit tricky -- COMSPEC is the closest we come, but we must
4481 downcase it and mirror the backslashes. */
4482 s
= getenv ("COMSPEC");
4483 if (!s
) s
= "c:/command.com";
4484 t
= alloca (strlen (s
) + 1);
4486 dostounix_filename (t
);
4487 setenv ("SHELL", t
, 0);
4489 /* PATH is also downcased and backslashes mirrored. */
4490 s
= getenv ("PATH");
4492 t
= alloca (strlen (s
) + 3);
4493 /* Current directory is always considered part of MsDos's path but it is
4494 not normally mentioned. Now it is. */
4495 strcat (strcpy (t
, ".;"), s
);
4496 dostounix_filename (t
); /* Not a single file name, but this should work. */
4497 setenv ("PATH", t
, 1);
4499 /* In some sense all dos users have root privileges, so... */
4500 setenv ("USER", "root", 0);
4501 setenv ("NAME", getenv ("USER"), 0);
4503 /* Time zone determined from country code. To make this possible, the
4504 country code may not span more than one time zone. In other words,
4505 in the USA, you lose. */
4507 switch (dos_country_code
)
4509 case 31: /* Belgium */
4510 case 32: /* The Netherlands */
4511 case 33: /* France */
4512 case 34: /* Spain */
4513 case 36: /* Hungary */
4514 case 38: /* Yugoslavia (or what's left of it?) */
4515 case 39: /* Italy */
4516 case 41: /* Switzerland */
4517 case 42: /* Tjekia */
4518 case 45: /* Denmark */
4519 case 46: /* Sweden */
4520 case 47: /* Norway */
4521 case 48: /* Poland */
4522 case 49: /* Germany */
4523 /* Daylight saving from last Sunday in March to last Sunday in
4524 September, both at 2AM. */
4525 setenv ("TZ", "MET-01METDST-02,M3.5.0/02:00,M9.5.0/02:00", 0);
4527 case 44: /* United Kingdom */
4528 case 351: /* Portugal */
4529 case 354: /* Iceland */
4530 setenv ("TZ", "GMT+00", 0);
4532 case 81: /* Japan */
4533 case 82: /* Korea */
4534 setenv ("TZ", "JST-09", 0);
4536 case 90: /* Turkey */
4537 case 358: /* Finland */
4538 setenv ("TZ", "EET-02", 0);
4540 case 972: /* Israel */
4541 /* This is an approximation. (For exact rules, use the
4542 `zoneinfo/israel' file which comes with DJGPP, but you need
4543 to install it in `/usr/share/zoneinfo/' directory first.) */
4544 setenv ("TZ", "IST-02IDT-03,M4.1.6/00:00,M9.5.6/01:00", 0);
4552 static int break_stat
; /* BREAK check mode status. */
4553 static int stdin_stat
; /* stdin IOCTL status. */
4557 /* These must be global. */
4558 static _go32_dpmi_seginfo ctrl_break_vector
;
4559 static _go32_dpmi_registers ctrl_break_regs
;
4560 static int ctrlbreakinstalled
= 0;
4562 /* Interrupt level detection of Ctrl-Break. Don't do anything fancy here! */
4565 ctrl_break_func (regs
)
4566 _go32_dpmi_registers
*regs
;
4572 install_ctrl_break_check ()
4574 if (!ctrlbreakinstalled
)
4576 /* Don't press Ctrl-Break if you don't have either DPMI or Emacs
4577 was compiler with Djgpp 1.11 maintenance level 5 or later! */
4578 ctrlbreakinstalled
= 1;
4579 ctrl_break_vector
.pm_offset
= (int) ctrl_break_func
;
4580 _go32_dpmi_allocate_real_mode_callback_iret (&ctrl_break_vector
,
4582 _go32_dpmi_set_real_mode_interrupt_vector (0x1b, &ctrl_break_vector
);
4586 #endif /* __DJGPP__ < 2 */
4588 /* Turn off Dos' Ctrl-C checking and inhibit interpretation of
4589 control chars by DOS. Determine the keyboard type. */
4594 union REGS inregs
, outregs
;
4595 static int first_time
= 1;
4597 break_stat
= getcbrk ();
4600 install_ctrl_break_check ();
4606 int86 (0x15, &inregs
, &outregs
);
4607 extended_kbd
= (!outregs
.x
.cflag
) && (outregs
.h
.ah
== 0);
4611 if (internal_terminal
4612 #ifdef HAVE_X_WINDOWS
4613 && inhibit_window_system
4617 inregs
.x
.ax
= 0x0021;
4618 int86 (0x33, &inregs
, &outregs
);
4619 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4622 /* Reportedly, the above doesn't work for some mouse drivers. There
4623 is an additional detection method that should work, but might be
4624 a little slower. Use that as an alternative. */
4625 inregs
.x
.ax
= 0x0000;
4626 int86 (0x33, &inregs
, &outregs
);
4627 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4632 have_mouse
= 1; /* enable mouse */
4634 mouse_setup_buttons (outregs
.x
.bx
);
4635 mouse_position_hook
= &mouse_get_pos
;
4639 #ifndef HAVE_X_WINDOWS
4641 /* Save the cursor shape used outside Emacs. */
4642 outside_cursor
= _farpeekw (_dos_ds
, 0x460);
4651 stdin_stat
= setmode (fileno (stdin
), O_BINARY
);
4652 return (stdin_stat
!= -1);
4655 return (setmode (fileno (stdin
), O_BINARY
) != -1);
4657 #else /* __DJGPP__ < 2 */
4661 /* I think it is wrong to overwrite `stdin_stat' every time
4662 but the first one this function is called, but I don't
4663 want to change the way it used to work in v1.x.--EZ */
4665 inregs
.x
.ax
= 0x4400; /* Get IOCTL status. */
4666 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4667 intdos (&inregs
, &outregs
);
4668 stdin_stat
= outregs
.h
.dl
;
4670 inregs
.x
.dx
= stdin_stat
| 0x0020; /* raw mode */
4671 inregs
.x
.ax
= 0x4401; /* Set IOCTL status */
4672 intdos (&inregs
, &outregs
);
4673 return !outregs
.x
.cflag
;
4675 #endif /* __DJGPP__ < 2 */
4678 /* Restore status of standard input and Ctrl-C checking. */
4683 union REGS inregs
, outregs
;
4685 setcbrk (break_stat
);
4690 #ifndef HAVE_X_WINDOWS
4691 /* Restore the cursor shape we found on startup. */
4695 inregs
.x
.cx
= outside_cursor
;
4696 int86 (0x10, &inregs
, &outregs
);
4700 return (setmode (fileno (stdin
), stdin_stat
) != -1);
4702 #else /* not __DJGPP__ >= 2 */
4704 inregs
.x
.ax
= 0x4401; /* Set IOCTL status. */
4705 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4706 inregs
.x
.dx
= stdin_stat
;
4707 intdos (&inregs
, &outregs
);
4708 return !outregs
.x
.cflag
;
4710 #endif /* not __DJGPP__ >= 2 */
4714 /* Run command as specified by ARGV in directory DIR.
4715 The command is run with input from TEMPIN, output to
4716 file TEMPOUT and stderr to TEMPERR. */
4719 run_msdos_command (argv
, working_dir
, tempin
, tempout
, temperr
, envv
)
4720 unsigned char **argv
;
4721 const char *working_dir
;
4722 int tempin
, tempout
, temperr
;
4725 char *saveargv1
, *saveargv2
, *lowcase_argv0
, *pa
, *pl
;
4726 char oldwd
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
4727 int msshell
, result
= -1;
4728 int inbak
, outbak
, errbak
;
4732 /* Get current directory as MSDOS cwd is not per-process. */
4735 /* If argv[0] is the shell, it might come in any lettercase.
4736 Since `Fmember' is case-sensitive, we need to downcase
4737 argv[0], even if we are on case-preserving filesystems. */
4738 lowcase_argv0
= alloca (strlen (argv
[0]) + 1);
4739 for (pa
= argv
[0], pl
= lowcase_argv0
; *pa
; pl
++)
4742 if (*pl
>= 'A' && *pl
<= 'Z')
4747 cmd
= Ffile_name_nondirectory (build_string (lowcase_argv0
));
4748 msshell
= !NILP (Fmember (cmd
, Fsymbol_value (intern ("msdos-shells"))))
4749 && !strcmp ("-c", argv
[1]);
4752 saveargv1
= argv
[1];
4753 saveargv2
= argv
[2];
4755 /* We only need to mirror slashes if a DOS shell will be invoked
4756 not via `system' (which does the mirroring itself). Yes, that
4757 means DJGPP v1.x will lose here. */
4758 if (argv
[2] && argv
[3])
4760 char *p
= alloca (strlen (argv
[2]) + 1);
4762 strcpy (argv
[2] = p
, saveargv2
);
4763 while (*p
&& isspace (*p
))
4775 chdir (working_dir
);
4779 if (inbak
< 0 || outbak
< 0 || errbak
< 0)
4780 goto done
; /* Allocation might fail due to lack of descriptors. */
4783 mouse_get_xy (&x
, &y
);
4785 dos_ttcooked (); /* do it here while 0 = stdin */
4793 if (msshell
&& !argv
[3])
4795 /* MS-DOS native shells are too restrictive. For starters, they
4796 cannot grok commands longer than 126 characters. In DJGPP v2
4797 and later, `system' is much smarter, so we'll call it instead. */
4801 /* A shell gets a single argument--its full command
4802 line--whose original was saved in `saveargv2'. */
4804 /* Don't let them pass empty command lines to `system', since
4805 with some shells it will try to invoke an interactive shell,
4806 which will hang Emacs. */
4807 for (cmnd
= saveargv2
; *cmnd
&& isspace (*cmnd
); cmnd
++)
4811 extern char **environ
;
4812 char **save_env
= environ
;
4813 int save_system_flags
= __system_flags
;
4815 /* Request the most powerful version of `system'. We need
4816 all the help we can get to avoid calling stock DOS shells. */
4817 __system_flags
= (__system_redirect
4818 | __system_use_shell
4819 | __system_allow_multiple_cmds
4820 | __system_allow_long_cmds
4821 | __system_handle_null_commands
4822 | __system_emulate_chdir
);
4825 result
= system (cmnd
);
4826 __system_flags
= save_system_flags
;
4830 result
= 0; /* emulate Unixy shell behavior with empty cmd line */
4834 #endif /* __DJGPP__ > 1 */
4836 result
= spawnve (P_WAIT
, argv
[0], argv
, envv
);
4841 emacs_close (inbak
);
4842 emacs_close (outbak
);
4843 emacs_close (errbak
);
4849 mouse_moveto (x
, y
);
4852 /* Some programs might change the meaning of the highest bit of the
4853 text attribute byte, so we get blinking characters instead of the
4854 bright background colors. Restore that. */
4861 argv
[1] = saveargv1
;
4862 argv
[2] = saveargv2
;
4870 fprintf (stderr
, "%s not yet implemented\r\n", badfunc
);
4877 /* ------------------------- Compatibility functions -------------------
4882 /* Hostnames for a pc are not really funny,
4883 but they are used in change log so we emulate the best we can. */
4885 gethostname (p
, size
)
4889 char *q
= egetenv ("HOSTNAME");
4896 /* When time zones are set from Ms-Dos too many C-libraries are playing
4897 tricks with time values. We solve this by defining our own version
4898 of `gettimeofday' bypassing GO32. Our version needs to be initialized
4899 once and after each call to `tzset' with TZ changed. That is
4900 accomplished by aliasing tzset to init_gettimeofday. */
4902 static struct tm time_rec
;
4905 gettimeofday (struct timeval
*tp
, struct timezone
*tzp
)
4913 if (t
.ti_hour
< time_rec
.tm_hour
) /* midnight wrap */
4917 time_rec
.tm_year
= d
.da_year
- 1900;
4918 time_rec
.tm_mon
= d
.da_mon
- 1;
4919 time_rec
.tm_mday
= d
.da_day
;
4922 time_rec
.tm_hour
= t
.ti_hour
;
4923 time_rec
.tm_min
= t
.ti_min
;
4924 time_rec
.tm_sec
= t
.ti_sec
;
4927 tm
.tm_gmtoff
= dos_timezone_offset
;
4929 tp
->tv_sec
= mktime (&tm
); /* may modify tm */
4930 tp
->tv_usec
= t
.ti_hund
* (1000000 / 100);
4932 /* Ignore tzp; it's obsolescent. */
4936 #endif /* __DJGPP__ < 2 */
4939 * A list of unimplemented functions that we silently ignore.
4943 unsigned alarm (s
) unsigned s
; {}
4944 fork () { return 0; }
4945 int kill (x
, y
) int x
, y
; { return -1; }
4947 void volatile pause () {}
4948 sigsetmask (x
) int x
; { return 0; }
4949 sigblock (mask
) int mask
; { return 0; }
4952 void request_sigio (void) {}
4953 setpgrp () {return 0; }
4954 setpriority (x
,y
,z
) int x
,y
,z
; { return 0; }
4955 void unrequest_sigio (void) {}
4959 #ifdef POSIX_SIGNALS
4961 /* Augment DJGPP library POSIX signal functions. This is needed
4962 as of DJGPP v2.01, but might be in the library in later releases. */
4964 #include <libc/bss.h>
4966 /* A counter to know when to re-initialize the static sets. */
4967 static int sigprocmask_count
= -1;
4969 /* Which signals are currently blocked (initially none). */
4970 static sigset_t current_mask
;
4972 /* Which signals are pending (initially none). */
4973 static sigset_t pending_signals
;
4975 /* Previous handlers to restore when the blocked signals are unblocked. */
4976 typedef void (*sighandler_t
)(int);
4977 static sighandler_t prev_handlers
[320];
4979 /* A signal handler which just records that a signal occured
4980 (it will be raised later, if and when the signal is unblocked). */
4982 sig_suspender (signo
)
4985 sigaddset (&pending_signals
, signo
);
4989 sigprocmask (how
, new_set
, old_set
)
4991 const sigset_t
*new_set
;
4997 /* If called for the first time, initialize. */
4998 if (sigprocmask_count
!= __bss_count
)
5000 sigprocmask_count
= __bss_count
;
5001 sigemptyset (&pending_signals
);
5002 sigemptyset (¤t_mask
);
5003 for (signo
= 0; signo
< 320; signo
++)
5004 prev_handlers
[signo
] = SIG_ERR
;
5008 *old_set
= current_mask
;
5013 if (how
!= SIG_BLOCK
&& how
!= SIG_UNBLOCK
&& how
!= SIG_SETMASK
)
5019 sigemptyset (&new_mask
);
5021 /* DJGPP supports upto 320 signals. */
5022 for (signo
= 0; signo
< 320; signo
++)
5024 if (sigismember (¤t_mask
, signo
))
5025 sigaddset (&new_mask
, signo
);
5026 else if (sigismember (new_set
, signo
) && how
!= SIG_UNBLOCK
)
5028 sigaddset (&new_mask
, signo
);
5030 /* SIGKILL is silently ignored, as on other platforms. */
5031 if (signo
!= SIGKILL
&& prev_handlers
[signo
] == SIG_ERR
)
5032 prev_handlers
[signo
] = signal (signo
, sig_suspender
);
5034 if (( how
== SIG_UNBLOCK
5035 && sigismember (&new_mask
, signo
)
5036 && sigismember (new_set
, signo
))
5037 || (how
== SIG_SETMASK
5038 && sigismember (&new_mask
, signo
)
5039 && !sigismember (new_set
, signo
)))
5041 sigdelset (&new_mask
, signo
);
5042 if (prev_handlers
[signo
] != SIG_ERR
)
5044 signal (signo
, prev_handlers
[signo
]);
5045 prev_handlers
[signo
] = SIG_ERR
;
5047 if (sigismember (&pending_signals
, signo
))
5049 sigdelset (&pending_signals
, signo
);
5054 current_mask
= new_mask
;
5058 #else /* not POSIX_SIGNALS */
5060 sigsetmask (x
) int x
; { return 0; }
5061 sigblock (mask
) int mask
; { return 0; }
5063 #endif /* not POSIX_SIGNALS */
5064 #endif /* __DJGPP__ > 1 */
5067 #include "sysselect.h"
5069 #ifndef EMACS_TIME_ZERO_OR_NEG_P
5070 #define EMACS_TIME_ZERO_OR_NEG_P(time) \
5071 ((long)(time).tv_sec < 0 \
5072 || ((time).tv_sec == 0 \
5073 && (long)(time).tv_usec <= 0))
5076 /* This yields the rest of the current time slice to the task manager.
5077 It should be called by any code which knows that it has nothing
5078 useful to do except idle.
5080 I don't use __dpmi_yield here, since versions of library before 2.02
5081 called Int 2Fh/AX=1680h there in a way that would wedge the DOS box
5082 on some versions of Windows 9X. */
5085 dos_yield_time_slice (void)
5087 _go32_dpmi_registers r
;
5090 r
.x
.ss
= r
.x
.sp
= r
.x
.flags
= 0;
5091 _go32_dpmi_simulate_int (0x2f, &r
);
5096 /* Only event queue is checked. */
5097 /* We don't have to call timer_check here
5098 because wait_reading_process_input takes care of that. */
5100 sys_select (nfds
, rfds
, wfds
, efds
, timeout
)
5102 SELECT_TYPE
*rfds
, *wfds
, *efds
;
5103 EMACS_TIME
*timeout
;
5111 check_input
= FD_ISSET (0, rfds
);
5122 /* If we are looking only for the terminal, with no timeout,
5123 just read it and wait -- that's more efficient. */
5126 while (!detect_input_pending ())
5128 dos_yield_time_slice ();
5133 EMACS_TIME clnow
, cllast
, cldiff
;
5136 EMACS_SET_SECS_USECS (cllast
, t
.ti_sec
, t
.ti_hund
* 10000L);
5138 while (!check_input
|| !detect_input_pending ())
5141 EMACS_SET_SECS_USECS (clnow
, t
.ti_sec
, t
.ti_hund
* 10000L);
5142 EMACS_SUB_TIME (cldiff
, clnow
, cllast
);
5144 /* When seconds wrap around, we assume that no more than
5145 1 minute passed since last `gettime'. */
5146 if (EMACS_TIME_NEG_P (cldiff
))
5147 EMACS_SET_SECS (cldiff
, EMACS_SECS (cldiff
) + 60);
5148 EMACS_SUB_TIME (*timeout
, *timeout
, cldiff
);
5150 /* Stop when timeout value crosses zero. */
5151 if (EMACS_TIME_ZERO_OR_NEG_P (*timeout
))
5154 dos_yield_time_slice ();
5164 * Define overlaid functions:
5166 * chdir -> sys_chdir
5167 * tzset -> init_gettimeofday
5168 * abort -> dos_abort
5173 extern int chdir ();
5179 int len
= strlen (path
);
5180 char *tmp
= (char *)path
;
5182 if (*tmp
&& tmp
[1] == ':')
5184 if (getdisk () != tolower (tmp
[0]) - 'a')
5185 setdisk (tolower (tmp
[0]) - 'a');
5186 tmp
+= 2; /* strip drive: KFS 1995-07-06 */
5190 if (len
> 1 && (tmp
[len
- 1] == '/'))
5192 char *tmp1
= (char *) alloca (len
+ 1);
5203 extern void tzset (void);
5206 init_gettimeofday ()
5212 ltm
= gtm
= time (NULL
);
5213 ltm
= mktime (lstm
= localtime (<m
));
5214 gtm
= mktime (gmtime (>m
));
5215 time_rec
.tm_hour
= 99; /* force gettimeofday to get date */
5216 time_rec
.tm_isdst
= lstm
->tm_isdst
;
5217 dos_timezone_offset
= time_rec
.tm_gmtoff
= (int)(gtm
- ltm
) / 60;
5224 dos_abort (file
, line
)
5228 char buffer1
[200], buffer2
[400];
5231 sprintf (buffer1
, "<EMACS FATAL ERROR IN %s LINE %d>", file
, line
);
5232 for (i
= j
= 0; buffer1
[i
]; i
++) {
5233 buffer2
[j
++] = buffer1
[i
];
5234 buffer2
[j
++] = 0x70;
5236 dosmemput (buffer2
, j
, (int)ScreenPrimary
);
5237 ScreenSetCursor (2, 0);
5245 ScreenSetCursor (10, 0);
5246 cputs ("\r\n\nEmacs aborted!\r\n");
5248 #if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
5249 if (screen_virtual_segment
)
5250 dosv_refresh_virtual_screen (2 * 10 * screen_size_X
, 4 * screen_size_X
);
5251 /* Generate traceback, so we could tell whodunit. */
5252 signal (SIGINT
, SIG_DFL
);
5253 __asm__
__volatile__ ("movb $0x1b,%al;call ___djgpp_hw_exception");
5254 #else /* __DJGPP_MINOR__ >= 2 */
5256 #endif /* __DJGPP_MINOR__ >= 2 */
5262 /* The following variables are required so that cus-start.el won't
5263 complain about unbound variables. */
5264 #ifndef HAVE_X_WINDOWS
5265 /* Search path for bitmap files (xfns.c). */
5266 Lisp_Object Vx_bitmap_file_path
;
5267 int x_stretch_cursor_p
;
5269 #ifndef subprocesses
5270 /* Nonzero means delete a process right away if it exits (process.c). */
5271 static int delete_exited_processes
;
5276 recent_doskeys
= Fmake_vector (make_number (NUM_RECENT_DOSKEYS
), Qnil
);
5277 staticpro (&recent_doskeys
);
5278 #ifndef HAVE_X_WINDOWS
5280 staticpro (&help_echo
);
5281 help_echo_object
= Qnil
;
5282 staticpro (&help_echo_object
);
5283 help_echo_window
= Qnil
;
5284 staticpro (&help_echo_window
);
5285 previous_help_echo
= Qnil
;
5286 staticpro (&previous_help_echo
);
5289 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
5290 "List of directories to search for bitmap files for X.");
5291 Vx_bitmap_file_path
= decode_env_path ((char *) 0, ".");
5293 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
5294 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
5295 For example, if a block cursor is over a tab, it will be drawn as\n\
5296 wide as that tab on the display. (No effect on MS-DOS.)");
5297 x_stretch_cursor_p
= 0;
5299 /* The following two are from xfns.c: */
5300 Qbar
= intern ("bar");
5302 Qcursor_type
= intern ("cursor-type");
5303 staticpro (&Qcursor_type
);
5304 Qreverse
= intern ("reverse");
5305 staticpro (&Qreverse
);
5307 DEFVAR_LISP ("dos-unsupported-char-glyph", &Vdos_unsupported_char_glyph
,
5308 "*Glyph to display instead of chars not supported by current codepage.\n\
5310 This variable is used only by MSDOS terminals.");
5311 Vdos_unsupported_char_glyph
= '\177';
5313 #ifndef subprocesses
5314 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
5315 "*Non-nil means delete processes immediately when they exit.\n\
5316 nil means don't delete them until `list-processes' is run.");
5317 delete_exited_processes
= 0;
5320 defsubr (&Srecent_doskeys
);
5321 defsubr (&Smsdos_long_file_names
);
5322 defsubr (&Smsdos_downcase_filename
);
5323 defsubr (&Smsdos_remember_default_colors
);
5324 defsubr (&Smsdos_set_mouse_buttons
);