1 /* Terminal control module for terminals described by TERMCAP
2 Copyright (C) 1985-1987, 1993-1995, 1998, 2000-2014 Free Software
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or
10 (at your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
20 /* New redisplay, TTY faces by Gerd Moellmann <gerd@gnu.org>. */
33 #include "character.h"
37 #include "composite.h"
41 #include "termhooks.h"
42 #include "dispextern.h"
45 #include "blockinput.h"
46 #include "syssignal.h"
48 #include "intervals.h"
51 static int been_here
= -1;
55 #include "../lwlib/lwlib.h"
65 /* The name of the default console device. */
67 #define DEV_TTY "CONOUT$"
70 #define DEV_TTY "/dev/tty"
73 static void tty_set_scroll_region (struct frame
*f
, int start
, int stop
);
74 static void turn_on_face (struct frame
*, int face_id
);
75 static void turn_off_face (struct frame
*, int face_id
);
76 static void tty_turn_off_highlight (struct tty_display_info
*);
77 static void tty_show_cursor (struct tty_display_info
*);
78 static void tty_hide_cursor (struct tty_display_info
*);
79 static void tty_background_highlight (struct tty_display_info
*tty
);
80 static struct terminal
*get_tty_terminal (Lisp_Object
, bool);
81 static void clear_tty_hooks (struct terminal
*terminal
);
82 static void set_tty_hooks (struct terminal
*terminal
);
83 static void dissociate_if_controlling_tty (int fd
);
84 static void delete_tty (struct terminal
*);
85 static _Noreturn
void maybe_fatal (bool, struct terminal
*,
86 const char *, const char *, ...)
87 ATTRIBUTE_FORMAT_PRINTF (3, 5) ATTRIBUTE_FORMAT_PRINTF (4, 5);
88 static _Noreturn
void vfatal (const char *str
, va_list ap
)
89 ATTRIBUTE_FORMAT_PRINTF (1, 0);
92 #define OUTPUT(tty, a) \
93 emacs_tputs ((tty), a, \
94 FRAME_TOTAL_LINES (XFRAME (selected_frame)) - curY (tty), \
97 #define OUTPUT1(tty, a) emacs_tputs ((tty), a, 1, cmputc)
98 #define OUTPUTL(tty, a, lines) emacs_tputs ((tty), a, lines, cmputc)
100 #define OUTPUT_IF(tty, a) \
106 #define OUTPUT1_IF(tty, a) do { if (a) emacs_tputs ((tty), a, 1, cmputc); } while (0)
108 /* Display space properties. */
110 /* Chain of all tty device parameters. */
111 struct tty_display_info
*tty_list
;
113 /* Meaning of bits in no_color_video. Each bit set means that the
114 corresponding attribute cannot be combined with colors. */
118 NC_STANDOUT
= 1 << 0,
119 NC_UNDERLINE
= 1 << 1,
130 /* The largest frame width in any call to calculate_costs. */
132 static int max_frame_cols
;
134 static Lisp_Object Qtty_mode_set_strings
;
135 static Lisp_Object Qtty_mode_reset_strings
;
140 #include <sys/fcntl.h>
142 /* The device for which we have enabled gpm support (or NULL). */
143 struct tty_display_info
*gpm_tty
= NULL
;
145 /* Last recorded mouse coordinates. */
146 static int last_mouse_x
, last_mouse_y
;
147 #endif /* HAVE_GPM */
149 /* Ring the bell on a tty. */
152 tty_ring_bell (struct frame
*f
)
154 struct tty_display_info
*tty
= FRAME_TTY (f
);
158 OUTPUT (tty
, (tty
->TS_visible_bell
&& visible_bell
159 ? tty
->TS_visible_bell
161 fflush (tty
->output
);
165 /* Set up termcap modes for Emacs. */
168 tty_send_additional_strings (struct terminal
*terminal
, Lisp_Object sym
)
170 Lisp_Object lisp_terminal
;
171 Lisp_Object extra_codes
;
172 struct tty_display_info
*tty
= terminal
->display_info
.tty
;
174 XSETTERMINAL (lisp_terminal
, terminal
);
175 for (extra_codes
= Fterminal_parameter (lisp_terminal
, sym
);
177 extra_codes
= XCDR (extra_codes
))
179 Lisp_Object string
= XCAR (extra_codes
);
180 if (STRINGP (string
))
182 fwrite (SDATA (string
), 1, SBYTES (string
), tty
->output
);
184 fwrite (SDATA (string
), 1, SBYTES (string
), tty
->termscript
);
190 tty_set_terminal_modes (struct terminal
*terminal
)
192 struct tty_display_info
*tty
= terminal
->display_info
.tty
;
196 if (tty
->TS_termcap_modes
)
197 OUTPUT (tty
, tty
->TS_termcap_modes
);
200 /* Output enough newlines to scroll all the old screen contents
201 off the screen, so it won't be overwritten and lost. */
204 for (i
= 0; i
< FRAME_TOTAL_LINES (XFRAME (selected_frame
)); i
++)
208 OUTPUT_IF (tty
, visible_cursor
? tty
->TS_cursor_visible
: tty
->TS_cursor_normal
);
209 OUTPUT_IF (tty
, tty
->TS_keypad_mode
);
211 tty_send_additional_strings (terminal
, Qtty_mode_set_strings
);
212 fflush (tty
->output
);
216 /* Reset termcap modes before exiting Emacs. */
219 tty_reset_terminal_modes (struct terminal
*terminal
)
221 struct tty_display_info
*tty
= terminal
->display_info
.tty
;
225 tty_send_additional_strings (terminal
, Qtty_mode_reset_strings
);
226 tty_turn_off_highlight (tty
);
227 tty_turn_off_insert (tty
);
228 OUTPUT_IF (tty
, tty
->TS_end_keypad_mode
);
229 OUTPUT_IF (tty
, tty
->TS_cursor_normal
);
230 OUTPUT_IF (tty
, tty
->TS_end_termcap_modes
);
231 OUTPUT_IF (tty
, tty
->TS_orig_pair
);
232 /* Output raw CR so kernel can track the cursor hpos. */
235 fflush (tty
->output
);
239 /* Flag the end of a display update on a termcap terminal. */
242 tty_update_end (struct frame
*f
)
244 struct tty_display_info
*tty
= FRAME_TTY (f
);
246 if (!XWINDOW (selected_window
)->cursor_off_p
)
247 tty_show_cursor (tty
);
248 tty_turn_off_insert (tty
);
249 tty_background_highlight (tty
);
250 fflush (tty
->output
);
253 /* The implementation of set_terminal_window for termcap frames. */
256 tty_set_terminal_window (struct frame
*f
, int size
)
258 struct tty_display_info
*tty
= FRAME_TTY (f
);
260 tty
->specified_window
= size
? size
: FRAME_TOTAL_LINES (f
);
261 if (FRAME_SCROLL_REGION_OK (f
))
262 tty_set_scroll_region (f
, 0, tty
->specified_window
);
266 tty_set_scroll_region (struct frame
*f
, int start
, int stop
)
269 struct tty_display_info
*tty
= FRAME_TTY (f
);
271 if (tty
->TS_set_scroll_region
)
272 buf
= tparam (tty
->TS_set_scroll_region
, 0, 0, start
, stop
- 1, 0, 0);
273 else if (tty
->TS_set_scroll_region_1
)
274 buf
= tparam (tty
->TS_set_scroll_region_1
, 0, 0,
275 FRAME_TOTAL_LINES (f
), start
,
276 FRAME_TOTAL_LINES (f
) - stop
,
277 FRAME_TOTAL_LINES (f
));
279 buf
= tparam (tty
->TS_set_window
, 0, 0, start
, 0, stop
, FRAME_COLS (f
));
288 tty_turn_on_insert (struct tty_display_info
*tty
)
290 if (!tty
->insert_mode
)
291 OUTPUT (tty
, tty
->TS_insert_mode
);
292 tty
->insert_mode
= 1;
296 tty_turn_off_insert (struct tty_display_info
*tty
)
298 if (tty
->insert_mode
)
299 OUTPUT (tty
, tty
->TS_end_insert_mode
);
300 tty
->insert_mode
= 0;
303 /* Handle highlighting. */
306 tty_turn_off_highlight (struct tty_display_info
*tty
)
308 if (tty
->standout_mode
)
309 OUTPUT_IF (tty
, tty
->TS_end_standout_mode
);
310 tty
->standout_mode
= 0;
314 tty_turn_on_highlight (struct tty_display_info
*tty
)
316 if (!tty
->standout_mode
)
317 OUTPUT_IF (tty
, tty
->TS_standout_mode
);
318 tty
->standout_mode
= 1;
322 tty_toggle_highlight (struct tty_display_info
*tty
)
324 if (tty
->standout_mode
)
325 tty_turn_off_highlight (tty
);
327 tty_turn_on_highlight (tty
);
331 /* Make cursor invisible. */
334 tty_hide_cursor (struct tty_display_info
*tty
)
336 if (tty
->cursor_hidden
== 0)
338 tty
->cursor_hidden
= 1;
340 w32con_hide_cursor ();
342 OUTPUT_IF (tty
, tty
->TS_cursor_invisible
);
348 /* Ensure that cursor is visible. */
351 tty_show_cursor (struct tty_display_info
*tty
)
353 if (tty
->cursor_hidden
)
355 tty
->cursor_hidden
= 0;
357 w32con_show_cursor ();
359 OUTPUT_IF (tty
, tty
->TS_cursor_normal
);
361 OUTPUT_IF (tty
, tty
->TS_cursor_visible
);
367 /* Set standout mode to the state it should be in for
368 empty space inside windows. What this is,
369 depends on the user option inverse-video. */
372 tty_background_highlight (struct tty_display_info
*tty
)
375 tty_turn_on_highlight (tty
);
377 tty_turn_off_highlight (tty
);
380 /* Set standout mode to the mode specified for the text to be output. */
383 tty_highlight_if_desired (struct tty_display_info
*tty
)
386 tty_turn_on_highlight (tty
);
388 tty_turn_off_highlight (tty
);
392 /* Move cursor to row/column position VPOS/HPOS. HPOS/VPOS are
393 frame-relative coordinates. */
396 tty_cursor_to (struct frame
*f
, int vpos
, int hpos
)
398 struct tty_display_info
*tty
= FRAME_TTY (f
);
400 /* Detect the case where we are called from reset_sys_modes
401 and the costs have never been calculated. Do nothing. */
402 if (! tty
->costs_set
)
405 if (curY (tty
) == vpos
406 && curX (tty
) == hpos
)
408 if (!tty
->TF_standout_motion
)
409 tty_background_highlight (tty
);
410 if (!tty
->TF_insmode_motion
)
411 tty_turn_off_insert (tty
);
412 cmgoto (tty
, vpos
, hpos
);
415 /* Similar but don't take any account of the wasted characters. */
418 tty_raw_cursor_to (struct frame
*f
, int row
, int col
)
420 struct tty_display_info
*tty
= FRAME_TTY (f
);
422 if (curY (tty
) == row
423 && curX (tty
) == col
)
425 if (!tty
->TF_standout_motion
)
426 tty_background_highlight (tty
);
427 if (!tty
->TF_insmode_motion
)
428 tty_turn_off_insert (tty
);
429 cmgoto (tty
, row
, col
);
432 /* Erase operations */
434 /* Clear from cursor to end of frame on a termcap device. */
437 tty_clear_to_end (struct frame
*f
)
440 struct tty_display_info
*tty
= FRAME_TTY (f
);
442 if (tty
->TS_clr_to_bottom
)
444 tty_background_highlight (tty
);
445 OUTPUT (tty
, tty
->TS_clr_to_bottom
);
449 for (i
= curY (tty
); i
< FRAME_TOTAL_LINES (f
); i
++)
452 clear_end_of_line (f
, FRAME_COLS (f
));
457 /* Clear an entire termcap frame. */
460 tty_clear_frame (struct frame
*f
)
462 struct tty_display_info
*tty
= FRAME_TTY (f
);
464 if (tty
->TS_clr_frame
)
466 tty_background_highlight (tty
);
467 OUTPUT (tty
, tty
->TS_clr_frame
);
477 /* An implementation of clear_end_of_line for termcap frames.
479 Note that the cursor may be moved, on terminals lacking a `ce' string. */
482 tty_clear_end_of_line (struct frame
*f
, int first_unused_hpos
)
485 struct tty_display_info
*tty
= FRAME_TTY (f
);
487 /* Detect the case where we are called from reset_sys_modes
488 and the costs have never been calculated. Do nothing. */
489 if (! tty
->costs_set
)
492 if (curX (tty
) >= first_unused_hpos
)
494 tty_background_highlight (tty
);
495 if (tty
->TS_clr_line
)
497 OUTPUT1 (tty
, tty
->TS_clr_line
);
500 { /* have to do it the hard way */
501 tty_turn_off_insert (tty
);
503 /* Do not write in last row last col with Auto-wrap on. */
505 && curY (tty
) == FrameRows (tty
) - 1
506 && first_unused_hpos
== FrameCols (tty
))
509 for (i
= curX (tty
); i
< first_unused_hpos
; i
++)
512 fputc (' ', tty
->termscript
);
513 fputc (' ', tty
->output
);
515 cmplus (tty
, first_unused_hpos
- curX (tty
));
519 /* Buffers to store the source and result of code conversion for terminal. */
520 static unsigned char *encode_terminal_src
;
521 static unsigned char *encode_terminal_dst
;
522 /* Allocated sizes of the above buffers. */
523 static ptrdiff_t encode_terminal_src_size
;
524 static ptrdiff_t encode_terminal_dst_size
;
526 /* Encode SRC_LEN glyphs starting at SRC to terminal output codes.
527 Set CODING->produced to the byte-length of the resulting byte
528 sequence, and return a pointer to that byte sequence. */
531 encode_terminal_code (struct glyph
*src
, int src_len
,
532 struct coding_system
*coding
)
534 struct glyph
*src_end
= src
+ src_len
;
536 ptrdiff_t nchars
, nbytes
, required
;
537 ptrdiff_t tlen
= GLYPH_TABLE_LENGTH
;
538 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
539 Lisp_Object charset_list
;
541 /* Allocate sufficient size of buffer to store all characters in
542 multibyte-form. But, it may be enlarged on demand if
543 Vglyph_table contains a string or a composite glyph is
545 if (min (PTRDIFF_MAX
, SIZE_MAX
) / MAX_MULTIBYTE_LENGTH
< src_len
)
546 memory_full (SIZE_MAX
);
548 required
*= MAX_MULTIBYTE_LENGTH
;
549 if (encode_terminal_src_size
< required
)
551 encode_terminal_src
= xrealloc (encode_terminal_src
, required
);
552 encode_terminal_src_size
= required
;
555 charset_list
= coding_charset_list (coding
);
557 buf
= encode_terminal_src
;
559 while (src
< src_end
)
561 if (src
->type
== COMPOSITE_GLYPH
)
563 struct composition
*cmp
IF_LINT (= NULL
);
564 Lisp_Object gstring
IF_LINT (= Qnil
);
567 nbytes
= buf
- encode_terminal_src
;
568 if (src
->u
.cmp
.automatic
)
570 gstring
= composition_gstring_from_id (src
->u
.cmp
.id
);
571 required
= src
->slice
.cmp
.to
- src
->slice
.cmp
.from
+ 1;
575 cmp
= composition_table
[src
->u
.cmp
.id
];
576 required
= cmp
->glyph_len
;
577 required
*= MAX_MULTIBYTE_LENGTH
;
580 if (encode_terminal_src_size
- nbytes
< required
)
582 encode_terminal_src
=
583 xpalloc (encode_terminal_src
, &encode_terminal_src_size
,
584 required
- (encode_terminal_src_size
- nbytes
),
586 buf
= encode_terminal_src
+ nbytes
;
589 if (src
->u
.cmp
.automatic
)
590 for (i
= src
->slice
.cmp
.from
; i
<= src
->slice
.cmp
.to
; i
++)
592 Lisp_Object g
= LGSTRING_GLYPH (gstring
, i
);
593 int c
= LGLYPH_CHAR (g
);
595 if (! char_charset (c
, charset_list
, NULL
))
597 buf
+= CHAR_STRING (c
, buf
);
601 for (i
= 0; i
< cmp
->glyph_len
; i
++)
603 int c
= COMPOSITION_GLYPH (cmp
, i
);
605 /* TAB in a composition means display glyphs with
606 padding space on the left or right. */
609 if (char_charset (c
, charset_list
, NULL
))
611 if (CHAR_WIDTH (c
) == 0
612 && i
> 0 && COMPOSITION_GLYPH (cmp
, i
- 1) == '\t')
613 /* Should be left-padded */
615 buf
+= CHAR_STRING (' ', buf
);
621 buf
+= CHAR_STRING (c
, buf
);
625 /* We must skip glyphs to be padded for a wide character. */
626 else if (! CHAR_GLYPH_PADDING_P (*src
))
633 SET_GLYPH_FROM_CHAR_GLYPH (g
, src
[0]);
635 if (GLYPH_INVALID_P (g
) || GLYPH_SIMPLE_P (tbase
, tlen
, g
))
637 /* This glyph doesn't have an entry in Vglyph_table. */
642 /* This glyph has an entry in Vglyph_table,
643 so process any alias before testing for simpleness. */
644 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
646 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
647 /* We set the multi-byte form of a character in G
648 (that should be an ASCII character) at WORKBUF. */
651 /* We have a string in Vglyph_table. */
652 string
= tbase
[GLYPH_CHAR (g
)];
657 nbytes
= buf
- encode_terminal_src
;
658 if (encode_terminal_src_size
- nbytes
< MAX_MULTIBYTE_LENGTH
)
660 encode_terminal_src
=
661 xpalloc (encode_terminal_src
, &encode_terminal_src_size
,
662 MAX_MULTIBYTE_LENGTH
, -1, 1);
663 buf
= encode_terminal_src
+ nbytes
;
666 || char_charset (c
, charset_list
, NULL
))
668 /* Store the multibyte form of C at BUF. */
669 buf
+= CHAR_STRING (c
, buf
);
674 /* C is not encodable. */
677 while (src
+ 1 < src_end
&& CHAR_GLYPH_PADDING_P (src
[1]))
687 if (! STRING_MULTIBYTE (string
))
688 string
= string_to_multibyte (string
);
689 nbytes
= buf
- encode_terminal_src
;
690 if (encode_terminal_src_size
- nbytes
< SBYTES (string
))
692 encode_terminal_src
=
693 xpalloc (encode_terminal_src
, &encode_terminal_src_size
,
695 - (encode_terminal_src_size
- nbytes
)),
697 buf
= encode_terminal_src
+ nbytes
;
699 memcpy (buf
, SDATA (string
), SBYTES (string
));
700 buf
+= SBYTES (string
);
701 nchars
+= SCHARS (string
);
709 coding
->produced
= 0;
713 nbytes
= buf
- encode_terminal_src
;
714 coding
->source
= encode_terminal_src
;
715 if (encode_terminal_dst_size
== 0)
717 encode_terminal_dst
= xrealloc (encode_terminal_dst
,
718 encode_terminal_src_size
);
719 encode_terminal_dst_size
= encode_terminal_src_size
;
721 coding
->destination
= encode_terminal_dst
;
722 coding
->dst_bytes
= encode_terminal_dst_size
;
723 encode_coding_object (coding
, Qnil
, 0, 0, nchars
, nbytes
, Qnil
);
724 /* coding->destination may have been reallocated. */
725 encode_terminal_dst
= coding
->destination
;
726 encode_terminal_dst_size
= coding
->dst_bytes
;
728 return (encode_terminal_dst
);
733 /* An implementation of write_glyphs for termcap frames. */
736 tty_write_glyphs (struct frame
*f
, struct glyph
*string
, int len
)
738 unsigned char *conversion_buffer
;
739 struct coding_system
*coding
;
742 struct tty_display_info
*tty
= FRAME_TTY (f
);
744 tty_turn_off_insert (tty
);
745 tty_hide_cursor (tty
);
747 /* Don't dare write in last column of bottom line, if Auto-Wrap,
748 since that would scroll the whole frame on some terminals. */
751 && curY (tty
) + 1 == FRAME_TOTAL_LINES (f
)
752 && (curX (tty
) + len
) == FRAME_COLS (f
))
759 /* If terminal_coding does any conversion, use it, otherwise use
760 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
761 because it always return 1 if the member src_multibyte is 1. */
762 coding
= (FRAME_TERMINAL_CODING (f
)->common_flags
& CODING_REQUIRE_ENCODING_MASK
763 ? FRAME_TERMINAL_CODING (f
) : &safe_terminal_coding
);
764 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
766 coding
->mode
&= ~CODING_MODE_LAST_BLOCK
;
768 for (stringlen
= len
; stringlen
!= 0; stringlen
-= n
)
770 /* Identify a run of glyphs with the same face. */
771 int face_id
= string
->face_id
;
773 for (n
= 1; n
< stringlen
; ++n
)
774 if (string
[n
].face_id
!= face_id
)
777 /* Turn appearance modes of the face of the run on. */
778 tty_highlight_if_desired (tty
);
779 turn_on_face (f
, face_id
);
782 /* This is the last run. */
783 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
784 conversion_buffer
= encode_terminal_code (string
, n
, coding
);
785 if (coding
->produced
> 0)
788 fwrite (conversion_buffer
, 1, coding
->produced
, tty
->output
);
789 if (ferror (tty
->output
))
790 clearerr (tty
->output
);
792 fwrite (conversion_buffer
, 1, coding
->produced
, tty
->termscript
);
797 /* Turn appearance modes off. */
798 turn_off_face (f
, face_id
);
799 tty_turn_off_highlight (tty
);
805 #ifdef HAVE_GPM /* Only used by GPM code. */
808 tty_write_glyphs_with_face (register struct frame
*f
, register struct glyph
*string
,
809 register int len
, register int face_id
)
811 unsigned char *conversion_buffer
;
812 struct coding_system
*coding
;
814 struct tty_display_info
*tty
= FRAME_TTY (f
);
816 tty_turn_off_insert (tty
);
817 tty_hide_cursor (tty
);
819 /* Don't dare write in last column of bottom line, if Auto-Wrap,
820 since that would scroll the whole frame on some terminals. */
823 && curY (tty
) + 1 == FRAME_TOTAL_LINES (f
)
824 && (curX (tty
) + len
) == FRAME_COLS (f
))
831 /* If terminal_coding does any conversion, use it, otherwise use
832 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
833 because it always return 1 if the member src_multibyte is 1. */
834 coding
= (FRAME_TERMINAL_CODING (f
)->common_flags
& CODING_REQUIRE_ENCODING_MASK
835 ? FRAME_TERMINAL_CODING (f
) : &safe_terminal_coding
);
836 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
838 coding
->mode
&= ~CODING_MODE_LAST_BLOCK
;
840 /* Turn appearance modes of the face. */
841 tty_highlight_if_desired (tty
);
842 turn_on_face (f
, face_id
);
844 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
845 conversion_buffer
= encode_terminal_code (string
, len
, coding
);
846 if (coding
->produced
> 0)
849 fwrite (conversion_buffer
, 1, coding
->produced
, tty
->output
);
850 if (ferror (tty
->output
))
851 clearerr (tty
->output
);
853 fwrite (conversion_buffer
, 1, coding
->produced
, tty
->termscript
);
857 /* Turn appearance modes off. */
858 turn_off_face (f
, face_id
);
859 tty_turn_off_highlight (tty
);
865 /* An implementation of insert_glyphs for termcap frames. */
868 tty_insert_glyphs (struct frame
*f
, struct glyph
*start
, int len
)
871 struct glyph
*glyph
= NULL
;
872 unsigned char *conversion_buffer
;
873 unsigned char space
[1];
874 struct coding_system
*coding
;
876 struct tty_display_info
*tty
= FRAME_TTY (f
);
878 if (tty
->TS_ins_multi_chars
)
880 buf
= tparam (tty
->TS_ins_multi_chars
, 0, 0, len
, 0, 0, 0);
884 write_glyphs (f
, start
, len
);
888 tty_turn_on_insert (tty
);
892 space
[0] = SPACEGLYPH
;
894 /* If terminal_coding does any conversion, use it, otherwise use
895 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
896 because it always return 1 if the member src_multibyte is 1. */
897 coding
= (FRAME_TERMINAL_CODING (f
)->common_flags
& CODING_REQUIRE_ENCODING_MASK
898 ? FRAME_TERMINAL_CODING (f
) : &safe_terminal_coding
);
899 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
901 coding
->mode
&= ~CODING_MODE_LAST_BLOCK
;
905 OUTPUT1_IF (tty
, tty
->TS_ins_char
);
908 conversion_buffer
= space
;
909 coding
->produced
= 1;
913 tty_highlight_if_desired (tty
);
914 turn_on_face (f
, start
->face_id
);
917 /* We must open sufficient space for a character which
918 occupies more than one column. */
919 while (len
&& CHAR_GLYPH_PADDING_P (*start
))
921 OUTPUT1_IF (tty
, tty
->TS_ins_char
);
926 /* This is the last glyph. */
927 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
929 conversion_buffer
= encode_terminal_code (glyph
, 1, coding
);
932 if (coding
->produced
> 0)
935 fwrite (conversion_buffer
, 1, coding
->produced
, tty
->output
);
936 if (ferror (tty
->output
))
937 clearerr (tty
->output
);
939 fwrite (conversion_buffer
, 1, coding
->produced
, tty
->termscript
);
943 OUTPUT1_IF (tty
, tty
->TS_pad_inserted_char
);
946 turn_off_face (f
, glyph
->face_id
);
947 tty_turn_off_highlight (tty
);
954 /* An implementation of delete_glyphs for termcap frames. */
957 tty_delete_glyphs (struct frame
*f
, int n
)
962 struct tty_display_info
*tty
= FRAME_TTY (f
);
964 if (tty
->delete_in_insert_mode
)
966 tty_turn_on_insert (tty
);
970 tty_turn_off_insert (tty
);
971 OUTPUT_IF (tty
, tty
->TS_delete_mode
);
974 if (tty
->TS_del_multi_chars
)
976 buf
= tparam (tty
->TS_del_multi_chars
, 0, 0, n
, 0, 0, 0);
981 for (i
= 0; i
< n
; i
++)
982 OUTPUT1 (tty
, tty
->TS_del_char
);
983 if (!tty
->delete_in_insert_mode
)
984 OUTPUT_IF (tty
, tty
->TS_end_delete_mode
);
987 /* An implementation of ins_del_lines for termcap frames. */
990 tty_ins_del_lines (struct frame
*f
, int vpos
, int n
)
992 struct tty_display_info
*tty
= FRAME_TTY (f
);
994 n
> 0 ? tty
->TS_ins_multi_lines
: tty
->TS_del_multi_lines
;
995 const char *single
= n
> 0 ? tty
->TS_ins_line
: tty
->TS_del_line
;
996 const char *scroll
= n
> 0 ? tty
->TS_rev_scroll
: tty
->TS_fwd_scroll
;
1001 /* If the lines below the insertion are being pushed
1002 into the end of the window, this is the same as clearing;
1003 and we know the lines are already clear, since the matching
1004 deletion has already been done. So can ignore this. */
1005 /* If the lines below the deletion are blank lines coming
1006 out of the end of the window, don't bother,
1007 as there will be a matching inslines later that will flush them. */
1008 if (FRAME_SCROLL_REGION_OK (f
)
1009 && vpos
+ i
>= tty
->specified_window
)
1011 if (!FRAME_MEMORY_BELOW_FRAME (f
)
1012 && vpos
+ i
>= FRAME_TOTAL_LINES (f
))
1017 raw_cursor_to (f
, vpos
, 0);
1018 tty_background_highlight (tty
);
1019 buf
= tparam (multi
, 0, 0, i
, 0, 0, 0);
1025 raw_cursor_to (f
, vpos
, 0);
1026 tty_background_highlight (tty
);
1028 OUTPUT (tty
, single
);
1029 if (tty
->TF_teleray
)
1034 tty_set_scroll_region (f
, vpos
, tty
->specified_window
);
1036 raw_cursor_to (f
, tty
->specified_window
- 1, 0);
1038 raw_cursor_to (f
, vpos
, 0);
1039 tty_background_highlight (tty
);
1041 OUTPUTL (tty
, scroll
, tty
->specified_window
- vpos
);
1042 tty_set_scroll_region (f
, 0, tty
->specified_window
);
1045 if (!FRAME_SCROLL_REGION_OK (f
)
1046 && FRAME_MEMORY_BELOW_FRAME (f
)
1049 cursor_to (f
, FRAME_TOTAL_LINES (f
) + n
, 0);
1054 /* Compute cost of sending "str", in characters,
1055 not counting any line-dependent padding. */
1058 string_cost (const char *str
)
1062 tputs (str
, 0, evalcost
);
1066 /* Compute cost of sending "str", in characters,
1067 counting any line-dependent padding at one line. */
1070 string_cost_one_line (const char *str
)
1074 tputs (str
, 1, evalcost
);
1078 /* Compute per line amount of line-dependent padding,
1079 in tenths of characters. */
1082 per_line_cost (const char *str
)
1086 tputs (str
, 0, evalcost
);
1089 tputs (str
, 10, evalcost
);
1093 /* char_ins_del_cost[n] is cost of inserting N characters.
1094 char_ins_del_cost[-n] is cost of deleting N characters.
1095 The length of this vector is based on max_frame_cols. */
1097 int *char_ins_del_vector
;
1099 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_COLS ((f))])
1103 calculate_ins_del_char_costs (struct frame
*f
)
1105 struct tty_display_info
*tty
= FRAME_TTY (f
);
1106 int ins_startup_cost
, del_startup_cost
;
1107 int ins_cost_per_char
, del_cost_per_char
;
1111 if (tty
->TS_ins_multi_chars
)
1113 ins_cost_per_char
= 0;
1114 ins_startup_cost
= string_cost_one_line (tty
->TS_ins_multi_chars
);
1116 else if (tty
->TS_ins_char
|| tty
->TS_pad_inserted_char
1117 || (tty
->TS_insert_mode
&& tty
->TS_end_insert_mode
))
1119 ins_startup_cost
= (30 * (string_cost (tty
->TS_insert_mode
)
1120 + string_cost (tty
->TS_end_insert_mode
))) / 100;
1121 ins_cost_per_char
= (string_cost_one_line (tty
->TS_ins_char
)
1122 + string_cost_one_line (tty
->TS_pad_inserted_char
));
1126 ins_startup_cost
= 9999;
1127 ins_cost_per_char
= 0;
1130 if (tty
->TS_del_multi_chars
)
1132 del_cost_per_char
= 0;
1133 del_startup_cost
= string_cost_one_line (tty
->TS_del_multi_chars
);
1135 else if (tty
->TS_del_char
)
1137 del_startup_cost
= (string_cost (tty
->TS_delete_mode
)
1138 + string_cost (tty
->TS_end_delete_mode
));
1139 if (tty
->delete_in_insert_mode
)
1140 del_startup_cost
/= 2;
1141 del_cost_per_char
= string_cost_one_line (tty
->TS_del_char
);
1145 del_startup_cost
= 9999;
1146 del_cost_per_char
= 0;
1149 /* Delete costs are at negative offsets */
1150 p
= &char_ins_del_cost (f
)[0];
1151 for (i
= FRAME_COLS (f
); --i
>= 0;)
1152 *--p
= (del_startup_cost
+= del_cost_per_char
);
1154 /* Doing nothing is free */
1155 p
= &char_ins_del_cost (f
)[0];
1158 /* Insert costs are at positive offsets */
1159 for (i
= FRAME_COLS (f
); --i
>= 0;)
1160 *p
++ = (ins_startup_cost
+= ins_cost_per_char
);
1164 calculate_costs (struct frame
*frame
)
1166 FRAME_COST_BAUD_RATE (frame
) = baud_rate
;
1168 if (FRAME_TERMCAP_P (frame
))
1170 struct tty_display_info
*tty
= FRAME_TTY (frame
);
1171 register const char *f
= (tty
->TS_set_scroll_region
1172 ? tty
->TS_set_scroll_region
1173 : tty
->TS_set_scroll_region_1
);
1175 FRAME_SCROLL_REGION_COST (frame
) = string_cost (f
);
1179 /* These variables are only used for terminal stuff. They are
1180 allocated once for the terminal frame of X-windows emacs, but not
1183 char_ins_del_vector (i.e., char_ins_del_cost) isn't used because
1184 X turns off char_ins_del_ok. */
1186 max_frame_cols
= max (max_frame_cols
, FRAME_COLS (frame
));
1187 if ((min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof (int) - 1) / 2
1189 memory_full (SIZE_MAX
);
1191 char_ins_del_vector
=
1192 xrealloc (char_ins_del_vector
,
1193 (sizeof (int) + 2 * sizeof (int) * max_frame_cols
));
1195 memset (char_ins_del_vector
, 0,
1196 (sizeof (int) + 2 * sizeof (int) * max_frame_cols
));
1199 if (f
&& (!tty
->TS_ins_line
&& !tty
->TS_del_line
))
1200 do_line_insertion_deletion_costs (frame
,
1201 tty
->TS_rev_scroll
, tty
->TS_ins_multi_lines
,
1202 tty
->TS_fwd_scroll
, tty
->TS_del_multi_lines
,
1205 do_line_insertion_deletion_costs (frame
,
1206 tty
->TS_ins_line
, tty
->TS_ins_multi_lines
,
1207 tty
->TS_del_line
, tty
->TS_del_multi_lines
,
1210 calculate_ins_del_char_costs (frame
);
1212 /* Don't use TS_repeat if its padding is worse than sending the chars */
1213 if (tty
->TS_repeat
&& per_line_cost (tty
->TS_repeat
) * baud_rate
< 9000)
1214 tty
->RPov
= string_cost (tty
->TS_repeat
);
1216 tty
->RPov
= FRAME_COLS (frame
) * 2;
1218 cmcostinit (FRAME_TTY (frame
)); /* set up cursor motion costs */
1223 const char *cap
, *name
;
1226 /* Termcap capability names that correspond directly to X keysyms.
1227 Some of these (marked "terminfo") aren't supplied by old-style
1228 (Berkeley) termcap entries. They're listed in X keysym order;
1229 except we put the keypad keys first, so that if they clash with
1230 other keys (as on the IBM PC keyboard) they get overridden.
1233 static const struct fkey_table keys
[] =
1235 {"kh", "home"}, /* termcap */
1236 {"kl", "left"}, /* termcap */
1237 {"ku", "up"}, /* termcap */
1238 {"kr", "right"}, /* termcap */
1239 {"kd", "down"}, /* termcap */
1240 {"%8", "prior"}, /* terminfo */
1241 {"%5", "next"}, /* terminfo */
1242 {"@7", "end"}, /* terminfo */
1243 {"@1", "begin"}, /* terminfo */
1244 {"*6", "select"}, /* terminfo */
1245 {"%9", "print"}, /* terminfo */
1246 {"@4", "execute"}, /* terminfo --- actually the `command' key */
1248 * "insert" --- see below
1250 {"&8", "undo"}, /* terminfo */
1251 {"%0", "redo"}, /* terminfo */
1252 {"%7", "menu"}, /* terminfo --- actually the `options' key */
1253 {"@0", "find"}, /* terminfo */
1254 {"@2", "cancel"}, /* terminfo */
1255 {"%1", "help"}, /* terminfo */
1257 * "break" goes here, but can't be reliably intercepted with termcap
1259 {"&4", "reset"}, /* terminfo --- actually `restart' */
1261 * "system" and "user" --- no termcaps
1263 {"kE", "clearline"}, /* terminfo */
1264 {"kA", "insertline"}, /* terminfo */
1265 {"kL", "deleteline"}, /* terminfo */
1266 {"kI", "insertchar"}, /* terminfo */
1267 {"kD", "deletechar"}, /* terminfo */
1268 {"kB", "backtab"}, /* terminfo */
1270 * "kp_backtab", "kp-space", "kp-tab" --- no termcaps
1272 {"@8", "kp-enter"}, /* terminfo */
1274 * "kp-f1", "kp-f2", "kp-f3" "kp-f4",
1275 * "kp-multiply", "kp-add", "kp-separator",
1276 * "kp-subtract", "kp-decimal", "kp-divide", "kp-0";
1277 * --- no termcaps for any of these.
1279 {"K4", "kp-1"}, /* terminfo */
1281 * "kp-2" --- no termcap
1283 {"K5", "kp-3"}, /* terminfo */
1285 * "kp-4" --- no termcap
1287 {"K2", "kp-5"}, /* terminfo */
1289 * "kp-6" --- no termcap
1291 {"K1", "kp-7"}, /* terminfo */
1293 * "kp-8" --- no termcap
1295 {"K3", "kp-9"}, /* terminfo */
1297 * "kp-equal" --- no termcap
1309 {"&0", "S-cancel"}, /*shifted cancel key*/
1310 {"&9", "S-begin"}, /*shifted begin key*/
1311 {"*0", "S-find"}, /*shifted find key*/
1312 {"*1", "S-execute"}, /*shifted execute? actually shifted command key*/
1313 {"*4", "S-delete"}, /*shifted delete-character key*/
1314 {"*7", "S-end"}, /*shifted end key*/
1315 {"*8", "S-clearline"}, /*shifted clear-to end-of-line key*/
1316 {"#1", "S-help"}, /*shifted help key*/
1317 {"#2", "S-home"}, /*shifted home key*/
1318 {"#3", "S-insert"}, /*shifted insert-character key*/
1319 {"#4", "S-left"}, /*shifted left-arrow key*/
1320 {"%d", "S-menu"}, /*shifted menu? actually shifted options key*/
1321 {"%c", "S-next"}, /*shifted next key*/
1322 {"%e", "S-prior"}, /*shifted previous key*/
1323 {"%f", "S-print"}, /*shifted print key*/
1324 {"%g", "S-redo"}, /*shifted redo key*/
1325 {"%i", "S-right"}, /*shifted right-arrow key*/
1326 {"!3", "S-undo"} /*shifted undo key*/
1330 static char **term_get_fkeys_address
;
1331 static KBOARD
*term_get_fkeys_kboard
;
1332 static Lisp_Object
term_get_fkeys_1 (void);
1334 /* Find the escape codes sent by the function keys for Vinput_decode_map.
1335 This function scans the termcap function key sequence entries, and
1336 adds entries to Vinput_decode_map for each function key it finds. */
1339 term_get_fkeys (char **address
, KBOARD
*kboard
)
1341 /* We run the body of the function (term_get_fkeys_1) and ignore all Lisp
1342 errors during the call. The only errors should be from Fdefine_key
1343 when given a key sequence containing an invalid prefix key. If the
1344 termcap defines function keys which use a prefix that is already bound
1345 to a command by the default bindings, we should silently ignore that
1346 function key specification, rather than giving the user an error and
1347 refusing to run at all on such a terminal. */
1349 term_get_fkeys_address
= address
;
1350 term_get_fkeys_kboard
= kboard
;
1351 internal_condition_case (term_get_fkeys_1
, Qerror
, Fidentity
);
1355 term_get_fkeys_1 (void)
1359 char **address
= term_get_fkeys_address
;
1360 KBOARD
*kboard
= term_get_fkeys_kboard
;
1362 /* This can happen if CANNOT_DUMP or with strange options. */
1363 if (!KEYMAPP (KVAR (kboard
, Vinput_decode_map
)))
1364 kset_input_decode_map (kboard
, Fmake_sparse_keymap (Qnil
));
1366 for (i
= 0; i
< ARRAYELTS (keys
); i
++)
1368 char *sequence
= tgetstr (keys
[i
].cap
, address
);
1370 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (sequence
),
1371 Fmake_vector (make_number (1),
1372 intern (keys
[i
].name
)));
1375 /* The uses of the "k0" capability are inconsistent; sometimes it
1376 describes F10, whereas othertimes it describes F0 and "k;" describes F10.
1377 We will attempt to politely accommodate both systems by testing for
1378 "k;", and if it is present, assuming that "k0" denotes F0, otherwise F10.
1381 const char *k_semi
= tgetstr ("k;", address
);
1382 const char *k0
= tgetstr ("k0", address
);
1383 const char *k0_name
= "f10";
1388 /* Define f0 first, so that f10 takes precedence in case the
1389 key sequences happens to be the same. */
1390 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (k0
),
1391 Fmake_vector (make_number (1), intern ("f0")));
1392 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (k_semi
),
1393 Fmake_vector (make_number (1), intern ("f10")));
1396 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (k0
),
1397 Fmake_vector (make_number (1), intern (k0_name
)));
1400 /* Set up cookies for numbered function keys above f10. */
1402 char fcap
[3], fkey
[4];
1404 fcap
[0] = 'F'; fcap
[2] = '\0';
1405 for (i
= 11; i
< 64; i
++)
1408 fcap
[1] = '1' + i
- 11;
1410 fcap
[1] = 'A' + i
- 20;
1412 fcap
[1] = 'a' + i
- 46;
1415 char *sequence
= tgetstr (fcap
, address
);
1418 sprintf (fkey
, "f%d", i
);
1419 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (sequence
),
1420 Fmake_vector (make_number (1),
1428 * Various mappings to try and get a better fit.
1431 #define CONDITIONAL_REASSIGN(cap1, cap2, sym) \
1432 if (!tgetstr (cap1, address)) \
1434 char *sequence = tgetstr (cap2, address); \
1436 Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (sequence), \
1437 Fmake_vector (make_number (1), \
1441 /* if there's no key_next keycap, map key_npage to `next' keysym */
1442 CONDITIONAL_REASSIGN ("%5", "kN", "next");
1443 /* if there's no key_prev keycap, map key_ppage to `previous' keysym */
1444 CONDITIONAL_REASSIGN ("%8", "kP", "prior");
1445 /* if there's no key_dc keycap, map key_ic to `insert' keysym */
1446 CONDITIONAL_REASSIGN ("kD", "kI", "insert");
1447 /* if there's no key_end keycap, map key_ll to 'end' keysym */
1448 CONDITIONAL_REASSIGN ("@7", "kH", "end");
1449 #undef CONDITIONAL_REASSIGN
1454 #endif /* not DOS_NT */
1457 /***********************************************************************
1458 Character Display Information
1459 ***********************************************************************/
1460 static void append_glyph (struct it
*);
1461 static void append_composite_glyph (struct it
*);
1462 static void produce_composite_glyph (struct it
*);
1463 static void append_glyphless_glyph (struct it
*, int, const char *);
1464 static void produce_glyphless_glyph (struct it
*, Lisp_Object
);
1466 /* Append glyphs to IT's glyph_row. Called from produce_glyphs for
1467 terminal frames if IT->glyph_row != NULL. IT->char_to_display is
1468 the character for which to produce glyphs; IT->face_id contains the
1469 character's face. Padding glyphs are appended if IT->c has a
1470 IT->pixel_width > 1. */
1473 append_glyph (struct it
*it
)
1475 struct glyph
*glyph
, *end
;
1478 eassert (it
->glyph_row
);
1479 glyph
= (it
->glyph_row
->glyphs
[it
->area
]
1480 + it
->glyph_row
->used
[it
->area
]);
1481 end
= it
->glyph_row
->glyphs
[1 + it
->area
];
1483 /* If the glyph row is reversed, we need to prepend the glyph rather
1485 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
1488 int move_by
= it
->pixel_width
;
1490 /* Make room for the new glyphs. */
1491 if (move_by
> end
- glyph
) /* don't overstep end of this area */
1492 move_by
= end
- glyph
;
1493 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
1495 glyph
= it
->glyph_row
->glyphs
[it
->area
];
1496 end
= glyph
+ move_by
;
1499 /* BIDI Note: we put the glyphs of a "multi-pixel" character left to
1500 right, even in the REVERSED_P case, since (a) all of its u.ch are
1501 identical, and (b) the PADDING_P flag needs to be set for the
1502 leftmost one, because we write to the terminal left-to-right. */
1504 i
< it
->pixel_width
&& glyph
< end
;
1507 glyph
->type
= CHAR_GLYPH
;
1508 glyph
->pixel_width
= 1;
1509 glyph
->u
.ch
= it
->char_to_display
;
1510 glyph
->face_id
= it
->face_id
;
1511 glyph
->padding_p
= i
> 0;
1512 glyph
->charpos
= CHARPOS (it
->position
);
1513 glyph
->object
= it
->object
;
1516 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
1517 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
1519 glyph
->bidi_type
= it
->bidi_it
.type
;
1523 glyph
->resolved_level
= 0;
1524 glyph
->bidi_type
= UNKNOWN_BT
;
1527 ++it
->glyph_row
->used
[it
->area
];
1532 /* For external use. */
1534 tty_append_glyph (struct it
*it
)
1540 /* Produce glyphs for the display element described by IT. *IT
1541 specifies what we want to produce a glyph for (character, image, ...),
1542 and where in the glyph matrix we currently are (glyph row and hpos).
1543 produce_glyphs fills in output fields of *IT with information such as the
1544 pixel width and height of a character, and maybe output actual glyphs at
1545 the same time if IT->glyph_row is non-null. For an overview, see
1546 the explanation in dispextern.h, before the definition of the
1547 display_element_type enumeration.
1549 produce_glyphs also stores the result of glyph width, ascent
1550 etc. computations in *IT.
1552 IT->glyph_row may be null, in which case produce_glyphs does not
1553 actually fill in the glyphs. This is used in the move_* functions
1554 in xdisp.c for text width and height computations.
1556 Callers usually don't call produce_glyphs directly;
1557 instead they use the macro PRODUCE_GLYPHS. */
1560 produce_glyphs (struct it
*it
)
1562 /* If a hook is installed, let it do the work. */
1564 /* Nothing but characters are supported on terminal frames. */
1565 eassert (it
->what
== IT_CHARACTER
1566 || it
->what
== IT_COMPOSITION
1567 || it
->what
== IT_STRETCH
1568 || it
->what
== IT_GLYPHLESS
);
1570 if (it
->what
== IT_STRETCH
)
1572 produce_stretch_glyph (it
);
1576 if (it
->what
== IT_COMPOSITION
)
1578 produce_composite_glyph (it
);
1582 if (it
->what
== IT_GLYPHLESS
)
1584 produce_glyphless_glyph (it
, Qnil
);
1588 if (it
->char_to_display
>= 040 && it
->char_to_display
< 0177)
1590 it
->pixel_width
= it
->nglyphs
= 1;
1594 else if (it
->char_to_display
== '\n')
1595 it
->pixel_width
= it
->nglyphs
= 0;
1596 else if (it
->char_to_display
== '\t')
1598 int absolute_x
= (it
->current_x
1599 + it
->continuation_lines_width
);
1601 = (((1 + absolute_x
+ it
->tab_width
- 1)
1606 /* If part of the TAB has been displayed on the previous line
1607 which is continued now, continuation_lines_width will have
1608 been incremented already by the part that fitted on the
1609 continued line. So, we will get the right number of spaces
1611 nspaces
= next_tab_x
- absolute_x
;
1617 it
->char_to_display
= ' ';
1618 it
->pixel_width
= it
->len
= 1;
1624 it
->pixel_width
= nspaces
;
1625 it
->nglyphs
= nspaces
;
1627 else if (CHAR_BYTE8_P (it
->char_to_display
))
1629 /* Coming here means that we must send the raw 8-bit byte as is
1630 to the terminal. Although there's no way to know how many
1631 columns it occupies on a screen, it is a good assumption that
1632 a single byte code has 1-column width. */
1633 it
->pixel_width
= it
->nglyphs
= 1;
1639 Lisp_Object charset_list
= FRAME_TERMINAL (it
->f
)->charset_list
;
1641 if (char_charset (it
->char_to_display
, charset_list
, NULL
))
1643 it
->pixel_width
= CHAR_WIDTH (it
->char_to_display
);
1644 it
->nglyphs
= it
->pixel_width
;
1650 Lisp_Object acronym
= lookup_glyphless_char_display (-1, it
);
1652 eassert (it
->what
== IT_GLYPHLESS
);
1653 produce_glyphless_glyph (it
, acronym
);
1658 /* Advance current_x by the pixel width as a convenience for
1660 if (it
->area
== TEXT_AREA
)
1661 it
->current_x
+= it
->pixel_width
;
1662 it
->ascent
= it
->max_ascent
= it
->phys_ascent
= it
->max_phys_ascent
= 0;
1663 it
->descent
= it
->max_descent
= it
->phys_descent
= it
->max_phys_descent
= 1;
1666 /* Append glyphs to IT's glyph_row for the composition IT->cmp_id.
1667 Called from produce_composite_glyph for terminal frames if
1668 IT->glyph_row != NULL. IT->face_id contains the character's
1672 append_composite_glyph (struct it
*it
)
1674 struct glyph
*glyph
;
1676 eassert (it
->glyph_row
);
1677 glyph
= it
->glyph_row
->glyphs
[it
->area
] + it
->glyph_row
->used
[it
->area
];
1678 if (glyph
< it
->glyph_row
->glyphs
[1 + it
->area
])
1680 /* If the glyph row is reversed, we need to prepend the glyph
1681 rather than append it. */
1682 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
1686 /* Make room for the new glyph. */
1687 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
1689 glyph
= it
->glyph_row
->glyphs
[it
->area
];
1691 glyph
->type
= COMPOSITE_GLYPH
;
1692 glyph
->pixel_width
= it
->pixel_width
;
1693 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
1694 if (it
->cmp_it
.ch
< 0)
1696 glyph
->u
.cmp
.automatic
= 0;
1697 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
1701 glyph
->u
.cmp
.automatic
= 1;
1702 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
1703 glyph
->slice
.cmp
.from
= it
->cmp_it
.from
;
1704 glyph
->slice
.cmp
.to
= it
->cmp_it
.to
- 1;
1707 glyph
->face_id
= it
->face_id
;
1708 glyph
->padding_p
= 0;
1709 glyph
->charpos
= CHARPOS (it
->position
);
1710 glyph
->object
= it
->object
;
1713 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
1714 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
1716 glyph
->bidi_type
= it
->bidi_it
.type
;
1720 glyph
->resolved_level
= 0;
1721 glyph
->bidi_type
= UNKNOWN_BT
;
1724 ++it
->glyph_row
->used
[it
->area
];
1730 /* Produce a composite glyph for iterator IT. IT->cmp_id is the ID of
1731 the composition. We simply produces components of the composition
1732 assuming that the terminal has a capability to layout/render it
1736 produce_composite_glyph (struct it
*it
)
1738 if (it
->cmp_it
.ch
< 0)
1740 struct composition
*cmp
= composition_table
[it
->cmp_it
.id
];
1742 it
->pixel_width
= cmp
->width
;
1746 Lisp_Object gstring
= composition_gstring_from_id (it
->cmp_it
.id
);
1748 it
->pixel_width
= composition_gstring_width (gstring
, it
->cmp_it
.from
,
1749 it
->cmp_it
.to
, NULL
);
1753 append_composite_glyph (it
);
1757 /* Append a glyph for a glyphless character to IT->glyph_row. FACE_ID
1758 is a face ID to be used for the glyph. What is actually appended
1759 are glyphs of type CHAR_GLYPH whose characters are in STR (which
1760 comes from it->nglyphs bytes). */
1763 append_glyphless_glyph (struct it
*it
, int face_id
, const char *str
)
1765 struct glyph
*glyph
, *end
;
1768 eassert (it
->glyph_row
);
1769 glyph
= it
->glyph_row
->glyphs
[it
->area
] + it
->glyph_row
->used
[it
->area
];
1770 end
= it
->glyph_row
->glyphs
[1 + it
->area
];
1772 /* If the glyph row is reversed, we need to prepend the glyph rather
1774 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
1777 int move_by
= it
->pixel_width
;
1779 /* Make room for the new glyphs. */
1780 if (move_by
> end
- glyph
) /* don't overstep end of this area */
1781 move_by
= end
- glyph
;
1782 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
1784 glyph
= it
->glyph_row
->glyphs
[it
->area
];
1785 end
= glyph
+ move_by
;
1790 glyph
->type
= CHAR_GLYPH
;
1791 glyph
->pixel_width
= 1;
1792 glyph
->face_id
= face_id
;
1793 glyph
->padding_p
= 0;
1794 glyph
->charpos
= CHARPOS (it
->position
);
1795 glyph
->object
= it
->object
;
1798 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
1799 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
1801 glyph
->bidi_type
= it
->bidi_it
.type
;
1805 glyph
->resolved_level
= 0;
1806 glyph
->bidi_type
= UNKNOWN_BT
;
1809 /* BIDI Note: we put the glyphs of characters left to right, even in
1810 the REVERSED_P case because we write to the terminal
1812 for (i
= 0; i
< it
->nglyphs
&& glyph
< end
; ++i
)
1815 glyph
[0] = glyph
[-1];
1816 glyph
->u
.ch
= str
[i
];
1817 ++it
->glyph_row
->used
[it
->area
];
1822 /* Produce glyphs for a glyphless character for iterator IT.
1823 IT->glyphless_method specifies which method to use for displaying
1824 the character. See the description of enum
1825 glyphless_display_method in dispextern.h for the details.
1827 ACRONYM, if non-nil, is an acronym string for the character.
1829 The glyphs actually produced are of type CHAR_GLYPH. */
1832 produce_glyphless_glyph (struct it
*it
, Lisp_Object acronym
)
1834 int len
, face_id
= merge_glyphless_glyph_face (it
);
1835 char buf
[sizeof "\\x" + max (6, (sizeof it
->c
* CHAR_BIT
+ 3) / 4)];
1836 char const *str
= " ";
1838 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_THIN_SPACE
)
1840 /* As there's no way to produce a thin space, we produce a space
1841 of canonical width. */
1844 else if (it
->glyphless_method
== GLYPHLESS_DISPLAY_EMPTY_BOX
)
1846 len
= CHAR_WIDTH (it
->c
);
1851 len
= sprintf (buf
, "[%.*s]", len
, str
);
1856 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_ACRONYM
)
1858 if (! STRINGP (acronym
) && CHAR_TABLE_P (Vglyphless_char_display
))
1859 acronym
= CHAR_TABLE_REF (Vglyphless_char_display
, it
->c
);
1860 if (CONSP (acronym
))
1861 acronym
= XCDR (acronym
);
1863 str
= STRINGP (acronym
) ? SSDATA (acronym
) : "";
1864 for (len
= 0; len
< 6 && str
[len
] && ASCII_CHAR_P (str
[len
]); len
++)
1865 buf
[1 + len
] = str
[len
];
1871 eassert (it
->glyphless_method
== GLYPHLESS_DISPLAY_HEX_CODE
);
1872 len
= (it
->c
< 0x10000 ? sprintf (buf
, "\\u%04X", it
->c
)
1873 : it
->c
<= MAX_UNICODE_CHAR
? sprintf (buf
, "\\U%06X", it
->c
)
1874 : sprintf (buf
, "\\x%06X", it
->c
));
1879 it
->pixel_width
= len
;
1882 append_glyphless_glyph (it
, face_id
, str
);
1886 /***********************************************************************
1888 ***********************************************************************/
1890 /* Value is non-zero if attribute ATTR may be used. ATTR should be
1891 one of the enumerators from enum no_color_bit, or a bit set built
1892 from them. Some display attributes may not be used together with
1893 color; the termcap capability `NC' specifies which ones. */
1895 #define MAY_USE_WITH_COLORS_P(tty, ATTR) \
1896 (tty->TN_max_colors > 0 \
1897 ? (tty->TN_no_color_video & (ATTR)) == 0 \
1900 /* Turn appearances of face FACE_ID on tty frame F on.
1901 FACE_ID is a realized face ID number, in the face cache. */
1904 turn_on_face (struct frame
*f
, int face_id
)
1906 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1907 unsigned long fg
= face
->foreground
;
1908 unsigned long bg
= face
->background
;
1909 struct tty_display_info
*tty
= FRAME_TTY (f
);
1911 /* Use reverse video if the face specifies that.
1912 Do this first because TS_end_standout_mode may be the same
1913 as TS_exit_attribute_mode, which turns all appearances off. */
1914 if (MAY_USE_WITH_COLORS_P (tty
, NC_REVERSE
)
1916 ? fg
== FACE_TTY_DEFAULT_FG_COLOR
|| bg
== FACE_TTY_DEFAULT_BG_COLOR
1917 : fg
== FACE_TTY_DEFAULT_BG_COLOR
|| bg
== FACE_TTY_DEFAULT_FG_COLOR
))
1918 tty_toggle_highlight (tty
);
1920 if (face
->tty_bold_p
&& MAY_USE_WITH_COLORS_P (tty
, NC_BOLD
))
1921 OUTPUT1_IF (tty
, tty
->TS_enter_bold_mode
);
1923 if (face
->tty_italic_p
&& MAY_USE_WITH_COLORS_P (tty
, NC_ITALIC
))
1925 if (tty
->TS_enter_italic_mode
)
1926 OUTPUT1 (tty
, tty
->TS_enter_italic_mode
);
1928 /* Italics mode is unavailable on many terminals. In that
1929 case, map slant to dimmed text; we want italic text to
1930 appear different and dimming is not otherwise used. */
1931 OUTPUT1 (tty
, tty
->TS_enter_dim_mode
);
1934 if (face
->tty_underline_p
&& MAY_USE_WITH_COLORS_P (tty
, NC_UNDERLINE
))
1935 OUTPUT1_IF (tty
, tty
->TS_enter_underline_mode
);
1937 if (tty
->TN_max_colors
> 0)
1942 ts
= tty
->standout_mode
? tty
->TS_set_background
: tty
->TS_set_foreground
;
1943 if (face_tty_specified_color (fg
) && ts
)
1945 p
= tparam (ts
, NULL
, 0, fg
, 0, 0, 0);
1950 ts
= tty
->standout_mode
? tty
->TS_set_foreground
: tty
->TS_set_background
;
1951 if (face_tty_specified_color (bg
) && ts
)
1953 p
= tparam (ts
, NULL
, 0, bg
, 0, 0, 0);
1961 /* Turn off appearances of face FACE_ID on tty frame F. */
1964 turn_off_face (struct frame
*f
, int face_id
)
1966 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1967 struct tty_display_info
*tty
= FRAME_TTY (f
);
1969 eassert (face
!= NULL
);
1971 if (tty
->TS_exit_attribute_mode
)
1973 /* Capability "me" will turn off appearance modes double-bright,
1974 half-bright, reverse-video, standout, underline. It may or
1975 may not turn off alt-char-mode. */
1976 if (face
->tty_bold_p
1977 || face
->tty_italic_p
1978 || face
->tty_reverse_p
1979 || face
->tty_underline_p
)
1981 OUTPUT1_IF (tty
, tty
->TS_exit_attribute_mode
);
1982 if (strcmp (tty
->TS_exit_attribute_mode
, tty
->TS_end_standout_mode
) == 0)
1983 tty
->standout_mode
= 0;
1988 /* If we don't have "me" we can only have those appearances
1989 that have exit sequences defined. */
1990 if (face
->tty_underline_p
)
1991 OUTPUT_IF (tty
, tty
->TS_exit_underline_mode
);
1994 /* Switch back to default colors. */
1995 if (tty
->TN_max_colors
> 0
1996 && ((face
->foreground
!= FACE_TTY_DEFAULT_COLOR
1997 && face
->foreground
!= FACE_TTY_DEFAULT_FG_COLOR
)
1998 || (face
->background
!= FACE_TTY_DEFAULT_COLOR
1999 && face
->background
!= FACE_TTY_DEFAULT_BG_COLOR
)))
2000 OUTPUT1_IF (tty
, tty
->TS_orig_pair
);
2004 /* Return true if the terminal on frame F supports all of the
2005 capabilities in CAPS simultaneously. */
2008 tty_capable_p (struct tty_display_info
*tty
, unsigned int caps
)
2010 #define TTY_CAPABLE_P_TRY(tty, cap, TS, NC_bit) \
2011 if ((caps & (cap)) && (!(TS) || !MAY_USE_WITH_COLORS_P(tty, NC_bit))) \
2014 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_INVERSE
, tty
->TS_standout_mode
, NC_REVERSE
);
2015 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_UNDERLINE
, tty
->TS_enter_underline_mode
, NC_UNDERLINE
);
2016 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_BOLD
, tty
->TS_enter_bold_mode
, NC_BOLD
);
2017 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_DIM
, tty
->TS_enter_dim_mode
, NC_DIM
);
2018 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_ITALIC
, tty
->TS_enter_italic_mode
, NC_ITALIC
);
2024 /* Return non-zero if the terminal is capable to display colors. */
2026 DEFUN ("tty-display-color-p", Ftty_display_color_p
, Stty_display_color_p
,
2028 doc
: /* Return non-nil if the tty device TERMINAL can display colors.
2030 TERMINAL can be a terminal object, a frame, or nil (meaning the
2031 selected frame's terminal). This function always returns nil if
2032 TERMINAL does not refer to a text terminal. */)
2033 (Lisp_Object terminal
)
2035 struct terminal
*t
= get_tty_terminal (terminal
, 0);
2039 return t
->display_info
.tty
->TN_max_colors
> 0 ? Qt
: Qnil
;
2042 /* Return the number of supported colors. */
2043 DEFUN ("tty-display-color-cells", Ftty_display_color_cells
,
2044 Stty_display_color_cells
, 0, 1, 0,
2045 doc
: /* Return the number of colors supported by the tty device TERMINAL.
2047 TERMINAL can be a terminal object, a frame, or nil (meaning the
2048 selected frame's terminal). This function always returns 0 if
2049 TERMINAL does not refer to a text terminal. */)
2050 (Lisp_Object terminal
)
2052 struct terminal
*t
= get_tty_terminal (terminal
, 0);
2054 return make_number (0);
2056 return make_number (t
->display_info
.tty
->TN_max_colors
);
2061 /* Declare here rather than in the function, as in the rest of Emacs,
2062 to work around an HPUX compiler bug (?). See
2063 http://lists.gnu.org/archive/html/emacs-devel/2007-08/msg00410.html */
2064 static int default_max_colors
;
2065 static int default_max_pairs
;
2066 static int default_no_color_video
;
2067 static char *default_orig_pair
;
2068 static char *default_set_foreground
;
2069 static char *default_set_background
;
2071 /* Save or restore the default color-related capabilities of this
2074 tty_default_color_capabilities (struct tty_display_info
*tty
, bool save
)
2079 dupstring (&default_orig_pair
, tty
->TS_orig_pair
);
2080 dupstring (&default_set_foreground
, tty
->TS_set_foreground
);
2081 dupstring (&default_set_background
, tty
->TS_set_background
);
2082 default_max_colors
= tty
->TN_max_colors
;
2083 default_max_pairs
= tty
->TN_max_pairs
;
2084 default_no_color_video
= tty
->TN_no_color_video
;
2088 tty
->TS_orig_pair
= default_orig_pair
;
2089 tty
->TS_set_foreground
= default_set_foreground
;
2090 tty
->TS_set_background
= default_set_background
;
2091 tty
->TN_max_colors
= default_max_colors
;
2092 tty
->TN_max_pairs
= default_max_pairs
;
2093 tty
->TN_no_color_video
= default_no_color_video
;
2097 /* Setup one of the standard tty color schemes according to MODE.
2098 MODE's value is generally the number of colors which we want to
2099 support; zero means set up for the default capabilities, the ones
2100 we saw at init_tty time; -1 means turn off color support. */
2102 tty_setup_colors (struct tty_display_info
*tty
, int mode
)
2104 /* Canonicalize all negative values of MODE. */
2110 case -1: /* no colors at all */
2111 tty
->TN_max_colors
= 0;
2112 tty
->TN_max_pairs
= 0;
2113 tty
->TN_no_color_video
= 0;
2114 tty
->TS_set_foreground
= tty
->TS_set_background
= tty
->TS_orig_pair
= NULL
;
2116 case 0: /* default colors, if any */
2118 tty_default_color_capabilities (tty
, 0);
2120 case 8: /* 8 standard ANSI colors */
2121 tty
->TS_orig_pair
= "\033[0m";
2123 tty
->TS_set_foreground
= "\033[3%p1%dm";
2124 tty
->TS_set_background
= "\033[4%p1%dm";
2126 tty
->TS_set_foreground
= "\033[3%dm";
2127 tty
->TS_set_background
= "\033[4%dm";
2129 tty
->TN_max_colors
= 8;
2130 tty
->TN_max_pairs
= 64;
2131 tty
->TN_no_color_video
= 0;
2137 set_tty_color_mode (struct tty_display_info
*tty
, struct frame
*f
)
2139 Lisp_Object tem
, val
;
2140 Lisp_Object color_mode
;
2142 Lisp_Object tty_color_mode_alist
2143 = Fintern_soft (build_string ("tty-color-mode-alist"), Qnil
);
2145 tem
= assq_no_quit (Qtty_color_mode
, f
->param_alist
);
2146 val
= CONSP (tem
) ? XCDR (tem
) : Qnil
;
2150 else if (SYMBOLP (tty_color_mode_alist
))
2152 tem
= Fassq (val
, Fsymbol_value (tty_color_mode_alist
));
2153 color_mode
= CONSP (tem
) ? XCDR (tem
) : Qnil
;
2158 mode
= TYPE_RANGED_INTEGERP (int, color_mode
) ? XINT (color_mode
) : 0;
2160 if (mode
!= tty
->previous_color_mode
)
2162 tty
->previous_color_mode
= mode
;
2163 tty_setup_colors (tty
, mode
);
2164 /* This recomputes all the faces given the new color definitions. */
2165 safe_call (1, intern ("tty-set-up-initial-frame-faces"));
2169 #endif /* !DOS_NT */
2173 /* Return the tty display object specified by TERMINAL. */
2175 static struct terminal
*
2176 get_tty_terminal (Lisp_Object terminal
, bool throw)
2178 struct terminal
*t
= get_terminal (terminal
, throw);
2180 if (t
&& t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
)
2183 error ("Device %d is not a termcap terminal device", t
->id
);
2191 /* Return an active termcap device that uses the tty device with the
2194 This function ignores suspended devices.
2196 Returns NULL if the named terminal device is not opened. */
2199 get_named_tty (const char *name
)
2205 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
2207 if ((t
->type
== output_termcap
|| t
->type
== output_msdos_raw
)
2208 && !strcmp (t
->display_info
.tty
->name
, name
)
2209 && TERMINAL_ACTIVE_P (t
))
2217 DEFUN ("tty-type", Ftty_type
, Stty_type
, 0, 1, 0,
2218 doc
: /* Return the type of the tty device that TERMINAL uses.
2219 Returns nil if TERMINAL is not on a tty device.
2221 TERMINAL can be a terminal object, a frame, or nil (meaning the
2222 selected frame's terminal). */)
2223 (Lisp_Object terminal
)
2225 struct terminal
*t
= get_terminal (terminal
, 1);
2227 if (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
)
2230 if (t
->display_info
.tty
->type
)
2231 return build_string (t
->display_info
.tty
->type
);
2236 DEFUN ("controlling-tty-p", Fcontrolling_tty_p
, Scontrolling_tty_p
, 0, 1, 0,
2237 doc
: /* Return non-nil if TERMINAL is the controlling tty of the Emacs process.
2239 TERMINAL can be a terminal object, a frame, or nil (meaning the
2240 selected frame's terminal). This function always returns nil if
2241 TERMINAL is not on a tty device. */)
2242 (Lisp_Object terminal
)
2244 struct terminal
*t
= get_terminal (terminal
, 1);
2246 if ((t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
)
2247 || strcmp (t
->display_info
.tty
->name
, DEV_TTY
) != 0)
2253 DEFUN ("tty-no-underline", Ftty_no_underline
, Stty_no_underline
, 0, 1, 0,
2254 doc
: /* Declare that the tty used by TERMINAL does not handle underlining.
2255 This is used to override the terminfo data, for certain terminals that
2256 do not really do underlining, but say that they do. This function has
2257 no effect if used on a non-tty terminal.
2259 TERMINAL can be a terminal object, a frame or nil (meaning the
2260 selected frame's terminal). This function always returns nil if
2261 TERMINAL does not refer to a text terminal. */)
2262 (Lisp_Object terminal
)
2264 struct terminal
*t
= get_terminal (terminal
, 1);
2266 if (t
->type
== output_termcap
)
2267 t
->display_info
.tty
->TS_enter_underline_mode
= 0;
2271 DEFUN ("tty-top-frame", Ftty_top_frame
, Stty_top_frame
, 0, 1, 0,
2272 doc
: /* Return the topmost terminal frame on TERMINAL.
2273 TERMINAL can be a terminal object, a frame or nil (meaning the
2274 selected frame's terminal). This function returns nil if TERMINAL
2275 does not refer to a text terminal. Otherwise, it returns the
2276 top-most frame on the text terminal. */)
2277 (Lisp_Object terminal
)
2279 struct terminal
*t
= get_terminal (terminal
, 1);
2281 if (t
->type
== output_termcap
)
2282 return t
->display_info
.tty
->top_frame
;
2288 DEFUN ("suspend-tty", Fsuspend_tty
, Ssuspend_tty
, 0, 1, 0,
2289 doc
: /* Suspend the terminal device TTY.
2291 The device is restored to its default state, and Emacs ceases all
2292 access to the tty device. Frames that use the device are not deleted,
2293 but input is not read from them and if they change, their display is
2296 TTY may be a terminal object, a frame, or nil for the terminal device
2297 of the currently selected frame.
2299 This function runs `suspend-tty-functions' after suspending the
2300 device. The functions are run with one arg, the id of the suspended
2303 `suspend-tty' does nothing if it is called on a device that is already
2306 A suspended tty may be resumed by calling `resume-tty' on it. */)
2309 struct terminal
*t
= get_tty_terminal (tty
, 1);
2313 error ("Unknown tty device");
2315 f
= t
->display_info
.tty
->input
;
2319 /* First run `suspend-tty-functions' and then clean up the tty
2320 state because `suspend-tty-functions' might need to change
2322 Lisp_Object args
[2];
2323 args
[0] = intern ("suspend-tty-functions");
2324 XSETTERMINAL (args
[1], t
);
2325 Frun_hook_with_args (2, args
);
2327 reset_sys_modes (t
->display_info
.tty
);
2328 delete_keyboard_wait_descriptor (fileno (f
));
2332 if (f
!= t
->display_info
.tty
->output
)
2333 fclose (t
->display_info
.tty
->output
);
2336 t
->display_info
.tty
->input
= 0;
2337 t
->display_info
.tty
->output
= 0;
2339 if (FRAMEP (t
->display_info
.tty
->top_frame
))
2340 SET_FRAME_VISIBLE (XFRAME (t
->display_info
.tty
->top_frame
), 0);
2344 /* Clear display hooks to prevent further output. */
2345 clear_tty_hooks (t
);
2350 DEFUN ("resume-tty", Fresume_tty
, Sresume_tty
, 0, 1, 0,
2351 doc
: /* Resume the previously suspended terminal device TTY.
2352 The terminal is opened and reinitialized. Frames that are on the
2353 suspended terminal are revived.
2355 It is an error to resume a terminal while another terminal is active
2358 This function runs `resume-tty-functions' after resuming the terminal.
2359 The functions are run with one arg, the id of the resumed terminal
2362 `resume-tty' does nothing if it is called on a device that is not
2365 TTY may be a terminal object, a frame, or nil (meaning the selected
2366 frame's terminal). */)
2369 struct terminal
*t
= get_tty_terminal (tty
, 1);
2373 error ("Unknown tty device");
2375 if (!t
->display_info
.tty
->input
)
2377 if (get_named_tty (t
->display_info
.tty
->name
))
2378 error ("Cannot resume display while another display is active on the same device");
2381 t
->display_info
.tty
->output
= stdout
;
2382 t
->display_info
.tty
->input
= stdin
;
2384 fd
= emacs_open (t
->display_info
.tty
->name
, O_RDWR
| O_NOCTTY
, 0);
2385 t
->display_info
.tty
->input
= t
->display_info
.tty
->output
2386 = fd
< 0 ? 0 : fdopen (fd
, "w+");
2388 if (! t
->display_info
.tty
->input
)
2390 int open_errno
= errno
;
2392 report_file_errno ("Cannot reopen tty device",
2393 build_string (t
->display_info
.tty
->name
),
2397 if (!O_IGNORE_CTTY
&& strcmp (t
->display_info
.tty
->name
, DEV_TTY
) != 0)
2398 dissociate_if_controlling_tty (fd
);
2401 add_keyboard_wait_descriptor (fd
);
2403 if (FRAMEP (t
->display_info
.tty
->top_frame
))
2405 struct frame
*f
= XFRAME (t
->display_info
.tty
->top_frame
);
2407 int old_height
= FRAME_COLS (f
);
2408 int old_width
= FRAME_TOTAL_LINES (f
);
2410 /* Check if terminal/window size has changed while the frame
2412 get_tty_size (fileno (t
->display_info
.tty
->input
), &width
, &height
);
2413 if (width
!= old_width
|| height
!= old_height
)
2414 change_frame_size (f
, width
, height
- FRAME_MENU_BAR_LINES (f
),
2416 SET_FRAME_VISIBLE (XFRAME (t
->display_info
.tty
->top_frame
), 1);
2420 init_sys_modes (t
->display_info
.tty
);
2423 /* Run `resume-tty-functions'. */
2424 Lisp_Object args
[2];
2425 args
[0] = intern ("resume-tty-functions");
2426 XSETTERMINAL (args
[1], t
);
2427 Frun_hook_with_args (2, args
);
2437 /***********************************************************************
2439 ***********************************************************************/
2443 #ifndef HAVE_WINDOW_SYSTEM
2445 term_mouse_moveto (int x
, int y
)
2447 /* TODO: how to set mouse position?
2450 name = (const char *) ttyname (0);
2451 fd = emacs_open (name, O_WRONLY, 0);
2452 SOME_FUNCTION (x, y, fd);
2455 last_mouse_y = y; */
2457 #endif /* HAVE_WINDOW_SYSTEM */
2459 /* Implementation of draw_row_with_mouse_face for TTY/GPM. */
2461 tty_draw_row_with_mouse_face (struct window
*w
, struct glyph_row
*row
,
2462 int start_hpos
, int end_hpos
,
2463 enum draw_glyphs_face draw
)
2465 int nglyphs
= end_hpos
- start_hpos
;
2466 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2467 struct tty_display_info
*tty
= FRAME_TTY (f
);
2468 int face_id
= tty
->mouse_highlight
.mouse_face_face_id
;
2469 int save_x
, save_y
, pos_x
, pos_y
;
2471 if (end_hpos
>= row
->used
[TEXT_AREA
])
2472 nglyphs
= row
->used
[TEXT_AREA
] - start_hpos
;
2474 pos_y
= row
->y
+ WINDOW_TOP_EDGE_Y (w
);
2475 pos_x
= row
->used
[LEFT_MARGIN_AREA
] + start_hpos
+ WINDOW_LEFT_EDGE_X (w
);
2477 /* Save current cursor co-ordinates. */
2478 save_y
= curY (tty
);
2479 save_x
= curX (tty
);
2480 cursor_to (f
, pos_y
, pos_x
);
2482 if (draw
== DRAW_MOUSE_FACE
)
2483 tty_write_glyphs_with_face (f
, row
->glyphs
[TEXT_AREA
] + start_hpos
,
2485 else if (draw
== DRAW_NORMAL_TEXT
)
2486 write_glyphs (f
, row
->glyphs
[TEXT_AREA
] + start_hpos
, nglyphs
);
2488 cursor_to (f
, save_y
, save_x
);
2492 term_mouse_movement (struct frame
*frame
, Gpm_Event
*event
)
2494 /* Has the mouse moved off the glyph it was on at the last sighting? */
2495 if (event
->x
!= last_mouse_x
|| event
->y
!= last_mouse_y
)
2497 frame
->mouse_moved
= 1;
2498 note_mouse_highlight (frame
, event
->x
, event
->y
);
2499 /* Remember which glyph we're now on. */
2500 last_mouse_x
= event
->x
;
2501 last_mouse_y
= event
->y
;
2507 /* Return the Time that corresponds to T. Wrap around on overflow. */
2509 timeval_to_Time (struct timeval
const *t
)
2515 ms
= t
->tv_usec
/ 1000;
2519 /* Return the current position of the mouse.
2521 Set *f to the frame the mouse is in, or zero if the mouse is in no
2522 Emacs frame. If it is set to zero, all the other arguments are
2525 Set *bar_window to Qnil, and *x and *y to the column and
2526 row of the character cell the mouse is over.
2528 Set *timeptr to the time the mouse was at the returned position.
2530 This clears mouse_moved until the next motion
2533 term_mouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
2534 enum scroll_bar_part
*part
, Lisp_Object
*x
,
2535 Lisp_Object
*y
, Time
*timeptr
)
2539 *fp
= SELECTED_FRAME ();
2540 (*fp
)->mouse_moved
= 0;
2545 XSETINT (*x
, last_mouse_x
);
2546 XSETINT (*y
, last_mouse_y
);
2547 gettimeofday(&now
, 0);
2548 *timeptr
= timeval_to_Time (&now
);
2551 /* Prepare a mouse-event in *RESULT for placement in the input queue.
2553 If the event is a button press, then note that we have grabbed
2557 term_mouse_click (struct input_event
*result
, Gpm_Event
*event
,
2563 result
->kind
= GPM_CLICK_EVENT
;
2564 for (i
= 0, j
= GPM_B_LEFT
; i
< 3; i
++, j
>>= 1 )
2566 if (event
->buttons
& j
) {
2567 result
->code
= i
; /* button number */
2571 gettimeofday(&now
, 0);
2572 result
->timestamp
= timeval_to_Time (&now
);
2574 if (event
->type
& GPM_UP
)
2575 result
->modifiers
= up_modifier
;
2576 else if (event
->type
& GPM_DOWN
)
2577 result
->modifiers
= down_modifier
;
2579 result
->modifiers
= 0;
2581 if (event
->type
& GPM_SINGLE
)
2582 result
->modifiers
|= click_modifier
;
2584 if (event
->type
& GPM_DOUBLE
)
2585 result
->modifiers
|= double_modifier
;
2587 if (event
->type
& GPM_TRIPLE
)
2588 result
->modifiers
|= triple_modifier
;
2590 if (event
->type
& GPM_DRAG
)
2591 result
->modifiers
|= drag_modifier
;
2593 if (!(event
->type
& (GPM_MOVE
| GPM_DRAG
))) {
2596 if (event
->modifiers
& (1 << 0))
2597 result
->modifiers
|= shift_modifier
;
2600 if (event
->modifiers
& (1 << 2))
2601 result
->modifiers
|= ctrl_modifier
;
2603 /* 1 << KG_ALT || KG_ALTGR */
2604 if (event
->modifiers
& (1 << 3)
2605 || event
->modifiers
& (1 << 1))
2606 result
->modifiers
|= meta_modifier
;
2609 XSETINT (result
->x
, event
->x
);
2610 XSETINT (result
->y
, event
->y
);
2611 XSETFRAME (result
->frame_or_window
, f
);
2617 handle_one_term_event (struct tty_display_info
*tty
, Gpm_Event
*event
, struct input_event
* hold_quit
)
2619 struct frame
*f
= XFRAME (tty
->top_frame
);
2620 struct input_event ie
;
2628 if (event
->type
& (GPM_MOVE
| GPM_DRAG
)) {
2629 previous_help_echo_string
= help_echo_string
;
2630 help_echo_string
= Qnil
;
2632 Gpm_DrawPointer (event
->x
, event
->y
, fileno (tty
->output
));
2634 if (!term_mouse_movement (f
, event
))
2635 help_echo_string
= previous_help_echo_string
;
2637 /* If the contents of the global variable help_echo_string
2638 has changed, generate a HELP_EVENT. */
2639 if (!NILP (help_echo_string
)
2640 || !NILP (previous_help_echo_string
))
2647 term_mouse_click (&ie
, event
, f
);
2651 if (ie
.kind
!= NO_EVENT
)
2653 kbd_buffer_store_event_hold (&ie
, hold_quit
);
2658 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
2663 XSETFRAME (frame
, f
);
2667 gen_help_event (help_echo_string
, frame
, help_echo_window
,
2668 help_echo_object
, help_echo_pos
);
2675 DEFUN ("gpm-mouse-start", Fgpm_mouse_start
, Sgpm_mouse_start
,
2677 doc
: /* Open a connection to Gpm.
2678 Gpm-mouse can only be activated for one tty at a time. */)
2681 struct frame
*f
= SELECTED_FRAME ();
2682 struct tty_display_info
*tty
2683 = ((f
)->output_method
== output_termcap
2684 ? (f
)->terminal
->display_info
.tty
: NULL
);
2685 Gpm_Connect connection
;
2688 error ("Gpm-mouse only works in the GNU/Linux console");
2690 return Qnil
; /* Already activated, nothing to do. */
2692 error ("Gpm-mouse can only be activated for one tty at a time");
2694 connection
.eventMask
= ~0;
2695 connection
.defaultMask
= ~GPM_HARD
;
2696 connection
.maxMod
= ~0;
2697 connection
.minMod
= 0;
2700 if (Gpm_Open (&connection
, 0) < 0)
2701 error ("Gpm-mouse failed to connect to the gpm daemon");
2705 /* `init_sys_modes' arranges for mouse movements sent through gpm_fd
2706 to generate SIGIOs. Apparently we need to call reset_sys_modes
2707 before calling init_sys_modes. */
2708 reset_sys_modes (tty
);
2709 init_sys_modes (tty
);
2710 add_gpm_wait_descriptor (gpm_fd
);
2719 delete_gpm_wait_descriptor (fd
);
2720 while (Gpm_Close()); /* close all the stack */
2724 DEFUN ("gpm-mouse-stop", Fgpm_mouse_stop
, Sgpm_mouse_stop
,
2726 doc
: /* Close a connection to Gpm. */)
2729 struct frame
*f
= SELECTED_FRAME ();
2730 struct tty_display_info
*tty
2731 = ((f
)->output_method
== output_termcap
2732 ? (f
)->terminal
->display_info
.tty
: NULL
);
2734 if (!tty
|| gpm_tty
!= tty
)
2735 return Qnil
; /* Not activated on this terminal, nothing to do. */
2740 #endif /* HAVE_GPM */
2743 /***********************************************************************
2745 ***********************************************************************/
2747 #if !defined (MSDOS)
2749 /* TTY menu implementation and main ideas are borrowed from msdos.c.
2751 However, unlike on MSDOS, where the menu text is drawn directly to
2752 the display video memory, on a TTY we use display_string (see
2753 display_tty_menu_item in xdisp.c) to put the glyphs produced from
2754 the menu items into the frame's 'desired_matrix' glyph matrix, and
2755 then call update_frame_with_menu to deliver the results to the
2756 glass. The previous contents of the screen, in the form of the
2757 current_matrix, is stashed away, and used to restore screen
2758 contents when the menu selection changes or when the final
2759 selection is made and the menu should be popped down.
2761 The idea of this implementation was suggested by Gerd Moellmann. */
2763 #define TTYM_FAILURE -1
2764 #define TTYM_SUCCESS 1
2765 #define TTYM_NO_SELECT 2
2766 #define TTYM_IA_SELECT 3
2770 /* These hold text of the current and the previous menu help messages. */
2771 static const char *menu_help_message
, *prev_menu_help_message
;
2772 /* Pane number and item number of the menu item which generated the
2773 last menu help message. */
2774 static int menu_help_paneno
, menu_help_itemno
;
2776 static Lisp_Object Qtty_menu_navigation_map
, Qtty_menu_exit
;
2777 static Lisp_Object Qtty_menu_prev_item
, Qtty_menu_next_item
;
2778 static Lisp_Object Qtty_menu_next_menu
, Qtty_menu_prev_menu
;
2779 static Lisp_Object Qtty_menu_select
, Qtty_menu_ignore
;
2780 static Lisp_Object Qtty_menu_mouse_movement
;
2782 typedef struct tty_menu_struct
2786 struct tty_menu_struct
**submenu
;
2787 int *panenumber
; /* Also used as enabled flag. */
2788 ptrdiff_t allocated
;
2791 const char **help_text
;
2794 /* Create a brand new menu structure. */
2797 tty_menu_create (void)
2799 return xzalloc (sizeof *tty_menu_create ());
2802 /* Allocate some (more) memory for MENU ensuring that there is room for one
2806 tty_menu_make_room (tty_menu
*menu
)
2808 if (menu
->allocated
== menu
->count
)
2810 ptrdiff_t allocated
= menu
->allocated
;
2811 menu
->text
= xpalloc (menu
->text
, &allocated
, 1, -1, sizeof *menu
->text
);
2812 menu
->text
= xrealloc (menu
->text
, allocated
* sizeof *menu
->text
);
2813 menu
->submenu
= xrealloc (menu
->submenu
,
2814 allocated
* sizeof *menu
->submenu
);
2815 menu
->panenumber
= xrealloc (menu
->panenumber
,
2816 allocated
* sizeof *menu
->panenumber
);
2817 menu
->help_text
= xrealloc (menu
->help_text
,
2818 allocated
* sizeof *menu
->help_text
);
2819 menu
->allocated
= allocated
;
2823 /* Search the given menu structure for a given pane number. */
2826 tty_menu_search_pane (tty_menu
*menu
, int pane
)
2831 for (i
= 0; i
< menu
->count
; i
++)
2832 if (menu
->submenu
[i
])
2834 if (pane
== menu
->panenumber
[i
])
2835 return menu
->submenu
[i
];
2836 try = tty_menu_search_pane (menu
->submenu
[i
], pane
);
2840 return (tty_menu
*) 0;
2843 /* Determine how much screen space a given menu needs. */
2846 tty_menu_calc_size (tty_menu
*menu
, int *width
, int *height
)
2848 int i
, h2
, w2
, maxsubwidth
, maxheight
;
2850 maxsubwidth
= menu
->width
;
2851 maxheight
= menu
->count
;
2852 for (i
= 0; i
< menu
->count
; i
++)
2854 if (menu
->submenu
[i
])
2856 tty_menu_calc_size (menu
->submenu
[i
], &w2
, &h2
);
2857 if (w2
> maxsubwidth
) maxsubwidth
= w2
;
2858 if (i
+ h2
> maxheight
) maxheight
= i
+ h2
;
2861 *width
= maxsubwidth
;
2862 *height
= maxheight
;
2866 mouse_get_xy (int *x
, int *y
)
2868 struct frame
*sf
= SELECTED_FRAME ();
2869 Lisp_Object lmx
= Qnil
, lmy
= Qnil
, lisp_dummy
;
2870 enum scroll_bar_part part_dummy
;
2873 if (FRAME_TERMINAL (sf
)->mouse_position_hook
)
2874 (*FRAME_TERMINAL (sf
)->mouse_position_hook
) (&sf
, -1,
2875 &lisp_dummy
, &part_dummy
,
2885 /* Display MENU at (X,Y) using FACES, starting with FIRST_ITEM
2889 tty_menu_display (tty_menu
*menu
, int x
, int y
, int pn
, int *faces
,
2890 int mx
, int my
, int first_item
, bool disp_help
)
2892 int i
, face
, width
, enabled
, mousehere
, row
, col
;
2893 struct frame
*sf
= SELECTED_FRAME ();
2894 struct tty_display_info
*tty
= FRAME_TTY (sf
);
2895 /* Don't try to display more menu items than the console can display
2896 using the available screen lines. Exclude the echo area line, as
2897 it will be overwritten by the help-echo anyway. */
2898 int max_items
= min (menu
->count
- first_item
, FRAME_TOTAL_LINES (sf
) - 1 - y
);
2900 menu_help_message
= NULL
;
2902 width
= menu
->width
;
2903 col
= cursorX (tty
);
2904 row
= cursorY (tty
);
2905 for (i
= 0; i
< max_items
; i
++)
2907 int max_width
= width
+ 2; /* +2 for padding blanks on each side */
2908 int j
= i
+ first_item
;
2910 if (menu
->submenu
[j
])
2911 max_width
+= 2; /* for displaying " >" after the item */
2913 = (!menu
->submenu
[j
] && menu
->panenumber
[j
]) || (menu
->submenu
[j
]);
2914 mousehere
= (y
+ i
== my
&& x
<= mx
&& mx
< x
+ max_width
);
2915 face
= faces
[enabled
+ mousehere
* 2];
2916 /* Display the menu help string for the i-th menu item even if
2917 the menu item is currently disabled. That's what the GUI
2919 if (disp_help
&& enabled
+ mousehere
* 2 >= 2)
2921 menu_help_message
= menu
->help_text
[j
];
2922 menu_help_paneno
= pn
- 1;
2923 menu_help_itemno
= j
;
2925 /* Take note of the coordinates of the active menu item, to
2926 display the cursor there. */
2932 display_tty_menu_item (menu
->text
[j
], max_width
, face
, x
, y
+ i
,
2933 menu
->submenu
[j
] != NULL
);
2935 update_frame_with_menu (sf
, row
, col
);
2938 /* --------------------------- X Menu emulation ---------------------- */
2940 /* Create a new pane and place it on the outer-most level. */
2943 tty_menu_add_pane (tty_menu
*menu
, const char *txt
)
2947 tty_menu_make_room (menu
);
2948 menu
->submenu
[menu
->count
] = tty_menu_create ();
2949 menu
->text
[menu
->count
] = (char *)txt
;
2950 menu
->panenumber
[menu
->count
] = ++menu
->panecount
;
2951 menu
->help_text
[menu
->count
] = NULL
;
2954 /* Update the menu width, if necessary. */
2955 len
= menu_item_width ((const unsigned char *) txt
);
2956 if (len
> menu
->width
)
2959 return menu
->panecount
;
2962 /* Create a new item in a menu pane. */
2965 tty_menu_add_selection (tty_menu
*menu
, int pane
,
2966 char *txt
, bool enable
, char const *help_text
)
2972 menu
= tty_menu_search_pane (menu
, pane
);
2976 tty_menu_make_room (menu
);
2977 menu
->submenu
[menu
->count
] = (tty_menu
*) 0;
2978 menu
->text
[menu
->count
] = txt
;
2979 menu
->panenumber
[menu
->count
] = enable
;
2980 menu
->help_text
[menu
->count
] = help_text
;
2983 /* Update the menu width, if necessary. */
2984 len
= menu_item_width ((const unsigned char *) txt
);
2985 if (len
> menu
->width
)
2991 /* Decide where the menu would be placed if requested at (X,Y). */
2994 tty_menu_locate (tty_menu
*menu
, int x
, int y
,
2995 int *ulx
, int *uly
, int *width
, int *height
)
2997 tty_menu_calc_size (menu
, width
, height
);
3003 struct tty_menu_state
3005 struct glyph_matrix
*screen_behind
;
3011 /* Save away the contents of frame F's current frame matrix, and
3012 enable all its rows. Value is a glyph matrix holding the contents
3013 of F's current frame matrix with all its glyph rows enabled. */
3015 static struct glyph_matrix
*
3016 save_and_enable_current_matrix (struct frame
*f
)
3019 struct glyph_matrix
*saved
= xzalloc (sizeof *saved
);
3020 saved
->nrows
= f
->current_matrix
->nrows
;
3021 saved
->rows
= xzalloc (saved
->nrows
* sizeof *saved
->rows
);
3023 for (i
= 0; i
< saved
->nrows
; ++i
)
3025 struct glyph_row
*from
= f
->current_matrix
->rows
+ i
;
3026 struct glyph_row
*to
= saved
->rows
+ i
;
3027 ptrdiff_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
3029 to
->glyphs
[TEXT_AREA
] = xmalloc (nbytes
);
3030 memcpy (to
->glyphs
[TEXT_AREA
], from
->glyphs
[TEXT_AREA
], nbytes
);
3031 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
3032 /* Make sure every row is enabled, or else update_frame will not
3033 redraw them. (Rows that are identical to what is already on
3034 screen will not be redrawn anyway.) */
3035 to
->enabled_p
= true;
3036 to
->hash
= from
->hash
;
3042 /* Restore the contents of frame F's desired frame matrix from SAVED,
3043 and free memory associated with SAVED. */
3046 restore_desired_matrix (struct frame
*f
, struct glyph_matrix
*saved
)
3050 for (i
= 0; i
< saved
->nrows
; ++i
)
3052 struct glyph_row
*from
= saved
->rows
+ i
;
3053 struct glyph_row
*to
= f
->desired_matrix
->rows
+ i
;
3054 ptrdiff_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
3056 eassert (to
->glyphs
[TEXT_AREA
] != from
->glyphs
[TEXT_AREA
]);
3057 memcpy (to
->glyphs
[TEXT_AREA
], from
->glyphs
[TEXT_AREA
], nbytes
);
3058 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
3059 to
->enabled_p
= from
->enabled_p
;
3060 to
->hash
= from
->hash
;
3065 free_saved_screen (struct glyph_matrix
*saved
)
3070 return; /* Already freed! */
3072 for (i
= 0; i
< saved
->nrows
; ++i
)
3074 struct glyph_row
*from
= saved
->rows
+ i
;
3076 xfree (from
->glyphs
[TEXT_AREA
]);
3079 xfree (saved
->rows
);
3083 /* Update the display of frame F from its saved contents. */
3085 screen_update (struct frame
*f
, struct glyph_matrix
*mtx
)
3087 restore_desired_matrix (f
, mtx
);
3088 update_frame_with_menu (f
, -1, -1);
3094 MI_ITEM_SELECTED
= 1,
3097 MI_SCROLL_FORWARD
= 4,
3101 /* Read user input and return X and Y coordinates where that input
3102 puts us. We only consider mouse movement and click events, and
3103 keyboard movement commands; the rest are ignored. */
3105 read_menu_input (struct frame
*sf
, int *x
, int *y
, int min_y
, int max_y
,
3110 *first_time
= false;
3111 sf
->mouse_moved
= 1;
3116 bool usable_input
= 1;
3117 mi_result st
= MI_CONTINUE
;
3118 struct tty_display_info
*tty
= FRAME_TTY (sf
);
3119 Lisp_Object saved_mouse_tracking
= do_mouse_tracking
;
3121 /* Signal the keyboard reading routines we are displaying a menu
3122 on this terminal. */
3123 tty
->showing_menu
= 1;
3124 /* We want mouse movements be reported by read_menu_command. */
3125 do_mouse_tracking
= Qt
;
3127 cmd
= read_menu_command ();
3128 } while (NILP (cmd
));
3129 tty
->showing_menu
= 0;
3130 do_mouse_tracking
= saved_mouse_tracking
;
3132 if (EQ (cmd
, Qt
) || EQ (cmd
, Qtty_menu_exit
)
3133 /* If some input switched frames under our feet, exit the
3134 menu, since the menu faces are no longer valid, and the
3135 menu is no longer relevant anyway. */
3136 || sf
!= SELECTED_FRAME ())
3137 return MI_QUIT_MENU
;
3138 if (EQ (cmd
, Qtty_menu_mouse_movement
))
3139 mouse_get_xy (x
, y
);
3140 else if (EQ (cmd
, Qtty_menu_next_menu
))
3145 else if (EQ (cmd
, Qtty_menu_prev_menu
))
3150 else if (EQ (cmd
, Qtty_menu_next_item
))
3155 st
= MI_SCROLL_FORWARD
;
3157 else if (EQ (cmd
, Qtty_menu_prev_item
))
3162 st
= MI_SCROLL_BACK
;
3164 else if (EQ (cmd
, Qtty_menu_select
))
3165 st
= MI_ITEM_SELECTED
;
3166 else if (!EQ (cmd
, Qtty_menu_ignore
))
3169 sf
->mouse_moved
= 1;
3175 /* Display menu, wait for user's response, and return that response. */
3177 tty_menu_activate (tty_menu
*menu
, int *pane
, int *selidx
,
3178 int x0
, int y0
, char **txt
,
3179 void (*help_callback
)(char const *, int, int),
3180 bool kbd_navigation
)
3182 struct tty_menu_state
*state
;
3183 int statecount
, x
, y
, i
;
3184 bool leave
, onepane
;
3185 int result
IF_LINT (= 0);
3186 int title_faces
[4]; /* Face to display the menu title. */
3187 int faces
[4], buffers_num_deleted
= 0;
3188 struct frame
*sf
= SELECTED_FRAME ();
3189 struct tty_display_info
*tty
= FRAME_TTY (sf
);
3191 Lisp_Object selectface
;
3195 /* Don't allow non-positive x0 and y0, lest the menu will wrap
3196 around the display. */
3202 state
= alloca (menu
->panecount
* sizeof (struct tty_menu_state
));
3203 memset (state
, 0, sizeof (*state
));
3205 = lookup_derived_face (sf
, intern ("tty-menu-disabled-face"),
3206 DEFAULT_FACE_ID
, 1);
3208 = lookup_derived_face (sf
, intern ("tty-menu-enabled-face"),
3209 DEFAULT_FACE_ID
, 1);
3210 selectface
= intern ("tty-menu-selected-face");
3211 faces
[2] = lookup_derived_face (sf
, selectface
,
3213 faces
[3] = lookup_derived_face (sf
, selectface
,
3216 /* Make sure the menu title is always displayed with
3217 `tty-menu-selected-face', no matter where the mouse pointer is. */
3218 for (i
= 0; i
< 4; i
++)
3219 title_faces
[i
] = faces
[3];
3223 /* Don't let the title for the "Buffers" popup menu include a
3224 digit (which is ugly).
3226 This is a terrible kludge, but I think the "Buffers" case is
3227 the only one where the title includes a number, so it doesn't
3228 seem to be necessary to make this more general. */
3229 if (strncmp (menu
->text
[0], "Buffers 1", 9) == 0)
3231 menu
->text
[0][7] = '\0';
3232 buffers_num_deleted
= 1;
3235 /* Force update of the current frame, so that the desired and the
3236 current matrices are identical. */
3237 update_frame_with_menu (sf
, -1, -1);
3238 state
[0].menu
= menu
;
3239 state
[0].screen_behind
= save_and_enable_current_matrix (sf
);
3241 /* Display the menu title. We subtract 1 from x0 and y0 because we
3242 want to interpret them as zero-based column and row coordinates,
3243 and also because we want the first item of the menu, not its
3244 title, to appear at x0,y0. */
3245 tty_menu_display (menu
, x0
- 1, y0
- 1, 1, title_faces
, x0
- 1, y0
- 1, 0, 0);
3247 /* Turn off the cursor. Otherwise it shows through the menu
3248 panes, which is ugly. */
3249 col
= cursorX (tty
);
3250 row
= cursorY (tty
);
3251 tty_hide_cursor (tty
);
3253 if (buffers_num_deleted
)
3254 menu
->text
[0][7] = ' ';
3255 onepane
= menu
->count
== 1 && menu
->submenu
[0];
3258 menu
->width
= menu
->submenu
[0]->width
;
3259 state
[0].menu
= menu
->submenu
[0];
3263 state
[0].menu
= menu
;
3265 state
[0].x
= x0
- 1;
3267 state
[0].pane
= onepane
;
3276 mi_result input_status
;
3277 int min_y
= state
[0].y
;
3278 int max_y
= min (min_y
+ state
[0].menu
->count
, FRAME_TOTAL_LINES (sf
) - 1) - 1;
3280 input_status
= read_menu_input (sf
, &x
, &y
, min_y
, max_y
, &first_time
);
3284 switch (input_status
)
3287 /* Remove the last help-echo, so that it doesn't
3288 re-appear after "Quit". */
3289 show_help_echo (Qnil
, Qnil
, Qnil
, Qnil
);
3290 result
= TTYM_NO_SELECT
;
3304 case MI_SCROLL_FORWARD
:
3305 if (y
- min_y
== state
[0].menu
->count
- 1 - first_item
)
3314 case MI_SCROLL_BACK
:
3315 if (first_item
== 0)
3318 first_item
= state
[0].menu
->count
- 1 - (y
- min_y
);
3325 /* MI_ITEM_SELECTED is handled below, so nothing to do. */
3329 if (sf
->mouse_moved
&& input_status
!= MI_QUIT_MENU
)
3331 sf
->mouse_moved
= 0;
3332 result
= TTYM_IA_SELECT
;
3333 for (i
= 0; i
< statecount
; i
++)
3334 if (state
[i
].x
<= x
&& x
< state
[i
].x
+ state
[i
].menu
->width
+ 2)
3336 int dy
= y
- state
[i
].y
+ first_item
;
3337 if (0 <= dy
&& dy
< state
[i
].menu
->count
)
3339 if (!state
[i
].menu
->submenu
[dy
])
3341 if (state
[i
].menu
->panenumber
[dy
])
3342 result
= TTYM_SUCCESS
;
3344 result
= TTYM_IA_SELECT
;
3346 *pane
= state
[i
].pane
- 1;
3348 /* We hit some part of a menu, so drop extra menus that
3349 have been opened. That does not include an open and
3351 if (i
!= statecount
- 2
3352 || state
[i
].menu
->submenu
[dy
] != state
[i
+ 1].menu
)
3353 while (i
!= statecount
- 1)
3356 screen_update (sf
, state
[statecount
].screen_behind
);
3357 state
[statecount
].screen_behind
= NULL
;
3359 if (i
== statecount
- 1 && state
[i
].menu
->submenu
[dy
])
3361 tty_menu_display (state
[i
].menu
,
3365 faces
, x
, y
, first_item
, 1);
3366 state
[statecount
].menu
= state
[i
].menu
->submenu
[dy
];
3367 state
[statecount
].pane
= state
[i
].menu
->panenumber
[dy
];
3368 state
[statecount
].screen_behind
3369 = save_and_enable_current_matrix (sf
);
3371 = state
[i
].x
+ state
[i
].menu
->width
+ 2;
3372 state
[statecount
].y
= y
;
3377 tty_menu_display (state
[statecount
- 1].menu
,
3378 state
[statecount
- 1].x
,
3379 state
[statecount
- 1].y
,
3380 state
[statecount
- 1].pane
,
3381 faces
, x
, y
, first_item
, 1);
3382 /* The call to display help-echo below will move the cursor,
3383 so remember its current position as computed by
3384 tty_menu_display. */
3385 col
= cursorX (tty
);
3386 row
= cursorY (tty
);
3389 /* Display the help-echo message for the currently-selected menu
3391 if ((menu_help_message
|| prev_menu_help_message
)
3392 && menu_help_message
!= prev_menu_help_message
)
3394 help_callback (menu_help_message
,
3395 menu_help_paneno
, menu_help_itemno
);
3396 /* Move the cursor to the beginning of the current menu
3397 item, so that screen readers and other accessibility aids
3398 know where the active region is. */
3399 cursor_to (sf
, row
, col
);
3400 prev_menu_help_message
= menu_help_message
;
3402 /* Both tty_menu_display and help_callback invoke update_end,
3403 which calls tty_show_cursor. Re-hide it, so it doesn't show
3404 through the menus. */
3405 tty_hide_cursor (tty
);
3406 fflush (tty
->output
);
3409 sf
->mouse_moved
= 0;
3410 screen_update (sf
, state
[0].screen_behind
);
3411 while (statecount
--)
3412 free_saved_screen (state
[statecount
].screen_behind
);
3413 tty_show_cursor (tty
); /* Turn cursor back on. */
3414 fflush (tty
->output
);
3416 /* Clean up any mouse events that are waiting inside Emacs event queue.
3417 These events are likely to be generated before the menu was even
3418 displayed, probably because the user pressed and released the button
3419 (which invoked the menu) too quickly. If we don't remove these events,
3420 Emacs will process them after we return and surprise the user. */
3421 discard_mouse_events ();
3422 if (!kbd_buffer_events_waiting ())
3423 clear_input_pending ();
3427 /* Dispose of a menu. */
3430 tty_menu_destroy (tty_menu
*menu
)
3433 if (menu
->allocated
)
3435 for (i
= 0; i
< menu
->count
; i
++)
3436 if (menu
->submenu
[i
])
3437 tty_menu_destroy (menu
->submenu
[i
]);
3439 xfree (menu
->submenu
);
3440 xfree (menu
->panenumber
);
3441 xfree (menu
->help_text
);
3444 menu_help_message
= prev_menu_help_message
= NULL
;
3447 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3449 PANE is the pane number, and ITEM is the menu item number in
3450 the menu (currently not used). */
3453 tty_menu_help_callback (char const *help_string
, int pane
, int item
)
3455 Lisp_Object
*first_item
;
3456 Lisp_Object pane_name
;
3457 Lisp_Object menu_object
;
3459 first_item
= XVECTOR (menu_items
)->contents
;
3460 if (EQ (first_item
[0], Qt
))
3461 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3462 else if (EQ (first_item
[0], Qquote
))
3463 /* This shouldn't happen, see xmenu_show. */
3464 pane_name
= empty_unibyte_string
;
3466 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3468 /* (menu-item MENU-NAME PANE-NUMBER) */
3469 menu_object
= list3 (Qmenu_item
, pane_name
, make_number (pane
));
3470 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3471 Qnil
, menu_object
, make_number (item
));
3475 tty_pop_down_menu (Lisp_Object arg
)
3477 tty_menu
*menu
= XSAVE_POINTER (arg
, 0);
3480 tty_menu_destroy (menu
);
3484 /* Return the zero-based index of the last menu-bar item on frame F. */
3486 tty_menu_last_menubar_item (struct frame
*f
)
3490 eassert (FRAME_TERMCAP_P (f
) && FRAME_LIVE_P (f
));
3491 if (FRAME_TERMCAP_P (f
) && FRAME_LIVE_P (f
))
3493 Lisp_Object items
= FRAME_MENU_BAR_ITEMS (f
);
3495 while (i
< ASIZE (items
))
3499 str
= AREF (items
, i
+ 1);
3504 i
-= 4; /* Went one too far! */
3509 /* Find in frame F's menu bar the menu item that is next or previous
3510 to the item at X/Y, and return that item's position in X/Y. WHICH
3511 says which one--next or previous--item to look for. X and Y are
3512 measured in character cells. This should only be called on TTY
3515 tty_menu_new_item_coords (struct frame
*f
, int which
, int *x
, int *y
)
3517 eassert (FRAME_TERMCAP_P (f
) && FRAME_LIVE_P (f
));
3518 if (FRAME_TERMCAP_P (f
) && FRAME_LIVE_P (f
))
3520 Lisp_Object items
= FRAME_MENU_BAR_ITEMS (f
);
3521 int last_i
= tty_menu_last_menubar_item (f
);
3524 /* This loop assumes a single menu-bar line, and will fail to
3525 find an item if it is not in the first line. Note that
3526 make_lispy_event in keyboard.c makes the same assumption. */
3527 for (i
= 0, prev_x
= -1; i
< ASIZE (items
); i
+= 4)
3529 Lisp_Object pos
, str
;
3532 str
= AREF (items
, i
+ 1);
3533 pos
= AREF (items
, i
+ 3);
3538 /* We use <= so the blank between 2 items on a TTY is
3539 considered part of the previous item. */
3540 && *x
<= ix
+ menu_item_width (SDATA (str
)))
3542 /* Found current item. Now compute the X coordinate of
3543 the previous or next item. */
3544 if (which
== TTYM_NEXT
)
3547 *x
= XINT (AREF (items
, i
+ 4 + 3));
3549 *x
= 0; /* Wrap around to the first item. */
3551 else if (prev_x
< 0)
3553 /* Wrap around to the last item. */
3554 *x
= XINT (AREF (items
, last_i
+ 3));
3565 /* WINDOWSNT uses this as menu_show_hook, see w32console.c. */
3567 tty_menu_show (struct frame
*f
, int x
, int y
, int menuflags
,
3568 Lisp_Object title
, const char **error_name
)
3571 int pane
, selidx
, lpane
, status
;
3572 Lisp_Object entry
, pane_prefix
;
3574 int ulx
, uly
, width
, height
;
3576 int dispwidth
, dispheight
;
3577 int i
, j
, lines
, maxlines
;
3579 ptrdiff_t specpdl_count
;
3581 eassert (FRAME_TERMCAP_P (f
));
3584 if (menu_items_n_panes
== 0)
3587 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3589 *error_name
= "Empty menu";
3593 /* Make the menu on that window. */
3594 menu
= tty_menu_create ();
3596 /* Don't GC while we prepare and show the menu, because we give the
3597 menu functions pointers to the contents of strings. */
3598 specpdl_count
= inhibit_garbage_collection ();
3600 /* Avoid crashes if, e.g., another client will connect while we
3602 temporarily_switch_to_single_kboard (f
);
3604 /* Adjust coordinates to be root-window-relative. */
3605 item_x
= x
+= f
->left_pos
;
3606 item_y
= y
+= f
->top_pos
;
3608 /* Create all the necessary panes and their items. */
3609 maxwidth
= maxlines
= lines
= i
= 0;
3610 lpane
= TTYM_FAILURE
;
3611 while (i
< menu_items_used
)
3613 if (EQ (AREF (menu_items
, i
), Qt
))
3615 /* Create a new pane. */
3616 Lisp_Object pane_name
, prefix
;
3617 const char *pane_string
;
3619 maxlines
= max (maxlines
, lines
);
3621 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
3622 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
3623 pane_string
= (NILP (pane_name
)
3624 ? "" : SSDATA (pane_name
));
3625 if ((menuflags
& MENU_KEYMAPS
) && !NILP (prefix
))
3628 lpane
= tty_menu_add_pane (menu
, pane_string
);
3629 if (lpane
== TTYM_FAILURE
)
3631 tty_menu_destroy (menu
);
3632 *error_name
= "Can't create pane";
3636 i
+= MENU_ITEMS_PANE_LENGTH
;
3638 /* Find the width of the widest item in this pane. */
3640 while (j
< menu_items_used
)
3643 item
= AREF (menu_items
, j
);
3651 width
= SBYTES (item
);
3652 if (width
> maxwidth
)
3655 j
+= MENU_ITEMS_ITEM_LENGTH
;
3658 /* Ignore a nil in the item list.
3659 It's meaningful only for dialog boxes. */
3660 else if (EQ (AREF (menu_items
, i
), Qquote
))
3664 /* Create a new item within current pane. */
3665 Lisp_Object item_name
, enable
, descrip
, help
;
3667 char const *help_string
;
3669 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
3670 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
3671 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
3672 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
3673 help_string
= STRINGP (help
) ? SSDATA (help
) : NULL
;
3675 if (!NILP (descrip
))
3677 /* If alloca is fast, use that to make the space,
3678 to reduce gc needs. */
3679 item_data
= (char *) alloca (maxwidth
+ SBYTES (descrip
) + 1);
3680 memcpy (item_data
, SSDATA (item_name
), SBYTES (item_name
));
3681 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3683 memcpy (item_data
+ j
, SSDATA (descrip
), SBYTES (descrip
));
3684 item_data
[j
+ SBYTES (descrip
)] = 0;
3687 item_data
= SSDATA (item_name
);
3689 if (lpane
== TTYM_FAILURE
3690 || (! tty_menu_add_selection (menu
, lpane
, item_data
,
3691 !NILP (enable
), help_string
)))
3693 tty_menu_destroy (menu
);
3694 *error_name
= "Can't add selection to menu";
3698 i
+= MENU_ITEMS_ITEM_LENGTH
;
3703 maxlines
= max (maxlines
, lines
);
3705 /* All set and ready to fly. */
3706 dispwidth
= f
->text_cols
;
3707 dispheight
= f
->text_lines
;
3708 x
= min (x
, dispwidth
);
3709 y
= min (y
, dispheight
);
3712 tty_menu_locate (menu
, x
, y
, &ulx
, &uly
, &width
, &height
);
3713 if (ulx
+ width
> dispwidth
)
3715 x
-= (ulx
+ width
) - dispwidth
;
3716 ulx
= dispwidth
- width
;
3718 if (uly
+ height
> dispheight
)
3720 y
-= (uly
+ height
) - dispheight
;
3721 uly
= dispheight
- height
;
3724 if (FRAME_HAS_MINIBUF_P (f
) && uly
+ height
> dispheight
- 2)
3726 /* Move the menu away of the echo area, to avoid overwriting the
3727 menu with help echo messages or vice versa. */
3728 if (BUFFERP (echo_area_buffer
[0]) && WINDOWP (echo_area_window
))
3730 y
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
)) + 1;
3731 uly
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
)) + 1;
3740 if (ulx
< 0) x
-= ulx
;
3741 if (uly
< 0) y
-= uly
;
3744 /* This code doesn't make sense on a TTY, since it can easily annul
3745 the adjustments above that carefully avoid truncation of the menu
3746 items. I think it was written to fix some problem that only
3750 /* If position was not given by a mouse click, adjust so upper left
3751 corner of the menu as a whole ends up at given coordinates. This
3752 is what x-popup-menu says in its documentation. */
3754 y
+= 1.5 * height
/ (maxlines
+ 2);
3760 record_unwind_protect (tty_pop_down_menu
, make_save_ptr (menu
));
3762 specbind (Qoverriding_terminal_local_map
,
3763 Fsymbol_value (Qtty_menu_navigation_map
));
3764 status
= tty_menu_activate (menu
, &pane
, &selidx
, x
, y
, &datap
,
3765 tty_menu_help_callback
,
3766 menuflags
& MENU_KBD_NAVIGATION
);
3767 entry
= pane_prefix
= Qnil
;
3772 /* Find the item number SELIDX in pane number PANE. */
3774 while (i
< menu_items_used
)
3776 if (EQ (AREF (menu_items
, i
), Qt
))
3780 = AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
3782 i
+= MENU_ITEMS_PANE_LENGTH
;
3791 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
3792 if (menuflags
& MENU_KEYMAPS
)
3794 entry
= Fcons (entry
, Qnil
);
3795 if (!NILP (pane_prefix
))
3796 entry
= Fcons (pane_prefix
, entry
);
3802 i
+= MENU_ITEMS_ITEM_LENGTH
;
3809 tty_menu_new_item_coords (f
, status
, &item_x
, &item_y
);
3810 entry
= Fcons (make_number (item_x
), make_number (item_y
));
3814 *error_name
= "Can't activate menu";
3815 case TTYM_IA_SELECT
:
3817 case TTYM_NO_SELECT
:
3818 /* If the selected frame was changed while we displayed a menu,
3819 throw to top level in order to undo any temporary settings
3820 made by TTY menu code. */
3821 if (f
!= SELECTED_FRAME ())
3823 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
3824 the menu was invoked with a mouse event as POSITION). */
3825 if (!(menuflags
& MENU_FOR_CLICK
))
3826 Fsignal (Qquit
, Qnil
);
3832 unbind_to (specpdl_count
, Qnil
);
3840 /***********************************************************************
3842 ***********************************************************************/
3844 /* Initialize the tty-dependent part of frame F. The frame must
3845 already have its device initialized. */
3848 create_tty_output (struct frame
*f
)
3850 struct tty_output
*t
= xzalloc (sizeof *t
);
3852 eassert (FRAME_TERMCAP_P (f
));
3854 t
->display_info
= FRAME_TERMINAL (f
)->display_info
.tty
;
3856 f
->output_data
.tty
= t
;
3859 /* Delete frame F's face cache, and its tty-dependent part. */
3862 tty_free_frame_resources (struct frame
*f
)
3864 eassert (FRAME_TERMCAP_P (f
));
3865 free_frame_faces (f
);
3866 xfree (f
->output_data
.tty
);
3871 /* Delete frame F's face cache. */
3874 tty_free_frame_resources (struct frame
*f
)
3876 eassert (FRAME_TERMCAP_P (f
) || FRAME_MSDOS_P (f
));
3877 free_frame_faces (f
);
3881 /* Reset the hooks in TERMINAL. */
3884 clear_tty_hooks (struct terminal
*terminal
)
3887 terminal
->cursor_to_hook
= 0;
3888 terminal
->raw_cursor_to_hook
= 0;
3889 terminal
->clear_to_end_hook
= 0;
3890 terminal
->clear_frame_hook
= 0;
3891 terminal
->clear_end_of_line_hook
= 0;
3892 terminal
->ins_del_lines_hook
= 0;
3893 terminal
->insert_glyphs_hook
= 0;
3894 terminal
->write_glyphs_hook
= 0;
3895 terminal
->delete_glyphs_hook
= 0;
3896 terminal
->ring_bell_hook
= 0;
3897 terminal
->reset_terminal_modes_hook
= 0;
3898 terminal
->set_terminal_modes_hook
= 0;
3899 terminal
->update_begin_hook
= 0;
3900 terminal
->update_end_hook
= 0;
3901 terminal
->set_terminal_window_hook
= 0;
3902 terminal
->mouse_position_hook
= 0;
3903 terminal
->frame_rehighlight_hook
= 0;
3904 terminal
->frame_raise_lower_hook
= 0;
3905 terminal
->fullscreen_hook
= 0;
3906 terminal
->menu_show_hook
= 0;
3907 terminal
->set_vertical_scroll_bar_hook
= 0;
3908 terminal
->set_horizontal_scroll_bar_hook
= 0;
3909 terminal
->condemn_scroll_bars_hook
= 0;
3910 terminal
->redeem_scroll_bar_hook
= 0;
3911 terminal
->judge_scroll_bars_hook
= 0;
3912 terminal
->read_socket_hook
= 0;
3913 terminal
->frame_up_to_date_hook
= 0;
3915 /* Leave these two set, or suspended frames are not deleted
3917 terminal
->delete_frame_hook
= &tty_free_frame_resources
;
3918 terminal
->delete_terminal_hook
= &delete_tty
;
3921 /* Initialize hooks in TERMINAL with the values needed for a tty. */
3924 set_tty_hooks (struct terminal
*terminal
)
3926 terminal
->cursor_to_hook
= &tty_cursor_to
;
3927 terminal
->raw_cursor_to_hook
= &tty_raw_cursor_to
;
3928 terminal
->clear_to_end_hook
= &tty_clear_to_end
;
3929 terminal
->clear_frame_hook
= &tty_clear_frame
;
3930 terminal
->clear_end_of_line_hook
= &tty_clear_end_of_line
;
3931 terminal
->ins_del_lines_hook
= &tty_ins_del_lines
;
3932 terminal
->insert_glyphs_hook
= &tty_insert_glyphs
;
3933 terminal
->write_glyphs_hook
= &tty_write_glyphs
;
3934 terminal
->delete_glyphs_hook
= &tty_delete_glyphs
;
3935 terminal
->ring_bell_hook
= &tty_ring_bell
;
3936 terminal
->reset_terminal_modes_hook
= &tty_reset_terminal_modes
;
3937 terminal
->set_terminal_modes_hook
= &tty_set_terminal_modes
;
3938 terminal
->update_end_hook
= &tty_update_end
;
3940 terminal
->menu_show_hook
= &x_menu_show
;
3942 terminal
->menu_show_hook
= &tty_menu_show
;
3944 terminal
->set_terminal_window_hook
= &tty_set_terminal_window
;
3945 terminal
->read_socket_hook
= &tty_read_avail_input
; /* keyboard.c */
3946 terminal
->delete_frame_hook
= &tty_free_frame_resources
;
3947 terminal
->delete_terminal_hook
= &delete_tty
;
3948 /* Other hooks are NULL by default. */
3951 /* If FD is the controlling terminal, drop it. */
3953 dissociate_if_controlling_tty (int fd
)
3955 /* If tcgetpgrp succeeds, fd is the controlling terminal,
3956 so dissociate it by invoking setsid. */
3957 if (tcgetpgrp (fd
) >= 0 && setsid () < 0)
3960 /* setsid failed, presumably because Emacs is already a process
3961 group leader. Fall back on the obsolescent way to dissociate
3962 a controlling tty. */
3964 block_tty_out_signal (&oldset
);
3965 ioctl (fd
, TIOCNOTTY
, 0);
3966 unblock_tty_out_signal (&oldset
);
3971 /* Create a termcap display on the tty device with the given name and
3974 If NAME is NULL, then use the controlling tty, i.e., "/dev/tty".
3975 Otherwise NAME should be a path to the tty device file,
3978 TERMINAL_TYPE is the termcap type of the device, e.g. "vt100".
3980 If MUST_SUCCEED is true, then all errors are fatal. */
3983 init_tty (const char *name
, const char *terminal_type
, bool must_succeed
)
3986 char **address
= &area
;
3988 struct tty_display_info
*tty
= NULL
;
3989 struct terminal
*terminal
= NULL
;
3991 bool ctty
= false; /* True if asked to open controlling tty. */
3994 maybe_fatal (must_succeed
, 0,
3995 "Unknown terminal type",
3996 "Unknown terminal type");
4000 if (!strcmp (name
, DEV_TTY
))
4003 /* If we already have a terminal on the given device, use that. If
4004 all such terminals are suspended, create a new one instead. */
4005 /* XXX Perhaps this should be made explicit by having init_tty
4006 always create a new terminal and separating terminal and frame
4007 creation on Lisp level. */
4008 terminal
= get_named_tty (name
);
4012 terminal
= create_terminal (output_termcap
, NULL
);
4015 maybe_fatal (0, 0, "Attempt to create another terminal %s", "",
4018 tty
= &the_only_display_info
;
4020 tty
= xzalloc (sizeof *tty
);
4022 tty
->top_frame
= Qnil
;
4023 tty
->next
= tty_list
;
4026 terminal
->display_info
.tty
= tty
;
4027 tty
->terminal
= terminal
;
4029 tty
->Wcm
= xmalloc (sizeof *tty
->Wcm
);
4032 encode_terminal_src_size
= 0;
4033 encode_terminal_dst_size
= 0;
4037 set_tty_hooks (terminal
);
4040 /* Open the terminal device. */
4042 /* If !ctty, don't recognize it as our controlling terminal, and
4043 don't make it the controlling tty if we don't have one now.
4045 Alas, O_IGNORE_CTTY is a GNU extension that seems to be only
4046 defined on Hurd. On other systems, we need to explicitly
4047 dissociate ourselves from the controlling tty when we want to
4048 open a frame on the same terminal. */
4049 int flags
= O_RDWR
| O_NOCTTY
| (ctty
? 0 : O_IGNORE_CTTY
);
4050 int fd
= emacs_open (name
, flags
, 0);
4051 tty
->input
= tty
->output
4052 = ((fd
< 0 || ! isatty (fd
))
4054 : fdopen (fd
, "w+"));
4058 char const *diagnostic
4059 = (fd
< 0) ? "Could not open file: %s" : "Not a tty device: %s";
4061 maybe_fatal (must_succeed
, terminal
, diagnostic
, diagnostic
, name
);
4064 tty
->name
= xstrdup (name
);
4065 terminal
->name
= xstrdup (name
);
4067 if (!O_IGNORE_CTTY
&& !ctty
)
4068 dissociate_if_controlling_tty (fd
);
4071 tty
->type
= xstrdup (terminal_type
);
4073 add_keyboard_wait_descriptor (fileno (tty
->input
));
4077 /* On some systems, tgetent tries to access the controlling
4079 block_tty_out_signal (&oldset
);
4080 status
= tgetent (tty
->termcap_term_buffer
, terminal_type
);
4081 if (tty
->termcap_term_buffer
[TERMCAP_BUFFER_SIZE
- 1])
4083 unblock_tty_out_signal (&oldset
);
4088 maybe_fatal (must_succeed
, terminal
,
4089 "Cannot open terminfo database file",
4090 "Cannot open terminfo database file");
4092 maybe_fatal (must_succeed
, terminal
,
4093 "Cannot open termcap database file",
4094 "Cannot open termcap database file");
4099 maybe_fatal (must_succeed
, terminal
,
4100 "Terminal type %s is not defined",
4101 "Terminal type %s is not defined.\n\
4102 If that is not the actual type of terminal you have,\n\
4103 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
4104 `setenv TERM ...') to specify the correct type. It may be necessary\n"
4106 "to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
4108 "to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
4113 area
= tty
->termcap_strings_buffer
;
4114 tty
->TS_ins_line
= tgetstr ("al", address
);
4115 tty
->TS_ins_multi_lines
= tgetstr ("AL", address
);
4116 tty
->TS_bell
= tgetstr ("bl", address
);
4117 BackTab (tty
) = tgetstr ("bt", address
);
4118 tty
->TS_clr_to_bottom
= tgetstr ("cd", address
);
4119 tty
->TS_clr_line
= tgetstr ("ce", address
);
4120 tty
->TS_clr_frame
= tgetstr ("cl", address
);
4121 ColPosition (tty
) = NULL
; /* tgetstr ("ch", address); */
4122 AbsPosition (tty
) = tgetstr ("cm", address
);
4123 CR (tty
) = tgetstr ("cr", address
);
4124 tty
->TS_set_scroll_region
= tgetstr ("cs", address
);
4125 tty
->TS_set_scroll_region_1
= tgetstr ("cS", address
);
4126 RowPosition (tty
) = tgetstr ("cv", address
);
4127 tty
->TS_del_char
= tgetstr ("dc", address
);
4128 tty
->TS_del_multi_chars
= tgetstr ("DC", address
);
4129 tty
->TS_del_line
= tgetstr ("dl", address
);
4130 tty
->TS_del_multi_lines
= tgetstr ("DL", address
);
4131 tty
->TS_delete_mode
= tgetstr ("dm", address
);
4132 tty
->TS_end_delete_mode
= tgetstr ("ed", address
);
4133 tty
->TS_end_insert_mode
= tgetstr ("ei", address
);
4134 Home (tty
) = tgetstr ("ho", address
);
4135 tty
->TS_ins_char
= tgetstr ("ic", address
);
4136 tty
->TS_ins_multi_chars
= tgetstr ("IC", address
);
4137 tty
->TS_insert_mode
= tgetstr ("im", address
);
4138 tty
->TS_pad_inserted_char
= tgetstr ("ip", address
);
4139 tty
->TS_end_keypad_mode
= tgetstr ("ke", address
);
4140 tty
->TS_keypad_mode
= tgetstr ("ks", address
);
4141 LastLine (tty
) = tgetstr ("ll", address
);
4142 Right (tty
) = tgetstr ("nd", address
);
4143 Down (tty
) = tgetstr ("do", address
);
4145 Down (tty
) = tgetstr ("nl", address
); /* Obsolete name for "do". */
4146 if (tgetflag ("bs"))
4147 Left (tty
) = "\b"; /* Can't possibly be longer! */
4148 else /* (Actually, "bs" is obsolete...) */
4149 Left (tty
) = tgetstr ("le", address
);
4151 Left (tty
) = tgetstr ("bc", address
); /* Obsolete name for "le". */
4152 tty
->TS_pad_char
= tgetstr ("pc", address
);
4153 tty
->TS_repeat
= tgetstr ("rp", address
);
4154 tty
->TS_end_standout_mode
= tgetstr ("se", address
);
4155 tty
->TS_fwd_scroll
= tgetstr ("sf", address
);
4156 tty
->TS_standout_mode
= tgetstr ("so", address
);
4157 tty
->TS_rev_scroll
= tgetstr ("sr", address
);
4158 tty
->Wcm
->cm_tab
= tgetstr ("ta", address
);
4159 tty
->TS_end_termcap_modes
= tgetstr ("te", address
);
4160 tty
->TS_termcap_modes
= tgetstr ("ti", address
);
4161 Up (tty
) = tgetstr ("up", address
);
4162 tty
->TS_visible_bell
= tgetstr ("vb", address
);
4163 tty
->TS_cursor_normal
= tgetstr ("ve", address
);
4164 tty
->TS_cursor_visible
= tgetstr ("vs", address
);
4165 tty
->TS_cursor_invisible
= tgetstr ("vi", address
);
4166 tty
->TS_set_window
= tgetstr ("wi", address
);
4168 tty
->TS_enter_underline_mode
= tgetstr ("us", address
);
4169 tty
->TS_exit_underline_mode
= tgetstr ("ue", address
);
4170 tty
->TS_enter_bold_mode
= tgetstr ("md", address
);
4171 tty
->TS_enter_italic_mode
= tgetstr ("ZH", address
);
4172 tty
->TS_enter_dim_mode
= tgetstr ("mh", address
);
4173 tty
->TS_enter_reverse_mode
= tgetstr ("mr", address
);
4174 tty
->TS_enter_alt_charset_mode
= tgetstr ("as", address
);
4175 tty
->TS_exit_alt_charset_mode
= tgetstr ("ae", address
);
4176 tty
->TS_exit_attribute_mode
= tgetstr ("me", address
);
4178 MultiUp (tty
) = tgetstr ("UP", address
);
4179 MultiDown (tty
) = tgetstr ("DO", address
);
4180 MultiLeft (tty
) = tgetstr ("LE", address
);
4181 MultiRight (tty
) = tgetstr ("RI", address
);
4183 /* SVr4/ANSI color support. If "op" isn't available, don't support
4184 color because we can't switch back to the default foreground and
4186 tty
->TS_orig_pair
= tgetstr ("op", address
);
4187 if (tty
->TS_orig_pair
)
4189 tty
->TS_set_foreground
= tgetstr ("AF", address
);
4190 tty
->TS_set_background
= tgetstr ("AB", address
);
4191 if (!tty
->TS_set_foreground
)
4194 tty
->TS_set_foreground
= tgetstr ("Sf", address
);
4195 tty
->TS_set_background
= tgetstr ("Sb", address
);
4198 tty
->TN_max_colors
= tgetnum ("Co");
4199 tty
->TN_max_pairs
= tgetnum ("pa");
4201 tty
->TN_no_color_video
= tgetnum ("NC");
4202 if (tty
->TN_no_color_video
== -1)
4203 tty
->TN_no_color_video
= 0;
4206 tty_default_color_capabilities (tty
, 1);
4208 MagicWrap (tty
) = tgetflag ("xn");
4209 /* Since we make MagicWrap terminals look like AutoWrap, we need to have
4210 the former flag imply the latter. */
4211 AutoWrap (tty
) = MagicWrap (tty
) || tgetflag ("am");
4212 tty
->memory_below_frame
= tgetflag ("db");
4213 tty
->TF_hazeltine
= tgetflag ("hz");
4214 tty
->must_write_spaces
= tgetflag ("in");
4215 tty
->meta_key
= tgetflag ("km") || tgetflag ("MT");
4216 tty
->TF_insmode_motion
= tgetflag ("mi");
4217 tty
->TF_standout_motion
= tgetflag ("ms");
4218 tty
->TF_underscore
= tgetflag ("ul");
4219 tty
->TF_teleray
= tgetflag ("xt");
4224 struct frame
*f
= XFRAME (selected_frame
);
4227 initialize_w32_display (terminal
, &width
, &height
);
4229 FrameRows (tty
) = height
;
4230 FrameCols (tty
) = width
;
4231 tty
->specified_window
= height
;
4233 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
) = vertical_scroll_bar_none
;
4234 FRAME_HAS_HORIZONTAL_SCROLL_BARS (f
) = 0;
4235 tty
->char_ins_del_ok
= 1;
4241 if (strcmp (terminal_type
, "internal") == 0)
4242 terminal
->type
= output_msdos_raw
;
4243 initialize_msdos_display (terminal
);
4245 get_tty_size (fileno (tty
->input
), &width
, &height
);
4246 FrameCols (tty
) = width
;
4247 FrameRows (tty
) = height
;
4248 tty
->char_ins_del_ok
= 0;
4249 init_baud_rate (fileno (tty
->input
));
4252 tty
->output
= stdout
;
4254 /* The following two are inaccessible from w32console.c. */
4255 terminal
->delete_frame_hook
= &tty_free_frame_resources
;
4256 terminal
->delete_terminal_hook
= &delete_tty
;
4258 tty
->name
= xstrdup (name
);
4259 terminal
->name
= xstrdup (name
);
4260 tty
->type
= xstrdup (terminal_type
);
4262 add_keyboard_wait_descriptor (0);
4264 tty
->delete_in_insert_mode
= 1;
4267 tty
->scroll_region_ok
= 0;
4269 /* Seems to insert lines when it's not supposed to, messing up the
4270 display. In doing a trace, it didn't seem to be called much, so I
4271 don't think we're losing anything by turning it off. */
4272 tty
->line_ins_del_ok
= 0;
4274 tty
->TN_max_colors
= 16; /* Must be non-zero for tty-display-color-p. */
4278 terminal
->mouse_position_hook
= term_mouse_position
;
4279 tty
->mouse_highlight
.mouse_face_window
= Qnil
;
4282 terminal
->kboard
= allocate_kboard (Qnil
);
4283 terminal
->kboard
->reference_count
++;
4284 /* Don't let the initial kboard remain current longer than necessary.
4285 That would cause problems if a file loaded on startup tries to
4286 prompt in the mini-buffer. */
4287 if (current_kboard
== initial_kboard
)
4288 current_kboard
= terminal
->kboard
;
4290 term_get_fkeys (address
, terminal
->kboard
);
4292 /* Get frame size from system, or else from termcap. */
4295 get_tty_size (fileno (tty
->input
), &width
, &height
);
4296 FrameCols (tty
) = width
;
4297 FrameRows (tty
) = height
;
4300 if (FrameCols (tty
) <= 0)
4301 FrameCols (tty
) = tgetnum ("co");
4302 if (FrameRows (tty
) <= 0)
4303 FrameRows (tty
) = tgetnum ("li");
4305 if (FrameRows (tty
) < 3 || FrameCols (tty
) < 3)
4306 maybe_fatal (must_succeed
, terminal
,
4307 "Screen size %dx%d is too small",
4308 "Screen size %dx%d is too small",
4309 FrameCols (tty
), FrameRows (tty
));
4311 TabWidth (tty
) = tgetnum ("tw");
4314 tty
->TS_bell
= "\07";
4316 if (!tty
->TS_fwd_scroll
)
4317 tty
->TS_fwd_scroll
= Down (tty
);
4319 PC
= tty
->TS_pad_char
? *tty
->TS_pad_char
: 0;
4321 if (TabWidth (tty
) < 0)
4324 /* Turned off since /etc/termcap seems to have :ta= for most terminals
4325 and newer termcap doc does not seem to say there is a default.
4326 if (!tty->Wcm->cm_tab)
4327 tty->Wcm->cm_tab = "\t";
4330 /* We don't support standout modes that use `magic cookies', so
4331 turn off any that do. */
4332 if (tty
->TS_standout_mode
&& tgetnum ("sg") >= 0)
4334 tty
->TS_standout_mode
= 0;
4335 tty
->TS_end_standout_mode
= 0;
4337 if (tty
->TS_enter_underline_mode
&& tgetnum ("ug") >= 0)
4339 tty
->TS_enter_underline_mode
= 0;
4340 tty
->TS_exit_underline_mode
= 0;
4343 /* If there's no standout mode, try to use underlining instead. */
4344 if (tty
->TS_standout_mode
== 0)
4346 tty
->TS_standout_mode
= tty
->TS_enter_underline_mode
;
4347 tty
->TS_end_standout_mode
= tty
->TS_exit_underline_mode
;
4350 /* If no `se' string, try using a `me' string instead.
4351 If that fails, we can't use standout mode at all. */
4352 if (tty
->TS_end_standout_mode
== 0)
4354 char *s
= tgetstr ("me", address
);
4356 tty
->TS_end_standout_mode
= s
;
4358 tty
->TS_standout_mode
= 0;
4361 if (tty
->TF_teleray
)
4363 tty
->Wcm
->cm_tab
= 0;
4364 /* We can't support standout mode, because it uses magic cookies. */
4365 tty
->TS_standout_mode
= 0;
4366 /* But that means we cannot rely on ^M to go to column zero! */
4368 /* LF can't be trusted either -- can alter hpos. */
4369 /* If move at column 0 thru a line with TS_standout_mode. */
4373 tty
->specified_window
= FrameRows (tty
);
4375 if (Wcm_init (tty
) == -1) /* Can't do cursor motion. */
4377 maybe_fatal (must_succeed
, terminal
,
4378 "Terminal type \"%s\" is not powerful enough to run Emacs",
4379 "Terminal type \"%s\" is not powerful enough to run Emacs.\n\
4380 It lacks the ability to position the cursor.\n\
4381 If that is not the actual type of terminal you have,\n\
4382 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
4383 `setenv TERM ...') to specify the correct type. It may be necessary\n"
4385 "to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
4386 # else /* TERMCAP */
4387 "to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
4388 # endif /* TERMINFO */
4392 if (FrameRows (tty
) <= 0 || FrameCols (tty
) <= 0)
4393 maybe_fatal (must_succeed
, terminal
,
4394 "Could not determine the frame size",
4395 "Could not determine the frame size");
4397 tty
->delete_in_insert_mode
4398 = tty
->TS_delete_mode
&& tty
->TS_insert_mode
4399 && !strcmp (tty
->TS_delete_mode
, tty
->TS_insert_mode
);
4401 UseTabs (tty
) = tabs_safe_p (fileno (tty
->input
)) && TabWidth (tty
) == 8;
4403 tty
->scroll_region_ok
4405 && (tty
->TS_set_window
|| tty
->TS_set_scroll_region
|| tty
->TS_set_scroll_region_1
));
4407 tty
->line_ins_del_ok
4408 = (((tty
->TS_ins_line
|| tty
->TS_ins_multi_lines
)
4409 && (tty
->TS_del_line
|| tty
->TS_del_multi_lines
))
4410 || (tty
->scroll_region_ok
4411 && tty
->TS_fwd_scroll
&& tty
->TS_rev_scroll
));
4413 tty
->char_ins_del_ok
4414 = ((tty
->TS_ins_char
|| tty
->TS_insert_mode
4415 || tty
->TS_pad_inserted_char
|| tty
->TS_ins_multi_chars
)
4416 && (tty
->TS_del_char
|| tty
->TS_del_multi_chars
));
4418 init_baud_rate (fileno (tty
->input
));
4420 #endif /* not DOS_NT */
4422 /* Init system terminal modes (RAW or CBREAK, etc.). */
4423 init_sys_modes (tty
);
4430 vfatal (const char *str
, va_list ap
)
4432 fprintf (stderr
, "emacs: ");
4433 vfprintf (stderr
, str
, ap
);
4434 if (!(strlen (str
) > 0 && str
[strlen (str
) - 1] == '\n'))
4435 fprintf (stderr
, "\n");
4441 /* Auxiliary error-handling function for init_tty.
4442 Delete TERMINAL, then call error or fatal with str1 or str2,
4443 respectively, according to whether MUST_SUCCEED is true. */
4446 maybe_fatal (bool must_succeed
, struct terminal
*terminal
,
4447 const char *str1
, const char *str2
, ...)
4450 va_start (ap
, str2
);
4452 delete_tty (terminal
);
4461 fatal (const char *str
, ...)
4470 /* Delete the given tty terminal, closing all frames on it. */
4473 delete_tty (struct terminal
*terminal
)
4475 struct tty_display_info
*tty
;
4477 /* Protect against recursive calls. delete_frame in
4478 delete_terminal calls us back when it deletes our last frame. */
4479 if (!terminal
->name
)
4482 eassert (terminal
->type
== output_termcap
);
4484 tty
= terminal
->display_info
.tty
;
4486 if (tty
== tty_list
)
4487 tty_list
= tty
->next
;
4490 struct tty_display_info
*p
;
4491 for (p
= tty_list
; p
&& p
->next
!= tty
; p
= p
->next
)
4495 /* This should not happen. */
4498 p
->next
= tty
->next
;
4502 /* reset_sys_modes needs a valid device, so this call needs to be
4503 before delete_terminal. */
4504 reset_sys_modes (tty
);
4506 delete_terminal (terminal
);
4513 delete_keyboard_wait_descriptor (fileno (tty
->input
));
4514 if (tty
->input
!= stdin
)
4515 fclose (tty
->input
);
4517 if (tty
->output
&& tty
->output
!= stdout
&& tty
->output
!= tty
->input
)
4518 fclose (tty
->output
);
4519 if (tty
->termscript
)
4520 fclose (tty
->termscript
);
4522 xfree (tty
->old_tty
);
4530 DEFVAR_BOOL ("system-uses-terminfo", system_uses_terminfo
,
4531 doc
: /* Non-nil means the system uses terminfo rather than termcap.
4532 This variable can be used by terminal emulator packages. */);
4534 system_uses_terminfo
= 1;
4536 system_uses_terminfo
= 0;
4539 DEFVAR_LISP ("suspend-tty-functions", Vsuspend_tty_functions
,
4540 doc
: /* Functions run after suspending a tty.
4541 The functions are run with one argument, the terminal object to be suspended.
4542 See `suspend-tty'. */);
4543 Vsuspend_tty_functions
= Qnil
;
4546 DEFVAR_LISP ("resume-tty-functions", Vresume_tty_functions
,
4547 doc
: /* Functions run after resuming a tty.
4548 The functions are run with one argument, the terminal object that was revived.
4549 See `resume-tty'. */);
4550 Vresume_tty_functions
= Qnil
;
4552 DEFVAR_BOOL ("visible-cursor", visible_cursor
,
4553 doc
: /* Non-nil means to make the cursor very visible.
4554 This only has an effect when running in a text terminal.
4555 What means \"very visible\" is up to your terminal. It may make the cursor
4556 bigger, or it may make it blink, or it may do nothing at all. */);
4559 defsubr (&Stty_display_color_p
);
4560 defsubr (&Stty_display_color_cells
);
4561 defsubr (&Stty_no_underline
);
4562 defsubr (&Stty_type
);
4563 defsubr (&Scontrolling_tty_p
);
4564 defsubr (&Stty_top_frame
);
4565 defsubr (&Ssuspend_tty
);
4566 defsubr (&Sresume_tty
);
4568 defsubr (&Sgpm_mouse_start
);
4569 defsubr (&Sgpm_mouse_stop
);
4570 #endif /* HAVE_GPM */
4573 default_orig_pair
= NULL
;
4574 default_set_foreground
= NULL
;
4575 default_set_background
= NULL
;
4576 #endif /* !DOS_NT */
4578 encode_terminal_src
= NULL
;
4579 encode_terminal_dst
= NULL
;
4581 DEFSYM (Qtty_mode_set_strings
, "tty-mode-set-strings");
4582 DEFSYM (Qtty_mode_reset_strings
, "tty-mode-reset-strings");
4585 DEFSYM (Qtty_menu_next_item
, "tty-menu-next-item");
4586 DEFSYM (Qtty_menu_prev_item
, "tty-menu-prev-item");
4587 DEFSYM (Qtty_menu_next_menu
, "tty-menu-next-menu");
4588 DEFSYM (Qtty_menu_prev_menu
, "tty-menu-prev-menu");
4589 DEFSYM (Qtty_menu_select
, "tty-menu-select");
4590 DEFSYM (Qtty_menu_ignore
, "tty-menu-ignore");
4591 DEFSYM (Qtty_menu_exit
, "tty-menu-exit");
4592 DEFSYM (Qtty_menu_mouse_movement
, "tty-menu-mouse-movement");
4593 DEFSYM (Qtty_menu_navigation_map
, "tty-menu-navigation-map");