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
;
3196 /* Don't allow non-positive x0 and y0, lest the menu will wrap
3197 around the display. */
3203 SAFE_NALLOCA (state
, 1, menu
->panecount
);
3204 memset (state
, 0, sizeof (*state
));
3206 = lookup_derived_face (sf
, intern ("tty-menu-disabled-face"),
3207 DEFAULT_FACE_ID
, 1);
3209 = lookup_derived_face (sf
, intern ("tty-menu-enabled-face"),
3210 DEFAULT_FACE_ID
, 1);
3211 selectface
= intern ("tty-menu-selected-face");
3212 faces
[2] = lookup_derived_face (sf
, selectface
,
3214 faces
[3] = lookup_derived_face (sf
, selectface
,
3217 /* Make sure the menu title is always displayed with
3218 `tty-menu-selected-face', no matter where the mouse pointer is. */
3219 for (i
= 0; i
< 4; i
++)
3220 title_faces
[i
] = faces
[3];
3224 /* Don't let the title for the "Buffers" popup menu include a
3225 digit (which is ugly).
3227 This is a terrible kludge, but I think the "Buffers" case is
3228 the only one where the title includes a number, so it doesn't
3229 seem to be necessary to make this more general. */
3230 if (strncmp (menu
->text
[0], "Buffers 1", 9) == 0)
3232 menu
->text
[0][7] = '\0';
3233 buffers_num_deleted
= 1;
3236 /* Force update of the current frame, so that the desired and the
3237 current matrices are identical. */
3238 update_frame_with_menu (sf
, -1, -1);
3239 state
[0].menu
= menu
;
3240 state
[0].screen_behind
= save_and_enable_current_matrix (sf
);
3242 /* Display the menu title. We subtract 1 from x0 and y0 because we
3243 want to interpret them as zero-based column and row coordinates,
3244 and also because we want the first item of the menu, not its
3245 title, to appear at x0,y0. */
3246 tty_menu_display (menu
, x0
- 1, y0
- 1, 1, title_faces
, x0
- 1, y0
- 1, 0, 0);
3248 /* Turn off the cursor. Otherwise it shows through the menu
3249 panes, which is ugly. */
3250 col
= cursorX (tty
);
3251 row
= cursorY (tty
);
3252 tty_hide_cursor (tty
);
3254 if (buffers_num_deleted
)
3255 menu
->text
[0][7] = ' ';
3256 onepane
= menu
->count
== 1 && menu
->submenu
[0];
3259 menu
->width
= menu
->submenu
[0]->width
;
3260 state
[0].menu
= menu
->submenu
[0];
3264 state
[0].menu
= menu
;
3266 state
[0].x
= x0
- 1;
3268 state
[0].pane
= onepane
;
3277 mi_result input_status
;
3278 int min_y
= state
[0].y
;
3279 int max_y
= min (min_y
+ state
[0].menu
->count
, FRAME_TOTAL_LINES (sf
) - 1) - 1;
3281 input_status
= read_menu_input (sf
, &x
, &y
, min_y
, max_y
, &first_time
);
3285 switch (input_status
)
3288 /* Remove the last help-echo, so that it doesn't
3289 re-appear after "Quit". */
3290 show_help_echo (Qnil
, Qnil
, Qnil
, Qnil
);
3291 result
= TTYM_NO_SELECT
;
3305 case MI_SCROLL_FORWARD
:
3306 if (y
- min_y
== state
[0].menu
->count
- 1 - first_item
)
3315 case MI_SCROLL_BACK
:
3316 if (first_item
== 0)
3319 first_item
= state
[0].menu
->count
- 1 - (y
- min_y
);
3326 /* MI_ITEM_SELECTED is handled below, so nothing to do. */
3330 if (sf
->mouse_moved
&& input_status
!= MI_QUIT_MENU
)
3332 sf
->mouse_moved
= 0;
3333 result
= TTYM_IA_SELECT
;
3334 for (i
= 0; i
< statecount
; i
++)
3335 if (state
[i
].x
<= x
&& x
< state
[i
].x
+ state
[i
].menu
->width
+ 2)
3337 int dy
= y
- state
[i
].y
+ first_item
;
3338 if (0 <= dy
&& dy
< state
[i
].menu
->count
)
3340 if (!state
[i
].menu
->submenu
[dy
])
3342 if (state
[i
].menu
->panenumber
[dy
])
3343 result
= TTYM_SUCCESS
;
3345 result
= TTYM_IA_SELECT
;
3347 *pane
= state
[i
].pane
- 1;
3349 /* We hit some part of a menu, so drop extra menus that
3350 have been opened. That does not include an open and
3352 if (i
!= statecount
- 2
3353 || state
[i
].menu
->submenu
[dy
] != state
[i
+ 1].menu
)
3354 while (i
!= statecount
- 1)
3357 screen_update (sf
, state
[statecount
].screen_behind
);
3358 state
[statecount
].screen_behind
= NULL
;
3360 if (i
== statecount
- 1 && state
[i
].menu
->submenu
[dy
])
3362 tty_menu_display (state
[i
].menu
,
3366 faces
, x
, y
, first_item
, 1);
3367 state
[statecount
].menu
= state
[i
].menu
->submenu
[dy
];
3368 state
[statecount
].pane
= state
[i
].menu
->panenumber
[dy
];
3369 state
[statecount
].screen_behind
3370 = save_and_enable_current_matrix (sf
);
3372 = state
[i
].x
+ state
[i
].menu
->width
+ 2;
3373 state
[statecount
].y
= y
;
3378 tty_menu_display (state
[statecount
- 1].menu
,
3379 state
[statecount
- 1].x
,
3380 state
[statecount
- 1].y
,
3381 state
[statecount
- 1].pane
,
3382 faces
, x
, y
, first_item
, 1);
3383 /* The call to display help-echo below will move the cursor,
3384 so remember its current position as computed by
3385 tty_menu_display. */
3386 col
= cursorX (tty
);
3387 row
= cursorY (tty
);
3390 /* Display the help-echo message for the currently-selected menu
3392 if ((menu_help_message
|| prev_menu_help_message
)
3393 && menu_help_message
!= prev_menu_help_message
)
3395 help_callback (menu_help_message
,
3396 menu_help_paneno
, menu_help_itemno
);
3397 /* Move the cursor to the beginning of the current menu
3398 item, so that screen readers and other accessibility aids
3399 know where the active region is. */
3400 cursor_to (sf
, row
, col
);
3401 prev_menu_help_message
= menu_help_message
;
3403 /* Both tty_menu_display and help_callback invoke update_end,
3404 which calls tty_show_cursor. Re-hide it, so it doesn't show
3405 through the menus. */
3406 tty_hide_cursor (tty
);
3407 fflush (tty
->output
);
3410 sf
->mouse_moved
= 0;
3411 screen_update (sf
, state
[0].screen_behind
);
3412 while (statecount
--)
3413 free_saved_screen (state
[statecount
].screen_behind
);
3414 tty_show_cursor (tty
); /* Turn cursor back on. */
3415 fflush (tty
->output
);
3417 /* Clean up any mouse events that are waiting inside Emacs event queue.
3418 These events are likely to be generated before the menu was even
3419 displayed, probably because the user pressed and released the button
3420 (which invoked the menu) too quickly. If we don't remove these events,
3421 Emacs will process them after we return and surprise the user. */
3422 discard_mouse_events ();
3423 if (!kbd_buffer_events_waiting ())
3424 clear_input_pending ();
3429 /* Dispose of a menu. */
3432 tty_menu_destroy (tty_menu
*menu
)
3435 if (menu
->allocated
)
3437 for (i
= 0; i
< menu
->count
; i
++)
3438 if (menu
->submenu
[i
])
3439 tty_menu_destroy (menu
->submenu
[i
]);
3441 xfree (menu
->submenu
);
3442 xfree (menu
->panenumber
);
3443 xfree (menu
->help_text
);
3446 menu_help_message
= prev_menu_help_message
= NULL
;
3449 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3451 PANE is the pane number, and ITEM is the menu item number in
3452 the menu (currently not used). */
3455 tty_menu_help_callback (char const *help_string
, int pane
, int item
)
3457 Lisp_Object
*first_item
;
3458 Lisp_Object pane_name
;
3459 Lisp_Object menu_object
;
3461 first_item
= XVECTOR (menu_items
)->contents
;
3462 if (EQ (first_item
[0], Qt
))
3463 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3464 else if (EQ (first_item
[0], Qquote
))
3465 /* This shouldn't happen, see xmenu_show. */
3466 pane_name
= empty_unibyte_string
;
3468 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3470 /* (menu-item MENU-NAME PANE-NUMBER) */
3471 menu_object
= list3 (Qmenu_item
, pane_name
, make_number (pane
));
3472 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3473 Qnil
, menu_object
, make_number (item
));
3477 tty_pop_down_menu (Lisp_Object arg
)
3479 tty_menu
*menu
= XSAVE_POINTER (arg
, 0);
3482 tty_menu_destroy (menu
);
3486 /* Return the zero-based index of the last menu-bar item on frame F. */
3488 tty_menu_last_menubar_item (struct frame
*f
)
3492 eassert (FRAME_TERMCAP_P (f
) && FRAME_LIVE_P (f
));
3493 if (FRAME_TERMCAP_P (f
) && FRAME_LIVE_P (f
))
3495 Lisp_Object items
= FRAME_MENU_BAR_ITEMS (f
);
3497 while (i
< ASIZE (items
))
3501 str
= AREF (items
, i
+ 1);
3506 i
-= 4; /* Went one too far! */
3511 /* Find in frame F's menu bar the menu item that is next or previous
3512 to the item at X/Y, and return that item's position in X/Y. WHICH
3513 says which one--next or previous--item to look for. X and Y are
3514 measured in character cells. This should only be called on TTY
3517 tty_menu_new_item_coords (struct frame
*f
, int which
, int *x
, int *y
)
3519 eassert (FRAME_TERMCAP_P (f
) && FRAME_LIVE_P (f
));
3520 if (FRAME_TERMCAP_P (f
) && FRAME_LIVE_P (f
))
3522 Lisp_Object items
= FRAME_MENU_BAR_ITEMS (f
);
3523 int last_i
= tty_menu_last_menubar_item (f
);
3526 /* This loop assumes a single menu-bar line, and will fail to
3527 find an item if it is not in the first line. Note that
3528 make_lispy_event in keyboard.c makes the same assumption. */
3529 for (i
= 0, prev_x
= -1; i
< ASIZE (items
); i
+= 4)
3531 Lisp_Object pos
, str
;
3534 str
= AREF (items
, i
+ 1);
3535 pos
= AREF (items
, i
+ 3);
3540 /* We use <= so the blank between 2 items on a TTY is
3541 considered part of the previous item. */
3542 && *x
<= ix
+ menu_item_width (SDATA (str
)))
3544 /* Found current item. Now compute the X coordinate of
3545 the previous or next item. */
3546 if (which
== TTYM_NEXT
)
3549 *x
= XINT (AREF (items
, i
+ 4 + 3));
3551 *x
= 0; /* Wrap around to the first item. */
3553 else if (prev_x
< 0)
3555 /* Wrap around to the last item. */
3556 *x
= XINT (AREF (items
, last_i
+ 3));
3567 /* WINDOWSNT uses this as menu_show_hook, see w32console.c. */
3569 tty_menu_show (struct frame
*f
, int x
, int y
, int menuflags
,
3570 Lisp_Object title
, const char **error_name
)
3573 int pane
, selidx
, lpane
, status
;
3574 Lisp_Object entry
, pane_prefix
;
3576 int ulx
, uly
, width
, height
;
3578 int dispwidth
, dispheight
;
3579 int i
, j
, lines
, maxlines
;
3581 ptrdiff_t specpdl_count
;
3583 eassert (FRAME_TERMCAP_P (f
));
3586 if (menu_items_n_panes
== 0)
3589 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3591 *error_name
= "Empty menu";
3595 /* Make the menu on that window. */
3596 menu
= tty_menu_create ();
3598 /* Don't GC while we prepare and show the menu, because we give the
3599 menu functions pointers to the contents of strings. */
3600 specpdl_count
= inhibit_garbage_collection ();
3602 /* Avoid crashes if, e.g., another client will connect while we
3604 temporarily_switch_to_single_kboard (f
);
3606 /* Adjust coordinates to be root-window-relative. */
3607 item_x
= x
+= f
->left_pos
;
3608 item_y
= y
+= f
->top_pos
;
3610 /* Create all the necessary panes and their items. */
3612 maxwidth
= maxlines
= lines
= i
= 0;
3613 lpane
= TTYM_FAILURE
;
3614 while (i
< menu_items_used
)
3616 if (EQ (AREF (menu_items
, i
), Qt
))
3618 /* Create a new pane. */
3619 Lisp_Object pane_name
, prefix
;
3620 const char *pane_string
;
3622 maxlines
= max (maxlines
, lines
);
3624 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
3625 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
3626 pane_string
= (NILP (pane_name
)
3627 ? "" : SSDATA (pane_name
));
3628 if ((menuflags
& MENU_KEYMAPS
) && !NILP (prefix
))
3631 lpane
= tty_menu_add_pane (menu
, pane_string
);
3632 if (lpane
== TTYM_FAILURE
)
3634 tty_menu_destroy (menu
);
3635 *error_name
= "Can't create pane";
3639 i
+= MENU_ITEMS_PANE_LENGTH
;
3641 /* Find the width of the widest item in this pane. */
3643 while (j
< menu_items_used
)
3646 item
= AREF (menu_items
, j
);
3654 width
= SBYTES (item
);
3655 if (width
> maxwidth
)
3658 j
+= MENU_ITEMS_ITEM_LENGTH
;
3661 /* Ignore a nil in the item list.
3662 It's meaningful only for dialog boxes. */
3663 else if (EQ (AREF (menu_items
, i
), Qquote
))
3667 /* Create a new item within current pane. */
3668 Lisp_Object item_name
, enable
, descrip
, help
;
3670 char const *help_string
;
3672 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
3673 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
3674 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
3675 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
3676 help_string
= STRINGP (help
) ? SSDATA (help
) : NULL
;
3678 if (!NILP (descrip
))
3680 item_data
= SAFE_ALLOCA (maxwidth
+ SBYTES (descrip
) + 1);
3681 memcpy (item_data
, SSDATA (item_name
), SBYTES (item_name
));
3682 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3684 memcpy (item_data
+ j
, SSDATA (descrip
), SBYTES (descrip
));
3685 item_data
[j
+ SBYTES (descrip
)] = 0;
3688 item_data
= SSDATA (item_name
);
3690 if (lpane
== TTYM_FAILURE
3691 || (! tty_menu_add_selection (menu
, lpane
, item_data
,
3692 !NILP (enable
), help_string
)))
3694 tty_menu_destroy (menu
);
3695 *error_name
= "Can't add selection to menu";
3699 i
+= MENU_ITEMS_ITEM_LENGTH
;
3704 maxlines
= max (maxlines
, lines
);
3706 /* All set and ready to fly. */
3707 dispwidth
= f
->text_cols
;
3708 dispheight
= f
->text_lines
;
3709 x
= min (x
, dispwidth
);
3710 y
= min (y
, dispheight
);
3713 tty_menu_locate (menu
, x
, y
, &ulx
, &uly
, &width
, &height
);
3714 if (ulx
+ width
> dispwidth
)
3716 x
-= (ulx
+ width
) - dispwidth
;
3717 ulx
= dispwidth
- width
;
3719 if (uly
+ height
> dispheight
)
3721 y
-= (uly
+ height
) - dispheight
;
3722 uly
= dispheight
- height
;
3725 if (FRAME_HAS_MINIBUF_P (f
) && uly
+ height
> dispheight
- 2)
3727 /* Move the menu away of the echo area, to avoid overwriting the
3728 menu with help echo messages or vice versa. */
3729 if (BUFFERP (echo_area_buffer
[0]) && WINDOWP (echo_area_window
))
3731 y
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
)) + 1;
3732 uly
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
)) + 1;
3741 if (ulx
< 0) x
-= ulx
;
3742 if (uly
< 0) y
-= uly
;
3745 /* This code doesn't make sense on a TTY, since it can easily annul
3746 the adjustments above that carefully avoid truncation of the menu
3747 items. I think it was written to fix some problem that only
3751 /* If position was not given by a mouse click, adjust so upper left
3752 corner of the menu as a whole ends up at given coordinates. This
3753 is what x-popup-menu says in its documentation. */
3755 y
+= 1.5 * height
/ (maxlines
+ 2);
3761 record_unwind_protect (tty_pop_down_menu
, make_save_ptr (menu
));
3763 specbind (Qoverriding_terminal_local_map
,
3764 Fsymbol_value (Qtty_menu_navigation_map
));
3765 status
= tty_menu_activate (menu
, &pane
, &selidx
, x
, y
, &datap
,
3766 tty_menu_help_callback
,
3767 menuflags
& MENU_KBD_NAVIGATION
);
3768 entry
= pane_prefix
= Qnil
;
3773 /* Find the item number SELIDX in pane number PANE. */
3775 while (i
< menu_items_used
)
3777 if (EQ (AREF (menu_items
, i
), Qt
))
3781 = AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
3783 i
+= MENU_ITEMS_PANE_LENGTH
;
3792 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
3793 if (menuflags
& MENU_KEYMAPS
)
3795 entry
= Fcons (entry
, Qnil
);
3796 if (!NILP (pane_prefix
))
3797 entry
= Fcons (pane_prefix
, entry
);
3803 i
+= MENU_ITEMS_ITEM_LENGTH
;
3810 tty_menu_new_item_coords (f
, status
, &item_x
, &item_y
);
3811 entry
= Fcons (make_number (item_x
), make_number (item_y
));
3815 *error_name
= "Can't activate menu";
3816 case TTYM_IA_SELECT
:
3818 case TTYM_NO_SELECT
:
3819 /* If the selected frame was changed while we displayed a menu,
3820 throw to top level in order to undo any temporary settings
3821 made by TTY menu code. */
3822 if (f
!= SELECTED_FRAME ())
3824 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
3825 the menu was invoked with a mouse event as POSITION). */
3826 if (!(menuflags
& MENU_FOR_CLICK
))
3827 Fsignal (Qquit
, Qnil
);
3834 unbind_to (specpdl_count
, Qnil
);
3842 /***********************************************************************
3844 ***********************************************************************/
3846 /* Initialize the tty-dependent part of frame F. The frame must
3847 already have its device initialized. */
3850 create_tty_output (struct frame
*f
)
3852 struct tty_output
*t
= xzalloc (sizeof *t
);
3854 eassert (FRAME_TERMCAP_P (f
));
3856 t
->display_info
= FRAME_TERMINAL (f
)->display_info
.tty
;
3858 f
->output_data
.tty
= t
;
3861 /* Delete frame F's face cache, and its tty-dependent part. */
3864 tty_free_frame_resources (struct frame
*f
)
3866 eassert (FRAME_TERMCAP_P (f
));
3867 free_frame_faces (f
);
3868 xfree (f
->output_data
.tty
);
3873 /* Delete frame F's face cache. */
3876 tty_free_frame_resources (struct frame
*f
)
3878 eassert (FRAME_TERMCAP_P (f
) || FRAME_MSDOS_P (f
));
3879 free_frame_faces (f
);
3883 /* Reset the hooks in TERMINAL. */
3886 clear_tty_hooks (struct terminal
*terminal
)
3889 terminal
->cursor_to_hook
= 0;
3890 terminal
->raw_cursor_to_hook
= 0;
3891 terminal
->clear_to_end_hook
= 0;
3892 terminal
->clear_frame_hook
= 0;
3893 terminal
->clear_end_of_line_hook
= 0;
3894 terminal
->ins_del_lines_hook
= 0;
3895 terminal
->insert_glyphs_hook
= 0;
3896 terminal
->write_glyphs_hook
= 0;
3897 terminal
->delete_glyphs_hook
= 0;
3898 terminal
->ring_bell_hook
= 0;
3899 terminal
->reset_terminal_modes_hook
= 0;
3900 terminal
->set_terminal_modes_hook
= 0;
3901 terminal
->update_begin_hook
= 0;
3902 terminal
->update_end_hook
= 0;
3903 terminal
->set_terminal_window_hook
= 0;
3904 terminal
->mouse_position_hook
= 0;
3905 terminal
->frame_rehighlight_hook
= 0;
3906 terminal
->frame_raise_lower_hook
= 0;
3907 terminal
->fullscreen_hook
= 0;
3908 terminal
->menu_show_hook
= 0;
3909 terminal
->set_vertical_scroll_bar_hook
= 0;
3910 terminal
->set_horizontal_scroll_bar_hook
= 0;
3911 terminal
->condemn_scroll_bars_hook
= 0;
3912 terminal
->redeem_scroll_bar_hook
= 0;
3913 terminal
->judge_scroll_bars_hook
= 0;
3914 terminal
->read_socket_hook
= 0;
3915 terminal
->frame_up_to_date_hook
= 0;
3917 /* Leave these two set, or suspended frames are not deleted
3919 terminal
->delete_frame_hook
= &tty_free_frame_resources
;
3920 terminal
->delete_terminal_hook
= &delete_tty
;
3923 /* Initialize hooks in TERMINAL with the values needed for a tty. */
3926 set_tty_hooks (struct terminal
*terminal
)
3928 terminal
->cursor_to_hook
= &tty_cursor_to
;
3929 terminal
->raw_cursor_to_hook
= &tty_raw_cursor_to
;
3930 terminal
->clear_to_end_hook
= &tty_clear_to_end
;
3931 terminal
->clear_frame_hook
= &tty_clear_frame
;
3932 terminal
->clear_end_of_line_hook
= &tty_clear_end_of_line
;
3933 terminal
->ins_del_lines_hook
= &tty_ins_del_lines
;
3934 terminal
->insert_glyphs_hook
= &tty_insert_glyphs
;
3935 terminal
->write_glyphs_hook
= &tty_write_glyphs
;
3936 terminal
->delete_glyphs_hook
= &tty_delete_glyphs
;
3937 terminal
->ring_bell_hook
= &tty_ring_bell
;
3938 terminal
->reset_terminal_modes_hook
= &tty_reset_terminal_modes
;
3939 terminal
->set_terminal_modes_hook
= &tty_set_terminal_modes
;
3940 terminal
->update_end_hook
= &tty_update_end
;
3942 terminal
->menu_show_hook
= &x_menu_show
;
3944 terminal
->menu_show_hook
= &tty_menu_show
;
3946 terminal
->set_terminal_window_hook
= &tty_set_terminal_window
;
3947 terminal
->read_socket_hook
= &tty_read_avail_input
; /* keyboard.c */
3948 terminal
->delete_frame_hook
= &tty_free_frame_resources
;
3949 terminal
->delete_terminal_hook
= &delete_tty
;
3950 /* Other hooks are NULL by default. */
3953 /* If FD is the controlling terminal, drop it. */
3955 dissociate_if_controlling_tty (int fd
)
3957 /* If tcgetpgrp succeeds, fd is the controlling terminal,
3958 so dissociate it by invoking setsid. */
3959 if (tcgetpgrp (fd
) >= 0 && setsid () < 0)
3962 /* setsid failed, presumably because Emacs is already a process
3963 group leader. Fall back on the obsolescent way to dissociate
3964 a controlling tty. */
3966 block_tty_out_signal (&oldset
);
3967 ioctl (fd
, TIOCNOTTY
, 0);
3968 unblock_tty_out_signal (&oldset
);
3973 /* Create a termcap display on the tty device with the given name and
3976 If NAME is NULL, then use the controlling tty, i.e., "/dev/tty".
3977 Otherwise NAME should be a path to the tty device file,
3980 TERMINAL_TYPE is the termcap type of the device, e.g. "vt100".
3982 If MUST_SUCCEED is true, then all errors are fatal. */
3985 init_tty (const char *name
, const char *terminal_type
, bool must_succeed
)
3988 char **address
= &area
;
3990 struct tty_display_info
*tty
= NULL
;
3991 struct terminal
*terminal
= NULL
;
3993 bool ctty
= false; /* True if asked to open controlling tty. */
3996 maybe_fatal (must_succeed
, 0,
3997 "Unknown terminal type",
3998 "Unknown terminal type");
4002 if (!strcmp (name
, DEV_TTY
))
4005 /* If we already have a terminal on the given device, use that. If
4006 all such terminals are suspended, create a new one instead. */
4007 /* XXX Perhaps this should be made explicit by having init_tty
4008 always create a new terminal and separating terminal and frame
4009 creation on Lisp level. */
4010 terminal
= get_named_tty (name
);
4014 terminal
= create_terminal (output_termcap
, NULL
);
4017 maybe_fatal (0, 0, "Attempt to create another terminal %s", "",
4020 tty
= &the_only_display_info
;
4022 tty
= xzalloc (sizeof *tty
);
4024 tty
->top_frame
= Qnil
;
4025 tty
->next
= tty_list
;
4028 terminal
->display_info
.tty
= tty
;
4029 tty
->terminal
= terminal
;
4031 tty
->Wcm
= xmalloc (sizeof *tty
->Wcm
);
4034 encode_terminal_src_size
= 0;
4035 encode_terminal_dst_size
= 0;
4039 set_tty_hooks (terminal
);
4042 /* Open the terminal device. */
4044 /* If !ctty, don't recognize it as our controlling terminal, and
4045 don't make it the controlling tty if we don't have one now.
4047 Alas, O_IGNORE_CTTY is a GNU extension that seems to be only
4048 defined on Hurd. On other systems, we need to explicitly
4049 dissociate ourselves from the controlling tty when we want to
4050 open a frame on the same terminal. */
4051 int flags
= O_RDWR
| O_NOCTTY
| (ctty
? 0 : O_IGNORE_CTTY
);
4052 int fd
= emacs_open (name
, flags
, 0);
4053 tty
->input
= tty
->output
4054 = ((fd
< 0 || ! isatty (fd
))
4056 : fdopen (fd
, "w+"));
4060 char const *diagnostic
4061 = (fd
< 0) ? "Could not open file: %s" : "Not a tty device: %s";
4063 maybe_fatal (must_succeed
, terminal
, diagnostic
, diagnostic
, name
);
4066 tty
->name
= xstrdup (name
);
4067 terminal
->name
= xstrdup (name
);
4069 if (!O_IGNORE_CTTY
&& !ctty
)
4070 dissociate_if_controlling_tty (fd
);
4073 tty
->type
= xstrdup (terminal_type
);
4075 add_keyboard_wait_descriptor (fileno (tty
->input
));
4079 /* On some systems, tgetent tries to access the controlling
4081 block_tty_out_signal (&oldset
);
4082 status
= tgetent (tty
->termcap_term_buffer
, terminal_type
);
4083 if (tty
->termcap_term_buffer
[TERMCAP_BUFFER_SIZE
- 1])
4085 unblock_tty_out_signal (&oldset
);
4090 maybe_fatal (must_succeed
, terminal
,
4091 "Cannot open terminfo database file",
4092 "Cannot open terminfo database file");
4094 maybe_fatal (must_succeed
, terminal
,
4095 "Cannot open termcap database file",
4096 "Cannot open termcap database file");
4101 maybe_fatal (must_succeed
, terminal
,
4102 "Terminal type %s is not defined",
4103 "Terminal type %s is not defined.\n\
4104 If that is not the actual type of terminal you have,\n\
4105 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
4106 `setenv TERM ...') to specify the correct type. It may be necessary\n"
4108 "to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
4110 "to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
4115 area
= tty
->termcap_strings_buffer
;
4116 tty
->TS_ins_line
= tgetstr ("al", address
);
4117 tty
->TS_ins_multi_lines
= tgetstr ("AL", address
);
4118 tty
->TS_bell
= tgetstr ("bl", address
);
4119 BackTab (tty
) = tgetstr ("bt", address
);
4120 tty
->TS_clr_to_bottom
= tgetstr ("cd", address
);
4121 tty
->TS_clr_line
= tgetstr ("ce", address
);
4122 tty
->TS_clr_frame
= tgetstr ("cl", address
);
4123 ColPosition (tty
) = NULL
; /* tgetstr ("ch", address); */
4124 AbsPosition (tty
) = tgetstr ("cm", address
);
4125 CR (tty
) = tgetstr ("cr", address
);
4126 tty
->TS_set_scroll_region
= tgetstr ("cs", address
);
4127 tty
->TS_set_scroll_region_1
= tgetstr ("cS", address
);
4128 RowPosition (tty
) = tgetstr ("cv", address
);
4129 tty
->TS_del_char
= tgetstr ("dc", address
);
4130 tty
->TS_del_multi_chars
= tgetstr ("DC", address
);
4131 tty
->TS_del_line
= tgetstr ("dl", address
);
4132 tty
->TS_del_multi_lines
= tgetstr ("DL", address
);
4133 tty
->TS_delete_mode
= tgetstr ("dm", address
);
4134 tty
->TS_end_delete_mode
= tgetstr ("ed", address
);
4135 tty
->TS_end_insert_mode
= tgetstr ("ei", address
);
4136 Home (tty
) = tgetstr ("ho", address
);
4137 tty
->TS_ins_char
= tgetstr ("ic", address
);
4138 tty
->TS_ins_multi_chars
= tgetstr ("IC", address
);
4139 tty
->TS_insert_mode
= tgetstr ("im", address
);
4140 tty
->TS_pad_inserted_char
= tgetstr ("ip", address
);
4141 tty
->TS_end_keypad_mode
= tgetstr ("ke", address
);
4142 tty
->TS_keypad_mode
= tgetstr ("ks", address
);
4143 LastLine (tty
) = tgetstr ("ll", address
);
4144 Right (tty
) = tgetstr ("nd", address
);
4145 Down (tty
) = tgetstr ("do", address
);
4147 Down (tty
) = tgetstr ("nl", address
); /* Obsolete name for "do". */
4148 if (tgetflag ("bs"))
4149 Left (tty
) = "\b"; /* Can't possibly be longer! */
4150 else /* (Actually, "bs" is obsolete...) */
4151 Left (tty
) = tgetstr ("le", address
);
4153 Left (tty
) = tgetstr ("bc", address
); /* Obsolete name for "le". */
4154 tty
->TS_pad_char
= tgetstr ("pc", address
);
4155 tty
->TS_repeat
= tgetstr ("rp", address
);
4156 tty
->TS_end_standout_mode
= tgetstr ("se", address
);
4157 tty
->TS_fwd_scroll
= tgetstr ("sf", address
);
4158 tty
->TS_standout_mode
= tgetstr ("so", address
);
4159 tty
->TS_rev_scroll
= tgetstr ("sr", address
);
4160 tty
->Wcm
->cm_tab
= tgetstr ("ta", address
);
4161 tty
->TS_end_termcap_modes
= tgetstr ("te", address
);
4162 tty
->TS_termcap_modes
= tgetstr ("ti", address
);
4163 Up (tty
) = tgetstr ("up", address
);
4164 tty
->TS_visible_bell
= tgetstr ("vb", address
);
4165 tty
->TS_cursor_normal
= tgetstr ("ve", address
);
4166 tty
->TS_cursor_visible
= tgetstr ("vs", address
);
4167 tty
->TS_cursor_invisible
= tgetstr ("vi", address
);
4168 tty
->TS_set_window
= tgetstr ("wi", address
);
4170 tty
->TS_enter_underline_mode
= tgetstr ("us", address
);
4171 tty
->TS_exit_underline_mode
= tgetstr ("ue", address
);
4172 tty
->TS_enter_bold_mode
= tgetstr ("md", address
);
4173 tty
->TS_enter_italic_mode
= tgetstr ("ZH", address
);
4174 tty
->TS_enter_dim_mode
= tgetstr ("mh", address
);
4175 tty
->TS_enter_reverse_mode
= tgetstr ("mr", address
);
4176 tty
->TS_enter_alt_charset_mode
= tgetstr ("as", address
);
4177 tty
->TS_exit_alt_charset_mode
= tgetstr ("ae", address
);
4178 tty
->TS_exit_attribute_mode
= tgetstr ("me", address
);
4180 MultiUp (tty
) = tgetstr ("UP", address
);
4181 MultiDown (tty
) = tgetstr ("DO", address
);
4182 MultiLeft (tty
) = tgetstr ("LE", address
);
4183 MultiRight (tty
) = tgetstr ("RI", address
);
4185 /* SVr4/ANSI color support. If "op" isn't available, don't support
4186 color because we can't switch back to the default foreground and
4188 tty
->TS_orig_pair
= tgetstr ("op", address
);
4189 if (tty
->TS_orig_pair
)
4191 tty
->TS_set_foreground
= tgetstr ("AF", address
);
4192 tty
->TS_set_background
= tgetstr ("AB", address
);
4193 if (!tty
->TS_set_foreground
)
4196 tty
->TS_set_foreground
= tgetstr ("Sf", address
);
4197 tty
->TS_set_background
= tgetstr ("Sb", address
);
4200 tty
->TN_max_colors
= tgetnum ("Co");
4201 tty
->TN_max_pairs
= tgetnum ("pa");
4203 tty
->TN_no_color_video
= tgetnum ("NC");
4204 if (tty
->TN_no_color_video
== -1)
4205 tty
->TN_no_color_video
= 0;
4208 tty_default_color_capabilities (tty
, 1);
4210 MagicWrap (tty
) = tgetflag ("xn");
4211 /* Since we make MagicWrap terminals look like AutoWrap, we need to have
4212 the former flag imply the latter. */
4213 AutoWrap (tty
) = MagicWrap (tty
) || tgetflag ("am");
4214 tty
->memory_below_frame
= tgetflag ("db");
4215 tty
->TF_hazeltine
= tgetflag ("hz");
4216 tty
->must_write_spaces
= tgetflag ("in");
4217 tty
->meta_key
= tgetflag ("km") || tgetflag ("MT");
4218 tty
->TF_insmode_motion
= tgetflag ("mi");
4219 tty
->TF_standout_motion
= tgetflag ("ms");
4220 tty
->TF_underscore
= tgetflag ("ul");
4221 tty
->TF_teleray
= tgetflag ("xt");
4226 struct frame
*f
= XFRAME (selected_frame
);
4229 initialize_w32_display (terminal
, &width
, &height
);
4231 FrameRows (tty
) = height
;
4232 FrameCols (tty
) = width
;
4233 tty
->specified_window
= height
;
4235 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
) = vertical_scroll_bar_none
;
4236 FRAME_HAS_HORIZONTAL_SCROLL_BARS (f
) = 0;
4237 tty
->char_ins_del_ok
= 1;
4243 if (strcmp (terminal_type
, "internal") == 0)
4244 terminal
->type
= output_msdos_raw
;
4245 initialize_msdos_display (terminal
);
4247 get_tty_size (fileno (tty
->input
), &width
, &height
);
4248 FrameCols (tty
) = width
;
4249 FrameRows (tty
) = height
;
4250 tty
->char_ins_del_ok
= 0;
4251 init_baud_rate (fileno (tty
->input
));
4254 tty
->output
= stdout
;
4256 /* The following two are inaccessible from w32console.c. */
4257 terminal
->delete_frame_hook
= &tty_free_frame_resources
;
4258 terminal
->delete_terminal_hook
= &delete_tty
;
4260 tty
->name
= xstrdup (name
);
4261 terminal
->name
= xstrdup (name
);
4262 tty
->type
= xstrdup (terminal_type
);
4264 add_keyboard_wait_descriptor (0);
4266 tty
->delete_in_insert_mode
= 1;
4269 tty
->scroll_region_ok
= 0;
4271 /* Seems to insert lines when it's not supposed to, messing up the
4272 display. In doing a trace, it didn't seem to be called much, so I
4273 don't think we're losing anything by turning it off. */
4274 tty
->line_ins_del_ok
= 0;
4276 tty
->TN_max_colors
= 16; /* Must be non-zero for tty-display-color-p. */
4280 terminal
->mouse_position_hook
= term_mouse_position
;
4281 tty
->mouse_highlight
.mouse_face_window
= Qnil
;
4284 terminal
->kboard
= allocate_kboard (Qnil
);
4285 terminal
->kboard
->reference_count
++;
4286 /* Don't let the initial kboard remain current longer than necessary.
4287 That would cause problems if a file loaded on startup tries to
4288 prompt in the mini-buffer. */
4289 if (current_kboard
== initial_kboard
)
4290 current_kboard
= terminal
->kboard
;
4292 term_get_fkeys (address
, terminal
->kboard
);
4294 /* Get frame size from system, or else from termcap. */
4297 get_tty_size (fileno (tty
->input
), &width
, &height
);
4298 FrameCols (tty
) = width
;
4299 FrameRows (tty
) = height
;
4302 if (FrameCols (tty
) <= 0)
4303 FrameCols (tty
) = tgetnum ("co");
4304 if (FrameRows (tty
) <= 0)
4305 FrameRows (tty
) = tgetnum ("li");
4307 if (FrameRows (tty
) < 3 || FrameCols (tty
) < 3)
4308 maybe_fatal (must_succeed
, terminal
,
4309 "Screen size %dx%d is too small",
4310 "Screen size %dx%d is too small",
4311 FrameCols (tty
), FrameRows (tty
));
4313 TabWidth (tty
) = tgetnum ("tw");
4316 tty
->TS_bell
= "\07";
4318 if (!tty
->TS_fwd_scroll
)
4319 tty
->TS_fwd_scroll
= Down (tty
);
4321 PC
= tty
->TS_pad_char
? *tty
->TS_pad_char
: 0;
4323 if (TabWidth (tty
) < 0)
4326 /* Turned off since /etc/termcap seems to have :ta= for most terminals
4327 and newer termcap doc does not seem to say there is a default.
4328 if (!tty->Wcm->cm_tab)
4329 tty->Wcm->cm_tab = "\t";
4332 /* We don't support standout modes that use `magic cookies', so
4333 turn off any that do. */
4334 if (tty
->TS_standout_mode
&& tgetnum ("sg") >= 0)
4336 tty
->TS_standout_mode
= 0;
4337 tty
->TS_end_standout_mode
= 0;
4339 if (tty
->TS_enter_underline_mode
&& tgetnum ("ug") >= 0)
4341 tty
->TS_enter_underline_mode
= 0;
4342 tty
->TS_exit_underline_mode
= 0;
4345 /* If there's no standout mode, try to use underlining instead. */
4346 if (tty
->TS_standout_mode
== 0)
4348 tty
->TS_standout_mode
= tty
->TS_enter_underline_mode
;
4349 tty
->TS_end_standout_mode
= tty
->TS_exit_underline_mode
;
4352 /* If no `se' string, try using a `me' string instead.
4353 If that fails, we can't use standout mode at all. */
4354 if (tty
->TS_end_standout_mode
== 0)
4356 char *s
= tgetstr ("me", address
);
4358 tty
->TS_end_standout_mode
= s
;
4360 tty
->TS_standout_mode
= 0;
4363 if (tty
->TF_teleray
)
4365 tty
->Wcm
->cm_tab
= 0;
4366 /* We can't support standout mode, because it uses magic cookies. */
4367 tty
->TS_standout_mode
= 0;
4368 /* But that means we cannot rely on ^M to go to column zero! */
4370 /* LF can't be trusted either -- can alter hpos. */
4371 /* If move at column 0 thru a line with TS_standout_mode. */
4375 tty
->specified_window
= FrameRows (tty
);
4377 if (Wcm_init (tty
) == -1) /* Can't do cursor motion. */
4379 maybe_fatal (must_succeed
, terminal
,
4380 "Terminal type \"%s\" is not powerful enough to run Emacs",
4381 "Terminal type \"%s\" is not powerful enough to run Emacs.\n\
4382 It lacks the ability to position the cursor.\n\
4383 If that is not the actual type of terminal you have,\n\
4384 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
4385 `setenv TERM ...') to specify the correct type. It may be necessary\n"
4387 "to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
4388 # else /* TERMCAP */
4389 "to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
4390 # endif /* TERMINFO */
4394 if (FrameRows (tty
) <= 0 || FrameCols (tty
) <= 0)
4395 maybe_fatal (must_succeed
, terminal
,
4396 "Could not determine the frame size",
4397 "Could not determine the frame size");
4399 tty
->delete_in_insert_mode
4400 = tty
->TS_delete_mode
&& tty
->TS_insert_mode
4401 && !strcmp (tty
->TS_delete_mode
, tty
->TS_insert_mode
);
4403 UseTabs (tty
) = tabs_safe_p (fileno (tty
->input
)) && TabWidth (tty
) == 8;
4405 tty
->scroll_region_ok
4407 && (tty
->TS_set_window
|| tty
->TS_set_scroll_region
|| tty
->TS_set_scroll_region_1
));
4409 tty
->line_ins_del_ok
4410 = (((tty
->TS_ins_line
|| tty
->TS_ins_multi_lines
)
4411 && (tty
->TS_del_line
|| tty
->TS_del_multi_lines
))
4412 || (tty
->scroll_region_ok
4413 && tty
->TS_fwd_scroll
&& tty
->TS_rev_scroll
));
4415 tty
->char_ins_del_ok
4416 = ((tty
->TS_ins_char
|| tty
->TS_insert_mode
4417 || tty
->TS_pad_inserted_char
|| tty
->TS_ins_multi_chars
)
4418 && (tty
->TS_del_char
|| tty
->TS_del_multi_chars
));
4420 init_baud_rate (fileno (tty
->input
));
4422 #endif /* not DOS_NT */
4424 /* Init system terminal modes (RAW or CBREAK, etc.). */
4425 init_sys_modes (tty
);
4432 vfatal (const char *str
, va_list ap
)
4434 fprintf (stderr
, "emacs: ");
4435 vfprintf (stderr
, str
, ap
);
4436 if (!(strlen (str
) > 0 && str
[strlen (str
) - 1] == '\n'))
4437 fprintf (stderr
, "\n");
4443 /* Auxiliary error-handling function for init_tty.
4444 Delete TERMINAL, then call error or fatal with str1 or str2,
4445 respectively, according to whether MUST_SUCCEED is true. */
4448 maybe_fatal (bool must_succeed
, struct terminal
*terminal
,
4449 const char *str1
, const char *str2
, ...)
4452 va_start (ap
, str2
);
4454 delete_tty (terminal
);
4463 fatal (const char *str
, ...)
4472 /* Delete the given tty terminal, closing all frames on it. */
4475 delete_tty (struct terminal
*terminal
)
4477 struct tty_display_info
*tty
;
4479 /* Protect against recursive calls. delete_frame in
4480 delete_terminal calls us back when it deletes our last frame. */
4481 if (!terminal
->name
)
4484 eassert (terminal
->type
== output_termcap
);
4486 tty
= terminal
->display_info
.tty
;
4488 if (tty
== tty_list
)
4489 tty_list
= tty
->next
;
4492 struct tty_display_info
*p
;
4493 for (p
= tty_list
; p
&& p
->next
!= tty
; p
= p
->next
)
4497 /* This should not happen. */
4500 p
->next
= tty
->next
;
4504 /* reset_sys_modes needs a valid device, so this call needs to be
4505 before delete_terminal. */
4506 reset_sys_modes (tty
);
4508 delete_terminal (terminal
);
4515 delete_keyboard_wait_descriptor (fileno (tty
->input
));
4516 if (tty
->input
!= stdin
)
4517 fclose (tty
->input
);
4519 if (tty
->output
&& tty
->output
!= stdout
&& tty
->output
!= tty
->input
)
4520 fclose (tty
->output
);
4521 if (tty
->termscript
)
4522 fclose (tty
->termscript
);
4524 xfree (tty
->old_tty
);
4532 DEFVAR_BOOL ("system-uses-terminfo", system_uses_terminfo
,
4533 doc
: /* Non-nil means the system uses terminfo rather than termcap.
4534 This variable can be used by terminal emulator packages. */);
4536 system_uses_terminfo
= 1;
4538 system_uses_terminfo
= 0;
4541 DEFVAR_LISP ("suspend-tty-functions", Vsuspend_tty_functions
,
4542 doc
: /* Functions run after suspending a tty.
4543 The functions are run with one argument, the terminal object to be suspended.
4544 See `suspend-tty'. */);
4545 Vsuspend_tty_functions
= Qnil
;
4548 DEFVAR_LISP ("resume-tty-functions", Vresume_tty_functions
,
4549 doc
: /* Functions run after resuming a tty.
4550 The functions are run with one argument, the terminal object that was revived.
4551 See `resume-tty'. */);
4552 Vresume_tty_functions
= Qnil
;
4554 DEFVAR_BOOL ("visible-cursor", visible_cursor
,
4555 doc
: /* Non-nil means to make the cursor very visible.
4556 This only has an effect when running in a text terminal.
4557 What means \"very visible\" is up to your terminal. It may make the cursor
4558 bigger, or it may make it blink, or it may do nothing at all. */);
4561 defsubr (&Stty_display_color_p
);
4562 defsubr (&Stty_display_color_cells
);
4563 defsubr (&Stty_no_underline
);
4564 defsubr (&Stty_type
);
4565 defsubr (&Scontrolling_tty_p
);
4566 defsubr (&Stty_top_frame
);
4567 defsubr (&Ssuspend_tty
);
4568 defsubr (&Sresume_tty
);
4570 defsubr (&Sgpm_mouse_start
);
4571 defsubr (&Sgpm_mouse_stop
);
4572 #endif /* HAVE_GPM */
4575 default_orig_pair
= NULL
;
4576 default_set_foreground
= NULL
;
4577 default_set_background
= NULL
;
4578 #endif /* !DOS_NT */
4580 encode_terminal_src
= NULL
;
4581 encode_terminal_dst
= NULL
;
4583 DEFSYM (Qtty_mode_set_strings
, "tty-mode-set-strings");
4584 DEFSYM (Qtty_mode_reset_strings
, "tty-mode-reset-strings");
4587 DEFSYM (Qtty_menu_next_item
, "tty-menu-next-item");
4588 DEFSYM (Qtty_menu_prev_item
, "tty-menu-prev-item");
4589 DEFSYM (Qtty_menu_next_menu
, "tty-menu-next-menu");
4590 DEFSYM (Qtty_menu_prev_menu
, "tty-menu-prev-menu");
4591 DEFSYM (Qtty_menu_select
, "tty-menu-select");
4592 DEFSYM (Qtty_menu_ignore
, "tty-menu-ignore");
4593 DEFSYM (Qtty_menu_exit
, "tty-menu-exit");
4594 DEFSYM (Qtty_menu_mouse_movement
, "tty-menu-mouse-movement");
4595 DEFSYM (Qtty_menu_navigation_map
, "tty-menu-navigation-map");