1 /* MS-DOS specific C utilities. -*- coding: raw-text -*-
2 Copyright (C) 1993, 94, 95, 96, 97, 1999 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
6 GNU Emacs is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
21 /* Contributed by Morten Welinder */
22 /* New display, keyboard, and mouse control by Kim F. Storm */
24 /* Note: some of the stuff here was taken from end of sysdep.c in demacs. */
33 #include <sys/param.h>
37 #include <string.h> /* for bzero and string functions */
38 #include <sys/stat.h> /* for _fixpath */
39 #include <unistd.h> /* for chdir, dup, dup2, etc. */
42 #include <io.h> /* for setmode */
43 #include <dpmi.h> /* for __dpmi_xxx stuff */
44 #include <sys/farptr.h> /* for _farsetsel, _farnspokeb */
45 #include <libc/dosio.h> /* for _USE_LFN */
46 #include <conio.h> /* for cputs */
51 #include "termhooks.h"
53 #include "dispextern.h"
63 #include "blockinput.h"
67 /* #include <process.h> */
68 /* Damn that local process.h! Instead we can define P_WAIT ourselves. */
76 #define _dos_ds _go32_info_block.selector_for_linear_memory
82 #include "syssignal.h"
88 /* If other `malloc' than ours is used, force our `sbrk' behave like
89 Unix programs expect (resize memory blocks to keep them contiguous).
90 If `sbrk' from `ralloc.c' is NOT used, also zero-out sbrk'ed memory,
91 because that's what `gmalloc' expects to get. */
95 int _crt0_startup_flags
= _CRT0_FLAG_UNIX_SBRK
;
96 #else /* not REL_ALLOC */
97 int _crt0_startup_flags
= (_CRT0_FLAG_UNIX_SBRK
| _CRT0_FLAG_FILL_SBRK_MEMORY
);
98 #endif /* not REL_ALLOC */
99 #endif /* GNU_MALLOC */
101 #endif /* not SYSTEM_MALLOC */
102 #endif /* __DJGPP__ > 1 */
121 /* ------------------------ Mouse control ---------------------------
123 * Coordinates are in screen positions and zero based.
124 * Mouse buttons are numbered from left to right and also zero based.
127 int have_mouse
; /* 0: no, 1: enabled, -1: disabled */
128 static int mouse_visible
;
130 static int mouse_last_x
;
131 static int mouse_last_y
;
133 static int mouse_button_translate
[NUM_MOUSE_BUTTONS
];
134 static int mouse_button_count
;
141 if (have_mouse
> 0 && !mouse_visible
)
144 fprintf (termscript
, "<M_ON>");
146 int86 (0x33, ®s
, ®s
);
156 if (have_mouse
> 0 && mouse_visible
)
159 fprintf (termscript
, "<M_OFF>");
161 int86 (0x33, ®s
, ®s
);
167 mouse_get_xy (int *x
, int *y
)
172 int86 (0x33, ®s
, ®s
);
184 fprintf (termscript
, "<M_XY=%dx%d>", x
, y
);
186 mouse_last_x
= regs
.x
.cx
= x
* 8;
187 mouse_last_y
= regs
.x
.dx
= y
* 8;
188 int86 (0x33, ®s
, ®s
);
192 mouse_pressed (b
, xp
, yp
)
197 if (b
>= mouse_button_count
)
200 regs
.x
.bx
= mouse_button_translate
[b
];
201 int86 (0x33, ®s
, ®s
);
203 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
204 return (regs
.x
.bx
!= 0);
208 mouse_released (b
, xp
, yp
)
213 if (b
>= mouse_button_count
)
216 regs
.x
.bx
= mouse_button_translate
[b
];
217 int86 (0x33, ®s
, ®s
);
219 *xp
= regs
.x
.cx
/ 8, *yp
= regs
.x
.dx
/ 8;
220 return (regs
.x
.bx
!= 0);
224 mouse_button_depressed (b
, xp
, yp
)
229 if (b
>= mouse_button_count
)
232 int86 (0x33, ®s
, ®s
);
233 if ((regs
.x
.bx
& (1 << mouse_button_translate
[b
])) != 0)
243 mouse_get_pos (f
, insist
, bar_window
, part
, x
, y
, time
)
246 Lisp_Object
*bar_window
, *x
, *y
;
247 enum scroll_bar_part
*part
;
251 Lisp_Object frame
, tail
;
253 /* Clear the mouse-moved flag for every frame on this display. */
254 FOR_EACH_FRAME (tail
, frame
)
255 XFRAME (frame
)->mouse_moved
= 0;
257 *f
= SELECTED_FRAME();
259 mouse_get_xy (&ix
, &iy
);
260 *time
= event_timestamp ();
261 *x
= make_number (mouse_last_x
= ix
);
262 *y
= make_number (mouse_last_y
= iy
);
270 mouse_get_xy (&x
, &y
);
271 SELECTED_FRAME()->mouse_moved
|= (x
!= mouse_last_x
|| y
!= mouse_last_y
);
283 fprintf (termscript
, "<M_INIT>");
286 int86 (0x33, ®s
, ®s
);
288 /* Reset the mouse last press/release info. It seems that Windows
289 doesn't do that automatically when function 21h is called, which
290 causes Emacs to ``remember'' the click that switched focus to the
291 window just before Emacs was started from that window. */
292 for (b
= 0; b
< mouse_button_count
; b
++)
294 int dummy_x
, dummy_y
;
296 (void) mouse_pressed (b
, &dummy_x
, &dummy_y
);
297 (void) mouse_released (b
, &dummy_x
, &dummy_y
);
302 regs
.x
.dx
= 8 * (ScreenCols () - 1);
303 int86 (0x33, ®s
, ®s
);
307 regs
.x
.dx
= 8 * (ScreenRows () - 1);
308 int86 (0x33, ®s
, ®s
);
314 /* ------------------------- Screen control ----------------------
318 static int internal_terminal
= 0;
320 #ifndef HAVE_X_WINDOWS
321 extern unsigned char ScreenAttrib
;
322 static int screen_face
;
323 static int highlight
;
325 static int screen_size_X
;
326 static int screen_size_Y
;
327 static int screen_size
;
329 static int current_pos_X
;
330 static int current_pos_Y
;
331 static int new_pos_X
;
332 static int new_pos_Y
;
334 static void *startup_screen_buffer
;
335 static int startup_screen_size_X
;
336 static int startup_screen_size_Y
;
337 static int startup_pos_X
;
338 static int startup_pos_Y
;
339 static unsigned char startup_screen_attrib
;
341 static clock_t startup_time
;
343 static int term_setup_done
;
345 /* Similar to the_only_frame. */
346 struct x_output the_only_x_display
;
348 /* Support for DOS/V (allows Japanese characters to be displayed on
349 standard, non-Japanese, ATs). Only supported for DJGPP v2 and later. */
351 /* Holds the address of the text-mode screen buffer. */
352 static unsigned long screen_old_address
= 0;
353 /* Segment and offset of the virtual screen. If 0, DOS/V is NOT loaded. */
354 static unsigned short screen_virtual_segment
= 0;
355 static unsigned short screen_virtual_offset
= 0;
356 /* A flag to control how to display unibyte 8-bit characters. */
357 extern int unibyte_display_via_language_environment
;
360 /* Update the screen from a part of relocated DOS/V screen buffer which
361 begins at OFFSET and includes COUNT characters. */
363 dosv_refresh_virtual_screen (int offset
, int count
)
367 if (offset
< 0 || count
< 0) /* paranoia; illegal values crash DOS/V */
370 regs
.h
.ah
= 0xff; /* update relocated screen */
371 regs
.x
.es
= screen_virtual_segment
;
372 regs
.x
.di
= screen_virtual_offset
+ offset
;
374 __dpmi_int (0x10, ®s
);
379 dos_direct_output (y
, x
, buf
, len
)
385 int t0
= 2 * (x
+ y
* screen_size_X
);
386 int t
= t0
+ (int) ScreenPrimary
;
391 dosmemput (buf
++, 1, t
);
395 /* This is faster. */
396 for (_farsetsel (_dos_ds
); --len
>= 0; t
+= 2, buf
++)
397 _farnspokeb (t
, *buf
);
399 if (screen_virtual_segment
)
400 dosv_refresh_virtual_screen (t0
, l0
);
405 /* Flash the screen as a substitute for BEEPs. */
409 do_visible_bell (xorattr
)
410 unsigned char xorattr
;
415 movl _ScreenPrimary,%%eax
422 xorb %%al,%%gs:(%%ebx)
438 : "m" (xorattr
), "g" (screen_size
)
439 : "%eax", "%ebx", /* "%gs",*/ "%ecx", "%edx");
443 ScreenVisualBell (void)
445 /* This creates an xor-mask that will swap the default fore- and
446 background colors. */
447 do_visible_bell (((the_only_x_display
.foreground_pixel
448 ^ the_only_x_display
.background_pixel
)
453 #ifndef HAVE_X_WINDOWS
455 static int blink_bit
= -1; /* the state of the blink bit at startup */
457 /* Enable bright background colors. */
463 /* Remember the original state of the blink/bright-background bit.
464 It is stored at 0040:0065h in the BIOS data area. */
466 blink_bit
= (_farpeekb (_dos_ds
, 0x465) & 0x20) == 0x20;
470 int86 (0x10, ®s
, ®s
);
473 /* Disable bright background colors (and enable blinking) if we found
474 the video system in that state at startup. */
476 maybe_enable_blinking (void)
484 int86 (0x10, ®s
, ®s
);
488 /* Set the screen dimensions so that it can show no less than
489 ROWS x COLS frame. */
492 dos_set_window_size (rows
, cols
)
496 Lisp_Object video_mode
;
497 int video_mode_value
;
500 int current_rows
= ScreenRows (), current_cols
= ScreenCols ();
502 if (*rows
== current_rows
&& *cols
== current_cols
)
505 /* Do we have a VGA? */
507 int86 (0x10, ®s
, ®s
);
508 if (regs
.h
.al
== 0x1a && regs
.h
.bl
> 5 && regs
.h
.bl
< 13)
513 /* If the user specified a special video mode for these dimensions,
515 sprintf (video_name
, "screen-dimensions-%dx%d", *rows
, *cols
);
516 video_mode
= XSYMBOL (Fintern_soft (build_string (video_name
),
519 if (INTEGERP (video_mode
)
520 && (video_mode_value
= XINT (video_mode
)) > 0)
522 regs
.x
.ax
= video_mode_value
;
523 int86 (0x10, ®s
, ®s
);
527 /* Must hardware-reset the mouse, or else it won't update
528 its notion of screen dimensions for some non-standard
529 video modes. This is *painfully* slow... */
531 int86 (0x33, ®s
, ®s
);
535 /* Find one of the dimensions supported by standard EGA/VGA
536 which gives us at least the required dimensions. */
545 } std_dimension
[] = {
555 while (i
< sizeof (std_dimension
) / sizeof (std_dimension
[0]))
557 if (std_dimension
[i
].need_vga
<= have_vga
558 && std_dimension
[i
].rows
>= *rows
)
560 if (std_dimension
[i
].rows
!= current_rows
561 || *cols
!= current_cols
)
562 _set_screen_lines (std_dimension
[i
].rows
);
569 #else /* not __DJGPP__ > 1 */
571 else if (*rows
<= 25)
573 if (current_rows
!= 25 || current_cols
!= 80)
576 int86 (0x10, ®s
, ®s
);
579 int86 (0x10, ®s
, ®s
);
582 int86 (0x10, ®s
, ®s
);
584 int86 (0x10, ®s
, ®s
);
587 else if (*rows
<= 50)
588 if (have_vga
&& (current_rows
!= 50 || current_cols
!= 80)
589 || *rows
<= 43 && (current_rows
!= 43 || current_cols
!= 80))
592 int86 (0x10, ®s
, ®s
);
595 int86 (0x10, ®s
, ®s
);
598 int86 (0x10, ®s
, ®s
);
601 int86 (0x10, ®s
, ®s
);
603 #endif /* not __DJGPP__ > 1 */
611 /* Tell the caller what dimensions have been REALLY set. */
612 *rows
= ScreenRows ();
613 *cols
= ScreenCols ();
616 /* If the dimensions changed, the mouse highlight info is invalid. */
617 if (current_rows
!= *rows
|| current_cols
!= *cols
)
619 struct frame
*f
= SELECTED_FRAME();
620 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
621 Lisp_Object window
= dpyinfo
->mouse_face_window
;
623 if (! NILP (window
) && XFRAME (XWINDOW (window
)->frame
) == f
)
625 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
626 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
627 dpyinfo
->mouse_face_window
= Qnil
;
632 /* Enable bright background colors. */
635 /* FIXME: I'm not sure the above will run at all on DOS/V. But let's
636 be defensive anyway. */
637 if (screen_virtual_segment
)
638 dosv_refresh_virtual_screen (0, *cols
* *rows
);
641 /* If we write a character in the position where the mouse is,
642 the mouse cursor may need to be refreshed. */
652 mouse_get_xy (&x
, &y
);
653 if (y
!= new_pos_Y
|| x
< new_pos_X
)
669 union REGS inregs
, outregs
;
672 intdos (&inregs
, &outregs
);
676 /* Given a face id FACE, extract the face parameters to be used for
677 display until the face changes. The face parameters (actually, its
678 color) are used to construct the video attribute byte for each
679 glyph during the construction of the buffer that is then blitted to
682 IT_set_face (int face
)
684 struct frame
*sf
= SELECTED_FRAME();
685 struct face
*fp
= FACE_FROM_ID (sf
, face
);
686 unsigned long fg
, bg
;
690 fp
= FACE_FROM_ID (sf
, DEFAULT_FACE_ID
);
691 /* The default face for the frame should always be realized and
700 /* Don't use invalid colors. In particular, FACE_TTY_DEFAULT_*
701 colors mean use the colors of the default face, except that if
702 highlight is on, invert the foreground and the background. Note
703 that we assume all 16 colors to be available for the background,
704 since Emacs switches on this mode (and loses the blinking
705 attribute) at startup. */
706 if (fg
== FACE_TTY_DEFAULT_COLOR
|| fg
== FACE_TTY_DEFAULT_FG_COLOR
)
707 fg
= FRAME_FOREGROUND_PIXEL (sf
);
708 else if (fg
== FACE_TTY_DEFAULT_BG_COLOR
)
709 fg
= FRAME_BACKGROUND_PIXEL (sf
);
710 if (bg
== FACE_TTY_DEFAULT_COLOR
|| bg
== FACE_TTY_DEFAULT_BG_COLOR
)
711 bg
= FRAME_BACKGROUND_PIXEL (sf
);
712 else if (bg
== FACE_TTY_DEFAULT_FG_COLOR
)
713 bg
= FRAME_FOREGROUND_PIXEL (sf
);
715 /* Make sure highlighted lines really stand out, come what may. */
716 if ((highlight
|| fp
->tty_reverse_p
)
717 && (fg
== FRAME_FOREGROUND_PIXEL (sf
)
718 && bg
== FRAME_BACKGROUND_PIXEL (sf
)))
720 unsigned long tem
= fg
;
726 fprintf (termscript
, "<FACE %d%s: %d/%d[FG:%d/BG:%d]>", face
,
727 highlight
? "H" : "", fp
->foreground
, fp
->background
, fg
, bg
);
728 if (fg
>= 0 && fg
< 16)
730 ScreenAttrib
&= 0xf0;
733 if (bg
>= 0 && bg
< 16)
735 ScreenAttrib
&= 0x0f;
736 ScreenAttrib
|= ((bg
& 0x0f) << 4);
740 Lisp_Object Vdos_unsupported_char_glyph
;
743 IT_write_glyphs (struct glyph
*str
, int str_len
)
745 unsigned char *screen_buf
, *screen_bp
, *screen_buf_end
, *bp
;
746 int unsupported_face
= FAST_GLYPH_FACE (Vdos_unsupported_char_glyph
);
747 unsigned unsupported_char
= FAST_GLYPH_CHAR (Vdos_unsupported_char_glyph
);
748 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
749 register int sl
= str_len
;
750 register int tlen
= GLYPH_TABLE_LENGTH
;
751 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
753 struct coding_system
*coding
= (CODING_REQUIRE_ENCODING (&terminal_coding
)
755 : &safe_terminal_coding
);
758 /* Do we need to consider conversion of unibyte characters to
760 int convert_unibyte_characters
761 = (NILP (current_buffer
->enable_multibyte_characters
)
762 && unibyte_display_via_language_environment
);
764 if (str_len
<= 0) return;
766 screen_buf
= screen_bp
= alloca (str_len
* 2);
767 screen_buf_end
= screen_buf
+ str_len
* 2;
768 sf
= SELECTED_FRAME();
770 /* Since faces get cached and uncached behind our back, we can't
771 rely on their indices in the cache being consistent across
772 invocations. So always reset the screen face to the default
773 face of the frame, before writing glyphs, and let the glyphs
774 set the right face if it's different from the default. */
775 IT_set_face (DEFAULT_FACE_ID
);
777 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
779 terminal_coding
.mode
&= ~CODING_MODE_LAST_BLOCK
;
782 int cf
, chlen
, enclen
;
783 unsigned char workbuf
[MAX_MULTIBYTE_LENGTH
], *buf
;
786 /* Glyphs with GLYPH_MASK_PADDING bit set are actually there
787 only for the redisplay code to know how many columns does
788 this character occupy on the screen. Skip padding glyphs. */
789 if (CHAR_GLYPH_PADDING_P (*str
))
796 register GLYPH g
= GLYPH_FROM_CHAR_GLYPH (*str
);
797 int glyph_not_in_table
= 0;
799 if (g
< 0 || g
>= tlen
)
801 /* This glyph doesn't have an entry in Vglyph_table. */
803 glyph_not_in_table
= 1;
807 /* This glyph has an entry in Vglyph_table, so process
808 any aliases before testing for simpleness. */
809 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
810 ch
= FAST_GLYPH_CHAR (g
);
813 /* Convert the character code to multibyte, if they
814 requested display via language environment. We only want
815 to convert unibyte characters to multibyte in unibyte
816 buffers! Otherwise, the 8-bit value in CH came from the
817 display table set up to display foreign characters. */
818 if (SINGLE_BYTE_CHAR_P (ch
) && convert_unibyte_characters
820 || (ch
>= 0200 && !NILP (Vnonascii_translation_table
))))
821 ch
= unibyte_char_to_multibyte (ch
);
823 /* Invalid characters are displayed with a special glyph. */
824 if (! CHAR_VALID_P (ch
, 0))
826 g
= !NILP (Vdos_unsupported_char_glyph
)
827 ? Vdos_unsupported_char_glyph
828 : MAKE_GLYPH (sf
, '\177', GLYPH_FACE (sf
, g
));
829 ch
= FAST_GLYPH_CHAR (g
);
832 /* If the face of this glyph is different from the current
833 screen face, update the screen attribute byte. */
834 cf
= FAST_GLYPH_FACE (g
);
835 if (cf
!= screen_face
)
836 IT_set_face (cf
); /* handles invalid faces gracefully */
838 if (glyph_not_in_table
|| GLYPH_SIMPLE_P (tbase
, tlen
, g
))
840 /* We generate the multi-byte form of CH in WORKBUF. */
841 chlen
= CHAR_STRING (ch
, workbuf
);
846 /* We have a string in Vglyph_table. */
847 chlen
= GLYPH_LENGTH (tbase
, g
);
848 buf
= GLYPH_STRING (tbase
, g
);
851 /* If the character is not multibyte, don't bother converting it. */
854 *conversion_buffer
= (unsigned char)ch
;
860 encode_coding (coding
, buf
, conversion_buffer
, chlen
,
861 conversion_buffer_size
);
862 chlen
-= coding
->consumed
;
863 enclen
= coding
->produced
;
865 /* Replace glyph codes that cannot be converted by
866 terminal_coding with Vdos_unsupported_char_glyph. */
867 if (*conversion_buffer
== '?')
869 char *cbp
= conversion_buffer
;
871 while (cbp
< conversion_buffer
+ enclen
&& *cbp
== '?')
872 *cbp
++ = unsupported_char
;
873 if (unsupported_face
!= screen_face
)
874 IT_set_face (unsupported_face
);
878 if (enclen
+ chlen
> screen_buf_end
- screen_bp
)
880 /* The allocated buffer for screen writes is too small.
881 Flush it and loop again without incrementing STR, so
882 that the next loop will begin with the same glyph. */
883 int nbytes
= screen_bp
- screen_buf
;
886 dosmemput (screen_buf
, nbytes
, (int)ScreenPrimary
+ offset
);
887 if (screen_virtual_segment
)
888 dosv_refresh_virtual_screen (offset
, nbytes
/ 2);
889 new_pos_X
+= nbytes
/ 2;
892 /* Prepare to reuse the same buffer again. */
893 screen_bp
= screen_buf
;
897 /* There's enough place in the allocated buffer to add
898 the encoding of this glyph. */
900 /* First, copy the encoded bytes. */
901 for (bp
= conversion_buffer
; enclen
--; bp
++)
903 *screen_bp
++ = (unsigned char)*bp
;
904 *screen_bp
++ = ScreenAttrib
;
906 fputc (*bp
, termscript
);
909 /* Now copy the bytes not consumed by the encoding. */
912 buf
+= coding
->consumed
;
916 fputc (*buf
, termscript
);
917 *screen_bp
++ = (unsigned char)*buf
++;
918 *screen_bp
++ = ScreenAttrib
;
922 /* Update STR and its remaining length. */
929 /* Dump whatever is left in the screen buffer. */
931 dosmemput (screen_buf
, screen_bp
- screen_buf
, (int)ScreenPrimary
+ offset
);
932 if (screen_virtual_segment
)
933 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
934 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
936 /* We may have to output some codes to terminate the writing. */
937 if (CODING_REQUIRE_FLUSHING (coding
))
939 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
940 encode_coding (coding
, "", conversion_buffer
, 0, conversion_buffer_size
);
941 if (coding
->produced
> 0)
943 for (screen_bp
= screen_buf
, bp
= conversion_buffer
;
944 coding
->produced
--; bp
++)
946 *screen_bp
++ = (unsigned char)*bp
;
947 *screen_bp
++ = ScreenAttrib
;
949 fputc (*bp
, termscript
);
951 offset
+= screen_bp
- screen_buf
;
953 dosmemput (screen_buf
, screen_bp
- screen_buf
,
954 (int)ScreenPrimary
+ offset
);
955 if (screen_virtual_segment
)
956 dosv_refresh_virtual_screen (offset
, (screen_bp
- screen_buf
) / 2);
957 new_pos_X
+= (screen_bp
- screen_buf
) / 2;
962 /************************************************************************
963 Mouse Highlight (and friends..)
964 ************************************************************************/
966 /* This is used for debugging, to turn off note_mouse_highlight. */
967 int disable_mouse_highlight
;
969 /* If a string, dos_rawgetc generates an event to display that string.
970 (The display is done in keyboard.c:read_char.) */
971 static Lisp_Object help_echo
;
972 static Lisp_Object previous_help_echo
; /* a helper temporary variable */
974 static int mouse_preempted
= 0; /* non-zero when XMenu gobbles mouse events */
976 /* Set the mouse pointer shape according to whether it is in the
977 area where the mouse highlight is in effect. */
979 IT_set_mouse_pointer (int mode
)
981 /* A no-op for now. DOS text-mode mouse pointer doesn't offer too
982 many possibilities to change its shape, and the available
983 functionality pretty much sucks (e.g., almost every reasonable
984 shape will conceal the character it is on). Since the color of
985 the pointer changes in the highlighted area, it is not clear to
986 me whether anything else is required, anyway. */
989 /* Display the active region described by mouse_face_*
990 in its mouse-face if HL > 0, in its normal face if HL = 0. */
992 show_mouse_face (struct display_info
*dpyinfo
, int hl
)
994 struct window
*w
= XWINDOW (dpyinfo
->mouse_face_window
);
995 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
1000 /* If window is in the process of being destroyed, don't bother
1002 if (w
->current_matrix
== NULL
)
1003 goto set_cursor_shape
;
1005 /* Recognize when we are called to operate on rows that don't exist
1006 anymore. This can happen when a window is split. */
1007 if (dpyinfo
->mouse_face_end_row
>= w
->current_matrix
->nrows
)
1008 goto set_cursor_shape
;
1010 /* There's no sense to do anything if the mouse face isn't realized. */
1013 fp
= FACE_FROM_ID (SELECTED_FRAME(), dpyinfo
->mouse_face_face_id
);
1015 goto set_cursor_shape
;
1018 /* Note that mouse_face_beg_row etc. are window relative. */
1019 for (i
= dpyinfo
->mouse_face_beg_row
;
1020 i
<= dpyinfo
->mouse_face_end_row
;
1023 int start_hpos
, end_hpos
;
1024 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, i
);
1026 /* Don't do anything if row doesn't have valid contents. */
1027 if (!row
->enabled_p
)
1030 /* For all but the first row, the highlight starts at column 0. */
1031 if (i
== dpyinfo
->mouse_face_beg_row
)
1032 start_hpos
= dpyinfo
->mouse_face_beg_col
;
1036 if (i
== dpyinfo
->mouse_face_end_row
)
1037 end_hpos
= dpyinfo
->mouse_face_end_col
;
1039 end_hpos
= row
->used
[TEXT_AREA
];
1041 if (end_hpos
<= start_hpos
)
1045 int vpos
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1046 int kstart
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1047 int nglyphs
= end_hpos
- start_hpos
;
1048 int offset
= ScreenPrimary
+ 2*(vpos
*screen_size_X
+ kstart
) + 1;
1049 int start_offset
= offset
;
1052 fprintf (termscript
, "\n<MH+ %d-%d:%d>",
1053 kstart
, kstart
+ nglyphs
- 1, vpos
);
1056 IT_set_face (dpyinfo
->mouse_face_face_id
);
1057 /* Since we are going to change only the _colors_ of the
1058 displayed text, there's no need to go through all the
1059 pain of generating and encoding the text from the glyphs.
1060 Instead, we simply poke the attribute byte of each
1061 affected position in video memory with the colors
1062 computed by IT_set_face! */
1063 _farsetsel (_dos_ds
);
1066 _farnspokeb (offset
, ScreenAttrib
);
1069 if (screen_virtual_segment
)
1070 dosv_refresh_virtual_screen (start_offset
, end_hpos
- start_hpos
);
1075 /* We are removing a previously-drawn mouse highlight. The
1076 safest way to do so is to redraw the glyphs anew, since
1077 all kinds of faces and display tables could have changed
1079 int nglyphs
= end_hpos
- start_hpos
;
1080 int save_x
= new_pos_X
, save_y
= new_pos_Y
;
1082 if (end_hpos
>= row
->used
[TEXT_AREA
])
1083 nglyphs
= row
->used
[TEXT_AREA
] - start_hpos
;
1085 /* IT_write_glyphs writes at cursor position, so we need to
1086 temporarily move cursor coordinates to the beginning of
1087 the highlight region. */
1088 new_pos_X
= start_hpos
+ WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1089 new_pos_Y
= row
->y
+ WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1092 fprintf (termscript
, "<MH- %d-%d:%d>",
1093 new_pos_X
, new_pos_X
+ nglyphs
- 1, new_pos_Y
);
1094 IT_write_glyphs (row
->glyphs
[TEXT_AREA
] + start_hpos
, nglyphs
);
1096 fputs ("\n", termscript
);
1104 /* Change the mouse pointer shape. */
1105 IT_set_mouse_pointer (hl
);
1108 /* Clear out the mouse-highlighted active region.
1109 Redraw it un-highlighted first. */
1111 clear_mouse_face (struct display_info
*dpyinfo
)
1113 if (! NILP (dpyinfo
->mouse_face_window
))
1114 show_mouse_face (dpyinfo
, 0);
1116 dpyinfo
->mouse_face_beg_row
= dpyinfo
->mouse_face_beg_col
= -1;
1117 dpyinfo
->mouse_face_end_row
= dpyinfo
->mouse_face_end_col
= -1;
1118 dpyinfo
->mouse_face_window
= Qnil
;
1121 /* Find the glyph matrix position of buffer position POS in window W.
1122 *HPOS and *VPOS are set to the positions found. W's current glyphs
1123 must be up to date. If POS is above window start return (0, 0).
1124 If POS is after end of W, return end of last line in W. */
1126 fast_find_position (struct window
*w
, int pos
, int *hpos
, int *vpos
)
1130 int maybe_next_line_p
= 0;
1131 int line_start_position
;
1132 int yb
= window_text_bottom_y (w
);
1133 struct glyph_row
*row
= MATRIX_ROW (w
->current_matrix
, 0);
1134 struct glyph_row
*best_row
= row
;
1138 if (row
->used
[TEXT_AREA
])
1139 line_start_position
= row
->glyphs
[TEXT_AREA
]->charpos
;
1141 line_start_position
= 0;
1143 if (line_start_position
> pos
)
1145 /* If the position sought is the end of the buffer,
1146 don't include the blank lines at the bottom of the window. */
1147 else if (line_start_position
== pos
1148 && pos
== BUF_ZV (XBUFFER (w
->buffer
)))
1150 maybe_next_line_p
= 1;
1153 else if (line_start_position
> 0)
1159 /* Find the right column within BEST_ROW. */
1162 for (i
= 0; i
< row
->used
[TEXT_AREA
]; i
++)
1164 struct glyph
*glyph
= row
->glyphs
[TEXT_AREA
] + i
;
1167 charpos
= glyph
->charpos
;
1174 else if (charpos
> pos
)
1176 else if (charpos
> 0)
1180 /* If we're looking for the end of the buffer,
1181 and we didn't find it in the line we scanned,
1182 use the start of the following line. */
1183 if (maybe_next_line_p
)
1190 *hpos
= lastcol
+ 1;
1194 /* Take proper action when mouse has moved to the mode or top line of
1195 window W, x-position X. MODE_LINE_P non-zero means mouse is on the
1196 mode line. X is relative to the start of the text display area of
1197 W, so the width of bitmap areas and scroll bars must be subtracted
1198 to get a position relative to the start of the mode line. */
1200 IT_note_mode_line_highlight (struct window
*w
, int x
, int mode_line_p
)
1202 struct frame
*f
= XFRAME (w
->frame
);
1203 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1204 struct glyph_row
*row
;
1207 row
= MATRIX_MODE_LINE_ROW (w
->current_matrix
);
1209 row
= MATRIX_HEADER_LINE_ROW (w
->current_matrix
);
1213 extern Lisp_Object Qhelp_echo
;
1214 struct glyph
*glyph
, *end
;
1215 Lisp_Object help
, map
;
1217 /* Find the glyph under X. */
1218 glyph
= row
->glyphs
[TEXT_AREA
]
1219 + x
- FRAME_LEFT_SCROLL_BAR_WIDTH (f
) * CANON_X_UNIT (f
);
1220 end
= glyph
+ row
->used
[TEXT_AREA
];
1222 && STRINGP (glyph
->object
)
1223 && XSTRING (glyph
->object
)->intervals
1224 && glyph
->charpos
>= 0
1225 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1227 /* If we're on a string with `help-echo' text property,
1228 arrange for the help to be displayed. This is done by
1229 setting the global variable help_echo to the help string. */
1230 help
= Fget_text_property (make_number (glyph
->charpos
),
1231 Qhelp_echo
, glyph
->object
);
1238 /* Take proper action when the mouse has moved to position X, Y on
1239 frame F as regards highlighting characters that have mouse-face
1240 properties. Also de-highlighting chars where the mouse was before.
1241 X and Y can be negative or out of range. */
1243 IT_note_mouse_highlight (struct frame
*f
, int x
, int y
)
1245 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1250 /* When a menu is active, don't highlight because this looks odd. */
1251 if (mouse_preempted
)
1254 if (disable_mouse_highlight
)
1257 dpyinfo
->mouse_face_mouse_x
= x
;
1258 dpyinfo
->mouse_face_mouse_y
= y
;
1259 dpyinfo
->mouse_face_mouse_frame
= f
;
1261 if (dpyinfo
->mouse_face_defer
)
1266 dpyinfo
->mouse_face_deferred_gc
= 1;
1270 /* Which window is that in? */
1271 window
= window_from_coordinates (f
, x
, y
, &portion
, 0);
1273 /* If we were displaying active text in another window, clear that. */
1274 if (! EQ (window
, dpyinfo
->mouse_face_window
))
1275 clear_mouse_face (dpyinfo
);
1277 /* Not on a window -> return. */
1278 if (!WINDOWP (window
))
1281 /* Convert to window-relative coordinates. */
1282 w
= XWINDOW (window
);
1283 x
-= WINDOW_DISPLAY_LEFT_EDGE_PIXEL_X (w
);
1284 y
-= WINDOW_DISPLAY_TOP_EDGE_PIXEL_Y (w
);
1286 if (portion
== 1 || portion
== 3)
1288 /* Mouse is on the mode or top line. */
1289 IT_note_mode_line_highlight (w
, x
, portion
== 1);
1293 IT_set_mouse_pointer (0);
1295 /* Are we in a window whose display is up to date?
1296 And verify the buffer's text has not changed. */
1297 if (/* Within text portion of the window. */
1299 && EQ (w
->window_end_valid
, w
->buffer
)
1300 && XFASTINT (w
->last_modified
) == BUF_MODIFF (XBUFFER (w
->buffer
))
1301 && (XFASTINT (w
->last_overlay_modified
)
1302 == BUF_OVERLAY_MODIFF (XBUFFER (w
->buffer
))))
1305 struct glyph_row
*row
;
1306 struct glyph
*glyph
;
1308 /* Find the glyph under X/Y. */
1310 if (y
< w
->current_matrix
->nrows
)
1312 row
= MATRIX_ROW (w
->current_matrix
, y
);
1314 && row
->displays_text_p
1315 && x
< window_box_width (w
, TEXT_AREA
))
1317 glyph
= row
->glyphs
[TEXT_AREA
];
1318 if (x
>= row
->used
[TEXT_AREA
])
1323 if (!BUFFERP (glyph
->object
))
1329 /* Clear mouse face if X/Y not over text. */
1332 clear_mouse_face (dpyinfo
);
1336 if (!BUFFERP (glyph
->object
))
1338 pos
= glyph
->charpos
;
1340 /* Check for mouse-face and help-echo. */
1342 extern Lisp_Object Qmouse_face
;
1343 Lisp_Object mouse_face
, overlay
, position
;
1344 Lisp_Object
*overlay_vec
;
1346 struct buffer
*obuf
;
1349 /* If we get an out-of-range value, return now; avoid an error. */
1350 if (pos
> BUF_Z (XBUFFER (w
->buffer
)))
1353 /* Make the window's buffer temporarily current for
1354 overlays_at and compute_char_face. */
1355 obuf
= current_buffer
;
1356 current_buffer
= XBUFFER (w
->buffer
);
1362 /* Is this char mouse-active or does it have help-echo? */
1363 XSETINT (position
, pos
);
1365 /* Put all the overlays we want in a vector in overlay_vec.
1366 Store the length in len. If there are more than 10, make
1367 enough space for all, and try again. */
1369 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1370 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
);
1371 if (noverlays
> len
)
1374 overlay_vec
= (Lisp_Object
*) alloca (len
* sizeof (Lisp_Object
));
1375 noverlays
= overlays_at (pos
, 0, &overlay_vec
, &len
, NULL
, NULL
);
1378 noverlays
= sort_overlays (overlay_vec
, noverlays
, w
);
1380 /* Check mouse-face highlighting. */
1381 if (! (EQ (window
, dpyinfo
->mouse_face_window
)
1382 && y
>= dpyinfo
->mouse_face_beg_row
1383 && y
<= dpyinfo
->mouse_face_end_row
1384 && (y
> dpyinfo
->mouse_face_beg_row
1385 || x
>= dpyinfo
->mouse_face_beg_col
)
1386 && (y
< dpyinfo
->mouse_face_end_row
1387 || x
< dpyinfo
->mouse_face_end_col
1388 || dpyinfo
->mouse_face_past_end
)))
1390 /* Clear the display of the old active region, if any. */
1391 clear_mouse_face (dpyinfo
);
1393 /* Find highest priority overlay that has a mouse-face prop. */
1395 for (i
= 0; i
< noverlays
; i
++)
1397 mouse_face
= Foverlay_get (overlay_vec
[i
], Qmouse_face
);
1398 if (!NILP (mouse_face
))
1400 overlay
= overlay_vec
[i
];
1405 /* If no overlay applies, get a text property. */
1407 mouse_face
= Fget_text_property (position
, Qmouse_face
,
1410 /* Handle the overlay case. */
1411 if (! NILP (overlay
))
1413 /* Find the range of text around this char that
1414 should be active. */
1415 Lisp_Object before
, after
;
1418 before
= Foverlay_start (overlay
);
1419 after
= Foverlay_end (overlay
);
1420 /* Record this as the current active region. */
1421 fast_find_position (w
, XFASTINT (before
),
1422 &dpyinfo
->mouse_face_beg_col
,
1423 &dpyinfo
->mouse_face_beg_row
);
1424 dpyinfo
->mouse_face_past_end
1425 = !fast_find_position (w
, XFASTINT (after
),
1426 &dpyinfo
->mouse_face_end_col
,
1427 &dpyinfo
->mouse_face_end_row
);
1428 dpyinfo
->mouse_face_window
= window
;
1429 dpyinfo
->mouse_face_face_id
1430 = face_at_buffer_position (w
, pos
, 0, 0,
1431 &ignore
, pos
+ 1, 1);
1433 /* Display it as active. */
1434 show_mouse_face (dpyinfo
, 1);
1436 /* Handle the text property case. */
1437 else if (! NILP (mouse_face
))
1439 /* Find the range of text around this char that
1440 should be active. */
1441 Lisp_Object before
, after
, beginning
, end
;
1444 beginning
= Fmarker_position (w
->start
);
1445 XSETINT (end
, (BUF_Z (XBUFFER (w
->buffer
))
1446 - XFASTINT (w
->window_end_pos
)));
1448 = Fprevious_single_property_change (make_number (pos
+ 1),
1450 w
->buffer
, beginning
);
1452 = Fnext_single_property_change (position
, Qmouse_face
,
1454 /* Record this as the current active region. */
1455 fast_find_position (w
, XFASTINT (before
),
1456 &dpyinfo
->mouse_face_beg_col
,
1457 &dpyinfo
->mouse_face_beg_row
);
1458 dpyinfo
->mouse_face_past_end
1459 = !fast_find_position (w
, XFASTINT (after
),
1460 &dpyinfo
->mouse_face_end_col
,
1461 &dpyinfo
->mouse_face_end_row
);
1462 dpyinfo
->mouse_face_window
= window
;
1463 dpyinfo
->mouse_face_face_id
1464 = face_at_buffer_position (w
, pos
, 0, 0,
1465 &ignore
, pos
+ 1, 1);
1467 /* Display it as active. */
1468 show_mouse_face (dpyinfo
, 1);
1472 /* Look for a `help-echo' property. */
1475 extern Lisp_Object Qhelp_echo
;
1477 /* Check overlays first. */
1479 for (i
= 0; i
< noverlays
&& !STRINGP (help
); ++i
)
1480 help
= Foverlay_get (overlay_vec
[i
], Qhelp_echo
);
1482 /* Try text properties. */
1484 && ((STRINGP (glyph
->object
)
1485 && glyph
->charpos
>= 0
1486 && glyph
->charpos
< XSTRING (glyph
->object
)->size
)
1487 || (BUFFERP (glyph
->object
)
1488 && glyph
->charpos
>= BEGV
1489 && glyph
->charpos
< ZV
)))
1490 help
= Fget_text_property (make_number (glyph
->charpos
),
1491 Qhelp_echo
, glyph
->object
);
1499 current_buffer
= obuf
;
1505 IT_clear_end_of_line (int first_unused
)
1509 int offset
= 2 * (new_pos_X
+ screen_size_X
* new_pos_Y
);
1510 extern int fatal_error_in_progress
;
1512 if (new_pos_X
>= first_unused
|| fatal_error_in_progress
)
1516 i
= (j
= first_unused
- new_pos_X
) * 2;
1518 fprintf (termscript
, "<CLR:EOL[%d..%d)>", new_pos_X
, first_unused
);
1519 spaces
= sp
= alloca (i
);
1524 *sp
++ = ScreenAttrib
;
1528 dosmemput (spaces
, i
, (int)ScreenPrimary
+ offset
);
1529 if (screen_virtual_segment
)
1530 dosv_refresh_virtual_screen (offset
, i
/ 2);
1532 /* clear_end_of_line_raw on term.c leaves the cursor at first_unused.
1533 Let's follow their lead, in case someone relies on this. */
1534 new_pos_X
= first_unused
;
1538 IT_clear_screen (void)
1541 fprintf (termscript
, "<CLR:SCR>");
1545 if (screen_virtual_segment
)
1546 dosv_refresh_virtual_screen (0, screen_size
);
1547 new_pos_X
= new_pos_Y
= 0;
1551 IT_clear_to_end (void)
1554 fprintf (termscript
, "<CLR:EOS>");
1556 while (new_pos_Y
< screen_size_Y
) {
1558 IT_clear_end_of_line (screen_size_X
);
1564 IT_cursor_to (int y
, int x
)
1567 fprintf (termscript
, "\n<XY=%dx%d>", x
, y
);
1572 static int cursor_cleared
;
1575 IT_display_cursor (int on
)
1577 if (on
&& cursor_cleared
)
1579 ScreenSetCursor (current_pos_Y
, current_pos_X
);
1582 else if (!on
&& !cursor_cleared
)
1584 ScreenSetCursor (-1, -1);
1589 /* Emacs calls cursor-movement functions a lot when it updates the
1590 display (probably a legacy of old terminals where you cannot
1591 update a screen line without first moving the cursor there).
1592 However, cursor movement is expensive on MSDOS (it calls a slow
1593 BIOS function and requires 2 mode switches), while actual screen
1594 updates access the video memory directly and don't depend on
1595 cursor position. To avoid slowing down the redisplay, we cheat:
1596 all functions that move the cursor only set internal variables
1597 which record the cursor position, whereas the cursor is only
1598 moved to its final position whenever screen update is complete.
1600 `IT_cmgoto' is called from the keyboard reading loop and when the
1601 frame update is complete. This means that we are ready for user
1602 input, so we update the cursor position to show where the point is,
1603 and also make the mouse pointer visible.
1605 Special treatment is required when the cursor is in the echo area,
1606 to put the cursor at the end of the text displayed there. */
1609 IT_cmgoto (FRAME_PTR f
)
1611 /* Only set the cursor to where it should be if the display is
1612 already in sync with the window contents. */
1613 int update_cursor_pos
= 1; /* MODIFF == unchanged_modified; */
1615 /* FIXME: This needs to be rewritten for the new redisplay, or
1618 static int previous_pos_X
= -1;
1620 update_cursor_pos
= 1; /* temporary!!! */
1622 /* If the display is in sync, forget any previous knowledge about
1623 cursor position. This is primarily for unexpected events like
1624 C-g in the minibuffer. */
1625 if (update_cursor_pos
&& previous_pos_X
>= 0)
1626 previous_pos_X
= -1;
1627 /* If we are in the echo area, put the cursor at the
1628 end of the echo area message. */
1629 if (!update_cursor_pos
1630 && XFASTINT (XWINDOW (FRAME_MINIBUF_WINDOW (f
))->top
) <= new_pos_Y
)
1632 int tem_X
= current_pos_X
, dummy
;
1634 if (echo_area_glyphs
)
1636 tem_X
= echo_area_glyphs_length
;
1637 /* Save current cursor position, to be restored after the
1638 echo area message is erased. Only remember one level
1639 of previous cursor position. */
1640 if (previous_pos_X
== -1)
1641 ScreenGetCursor (&dummy
, &previous_pos_X
);
1643 else if (previous_pos_X
>= 0)
1645 /* We wind up here after the echo area message is erased.
1646 Restore the cursor position we remembered above. */
1647 tem_X
= previous_pos_X
;
1648 previous_pos_X
= -1;
1651 if (current_pos_X
!= tem_X
)
1654 update_cursor_pos
= 1;
1659 if (update_cursor_pos
1660 && (current_pos_X
!= new_pos_X
|| current_pos_Y
!= new_pos_Y
))
1662 ScreenSetCursor (current_pos_Y
= new_pos_Y
, current_pos_X
= new_pos_X
);
1664 fprintf (termscript
, "\n<CURSOR:%dx%d>", current_pos_X
, current_pos_Y
);
1667 /* Maybe cursor is invisible, so make it visible. */
1668 IT_display_cursor (1);
1670 /* Mouse pointer should be always visible if we are waiting for
1677 IT_reassert_line_highlight (int new, int vpos
)
1683 IT_change_line_highlight (int new_highlight
, int y
, int vpos
, int first_unused_hpos
)
1685 highlight
= new_highlight
;
1686 IT_cursor_to (vpos
, 0);
1687 IT_clear_end_of_line (first_unused_hpos
);
1691 IT_update_begin (struct frame
*f
)
1693 struct display_info
*display_info
= FRAME_X_DISPLAY_INFO (f
);
1699 if (f
== display_info
->mouse_face_mouse_frame
)
1701 /* Don't do highlighting for mouse motion during the update. */
1702 display_info
->mouse_face_defer
= 1;
1704 /* If F needs to be redrawn, simply forget about any prior mouse
1706 if (FRAME_GARBAGED_P (f
))
1707 display_info
->mouse_face_window
= Qnil
;
1709 /* Can we tell that this update does not affect the window
1710 where the mouse highlight is? If so, no need to turn off.
1711 Likewise, don't do anything if the frame is garbaged;
1712 in that case, the frame's current matrix that we would use
1713 is all wrong, and we will redisplay that line anyway. */
1714 if (!NILP (display_info
->mouse_face_window
)
1715 && WINDOWP (display_info
->mouse_face_window
))
1717 struct window
*w
= XWINDOW (display_info
->mouse_face_window
);
1720 /* If the mouse highlight is in the window that was deleted
1721 (e.g., if it was popped by completion), clear highlight
1723 if (NILP (w
->buffer
))
1724 display_info
->mouse_face_window
= Qnil
;
1727 for (i
= 0; i
< w
->desired_matrix
->nrows
; ++i
)
1728 if (MATRIX_ROW_ENABLED_P (w
->desired_matrix
, i
))
1732 if (NILP (w
->buffer
) || i
< w
->desired_matrix
->nrows
)
1733 clear_mouse_face (display_info
);
1736 else if (!FRAME_LIVE_P (display_info
->mouse_face_mouse_frame
))
1738 /* If the frame with mouse highlight was deleted, invalidate the
1740 display_info
->mouse_face_beg_row
= display_info
->mouse_face_beg_col
= -1;
1741 display_info
->mouse_face_end_row
= display_info
->mouse_face_end_col
= -1;
1742 display_info
->mouse_face_window
= Qnil
;
1743 display_info
->mouse_face_deferred_gc
= 0;
1744 display_info
->mouse_face_mouse_frame
= NULL
;
1751 IT_update_end (struct frame
*f
)
1754 FRAME_X_DISPLAY_INFO (f
)->mouse_face_defer
= 0;
1758 IT_frame_up_to_date (struct frame
*f
)
1760 struct display_info
*dpyinfo
= FRAME_X_DISPLAY_INFO (f
);
1762 if (dpyinfo
->mouse_face_deferred_gc
1763 || f
== dpyinfo
->mouse_face_mouse_frame
)
1766 if (dpyinfo
->mouse_face_mouse_frame
)
1767 IT_note_mouse_highlight (dpyinfo
->mouse_face_mouse_frame
,
1768 dpyinfo
->mouse_face_mouse_x
,
1769 dpyinfo
->mouse_face_mouse_y
);
1770 dpyinfo
->mouse_face_deferred_gc
= 0;
1774 IT_cmgoto (f
); /* position cursor when update is done */
1777 /* Copy LEN glyphs displayed on a single line whose vertical position
1778 is YPOS, beginning at horizontal position XFROM to horizontal
1779 position XTO, by moving blocks in the video memory. Used by
1780 functions that insert and delete glyphs. */
1782 IT_copy_glyphs (int xfrom
, int xto
, size_t len
, int ypos
)
1784 /* The offsets of source and destination relative to the
1785 conventional memorty selector. */
1786 int from
= 2 * (xfrom
+ screen_size_X
* ypos
) + ScreenPrimary
;
1787 int to
= 2 * (xto
+ screen_size_X
* ypos
) + ScreenPrimary
;
1789 if (from
== to
|| len
<= 0)
1792 _farsetsel (_dos_ds
);
1794 /* The source and destination might overlap, so we need to move
1795 glyphs non-destructively. */
1798 for ( ; len
; from
+= 2, to
+= 2, len
--)
1799 _farnspokew (to
, _farnspeekw (from
));
1803 from
+= (len
- 1) * 2;
1804 to
+= (len
- 1) * 2;
1805 for ( ; len
; from
-= 2, to
-= 2, len
--)
1806 _farnspokew (to
, _farnspeekw (from
));
1808 if (screen_virtual_segment
)
1809 dosv_refresh_virtual_screen (ypos
* screen_size_X
* 2, screen_size_X
);
1812 /* Insert and delete glyphs. */
1814 IT_insert_glyphs (start
, len
)
1815 register struct glyph
*start
;
1818 int shift_by_width
= screen_size_X
- (new_pos_X
+ len
);
1820 /* Shift right the glyphs from the nominal cursor position to the
1821 end of this line. */
1822 IT_copy_glyphs (new_pos_X
, new_pos_X
+ len
, shift_by_width
, new_pos_Y
);
1824 /* Now write the glyphs to be inserted. */
1825 IT_write_glyphs (start
, len
);
1829 IT_delete_glyphs (n
)
1835 /* set-window-configuration on window.c needs this. */
1837 x_set_menu_bar_lines (f
, value
, oldval
)
1839 Lisp_Object value
, oldval
;
1841 set_menu_bar_lines (f
, value
, oldval
);
1844 /* This was copied from xfns.c */
1846 Lisp_Object Qbackground_color
;
1847 Lisp_Object Qforeground_color
;
1848 extern Lisp_Object Qtitle
;
1850 /* IT_set_terminal_modes is called when emacs is started,
1851 resumed, and whenever the screen is redrawn! */
1854 IT_set_terminal_modes (void)
1857 fprintf (termscript
, "\n<SET_TERM>");
1860 screen_size_X
= ScreenCols ();
1861 screen_size_Y
= ScreenRows ();
1862 screen_size
= screen_size_X
* screen_size_Y
;
1864 new_pos_X
= new_pos_Y
= 0;
1865 current_pos_X
= current_pos_Y
= -1;
1867 if (term_setup_done
)
1869 term_setup_done
= 1;
1871 startup_screen_size_X
= screen_size_X
;
1872 startup_screen_size_Y
= screen_size_Y
;
1873 startup_screen_attrib
= ScreenAttrib
;
1876 /* Is DOS/V (or any other RSIS software which relocates
1877 the screen) installed? */
1879 unsigned short es_value
;
1882 regs
.h
.ah
= 0xfe; /* get relocated screen address */
1883 if (ScreenPrimary
== 0xb0000UL
|| ScreenPrimary
== 0xb8000UL
)
1884 regs
.x
.es
= (ScreenPrimary
>> 4) & 0xffff;
1885 else if (screen_old_address
) /* already switched to Japanese mode once */
1886 regs
.x
.es
= (screen_old_address
>> 4) & 0xffff;
1888 regs
.x
.es
= ScreenMode () == 7 ? 0xb000 : 0xb800;
1890 es_value
= regs
.x
.es
;
1891 __dpmi_int (0x10, ®s
);
1893 if (regs
.x
.es
!= es_value
)
1895 /* screen_old_address is only set if ScreenPrimary does NOT
1896 already point to the relocated buffer address returned by
1897 the Int 10h/AX=FEh call above. DJGPP v2.02 and later sets
1898 ScreenPrimary to that address at startup under DOS/V. */
1899 if (regs
.x
.es
!= (ScreenPrimary
>> 4) & 0xffff)
1900 screen_old_address
= ScreenPrimary
;
1901 screen_virtual_segment
= regs
.x
.es
;
1902 screen_virtual_offset
= regs
.x
.di
;
1903 ScreenPrimary
= (screen_virtual_segment
<< 4) + screen_virtual_offset
;
1906 #endif /* __DJGPP__ > 1 */
1908 ScreenGetCursor (&startup_pos_Y
, &startup_pos_X
);
1909 ScreenRetrieve (startup_screen_buffer
= xmalloc (screen_size
* 2));
1912 fprintf (termscript
, "<SCREEN SAVED (dimensions=%dx%d)>\n",
1913 screen_size_X
, screen_size_Y
);
1918 /* IT_reset_terminal_modes is called when emacs is
1919 suspended or killed. */
1922 IT_reset_terminal_modes (void)
1924 int display_row_start
= (int) ScreenPrimary
;
1925 int saved_row_len
= startup_screen_size_X
* 2;
1926 int update_row_len
= ScreenCols () * 2;
1927 int current_rows
= ScreenRows ();
1928 int to_next_row
= update_row_len
;
1929 unsigned char *saved_row
= startup_screen_buffer
;
1930 int cursor_pos_X
= ScreenCols () - 1;
1931 int cursor_pos_Y
= ScreenRows () - 1;
1934 fprintf (termscript
, "\n<RESET_TERM>");
1938 if (!term_setup_done
)
1943 /* Leave the video system in the same state as we found it,
1944 as far as the blink/bright-background bit is concerned. */
1945 maybe_enable_blinking ();
1947 /* We have a situation here.
1948 We cannot just do ScreenUpdate(startup_screen_buffer) because
1949 the luser could have changed screen dimensions inside Emacs
1950 and failed (or didn't want) to restore them before killing
1951 Emacs. ScreenUpdate() uses the *current* screen dimensions and
1952 thus will happily use memory outside what was allocated for
1953 `startup_screen_buffer'.
1954 Thus we only restore as much as the current screen dimensions
1955 can hold, and clear the rest (if the saved screen is smaller than
1956 the current) with the color attribute saved at startup. The cursor
1957 is also restored within the visible dimensions. */
1959 ScreenAttrib
= startup_screen_attrib
;
1961 /* Don't restore the screen if we are exiting less than 2 seconds
1962 after startup: we might be crashing, and the screen might show
1963 some vital clues to what's wrong. */
1964 if (clock () - startup_time
>= 2*CLOCKS_PER_SEC
)
1967 if (screen_virtual_segment
)
1968 dosv_refresh_virtual_screen (0, screen_size
);
1970 if (update_row_len
> saved_row_len
)
1971 update_row_len
= saved_row_len
;
1972 if (current_rows
> startup_screen_size_Y
)
1973 current_rows
= startup_screen_size_Y
;
1976 fprintf (termscript
, "<SCREEN RESTORED (dimensions=%dx%d)>\n",
1977 update_row_len
/ 2, current_rows
);
1979 while (current_rows
--)
1981 dosmemput (saved_row
, update_row_len
, display_row_start
);
1982 if (screen_virtual_segment
)
1983 dosv_refresh_virtual_screen (display_row_start
- ScreenPrimary
,
1984 update_row_len
/ 2);
1985 saved_row
+= saved_row_len
;
1986 display_row_start
+= to_next_row
;
1989 if (startup_pos_X
< cursor_pos_X
)
1990 cursor_pos_X
= startup_pos_X
;
1991 if (startup_pos_Y
< cursor_pos_Y
)
1992 cursor_pos_Y
= startup_pos_Y
;
1994 ScreenSetCursor (cursor_pos_Y
, cursor_pos_X
);
1995 xfree (startup_screen_buffer
);
1997 term_setup_done
= 0;
2001 IT_set_terminal_window (int foo
)
2005 /* Remember the screen colors of the curent frame, to serve as the
2006 default colors for newly-created frames. */
2008 static int initial_screen_colors
[2];
2010 DEFUN ("msdos-remember-default-colors", Fmsdos_remember_default_colors
,
2011 Smsdos_remember_default_colors
, 1, 1, 0,
2012 "Remember the screen colors of the current frame.")
2019 CHECK_FRAME (frame
, 0);
2021 reverse
= EQ (Fcdr (Fassq (intern ("reverse"), f
->param_alist
)), Qt
);
2023 initial_screen_colors
[0]
2024 = reverse
? FRAME_BACKGROUND_PIXEL (f
) : FRAME_FOREGROUND_PIXEL (f
);
2025 initial_screen_colors
[1]
2026 = reverse
? FRAME_FOREGROUND_PIXEL (f
) : FRAME_BACKGROUND_PIXEL (f
);
2030 IT_set_frame_parameters (f
, alist
)
2035 int length
= XINT (Flength (alist
));
2038 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2040 = (Lisp_Object
*) alloca (length
* sizeof (Lisp_Object
));
2041 Lisp_Object qreverse
= intern ("reverse");
2042 /* Do we have to reverse the foreground and background colors? */
2043 int reverse
= EQ (Fcdr (Fassq (qreverse
, f
->param_alist
)), Qt
);
2044 int was_reverse
= reverse
;
2045 int redraw
= 0, fg_set
= 0, bg_set
= 0;
2046 unsigned long orig_fg
;
2047 unsigned long orig_bg
;
2049 /* If we are creating a new frame, begin with the original screen colors
2050 used for the initial frame. */
2051 if (alist
== Vdefault_frame_alist
2052 && initial_screen_colors
[0] != -1 && initial_screen_colors
[1] != -1)
2054 FRAME_FOREGROUND_PIXEL (f
) = initial_screen_colors
[0];
2055 FRAME_BACKGROUND_PIXEL (f
) = initial_screen_colors
[1];
2057 orig_fg
= FRAME_FOREGROUND_PIXEL (f
);
2058 orig_bg
= FRAME_BACKGROUND_PIXEL (f
);
2060 /* Extract parm names and values into those vectors. */
2062 for (tail
= alist
; CONSP (tail
); tail
= Fcdr (tail
))
2067 parms
[i
] = Fcar (elt
);
2068 CHECK_SYMBOL (parms
[i
], 1);
2069 values
[i
] = Fcdr (elt
);
2075 for (i
= 0; i
< j
; i
++)
2077 Lisp_Object prop
= parms
[i
];
2078 Lisp_Object val
= values
[i
];
2080 if (EQ (prop
, qreverse
))
2081 reverse
= EQ (val
, Qt
);
2084 if (termscript
&& reverse
&& !was_reverse
)
2085 fprintf (termscript
, "<INVERSE-VIDEO>\n");
2087 /* Now process the alist elements in reverse of specified order. */
2088 for (i
--; i
>= 0; i
--)
2090 Lisp_Object prop
= parms
[i
];
2091 Lisp_Object val
= values
[i
];
2093 if (EQ (prop
, Qforeground_color
))
2095 unsigned long new_color
= load_color (f
, NULL
, val
, reverse
2096 ? LFACE_BACKGROUND_INDEX
2097 : LFACE_FOREGROUND_INDEX
);
2098 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2099 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2100 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2103 /* FIXME: should the fore-/background of the default
2104 face change here as well? */
2105 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2107 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2111 fprintf (termscript
, "<FGCOLOR %lu>\n", new_color
);
2114 else if (EQ (prop
, Qbackground_color
))
2116 unsigned long new_color
= load_color (f
, NULL
, val
, reverse
2117 ? LFACE_FOREGROUND_INDEX
2118 : LFACE_BACKGROUND_INDEX
);
2119 if (new_color
!= FACE_TTY_DEFAULT_COLOR
2120 && new_color
!= FACE_TTY_DEFAULT_FG_COLOR
2121 && new_color
!= FACE_TTY_DEFAULT_BG_COLOR
)
2124 FRAME_FOREGROUND_PIXEL (f
) = new_color
;
2126 FRAME_BACKGROUND_PIXEL (f
) = new_color
;
2130 fprintf (termscript
, "<BGCOLOR %lu>\n", new_color
);
2133 else if (EQ (prop
, Qtitle
))
2135 x_set_title (f
, val
);
2137 fprintf (termscript
, "<TITLE: %s>\n", XSTRING (val
)->data
);
2139 store_frame_param (f
, prop
, val
);
2142 /* If they specified "reverse", but not the colors, we need to swap
2143 the current frame colors. */
2144 if (reverse
&& !was_reverse
)
2148 FRAME_BACKGROUND_PIXEL (f
) = orig_fg
;
2153 FRAME_FOREGROUND_PIXEL (f
) = orig_bg
;
2160 face_change_count
++; /* forces xdisp.c to recompute basic faces */
2161 if (f
== SELECTED_FRAME())
2166 extern void init_frame_faces (FRAME_PTR
);
2168 #endif /* !HAVE_X_WINDOWS */
2171 /* Do we need the internal terminal? */
2174 internal_terminal_init ()
2176 char *term
= getenv ("TERM");
2178 struct frame
*sf
= SELECTED_FRAME();
2180 #ifdef HAVE_X_WINDOWS
2181 if (!inhibit_window_system
)
2186 = (!noninteractive
) && term
&& !strcmp (term
, "internal");
2188 if (getenv ("EMACSTEST"))
2189 termscript
= fopen (getenv ("EMACSTEST"), "wt");
2191 #ifndef HAVE_X_WINDOWS
2192 if (!internal_terminal
|| inhibit_window_system
)
2194 sf
->output_method
= output_termcap
;
2198 Vwindow_system
= intern ("pc");
2199 Vwindow_system_version
= make_number (1);
2200 sf
->output_method
= output_msdos_raw
;
2202 /* If Emacs was dumped on DOS/V machine, forget the stale VRAM address. */
2203 screen_old_address
= 0;
2205 /* Forget the stale screen colors as well. */
2206 initial_screen_colors
[0] = initial_screen_colors
[1] = -1;
2208 bzero (&the_only_x_display
, sizeof the_only_x_display
);
2209 the_only_x_display
.background_pixel
= 7; /* White */
2210 the_only_x_display
.foreground_pixel
= 0; /* Black */
2212 colors
= getenv ("EMACSCOLORS");
2213 if (colors
&& strlen (colors
) >= 2)
2215 /* The colors use 4 bits each (we enable bright background). */
2216 if (isdigit (colors
[0]))
2218 else if (isxdigit (colors
[0]))
2219 colors
[0] -= (isupper (colors
[0]) ? 'A' : 'a') - 10;
2220 if (colors
[0] >= 0 && colors
[0] < 16)
2221 the_only_x_display
.foreground_pixel
= colors
[0];
2222 if (isdigit (colors
[1]))
2224 else if (isxdigit (colors
[1]))
2225 colors
[1] -= (isupper (colors
[1]) ? 'A' : 'a') - 10;
2226 if (colors
[1] >= 0 && colors
[1] < 16)
2227 the_only_x_display
.background_pixel
= colors
[1];
2229 the_only_x_display
.line_height
= 1;
2230 the_only_x_display
.font
= (XFontStruct
*)1; /* must *not* be zero */
2231 the_only_x_display
.display_info
.mouse_face_mouse_frame
= NULL
;
2232 the_only_x_display
.display_info
.mouse_face_deferred_gc
= 0;
2233 the_only_x_display
.display_info
.mouse_face_beg_row
=
2234 the_only_x_display
.display_info
.mouse_face_beg_col
= -1;
2235 the_only_x_display
.display_info
.mouse_face_end_row
=
2236 the_only_x_display
.display_info
.mouse_face_end_col
= -1;
2237 the_only_x_display
.display_info
.mouse_face_face_id
= DEFAULT_FACE_ID
;
2238 the_only_x_display
.display_info
.mouse_face_window
= Qnil
;
2239 the_only_x_display
.display_info
.mouse_face_mouse_x
=
2240 the_only_x_display
.display_info
.mouse_face_mouse_y
= 0;
2241 the_only_x_display
.display_info
.mouse_face_defer
= 0;
2243 init_frame_faces (sf
);
2245 ring_bell_hook
= IT_ring_bell
;
2246 insert_glyphs_hook
= IT_insert_glyphs
;
2247 delete_glyphs_hook
= IT_delete_glyphs
;
2248 write_glyphs_hook
= IT_write_glyphs
;
2249 cursor_to_hook
= raw_cursor_to_hook
= IT_cursor_to
;
2250 clear_to_end_hook
= IT_clear_to_end
;
2251 clear_end_of_line_hook
= IT_clear_end_of_line
;
2252 clear_frame_hook
= IT_clear_screen
;
2253 change_line_highlight_hook
= IT_change_line_highlight
;
2254 update_begin_hook
= IT_update_begin
;
2255 update_end_hook
= IT_update_end
;
2256 reassert_line_highlight_hook
= IT_reassert_line_highlight
;
2257 frame_up_to_date_hook
= IT_frame_up_to_date
;
2259 /* These hooks are called by term.c without being checked. */
2260 set_terminal_modes_hook
= IT_set_terminal_modes
;
2261 reset_terminal_modes_hook
= IT_reset_terminal_modes
;
2262 set_terminal_window_hook
= IT_set_terminal_window
;
2263 char_ins_del_ok
= 0;
2267 dos_get_saved_screen (screen
, rows
, cols
)
2272 #ifndef HAVE_X_WINDOWS
2273 *screen
= startup_screen_buffer
;
2274 *cols
= startup_screen_size_X
;
2275 *rows
= startup_screen_size_Y
;
2276 return *screen
!= (char *)0;
2282 #ifndef HAVE_X_WINDOWS
2284 /* We are not X, but we can emulate it well enough for our needs... */
2288 if (! FRAME_MSDOS_P (SELECTED_FRAME()))
2289 error ("Not running under a window system");
2295 /* ----------------------- Keyboard control ----------------------
2297 * Keymaps reflect the following keyboard layout:
2299 * 0 1 2 3 4 5 6 7 8 9 10 11 12 BS
2300 * TAB 15 16 17 18 19 20 21 22 23 24 25 26 (41)
2301 * CLOK 30 31 32 33 34 35 36 37 38 39 40 (41) RET
2302 * SH () 45 46 47 48 49 50 51 52 53 54 SHIFT
2306 #define Ignore 0x0000
2307 #define Normal 0x0000 /* normal key - alt changes scan-code */
2308 #define FctKey 0x1000 /* func key if c == 0, else c */
2309 #define Special 0x2000 /* func key even if c != 0 */
2310 #define ModFct 0x3000 /* special if mod-keys, else 'c' */
2311 #define Map 0x4000 /* alt scan-code, map to unshift/shift key */
2312 #define KeyPad 0x5000 /* map to insert/kp-0 depending on c == 0xe0 */
2313 #define Grey 0x6000 /* Grey keypad key */
2315 #define Alt 0x0100 /* alt scan-code */
2316 #define Ctrl 0x0200 /* ctrl scan-code */
2317 #define Shift 0x0400 /* shift scan-code */
2319 static int extended_kbd
; /* 101 (102) keyboard present. */
2321 struct kbd_translate
{
2324 unsigned short code
;
2327 struct dos_keyboard_map
2332 struct kbd_translate
*translate_table
;
2336 static struct dos_keyboard_map us_keyboard
= {
2338 /* 01234567890123456789012345678901234567890 12345678901234 */
2339 "`1234567890-= qwertyuiop[] asdfghjkl;'\\ zxcvbnm,./ ",
2340 /* 0123456789012345678901234567890123456789 012345678901234 */
2341 "~!@#$%^&*()_+ QWERTYUIOP{} ASDFGHJKL:\"| ZXCVBNM<>? ",
2342 0, /* no Alt-Gr key */
2343 0 /* no translate table */
2346 static struct dos_keyboard_map fr_keyboard
= {
2348 /* 012 3456789012345678901234567890123456789012345678901234 */
2349 "ý&\82\",(-\8a_\80\85)= azertyuiop^$ qsdfghjklm\97* wxcvbnm;:! ",
2350 /* 0123456789012345678901234567890123456789012345678901234 */
2351 " 1234567890ø+ AZERTYUIOPù\9c QSDFGHJKLM%æ WXCVBN?./õ ",
2352 /* 01234567 89012345678901234567890123456789012345678901234 */
2354 0 /* no translate table */
2358 * Italian keyboard support, country code 39.
2361 * added also {,},` as, respectively, AltGr-8, AltGr-9, AltGr-'
2362 * Donated by Stefano Brozzi <brozzis@mag00.cedi.unipr.it>
2365 static struct kbd_translate it_kbd_translate_table
[] = {
2366 { 0x56, 0x3c, Normal
| 13 },
2367 { 0x56, 0x3e, Normal
| 27 },
2370 static struct dos_keyboard_map it_keyboard
= {
2372 /* 0 123456789012345678901234567890123456789012345678901234 */
2373 "\\1234567890'\8d< qwertyuiop\8a+> asdfghjkl\95\85\97 zxcvbnm,.- ",
2374 /* 01 23456789012345678901234567890123456789012345678901234 */
2375 "|!\"\9c$%&/()=?^> QWERTYUIOP\82* ASDFGHJKL\87øõ ZXCVBNM;:_ ",
2376 /* 0123456789012345678901234567890123456789012345678901234 */
2378 it_kbd_translate_table
2381 static struct dos_keyboard_map dk_keyboard
= {
2383 /* 0123456789012345678901234567890123456789012345678901234 */
2384 "«1234567890+| qwertyuiop\86~ asdfghjkl\91\9b' zxcvbnm,.- ",
2385 /* 01 23456789012345678901234567890123456789012345678901234 */
2386 "õ!\"#$%&/()=?` QWERTYUIOP\8f^ ASDFGHJKL\92\9d* ZXCVBNM;:_ ",
2387 /* 0123456789012345678901234567890123456789012345678901234 */
2389 0 /* no translate table */
2392 static struct kbd_translate jp_kbd_translate_table
[] = {
2393 { 0x73, 0x5c, Normal
| 0 },
2394 { 0x73, 0x5f, Normal
| 0 },
2395 { 0x73, 0x1c, Map
| 0 },
2396 { 0x7d, 0x5c, Normal
| 13 },
2397 { 0x7d, 0x7c, Normal
| 13 },
2398 { 0x7d, 0x1c, Map
| 13 },
2401 static struct dos_keyboard_map jp_keyboard
= {
2403 /* 0123456789012 345678901234567890123456789012345678901234 */
2404 "\\1234567890-^\\ qwertyuiop@[ asdfghjkl;:] zxcvbnm,./ ",
2405 /* 01 23456789012345678901234567890123456789012345678901234 */
2406 "_!\"#$%&'()~=~| QWERTYUIOP`{ ASDFGHJKL+*} ZXCVBNM<>? ",
2407 0, /* no Alt-Gr key */
2408 jp_kbd_translate_table
2411 static struct keyboard_layout_list
2414 struct dos_keyboard_map
*keyboard_map
;
2415 } keyboard_layout_list
[] =
2424 static struct dos_keyboard_map
*keyboard
;
2425 static int keyboard_map_all
;
2426 static int international_keyboard
;
2429 dos_set_keyboard (code
, always
)
2434 _go32_dpmi_registers regs
;
2436 /* See if Keyb.Com is installed (for international keyboard support).
2437 Note: calling Int 2Fh via int86 wedges the DOS box on some versions
2438 of Windows 9X! So don't do that! */
2440 regs
.x
.ss
= regs
.x
.sp
= regs
.x
.flags
= 0;
2441 _go32_dpmi_simulate_int (0x2f, ®s
);
2442 if (regs
.h
.al
== 0xff)
2443 international_keyboard
= 1;
2445 /* Initialize to US settings, for countries that don't have their own. */
2446 keyboard
= keyboard_layout_list
[0].keyboard_map
;
2447 keyboard_map_all
= always
;
2448 dos_keyboard_layout
= 1;
2450 for (i
= 0; i
< (sizeof (keyboard_layout_list
)/sizeof (struct keyboard_layout_list
)); i
++)
2451 if (code
== keyboard_layout_list
[i
].country_code
)
2453 keyboard
= keyboard_layout_list
[i
].keyboard_map
;
2454 keyboard_map_all
= always
;
2455 dos_keyboard_layout
= code
;
2463 unsigned char char_code
; /* normal code */
2464 unsigned char meta_code
; /* M- code */
2465 unsigned char keypad_code
; /* keypad code */
2466 unsigned char editkey_code
; /* edit key */
2467 } keypad_translate_map
[] = {
2468 '0', '0', 0xb0, /* kp-0 */ 0x63, /* insert */
2469 '1', '1', 0xb1, /* kp-1 */ 0x57, /* end */
2470 '2', '2', 0xb2, /* kp-2 */ 0x54, /* down */
2471 '3', '3', 0xb3, /* kp-3 */ 0x56, /* next */
2472 '4', '4', 0xb4, /* kp-4 */ 0x51, /* left */
2473 '5', '5', 0xb5, /* kp-5 */ 0xb5, /* kp-5 */
2474 '6', '6', 0xb6, /* kp-6 */ 0x53, /* right */
2475 '7', '7', 0xb7, /* kp-7 */ 0x50, /* home */
2476 '8', '8', 0xb8, /* kp-8 */ 0x52, /* up */
2477 '9', '9', 0xb9, /* kp-9 */ 0x55, /* prior */
2478 '.', '-', 0xae, /* kp-decimal */ 0xff /* delete */
2483 unsigned char char_code
; /* normal code */
2484 unsigned char keypad_code
; /* keypad code */
2485 } grey_key_translate_map
[] = {
2486 '/', 0xaf, /* kp-decimal */
2487 '*', 0xaa, /* kp-multiply */
2488 '-', 0xad, /* kp-subtract */
2489 '+', 0xab, /* kp-add */
2490 '\r', 0x8d /* kp-enter */
2493 static unsigned short
2494 ibmpc_translate_map
[] =
2496 /* --------------- 00 to 0f --------------- */
2497 Normal
| 0xff, /* Ctrl Break + Alt-NNN */
2498 Alt
| ModFct
| 0x1b, /* Escape */
2499 Normal
| 1, /* '1' */
2500 Normal
| 2, /* '2' */
2501 Normal
| 3, /* '3' */
2502 Normal
| 4, /* '4' */
2503 Normal
| 5, /* '5' */
2504 Normal
| 6, /* '6' */
2505 Normal
| 7, /* '7' */
2506 Normal
| 8, /* '8' */
2507 Normal
| 9, /* '9' */
2508 Normal
| 10, /* '0' */
2509 Normal
| 11, /* '-' */
2510 Normal
| 12, /* '=' */
2511 Special
| 0x08, /* Backspace */
2512 ModFct
| 0x74, /* Tab/Backtab */
2514 /* --------------- 10 to 1f --------------- */
2527 ModFct
| 0x0d, /* Return */
2532 /* --------------- 20 to 2f --------------- */
2541 Map
| 40, /* '\'' */
2543 Ignore
, /* Left shift */
2544 Map
| 41, /* '\\' */
2550 /* --------------- 30 to 3f --------------- */
2557 Ignore
, /* Right shift */
2558 Grey
| 1, /* Grey * */
2560 Normal
| 55, /* ' ' */
2561 Ignore
, /* Caps Lock */
2562 FctKey
| 0xbe, /* F1 */
2563 FctKey
| 0xbf, /* F2 */
2564 FctKey
| 0xc0, /* F3 */
2565 FctKey
| 0xc1, /* F4 */
2566 FctKey
| 0xc2, /* F5 */
2568 /* --------------- 40 to 4f --------------- */
2569 FctKey
| 0xc3, /* F6 */
2570 FctKey
| 0xc4, /* F7 */
2571 FctKey
| 0xc5, /* F8 */
2572 FctKey
| 0xc6, /* F9 */
2573 FctKey
| 0xc7, /* F10 */
2574 Ignore
, /* Num Lock */
2575 Ignore
, /* Scroll Lock */
2576 KeyPad
| 7, /* Home */
2577 KeyPad
| 8, /* Up */
2578 KeyPad
| 9, /* Page Up */
2579 Grey
| 2, /* Grey - */
2580 KeyPad
| 4, /* Left */
2581 KeyPad
| 5, /* Keypad 5 */
2582 KeyPad
| 6, /* Right */
2583 Grey
| 3, /* Grey + */
2584 KeyPad
| 1, /* End */
2586 /* --------------- 50 to 5f --------------- */
2587 KeyPad
| 2, /* Down */
2588 KeyPad
| 3, /* Page Down */
2589 KeyPad
| 0, /* Insert */
2590 KeyPad
| 10, /* Delete */
2591 Shift
| FctKey
| 0xbe, /* (Shift) F1 */
2592 Shift
| FctKey
| 0xbf, /* (Shift) F2 */
2593 Shift
| FctKey
| 0xc0, /* (Shift) F3 */
2594 Shift
| FctKey
| 0xc1, /* (Shift) F4 */
2595 Shift
| FctKey
| 0xc2, /* (Shift) F5 */
2596 Shift
| FctKey
| 0xc3, /* (Shift) F6 */
2597 Shift
| FctKey
| 0xc4, /* (Shift) F7 */
2598 Shift
| FctKey
| 0xc5, /* (Shift) F8 */
2599 Shift
| FctKey
| 0xc6, /* (Shift) F9 */
2600 Shift
| FctKey
| 0xc7, /* (Shift) F10 */
2601 Ctrl
| FctKey
| 0xbe, /* (Ctrl) F1 */
2602 Ctrl
| FctKey
| 0xbf, /* (Ctrl) F2 */
2604 /* --------------- 60 to 6f --------------- */
2605 Ctrl
| FctKey
| 0xc0, /* (Ctrl) F3 */
2606 Ctrl
| FctKey
| 0xc1, /* (Ctrl) F4 */
2607 Ctrl
| FctKey
| 0xc2, /* (Ctrl) F5 */
2608 Ctrl
| FctKey
| 0xc3, /* (Ctrl) F6 */
2609 Ctrl
| FctKey
| 0xc4, /* (Ctrl) F7 */
2610 Ctrl
| FctKey
| 0xc5, /* (Ctrl) F8 */
2611 Ctrl
| FctKey
| 0xc6, /* (Ctrl) F9 */
2612 Ctrl
| FctKey
| 0xc7, /* (Ctrl) F10 */
2613 Alt
| FctKey
| 0xbe, /* (Alt) F1 */
2614 Alt
| FctKey
| 0xbf, /* (Alt) F2 */
2615 Alt
| FctKey
| 0xc0, /* (Alt) F3 */
2616 Alt
| FctKey
| 0xc1, /* (Alt) F4 */
2617 Alt
| FctKey
| 0xc2, /* (Alt) F5 */
2618 Alt
| FctKey
| 0xc3, /* (Alt) F6 */
2619 Alt
| FctKey
| 0xc4, /* (Alt) F7 */
2620 Alt
| FctKey
| 0xc5, /* (Alt) F8 */
2622 /* --------------- 70 to 7f --------------- */
2623 Alt
| FctKey
| 0xc6, /* (Alt) F9 */
2624 Alt
| FctKey
| 0xc7, /* (Alt) F10 */
2625 Ctrl
| FctKey
| 0x6d, /* (Ctrl) Sys Rq */
2626 Ctrl
| KeyPad
| 4, /* (Ctrl) Left */
2627 Ctrl
| KeyPad
| 6, /* (Ctrl) Right */
2628 Ctrl
| KeyPad
| 1, /* (Ctrl) End */
2629 Ctrl
| KeyPad
| 3, /* (Ctrl) Page Down */
2630 Ctrl
| KeyPad
| 7, /* (Ctrl) Home */
2631 Alt
| Map
| 1, /* '1' */
2632 Alt
| Map
| 2, /* '2' */
2633 Alt
| Map
| 3, /* '3' */
2634 Alt
| Map
| 4, /* '4' */
2635 Alt
| Map
| 5, /* '5' */
2636 Alt
| Map
| 6, /* '6' */
2637 Alt
| Map
| 7, /* '7' */
2638 Alt
| Map
| 8, /* '8' */
2640 /* --------------- 80 to 8f --------------- */
2641 Alt
| Map
| 9, /* '9' */
2642 Alt
| Map
| 10, /* '0' */
2643 Alt
| Map
| 11, /* '-' */
2644 Alt
| Map
| 12, /* '=' */
2645 Ctrl
| KeyPad
| 9, /* (Ctrl) Page Up */
2646 FctKey
| 0xc8, /* F11 */
2647 FctKey
| 0xc9, /* F12 */
2648 Shift
| FctKey
| 0xc8, /* (Shift) F11 */
2649 Shift
| FctKey
| 0xc9, /* (Shift) F12 */
2650 Ctrl
| FctKey
| 0xc8, /* (Ctrl) F11 */
2651 Ctrl
| FctKey
| 0xc9, /* (Ctrl) F12 */
2652 Alt
| FctKey
| 0xc8, /* (Alt) F11 */
2653 Alt
| FctKey
| 0xc9, /* (Alt) F12 */
2654 Ctrl
| KeyPad
| 8, /* (Ctrl) Up */
2655 Ctrl
| Grey
| 2, /* (Ctrl) Grey - */
2656 Ctrl
| KeyPad
| 5, /* (Ctrl) Keypad 5 */
2658 /* --------------- 90 to 9f --------------- */
2659 Ctrl
| Grey
| 3, /* (Ctrl) Grey + */
2660 Ctrl
| KeyPad
| 2, /* (Ctrl) Down */
2661 Ctrl
| KeyPad
| 0, /* (Ctrl) Insert */
2662 Ctrl
| KeyPad
| 10, /* (Ctrl) Delete */
2663 Ctrl
| FctKey
| 0x09, /* (Ctrl) Tab */
2664 Ctrl
| Grey
| 0, /* (Ctrl) Grey / */
2665 Ctrl
| Grey
| 1, /* (Ctrl) Grey * */
2666 Alt
| FctKey
| 0x50, /* (Alt) Home */
2667 Alt
| FctKey
| 0x52, /* (Alt) Up */
2668 Alt
| FctKey
| 0x55, /* (Alt) Page Up */
2669 Ignore
, /* NO KEY */
2670 Alt
| FctKey
| 0x51, /* (Alt) Left */
2671 Ignore
, /* NO KEY */
2672 Alt
| FctKey
| 0x53, /* (Alt) Right */
2673 Ignore
, /* NO KEY */
2674 Alt
| FctKey
| 0x57, /* (Alt) End */
2676 /* --------------- a0 to af --------------- */
2677 Alt
| KeyPad
| 2, /* (Alt) Down */
2678 Alt
| KeyPad
| 3, /* (Alt) Page Down */
2679 Alt
| KeyPad
| 0, /* (Alt) Insert */
2680 Alt
| KeyPad
| 10, /* (Alt) Delete */
2681 Alt
| Grey
| 0, /* (Alt) Grey / */
2682 Alt
| FctKey
| 0x09, /* (Alt) Tab */
2683 Alt
| Grey
| 4 /* (Alt) Keypad Enter */
2686 /* These bit-positions corresponds to values returned by BIOS */
2687 #define SHIFT_P 0x0003 /* two bits! */
2688 #define CTRL_P 0x0004
2689 #define ALT_P 0x0008
2690 #define SCRLOCK_P 0x0010
2691 #define NUMLOCK_P 0x0020
2692 #define CAPSLOCK_P 0x0040
2693 #define ALT_GR_P 0x0800
2694 #define SUPER_P 0x4000 /* pseudo */
2695 #define HYPER_P 0x8000 /* pseudo */
2698 dos_get_modifiers (keymask
)
2705 /* Calculate modifier bits */
2706 regs
.h
.ah
= extended_kbd
? 0x12 : 0x02;
2707 int86 (0x16, ®s
, ®s
);
2711 mask
= regs
.h
.al
& (SHIFT_P
| CTRL_P
| ALT_P
|
2712 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
2716 mask
= regs
.h
.al
& (SHIFT_P
|
2717 SCRLOCK_P
| NUMLOCK_P
| CAPSLOCK_P
);
2719 /* Do not break international keyboard support. */
2720 /* When Keyb.Com is loaded, the right Alt key is */
2721 /* used for accessing characters like { and } */
2722 if (regs
.h
.ah
& 2) /* Left ALT pressed ? */
2725 if ((regs
.h
.ah
& 8) != 0) /* Right ALT pressed ? */
2728 if (dos_hyper_key
== 1)
2731 modifiers
|= hyper_modifier
;
2733 else if (dos_super_key
== 1)
2736 modifiers
|= super_modifier
;
2738 else if (!international_keyboard
)
2740 /* If Keyb.Com is NOT installed, let Right Alt behave
2741 like the Left Alt. */
2747 if (regs
.h
.ah
& 1) /* Left CTRL pressed ? */
2750 if (regs
.h
.ah
& 4) /* Right CTRL pressed ? */
2752 if (dos_hyper_key
== 2)
2755 modifiers
|= hyper_modifier
;
2757 else if (dos_super_key
== 2)
2760 modifiers
|= super_modifier
;
2768 modifiers
|= shift_modifier
;
2770 modifiers
|= ctrl_modifier
;
2772 modifiers
|= meta_modifier
;
2779 #define NUM_RECENT_DOSKEYS (100)
2780 int recent_doskeys_index
; /* Index for storing next element into recent_doskeys */
2781 int total_doskeys
; /* Total number of elements stored into recent_doskeys */
2782 Lisp_Object recent_doskeys
; /* A vector, holding the last 100 keystrokes */
2784 DEFUN ("recent-doskeys", Frecent_doskeys
, Srecent_doskeys
, 0, 0, 0,
2785 "Return vector of last 100 keyboard input values seen in dos_rawgetc.\n\
2786 Each input key receives two values in this vector: first the ASCII code,\n\
2787 and then the scan code.")
2790 Lisp_Object
*keys
= XVECTOR (recent_doskeys
)->contents
;
2793 if (total_doskeys
< NUM_RECENT_DOSKEYS
)
2794 return Fvector (total_doskeys
, keys
);
2797 val
= Fvector (NUM_RECENT_DOSKEYS
, keys
);
2798 bcopy (keys
+ recent_doskeys_index
,
2799 XVECTOR (val
)->contents
,
2800 (NUM_RECENT_DOSKEYS
- recent_doskeys_index
) * sizeof (Lisp_Object
));
2802 XVECTOR (val
)->contents
+ NUM_RECENT_DOSKEYS
- recent_doskeys_index
,
2803 recent_doskeys_index
* sizeof (Lisp_Object
));
2808 /* Get a char from keyboard. Function keys are put into the event queue. */
2810 extern void kbd_buffer_store_event (struct input_event
*);
2815 struct input_event event
;
2818 #ifndef HAVE_X_WINDOWS
2819 /* Maybe put the cursor where it should be. */
2820 IT_cmgoto (SELECTED_FRAME());
2823 /* The following condition is equivalent to `kbhit ()', except that
2824 it uses the bios to do its job. This pleases DESQview/X. */
2825 while ((regs
.h
.ah
= extended_kbd
? 0x11 : 0x01),
2826 int86 (0x16, ®s
, ®s
),
2827 (regs
.x
.flags
& 0x40) == 0)
2830 register unsigned char c
;
2831 int sc
, code
= -1, mask
, kp_mode
;
2834 regs
.h
.ah
= extended_kbd
? 0x10 : 0x00;
2835 int86 (0x16, ®s
, ®s
);
2840 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
2842 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
2843 recent_doskeys_index
= 0;
2844 XVECTOR (recent_doskeys
)->contents
[recent_doskeys_index
++]
2846 if (recent_doskeys_index
== NUM_RECENT_DOSKEYS
)
2847 recent_doskeys_index
= 0;
2849 modifiers
= dos_get_modifiers (&mask
);
2851 #ifndef HAVE_X_WINDOWS
2852 if (!NILP (Vdos_display_scancodes
))
2855 sprintf (buf
, "%02x:%02x*%04x",
2856 (unsigned) (sc
&0xff), (unsigned) c
, mask
);
2857 dos_direct_output (screen_size_Y
- 2, screen_size_X
- 12, buf
, 10);
2865 case 10: /* Ctrl Grey Enter */
2866 code
= Ctrl
| Grey
| 4;
2868 case 13: /* Grey Enter */
2871 case '/': /* Grey / */
2881 /* Try the keyboard-private translation table first. */
2882 if (keyboard
->translate_table
)
2884 struct kbd_translate
*p
= keyboard
->translate_table
;
2888 if (p
->sc
== sc
&& p
->ch
== c
)
2896 /* If the private table didn't translate it, use the general
2900 if (sc
>= (sizeof (ibmpc_translate_map
) / sizeof (short)))
2902 if ((code
= ibmpc_translate_map
[sc
]) == Ignore
)
2909 /* We only look at the keyboard Ctrl/Shift/Alt keys when
2910 Emacs is ready to read a key. Therefore, if they press
2911 `Alt-x' when Emacs is busy, by the time we get to
2912 `dos_get_modifiers', they might have already released the
2913 Alt key, and Emacs gets just `x', which is BAD.
2914 However, for keys with the `Map' property set, the ASCII
2915 code returns zero iff Alt is pressed. So, when we DON'T
2916 have to support international_keyboard, we don't have to
2917 distinguish between the left and right Alt keys, and we
2918 can set the META modifier for any keys with the `Map'
2919 property if they return zero ASCII code (c = 0). */
2921 || ( (code
& 0xf000) == Map
&& !international_keyboard
))
2922 modifiers
|= meta_modifier
;
2924 modifiers
|= ctrl_modifier
;
2926 modifiers
|= shift_modifier
;
2929 switch (code
& 0xf000)
2932 if (c
&& !(mask
& (SHIFT_P
| ALT_P
| CTRL_P
| HYPER_P
| SUPER_P
)))
2934 c
= 0; /* Special */
2947 if (c
== 0) /* ctrl-break */
2949 return c
; /* ALT-nnn */
2951 if (!keyboard_map_all
)
2960 if (c
&& !(mask
& ALT_P
) && !((mask
& SHIFT_P
) && (mask
& CTRL_P
)))
2961 if (!keyboard_map_all
)
2965 if (mask
& ALT_P
&& code
<= 10 && code
> 0 && dos_keypad_mode
& 0x200)
2966 mask
|= SHIFT_P
; /* ALT-1 => M-! etc. */
2970 code
= keyboard
->shifted
[code
];
2972 modifiers
&= ~shift_modifier
;
2975 if ((mask
& ALT_GR_P
) && keyboard
->alt_gr
&& keyboard
->alt_gr
[code
] != ' ')
2976 code
= keyboard
->alt_gr
[code
];
2978 code
= keyboard
->unshifted
[code
];
2983 if (c
== 0xe0) /* edit key */
2986 if ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) /* numlock on */
2987 kp_mode
= dos_keypad_mode
& 0x03;
2989 kp_mode
= (dos_keypad_mode
>> 4) & 0x03;
2994 if (code
== 10 && dos_decimal_point
)
2995 return dos_decimal_point
;
2996 return keypad_translate_map
[code
].char_code
;
2999 code
= 0xff00 | keypad_translate_map
[code
].keypad_code
;
3003 code
= keypad_translate_map
[code
].meta_code
;
3004 modifiers
= meta_modifier
;
3008 code
= 0xff00 | keypad_translate_map
[code
].editkey_code
;
3015 kp_mode
= ((mask
& (NUMLOCK_P
|CTRL_P
|SHIFT_P
|ALT_P
)) == NUMLOCK_P
) ? 0x04 : 0x40;
3016 if (dos_keypad_mode
& kp_mode
)
3017 code
= 0xff00 | grey_key_translate_map
[code
].keypad_code
;
3019 code
= grey_key_translate_map
[code
].char_code
;
3028 event
.kind
= non_ascii_keystroke
;
3030 event
.kind
= ascii_keystroke
;
3032 event
.modifiers
= modifiers
;
3033 event
.frame_or_window
= selected_frame
;
3034 event
.timestamp
= event_timestamp ();
3035 kbd_buffer_store_event (&event
);
3038 if (have_mouse
> 0 && !mouse_preempted
)
3040 int but
, press
, x
, y
, ok
;
3041 int mouse_prev_x
= mouse_last_x
, mouse_prev_y
= mouse_last_y
;
3043 /* Check for mouse movement *before* buttons. */
3044 mouse_check_moved ();
3046 /* If the mouse moved from the spot of its last sighting, we
3047 might need to update mouse highlight. */
3048 if (mouse_last_x
!= mouse_prev_x
|| mouse_last_y
!= mouse_prev_y
)
3050 previous_help_echo
= help_echo
;
3052 IT_note_mouse_highlight (SELECTED_FRAME(),
3053 mouse_last_x
, mouse_last_y
);
3054 /* If the contents of the global variable help_echo has
3055 changed, generate a HELP_EVENT. */
3056 if (STRINGP (help_echo
) || STRINGP (previous_help_echo
))
3058 event
.kind
= HELP_EVENT
;
3059 event
.frame_or_window
= Fcons (selected_frame
, help_echo
);
3060 event
.timestamp
= event_timestamp ();
3061 kbd_buffer_store_event (&event
);
3065 for (but
= 0; but
< NUM_MOUSE_BUTTONS
; but
++)
3066 for (press
= 0; press
< 2; press
++)
3068 int button_num
= but
;
3071 ok
= mouse_pressed (but
, &x
, &y
);
3073 ok
= mouse_released (but
, &x
, &y
);
3076 /* Allow a simultaneous press/release of Mouse-1 and
3077 Mouse-2 to simulate Mouse-3 on two-button mice. */
3078 if (mouse_button_count
== 2 && but
< 2)
3080 int x2
, y2
; /* don't clobber original coordinates */
3082 /* If only one button is pressed, wait 100 msec and
3083 check again. This way, Speedy Gonzales isn't
3084 punished, while the slow get their chance. */
3085 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3086 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3091 if (press
&& mouse_pressed (1-but
, &x2
, &y2
)
3092 || !press
&& mouse_released (1-but
, &x2
, &y2
))
3097 event
.kind
= mouse_click
;
3098 event
.code
= button_num
;
3099 event
.modifiers
= dos_get_modifiers (0)
3100 | (press
? down_modifier
: up_modifier
);
3103 event
.frame_or_window
= selected_frame
;
3104 event
.timestamp
= event_timestamp ();
3105 kbd_buffer_store_event (&event
);
3113 static int prev_get_char
= -1;
3115 /* Return 1 if a key is ready to be read without suspending execution. */
3119 if (prev_get_char
!= -1)
3122 return ((prev_get_char
= dos_rawgetc ()) != -1);
3125 /* Read a key. Return -1 if no key is ready. */
3129 if (prev_get_char
!= -1)
3131 int c
= prev_get_char
;
3136 return dos_rawgetc ();
3139 #ifndef HAVE_X_WINDOWS
3140 /* See xterm.c for more info. */
3142 pixel_to_glyph_coords (f
, pix_x
, pix_y
, x
, y
, bounds
, noclip
)
3144 register int pix_x
, pix_y
;
3145 register int *x
, *y
;
3149 if (bounds
) abort ();
3151 /* Ignore clipping. */
3158 glyph_to_pixel_coords (f
, x
, y
, pix_x
, pix_y
)
3161 register int *pix_x
, *pix_y
;
3167 /* Simulation of X's menus. Nothing too fancy here -- just make it work
3170 Actually, I don't know the meaning of all the parameters of the functions
3171 here -- I only know how they are called by xmenu.c. I could of course
3172 grab the nearest Xlib manual (down the hall, second-to-last door on the
3173 left), but I don't think it's worth the effort. */
3175 static char *menu_help_message
, *prev_menu_help_message
;
3182 menu
= (XMenu
*) xmalloc (sizeof (XMenu
));
3183 menu
->allocated
= menu
->count
= menu
->panecount
= menu
->width
= 0;
3187 /* Allocate some (more) memory for MENU ensuring that there is room for one
3191 IT_menu_make_room (XMenu
*menu
)
3193 if (menu
->allocated
== 0)
3195 int count
= menu
->allocated
= 10;
3196 menu
->text
= (char **) xmalloc (count
* sizeof (char *));
3197 menu
->submenu
= (XMenu
**) xmalloc (count
* sizeof (XMenu
*));
3198 menu
->panenumber
= (int *) xmalloc (count
* sizeof (int));
3199 menu
->help_text
= (char **) xmalloc (count
* sizeof (char *));
3201 else if (menu
->allocated
== menu
->count
)
3203 int count
= menu
->allocated
= menu
->allocated
+ 10;
3205 = (char **) xrealloc (menu
->text
, count
* sizeof (char *));
3207 = (XMenu
**) xrealloc (menu
->submenu
, count
* sizeof (XMenu
*));
3209 = (int *) xrealloc (menu
->panenumber
, count
* sizeof (int));
3211 = (char **) xrealloc (menu
->help_text
, count
* sizeof (char *));
3215 /* Search the given menu structure for a given pane number. */
3218 IT_menu_search_pane (XMenu
*menu
, int pane
)
3223 for (i
= 0; i
< menu
->count
; i
++)
3224 if (menu
->submenu
[i
])
3226 if (pane
== menu
->panenumber
[i
])
3227 return menu
->submenu
[i
];
3228 if ((try = IT_menu_search_pane (menu
->submenu
[i
], pane
)))
3234 /* Determine how much screen space a given menu needs. */
3237 IT_menu_calc_size (XMenu
*menu
, int *width
, int *height
)
3239 int i
, h2
, w2
, maxsubwidth
, maxheight
;
3242 maxheight
= menu
->count
;
3243 for (i
= 0; i
< menu
->count
; i
++)
3245 if (menu
->submenu
[i
])
3247 IT_menu_calc_size (menu
->submenu
[i
], &w2
, &h2
);
3248 if (w2
> maxsubwidth
) maxsubwidth
= w2
;
3249 if (i
+ h2
> maxheight
) maxheight
= i
+ h2
;
3252 *width
= menu
->width
+ maxsubwidth
;
3253 *height
= maxheight
;
3256 /* Display MENU at (X,Y) using FACES. */
3259 IT_menu_display (XMenu
*menu
, int y
, int x
, int *faces
, int disp_help
)
3261 int i
, j
, face
, width
;
3262 struct glyph
*text
, *p
;
3265 int enabled
, mousehere
;
3267 struct frame
*sf
= SELECTED_FRAME();
3269 menu_help_message
= NULL
;
3271 width
= menu
->width
;
3272 text
= (struct glyph
*) xmalloc ((width
+ 2) * sizeof (struct glyph
));
3273 ScreenGetCursor (&row
, &col
);
3274 mouse_get_xy (&mx
, &my
);
3275 IT_update_begin (sf
);
3276 for (i
= 0; i
< menu
->count
; i
++)
3278 int max_width
= width
+ 2;
3280 IT_cursor_to (y
+ i
, x
);
3282 = (!menu
->submenu
[i
] && menu
->panenumber
[i
]) || (menu
->submenu
[i
]);
3283 mousehere
= (y
+ i
== my
&& x
<= mx
&& mx
< x
+ width
+ 2);
3284 face
= faces
[enabled
+ mousehere
* 2];
3285 if (disp_help
&& enabled
+ mousehere
* 2 >= 2)
3286 menu_help_message
= menu
->help_text
[i
];
3288 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3290 for (j
= 0, q
= menu
->text
[i
]; *q
; j
++)
3294 SET_CHAR_GLYPH (*p
, *q
++, face
, 0);
3297 else /* make '^x' */
3299 SET_CHAR_GLYPH (*p
, '^', face
, 0);
3302 SET_CHAR_GLYPH (*p
, *q
++ + 64, face
, 0);
3306 /* Don't let the menu text overflow into the next screen row. */
3307 if (x
+ max_width
> screen_size_X
)
3309 max_width
= screen_size_X
- x
;
3310 text
[max_width
- 1].u
.ch
= '$'; /* indicate it's truncated */
3312 for (; j
< max_width
- 2; j
++, p
++)
3313 SET_CHAR_GLYPH (*p
, ' ', face
, 0);
3315 SET_CHAR_GLYPH (*p
, menu
->submenu
[i
] ? 16 : ' ', face
, 0);
3317 IT_write_glyphs (text
, max_width
);
3320 IT_cursor_to (row
, col
);
3324 /* --------------------------- X Menu emulation ---------------------- */
3326 /* Report availability of menus. */
3334 /* Create a brand new menu structure. */
3337 XMenuCreate (Display
*foo1
, Window foo2
, char *foo3
)
3339 return IT_menu_create ();
3342 /* Create a new pane and place it on the outer-most level. It is not
3343 clear that it should be placed out there, but I don't know what else
3347 XMenuAddPane (Display
*foo
, XMenu
*menu
, char *txt
, int enable
)
3355 IT_menu_make_room (menu
);
3356 menu
->submenu
[menu
->count
] = IT_menu_create ();
3357 menu
->text
[menu
->count
] = txt
;
3358 menu
->panenumber
[menu
->count
] = ++menu
->panecount
;
3359 menu
->help_text
[menu
->count
] = NULL
;
3362 /* Adjust length for possible control characters (which will
3363 be written as ^x). */
3364 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3368 if (len
> menu
->width
)
3371 return menu
->panecount
;
3374 /* Create a new item in a menu pane. */
3377 XMenuAddSelection (Display
*bar
, XMenu
*menu
, int pane
,
3378 int foo
, char *txt
, int enable
, char *help_text
)
3384 if (!(menu
= IT_menu_search_pane (menu
, pane
)))
3386 IT_menu_make_room (menu
);
3387 menu
->submenu
[menu
->count
] = (XMenu
*) 0;
3388 menu
->text
[menu
->count
] = txt
;
3389 menu
->panenumber
[menu
->count
] = enable
;
3390 menu
->help_text
[menu
->count
] = help_text
;
3393 /* Adjust length for possible control characters (which will
3394 be written as ^x). */
3395 for (len
= strlen (txt
), p
= txt
; *p
; p
++)
3399 if (len
> menu
->width
)
3405 /* Decide where the menu would be placed if requested at (X,Y). */
3408 XMenuLocate (Display
*foo0
, XMenu
*menu
, int foo1
, int foo2
, int x
, int y
,
3409 int *ulx
, int *uly
, int *width
, int *height
)
3411 IT_menu_calc_size (menu
, width
, height
);
3417 struct IT_menu_state
3419 void *screen_behind
;
3426 /* Display menu, wait for user's response, and return that response. */
3429 XMenuActivate (Display
*foo
, XMenu
*menu
, int *pane
, int *selidx
,
3430 int x0
, int y0
, unsigned ButtonMask
, char **txt
,
3431 void (*help_callback
)(char *))
3433 struct IT_menu_state
*state
;
3438 Lisp_Object selectface
;
3439 int leave
, result
, onepane
;
3440 int title_faces
[4]; /* face to display the menu title */
3441 int buffers_num_deleted
= 0;
3442 struct frame
*sf
= SELECTED_FRAME();
3444 /* Just in case we got here without a mouse present... */
3445 if (have_mouse
<= 0)
3446 return XM_IA_SELECT
;
3447 /* Don't allow non-positive x0 and y0, lest the menu will wrap
3448 around the display. */
3454 /* We will process all the mouse events directly, so we had
3455 better prevented dos_rawgetc from stealing them from us. */
3458 state
= alloca (menu
->panecount
* sizeof (struct IT_menu_state
));
3459 screensize
= screen_size
* 2;
3461 = lookup_derived_face (sf
, intern ("msdos-menu-passive-face"),
3462 CHARSET_ASCII
, DEFAULT_FACE_ID
);
3464 = lookup_derived_face (sf
, intern ("msdos-menu-active-face"),
3465 CHARSET_ASCII
, DEFAULT_FACE_ID
);
3466 selectface
= intern ("msdos-menu-select-face");
3467 faces
[2] = lookup_derived_face (sf
, selectface
,
3468 CHARSET_ASCII
, faces
[0]);
3469 faces
[3] = lookup_derived_face (sf
, selectface
,
3470 CHARSET_ASCII
, faces
[1]);
3472 /* Make sure the menu title is always displayed with
3473 `msdos-menu-active-face', no matter where the mouse pointer is. */
3474 for (i
= 0; i
< 4; i
++)
3475 title_faces
[i
] = faces
[3];
3479 /* Don't let the title for the "Buffers" popup menu include a
3480 digit (which is ugly).
3482 This is a terrible kludge, but I think the "Buffers" case is
3483 the only one where the title includes a number, so it doesn't
3484 seem to be necessary to make this more general. */
3485 if (strncmp (menu
->text
[0], "Buffers 1", 9) == 0)
3487 menu
->text
[0][7] = '\0';
3488 buffers_num_deleted
= 1;
3490 state
[0].menu
= menu
;
3492 ScreenRetrieve (state
[0].screen_behind
= xmalloc (screensize
));
3494 /* Turn off the cursor. Otherwise it shows through the menu
3495 panes, which is ugly. */
3496 IT_display_cursor (0);
3498 /* Display the menu title. */
3499 IT_menu_display (menu
, y0
- 1, x0
- 1, title_faces
, 0);
3500 if (buffers_num_deleted
)
3501 menu
->text
[0][7] = ' ';
3502 if ((onepane
= menu
->count
== 1 && menu
->submenu
[0]))
3504 menu
->width
= menu
->submenu
[0]->width
;
3505 state
[0].menu
= menu
->submenu
[0];
3509 state
[0].menu
= menu
;
3511 state
[0].x
= x0
- 1;
3513 state
[0].pane
= onepane
;
3515 mouse_last_x
= -1; /* A hack that forces display. */
3519 if (!mouse_visible
) mouse_on ();
3520 mouse_check_moved ();
3521 if (sf
->mouse_moved
)
3523 sf
->mouse_moved
= 0;
3524 result
= XM_IA_SELECT
;
3525 mouse_get_xy (&x
, &y
);
3526 for (i
= 0; i
< statecount
; i
++)
3527 if (state
[i
].x
<= x
&& x
< state
[i
].x
+ state
[i
].menu
->width
+ 2)
3529 int dy
= y
- state
[i
].y
;
3530 if (0 <= dy
&& dy
< state
[i
].menu
->count
)
3532 if (!state
[i
].menu
->submenu
[dy
])
3533 if (state
[i
].menu
->panenumber
[dy
])
3534 result
= XM_SUCCESS
;
3536 result
= XM_IA_SELECT
;
3537 *pane
= state
[i
].pane
- 1;
3539 /* We hit some part of a menu, so drop extra menus that
3540 have been opened. That does not include an open and
3542 if (i
!= statecount
- 2
3543 || state
[i
].menu
->submenu
[dy
] != state
[i
+1].menu
)
3544 while (i
!= statecount
- 1)
3548 ScreenUpdate (state
[statecount
].screen_behind
);
3549 if (screen_virtual_segment
)
3550 dosv_refresh_virtual_screen (0, screen_size
);
3551 xfree (state
[statecount
].screen_behind
);
3553 if (i
== statecount
- 1 && state
[i
].menu
->submenu
[dy
])
3555 IT_menu_display (state
[i
].menu
,
3559 state
[statecount
].menu
= state
[i
].menu
->submenu
[dy
];
3560 state
[statecount
].pane
= state
[i
].menu
->panenumber
[dy
];
3562 ScreenRetrieve (state
[statecount
].screen_behind
3563 = xmalloc (screensize
));
3565 = state
[i
].x
+ state
[i
].menu
->width
+ 2;
3566 state
[statecount
].y
= y
;
3571 IT_menu_display (state
[statecount
- 1].menu
,
3572 state
[statecount
- 1].y
,
3573 state
[statecount
- 1].x
,
3578 if ((menu_help_message
|| prev_menu_help_message
)
3579 && menu_help_message
!= prev_menu_help_message
)
3581 help_callback (menu_help_message
);
3582 IT_display_cursor (0);
3583 prev_menu_help_message
= menu_help_message
;
3585 /* We are busy-waiting for the mouse to move, so let's be nice
3586 to other Windows applications by releasing our time slice. */
3589 for (b
= 0; b
< mouse_button_count
&& !leave
; b
++)
3591 /* Only leave if user both pressed and released the mouse, and in
3592 that order. This avoids popping down the menu pane unless
3593 the user is really done with it. */
3594 if (mouse_pressed (b
, &x
, &y
))
3596 while (mouse_button_depressed (b
, &x
, &y
))
3600 (void) mouse_released (b
, &x
, &y
);
3605 ScreenUpdate (state
[0].screen_behind
);
3606 if (screen_virtual_segment
)
3607 dosv_refresh_virtual_screen (0, screen_size
);
3609 while (statecount
--)
3610 xfree (state
[statecount
].screen_behind
);
3611 IT_display_cursor (1); /* turn cursor back on */
3612 /* Clean up any mouse events that are waiting inside Emacs event queue.
3613 These events are likely to be generated before the menu was even
3614 displayed, probably because the user pressed and released the button
3615 (which invoked the menu) too quickly. If we don't remove these events,
3616 Emacs will process them after we return and surprise the user. */
3617 discard_mouse_events ();
3618 /* Allow mouse events generation by dos_rawgetc. */
3623 /* Dispose of a menu. */
3626 XMenuDestroy (Display
*foo
, XMenu
*menu
)
3629 if (menu
->allocated
)
3631 for (i
= 0; i
< menu
->count
; i
++)
3632 if (menu
->submenu
[i
])
3633 XMenuDestroy (foo
, menu
->submenu
[i
]);
3635 xfree (menu
->submenu
);
3636 xfree (menu
->panenumber
);
3637 xfree (menu
->help_text
);
3640 menu_help_message
= prev_menu_help_message
= NULL
;
3644 x_pixel_width (struct frame
*f
)
3646 return FRAME_WIDTH (f
);
3650 x_pixel_height (struct frame
*f
)
3652 return FRAME_HEIGHT (f
);
3654 #endif /* !HAVE_X_WINDOWS */
3656 /* ----------------------- DOS / UNIX conversion --------------------- */
3658 void msdos_downcase_filename (unsigned char *);
3660 /* Destructively turn backslashes into slashes. */
3663 dostounix_filename (p
)
3666 msdos_downcase_filename (p
);
3676 /* Destructively turn slashes into backslashes. */
3679 unixtodos_filename (p
)
3682 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
3696 /* Get the default directory for a given drive. 0=def, 1=A, 2=B, ... */
3699 getdefdir (drive
, dst
)
3703 char in_path
[4], *p
= in_path
;
3706 /* Generate "X:." (when drive is X) or "." (when drive is 0). */
3709 *p
++ = drive
+ 'A' - 1;
3716 _fixpath (in_path
, dst
);
3717 /* _fixpath can set errno to ENOSYS on non-LFN systems because
3718 it queries the LFN support, so ignore that error. */
3719 if ((errno
&& errno
!= ENOSYS
) || *dst
== '\0')
3722 msdos_downcase_filename (dst
);
3728 /* Remove all CR's that are followed by a LF. */
3733 register unsigned char *buf
;
3735 unsigned char *np
= buf
;
3736 unsigned char *startp
= buf
;
3737 unsigned char *endp
= buf
+ n
;
3741 while (buf
< endp
- 1)
3745 if (*(++buf
) != 0x0a)
3756 #if defined(__DJGPP__) && __DJGPP__ == 2 && __DJGPP_MINOR__ == 0
3758 /* In DJGPP v2.0, library `write' can call `malloc', which might
3759 cause relocation of the buffer whose address we get in ADDR.
3760 Here is a version of `write' that avoids calling `malloc',
3761 to serve us until such time as the library is fixed.
3762 Actually, what we define here is called `__write', because
3763 `write' is a stub that just jmp's to `__write' (to be
3764 POSIXLY-correct with respect to the global name-space). */
3766 #include <io.h> /* for _write */
3767 #include <libc/dosio.h> /* for __file_handle_modes[] */
3769 static char xbuf
[64 * 1024]; /* DOS cannot write more in one chunk */
3771 #define XBUF_END (xbuf + sizeof (xbuf) - 1)
3774 __write (int handle
, const void *buffer
, size_t count
)
3779 if(__file_handle_modes
[handle
] & O_BINARY
)
3780 return _write (handle
, buffer
, count
);
3784 const char *bp
= buffer
;
3785 int total_written
= 0;
3786 int nmoved
= 0, ncr
= 0;
3790 /* The next test makes sure there's space for at least 2 more
3791 characters in xbuf[], so both CR and LF can be put there. */
3803 if (xbp
>= XBUF_END
|| !count
)
3805 size_t to_write
= nmoved
+ ncr
;
3806 int written
= _write (handle
, xbuf
, to_write
);
3811 total_written
+= nmoved
; /* CRs aren't counted in ret value */
3813 /* If some, but not all were written (disk full?), return
3814 an estimate of the total written bytes not counting CRs. */
3815 if (written
< to_write
)
3816 return total_written
- (to_write
- written
) * nmoved
/to_write
;
3823 return total_written
;
3827 /* A low-level file-renaming function which works around Windows 95 bug.
3828 This is pulled directly out of DJGPP v2.01 library sources, and only
3829 used when you compile with DJGPP v2.0. */
3833 int _rename(const char *old
, const char *new)
3836 int olen
= strlen(old
) + 1;
3838 int use_lfn
= _USE_LFN
;
3839 char tempfile
[FILENAME_MAX
];
3840 const char *orig
= old
;
3843 r
.x
.dx
= __tb_offset
;
3844 r
.x
.di
= __tb_offset
+ olen
;
3845 r
.x
.ds
= r
.x
.es
= __tb_segment
;
3849 /* Windows 95 bug: for some filenames, when you rename
3850 file -> file~ (as in Emacs, to leave a backup), the
3851 short 8+3 alias doesn't change, which effectively
3852 makes OLD and NEW the same file. We must rename
3853 through a temporary file to work around this. */
3855 char *pbase
= 0, *p
;
3856 static char try_char
[] = "abcdefghijklmnopqrstuvwxyz012345789";
3857 int idx
= sizeof(try_char
) - 1;
3859 /* Generate a temporary name. Can't use `tmpnam', since $TMPDIR
3860 might point to another drive, which will fail the DOS call. */
3861 strcpy(tempfile
, old
);
3862 for (p
= tempfile
; *p
; p
++) /* ensure temporary is on the same drive */
3863 if (*p
== '/' || *p
== '\\' || *p
== ':')
3869 strcpy(pbase
, "X$$djren$$.$$temp$$");
3875 *pbase
= try_char
[--idx
];
3876 } while (_chmod(tempfile
, 0) != -1);
3879 _put_path2(tempfile
, olen
);
3881 __dpmi_int(0x21, &r
);
3884 errno
= __doserr_to_errno(r
.x
.ax
);
3888 /* Now create a file with the original name. This will
3889 ensure that NEW will always have a 8+3 alias
3890 different from that of OLD. (Seems to be required
3891 when NameNumericTail in the Registry is set to 0.) */
3892 lfn_fd
= _creat(old
, 0);
3894 olen
= strlen(tempfile
) + 1;
3896 r
.x
.di
= __tb_offset
+ olen
;
3905 _put_path2(new, olen
);
3907 __dpmi_int(0x21, &r
);
3910 if (r
.x
.ax
== 5 && i
== 0) /* access denied */
3911 remove(new); /* and try again */
3914 errno
= __doserr_to_errno(r
.x
.ax
);
3916 /* Restore to original name if we renamed it to temporary. */
3924 _put_path2(orig
, olen
);
3925 _put_path(tempfile
);
3927 __dpmi_int(0x21, &r
);
3936 /* Success. Delete the file possibly created to work
3937 around the Windows 95 bug. */
3939 return (_close (lfn_fd
) == 0) ? remove (orig
) : -1;
3943 #endif /* __DJGPP__ == 2 && __DJGPP_MINOR__ == 0 */
3945 DEFUN ("msdos-long-file-names", Fmsdos_long_file_names
, Smsdos_long_file_names
,
3947 "Return non-nil if long file names are supported on MSDOS.")
3950 return (_USE_LFN
? Qt
: Qnil
);
3953 /* Convert alphabetic characters in a filename to lower-case. */
3956 msdos_downcase_filename (p
)
3957 register unsigned char *p
;
3959 /* Always lower-case drive letters a-z, even if the filesystem
3960 preserves case in filenames.
3961 This is so MSDOS filenames could be compared by string comparison
3962 functions that are case-sensitive. Even case-preserving filesystems
3963 do not distinguish case in drive letters. */
3964 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
3970 /* Under LFN we expect to get pathnames in their true case. */
3971 if (NILP (Fmsdos_long_file_names ()))
3973 if (*p
>= 'A' && *p
<= 'Z')
3977 DEFUN ("msdos-downcase-filename", Fmsdos_downcase_filename
, Smsdos_downcase_filename
,
3979 "Convert alphabetic characters in FILENAME to lower case and return that.\n\
3980 When long filenames are supported, doesn't change FILENAME.\n\
3981 If FILENAME is not a string, returns nil.\n\
3982 The argument object is never altered--the value is a copy.")
3984 Lisp_Object filename
;
3988 if (! STRINGP (filename
))
3991 tem
= Fcopy_sequence (filename
);
3992 msdos_downcase_filename (XSTRING (tem
)->data
);
3996 /* The Emacs root directory as determined by init_environment. */
3998 static char emacsroot
[MAXPATHLEN
];
4001 rootrelativepath (rel
)
4004 static char result
[MAXPATHLEN
+ 10];
4006 strcpy (result
, emacsroot
);
4007 strcat (result
, "/");
4008 strcat (result
, rel
);
4012 /* Define a lot of environment variables if not already defined. Don't
4013 remove anything unless you know what you're doing -- lots of code will
4014 break if one or more of these are missing. */
4017 init_environment (argc
, argv
, skip_args
)
4024 static const char * const tempdirs
[] = {
4025 "$TMPDIR", "$TEMP", "$TMP", "c:/"
4028 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
4030 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
4031 temporary files and assume "/tmp" if $TMPDIR is unset, which
4032 will break on DOS/Windows. Refuse to work if we cannot find
4033 a directory, not even "c:/", usable for that purpose. */
4034 for (i
= 0; i
< imax
; i
++)
4036 const char *tmp
= tempdirs
[i
];
4039 tmp
= getenv (tmp
+ 1);
4040 /* Note that `access' can lie to us if the directory resides on a
4041 read-only filesystem, like CD-ROM or a write-protected floppy.
4042 The only way to be really sure is to actually create a file and
4043 see if it succeeds. But I think that's too much to ask. */
4044 if (tmp
&& access (tmp
, D_OK
) == 0)
4046 setenv ("TMPDIR", tmp
, 1);
4053 Fcons (build_string ("no usable temporary directories found!!"),
4055 "While setting TMPDIR: ");
4057 /* Note the startup time, so we know not to clear the screen if we
4058 exit immediately; see IT_reset_terminal_modes.
4059 (Yes, I know `clock' returns zero the first time it's called, but
4060 I do this anyway, in case some wiseguy changes that at some point.) */
4061 startup_time
= clock ();
4063 /* Find our root from argv[0]. Assuming argv[0] is, say,
4064 "c:/emacs/bin/emacs.exe" our root will be "c:/emacs". */
4065 root
= alloca (MAXPATHLEN
+ 20);
4066 _fixpath (argv
[0], root
);
4067 msdos_downcase_filename (root
);
4068 len
= strlen (root
);
4069 while (len
> 0 && root
[len
] != '/' && root
[len
] != ':')
4073 && (strcmp (root
+ len
- 4, "/bin") == 0
4074 || strcmp (root
+ len
- 4, "/src") == 0)) /* under a debugger */
4075 root
[len
- 4] = '\0';
4077 strcpy (root
, "c:/emacs"); /* let's be defensive */
4078 len
= strlen (root
);
4079 strcpy (emacsroot
, root
);
4081 /* We default HOME to our root. */
4082 setenv ("HOME", root
, 0);
4084 /* We default EMACSPATH to root + "/bin". */
4085 strcpy (root
+ len
, "/bin");
4086 setenv ("EMACSPATH", root
, 0);
4088 /* I don't expect anybody to ever use other terminals so the internal
4089 terminal is the default. */
4090 setenv ("TERM", "internal", 0);
4092 #ifdef HAVE_X_WINDOWS
4093 /* Emacs expects DISPLAY to be set. */
4094 setenv ("DISPLAY", "unix:0.0", 0);
4097 /* SHELL is a bit tricky -- COMSPEC is the closest we come, but we must
4098 downcase it and mirror the backslashes. */
4099 s
= getenv ("COMSPEC");
4100 if (!s
) s
= "c:/command.com";
4101 t
= alloca (strlen (s
) + 1);
4103 dostounix_filename (t
);
4104 setenv ("SHELL", t
, 0);
4106 /* PATH is also downcased and backslashes mirrored. */
4107 s
= getenv ("PATH");
4109 t
= alloca (strlen (s
) + 3);
4110 /* Current directory is always considered part of MsDos's path but it is
4111 not normally mentioned. Now it is. */
4112 strcat (strcpy (t
, ".;"), s
);
4113 dostounix_filename (t
); /* Not a single file name, but this should work. */
4114 setenv ("PATH", t
, 1);
4116 /* In some sense all dos users have root privileges, so... */
4117 setenv ("USER", "root", 0);
4118 setenv ("NAME", getenv ("USER"), 0);
4120 /* Time zone determined from country code. To make this possible, the
4121 country code may not span more than one time zone. In other words,
4122 in the USA, you lose. */
4124 switch (dos_country_code
)
4126 case 31: /* Belgium */
4127 case 32: /* The Netherlands */
4128 case 33: /* France */
4129 case 34: /* Spain */
4130 case 36: /* Hungary */
4131 case 38: /* Yugoslavia (or what's left of it?) */
4132 case 39: /* Italy */
4133 case 41: /* Switzerland */
4134 case 42: /* Tjekia */
4135 case 45: /* Denmark */
4136 case 46: /* Sweden */
4137 case 47: /* Norway */
4138 case 48: /* Poland */
4139 case 49: /* Germany */
4140 /* Daylight saving from last Sunday in March to last Sunday in
4141 September, both at 2AM. */
4142 setenv ("TZ", "MET-01METDST-02,M3.5.0/02:00,M9.5.0/02:00", 0);
4144 case 44: /* United Kingdom */
4145 case 351: /* Portugal */
4146 case 354: /* Iceland */
4147 setenv ("TZ", "GMT+00", 0);
4149 case 81: /* Japan */
4150 case 82: /* Korea */
4151 setenv ("TZ", "JST-09", 0);
4153 case 90: /* Turkey */
4154 case 358: /* Finland */
4155 setenv ("TZ", "EET-02", 0);
4157 case 972: /* Israel */
4158 /* This is an approximation. (For exact rules, use the
4159 `zoneinfo/israel' file which comes with DJGPP, but you need
4160 to install it in `/usr/share/zoneinfo/' directory first.) */
4161 setenv ("TZ", "IST-02IDT-03,M4.1.6/00:00,M9.5.6/01:00", 0);
4169 static int break_stat
; /* BREAK check mode status. */
4170 static int stdin_stat
; /* stdin IOCTL status. */
4174 /* These must be global. */
4175 static _go32_dpmi_seginfo ctrl_break_vector
;
4176 static _go32_dpmi_registers ctrl_break_regs
;
4177 static int ctrlbreakinstalled
= 0;
4179 /* Interrupt level detection of Ctrl-Break. Don't do anything fancy here! */
4182 ctrl_break_func (regs
)
4183 _go32_dpmi_registers
*regs
;
4189 install_ctrl_break_check ()
4191 if (!ctrlbreakinstalled
)
4193 /* Don't press Ctrl-Break if you don't have either DPMI or Emacs
4194 was compiler with Djgpp 1.11 maintenance level 5 or later! */
4195 ctrlbreakinstalled
= 1;
4196 ctrl_break_vector
.pm_offset
= (int) ctrl_break_func
;
4197 _go32_dpmi_allocate_real_mode_callback_iret (&ctrl_break_vector
,
4199 _go32_dpmi_set_real_mode_interrupt_vector (0x1b, &ctrl_break_vector
);
4203 #endif /* __DJGPP__ < 2 */
4205 /* Turn off Dos' Ctrl-C checking and inhibit interpretation of
4206 control chars by DOS. Determine the keyboard type. */
4211 union REGS inregs
, outregs
;
4212 static int first_time
= 1;
4214 break_stat
= getcbrk ();
4217 install_ctrl_break_check ();
4223 int86 (0x15, &inregs
, &outregs
);
4224 extended_kbd
= (!outregs
.x
.cflag
) && (outregs
.h
.ah
== 0);
4228 if (internal_terminal
4229 #ifdef HAVE_X_WINDOWS
4230 && inhibit_window_system
4234 inregs
.x
.ax
= 0x0021;
4235 int86 (0x33, &inregs
, &outregs
);
4236 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4239 /* Reportedly, the above doesn't work for some mouse drivers. There
4240 is an additional detection method that should work, but might be
4241 a little slower. Use that as an alternative. */
4242 inregs
.x
.ax
= 0x0000;
4243 int86 (0x33, &inregs
, &outregs
);
4244 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4249 have_mouse
= 1; /* enable mouse */
4252 if (outregs
.x
.bx
== 3)
4254 mouse_button_count
= 3;
4255 mouse_button_translate
[0] = 0; /* Left */
4256 mouse_button_translate
[1] = 2; /* Middle */
4257 mouse_button_translate
[2] = 1; /* Right */
4261 mouse_button_count
= 2;
4262 mouse_button_translate
[0] = 0;
4263 mouse_button_translate
[1] = 1;
4265 mouse_position_hook
= &mouse_get_pos
;
4274 stdin_stat
= setmode (fileno (stdin
), O_BINARY
);
4275 return (stdin_stat
!= -1);
4278 return (setmode (fileno (stdin
), O_BINARY
) != -1);
4280 #else /* __DJGPP__ < 2 */
4284 /* I think it is wrong to overwrite `stdin_stat' every time
4285 but the first one this function is called, but I don't
4286 want to change the way it used to work in v1.x.--EZ */
4288 inregs
.x
.ax
= 0x4400; /* Get IOCTL status. */
4289 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4290 intdos (&inregs
, &outregs
);
4291 stdin_stat
= outregs
.h
.dl
;
4293 inregs
.x
.dx
= stdin_stat
| 0x0020; /* raw mode */
4294 inregs
.x
.ax
= 0x4401; /* Set IOCTL status */
4295 intdos (&inregs
, &outregs
);
4296 return !outregs
.x
.cflag
;
4298 #endif /* __DJGPP__ < 2 */
4301 /* Restore status of standard input and Ctrl-C checking. */
4306 union REGS inregs
, outregs
;
4308 setcbrk (break_stat
);
4313 return (setmode (fileno (stdin
), stdin_stat
) != -1);
4315 #else /* not __DJGPP__ >= 2 */
4317 inregs
.x
.ax
= 0x4401; /* Set IOCTL status. */
4318 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4319 inregs
.x
.dx
= stdin_stat
;
4320 intdos (&inregs
, &outregs
);
4321 return !outregs
.x
.cflag
;
4323 #endif /* not __DJGPP__ >= 2 */
4327 /* Run command as specified by ARGV in directory DIR.
4328 The command is run with input from TEMPIN, output to
4329 file TEMPOUT and stderr to TEMPERR. */
4332 run_msdos_command (argv
, working_dir
, tempin
, tempout
, temperr
, envv
)
4333 unsigned char **argv
;
4334 const char *working_dir
;
4335 int tempin
, tempout
, temperr
;
4338 char *saveargv1
, *saveargv2
, *lowcase_argv0
, *pa
, *pl
;
4339 char oldwd
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
4340 int msshell
, result
= -1;
4341 int inbak
, outbak
, errbak
;
4345 /* Get current directory as MSDOS cwd is not per-process. */
4348 /* If argv[0] is the shell, it might come in any lettercase.
4349 Since `Fmember' is case-sensitive, we need to downcase
4350 argv[0], even if we are on case-preserving filesystems. */
4351 lowcase_argv0
= alloca (strlen (argv
[0]) + 1);
4352 for (pa
= argv
[0], pl
= lowcase_argv0
; *pa
; pl
++)
4355 if (*pl
>= 'A' && *pl
<= 'Z')
4360 cmd
= Ffile_name_nondirectory (build_string (lowcase_argv0
));
4361 msshell
= !NILP (Fmember (cmd
, Fsymbol_value (intern ("msdos-shells"))))
4362 && !strcmp ("-c", argv
[1]);
4365 saveargv1
= argv
[1];
4366 saveargv2
= argv
[2];
4370 char *p
= alloca (strlen (argv
[2]) + 1);
4372 strcpy (argv
[2] = p
, saveargv2
);
4373 while (*p
&& isspace (*p
))
4375 while (*p
&& !isspace (*p
))
4383 chdir (working_dir
);
4387 if (inbak
< 0 || outbak
< 0 || errbak
< 0)
4388 goto done
; /* Allocation might fail due to lack of descriptors. */
4391 mouse_get_xy (&x
, &y
);
4393 dos_ttcooked (); /* do it here while 0 = stdin */
4401 if (msshell
&& !argv
[3])
4403 /* MS-DOS native shells are too restrictive. For starters, they
4404 cannot grok commands longer than 126 characters. In DJGPP v2
4405 and later, `system' is much smarter, so we'll call it instead. */
4409 /* A shell gets a single argument--its full command
4410 line--whose original was saved in `saveargv2'. */
4412 /* Don't let them pass empty command lines to `system', since
4413 with some shells it will try to invoke an interactive shell,
4414 which will hang Emacs. */
4415 for (cmnd
= saveargv2
; *cmnd
&& isspace (*cmnd
); cmnd
++)
4419 extern char **environ
;
4420 int save_system_flags
= __system_flags
;
4422 /* Request the most powerful version of `system'. We need
4423 all the help we can get to avoid calling stock DOS shells. */
4424 __system_flags
= (__system_redirect
4425 | __system_use_shell
4426 | __system_allow_multiple_cmds
4427 | __system_allow_long_cmds
4428 | __system_handle_null_commands
4429 | __system_emulate_chdir
);
4432 result
= system (cmnd
);
4433 __system_flags
= save_system_flags
;
4436 result
= 0; /* emulate Unixy shell behavior with empty cmd line */
4440 #endif /* __DJGPP__ > 1 */
4442 result
= spawnve (P_WAIT
, argv
[0], argv
, envv
);
4447 emacs_close (inbak
);
4448 emacs_close (outbak
);
4449 emacs_close (errbak
);
4455 mouse_moveto (x
, y
);
4458 /* Some programs might change the meaning of the highest bit of the
4459 text attribute byte, so we get blinking characters instead of the
4460 bright background colors. Restore that. */
4467 argv
[1] = saveargv1
;
4468 argv
[2] = saveargv2
;
4476 fprintf (stderr
, "%s not yet implemented\r\n", badfunc
);
4483 /* ------------------------- Compatibility functions -------------------
4488 /* Hostnames for a pc are not really funny,
4489 but they are used in change log so we emulate the best we can. */
4491 gethostname (p
, size
)
4495 char *q
= egetenv ("HOSTNAME");
4502 /* When time zones are set from Ms-Dos too many C-libraries are playing
4503 tricks with time values. We solve this by defining our own version
4504 of `gettimeofday' bypassing GO32. Our version needs to be initialized
4505 once and after each call to `tzset' with TZ changed. That is
4506 accomplished by aliasing tzset to init_gettimeofday. */
4508 static struct tm time_rec
;
4511 gettimeofday (struct timeval
*tp
, struct timezone
*tzp
)
4519 if (t
.ti_hour
< time_rec
.tm_hour
) /* midnight wrap */
4523 time_rec
.tm_year
= d
.da_year
- 1900;
4524 time_rec
.tm_mon
= d
.da_mon
- 1;
4525 time_rec
.tm_mday
= d
.da_day
;
4528 time_rec
.tm_hour
= t
.ti_hour
;
4529 time_rec
.tm_min
= t
.ti_min
;
4530 time_rec
.tm_sec
= t
.ti_sec
;
4533 tm
.tm_gmtoff
= dos_timezone_offset
;
4535 tp
->tv_sec
= mktime (&tm
); /* may modify tm */
4536 tp
->tv_usec
= t
.ti_hund
* (1000000 / 100);
4538 /* Ignore tzp; it's obsolescent. */
4542 #endif /* __DJGPP__ < 2 */
4545 * A list of unimplemented functions that we silently ignore.
4549 unsigned alarm (s
) unsigned s
; {}
4550 fork () { return 0; }
4551 int kill (x
, y
) int x
, y
; { return -1; }
4553 void volatile pause () {}
4554 sigsetmask (x
) int x
; { return 0; }
4555 sigblock (mask
) int mask
; { return 0; }
4558 void request_sigio (void) {}
4559 setpgrp () {return 0; }
4560 setpriority (x
,y
,z
) int x
,y
,z
; { return 0; }
4561 void unrequest_sigio (void) {}
4565 #ifdef POSIX_SIGNALS
4567 /* Augment DJGPP library POSIX signal functions. This is needed
4568 as of DJGPP v2.01, but might be in the library in later releases. */
4570 #include <libc/bss.h>
4572 /* A counter to know when to re-initialize the static sets. */
4573 static int sigprocmask_count
= -1;
4575 /* Which signals are currently blocked (initially none). */
4576 static sigset_t current_mask
;
4578 /* Which signals are pending (initially none). */
4579 static sigset_t pending_signals
;
4581 /* Previous handlers to restore when the blocked signals are unblocked. */
4582 typedef void (*sighandler_t
)(int);
4583 static sighandler_t prev_handlers
[320];
4585 /* A signal handler which just records that a signal occured
4586 (it will be raised later, if and when the signal is unblocked). */
4588 sig_suspender (signo
)
4591 sigaddset (&pending_signals
, signo
);
4595 sigprocmask (how
, new_set
, old_set
)
4597 const sigset_t
*new_set
;
4603 /* If called for the first time, initialize. */
4604 if (sigprocmask_count
!= __bss_count
)
4606 sigprocmask_count
= __bss_count
;
4607 sigemptyset (&pending_signals
);
4608 sigemptyset (¤t_mask
);
4609 for (signo
= 0; signo
< 320; signo
++)
4610 prev_handlers
[signo
] = SIG_ERR
;
4614 *old_set
= current_mask
;
4619 if (how
!= SIG_BLOCK
&& how
!= SIG_UNBLOCK
&& how
!= SIG_SETMASK
)
4625 sigemptyset (&new_mask
);
4627 /* DJGPP supports upto 320 signals. */
4628 for (signo
= 0; signo
< 320; signo
++)
4630 if (sigismember (¤t_mask
, signo
))
4631 sigaddset (&new_mask
, signo
);
4632 else if (sigismember (new_set
, signo
) && how
!= SIG_UNBLOCK
)
4634 sigaddset (&new_mask
, signo
);
4636 /* SIGKILL is silently ignored, as on other platforms. */
4637 if (signo
!= SIGKILL
&& prev_handlers
[signo
] == SIG_ERR
)
4638 prev_handlers
[signo
] = signal (signo
, sig_suspender
);
4640 if (( how
== SIG_UNBLOCK
4641 && sigismember (&new_mask
, signo
)
4642 && sigismember (new_set
, signo
))
4643 || (how
== SIG_SETMASK
4644 && sigismember (&new_mask
, signo
)
4645 && !sigismember (new_set
, signo
)))
4647 sigdelset (&new_mask
, signo
);
4648 if (prev_handlers
[signo
] != SIG_ERR
)
4650 signal (signo
, prev_handlers
[signo
]);
4651 prev_handlers
[signo
] = SIG_ERR
;
4653 if (sigismember (&pending_signals
, signo
))
4655 sigdelset (&pending_signals
, signo
);
4660 current_mask
= new_mask
;
4664 #else /* not POSIX_SIGNALS */
4666 sigsetmask (x
) int x
; { return 0; }
4667 sigblock (mask
) int mask
; { return 0; }
4669 #endif /* not POSIX_SIGNALS */
4670 #endif /* __DJGPP__ > 1 */
4673 #include "sysselect.h"
4675 #ifndef EMACS_TIME_ZERO_OR_NEG_P
4676 #define EMACS_TIME_ZERO_OR_NEG_P(time) \
4677 ((long)(time).tv_sec < 0 \
4678 || ((time).tv_sec == 0 \
4679 && (long)(time).tv_usec <= 0))
4682 /* This yields the rest of the current time slice to the task manager.
4683 It should be called by any code which knows that it has nothing
4684 useful to do except idle.
4686 I don't use __dpmi_yield here, since versions of library before 2.02
4687 called Int 2Fh/AX=1680h there in a way that would wedge the DOS box
4688 on some versions of Windows 9X. */
4691 dos_yield_time_slice (void)
4693 _go32_dpmi_registers r
;
4696 r
.x
.ss
= r
.x
.sp
= r
.x
.flags
= 0;
4697 _go32_dpmi_simulate_int (0x2f, &r
);
4702 /* Only event queue is checked. */
4703 /* We don't have to call timer_check here
4704 because wait_reading_process_input takes care of that. */
4706 sys_select (nfds
, rfds
, wfds
, efds
, timeout
)
4708 SELECT_TYPE
*rfds
, *wfds
, *efds
;
4709 EMACS_TIME
*timeout
;
4717 check_input
= FD_ISSET (0, rfds
);
4728 /* If we are looking only for the terminal, with no timeout,
4729 just read it and wait -- that's more efficient. */
4732 while (!detect_input_pending ())
4734 dos_yield_time_slice ();
4739 EMACS_TIME clnow
, cllast
, cldiff
;
4742 EMACS_SET_SECS_USECS (cllast
, t
.ti_sec
, t
.ti_hund
* 10000L);
4744 while (!check_input
|| !detect_input_pending ())
4747 EMACS_SET_SECS_USECS (clnow
, t
.ti_sec
, t
.ti_hund
* 10000L);
4748 EMACS_SUB_TIME (cldiff
, clnow
, cllast
);
4750 /* When seconds wrap around, we assume that no more than
4751 1 minute passed since last `gettime'. */
4752 if (EMACS_TIME_NEG_P (cldiff
))
4753 EMACS_SET_SECS (cldiff
, EMACS_SECS (cldiff
) + 60);
4754 EMACS_SUB_TIME (*timeout
, *timeout
, cldiff
);
4756 /* Stop when timeout value crosses zero. */
4757 if (EMACS_TIME_ZERO_OR_NEG_P (*timeout
))
4760 dos_yield_time_slice ();
4770 * Define overlaid functions:
4772 * chdir -> sys_chdir
4773 * tzset -> init_gettimeofday
4774 * abort -> dos_abort
4779 extern int chdir ();
4785 int len
= strlen (path
);
4786 char *tmp
= (char *)path
;
4788 if (*tmp
&& tmp
[1] == ':')
4790 if (getdisk () != tolower (tmp
[0]) - 'a')
4791 setdisk (tolower (tmp
[0]) - 'a');
4792 tmp
+= 2; /* strip drive: KFS 1995-07-06 */
4796 if (len
> 1 && (tmp
[len
- 1] == '/'))
4798 char *tmp1
= (char *) alloca (len
+ 1);
4809 extern void tzset (void);
4812 init_gettimeofday ()
4818 ltm
= gtm
= time (NULL
);
4819 ltm
= mktime (lstm
= localtime (<m
));
4820 gtm
= mktime (gmtime (>m
));
4821 time_rec
.tm_hour
= 99; /* force gettimeofday to get date */
4822 time_rec
.tm_isdst
= lstm
->tm_isdst
;
4823 dos_timezone_offset
= time_rec
.tm_gmtoff
= (int)(gtm
- ltm
) / 60;
4830 dos_abort (file
, line
)
4834 char buffer1
[200], buffer2
[400];
4837 sprintf (buffer1
, "<EMACS FATAL ERROR IN %s LINE %d>", file
, line
);
4838 for (i
= j
= 0; buffer1
[i
]; i
++) {
4839 buffer2
[j
++] = buffer1
[i
];
4840 buffer2
[j
++] = 0x70;
4842 dosmemput (buffer2
, j
, (int)ScreenPrimary
);
4843 ScreenSetCursor (2, 0);
4851 ScreenSetCursor (10, 0);
4852 cputs ("\r\n\nEmacs aborted!\r\n");
4854 #if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
4855 if (screen_virtual_segment
)
4856 dosv_refresh_virtual_screen (2 * 10 * screen_size_X
, 4 * screen_size_X
);
4857 /* Generate traceback, so we could tell whodunit. */
4858 signal (SIGINT
, SIG_DFL
);
4859 __asm__
__volatile__ ("movb $0x1b,%al;call ___djgpp_hw_exception");
4860 #else /* __DJGPP_MINOR__ >= 2 */
4862 #endif /* __DJGPP_MINOR__ >= 2 */
4868 /* The following variables are required so that cus-start.el won't
4869 complain about unbound variables. */
4870 #ifndef HAVE_X_WINDOWS
4871 /* Search path for bitmap files (xfns.c). */
4872 Lisp_Object Vx_bitmap_file_path
;
4873 int x_stretch_cursor_p
;
4875 #ifndef subprocesses
4876 /* Nonzero means delete a process right away if it exits (process.c). */
4877 static int delete_exited_processes
;
4882 recent_doskeys
= Fmake_vector (make_number (NUM_RECENT_DOSKEYS
), Qnil
);
4883 staticpro (&recent_doskeys
);
4884 #ifndef HAVE_X_WINDOWS
4885 staticpro (&help_echo
);
4887 staticpro (&previous_help_echo
);
4888 previous_help_echo
= Qnil
;
4890 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
4891 "List of directories to search for bitmap files for X.");
4892 Vx_bitmap_file_path
= decode_env_path ((char *) 0, ".");
4894 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
4895 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
4896 For example, if a block cursor is over a tab, it will be drawn as\n\
4897 wide as that tab on the display. (No effect on MS-DOS.)");
4898 x_stretch_cursor_p
= 0;
4900 /* The following three are from xfns.c: */
4901 Qbackground_color
= intern ("background-color");
4902 staticpro (&Qbackground_color
);
4903 Qforeground_color
= intern ("foreground-color");
4904 staticpro (&Qforeground_color
);
4906 DEFVAR_LISP ("dos-unsupported-char-glyph", &Vdos_unsupported_char_glyph
,
4907 "*Glyph to display instead of chars not supported by current codepage.\n\
4909 This variable is used only by MSDOS terminals.");
4910 Vdos_unsupported_char_glyph
= '\177';
4912 #ifndef subprocesses
4913 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
4914 "*Non-nil means delete processes immediately when they exit.\n\
4915 nil means don't delete them until `list-processes' is run.");
4916 delete_exited_processes
= 0;
4919 defsubr (&Srecent_doskeys
);
4920 defsubr (&Smsdos_long_file_names
);
4921 defsubr (&Smsdos_downcase_filename
);
4922 defsubr (&Smsdos_remember_default_colors
);