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 "ý&‚\",(-Š_€…)= azertyuiop^$ qsdfghjklm—* wxcvbnm;:! ",
2350 /* 0123456789012345678901234567890123456789012345678901234 */
2351 " 1234567890ø+ AZERTYUIOPùœ 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'�< qwertyuiopŠ+> asdfghjkl•…— zxcvbnm,.- ",
2374 /* 01 23456789012345678901234567890123456789012345678901234 */
2375 "|!\"œ$%&/()=?^> QWERTYUIOP‚* ASDFGHJKL‡øõ ZXCVBNM;:_ ",
2376 /* 0123456789012345678901234567890123456789012345678901234 */
2378 it_kbd_translate_table
2381 static struct dos_keyboard_map dk_keyboard
= {
2383 /* 0123456789012345678901234567890123456789012345678901234 */
2384 "«1234567890+| qwertyuiop†~ asdfghjkl‘›' zxcvbnm,.- ",
2385 /* 01 23456789012345678901234567890123456789012345678901234 */
2386 "õ!\"#$%&/()=?` QWERTYUIOP�^ ASDFGHJKL’�* 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 prev_menu_help_message
= menu_help_message
;
3584 /* We are busy-waiting for the mouse to move, so let's be nice
3585 to other Windows applications by releasing our time slice. */
3588 for (b
= 0; b
< mouse_button_count
&& !leave
; b
++)
3590 /* Only leave if user both pressed and released the mouse, and in
3591 that order. This avoids popping down the menu pane unless
3592 the user is really done with it. */
3593 if (mouse_pressed (b
, &x
, &y
))
3595 while (mouse_button_depressed (b
, &x
, &y
))
3599 (void) mouse_released (b
, &x
, &y
);
3604 ScreenUpdate (state
[0].screen_behind
);
3605 if (screen_virtual_segment
)
3606 dosv_refresh_virtual_screen (0, screen_size
);
3608 while (statecount
--)
3609 xfree (state
[statecount
].screen_behind
);
3610 IT_display_cursor (1); /* turn cursor back on */
3611 /* Clean up any mouse events that are waiting inside Emacs event queue.
3612 These events are likely to be generated before the menu was even
3613 displayed, probably because the user pressed and released the button
3614 (which invoked the menu) too quickly. If we don't remove these events,
3615 Emacs will process them after we return and surprise the user. */
3616 discard_mouse_events ();
3617 /* Allow mouse events generation by dos_rawgetc. */
3622 /* Dispose of a menu. */
3625 XMenuDestroy (Display
*foo
, XMenu
*menu
)
3628 if (menu
->allocated
)
3630 for (i
= 0; i
< menu
->count
; i
++)
3631 if (menu
->submenu
[i
])
3632 XMenuDestroy (foo
, menu
->submenu
[i
]);
3634 xfree (menu
->submenu
);
3635 xfree (menu
->panenumber
);
3636 xfree (menu
->help_text
);
3639 menu_help_message
= prev_menu_help_message
= NULL
;
3643 x_pixel_width (struct frame
*f
)
3645 return FRAME_WIDTH (f
);
3649 x_pixel_height (struct frame
*f
)
3651 return FRAME_HEIGHT (f
);
3653 #endif /* !HAVE_X_WINDOWS */
3655 /* ----------------------- DOS / UNIX conversion --------------------- */
3657 void msdos_downcase_filename (unsigned char *);
3659 /* Destructively turn backslashes into slashes. */
3662 dostounix_filename (p
)
3665 msdos_downcase_filename (p
);
3675 /* Destructively turn slashes into backslashes. */
3678 unixtodos_filename (p
)
3681 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
3695 /* Get the default directory for a given drive. 0=def, 1=A, 2=B, ... */
3698 getdefdir (drive
, dst
)
3702 char in_path
[4], *p
= in_path
;
3705 /* Generate "X:." (when drive is X) or "." (when drive is 0). */
3708 *p
++ = drive
+ 'A' - 1;
3715 _fixpath (in_path
, dst
);
3716 /* _fixpath can set errno to ENOSYS on non-LFN systems because
3717 it queries the LFN support, so ignore that error. */
3718 if ((errno
&& errno
!= ENOSYS
) || *dst
== '\0')
3721 msdos_downcase_filename (dst
);
3727 /* Remove all CR's that are followed by a LF. */
3732 register unsigned char *buf
;
3734 unsigned char *np
= buf
;
3735 unsigned char *startp
= buf
;
3736 unsigned char *endp
= buf
+ n
;
3740 while (buf
< endp
- 1)
3744 if (*(++buf
) != 0x0a)
3755 #if defined(__DJGPP__) && __DJGPP__ == 2 && __DJGPP_MINOR__ == 0
3757 /* In DJGPP v2.0, library `write' can call `malloc', which might
3758 cause relocation of the buffer whose address we get in ADDR.
3759 Here is a version of `write' that avoids calling `malloc',
3760 to serve us until such time as the library is fixed.
3761 Actually, what we define here is called `__write', because
3762 `write' is a stub that just jmp's to `__write' (to be
3763 POSIXLY-correct with respect to the global name-space). */
3765 #include <io.h> /* for _write */
3766 #include <libc/dosio.h> /* for __file_handle_modes[] */
3768 static char xbuf
[64 * 1024]; /* DOS cannot write more in one chunk */
3770 #define XBUF_END (xbuf + sizeof (xbuf) - 1)
3773 __write (int handle
, const void *buffer
, size_t count
)
3778 if(__file_handle_modes
[handle
] & O_BINARY
)
3779 return _write (handle
, buffer
, count
);
3783 const char *bp
= buffer
;
3784 int total_written
= 0;
3785 int nmoved
= 0, ncr
= 0;
3789 /* The next test makes sure there's space for at least 2 more
3790 characters in xbuf[], so both CR and LF can be put there. */
3802 if (xbp
>= XBUF_END
|| !count
)
3804 size_t to_write
= nmoved
+ ncr
;
3805 int written
= _write (handle
, xbuf
, to_write
);
3810 total_written
+= nmoved
; /* CRs aren't counted in ret value */
3812 /* If some, but not all were written (disk full?), return
3813 an estimate of the total written bytes not counting CRs. */
3814 if (written
< to_write
)
3815 return total_written
- (to_write
- written
) * nmoved
/to_write
;
3822 return total_written
;
3826 /* A low-level file-renaming function which works around Windows 95 bug.
3827 This is pulled directly out of DJGPP v2.01 library sources, and only
3828 used when you compile with DJGPP v2.0. */
3832 int _rename(const char *old
, const char *new)
3835 int olen
= strlen(old
) + 1;
3837 int use_lfn
= _USE_LFN
;
3838 char tempfile
[FILENAME_MAX
];
3839 const char *orig
= old
;
3842 r
.x
.dx
= __tb_offset
;
3843 r
.x
.di
= __tb_offset
+ olen
;
3844 r
.x
.ds
= r
.x
.es
= __tb_segment
;
3848 /* Windows 95 bug: for some filenames, when you rename
3849 file -> file~ (as in Emacs, to leave a backup), the
3850 short 8+3 alias doesn't change, which effectively
3851 makes OLD and NEW the same file. We must rename
3852 through a temporary file to work around this. */
3854 char *pbase
= 0, *p
;
3855 static char try_char
[] = "abcdefghijklmnopqrstuvwxyz012345789";
3856 int idx
= sizeof(try_char
) - 1;
3858 /* Generate a temporary name. Can't use `tmpnam', since $TMPDIR
3859 might point to another drive, which will fail the DOS call. */
3860 strcpy(tempfile
, old
);
3861 for (p
= tempfile
; *p
; p
++) /* ensure temporary is on the same drive */
3862 if (*p
== '/' || *p
== '\\' || *p
== ':')
3868 strcpy(pbase
, "X$$djren$$.$$temp$$");
3874 *pbase
= try_char
[--idx
];
3875 } while (_chmod(tempfile
, 0) != -1);
3878 _put_path2(tempfile
, olen
);
3880 __dpmi_int(0x21, &r
);
3883 errno
= __doserr_to_errno(r
.x
.ax
);
3887 /* Now create a file with the original name. This will
3888 ensure that NEW will always have a 8+3 alias
3889 different from that of OLD. (Seems to be required
3890 when NameNumericTail in the Registry is set to 0.) */
3891 lfn_fd
= _creat(old
, 0);
3893 olen
= strlen(tempfile
) + 1;
3895 r
.x
.di
= __tb_offset
+ olen
;
3904 _put_path2(new, olen
);
3906 __dpmi_int(0x21, &r
);
3909 if (r
.x
.ax
== 5 && i
== 0) /* access denied */
3910 remove(new); /* and try again */
3913 errno
= __doserr_to_errno(r
.x
.ax
);
3915 /* Restore to original name if we renamed it to temporary. */
3923 _put_path2(orig
, olen
);
3924 _put_path(tempfile
);
3926 __dpmi_int(0x21, &r
);
3935 /* Success. Delete the file possibly created to work
3936 around the Windows 95 bug. */
3938 return (_close (lfn_fd
) == 0) ? remove (orig
) : -1;
3942 #endif /* __DJGPP__ == 2 && __DJGPP_MINOR__ == 0 */
3944 DEFUN ("msdos-long-file-names", Fmsdos_long_file_names
, Smsdos_long_file_names
,
3946 "Return non-nil if long file names are supported on MSDOS.")
3949 return (_USE_LFN
? Qt
: Qnil
);
3952 /* Convert alphabetic characters in a filename to lower-case. */
3955 msdos_downcase_filename (p
)
3956 register unsigned char *p
;
3958 /* Always lower-case drive letters a-z, even if the filesystem
3959 preserves case in filenames.
3960 This is so MSDOS filenames could be compared by string comparison
3961 functions that are case-sensitive. Even case-preserving filesystems
3962 do not distinguish case in drive letters. */
3963 if (p
[1] == ':' && *p
>= 'A' && *p
<= 'Z')
3969 /* Under LFN we expect to get pathnames in their true case. */
3970 if (NILP (Fmsdos_long_file_names ()))
3972 if (*p
>= 'A' && *p
<= 'Z')
3976 DEFUN ("msdos-downcase-filename", Fmsdos_downcase_filename
, Smsdos_downcase_filename
,
3978 "Convert alphabetic characters in FILENAME to lower case and return that.\n\
3979 When long filenames are supported, doesn't change FILENAME.\n\
3980 If FILENAME is not a string, returns nil.\n\
3981 The argument object is never altered--the value is a copy.")
3983 Lisp_Object filename
;
3987 if (! STRINGP (filename
))
3990 tem
= Fcopy_sequence (filename
);
3991 msdos_downcase_filename (XSTRING (tem
)->data
);
3995 /* The Emacs root directory as determined by init_environment. */
3997 static char emacsroot
[MAXPATHLEN
];
4000 rootrelativepath (rel
)
4003 static char result
[MAXPATHLEN
+ 10];
4005 strcpy (result
, emacsroot
);
4006 strcat (result
, "/");
4007 strcat (result
, rel
);
4011 /* Define a lot of environment variables if not already defined. Don't
4012 remove anything unless you know what you're doing -- lots of code will
4013 break if one or more of these are missing. */
4016 init_environment (argc
, argv
, skip_args
)
4023 static const char * const tempdirs
[] = {
4024 "$TMPDIR", "$TEMP", "$TMP", "c:/"
4027 const int imax
= sizeof (tempdirs
) / sizeof (tempdirs
[0]);
4029 /* Make sure they have a usable $TMPDIR. Many Emacs functions use
4030 temporary files and assume "/tmp" if $TMPDIR is unset, which
4031 will break on DOS/Windows. Refuse to work if we cannot find
4032 a directory, not even "c:/", usable for that purpose. */
4033 for (i
= 0; i
< imax
; i
++)
4035 const char *tmp
= tempdirs
[i
];
4038 tmp
= getenv (tmp
+ 1);
4039 /* Note that `access' can lie to us if the directory resides on a
4040 read-only filesystem, like CD-ROM or a write-protected floppy.
4041 The only way to be really sure is to actually create a file and
4042 see if it succeeds. But I think that's too much to ask. */
4043 if (tmp
&& access (tmp
, D_OK
) == 0)
4045 setenv ("TMPDIR", tmp
, 1);
4052 Fcons (build_string ("no usable temporary directories found!!"),
4054 "While setting TMPDIR: ");
4056 /* Note the startup time, so we know not to clear the screen if we
4057 exit immediately; see IT_reset_terminal_modes.
4058 (Yes, I know `clock' returns zero the first time it's called, but
4059 I do this anyway, in case some wiseguy changes that at some point.) */
4060 startup_time
= clock ();
4062 /* Find our root from argv[0]. Assuming argv[0] is, say,
4063 "c:/emacs/bin/emacs.exe" our root will be "c:/emacs". */
4064 root
= alloca (MAXPATHLEN
+ 20);
4065 _fixpath (argv
[0], root
);
4066 msdos_downcase_filename (root
);
4067 len
= strlen (root
);
4068 while (len
> 0 && root
[len
] != '/' && root
[len
] != ':')
4072 && (strcmp (root
+ len
- 4, "/bin") == 0
4073 || strcmp (root
+ len
- 4, "/src") == 0)) /* under a debugger */
4074 root
[len
- 4] = '\0';
4076 strcpy (root
, "c:/emacs"); /* let's be defensive */
4077 len
= strlen (root
);
4078 strcpy (emacsroot
, root
);
4080 /* We default HOME to our root. */
4081 setenv ("HOME", root
, 0);
4083 /* We default EMACSPATH to root + "/bin". */
4084 strcpy (root
+ len
, "/bin");
4085 setenv ("EMACSPATH", root
, 0);
4087 /* I don't expect anybody to ever use other terminals so the internal
4088 terminal is the default. */
4089 setenv ("TERM", "internal", 0);
4091 #ifdef HAVE_X_WINDOWS
4092 /* Emacs expects DISPLAY to be set. */
4093 setenv ("DISPLAY", "unix:0.0", 0);
4096 /* SHELL is a bit tricky -- COMSPEC is the closest we come, but we must
4097 downcase it and mirror the backslashes. */
4098 s
= getenv ("COMSPEC");
4099 if (!s
) s
= "c:/command.com";
4100 t
= alloca (strlen (s
) + 1);
4102 dostounix_filename (t
);
4103 setenv ("SHELL", t
, 0);
4105 /* PATH is also downcased and backslashes mirrored. */
4106 s
= getenv ("PATH");
4108 t
= alloca (strlen (s
) + 3);
4109 /* Current directory is always considered part of MsDos's path but it is
4110 not normally mentioned. Now it is. */
4111 strcat (strcpy (t
, ".;"), s
);
4112 dostounix_filename (t
); /* Not a single file name, but this should work. */
4113 setenv ("PATH", t
, 1);
4115 /* In some sense all dos users have root privileges, so... */
4116 setenv ("USER", "root", 0);
4117 setenv ("NAME", getenv ("USER"), 0);
4119 /* Time zone determined from country code. To make this possible, the
4120 country code may not span more than one time zone. In other words,
4121 in the USA, you lose. */
4123 switch (dos_country_code
)
4125 case 31: /* Belgium */
4126 case 32: /* The Netherlands */
4127 case 33: /* France */
4128 case 34: /* Spain */
4129 case 36: /* Hungary */
4130 case 38: /* Yugoslavia (or what's left of it?) */
4131 case 39: /* Italy */
4132 case 41: /* Switzerland */
4133 case 42: /* Tjekia */
4134 case 45: /* Denmark */
4135 case 46: /* Sweden */
4136 case 47: /* Norway */
4137 case 48: /* Poland */
4138 case 49: /* Germany */
4139 /* Daylight saving from last Sunday in March to last Sunday in
4140 September, both at 2AM. */
4141 setenv ("TZ", "MET-01METDST-02,M3.5.0/02:00,M9.5.0/02:00", 0);
4143 case 44: /* United Kingdom */
4144 case 351: /* Portugal */
4145 case 354: /* Iceland */
4146 setenv ("TZ", "GMT+00", 0);
4148 case 81: /* Japan */
4149 case 82: /* Korea */
4150 setenv ("TZ", "JST-09", 0);
4152 case 90: /* Turkey */
4153 case 358: /* Finland */
4154 setenv ("TZ", "EET-02", 0);
4156 case 972: /* Israel */
4157 /* This is an approximation. (For exact rules, use the
4158 `zoneinfo/israel' file which comes with DJGPP, but you need
4159 to install it in `/usr/share/zoneinfo/' directory first.) */
4160 setenv ("TZ", "IST-02IDT-03,M4.1.6/00:00,M9.5.6/01:00", 0);
4168 static int break_stat
; /* BREAK check mode status. */
4169 static int stdin_stat
; /* stdin IOCTL status. */
4173 /* These must be global. */
4174 static _go32_dpmi_seginfo ctrl_break_vector
;
4175 static _go32_dpmi_registers ctrl_break_regs
;
4176 static int ctrlbreakinstalled
= 0;
4178 /* Interrupt level detection of Ctrl-Break. Don't do anything fancy here! */
4181 ctrl_break_func (regs
)
4182 _go32_dpmi_registers
*regs
;
4188 install_ctrl_break_check ()
4190 if (!ctrlbreakinstalled
)
4192 /* Don't press Ctrl-Break if you don't have either DPMI or Emacs
4193 was compiler with Djgpp 1.11 maintenance level 5 or later! */
4194 ctrlbreakinstalled
= 1;
4195 ctrl_break_vector
.pm_offset
= (int) ctrl_break_func
;
4196 _go32_dpmi_allocate_real_mode_callback_iret (&ctrl_break_vector
,
4198 _go32_dpmi_set_real_mode_interrupt_vector (0x1b, &ctrl_break_vector
);
4202 #endif /* __DJGPP__ < 2 */
4204 /* Turn off Dos' Ctrl-C checking and inhibit interpretation of
4205 control chars by DOS. Determine the keyboard type. */
4210 union REGS inregs
, outregs
;
4211 static int first_time
= 1;
4213 break_stat
= getcbrk ();
4216 install_ctrl_break_check ();
4222 int86 (0x15, &inregs
, &outregs
);
4223 extended_kbd
= (!outregs
.x
.cflag
) && (outregs
.h
.ah
== 0);
4227 if (internal_terminal
4228 #ifdef HAVE_X_WINDOWS
4229 && inhibit_window_system
4233 inregs
.x
.ax
= 0x0021;
4234 int86 (0x33, &inregs
, &outregs
);
4235 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4238 /* Reportedly, the above doesn't work for some mouse drivers. There
4239 is an additional detection method that should work, but might be
4240 a little slower. Use that as an alternative. */
4241 inregs
.x
.ax
= 0x0000;
4242 int86 (0x33, &inregs
, &outregs
);
4243 have_mouse
= (outregs
.x
.ax
& 0xffff) == 0xffff;
4248 have_mouse
= 1; /* enable mouse */
4251 if (outregs
.x
.bx
== 3)
4253 mouse_button_count
= 3;
4254 mouse_button_translate
[0] = 0; /* Left */
4255 mouse_button_translate
[1] = 2; /* Middle */
4256 mouse_button_translate
[2] = 1; /* Right */
4260 mouse_button_count
= 2;
4261 mouse_button_translate
[0] = 0;
4262 mouse_button_translate
[1] = 1;
4264 mouse_position_hook
= &mouse_get_pos
;
4273 stdin_stat
= setmode (fileno (stdin
), O_BINARY
);
4274 return (stdin_stat
!= -1);
4277 return (setmode (fileno (stdin
), O_BINARY
) != -1);
4279 #else /* __DJGPP__ < 2 */
4283 /* I think it is wrong to overwrite `stdin_stat' every time
4284 but the first one this function is called, but I don't
4285 want to change the way it used to work in v1.x.--EZ */
4287 inregs
.x
.ax
= 0x4400; /* Get IOCTL status. */
4288 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4289 intdos (&inregs
, &outregs
);
4290 stdin_stat
= outregs
.h
.dl
;
4292 inregs
.x
.dx
= stdin_stat
| 0x0020; /* raw mode */
4293 inregs
.x
.ax
= 0x4401; /* Set IOCTL status */
4294 intdos (&inregs
, &outregs
);
4295 return !outregs
.x
.cflag
;
4297 #endif /* __DJGPP__ < 2 */
4300 /* Restore status of standard input and Ctrl-C checking. */
4305 union REGS inregs
, outregs
;
4307 setcbrk (break_stat
);
4312 return (setmode (fileno (stdin
), stdin_stat
) != -1);
4314 #else /* not __DJGPP__ >= 2 */
4316 inregs
.x
.ax
= 0x4401; /* Set IOCTL status. */
4317 inregs
.x
.bx
= 0x00; /* 0 = stdin. */
4318 inregs
.x
.dx
= stdin_stat
;
4319 intdos (&inregs
, &outregs
);
4320 return !outregs
.x
.cflag
;
4322 #endif /* not __DJGPP__ >= 2 */
4326 /* Run command as specified by ARGV in directory DIR.
4327 The command is run with input from TEMPIN, output to
4328 file TEMPOUT and stderr to TEMPERR. */
4331 run_msdos_command (argv
, working_dir
, tempin
, tempout
, temperr
, envv
)
4332 unsigned char **argv
;
4333 const char *working_dir
;
4334 int tempin
, tempout
, temperr
;
4337 char *saveargv1
, *saveargv2
, *lowcase_argv0
, *pa
, *pl
;
4338 char oldwd
[MAXPATHLEN
+ 1]; /* Fixed size is safe on MSDOS. */
4339 int msshell
, result
= -1;
4340 int inbak
, outbak
, errbak
;
4344 /* Get current directory as MSDOS cwd is not per-process. */
4347 /* If argv[0] is the shell, it might come in any lettercase.
4348 Since `Fmember' is case-sensitive, we need to downcase
4349 argv[0], even if we are on case-preserving filesystems. */
4350 lowcase_argv0
= alloca (strlen (argv
[0]) + 1);
4351 for (pa
= argv
[0], pl
= lowcase_argv0
; *pa
; pl
++)
4354 if (*pl
>= 'A' && *pl
<= 'Z')
4359 cmd
= Ffile_name_nondirectory (build_string (lowcase_argv0
));
4360 msshell
= !NILP (Fmember (cmd
, Fsymbol_value (intern ("msdos-shells"))))
4361 && !strcmp ("-c", argv
[1]);
4364 saveargv1
= argv
[1];
4365 saveargv2
= argv
[2];
4369 char *p
= alloca (strlen (argv
[2]) + 1);
4371 strcpy (argv
[2] = p
, saveargv2
);
4372 while (*p
&& isspace (*p
))
4374 while (*p
&& !isspace (*p
))
4382 chdir (working_dir
);
4386 if (inbak
< 0 || outbak
< 0 || errbak
< 0)
4387 goto done
; /* Allocation might fail due to lack of descriptors. */
4390 mouse_get_xy (&x
, &y
);
4392 dos_ttcooked (); /* do it here while 0 = stdin */
4400 if (msshell
&& !argv
[3])
4402 /* MS-DOS native shells are too restrictive. For starters, they
4403 cannot grok commands longer than 126 characters. In DJGPP v2
4404 and later, `system' is much smarter, so we'll call it instead. */
4408 /* A shell gets a single argument--its full command
4409 line--whose original was saved in `saveargv2'. */
4411 /* Don't let them pass empty command lines to `system', since
4412 with some shells it will try to invoke an interactive shell,
4413 which will hang Emacs. */
4414 for (cmnd
= saveargv2
; *cmnd
&& isspace (*cmnd
); cmnd
++)
4418 extern char **environ
;
4419 int save_system_flags
= __system_flags
;
4421 /* Request the most powerful version of `system'. We need
4422 all the help we can get to avoid calling stock DOS shells. */
4423 __system_flags
= (__system_redirect
4424 | __system_use_shell
4425 | __system_allow_multiple_cmds
4426 | __system_allow_long_cmds
4427 | __system_handle_null_commands
4428 | __system_emulate_chdir
);
4431 result
= system (cmnd
);
4432 __system_flags
= save_system_flags
;
4435 result
= 0; /* emulate Unixy shell behavior with empty cmd line */
4439 #endif /* __DJGPP__ > 1 */
4441 result
= spawnve (P_WAIT
, argv
[0], argv
, envv
);
4446 emacs_close (inbak
);
4447 emacs_close (outbak
);
4448 emacs_close (errbak
);
4454 mouse_moveto (x
, y
);
4457 /* Some programs might change the meaning of the highest bit of the
4458 text attribute byte, so we get blinking characters instead of the
4459 bright background colors. Restore that. */
4466 argv
[1] = saveargv1
;
4467 argv
[2] = saveargv2
;
4475 fprintf (stderr
, "%s not yet implemented\r\n", badfunc
);
4482 /* ------------------------- Compatibility functions -------------------
4487 /* Hostnames for a pc are not really funny,
4488 but they are used in change log so we emulate the best we can. */
4490 gethostname (p
, size
)
4494 char *q
= egetenv ("HOSTNAME");
4501 /* When time zones are set from Ms-Dos too many C-libraries are playing
4502 tricks with time values. We solve this by defining our own version
4503 of `gettimeofday' bypassing GO32. Our version needs to be initialized
4504 once and after each call to `tzset' with TZ changed. That is
4505 accomplished by aliasing tzset to init_gettimeofday. */
4507 static struct tm time_rec
;
4510 gettimeofday (struct timeval
*tp
, struct timezone
*tzp
)
4518 if (t
.ti_hour
< time_rec
.tm_hour
) /* midnight wrap */
4522 time_rec
.tm_year
= d
.da_year
- 1900;
4523 time_rec
.tm_mon
= d
.da_mon
- 1;
4524 time_rec
.tm_mday
= d
.da_day
;
4527 time_rec
.tm_hour
= t
.ti_hour
;
4528 time_rec
.tm_min
= t
.ti_min
;
4529 time_rec
.tm_sec
= t
.ti_sec
;
4532 tm
.tm_gmtoff
= dos_timezone_offset
;
4534 tp
->tv_sec
= mktime (&tm
); /* may modify tm */
4535 tp
->tv_usec
= t
.ti_hund
* (1000000 / 100);
4537 /* Ignore tzp; it's obsolescent. */
4541 #endif /* __DJGPP__ < 2 */
4544 * A list of unimplemented functions that we silently ignore.
4548 unsigned alarm (s
) unsigned s
; {}
4549 fork () { return 0; }
4550 int kill (x
, y
) int x
, y
; { return -1; }
4552 void volatile pause () {}
4553 sigsetmask (x
) int x
; { return 0; }
4554 sigblock (mask
) int mask
; { return 0; }
4557 void request_sigio (void) {}
4558 setpgrp () {return 0; }
4559 setpriority (x
,y
,z
) int x
,y
,z
; { return 0; }
4560 void unrequest_sigio (void) {}
4564 #ifdef POSIX_SIGNALS
4566 /* Augment DJGPP library POSIX signal functions. This is needed
4567 as of DJGPP v2.01, but might be in the library in later releases. */
4569 #include <libc/bss.h>
4571 /* A counter to know when to re-initialize the static sets. */
4572 static int sigprocmask_count
= -1;
4574 /* Which signals are currently blocked (initially none). */
4575 static sigset_t current_mask
;
4577 /* Which signals are pending (initially none). */
4578 static sigset_t pending_signals
;
4580 /* Previous handlers to restore when the blocked signals are unblocked. */
4581 typedef void (*sighandler_t
)(int);
4582 static sighandler_t prev_handlers
[320];
4584 /* A signal handler which just records that a signal occured
4585 (it will be raised later, if and when the signal is unblocked). */
4587 sig_suspender (signo
)
4590 sigaddset (&pending_signals
, signo
);
4594 sigprocmask (how
, new_set
, old_set
)
4596 const sigset_t
*new_set
;
4602 /* If called for the first time, initialize. */
4603 if (sigprocmask_count
!= __bss_count
)
4605 sigprocmask_count
= __bss_count
;
4606 sigemptyset (&pending_signals
);
4607 sigemptyset (¤t_mask
);
4608 for (signo
= 0; signo
< 320; signo
++)
4609 prev_handlers
[signo
] = SIG_ERR
;
4613 *old_set
= current_mask
;
4618 if (how
!= SIG_BLOCK
&& how
!= SIG_UNBLOCK
&& how
!= SIG_SETMASK
)
4624 sigemptyset (&new_mask
);
4626 /* DJGPP supports upto 320 signals. */
4627 for (signo
= 0; signo
< 320; signo
++)
4629 if (sigismember (¤t_mask
, signo
))
4630 sigaddset (&new_mask
, signo
);
4631 else if (sigismember (new_set
, signo
) && how
!= SIG_UNBLOCK
)
4633 sigaddset (&new_mask
, signo
);
4635 /* SIGKILL is silently ignored, as on other platforms. */
4636 if (signo
!= SIGKILL
&& prev_handlers
[signo
] == SIG_ERR
)
4637 prev_handlers
[signo
] = signal (signo
, sig_suspender
);
4639 if (( how
== SIG_UNBLOCK
4640 && sigismember (&new_mask
, signo
)
4641 && sigismember (new_set
, signo
))
4642 || (how
== SIG_SETMASK
4643 && sigismember (&new_mask
, signo
)
4644 && !sigismember (new_set
, signo
)))
4646 sigdelset (&new_mask
, signo
);
4647 if (prev_handlers
[signo
] != SIG_ERR
)
4649 signal (signo
, prev_handlers
[signo
]);
4650 prev_handlers
[signo
] = SIG_ERR
;
4652 if (sigismember (&pending_signals
, signo
))
4654 sigdelset (&pending_signals
, signo
);
4659 current_mask
= new_mask
;
4663 #else /* not POSIX_SIGNALS */
4665 sigsetmask (x
) int x
; { return 0; }
4666 sigblock (mask
) int mask
; { return 0; }
4668 #endif /* not POSIX_SIGNALS */
4669 #endif /* __DJGPP__ > 1 */
4672 #include "sysselect.h"
4674 #ifndef EMACS_TIME_ZERO_OR_NEG_P
4675 #define EMACS_TIME_ZERO_OR_NEG_P(time) \
4676 ((long)(time).tv_sec < 0 \
4677 || ((time).tv_sec == 0 \
4678 && (long)(time).tv_usec <= 0))
4681 /* This yields the rest of the current time slice to the task manager.
4682 It should be called by any code which knows that it has nothing
4683 useful to do except idle.
4685 I don't use __dpmi_yield here, since versions of library before 2.02
4686 called Int 2Fh/AX=1680h there in a way that would wedge the DOS box
4687 on some versions of Windows 9X. */
4690 dos_yield_time_slice (void)
4692 _go32_dpmi_registers r
;
4695 r
.x
.ss
= r
.x
.sp
= r
.x
.flags
= 0;
4696 _go32_dpmi_simulate_int (0x2f, &r
);
4701 /* Only event queue is checked. */
4702 /* We don't have to call timer_check here
4703 because wait_reading_process_input takes care of that. */
4705 sys_select (nfds
, rfds
, wfds
, efds
, timeout
)
4707 SELECT_TYPE
*rfds
, *wfds
, *efds
;
4708 EMACS_TIME
*timeout
;
4716 check_input
= FD_ISSET (0, rfds
);
4727 /* If we are looking only for the terminal, with no timeout,
4728 just read it and wait -- that's more efficient. */
4731 while (!detect_input_pending ())
4733 dos_yield_time_slice ();
4738 EMACS_TIME clnow
, cllast
, cldiff
;
4741 EMACS_SET_SECS_USECS (cllast
, t
.ti_sec
, t
.ti_hund
* 10000L);
4743 while (!check_input
|| !detect_input_pending ())
4746 EMACS_SET_SECS_USECS (clnow
, t
.ti_sec
, t
.ti_hund
* 10000L);
4747 EMACS_SUB_TIME (cldiff
, clnow
, cllast
);
4749 /* When seconds wrap around, we assume that no more than
4750 1 minute passed since last `gettime'. */
4751 if (EMACS_TIME_NEG_P (cldiff
))
4752 EMACS_SET_SECS (cldiff
, EMACS_SECS (cldiff
) + 60);
4753 EMACS_SUB_TIME (*timeout
, *timeout
, cldiff
);
4755 /* Stop when timeout value crosses zero. */
4756 if (EMACS_TIME_ZERO_OR_NEG_P (*timeout
))
4759 dos_yield_time_slice ();
4769 * Define overlaid functions:
4771 * chdir -> sys_chdir
4772 * tzset -> init_gettimeofday
4773 * abort -> dos_abort
4778 extern int chdir ();
4784 int len
= strlen (path
);
4785 char *tmp
= (char *)path
;
4787 if (*tmp
&& tmp
[1] == ':')
4789 if (getdisk () != tolower (tmp
[0]) - 'a')
4790 setdisk (tolower (tmp
[0]) - 'a');
4791 tmp
+= 2; /* strip drive: KFS 1995-07-06 */
4795 if (len
> 1 && (tmp
[len
- 1] == '/'))
4797 char *tmp1
= (char *) alloca (len
+ 1);
4808 extern void tzset (void);
4811 init_gettimeofday ()
4817 ltm
= gtm
= time (NULL
);
4818 ltm
= mktime (lstm
= localtime (<m
));
4819 gtm
= mktime (gmtime (>m
));
4820 time_rec
.tm_hour
= 99; /* force gettimeofday to get date */
4821 time_rec
.tm_isdst
= lstm
->tm_isdst
;
4822 dos_timezone_offset
= time_rec
.tm_gmtoff
= (int)(gtm
- ltm
) / 60;
4829 dos_abort (file
, line
)
4833 char buffer1
[200], buffer2
[400];
4836 sprintf (buffer1
, "<EMACS FATAL ERROR IN %s LINE %d>", file
, line
);
4837 for (i
= j
= 0; buffer1
[i
]; i
++) {
4838 buffer2
[j
++] = buffer1
[i
];
4839 buffer2
[j
++] = 0x70;
4841 dosmemput (buffer2
, j
, (int)ScreenPrimary
);
4842 ScreenSetCursor (2, 0);
4850 ScreenSetCursor (10, 0);
4851 cputs ("\r\n\nEmacs aborted!\r\n");
4853 #if __DJGPP__ == 2 && __DJGPP_MINOR__ < 2
4854 if (screen_virtual_segment
)
4855 dosv_refresh_virtual_screen (2 * 10 * screen_size_X
, 4 * screen_size_X
);
4856 /* Generate traceback, so we could tell whodunit. */
4857 signal (SIGINT
, SIG_DFL
);
4858 __asm__
__volatile__ ("movb $0x1b,%al;call ___djgpp_hw_exception");
4859 #else /* __DJGPP_MINOR__ >= 2 */
4861 #endif /* __DJGPP_MINOR__ >= 2 */
4867 /* The following variables are required so that cus-start.el won't
4868 complain about unbound variables. */
4869 #ifndef HAVE_X_WINDOWS
4870 /* Search path for bitmap files (xfns.c). */
4871 Lisp_Object Vx_bitmap_file_path
;
4872 int x_stretch_cursor_p
;
4874 #ifndef subprocesses
4875 /* Nonzero means delete a process right away if it exits (process.c). */
4876 static int delete_exited_processes
;
4881 recent_doskeys
= Fmake_vector (make_number (NUM_RECENT_DOSKEYS
), Qnil
);
4882 staticpro (&recent_doskeys
);
4883 #ifndef HAVE_X_WINDOWS
4884 staticpro (&help_echo
);
4886 staticpro (&previous_help_echo
);
4887 previous_help_echo
= Qnil
;
4889 DEFVAR_LISP ("x-bitmap-file-path", &Vx_bitmap_file_path
,
4890 "List of directories to search for bitmap files for X.");
4891 Vx_bitmap_file_path
= decode_env_path ((char *) 0, ".");
4893 DEFVAR_BOOL ("x-stretch-cursor", &x_stretch_cursor_p
,
4894 "*Non-nil means draw block cursor as wide as the glyph under it.\n\
4895 For example, if a block cursor is over a tab, it will be drawn as\n\
4896 wide as that tab on the display. (No effect on MS-DOS.)");
4897 x_stretch_cursor_p
= 0;
4899 /* The following three are from xfns.c: */
4900 Qbackground_color
= intern ("background-color");
4901 staticpro (&Qbackground_color
);
4902 Qforeground_color
= intern ("foreground-color");
4903 staticpro (&Qforeground_color
);
4905 DEFVAR_LISP ("dos-unsupported-char-glyph", &Vdos_unsupported_char_glyph
,
4906 "*Glyph to display instead of chars not supported by current codepage.\n\
4908 This variable is used only by MSDOS terminals.");
4909 Vdos_unsupported_char_glyph
= '\177';
4911 #ifndef subprocesses
4912 DEFVAR_BOOL ("delete-exited-processes", &delete_exited_processes
,
4913 "*Non-nil means delete processes immediately when they exit.\n\
4914 nil means don't delete them until `list-processes' is run.");
4915 delete_exited_processes
= 0;
4918 defsubr (&Srecent_doskeys
);
4919 defsubr (&Smsdos_long_file_names
);
4920 defsubr (&Smsdos_downcase_filename
);
4921 defsubr (&Smsdos_remember_default_colors
);