1 /* Terminal control module for terminals described by TERMCAP
2 Copyright (C) 1985-1987, 1993-1995, 1998, 2000-2013 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_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
;
137 #include <sys/fcntl.h>
139 /* The device for which we have enabled gpm support (or NULL). */
140 struct tty_display_info
*gpm_tty
= NULL
;
142 /* Last recorded mouse coordinates. */
143 static int last_mouse_x
, last_mouse_y
;
144 #endif /* HAVE_GPM */
146 /* Ring the bell on a tty. */
149 tty_ring_bell (struct frame
*f
)
151 struct tty_display_info
*tty
= FRAME_TTY (f
);
155 OUTPUT (tty
, (tty
->TS_visible_bell
&& visible_bell
156 ? tty
->TS_visible_bell
158 fflush (tty
->output
);
162 /* Set up termcap modes for Emacs. */
165 tty_set_terminal_modes (struct terminal
*terminal
)
167 struct tty_display_info
*tty
= terminal
->display_info
.tty
;
171 if (tty
->TS_termcap_modes
)
172 OUTPUT (tty
, tty
->TS_termcap_modes
);
175 /* Output enough newlines to scroll all the old screen contents
176 off the screen, so it won't be overwritten and lost. */
179 for (i
= 0; i
< FRAME_LINES (XFRAME (selected_frame
)); i
++)
183 OUTPUT_IF (tty
, visible_cursor
? tty
->TS_cursor_visible
: tty
->TS_cursor_normal
);
184 OUTPUT_IF (tty
, tty
->TS_keypad_mode
);
186 fflush (tty
->output
);
190 /* Reset termcap modes before exiting Emacs. */
193 tty_reset_terminal_modes (struct terminal
*terminal
)
195 struct tty_display_info
*tty
= terminal
->display_info
.tty
;
199 tty_turn_off_highlight (tty
);
200 tty_turn_off_insert (tty
);
201 OUTPUT_IF (tty
, tty
->TS_end_keypad_mode
);
202 OUTPUT_IF (tty
, tty
->TS_cursor_normal
);
203 OUTPUT_IF (tty
, tty
->TS_end_termcap_modes
);
204 OUTPUT_IF (tty
, tty
->TS_orig_pair
);
205 /* Output raw CR so kernel can track the cursor hpos. */
208 fflush (tty
->output
);
212 /* Flag the end of a display update on a termcap terminal. */
215 tty_update_end (struct frame
*f
)
217 struct tty_display_info
*tty
= FRAME_TTY (f
);
219 if (!XWINDOW (selected_window
)->cursor_off_p
)
220 tty_show_cursor (tty
);
221 tty_turn_off_insert (tty
);
222 tty_background_highlight (tty
);
225 /* The implementation of set_terminal_window for termcap frames. */
228 tty_set_terminal_window (struct frame
*f
, int size
)
230 struct tty_display_info
*tty
= FRAME_TTY (f
);
232 tty
->specified_window
= size
? size
: FRAME_LINES (f
);
233 if (FRAME_SCROLL_REGION_OK (f
))
234 tty_set_scroll_region (f
, 0, tty
->specified_window
);
238 tty_set_scroll_region (struct frame
*f
, int start
, int stop
)
241 struct tty_display_info
*tty
= FRAME_TTY (f
);
243 if (tty
->TS_set_scroll_region
)
244 buf
= tparam (tty
->TS_set_scroll_region
, 0, 0, start
, stop
- 1, 0, 0);
245 else if (tty
->TS_set_scroll_region_1
)
246 buf
= tparam (tty
->TS_set_scroll_region_1
, 0, 0,
247 FRAME_LINES (f
), start
,
248 FRAME_LINES (f
) - stop
,
251 buf
= tparam (tty
->TS_set_window
, 0, 0, start
, 0, stop
, FRAME_COLS (f
));
260 tty_turn_on_insert (struct tty_display_info
*tty
)
262 if (!tty
->insert_mode
)
263 OUTPUT (tty
, tty
->TS_insert_mode
);
264 tty
->insert_mode
= 1;
268 tty_turn_off_insert (struct tty_display_info
*tty
)
270 if (tty
->insert_mode
)
271 OUTPUT (tty
, tty
->TS_end_insert_mode
);
272 tty
->insert_mode
= 0;
275 /* Handle highlighting. */
278 tty_turn_off_highlight (struct tty_display_info
*tty
)
280 if (tty
->standout_mode
)
281 OUTPUT_IF (tty
, tty
->TS_end_standout_mode
);
282 tty
->standout_mode
= 0;
286 tty_turn_on_highlight (struct tty_display_info
*tty
)
288 if (!tty
->standout_mode
)
289 OUTPUT_IF (tty
, tty
->TS_standout_mode
);
290 tty
->standout_mode
= 1;
294 tty_toggle_highlight (struct tty_display_info
*tty
)
296 if (tty
->standout_mode
)
297 tty_turn_off_highlight (tty
);
299 tty_turn_on_highlight (tty
);
303 /* Make cursor invisible. */
306 tty_hide_cursor (struct tty_display_info
*tty
)
308 if (tty
->cursor_hidden
== 0)
310 tty
->cursor_hidden
= 1;
312 w32con_hide_cursor ();
314 OUTPUT_IF (tty
, tty
->TS_cursor_invisible
);
320 /* Ensure that cursor is visible. */
323 tty_show_cursor (struct tty_display_info
*tty
)
325 if (tty
->cursor_hidden
)
327 tty
->cursor_hidden
= 0;
329 w32con_show_cursor ();
331 OUTPUT_IF (tty
, tty
->TS_cursor_normal
);
333 OUTPUT_IF (tty
, tty
->TS_cursor_visible
);
339 /* Set standout mode to the state it should be in for
340 empty space inside windows. What this is,
341 depends on the user option inverse-video. */
344 tty_background_highlight (struct tty_display_info
*tty
)
347 tty_turn_on_highlight (tty
);
349 tty_turn_off_highlight (tty
);
352 /* Set standout mode to the mode specified for the text to be output. */
355 tty_highlight_if_desired (struct tty_display_info
*tty
)
358 tty_turn_on_highlight (tty
);
360 tty_turn_off_highlight (tty
);
364 /* Move cursor to row/column position VPOS/HPOS. HPOS/VPOS are
365 frame-relative coordinates. */
368 tty_cursor_to (struct frame
*f
, int vpos
, int hpos
)
370 struct tty_display_info
*tty
= FRAME_TTY (f
);
372 /* Detect the case where we are called from reset_sys_modes
373 and the costs have never been calculated. Do nothing. */
374 if (! tty
->costs_set
)
377 if (curY (tty
) == vpos
378 && curX (tty
) == hpos
)
380 if (!tty
->TF_standout_motion
)
381 tty_background_highlight (tty
);
382 if (!tty
->TF_insmode_motion
)
383 tty_turn_off_insert (tty
);
384 cmgoto (tty
, vpos
, hpos
);
387 /* Similar but don't take any account of the wasted characters. */
390 tty_raw_cursor_to (struct frame
*f
, int row
, int col
)
392 struct tty_display_info
*tty
= FRAME_TTY (f
);
394 if (curY (tty
) == row
395 && curX (tty
) == col
)
397 if (!tty
->TF_standout_motion
)
398 tty_background_highlight (tty
);
399 if (!tty
->TF_insmode_motion
)
400 tty_turn_off_insert (tty
);
401 cmgoto (tty
, row
, col
);
404 /* Erase operations */
406 /* Clear from cursor to end of frame on a termcap device. */
409 tty_clear_to_end (struct frame
*f
)
412 struct tty_display_info
*tty
= FRAME_TTY (f
);
414 if (tty
->TS_clr_to_bottom
)
416 tty_background_highlight (tty
);
417 OUTPUT (tty
, tty
->TS_clr_to_bottom
);
421 for (i
= curY (tty
); i
< FRAME_LINES (f
); i
++)
424 clear_end_of_line (f
, FRAME_COLS (f
));
429 /* Clear an entire termcap frame. */
432 tty_clear_frame (struct frame
*f
)
434 struct tty_display_info
*tty
= FRAME_TTY (f
);
436 if (tty
->TS_clr_frame
)
438 tty_background_highlight (tty
);
439 OUTPUT (tty
, tty
->TS_clr_frame
);
449 /* An implementation of clear_end_of_line for termcap frames.
451 Note that the cursor may be moved, on terminals lacking a `ce' string. */
454 tty_clear_end_of_line (struct frame
*f
, int first_unused_hpos
)
457 struct tty_display_info
*tty
= FRAME_TTY (f
);
459 /* Detect the case where we are called from reset_sys_modes
460 and the costs have never been calculated. Do nothing. */
461 if (! tty
->costs_set
)
464 if (curX (tty
) >= first_unused_hpos
)
466 tty_background_highlight (tty
);
467 if (tty
->TS_clr_line
)
469 OUTPUT1 (tty
, tty
->TS_clr_line
);
472 { /* have to do it the hard way */
473 tty_turn_off_insert (tty
);
475 /* Do not write in last row last col with Auto-wrap on. */
477 && curY (tty
) == FrameRows (tty
) - 1
478 && first_unused_hpos
== FrameCols (tty
))
481 for (i
= curX (tty
); i
< first_unused_hpos
; i
++)
484 fputc (' ', tty
->termscript
);
485 fputc (' ', tty
->output
);
487 cmplus (tty
, first_unused_hpos
- curX (tty
));
491 /* Buffers to store the source and result of code conversion for terminal. */
492 static unsigned char *encode_terminal_src
;
493 static unsigned char *encode_terminal_dst
;
494 /* Allocated sizes of the above buffers. */
495 static ptrdiff_t encode_terminal_src_size
;
496 static ptrdiff_t encode_terminal_dst_size
;
498 /* Encode SRC_LEN glyphs starting at SRC to terminal output codes.
499 Set CODING->produced to the byte-length of the resulting byte
500 sequence, and return a pointer to that byte sequence. */
503 encode_terminal_code (struct glyph
*src
, int src_len
, struct coding_system
*coding
)
505 struct glyph
*src_end
= src
+ src_len
;
507 ptrdiff_t nchars
, nbytes
, required
;
508 ptrdiff_t tlen
= GLYPH_TABLE_LENGTH
;
509 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
510 Lisp_Object charset_list
;
512 /* Allocate sufficient size of buffer to store all characters in
513 multibyte-form. But, it may be enlarged on demand if
514 Vglyph_table contains a string or a composite glyph is
516 if (min (PTRDIFF_MAX
, SIZE_MAX
) / MAX_MULTIBYTE_LENGTH
< src_len
)
517 memory_full (SIZE_MAX
);
519 required
*= MAX_MULTIBYTE_LENGTH
;
520 if (encode_terminal_src_size
< required
)
522 encode_terminal_src
= xrealloc (encode_terminal_src
, required
);
523 encode_terminal_src_size
= required
;
526 charset_list
= coding_charset_list (coding
);
528 buf
= encode_terminal_src
;
530 while (src
< src_end
)
532 if (src
->type
== COMPOSITE_GLYPH
)
534 struct composition
*cmp
IF_LINT (= NULL
);
535 Lisp_Object gstring
IF_LINT (= Qnil
);
538 nbytes
= buf
- encode_terminal_src
;
539 if (src
->u
.cmp
.automatic
)
541 gstring
= composition_gstring_from_id (src
->u
.cmp
.id
);
542 required
= src
->slice
.cmp
.to
- src
->slice
.cmp
.from
+ 1;
546 cmp
= composition_table
[src
->u
.cmp
.id
];
547 required
= cmp
->glyph_len
;
548 required
*= MAX_MULTIBYTE_LENGTH
;
551 if (encode_terminal_src_size
- nbytes
< required
)
553 encode_terminal_src
=
554 xpalloc (encode_terminal_src
, &encode_terminal_src_size
,
555 required
- (encode_terminal_src_size
- nbytes
),
557 buf
= encode_terminal_src
+ nbytes
;
560 if (src
->u
.cmp
.automatic
)
561 for (i
= src
->slice
.cmp
.from
; i
<= src
->slice
.cmp
.to
; i
++)
563 Lisp_Object g
= LGSTRING_GLYPH (gstring
, i
);
564 int c
= LGLYPH_CHAR (g
);
566 if (! char_charset (c
, charset_list
, NULL
))
568 buf
+= CHAR_STRING (c
, buf
);
572 for (i
= 0; i
< cmp
->glyph_len
; i
++)
574 int c
= COMPOSITION_GLYPH (cmp
, i
);
576 /* TAB in a composition means display glyphs with
577 padding space on the left or right. */
580 if (char_charset (c
, charset_list
, NULL
))
582 if (CHAR_WIDTH (c
) == 0
583 && i
> 0 && COMPOSITION_GLYPH (cmp
, i
- 1) == '\t')
584 /* Should be left-padded */
586 buf
+= CHAR_STRING (' ', buf
);
592 buf
+= CHAR_STRING (c
, buf
);
596 /* We must skip glyphs to be padded for a wide character. */
597 else if (! CHAR_GLYPH_PADDING_P (*src
))
604 SET_GLYPH_FROM_CHAR_GLYPH (g
, src
[0]);
606 if (GLYPH_INVALID_P (g
) || GLYPH_SIMPLE_P (tbase
, tlen
, g
))
608 /* This glyph doesn't have an entry in Vglyph_table. */
613 /* This glyph has an entry in Vglyph_table,
614 so process any alias before testing for simpleness. */
615 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
617 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
618 /* We set the multi-byte form of a character in G
619 (that should be an ASCII character) at WORKBUF. */
622 /* We have a string in Vglyph_table. */
623 string
= tbase
[GLYPH_CHAR (g
)];
628 nbytes
= buf
- encode_terminal_src
;
629 if (encode_terminal_src_size
- nbytes
< MAX_MULTIBYTE_LENGTH
)
631 encode_terminal_src
=
632 xpalloc (encode_terminal_src
, &encode_terminal_src_size
,
633 MAX_MULTIBYTE_LENGTH
, -1, 1);
634 buf
= encode_terminal_src
+ nbytes
;
637 || char_charset (c
, charset_list
, NULL
))
639 /* Store the multibyte form of C at BUF. */
640 buf
+= CHAR_STRING (c
, buf
);
645 /* C is not encodable. */
648 while (src
+ 1 < src_end
&& CHAR_GLYPH_PADDING_P (src
[1]))
658 if (! STRING_MULTIBYTE (string
))
659 string
= string_to_multibyte (string
);
660 nbytes
= buf
- encode_terminal_src
;
661 if (encode_terminal_src_size
- nbytes
< SBYTES (string
))
663 encode_terminal_src
=
664 xpalloc (encode_terminal_src
, &encode_terminal_src_size
,
666 - (encode_terminal_src_size
- nbytes
)),
668 buf
= encode_terminal_src
+ nbytes
;
670 memcpy (buf
, SDATA (string
), SBYTES (string
));
671 buf
+= SBYTES (string
);
672 nchars
+= SCHARS (string
);
680 coding
->produced
= 0;
684 nbytes
= buf
- encode_terminal_src
;
685 coding
->source
= encode_terminal_src
;
686 if (encode_terminal_dst_size
== 0)
688 encode_terminal_dst
= xrealloc (encode_terminal_dst
,
689 encode_terminal_src_size
);
690 encode_terminal_dst_size
= encode_terminal_src_size
;
692 coding
->destination
= encode_terminal_dst
;
693 coding
->dst_bytes
= encode_terminal_dst_size
;
694 encode_coding_object (coding
, Qnil
, 0, 0, nchars
, nbytes
, Qnil
);
695 /* coding->destination may have been reallocated. */
696 encode_terminal_dst
= coding
->destination
;
697 encode_terminal_dst_size
= coding
->dst_bytes
;
699 return (encode_terminal_dst
);
704 /* An implementation of write_glyphs for termcap frames. */
707 tty_write_glyphs (struct frame
*f
, struct glyph
*string
, int len
)
709 unsigned char *conversion_buffer
;
710 struct coding_system
*coding
;
713 struct tty_display_info
*tty
= FRAME_TTY (f
);
715 tty_turn_off_insert (tty
);
716 tty_hide_cursor (tty
);
718 /* Don't dare write in last column of bottom line, if Auto-Wrap,
719 since that would scroll the whole frame on some terminals. */
722 && curY (tty
) + 1 == FRAME_LINES (f
)
723 && (curX (tty
) + len
) == FRAME_COLS (f
))
730 /* If terminal_coding does any conversion, use it, otherwise use
731 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
732 because it always return 1 if the member src_multibyte is 1. */
733 coding
= (FRAME_TERMINAL_CODING (f
)->common_flags
& CODING_REQUIRE_ENCODING_MASK
734 ? FRAME_TERMINAL_CODING (f
) : &safe_terminal_coding
);
735 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
737 coding
->mode
&= ~CODING_MODE_LAST_BLOCK
;
739 for (stringlen
= len
; stringlen
!= 0; stringlen
-= n
)
741 /* Identify a run of glyphs with the same face. */
742 int face_id
= string
->face_id
;
744 for (n
= 1; n
< stringlen
; ++n
)
745 if (string
[n
].face_id
!= face_id
)
748 /* Turn appearance modes of the face of the run on. */
749 tty_highlight_if_desired (tty
);
750 turn_on_face (f
, face_id
);
753 /* This is the last run. */
754 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
755 conversion_buffer
= encode_terminal_code (string
, n
, coding
);
756 if (coding
->produced
> 0)
759 fwrite (conversion_buffer
, 1, coding
->produced
, tty
->output
);
760 if (ferror (tty
->output
))
761 clearerr (tty
->output
);
763 fwrite (conversion_buffer
, 1, coding
->produced
, tty
->termscript
);
768 /* Turn appearance modes off. */
769 turn_off_face (f
, face_id
);
770 tty_turn_off_highlight (tty
);
776 #ifdef HAVE_GPM /* Only used by GPM code. */
779 tty_write_glyphs_with_face (register struct frame
*f
, register struct glyph
*string
,
780 register int len
, register int face_id
)
782 unsigned char *conversion_buffer
;
783 struct coding_system
*coding
;
785 struct tty_display_info
*tty
= FRAME_TTY (f
);
787 tty_turn_off_insert (tty
);
788 tty_hide_cursor (tty
);
790 /* Don't dare write in last column of bottom line, if Auto-Wrap,
791 since that would scroll the whole frame on some terminals. */
794 && curY (tty
) + 1 == FRAME_LINES (f
)
795 && (curX (tty
) + len
) == FRAME_COLS (f
))
802 /* If terminal_coding does any conversion, use it, otherwise use
803 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
804 because it always return 1 if the member src_multibyte is 1. */
805 coding
= (FRAME_TERMINAL_CODING (f
)->common_flags
& CODING_REQUIRE_ENCODING_MASK
806 ? FRAME_TERMINAL_CODING (f
) : &safe_terminal_coding
);
807 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
809 coding
->mode
&= ~CODING_MODE_LAST_BLOCK
;
811 /* Turn appearance modes of the face. */
812 tty_highlight_if_desired (tty
);
813 turn_on_face (f
, face_id
);
815 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
816 conversion_buffer
= encode_terminal_code (string
, len
, coding
);
817 if (coding
->produced
> 0)
820 fwrite (conversion_buffer
, 1, coding
->produced
, tty
->output
);
821 if (ferror (tty
->output
))
822 clearerr (tty
->output
);
824 fwrite (conversion_buffer
, 1, coding
->produced
, tty
->termscript
);
828 /* Turn appearance modes off. */
829 turn_off_face (f
, face_id
);
830 tty_turn_off_highlight (tty
);
836 /* An implementation of insert_glyphs for termcap frames. */
839 tty_insert_glyphs (struct frame
*f
, struct glyph
*start
, int len
)
842 struct glyph
*glyph
= NULL
;
843 unsigned char *conversion_buffer
;
844 unsigned char space
[1];
845 struct coding_system
*coding
;
847 struct tty_display_info
*tty
= FRAME_TTY (f
);
849 if (tty
->TS_ins_multi_chars
)
851 buf
= tparam (tty
->TS_ins_multi_chars
, 0, 0, len
, 0, 0, 0);
855 write_glyphs (f
, start
, len
);
859 tty_turn_on_insert (tty
);
863 space
[0] = SPACEGLYPH
;
865 /* If terminal_coding does any conversion, use it, otherwise use
866 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
867 because it always return 1 if the member src_multibyte is 1. */
868 coding
= (FRAME_TERMINAL_CODING (f
)->common_flags
& CODING_REQUIRE_ENCODING_MASK
869 ? FRAME_TERMINAL_CODING (f
) : &safe_terminal_coding
);
870 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
872 coding
->mode
&= ~CODING_MODE_LAST_BLOCK
;
876 OUTPUT1_IF (tty
, tty
->TS_ins_char
);
879 conversion_buffer
= space
;
880 coding
->produced
= 1;
884 tty_highlight_if_desired (tty
);
885 turn_on_face (f
, start
->face_id
);
888 /* We must open sufficient space for a character which
889 occupies more than one column. */
890 while (len
&& CHAR_GLYPH_PADDING_P (*start
))
892 OUTPUT1_IF (tty
, tty
->TS_ins_char
);
897 /* This is the last glyph. */
898 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
900 conversion_buffer
= encode_terminal_code (glyph
, 1, coding
);
903 if (coding
->produced
> 0)
906 fwrite (conversion_buffer
, 1, coding
->produced
, tty
->output
);
907 if (ferror (tty
->output
))
908 clearerr (tty
->output
);
910 fwrite (conversion_buffer
, 1, coding
->produced
, tty
->termscript
);
914 OUTPUT1_IF (tty
, tty
->TS_pad_inserted_char
);
917 turn_off_face (f
, glyph
->face_id
);
918 tty_turn_off_highlight (tty
);
925 /* An implementation of delete_glyphs for termcap frames. */
928 tty_delete_glyphs (struct frame
*f
, int n
)
933 struct tty_display_info
*tty
= FRAME_TTY (f
);
935 if (tty
->delete_in_insert_mode
)
937 tty_turn_on_insert (tty
);
941 tty_turn_off_insert (tty
);
942 OUTPUT_IF (tty
, tty
->TS_delete_mode
);
945 if (tty
->TS_del_multi_chars
)
947 buf
= tparam (tty
->TS_del_multi_chars
, 0, 0, n
, 0, 0, 0);
952 for (i
= 0; i
< n
; i
++)
953 OUTPUT1 (tty
, tty
->TS_del_char
);
954 if (!tty
->delete_in_insert_mode
)
955 OUTPUT_IF (tty
, tty
->TS_end_delete_mode
);
958 /* An implementation of ins_del_lines for termcap frames. */
961 tty_ins_del_lines (struct frame
*f
, int vpos
, int n
)
963 struct tty_display_info
*tty
= FRAME_TTY (f
);
965 n
> 0 ? tty
->TS_ins_multi_lines
: tty
->TS_del_multi_lines
;
966 const char *single
= n
> 0 ? tty
->TS_ins_line
: tty
->TS_del_line
;
967 const char *scroll
= n
> 0 ? tty
->TS_rev_scroll
: tty
->TS_fwd_scroll
;
972 /* If the lines below the insertion are being pushed
973 into the end of the window, this is the same as clearing;
974 and we know the lines are already clear, since the matching
975 deletion has already been done. So can ignore this. */
976 /* If the lines below the deletion are blank lines coming
977 out of the end of the window, don't bother,
978 as there will be a matching inslines later that will flush them. */
979 if (FRAME_SCROLL_REGION_OK (f
)
980 && vpos
+ i
>= tty
->specified_window
)
982 if (!FRAME_MEMORY_BELOW_FRAME (f
)
983 && vpos
+ i
>= FRAME_LINES (f
))
988 raw_cursor_to (f
, vpos
, 0);
989 tty_background_highlight (tty
);
990 buf
= tparam (multi
, 0, 0, i
, 0, 0, 0);
996 raw_cursor_to (f
, vpos
, 0);
997 tty_background_highlight (tty
);
999 OUTPUT (tty
, single
);
1000 if (tty
->TF_teleray
)
1005 tty_set_scroll_region (f
, vpos
, tty
->specified_window
);
1007 raw_cursor_to (f
, tty
->specified_window
- 1, 0);
1009 raw_cursor_to (f
, vpos
, 0);
1010 tty_background_highlight (tty
);
1012 OUTPUTL (tty
, scroll
, tty
->specified_window
- vpos
);
1013 tty_set_scroll_region (f
, 0, tty
->specified_window
);
1016 if (!FRAME_SCROLL_REGION_OK (f
)
1017 && FRAME_MEMORY_BELOW_FRAME (f
)
1020 cursor_to (f
, FRAME_LINES (f
) + n
, 0);
1025 /* Compute cost of sending "str", in characters,
1026 not counting any line-dependent padding. */
1029 string_cost (const char *str
)
1033 tputs (str
, 0, evalcost
);
1037 /* Compute cost of sending "str", in characters,
1038 counting any line-dependent padding at one line. */
1041 string_cost_one_line (const char *str
)
1045 tputs (str
, 1, evalcost
);
1049 /* Compute per line amount of line-dependent padding,
1050 in tenths of characters. */
1053 per_line_cost (const char *str
)
1057 tputs (str
, 0, evalcost
);
1060 tputs (str
, 10, evalcost
);
1064 /* char_ins_del_cost[n] is cost of inserting N characters.
1065 char_ins_del_cost[-n] is cost of deleting N characters.
1066 The length of this vector is based on max_frame_cols. */
1068 int *char_ins_del_vector
;
1070 #define char_ins_del_cost(f) (&char_ins_del_vector[FRAME_COLS ((f))])
1074 calculate_ins_del_char_costs (struct frame
*f
)
1076 struct tty_display_info
*tty
= FRAME_TTY (f
);
1077 int ins_startup_cost
, del_startup_cost
;
1078 int ins_cost_per_char
, del_cost_per_char
;
1082 if (tty
->TS_ins_multi_chars
)
1084 ins_cost_per_char
= 0;
1085 ins_startup_cost
= string_cost_one_line (tty
->TS_ins_multi_chars
);
1087 else if (tty
->TS_ins_char
|| tty
->TS_pad_inserted_char
1088 || (tty
->TS_insert_mode
&& tty
->TS_end_insert_mode
))
1090 ins_startup_cost
= (30 * (string_cost (tty
->TS_insert_mode
)
1091 + string_cost (tty
->TS_end_insert_mode
))) / 100;
1092 ins_cost_per_char
= (string_cost_one_line (tty
->TS_ins_char
)
1093 + string_cost_one_line (tty
->TS_pad_inserted_char
));
1097 ins_startup_cost
= 9999;
1098 ins_cost_per_char
= 0;
1101 if (tty
->TS_del_multi_chars
)
1103 del_cost_per_char
= 0;
1104 del_startup_cost
= string_cost_one_line (tty
->TS_del_multi_chars
);
1106 else if (tty
->TS_del_char
)
1108 del_startup_cost
= (string_cost (tty
->TS_delete_mode
)
1109 + string_cost (tty
->TS_end_delete_mode
));
1110 if (tty
->delete_in_insert_mode
)
1111 del_startup_cost
/= 2;
1112 del_cost_per_char
= string_cost_one_line (tty
->TS_del_char
);
1116 del_startup_cost
= 9999;
1117 del_cost_per_char
= 0;
1120 /* Delete costs are at negative offsets */
1121 p
= &char_ins_del_cost (f
)[0];
1122 for (i
= FRAME_COLS (f
); --i
>= 0;)
1123 *--p
= (del_startup_cost
+= del_cost_per_char
);
1125 /* Doing nothing is free */
1126 p
= &char_ins_del_cost (f
)[0];
1129 /* Insert costs are at positive offsets */
1130 for (i
= FRAME_COLS (f
); --i
>= 0;)
1131 *p
++ = (ins_startup_cost
+= ins_cost_per_char
);
1135 calculate_costs (struct frame
*frame
)
1137 FRAME_COST_BAUD_RATE (frame
) = baud_rate
;
1139 if (FRAME_TERMCAP_P (frame
))
1141 struct tty_display_info
*tty
= FRAME_TTY (frame
);
1142 register const char *f
= (tty
->TS_set_scroll_region
1143 ? tty
->TS_set_scroll_region
1144 : tty
->TS_set_scroll_region_1
);
1146 FRAME_SCROLL_REGION_COST (frame
) = string_cost (f
);
1150 /* These variables are only used for terminal stuff. They are
1151 allocated once for the terminal frame of X-windows emacs, but not
1154 char_ins_del_vector (i.e., char_ins_del_cost) isn't used because
1155 X turns off char_ins_del_ok. */
1157 max_frame_cols
= max (max_frame_cols
, FRAME_COLS (frame
));
1158 if ((min (PTRDIFF_MAX
, SIZE_MAX
) / sizeof (int) - 1) / 2
1160 memory_full (SIZE_MAX
);
1162 char_ins_del_vector
=
1163 xrealloc (char_ins_del_vector
,
1164 (sizeof (int) + 2 * sizeof (int) * max_frame_cols
));
1166 memset (char_ins_del_vector
, 0,
1167 (sizeof (int) + 2 * sizeof (int) * max_frame_cols
));
1170 if (f
&& (!tty
->TS_ins_line
&& !tty
->TS_del_line
))
1171 do_line_insertion_deletion_costs (frame
,
1172 tty
->TS_rev_scroll
, tty
->TS_ins_multi_lines
,
1173 tty
->TS_fwd_scroll
, tty
->TS_del_multi_lines
,
1176 do_line_insertion_deletion_costs (frame
,
1177 tty
->TS_ins_line
, tty
->TS_ins_multi_lines
,
1178 tty
->TS_del_line
, tty
->TS_del_multi_lines
,
1181 calculate_ins_del_char_costs (frame
);
1183 /* Don't use TS_repeat if its padding is worse than sending the chars */
1184 if (tty
->TS_repeat
&& per_line_cost (tty
->TS_repeat
) * baud_rate
< 9000)
1185 tty
->RPov
= string_cost (tty
->TS_repeat
);
1187 tty
->RPov
= FRAME_COLS (frame
) * 2;
1189 cmcostinit (FRAME_TTY (frame
)); /* set up cursor motion costs */
1194 const char *cap
, *name
;
1197 /* Termcap capability names that correspond directly to X keysyms.
1198 Some of these (marked "terminfo") aren't supplied by old-style
1199 (Berkeley) termcap entries. They're listed in X keysym order;
1200 except we put the keypad keys first, so that if they clash with
1201 other keys (as on the IBM PC keyboard) they get overridden.
1204 static const struct fkey_table keys
[] =
1206 {"kh", "home"}, /* termcap */
1207 {"kl", "left"}, /* termcap */
1208 {"ku", "up"}, /* termcap */
1209 {"kr", "right"}, /* termcap */
1210 {"kd", "down"}, /* termcap */
1211 {"%8", "prior"}, /* terminfo */
1212 {"%5", "next"}, /* terminfo */
1213 {"@7", "end"}, /* terminfo */
1214 {"@1", "begin"}, /* terminfo */
1215 {"*6", "select"}, /* terminfo */
1216 {"%9", "print"}, /* terminfo */
1217 {"@4", "execute"}, /* terminfo --- actually the `command' key */
1219 * "insert" --- see below
1221 {"&8", "undo"}, /* terminfo */
1222 {"%0", "redo"}, /* terminfo */
1223 {"%7", "menu"}, /* terminfo --- actually the `options' key */
1224 {"@0", "find"}, /* terminfo */
1225 {"@2", "cancel"}, /* terminfo */
1226 {"%1", "help"}, /* terminfo */
1228 * "break" goes here, but can't be reliably intercepted with termcap
1230 {"&4", "reset"}, /* terminfo --- actually `restart' */
1232 * "system" and "user" --- no termcaps
1234 {"kE", "clearline"}, /* terminfo */
1235 {"kA", "insertline"}, /* terminfo */
1236 {"kL", "deleteline"}, /* terminfo */
1237 {"kI", "insertchar"}, /* terminfo */
1238 {"kD", "deletechar"}, /* terminfo */
1239 {"kB", "backtab"}, /* terminfo */
1241 * "kp_backtab", "kp-space", "kp-tab" --- no termcaps
1243 {"@8", "kp-enter"}, /* terminfo */
1245 * "kp-f1", "kp-f2", "kp-f3" "kp-f4",
1246 * "kp-multiply", "kp-add", "kp-separator",
1247 * "kp-subtract", "kp-decimal", "kp-divide", "kp-0";
1248 * --- no termcaps for any of these.
1250 {"K4", "kp-1"}, /* terminfo */
1252 * "kp-2" --- no termcap
1254 {"K5", "kp-3"}, /* terminfo */
1256 * "kp-4" --- no termcap
1258 {"K2", "kp-5"}, /* terminfo */
1260 * "kp-6" --- no termcap
1262 {"K1", "kp-7"}, /* terminfo */
1264 * "kp-8" --- no termcap
1266 {"K3", "kp-9"}, /* terminfo */
1268 * "kp-equal" --- no termcap
1280 {"&0", "S-cancel"}, /*shifted cancel key*/
1281 {"&9", "S-begin"}, /*shifted begin key*/
1282 {"*0", "S-find"}, /*shifted find key*/
1283 {"*1", "S-execute"}, /*shifted execute? actually shifted command key*/
1284 {"*4", "S-delete"}, /*shifted delete-character key*/
1285 {"*7", "S-end"}, /*shifted end key*/
1286 {"*8", "S-clearline"}, /*shifted clear-to end-of-line key*/
1287 {"#1", "S-help"}, /*shifted help key*/
1288 {"#2", "S-home"}, /*shifted home key*/
1289 {"#3", "S-insert"}, /*shifted insert-character key*/
1290 {"#4", "S-left"}, /*shifted left-arrow key*/
1291 {"%d", "S-menu"}, /*shifted menu? actually shifted options key*/
1292 {"%c", "S-next"}, /*shifted next key*/
1293 {"%e", "S-prior"}, /*shifted previous key*/
1294 {"%f", "S-print"}, /*shifted print key*/
1295 {"%g", "S-redo"}, /*shifted redo key*/
1296 {"%i", "S-right"}, /*shifted right-arrow key*/
1297 {"!3", "S-undo"} /*shifted undo key*/
1301 static char **term_get_fkeys_address
;
1302 static KBOARD
*term_get_fkeys_kboard
;
1303 static Lisp_Object
term_get_fkeys_1 (void);
1305 /* Find the escape codes sent by the function keys for Vinput_decode_map.
1306 This function scans the termcap function key sequence entries, and
1307 adds entries to Vinput_decode_map for each function key it finds. */
1310 term_get_fkeys (char **address
, KBOARD
*kboard
)
1312 /* We run the body of the function (term_get_fkeys_1) and ignore all Lisp
1313 errors during the call. The only errors should be from Fdefine_key
1314 when given a key sequence containing an invalid prefix key. If the
1315 termcap defines function keys which use a prefix that is already bound
1316 to a command by the default bindings, we should silently ignore that
1317 function key specification, rather than giving the user an error and
1318 refusing to run at all on such a terminal. */
1320 term_get_fkeys_address
= address
;
1321 term_get_fkeys_kboard
= kboard
;
1322 internal_condition_case (term_get_fkeys_1
, Qerror
, Fidentity
);
1326 term_get_fkeys_1 (void)
1330 char **address
= term_get_fkeys_address
;
1331 KBOARD
*kboard
= term_get_fkeys_kboard
;
1333 /* This can happen if CANNOT_DUMP or with strange options. */
1334 if (!KEYMAPP (KVAR (kboard
, Vinput_decode_map
)))
1335 kset_input_decode_map (kboard
, Fmake_sparse_keymap (Qnil
));
1337 for (i
= 0; i
< (sizeof (keys
) / sizeof (keys
[0])); i
++)
1339 char *sequence
= tgetstr (keys
[i
].cap
, address
);
1341 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (sequence
),
1342 Fmake_vector (make_number (1),
1343 intern (keys
[i
].name
)));
1346 /* The uses of the "k0" capability are inconsistent; sometimes it
1347 describes F10, whereas othertimes it describes F0 and "k;" describes F10.
1348 We will attempt to politely accommodate both systems by testing for
1349 "k;", and if it is present, assuming that "k0" denotes F0, otherwise F10.
1352 const char *k_semi
= tgetstr ("k;", address
);
1353 const char *k0
= tgetstr ("k0", address
);
1354 const char *k0_name
= "f10";
1359 /* Define f0 first, so that f10 takes precedence in case the
1360 key sequences happens to be the same. */
1361 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (k0
),
1362 Fmake_vector (make_number (1), intern ("f0")));
1363 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (k_semi
),
1364 Fmake_vector (make_number (1), intern ("f10")));
1367 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (k0
),
1368 Fmake_vector (make_number (1), intern (k0_name
)));
1371 /* Set up cookies for numbered function keys above f10. */
1373 char fcap
[3], fkey
[4];
1375 fcap
[0] = 'F'; fcap
[2] = '\0';
1376 for (i
= 11; i
< 64; i
++)
1379 fcap
[1] = '1' + i
- 11;
1381 fcap
[1] = 'A' + i
- 20;
1383 fcap
[1] = 'a' + i
- 46;
1386 char *sequence
= tgetstr (fcap
, address
);
1389 sprintf (fkey
, "f%d", i
);
1390 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (sequence
),
1391 Fmake_vector (make_number (1),
1399 * Various mappings to try and get a better fit.
1402 #define CONDITIONAL_REASSIGN(cap1, cap2, sym) \
1403 if (!tgetstr (cap1, address)) \
1405 char *sequence = tgetstr (cap2, address); \
1407 Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (sequence), \
1408 Fmake_vector (make_number (1), \
1412 /* if there's no key_next keycap, map key_npage to `next' keysym */
1413 CONDITIONAL_REASSIGN ("%5", "kN", "next");
1414 /* if there's no key_prev keycap, map key_ppage to `previous' keysym */
1415 CONDITIONAL_REASSIGN ("%8", "kP", "prior");
1416 /* if there's no key_dc keycap, map key_ic to `insert' keysym */
1417 CONDITIONAL_REASSIGN ("kD", "kI", "insert");
1418 /* if there's no key_end keycap, map key_ll to 'end' keysym */
1419 CONDITIONAL_REASSIGN ("@7", "kH", "end");
1421 /* IBM has their own non-standard dialect of terminfo.
1422 If the standard name isn't found, try the IBM name. */
1423 CONDITIONAL_REASSIGN ("kB", "KO", "backtab");
1424 CONDITIONAL_REASSIGN ("@4", "kJ", "execute"); /* actually "action" */
1425 CONDITIONAL_REASSIGN ("@4", "kc", "execute"); /* actually "command" */
1426 CONDITIONAL_REASSIGN ("%7", "ki", "menu");
1427 CONDITIONAL_REASSIGN ("@7", "kw", "end");
1428 CONDITIONAL_REASSIGN ("F1", "k<", "f11");
1429 CONDITIONAL_REASSIGN ("F2", "k>", "f12");
1430 CONDITIONAL_REASSIGN ("%1", "kq", "help");
1431 CONDITIONAL_REASSIGN ("*6", "kU", "select");
1432 #undef CONDITIONAL_REASSIGN
1437 #endif /* not DOS_NT */
1440 /***********************************************************************
1441 Character Display Information
1442 ***********************************************************************/
1443 static void append_glyph (struct it
*);
1444 static void append_composite_glyph (struct it
*);
1445 static void produce_composite_glyph (struct it
*);
1446 static void append_glyphless_glyph (struct it
*, int, const char *);
1447 static void produce_glyphless_glyph (struct it
*, Lisp_Object
);
1449 /* Append glyphs to IT's glyph_row. Called from produce_glyphs for
1450 terminal frames if IT->glyph_row != NULL. IT->char_to_display is
1451 the character for which to produce glyphs; IT->face_id contains the
1452 character's face. Padding glyphs are appended if IT->c has a
1453 IT->pixel_width > 1. */
1456 append_glyph (struct it
*it
)
1458 struct glyph
*glyph
, *end
;
1461 eassert (it
->glyph_row
);
1462 glyph
= (it
->glyph_row
->glyphs
[it
->area
]
1463 + it
->glyph_row
->used
[it
->area
]);
1464 end
= it
->glyph_row
->glyphs
[1 + it
->area
];
1466 /* If the glyph row is reversed, we need to prepend the glyph rather
1468 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
1471 int move_by
= it
->pixel_width
;
1473 /* Make room for the new glyphs. */
1474 if (move_by
> end
- glyph
) /* don't overstep end of this area */
1475 move_by
= end
- glyph
;
1476 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
1478 glyph
= it
->glyph_row
->glyphs
[it
->area
];
1479 end
= glyph
+ move_by
;
1482 /* BIDI Note: we put the glyphs of a "multi-pixel" character left to
1483 right, even in the REVERSED_P case, since (a) all of its u.ch are
1484 identical, and (b) the PADDING_P flag needs to be set for the
1485 leftmost one, because we write to the terminal left-to-right. */
1487 i
< it
->pixel_width
&& glyph
< end
;
1490 glyph
->type
= CHAR_GLYPH
;
1491 glyph
->pixel_width
= 1;
1492 glyph
->u
.ch
= it
->char_to_display
;
1493 glyph
->face_id
= it
->face_id
;
1494 glyph
->padding_p
= i
> 0;
1495 glyph
->charpos
= CHARPOS (it
->position
);
1496 glyph
->object
= it
->object
;
1499 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
1500 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
1502 glyph
->bidi_type
= it
->bidi_it
.type
;
1506 glyph
->resolved_level
= 0;
1507 glyph
->bidi_type
= UNKNOWN_BT
;
1510 ++it
->glyph_row
->used
[it
->area
];
1515 /* For external use. */
1517 tty_append_glyph (struct it
*it
)
1523 /* Produce glyphs for the display element described by IT. *IT
1524 specifies what we want to produce a glyph for (character, image, ...),
1525 and where in the glyph matrix we currently are (glyph row and hpos).
1526 produce_glyphs fills in output fields of *IT with information such as the
1527 pixel width and height of a character, and maybe output actual glyphs at
1528 the same time if IT->glyph_row is non-null. For an overview, see
1529 the explanation in dispextern.h, before the definition of the
1530 display_element_type enumeration.
1532 produce_glyphs also stores the result of glyph width, ascent
1533 etc. computations in *IT.
1535 IT->glyph_row may be null, in which case produce_glyphs does not
1536 actually fill in the glyphs. This is used in the move_* functions
1537 in xdisp.c for text width and height computations.
1539 Callers usually don't call produce_glyphs directly;
1540 instead they use the macro PRODUCE_GLYPHS. */
1543 produce_glyphs (struct it
*it
)
1545 /* If a hook is installed, let it do the work. */
1547 /* Nothing but characters are supported on terminal frames. */
1548 eassert (it
->what
== IT_CHARACTER
1549 || it
->what
== IT_COMPOSITION
1550 || it
->what
== IT_STRETCH
1551 || it
->what
== IT_GLYPHLESS
);
1553 if (it
->what
== IT_STRETCH
)
1555 produce_stretch_glyph (it
);
1559 if (it
->what
== IT_COMPOSITION
)
1561 produce_composite_glyph (it
);
1565 if (it
->what
== IT_GLYPHLESS
)
1567 produce_glyphless_glyph (it
, Qnil
);
1571 if (it
->char_to_display
>= 040 && it
->char_to_display
< 0177)
1573 it
->pixel_width
= it
->nglyphs
= 1;
1577 else if (it
->char_to_display
== '\n')
1578 it
->pixel_width
= it
->nglyphs
= 0;
1579 else if (it
->char_to_display
== '\t')
1581 int absolute_x
= (it
->current_x
1582 + it
->continuation_lines_width
);
1584 = (((1 + absolute_x
+ it
->tab_width
- 1)
1589 /* If part of the TAB has been displayed on the previous line
1590 which is continued now, continuation_lines_width will have
1591 been incremented already by the part that fitted on the
1592 continued line. So, we will get the right number of spaces
1594 nspaces
= next_tab_x
- absolute_x
;
1600 it
->char_to_display
= ' ';
1601 it
->pixel_width
= it
->len
= 1;
1607 it
->pixel_width
= nspaces
;
1608 it
->nglyphs
= nspaces
;
1610 else if (CHAR_BYTE8_P (it
->char_to_display
))
1612 /* Coming here means that we must send the raw 8-bit byte as is
1613 to the terminal. Although there's no way to know how many
1614 columns it occupies on a screen, it is a good assumption that
1615 a single byte code has 1-column width. */
1616 it
->pixel_width
= it
->nglyphs
= 1;
1622 Lisp_Object charset_list
= FRAME_TERMINAL (it
->f
)->charset_list
;
1624 if (char_charset (it
->char_to_display
, charset_list
, NULL
))
1626 it
->pixel_width
= CHAR_WIDTH (it
->char_to_display
);
1627 it
->nglyphs
= it
->pixel_width
;
1633 Lisp_Object acronym
= lookup_glyphless_char_display (-1, it
);
1635 eassert (it
->what
== IT_GLYPHLESS
);
1636 produce_glyphless_glyph (it
, acronym
);
1641 /* Advance current_x by the pixel width as a convenience for
1643 if (it
->area
== TEXT_AREA
)
1644 it
->current_x
+= it
->pixel_width
;
1645 it
->ascent
= it
->max_ascent
= it
->phys_ascent
= it
->max_phys_ascent
= 0;
1646 it
->descent
= it
->max_descent
= it
->phys_descent
= it
->max_phys_descent
= 1;
1649 /* Append glyphs to IT's glyph_row for the composition IT->cmp_id.
1650 Called from produce_composite_glyph for terminal frames if
1651 IT->glyph_row != NULL. IT->face_id contains the character's
1655 append_composite_glyph (struct it
*it
)
1657 struct glyph
*glyph
;
1659 eassert (it
->glyph_row
);
1660 glyph
= it
->glyph_row
->glyphs
[it
->area
] + it
->glyph_row
->used
[it
->area
];
1661 if (glyph
< it
->glyph_row
->glyphs
[1 + it
->area
])
1663 /* If the glyph row is reversed, we need to prepend the glyph
1664 rather than append it. */
1665 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
1669 /* Make room for the new glyph. */
1670 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
1672 glyph
= it
->glyph_row
->glyphs
[it
->area
];
1674 glyph
->type
= COMPOSITE_GLYPH
;
1675 glyph
->pixel_width
= it
->pixel_width
;
1676 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
1677 if (it
->cmp_it
.ch
< 0)
1679 glyph
->u
.cmp
.automatic
= 0;
1680 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
1684 glyph
->u
.cmp
.automatic
= 1;
1685 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
1686 glyph
->slice
.cmp
.from
= it
->cmp_it
.from
;
1687 glyph
->slice
.cmp
.to
= it
->cmp_it
.to
- 1;
1690 glyph
->face_id
= it
->face_id
;
1691 glyph
->padding_p
= 0;
1692 glyph
->charpos
= CHARPOS (it
->position
);
1693 glyph
->object
= it
->object
;
1696 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
1697 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
1699 glyph
->bidi_type
= it
->bidi_it
.type
;
1703 glyph
->resolved_level
= 0;
1704 glyph
->bidi_type
= UNKNOWN_BT
;
1707 ++it
->glyph_row
->used
[it
->area
];
1713 /* Produce a composite glyph for iterator IT. IT->cmp_id is the ID of
1714 the composition. We simply produces components of the composition
1715 assuming that the terminal has a capability to layout/render it
1719 produce_composite_glyph (struct it
*it
)
1721 if (it
->cmp_it
.ch
< 0)
1723 struct composition
*cmp
= composition_table
[it
->cmp_it
.id
];
1725 it
->pixel_width
= cmp
->width
;
1729 Lisp_Object gstring
= composition_gstring_from_id (it
->cmp_it
.id
);
1731 it
->pixel_width
= composition_gstring_width (gstring
, it
->cmp_it
.from
,
1732 it
->cmp_it
.to
, NULL
);
1736 append_composite_glyph (it
);
1740 /* Append a glyph for a glyphless character to IT->glyph_row. FACE_ID
1741 is a face ID to be used for the glyph. What is actually appended
1742 are glyphs of type CHAR_GLYPH whose characters are in STR (which
1743 comes from it->nglyphs bytes). */
1746 append_glyphless_glyph (struct it
*it
, int face_id
, const char *str
)
1748 struct glyph
*glyph
, *end
;
1751 eassert (it
->glyph_row
);
1752 glyph
= it
->glyph_row
->glyphs
[it
->area
] + it
->glyph_row
->used
[it
->area
];
1753 end
= it
->glyph_row
->glyphs
[1 + it
->area
];
1755 /* If the glyph row is reversed, we need to prepend the glyph rather
1757 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
1760 int move_by
= it
->pixel_width
;
1762 /* Make room for the new glyphs. */
1763 if (move_by
> end
- glyph
) /* don't overstep end of this area */
1764 move_by
= end
- glyph
;
1765 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
1767 glyph
= it
->glyph_row
->glyphs
[it
->area
];
1768 end
= glyph
+ move_by
;
1773 glyph
->type
= CHAR_GLYPH
;
1774 glyph
->pixel_width
= 1;
1775 glyph
->face_id
= face_id
;
1776 glyph
->padding_p
= 0;
1777 glyph
->charpos
= CHARPOS (it
->position
);
1778 glyph
->object
= it
->object
;
1781 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
1782 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
1784 glyph
->bidi_type
= it
->bidi_it
.type
;
1788 glyph
->resolved_level
= 0;
1789 glyph
->bidi_type
= UNKNOWN_BT
;
1792 /* BIDI Note: we put the glyphs of characters left to right, even in
1793 the REVERSED_P case because we write to the terminal
1795 for (i
= 0; i
< it
->nglyphs
&& glyph
< end
; ++i
)
1798 glyph
[0] = glyph
[-1];
1799 glyph
->u
.ch
= str
[i
];
1800 ++it
->glyph_row
->used
[it
->area
];
1805 /* Produce glyphs for a glyphless character for iterator IT.
1806 IT->glyphless_method specifies which method to use for displaying
1807 the character. See the description of enum
1808 glyphless_display_method in dispextern.h for the details.
1810 ACRONYM, if non-nil, is an acronym string for the character.
1812 The glyphs actually produced are of type CHAR_GLYPH. */
1815 produce_glyphless_glyph (struct it
*it
, Lisp_Object acronym
)
1817 int len
, face_id
= merge_glyphless_glyph_face (it
);
1818 char buf
[sizeof "\\x" + max (6, (sizeof it
->c
* CHAR_BIT
+ 3) / 4)];
1819 char const *str
= " ";
1821 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_THIN_SPACE
)
1823 /* As there's no way to produce a thin space, we produce a space
1824 of canonical width. */
1827 else if (it
->glyphless_method
== GLYPHLESS_DISPLAY_EMPTY_BOX
)
1829 len
= CHAR_WIDTH (it
->c
);
1834 len
= sprintf (buf
, "[%.*s]", len
, str
);
1839 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_ACRONYM
)
1841 if (! STRINGP (acronym
) && CHAR_TABLE_P (Vglyphless_char_display
))
1842 acronym
= CHAR_TABLE_REF (Vglyphless_char_display
, it
->c
);
1843 if (CONSP (acronym
))
1844 acronym
= XCDR (acronym
);
1846 str
= STRINGP (acronym
) ? SSDATA (acronym
) : "";
1847 for (len
= 0; len
< 6 && str
[len
] && ASCII_BYTE_P (str
[len
]); len
++)
1848 buf
[1 + len
] = str
[len
];
1854 eassert (it
->glyphless_method
== GLYPHLESS_DISPLAY_HEX_CODE
);
1855 len
= (it
->c
< 0x10000 ? sprintf (buf
, "\\u%04X", it
->c
)
1856 : it
->c
<= MAX_UNICODE_CHAR
? sprintf (buf
, "\\U%06X", it
->c
)
1857 : sprintf (buf
, "\\x%06X", it
->c
));
1862 it
->pixel_width
= len
;
1865 append_glyphless_glyph (it
, face_id
, str
);
1869 /***********************************************************************
1871 ***********************************************************************/
1873 /* Value is non-zero if attribute ATTR may be used. ATTR should be
1874 one of the enumerators from enum no_color_bit, or a bit set built
1875 from them. Some display attributes may not be used together with
1876 color; the termcap capability `NC' specifies which ones. */
1878 #define MAY_USE_WITH_COLORS_P(tty, ATTR) \
1879 (tty->TN_max_colors > 0 \
1880 ? (tty->TN_no_color_video & (ATTR)) == 0 \
1883 /* Turn appearances of face FACE_ID on tty frame F on.
1884 FACE_ID is a realized face ID number, in the face cache. */
1887 turn_on_face (struct frame
*f
, int face_id
)
1889 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1890 long fg
= face
->foreground
;
1891 long bg
= face
->background
;
1892 struct tty_display_info
*tty
= FRAME_TTY (f
);
1894 /* Do this first because TS_end_standout_mode may be the same
1895 as TS_exit_attribute_mode, which turns all appearances off. */
1896 if (MAY_USE_WITH_COLORS_P (tty
, NC_REVERSE
))
1898 if (tty
->TN_max_colors
> 0)
1900 if (fg
>= 0 && bg
>= 0)
1902 /* If the terminal supports colors, we can set them
1903 below without using reverse video. The face's fg
1904 and bg colors are set as they should appear on
1905 the screen, i.e. they take the inverse-video'ness
1906 of the face already into account. */
1908 else if (inverse_video
)
1910 if (fg
== FACE_TTY_DEFAULT_FG_COLOR
1911 || bg
== FACE_TTY_DEFAULT_BG_COLOR
)
1912 tty_toggle_highlight (tty
);
1916 if (fg
== FACE_TTY_DEFAULT_BG_COLOR
1917 || bg
== FACE_TTY_DEFAULT_FG_COLOR
)
1918 tty_toggle_highlight (tty
);
1923 /* If we can't display colors, use reverse video
1924 if the face specifies that. */
1927 if (fg
== FACE_TTY_DEFAULT_FG_COLOR
1928 || bg
== FACE_TTY_DEFAULT_BG_COLOR
)
1929 tty_toggle_highlight (tty
);
1933 if (fg
== FACE_TTY_DEFAULT_BG_COLOR
1934 || bg
== FACE_TTY_DEFAULT_FG_COLOR
)
1935 tty_toggle_highlight (tty
);
1940 if (face
->tty_bold_p
&& MAY_USE_WITH_COLORS_P (tty
, NC_BOLD
))
1941 OUTPUT1_IF (tty
, tty
->TS_enter_bold_mode
);
1943 if (face
->tty_italic_p
&& MAY_USE_WITH_COLORS_P (tty
, NC_ITALIC
))
1945 if (tty
->TS_enter_italic_mode
)
1946 OUTPUT1 (tty
, tty
->TS_enter_italic_mode
);
1948 /* Italics mode is unavailable on many terminals. In that
1949 case, map slant to dimmed text; we want italic text to
1950 appear different and dimming is not otherwise used. */
1951 OUTPUT1 (tty
, tty
->TS_enter_dim_mode
);
1954 if (face
->tty_underline_p
&& MAY_USE_WITH_COLORS_P (tty
, NC_UNDERLINE
))
1955 OUTPUT1_IF (tty
, tty
->TS_enter_underline_mode
);
1957 if (tty
->TN_max_colors
> 0)
1962 ts
= tty
->standout_mode
? tty
->TS_set_background
: tty
->TS_set_foreground
;
1965 p
= tparam (ts
, NULL
, 0, fg
, 0, 0, 0);
1970 ts
= tty
->standout_mode
? tty
->TS_set_foreground
: tty
->TS_set_background
;
1973 p
= tparam (ts
, NULL
, 0, bg
, 0, 0, 0);
1981 /* Turn off appearances of face FACE_ID on tty frame F. */
1984 turn_off_face (struct frame
*f
, int face_id
)
1986 struct face
*face
= FACE_FROM_ID (f
, face_id
);
1987 struct tty_display_info
*tty
= FRAME_TTY (f
);
1989 eassert (face
!= NULL
);
1991 if (tty
->TS_exit_attribute_mode
)
1993 /* Capability "me" will turn off appearance modes double-bright,
1994 half-bright, reverse-video, standout, underline. It may or
1995 may not turn off alt-char-mode. */
1996 if (face
->tty_bold_p
1997 || face
->tty_italic_p
1998 || face
->tty_reverse_p
1999 || face
->tty_underline_p
)
2001 OUTPUT1_IF (tty
, tty
->TS_exit_attribute_mode
);
2002 if (strcmp (tty
->TS_exit_attribute_mode
, tty
->TS_end_standout_mode
) == 0)
2003 tty
->standout_mode
= 0;
2008 /* If we don't have "me" we can only have those appearances
2009 that have exit sequences defined. */
2010 if (face
->tty_underline_p
)
2011 OUTPUT_IF (tty
, tty
->TS_exit_underline_mode
);
2014 /* Switch back to default colors. */
2015 if (tty
->TN_max_colors
> 0
2016 && ((face
->foreground
!= FACE_TTY_DEFAULT_COLOR
2017 && face
->foreground
!= FACE_TTY_DEFAULT_FG_COLOR
)
2018 || (face
->background
!= FACE_TTY_DEFAULT_COLOR
2019 && face
->background
!= FACE_TTY_DEFAULT_BG_COLOR
)))
2020 OUTPUT1_IF (tty
, tty
->TS_orig_pair
);
2024 /* Return true if the terminal on frame F supports all of the
2025 capabilities in CAPS simultaneously, with foreground and background
2026 colors FG and BG. */
2029 tty_capable_p (struct tty_display_info
*tty
, unsigned int caps
,
2030 unsigned long fg
, unsigned long bg
)
2032 #define TTY_CAPABLE_P_TRY(tty, cap, TS, NC_bit) \
2033 if ((caps & (cap)) && (!(TS) || !MAY_USE_WITH_COLORS_P(tty, NC_bit))) \
2036 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_INVERSE
, tty
->TS_standout_mode
, NC_REVERSE
);
2037 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_UNDERLINE
, tty
->TS_enter_underline_mode
, NC_UNDERLINE
);
2038 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_BOLD
, tty
->TS_enter_bold_mode
, NC_BOLD
);
2039 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_DIM
, tty
->TS_enter_dim_mode
, NC_DIM
);
2040 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_ITALIC
, tty
->TS_enter_italic_mode
, NC_ITALIC
);
2046 /* Return non-zero if the terminal is capable to display colors. */
2048 DEFUN ("tty-display-color-p", Ftty_display_color_p
, Stty_display_color_p
,
2050 doc
: /* Return non-nil if the tty device TERMINAL can display colors.
2052 TERMINAL can be a terminal object, a frame, or nil (meaning the
2053 selected frame's terminal). This function always returns nil if
2054 TERMINAL does not refer to a text terminal. */)
2055 (Lisp_Object terminal
)
2057 struct terminal
*t
= get_tty_terminal (terminal
, 0);
2061 return t
->display_info
.tty
->TN_max_colors
> 0 ? Qt
: Qnil
;
2064 /* Return the number of supported colors. */
2065 DEFUN ("tty-display-color-cells", Ftty_display_color_cells
,
2066 Stty_display_color_cells
, 0, 1, 0,
2067 doc
: /* Return the number of colors supported by the tty device TERMINAL.
2069 TERMINAL can be a terminal object, a frame, or nil (meaning the
2070 selected frame's terminal). This function always returns 0 if
2071 TERMINAL does not refer to a text terminal. */)
2072 (Lisp_Object terminal
)
2074 struct terminal
*t
= get_tty_terminal (terminal
, 0);
2076 return make_number (0);
2078 return make_number (t
->display_info
.tty
->TN_max_colors
);
2083 /* Declare here rather than in the function, as in the rest of Emacs,
2084 to work around an HPUX compiler bug (?). See
2085 http://lists.gnu.org/archive/html/emacs-devel/2007-08/msg00410.html */
2086 static int default_max_colors
;
2087 static int default_max_pairs
;
2088 static int default_no_color_video
;
2089 static char *default_orig_pair
;
2090 static char *default_set_foreground
;
2091 static char *default_set_background
;
2093 /* Save or restore the default color-related capabilities of this
2096 tty_default_color_capabilities (struct tty_display_info
*tty
, bool save
)
2101 xfree (default_orig_pair
);
2102 default_orig_pair
= tty
->TS_orig_pair
? xstrdup (tty
->TS_orig_pair
) : NULL
;
2104 xfree (default_set_foreground
);
2105 default_set_foreground
= tty
->TS_set_foreground
? xstrdup (tty
->TS_set_foreground
)
2108 xfree (default_set_background
);
2109 default_set_background
= tty
->TS_set_background
? xstrdup (tty
->TS_set_background
)
2112 default_max_colors
= tty
->TN_max_colors
;
2113 default_max_pairs
= tty
->TN_max_pairs
;
2114 default_no_color_video
= tty
->TN_no_color_video
;
2118 tty
->TS_orig_pair
= default_orig_pair
;
2119 tty
->TS_set_foreground
= default_set_foreground
;
2120 tty
->TS_set_background
= default_set_background
;
2121 tty
->TN_max_colors
= default_max_colors
;
2122 tty
->TN_max_pairs
= default_max_pairs
;
2123 tty
->TN_no_color_video
= default_no_color_video
;
2127 /* Setup one of the standard tty color schemes according to MODE.
2128 MODE's value is generally the number of colors which we want to
2129 support; zero means set up for the default capabilities, the ones
2130 we saw at init_tty time; -1 means turn off color support. */
2132 tty_setup_colors (struct tty_display_info
*tty
, int mode
)
2134 /* Canonicalize all negative values of MODE. */
2140 case -1: /* no colors at all */
2141 tty
->TN_max_colors
= 0;
2142 tty
->TN_max_pairs
= 0;
2143 tty
->TN_no_color_video
= 0;
2144 tty
->TS_set_foreground
= tty
->TS_set_background
= tty
->TS_orig_pair
= NULL
;
2146 case 0: /* default colors, if any */
2148 tty_default_color_capabilities (tty
, 0);
2150 case 8: /* 8 standard ANSI colors */
2151 tty
->TS_orig_pair
= "\033[0m";
2153 tty
->TS_set_foreground
= "\033[3%p1%dm";
2154 tty
->TS_set_background
= "\033[4%p1%dm";
2156 tty
->TS_set_foreground
= "\033[3%dm";
2157 tty
->TS_set_background
= "\033[4%dm";
2159 tty
->TN_max_colors
= 8;
2160 tty
->TN_max_pairs
= 64;
2161 tty
->TN_no_color_video
= 0;
2167 set_tty_color_mode (struct tty_display_info
*tty
, struct frame
*f
)
2169 Lisp_Object tem
, val
;
2170 Lisp_Object color_mode
;
2172 Lisp_Object tty_color_mode_alist
2173 = Fintern_soft (build_string ("tty-color-mode-alist"), Qnil
);
2175 tem
= assq_no_quit (Qtty_color_mode
, f
->param_alist
);
2176 val
= CONSP (tem
) ? XCDR (tem
) : Qnil
;
2180 else if (SYMBOLP (tty_color_mode_alist
))
2182 tem
= Fassq (val
, Fsymbol_value (tty_color_mode_alist
));
2183 color_mode
= CONSP (tem
) ? XCDR (tem
) : Qnil
;
2188 mode
= TYPE_RANGED_INTEGERP (int, color_mode
) ? XINT (color_mode
) : 0;
2190 if (mode
!= tty
->previous_color_mode
)
2192 tty
->previous_color_mode
= mode
;
2193 tty_setup_colors (tty
, mode
);
2194 /* This recomputes all the faces given the new color definitions. */
2195 safe_call (1, intern ("tty-set-up-initial-frame-faces"));
2199 #endif /* !DOS_NT */
2203 /* Return the tty display object specified by TERMINAL. */
2205 static struct terminal
*
2206 get_tty_terminal (Lisp_Object terminal
, bool throw)
2208 struct terminal
*t
= get_terminal (terminal
, throw);
2210 if (t
&& t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
)
2213 error ("Device %d is not a termcap terminal device", t
->id
);
2221 /* Return an active termcap device that uses the tty device with the
2224 This function ignores suspended devices.
2226 Returns NULL if the named terminal device is not opened. */
2229 get_named_tty (const char *name
)
2235 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
2237 if ((t
->type
== output_termcap
|| t
->type
== output_msdos_raw
)
2238 && !strcmp (t
->display_info
.tty
->name
, name
)
2239 && TERMINAL_ACTIVE_P (t
))
2247 DEFUN ("tty-type", Ftty_type
, Stty_type
, 0, 1, 0,
2248 doc
: /* Return the type of the tty device that TERMINAL uses.
2249 Returns nil if TERMINAL is not on a tty device.
2251 TERMINAL can be a terminal object, a frame, or nil (meaning the
2252 selected frame's terminal). */)
2253 (Lisp_Object terminal
)
2255 struct terminal
*t
= get_terminal (terminal
, 1);
2257 if (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
)
2260 if (t
->display_info
.tty
->type
)
2261 return build_string (t
->display_info
.tty
->type
);
2266 DEFUN ("controlling-tty-p", Fcontrolling_tty_p
, Scontrolling_tty_p
, 0, 1, 0,
2267 doc
: /* Return non-nil if TERMINAL is the controlling tty of the Emacs process.
2269 TERMINAL can be a terminal object, a frame, or nil (meaning the
2270 selected frame's terminal). This function always returns nil if
2271 TERMINAL is not on a tty device. */)
2272 (Lisp_Object terminal
)
2274 struct terminal
*t
= get_terminal (terminal
, 1);
2276 if ((t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
)
2277 || strcmp (t
->display_info
.tty
->name
, DEV_TTY
) != 0)
2283 DEFUN ("tty-no-underline", Ftty_no_underline
, Stty_no_underline
, 0, 1, 0,
2284 doc
: /* Declare that the tty used by TERMINAL does not handle underlining.
2285 This is used to override the terminfo data, for certain terminals that
2286 do not really do underlining, but say that they do. This function has
2287 no effect if used on a non-tty terminal.
2289 TERMINAL can be a terminal object, a frame or nil (meaning the
2290 selected frame's terminal). This function always returns nil if
2291 TERMINAL does not refer to a text terminal. */)
2292 (Lisp_Object terminal
)
2294 struct terminal
*t
= get_terminal (terminal
, 1);
2296 if (t
->type
== output_termcap
)
2297 t
->display_info
.tty
->TS_enter_underline_mode
= 0;
2301 DEFUN ("tty-top-frame", Ftty_top_frame
, Stty_top_frame
, 0, 1, 0,
2302 doc
: /* Return the topmost terminal frame on TERMINAL.
2303 TERMINAL can be a terminal object, a frame or nil (meaning the
2304 selected frame's terminal). This function returns nil if TERMINAL
2305 does not refer to a text terminal. Otherwise, it returns the
2306 top-most frame on the text terminal. */)
2307 (Lisp_Object terminal
)
2309 struct terminal
*t
= get_terminal (terminal
, 1);
2311 if (t
->type
== output_termcap
)
2312 return t
->display_info
.tty
->top_frame
;
2318 DEFUN ("suspend-tty", Fsuspend_tty
, Ssuspend_tty
, 0, 1, 0,
2319 doc
: /* Suspend the terminal device TTY.
2321 The device is restored to its default state, and Emacs ceases all
2322 access to the tty device. Frames that use the device are not deleted,
2323 but input is not read from them and if they change, their display is
2326 TTY may be a terminal object, a frame, or nil for the terminal device
2327 of the currently selected frame.
2329 This function runs `suspend-tty-functions' after suspending the
2330 device. The functions are run with one arg, the id of the suspended
2333 `suspend-tty' does nothing if it is called on a device that is already
2336 A suspended tty may be resumed by calling `resume-tty' on it. */)
2339 struct terminal
*t
= get_tty_terminal (tty
, 1);
2343 error ("Unknown tty device");
2345 f
= t
->display_info
.tty
->input
;
2349 /* First run `suspend-tty-functions' and then clean up the tty
2350 state because `suspend-tty-functions' might need to change
2352 Lisp_Object args
[2];
2353 args
[0] = intern ("suspend-tty-functions");
2354 XSETTERMINAL (args
[1], t
);
2355 Frun_hook_with_args (2, args
);
2357 reset_sys_modes (t
->display_info
.tty
);
2358 delete_keyboard_wait_descriptor (fileno (f
));
2362 if (f
!= t
->display_info
.tty
->output
)
2363 fclose (t
->display_info
.tty
->output
);
2366 t
->display_info
.tty
->input
= 0;
2367 t
->display_info
.tty
->output
= 0;
2369 if (FRAMEP (t
->display_info
.tty
->top_frame
))
2370 SET_FRAME_VISIBLE (XFRAME (t
->display_info
.tty
->top_frame
), 0);
2374 /* Clear display hooks to prevent further output. */
2375 clear_tty_hooks (t
);
2380 DEFUN ("resume-tty", Fresume_tty
, Sresume_tty
, 0, 1, 0,
2381 doc
: /* Resume the previously suspended terminal device TTY.
2382 The terminal is opened and reinitialized. Frames that are on the
2383 suspended terminal are revived.
2385 It is an error to resume a terminal while another terminal is active
2388 This function runs `resume-tty-functions' after resuming the terminal.
2389 The functions are run with one arg, the id of the resumed terminal
2392 `resume-tty' does nothing if it is called on a device that is not
2395 TTY may be a terminal object, a frame, or nil (meaning the selected
2396 frame's terminal). */)
2399 struct terminal
*t
= get_tty_terminal (tty
, 1);
2403 error ("Unknown tty device");
2405 if (!t
->display_info
.tty
->input
)
2407 if (get_named_tty (t
->display_info
.tty
->name
))
2408 error ("Cannot resume display while another display is active on the same device");
2411 t
->display_info
.tty
->output
= stdout
;
2412 t
->display_info
.tty
->input
= stdin
;
2414 fd
= emacs_open (t
->display_info
.tty
->name
, O_RDWR
| O_NOCTTY
, 0);
2415 t
->display_info
.tty
->input
= t
->display_info
.tty
->output
2416 = fd
< 0 ? 0 : fdopen (fd
, "w+");
2418 if (! t
->display_info
.tty
->input
)
2420 int open_errno
= errno
;
2422 report_file_errno ("Cannot reopen tty device",
2423 build_string (t
->display_info
.tty
->name
),
2427 if (!O_IGNORE_CTTY
&& strcmp (t
->display_info
.tty
->name
, DEV_TTY
) != 0)
2428 dissociate_if_controlling_tty (fd
);
2431 add_keyboard_wait_descriptor (fd
);
2433 if (FRAMEP (t
->display_info
.tty
->top_frame
))
2435 struct frame
*f
= XFRAME (t
->display_info
.tty
->top_frame
);
2437 int old_height
= FRAME_COLS (f
);
2438 int old_width
= FRAME_LINES (f
);
2440 /* Check if terminal/window size has changed while the frame
2442 get_tty_size (fileno (t
->display_info
.tty
->input
), &width
, &height
);
2443 if (width
!= old_width
|| height
!= old_height
)
2444 change_frame_size (f
, height
, width
, 0, 0, 0);
2445 SET_FRAME_VISIBLE (XFRAME (t
->display_info
.tty
->top_frame
), 1);
2449 init_sys_modes (t
->display_info
.tty
);
2452 /* Run `resume-tty-functions'. */
2453 Lisp_Object args
[2];
2454 args
[0] = intern ("resume-tty-functions");
2455 XSETTERMINAL (args
[1], t
);
2456 Frun_hook_with_args (2, args
);
2466 /***********************************************************************
2468 ***********************************************************************/
2472 #ifndef HAVE_WINDOW_SYSTEM
2474 term_mouse_moveto (int x
, int y
)
2476 /* TODO: how to set mouse position?
2479 name = (const char *) ttyname (0);
2480 fd = emacs_open (name, O_WRONLY, 0);
2481 SOME_FUNCTION (x, y, fd);
2484 last_mouse_y = y; */
2486 #endif /* HAVE_WINDOW_SYSTEM */
2488 /* Implementation of draw_row_with_mouse_face for TTY/GPM. */
2490 tty_draw_row_with_mouse_face (struct window
*w
, struct glyph_row
*row
,
2491 int start_hpos
, int end_hpos
,
2492 enum draw_glyphs_face draw
)
2494 int nglyphs
= end_hpos
- start_hpos
;
2495 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2496 struct tty_display_info
*tty
= FRAME_TTY (f
);
2497 int face_id
= tty
->mouse_highlight
.mouse_face_face_id
;
2498 int save_x
, save_y
, pos_x
, pos_y
;
2500 if (end_hpos
>= row
->used
[TEXT_AREA
])
2501 nglyphs
= row
->used
[TEXT_AREA
] - start_hpos
;
2503 pos_y
= row
->y
+ WINDOW_TOP_EDGE_Y (w
);
2504 pos_x
= row
->used
[LEFT_MARGIN_AREA
] + start_hpos
+ WINDOW_LEFT_EDGE_X (w
);
2506 /* Save current cursor co-ordinates. */
2507 save_y
= curY (tty
);
2508 save_x
= curX (tty
);
2509 cursor_to (f
, pos_y
, pos_x
);
2511 if (draw
== DRAW_MOUSE_FACE
)
2512 tty_write_glyphs_with_face (f
, row
->glyphs
[TEXT_AREA
] + start_hpos
,
2514 else if (draw
== DRAW_NORMAL_TEXT
)
2515 write_glyphs (f
, row
->glyphs
[TEXT_AREA
] + start_hpos
, nglyphs
);
2517 cursor_to (f
, save_y
, save_x
);
2521 term_mouse_movement (struct frame
*frame
, Gpm_Event
*event
)
2523 /* Has the mouse moved off the glyph it was on at the last sighting? */
2524 if (event
->x
!= last_mouse_x
|| event
->y
!= last_mouse_y
)
2526 frame
->mouse_moved
= 1;
2527 note_mouse_highlight (frame
, event
->x
, event
->y
);
2528 /* Remember which glyph we're now on. */
2529 last_mouse_x
= event
->x
;
2530 last_mouse_y
= event
->y
;
2536 /* Return the Time that corresponds to T. Wrap around on overflow. */
2538 timeval_to_Time (struct timeval
const *t
)
2544 ms
= t
->tv_usec
/ 1000;
2548 /* Return the current position of the mouse.
2550 Set *f to the frame the mouse is in, or zero if the mouse is in no
2551 Emacs frame. If it is set to zero, all the other arguments are
2554 Set *bar_window to Qnil, and *x and *y to the column and
2555 row of the character cell the mouse is over.
2557 Set *timeptr to the time the mouse was at the returned position.
2559 This clears mouse_moved until the next motion
2562 term_mouse_position (struct frame
**fp
, int insist
, Lisp_Object
*bar_window
,
2563 enum scroll_bar_part
*part
, Lisp_Object
*x
,
2564 Lisp_Object
*y
, Time
*timeptr
)
2568 *fp
= SELECTED_FRAME ();
2569 (*fp
)->mouse_moved
= 0;
2574 XSETINT (*x
, last_mouse_x
);
2575 XSETINT (*y
, last_mouse_y
);
2576 gettimeofday(&now
, 0);
2577 *timeptr
= timeval_to_Time (&now
);
2580 /* Prepare a mouse-event in *RESULT for placement in the input queue.
2582 If the event is a button press, then note that we have grabbed
2586 term_mouse_click (struct input_event
*result
, Gpm_Event
*event
,
2592 result
->kind
= GPM_CLICK_EVENT
;
2593 for (i
= 0, j
= GPM_B_LEFT
; i
< 3; i
++, j
>>= 1 )
2595 if (event
->buttons
& j
) {
2596 result
->code
= i
; /* button number */
2600 gettimeofday(&now
, 0);
2601 result
->timestamp
= timeval_to_Time (&now
);
2603 if (event
->type
& GPM_UP
)
2604 result
->modifiers
= up_modifier
;
2605 else if (event
->type
& GPM_DOWN
)
2606 result
->modifiers
= down_modifier
;
2608 result
->modifiers
= 0;
2610 if (event
->type
& GPM_SINGLE
)
2611 result
->modifiers
|= click_modifier
;
2613 if (event
->type
& GPM_DOUBLE
)
2614 result
->modifiers
|= double_modifier
;
2616 if (event
->type
& GPM_TRIPLE
)
2617 result
->modifiers
|= triple_modifier
;
2619 if (event
->type
& GPM_DRAG
)
2620 result
->modifiers
|= drag_modifier
;
2622 if (!(event
->type
& (GPM_MOVE
| GPM_DRAG
))) {
2625 if (event
->modifiers
& (1 << 0))
2626 result
->modifiers
|= shift_modifier
;
2629 if (event
->modifiers
& (1 << 2))
2630 result
->modifiers
|= ctrl_modifier
;
2632 /* 1 << KG_ALT || KG_ALTGR */
2633 if (event
->modifiers
& (1 << 3)
2634 || event
->modifiers
& (1 << 1))
2635 result
->modifiers
|= meta_modifier
;
2638 XSETINT (result
->x
, event
->x
);
2639 XSETINT (result
->y
, event
->y
);
2640 XSETFRAME (result
->frame_or_window
, f
);
2646 handle_one_term_event (struct tty_display_info
*tty
, Gpm_Event
*event
, struct input_event
* hold_quit
)
2648 struct frame
*f
= XFRAME (tty
->top_frame
);
2649 struct input_event ie
;
2657 if (event
->type
& (GPM_MOVE
| GPM_DRAG
)) {
2658 previous_help_echo_string
= help_echo_string
;
2659 help_echo_string
= Qnil
;
2661 Gpm_DrawPointer (event
->x
, event
->y
, fileno (tty
->output
));
2663 if (!term_mouse_movement (f
, event
))
2664 help_echo_string
= previous_help_echo_string
;
2666 /* If the contents of the global variable help_echo_string
2667 has changed, generate a HELP_EVENT. */
2668 if (!NILP (help_echo_string
)
2669 || !NILP (previous_help_echo_string
))
2676 term_mouse_click (&ie
, event
, f
);
2680 if (ie
.kind
!= NO_EVENT
)
2682 kbd_buffer_store_event_hold (&ie
, hold_quit
);
2687 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
2692 XSETFRAME (frame
, f
);
2696 gen_help_event (help_echo_string
, frame
, help_echo_window
,
2697 help_echo_object
, help_echo_pos
);
2704 DEFUN ("gpm-mouse-start", Fgpm_mouse_start
, Sgpm_mouse_start
,
2706 doc
: /* Open a connection to Gpm.
2707 Gpm-mouse can only be activated for one tty at a time. */)
2710 struct frame
*f
= SELECTED_FRAME ();
2711 struct tty_display_info
*tty
2712 = ((f
)->output_method
== output_termcap
2713 ? (f
)->terminal
->display_info
.tty
: NULL
);
2714 Gpm_Connect connection
;
2717 error ("Gpm-mouse only works in the GNU/Linux console");
2719 return Qnil
; /* Already activated, nothing to do. */
2721 error ("Gpm-mouse can only be activated for one tty at a time");
2723 connection
.eventMask
= ~0;
2724 connection
.defaultMask
= ~GPM_HARD
;
2725 connection
.maxMod
= ~0;
2726 connection
.minMod
= 0;
2729 if (Gpm_Open (&connection
, 0) < 0)
2730 error ("Gpm-mouse failed to connect to the gpm daemon");
2734 /* `init_sys_modes' arranges for mouse movements sent through gpm_fd
2735 to generate SIGIOs. Apparently we need to call reset_sys_modes
2736 before calling init_sys_modes. */
2737 reset_sys_modes (tty
);
2738 init_sys_modes (tty
);
2739 add_gpm_wait_descriptor (gpm_fd
);
2748 delete_gpm_wait_descriptor (fd
);
2749 while (Gpm_Close()); /* close all the stack */
2753 DEFUN ("gpm-mouse-stop", Fgpm_mouse_stop
, Sgpm_mouse_stop
,
2755 doc
: /* Close a connection to Gpm. */)
2758 struct frame
*f
= SELECTED_FRAME ();
2759 struct tty_display_info
*tty
2760 = ((f
)->output_method
== output_termcap
2761 ? (f
)->terminal
->display_info
.tty
: NULL
);
2763 if (!tty
|| gpm_tty
!= tty
)
2764 return Qnil
; /* Not activated on this terminal, nothing to do. */
2769 #endif /* HAVE_GPM */
2772 /***********************************************************************
2774 ***********************************************************************/
2776 #if defined (HAVE_MENUS) && !defined (MSDOS)
2778 /* TTY menu implementation and main ideas are borrowed from msdos.c.
2780 However, unlike on MSDOS, where the menu text is drawn directly to
2781 the display video memory, on a TTY we use display_string (see
2782 display_tty_menu_item in xdisp.c) to put the glyphs produced from
2783 the menu items directly into the frame's 'desired_matrix' glyph
2784 matrix, and then call update_frame_with_menu to deliver the results
2785 to the glass. The previous contents of the screen, in the form of
2786 the current_matrix, is stashed away, and used to restore screen
2787 contents when the menu selection changes or when the final
2788 selection is made and the menu should be popped down.
2790 The idea of this implementation was suggested by Gerd Moellmann. */
2792 #define TTYM_FAILURE -1
2793 #define TTYM_SUCCESS 1
2794 #define TTYM_NO_SELECT 2
2795 #define TTYM_IA_SELECT 3
2799 /* These hold text of the current and the previous menu help messages. */
2800 static const char *menu_help_message
, *prev_menu_help_message
;
2801 /* Pane number and item number of the menu item which generated the
2802 last menu help message. */
2803 static int menu_help_paneno
, menu_help_itemno
;
2805 static Lisp_Object Qtty_menu_navigation_map
, Qtty_menu_exit
;
2806 static Lisp_Object Qtty_menu_prev_item
, Qtty_menu_next_item
;
2807 static Lisp_Object Qtty_menu_next_menu
, Qtty_menu_prev_menu
;
2808 static Lisp_Object Qtty_menu_select
, Qtty_menu_ignore
;
2809 static Lisp_Object Qtty_menu_mouse_movement
;
2811 typedef struct tty_menu_struct
2815 struct tty_menu_struct
**submenu
;
2816 int *panenumber
; /* Also used as enabled flag. */
2820 const char **help_text
;
2823 /* Create a brand new menu structure. */
2826 tty_menu_create (void)
2830 menu
= (tty_menu
*) xmalloc (sizeof (tty_menu
));
2831 menu
->allocated
= menu
->count
= menu
->panecount
= menu
->width
= 0;
2835 /* Allocate some (more) memory for MENU ensuring that there is room for one
2839 tty_menu_make_room (tty_menu
*menu
)
2841 if (menu
->allocated
== 0)
2843 int count
= menu
->allocated
= 10;
2844 menu
->text
= (char **) xmalloc (count
* sizeof (char *));
2845 menu
->submenu
= (tty_menu
**) xmalloc (count
* sizeof (tty_menu
*));
2846 menu
->panenumber
= (int *) xmalloc (count
* sizeof (int));
2847 menu
->help_text
= (const char **) xmalloc (count
* sizeof (char *));
2849 else if (menu
->allocated
== menu
->count
)
2851 int count
= menu
->allocated
= menu
->allocated
+ 10;
2853 = (char **) xrealloc (menu
->text
, count
* sizeof (char *));
2855 = (tty_menu
**) xrealloc (menu
->submenu
, count
* sizeof (tty_menu
*));
2857 = (int *) xrealloc (menu
->panenumber
, count
* sizeof (int));
2859 = (const char **) xrealloc (menu
->help_text
, count
* sizeof (char *));
2863 /* Search the given menu structure for a given pane number. */
2866 tty_menu_search_pane (tty_menu
*menu
, int pane
)
2871 for (i
= 0; i
< menu
->count
; i
++)
2872 if (menu
->submenu
[i
])
2874 if (pane
== menu
->panenumber
[i
])
2875 return menu
->submenu
[i
];
2876 if ((try = tty_menu_search_pane (menu
->submenu
[i
], pane
)))
2879 return (tty_menu
*) 0;
2882 /* Determine how much screen space a given menu needs. */
2885 tty_menu_calc_size (tty_menu
*menu
, int *width
, int *height
)
2887 int i
, h2
, w2
, maxsubwidth
, maxheight
;
2889 maxsubwidth
= menu
->width
;
2890 maxheight
= menu
->count
;
2891 for (i
= 0; i
< menu
->count
; i
++)
2893 if (menu
->submenu
[i
])
2895 tty_menu_calc_size (menu
->submenu
[i
], &w2
, &h2
);
2896 if (w2
> maxsubwidth
) maxsubwidth
= w2
;
2897 if (i
+ h2
> maxheight
) maxheight
= i
+ h2
;
2900 *width
= maxsubwidth
;
2901 *height
= maxheight
;
2905 mouse_get_xy (int *x
, int *y
)
2907 struct frame
*sf
= SELECTED_FRAME ();
2908 Lisp_Object lmx
= Qnil
, lmy
= Qnil
, lisp_dummy
;
2909 enum scroll_bar_part part_dummy
;
2912 if (FRAME_TERMINAL (sf
)->mouse_position_hook
)
2913 (*FRAME_TERMINAL (sf
)->mouse_position_hook
) (&sf
, -1,
2914 &lisp_dummy
, &part_dummy
,
2924 /* Display MENU at (X,Y) using FACES. */
2927 tty_menu_display (tty_menu
*menu
, int x
, int y
, int pn
, int *faces
,
2928 int mx
, int my
, int disp_help
)
2930 int i
, face
, width
, enabled
, mousehere
, row
, col
;
2931 struct frame
*sf
= SELECTED_FRAME ();
2932 struct tty_display_info
*tty
= FRAME_TTY (sf
);
2934 menu_help_message
= NULL
;
2936 width
= menu
->width
;
2937 col
= cursorX (tty
);
2938 row
= cursorY (tty
);
2939 for (i
= 0; i
< menu
->count
; i
++)
2941 int max_width
= width
+ 2; /* +2 for padding blanks on each side */
2943 cursor_to (sf
, y
+ i
, x
);
2944 if (menu
->submenu
[i
])
2945 max_width
+= 2; /* for displaying " >" after the item */
2947 = (!menu
->submenu
[i
] && menu
->panenumber
[i
]) || (menu
->submenu
[i
]);
2948 mousehere
= (y
+ i
== my
&& x
<= mx
&& mx
< x
+ max_width
);
2949 face
= faces
[enabled
+ mousehere
* 2];
2950 /* Display the menu help string for the i-th menu item even if
2951 the menu item is currently disabled. That's what the GUI
2953 if (disp_help
&& enabled
+ mousehere
* 2 >= 2)
2955 menu_help_message
= menu
->help_text
[i
];
2956 menu_help_paneno
= pn
- 1;
2957 menu_help_itemno
= i
;
2959 display_tty_menu_item (menu
->text
[i
], max_width
, face
, x
, y
+ i
,
2960 menu
->submenu
[i
] != NULL
);
2962 update_frame_with_menu (sf
);
2963 cursor_to (sf
, row
, col
);
2966 /* --------------------------- X Menu emulation ---------------------- */
2968 /* Report availability of menus. */
2971 have_menus_p (void) { return 1; }
2973 /* Create a new pane and place it on the outer-most level. */
2976 tty_menu_add_pane (tty_menu
*menu
, const char *txt
)
2981 tty_menu_make_room (menu
);
2982 menu
->submenu
[menu
->count
] = tty_menu_create ();
2983 menu
->text
[menu
->count
] = (char *)txt
;
2984 menu
->panenumber
[menu
->count
] = ++menu
->panecount
;
2985 menu
->help_text
[menu
->count
] = NULL
;
2988 /* Update the menu width, if necessary. */
2989 for (len
= 0, p
= txt
; *p
; )
2992 int ch
= STRING_CHAR_AND_LENGTH (p
, ch_len
);
2994 len
+= CHAR_WIDTH (ch
);
2998 if (len
> menu
->width
)
3001 return menu
->panecount
;
3004 /* Create a new item in a menu pane. */
3007 tty_menu_add_selection (tty_menu
*menu
, int pane
,
3008 char *txt
, int enable
, char const *help_text
)
3014 if (!(menu
= tty_menu_search_pane (menu
, pane
)))
3015 return TTYM_FAILURE
;
3016 tty_menu_make_room (menu
);
3017 menu
->submenu
[menu
->count
] = (tty_menu
*) 0;
3018 menu
->text
[menu
->count
] = txt
;
3019 menu
->panenumber
[menu
->count
] = enable
;
3020 menu
->help_text
[menu
->count
] = help_text
;
3023 /* Update the menu width, if necessary. */
3024 for (len
= 0, p
= txt
; *p
; )
3027 int ch
= STRING_CHAR_AND_LENGTH (p
, ch_len
);
3029 len
+= CHAR_WIDTH (ch
);
3033 if (len
> menu
->width
)
3036 return TTYM_SUCCESS
;
3039 /* Decide where the menu would be placed if requested at (X,Y). */
3042 tty_menu_locate (tty_menu
*menu
, int x
, int y
,
3043 int *ulx
, int *uly
, int *width
, int *height
)
3045 tty_menu_calc_size (menu
, width
, height
);
3051 struct tty_menu_state
3053 struct glyph_matrix
*screen_behind
;
3059 /* Save away the contents of frame F's current frame matrix, and
3060 enable all its rows. Value is a glyph matrix holding the contents
3061 of F's current frame matrix with all its glyph rows enabled. */
3063 static struct glyph_matrix
*
3064 save_and_enable_current_matrix (struct frame
*f
)
3067 struct glyph_matrix
*saved
= xzalloc (sizeof *saved
);
3068 saved
->nrows
= f
->current_matrix
->nrows
;
3069 saved
->rows
= xzalloc (saved
->nrows
* sizeof *saved
->rows
);
3071 for (i
= 0; i
< saved
->nrows
; ++i
)
3073 struct glyph_row
*from
= f
->current_matrix
->rows
+ i
;
3074 struct glyph_row
*to
= saved
->rows
+ i
;
3075 ptrdiff_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
3077 to
->glyphs
[TEXT_AREA
] = xmalloc (nbytes
);
3078 memcpy (to
->glyphs
[TEXT_AREA
], from
->glyphs
[TEXT_AREA
], nbytes
);
3079 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
3080 /* Make sure every row is enabled, or else update_frame will not
3081 redraw them. (Rows that are identical to what is already on
3082 screen will not be redrawn anyway.) */
3084 to
->hash
= from
->hash
;
3085 if (from
->used
[LEFT_MARGIN_AREA
])
3087 nbytes
= from
->used
[LEFT_MARGIN_AREA
] * sizeof (struct glyph
);
3088 to
->glyphs
[LEFT_MARGIN_AREA
] = (struct glyph
*) xmalloc (nbytes
);
3089 memcpy (to
->glyphs
[LEFT_MARGIN_AREA
],
3090 from
->glyphs
[LEFT_MARGIN_AREA
], nbytes
);
3091 to
->used
[LEFT_MARGIN_AREA
] = from
->used
[LEFT_MARGIN_AREA
];
3093 if (from
->used
[RIGHT_MARGIN_AREA
])
3095 nbytes
= from
->used
[RIGHT_MARGIN_AREA
] * sizeof (struct glyph
);
3096 to
->glyphs
[RIGHT_MARGIN_AREA
] = (struct glyph
*) xmalloc (nbytes
);
3097 memcpy (to
->glyphs
[RIGHT_MARGIN_AREA
],
3098 from
->glyphs
[RIGHT_MARGIN_AREA
], nbytes
);
3099 to
->used
[RIGHT_MARGIN_AREA
] = from
->used
[RIGHT_MARGIN_AREA
];
3106 /* Restore the contents of frame F's desired frame matrix from SAVED,
3107 and free memory associated with SAVED. */
3110 restore_desired_matrix (struct frame
*f
, struct glyph_matrix
*saved
)
3114 for (i
= 0; i
< saved
->nrows
; ++i
)
3116 struct glyph_row
*from
= saved
->rows
+ i
;
3117 struct glyph_row
*to
= f
->desired_matrix
->rows
+ i
;
3118 ptrdiff_t nbytes
= from
->used
[TEXT_AREA
] * sizeof (struct glyph
);
3120 eassert (to
->glyphs
[TEXT_AREA
] != from
->glyphs
[TEXT_AREA
]);
3121 memcpy (to
->glyphs
[TEXT_AREA
], from
->glyphs
[TEXT_AREA
], nbytes
);
3122 to
->used
[TEXT_AREA
] = from
->used
[TEXT_AREA
];
3123 to
->enabled_p
= from
->enabled_p
;
3124 to
->hash
= from
->hash
;
3125 nbytes
= from
->used
[LEFT_MARGIN_AREA
] * sizeof (struct glyph
);
3128 eassert (to
->glyphs
[LEFT_MARGIN_AREA
] != from
->glyphs
[LEFT_MARGIN_AREA
]);
3129 memcpy (to
->glyphs
[LEFT_MARGIN_AREA
],
3130 from
->glyphs
[LEFT_MARGIN_AREA
], nbytes
);
3131 to
->used
[LEFT_MARGIN_AREA
] = from
->used
[LEFT_MARGIN_AREA
];
3134 to
->used
[LEFT_MARGIN_AREA
] = 0;
3135 nbytes
= from
->used
[RIGHT_MARGIN_AREA
] * sizeof (struct glyph
);
3138 eassert (to
->glyphs
[RIGHT_MARGIN_AREA
] != from
->glyphs
[RIGHT_MARGIN_AREA
]);
3139 memcpy (to
->glyphs
[RIGHT_MARGIN_AREA
],
3140 from
->glyphs
[RIGHT_MARGIN_AREA
], nbytes
);
3141 to
->used
[RIGHT_MARGIN_AREA
] = from
->used
[RIGHT_MARGIN_AREA
];
3144 to
->used
[RIGHT_MARGIN_AREA
] = 0;
3149 free_saved_screen (struct glyph_matrix
*saved
)
3154 return; /* already freed */
3156 for (i
= 0; i
< saved
->nrows
; ++i
)
3158 struct glyph_row
*from
= saved
->rows
+ i
;
3160 xfree (from
->glyphs
[TEXT_AREA
]);
3161 if (from
->used
[LEFT_MARGIN_AREA
])
3162 xfree (from
->glyphs
[LEFT_MARGIN_AREA
]);
3163 if (from
->used
[RIGHT_MARGIN_AREA
])
3164 xfree (from
->glyphs
[RIGHT_MARGIN_AREA
]);
3167 xfree (saved
->rows
);
3171 /* Update the display of frame F from its saved contents. */
3173 screen_update (struct frame
*f
, struct glyph_matrix
*mtx
)
3175 restore_desired_matrix (f
, mtx
);
3176 update_frame_with_menu (f
);
3179 /* Read user input and return X and Y coordinates where that input
3180 puts us. We only consider mouse movement and click events and
3181 keyboard movement commands; the rest are ignored.
3183 Value is -1 if C-g was pressed, 1 if an item was selected, 2 or 3
3184 if we need to move to the next or previous menu-bar menu, zero
3187 read_menu_input (struct frame
*sf
, int *x
, int *y
, int min_y
, int max_y
,
3192 *first_time
= false;
3193 sf
->mouse_moved
= 1;
3197 extern Lisp_Object
read_menu_command (void);
3199 int usable_input
= 1;
3201 struct tty_display_info
*tty
= FRAME_TTY (sf
);
3202 Lisp_Object saved_mouse_tracking
= do_mouse_tracking
;
3204 /* Signal the keyboard reading routines we are displaying a menu
3205 on this terminal. */
3206 tty
->showing_menu
= 1;
3207 /* We want mouse movements be reported by read_menu_command. */
3208 do_mouse_tracking
= Qt
;
3210 cmd
= read_menu_command ();
3211 } while (NILP (cmd
));
3212 tty
->showing_menu
= 0;
3213 do_mouse_tracking
= saved_mouse_tracking
;
3215 if (EQ (cmd
, Qt
) || EQ (cmd
, Qtty_menu_exit
))
3217 if (EQ (cmd
, Qtty_menu_mouse_movement
))
3221 mouse_get_xy (&mx
, &my
);
3225 else if (EQ (cmd
, Qtty_menu_next_menu
))
3230 else if (EQ (cmd
, Qtty_menu_prev_menu
))
3235 else if (EQ (cmd
, Qtty_menu_next_item
))
3240 else if (EQ (cmd
, Qtty_menu_prev_item
))
3245 else if (EQ (cmd
, Qtty_menu_select
))
3247 else if (!EQ (cmd
, Qtty_menu_ignore
))
3250 sf
->mouse_moved
= 1;
3256 /* Display menu, wait for user's response, and return that response. */
3258 tty_menu_activate (tty_menu
*menu
, int *pane
, int *selidx
,
3259 int x0
, int y0
, char **txt
,
3260 void (*help_callback
)(char const *, int, int),
3263 struct tty_menu_state
*state
;
3264 int statecount
, x
, y
, i
, b
, leave
, result
, onepane
;
3265 int title_faces
[4]; /* face to display the menu title */
3266 int faces
[4], buffers_num_deleted
= 0;
3267 struct frame
*sf
= SELECTED_FRAME ();
3268 struct tty_display_info
*tty
= FRAME_TTY (sf
);
3270 Lisp_Object saved_echo_area_message
, selectface
;
3272 /* Don't allow non-positive x0 and y0, lest the menu will wrap
3273 around the display. */
3279 state
= alloca (menu
->panecount
* sizeof (struct tty_menu_state
));
3280 memset (state
, 0, sizeof (*state
));
3282 = lookup_derived_face (sf
, intern ("tty-menu-disabled-face"),
3283 DEFAULT_FACE_ID
, 1);
3285 = lookup_derived_face (sf
, intern ("tty-menu-enabled-face"),
3286 DEFAULT_FACE_ID
, 1);
3287 selectface
= intern ("tty-menu-selected-face");
3288 faces
[2] = lookup_derived_face (sf
, selectface
,
3290 faces
[3] = lookup_derived_face (sf
, selectface
,
3293 /* Make sure the menu title is always displayed with
3294 `tty-menu-selected-face', no matter where the mouse pointer is. */
3295 for (i
= 0; i
< 4; i
++)
3296 title_faces
[i
] = faces
[3];
3300 /* Don't let the title for the "Buffers" popup menu include a
3301 digit (which is ugly).
3303 This is a terrible kludge, but I think the "Buffers" case is
3304 the only one where the title includes a number, so it doesn't
3305 seem to be necessary to make this more general. */
3306 if (strncmp (menu
->text
[0], "Buffers 1", 9) == 0)
3308 menu
->text
[0][7] = '\0';
3309 buffers_num_deleted
= 1;
3312 /* Force update of the current frame, so that the desired and the
3313 current matrices are identical. */
3314 update_frame_with_menu (sf
);
3315 state
[0].menu
= menu
;
3316 state
[0].screen_behind
= save_and_enable_current_matrix (sf
);
3318 /* Display the menu title. We subtract 1 from x0 and y0 because we
3319 want to interpret them as zero-based column and row coordinates,
3320 and also because we want the first item of the menu, not its
3321 title, to appear at x0,y0. */
3322 tty_menu_display (menu
, x0
- 1, y0
- 1, 1, title_faces
, x0
- 1, y0
- 1, 0);
3324 /* Turn off the cursor. Otherwise it shows through the menu
3325 panes, which is ugly. */
3326 tty_hide_cursor (tty
);
3327 if (buffers_num_deleted
)
3328 menu
->text
[0][7] = ' ';
3329 if ((onepane
= menu
->count
== 1 && menu
->submenu
[0]))
3331 menu
->width
= menu
->submenu
[0]->width
;
3332 state
[0].menu
= menu
->submenu
[0];
3336 state
[0].menu
= menu
;
3338 state
[0].x
= x0
- 1;
3340 state
[0].pane
= onepane
;
3350 int min_y
= state
[0].y
, max_y
= min_y
+ state
[0].menu
->count
- 1;
3352 input_status
= read_menu_input (sf
, &x
, &y
, min_y
, max_y
, &first_time
);
3356 if (input_status
== -1)
3358 /* Remove the last help-echo, so that it doesn't
3359 re-appear after "Quit". */
3360 show_help_echo (Qnil
, Qnil
, Qnil
, Qnil
);
3361 result
= TTYM_NO_SELECT
;
3363 else if (input_status
== 2)
3370 else if (input_status
== 3)
3378 if (sf
->mouse_moved
&& input_status
!= -1)
3380 sf
->mouse_moved
= 0;
3381 result
= TTYM_IA_SELECT
;
3382 for (i
= 0; i
< statecount
; i
++)
3383 if (state
[i
].x
<= x
&& x
< state
[i
].x
+ state
[i
].menu
->width
+ 2)
3385 int dy
= y
- state
[i
].y
;
3386 if (0 <= dy
&& dy
< state
[i
].menu
->count
)
3388 if (!state
[i
].menu
->submenu
[dy
])
3390 if (state
[i
].menu
->panenumber
[dy
])
3391 result
= TTYM_SUCCESS
;
3393 result
= TTYM_IA_SELECT
;
3395 *pane
= state
[i
].pane
- 1;
3397 /* We hit some part of a menu, so drop extra menus that
3398 have been opened. That does not include an open and
3400 if (i
!= statecount
- 2
3401 || state
[i
].menu
->submenu
[dy
] != state
[i
+1].menu
)
3402 while (i
!= statecount
- 1)
3405 screen_update (sf
, state
[statecount
].screen_behind
);
3406 state
[statecount
].screen_behind
= NULL
;
3408 if (i
== statecount
- 1 && state
[i
].menu
->submenu
[dy
])
3410 tty_menu_display (state
[i
].menu
,
3415 state
[statecount
].menu
= state
[i
].menu
->submenu
[dy
];
3416 state
[statecount
].pane
= state
[i
].menu
->panenumber
[dy
];
3417 state
[statecount
].screen_behind
3418 = save_and_enable_current_matrix (sf
);
3420 = state
[i
].x
+ state
[i
].menu
->width
+ 2;
3421 state
[statecount
].y
= y
;
3426 tty_menu_display (state
[statecount
- 1].menu
,
3427 state
[statecount
- 1].x
,
3428 state
[statecount
- 1].y
,
3429 state
[statecount
- 1].pane
,
3431 tty_hide_cursor (tty
);
3432 fflush (tty
->output
);
3435 /* Display the help-echo message for the currently-selected menu
3437 if ((menu_help_message
|| prev_menu_help_message
)
3438 && menu_help_message
!= prev_menu_help_message
)
3440 help_callback (menu_help_message
,
3441 menu_help_paneno
, menu_help_itemno
);
3442 tty_hide_cursor (tty
);
3443 fflush (tty
->output
);
3444 prev_menu_help_message
= menu_help_message
;
3448 sf
->mouse_moved
= 0;
3449 screen_update (sf
, state
[0].screen_behind
);
3450 while (statecount
--)
3451 free_saved_screen (state
[statecount
].screen_behind
);
3452 tty_show_cursor (tty
); /* turn cursor back on */
3454 /* Clean up any mouse events that are waiting inside Emacs event queue.
3455 These events are likely to be generated before the menu was even
3456 displayed, probably because the user pressed and released the button
3457 (which invoked the menu) too quickly. If we don't remove these events,
3458 Emacs will process them after we return and surprise the user. */
3459 discard_mouse_events ();
3460 if (!kbd_buffer_events_waiting ())
3461 clear_input_pending ();
3462 SET_FRAME_GARBAGED (sf
);
3466 /* Dispose of a menu. */
3469 tty_menu_destroy (tty_menu
*menu
)
3472 if (menu
->allocated
)
3474 for (i
= 0; i
< menu
->count
; i
++)
3475 if (menu
->submenu
[i
])
3476 tty_menu_destroy (menu
->submenu
[i
]);
3478 xfree (menu
->submenu
);
3479 xfree (menu
->panenumber
);
3480 xfree (menu
->help_text
);
3483 menu_help_message
= prev_menu_help_message
= NULL
;
3486 /* Show help HELP_STRING, or clear help if HELP_STRING is null.
3488 PANE is the pane number, and ITEM is the menu item number in
3489 the menu (currently not used). */
3492 tty_menu_help_callback (char const *help_string
, int pane
, int item
)
3494 Lisp_Object
*first_item
;
3495 Lisp_Object pane_name
;
3496 Lisp_Object menu_object
;
3498 first_item
= XVECTOR (menu_items
)->u
.contents
;
3499 if (EQ (first_item
[0], Qt
))
3500 pane_name
= first_item
[MENU_ITEMS_PANE_NAME
];
3501 else if (EQ (first_item
[0], Qquote
))
3502 /* This shouldn't happen, see xmenu_show. */
3503 pane_name
= empty_unibyte_string
;
3505 pane_name
= first_item
[MENU_ITEMS_ITEM_NAME
];
3507 /* (menu-item MENU-NAME PANE-NUMBER) */
3508 menu_object
= list3 (Qmenu_item
, pane_name
, make_number (pane
));
3509 show_help_echo (help_string
? build_string (help_string
) : Qnil
,
3510 Qnil
, menu_object
, make_number (item
));
3514 tty_pop_down_menu (Lisp_Object arg
)
3516 tty_menu
*menu
= XSAVE_POINTER (arg
, 0);
3519 tty_menu_destroy (menu
);
3523 /* Return the zero-based index of the last menu-bar item on frame F. */
3525 tty_menu_last_menubar_item (struct frame
*f
)
3529 eassert (FRAME_TERMCAP_P (f
) && FRAME_LIVE_P (f
));
3530 if (FRAME_TERMCAP_P (f
) && FRAME_LIVE_P (f
))
3532 Lisp_Object items
= FRAME_MENU_BAR_ITEMS (f
);
3534 while (i
< ASIZE (items
))
3538 str
= AREF (items
, i
+ 1);
3543 i
-= 4; /* went one too far */
3548 /* Find in frame F's menu bar the menu item that is next or previous
3549 to the item at X/Y, and return that item's position in X/Y. WHICH
3550 says which one--next or previous--item to look for. X and Y are
3551 measured in character cells. This should only be called on TTY
3554 tty_menu_new_item_coords (struct frame
*f
, int which
, int *x
, int *y
)
3556 eassert (FRAME_TERMCAP_P (f
) && FRAME_LIVE_P (f
));
3557 if (FRAME_TERMCAP_P (f
) && FRAME_LIVE_P (f
))
3559 Lisp_Object items
= FRAME_MENU_BAR_ITEMS (f
);
3560 int last_i
= tty_menu_last_menubar_item (f
);
3563 /* This loop assumes a single menu-bar line, and will fail to
3564 find an item if it is not in the first line. Note that
3565 make_lispy_event in keyboard.c makes the same assumption. */
3566 for (i
= 0, prev_x
= -1; i
< ASIZE (items
); i
+= 4)
3568 Lisp_Object pos
, str
;
3571 str
= AREF (items
, i
+ 1);
3572 pos
= AREF (items
, i
+ 3);
3577 /* We use <= so the blank between 2 items on a TTY is
3578 considered part of the previous item. */
3579 && *x
<= ix
+ menu_item_width (SSDATA (str
)))
3581 /* Found current item. Now compute the X coordinate of
3582 the previous or next item. */
3583 if (which
== TTYM_NEXT
)
3586 *x
= XINT (AREF (items
, i
+ 4 + 3));
3588 *x
= 0; /* wrap around to the first item */
3590 else if (prev_x
< 0)
3592 /* Wrap around to the last item. */
3593 *x
= XINT (AREF (items
, last_i
+ 3));
3605 tty_menu_show (struct frame
*f
, int x
, int y
, int for_click
, int keymaps
,
3606 Lisp_Object title
, int kbd_navigation
, const char **error_name
)
3609 int pane
, selidx
, lpane
, status
;
3610 Lisp_Object entry
, pane_prefix
;
3612 int ulx
, uly
, width
, height
;
3614 int dispwidth
, dispheight
;
3615 int i
, j
, lines
, maxlines
;
3618 unsigned int dummy_uint
;
3619 ptrdiff_t specpdl_count
= SPECPDL_INDEX ();
3621 if (! FRAME_TERMCAP_P (f
))
3625 if (menu_items_n_panes
== 0)
3628 if (menu_items_used
<= MENU_ITEMS_PANE_LENGTH
)
3630 *error_name
= "Empty menu";
3634 /* Make the menu on that window. */
3635 menu
= tty_menu_create ();
3638 *error_name
= "Can't create menu";
3642 /* Don't GC while we prepare and show the menu, because we give the
3643 menu functions pointers to the contents of strings. */
3644 inhibit_garbage_collection ();
3646 /* Adjust coordinates to be root-window-relative. */
3647 item_x
= x
+= f
->left_pos
;
3648 item_y
= y
+= f
->top_pos
;
3650 /* Create all the necessary panes and their items. */
3651 maxwidth
= maxlines
= lines
= i
= 0;
3652 lpane
= TTYM_FAILURE
;
3653 while (i
< menu_items_used
)
3655 if (EQ (AREF (menu_items
, i
), Qt
))
3657 /* Create a new pane. */
3658 Lisp_Object pane_name
, prefix
;
3659 const char *pane_string
;
3661 maxlines
= max (maxlines
, lines
);
3663 pane_name
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_NAME
);
3664 prefix
= AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
3665 pane_string
= (NILP (pane_name
)
3666 ? "" : SSDATA (pane_name
));
3667 if (keymaps
&& !NILP (prefix
))
3670 lpane
= tty_menu_add_pane (menu
, pane_string
);
3671 if (lpane
== TTYM_FAILURE
)
3673 tty_menu_destroy (menu
);
3674 *error_name
= "Can't create pane";
3677 i
+= MENU_ITEMS_PANE_LENGTH
;
3679 /* Find the width of the widest item in this pane. */
3681 while (j
< menu_items_used
)
3684 item
= AREF (menu_items
, j
);
3692 width
= SBYTES (item
);
3693 if (width
> maxwidth
)
3696 j
+= MENU_ITEMS_ITEM_LENGTH
;
3699 /* Ignore a nil in the item list.
3700 It's meaningful only for dialog boxes. */
3701 else if (EQ (AREF (menu_items
, i
), Qquote
))
3705 /* Create a new item within current pane. */
3706 Lisp_Object item_name
, enable
, descrip
, help
;
3708 char const *help_string
;
3710 item_name
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_NAME
);
3711 enable
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_ENABLE
);
3712 descrip
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_EQUIV_KEY
);
3713 help
= AREF (menu_items
, i
+ MENU_ITEMS_ITEM_HELP
);
3714 help_string
= STRINGP (help
) ? SSDATA (help
) : NULL
;
3716 if (!NILP (descrip
))
3718 /* if alloca is fast, use that to make the space,
3719 to reduce gc needs. */
3720 item_data
= (char *) alloca (maxwidth
+ SBYTES (descrip
) + 1);
3721 memcpy (item_data
, SSDATA (item_name
), SBYTES (item_name
));
3722 for (j
= SCHARS (item_name
); j
< maxwidth
; j
++)
3724 memcpy (item_data
+ j
, SSDATA (descrip
), SBYTES (descrip
));
3725 item_data
[j
+ SBYTES (descrip
)] = 0;
3728 item_data
= SSDATA (item_name
);
3730 if (lpane
== TTYM_FAILURE
3731 || (tty_menu_add_selection (menu
, lpane
, item_data
,
3732 !NILP (enable
), help_string
)
3735 tty_menu_destroy (menu
);
3736 *error_name
= "Can't add selection to menu";
3739 i
+= MENU_ITEMS_ITEM_LENGTH
;
3744 maxlines
= max (maxlines
, lines
);
3746 /* All set and ready to fly. */
3747 dispwidth
= f
->text_cols
;
3748 dispheight
= f
->text_lines
;
3749 x
= min (x
, dispwidth
);
3750 y
= min (y
, dispheight
);
3753 tty_menu_locate (menu
, x
, y
, &ulx
, &uly
, &width
, &height
);
3754 if (ulx
+width
> dispwidth
)
3756 x
-= (ulx
+ width
) - dispwidth
;
3757 ulx
= dispwidth
- width
;
3759 if (uly
+height
> dispheight
)
3761 y
-= (uly
+ height
) - dispheight
;
3762 uly
= dispheight
- height
;
3765 if (FRAME_HAS_MINIBUF_P (f
) && uly
+height
> dispheight
- 2)
3767 /* Move the menu away of the echo area, to avoid overwriting the
3768 menu with help echo messages or vice versa. */
3769 if (BUFFERP (echo_area_buffer
[0]) && WINDOWP (echo_area_window
))
3771 y
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
)) + 1;
3772 uly
-= WINDOW_TOTAL_LINES (XWINDOW (echo_area_window
)) + 1;
3781 if (ulx
< 0) x
-= ulx
;
3782 if (uly
< 0) y
-= uly
;
3785 /* This code doesn't make sense on a TTY, since it can easily annul
3786 the adjustments above that carefully avoid truncation of the menu
3787 items. I think it was written to fix some problem that only
3791 /* If position was not given by a mouse click, adjust so upper left
3792 corner of the menu as a whole ends up at given coordinates. This
3793 is what x-popup-menu says in its documentation. */
3795 y
+= 1.5*height
/(maxlines
+2);
3801 record_unwind_protect (tty_pop_down_menu
, make_save_ptr (menu
));
3803 specbind (Qoverriding_terminal_local_map
,
3804 Fsymbol_value (Qtty_menu_navigation_map
));
3805 status
= tty_menu_activate (menu
, &pane
, &selidx
, x
, y
, &datap
,
3806 tty_menu_help_callback
, kbd_navigation
);
3807 entry
= pane_prefix
= Qnil
;
3812 /* Find the item number SELIDX in pane number PANE. */
3814 while (i
< menu_items_used
)
3816 if (EQ (AREF (menu_items
, i
), Qt
))
3820 = AREF (menu_items
, i
+ MENU_ITEMS_PANE_PREFIX
);
3822 i
+= MENU_ITEMS_PANE_LENGTH
;
3831 = AREF (menu_items
, i
+ MENU_ITEMS_ITEM_VALUE
);
3834 entry
= Fcons (entry
, Qnil
);
3835 if (!NILP (pane_prefix
))
3836 entry
= Fcons (pane_prefix
, entry
);
3842 i
+= MENU_ITEMS_ITEM_LENGTH
;
3849 tty_menu_new_item_coords (f
, status
, &item_x
, &item_y
);
3850 entry
= Fcons (make_number (item_x
), make_number (item_y
));
3854 *error_name
= "Can't activate menu";
3855 case TTYM_IA_SELECT
:
3857 case TTYM_NO_SELECT
:
3858 /* Make "Cancel" equivalent to C-g unless FOR_CLICK (which means
3859 the menu was invoked with a mouse event as POSITION). */
3861 Fsignal (Qquit
, Qnil
);
3865 unbind_to (specpdl_count
, Qnil
);
3870 #endif /* HAVE_MENUS && !MSDOS */
3874 /***********************************************************************
3876 ***********************************************************************/
3878 /* Initialize the tty-dependent part of frame F. The frame must
3879 already have its device initialized. */
3882 create_tty_output (struct frame
*f
)
3884 struct tty_output
*t
= xzalloc (sizeof *t
);
3886 eassert (FRAME_TERMCAP_P (f
));
3888 t
->display_info
= FRAME_TERMINAL (f
)->display_info
.tty
;
3890 f
->output_data
.tty
= t
;
3893 /* Delete frame F's face cache, and its tty-dependent part. */
3896 tty_free_frame_resources (struct frame
*f
)
3898 eassert (FRAME_TERMCAP_P (f
));
3900 if (FRAME_FACE_CACHE (f
))
3901 free_frame_faces (f
);
3903 xfree (f
->output_data
.tty
);
3908 /* Delete frame F's face cache. */
3911 tty_free_frame_resources (struct frame
*f
)
3913 eassert (FRAME_TERMCAP_P (f
) || FRAME_MSDOS_P (f
));
3915 if (FRAME_FACE_CACHE (f
))
3916 free_frame_faces (f
);
3920 /* Reset the hooks in TERMINAL. */
3923 clear_tty_hooks (struct terminal
*terminal
)
3926 terminal
->cursor_to_hook
= 0;
3927 terminal
->raw_cursor_to_hook
= 0;
3928 terminal
->clear_to_end_hook
= 0;
3929 terminal
->clear_frame_hook
= 0;
3930 terminal
->clear_end_of_line_hook
= 0;
3931 terminal
->ins_del_lines_hook
= 0;
3932 terminal
->insert_glyphs_hook
= 0;
3933 terminal
->write_glyphs_hook
= 0;
3934 terminal
->delete_glyphs_hook
= 0;
3935 terminal
->ring_bell_hook
= 0;
3936 terminal
->reset_terminal_modes_hook
= 0;
3937 terminal
->set_terminal_modes_hook
= 0;
3938 terminal
->update_begin_hook
= 0;
3939 terminal
->update_end_hook
= 0;
3940 terminal
->set_terminal_window_hook
= 0;
3941 terminal
->mouse_position_hook
= 0;
3942 terminal
->frame_rehighlight_hook
= 0;
3943 terminal
->frame_raise_lower_hook
= 0;
3944 terminal
->fullscreen_hook
= 0;
3945 terminal
->set_vertical_scroll_bar_hook
= 0;
3946 terminal
->condemn_scroll_bars_hook
= 0;
3947 terminal
->redeem_scroll_bar_hook
= 0;
3948 terminal
->judge_scroll_bars_hook
= 0;
3949 terminal
->read_socket_hook
= 0;
3950 terminal
->frame_up_to_date_hook
= 0;
3952 /* Leave these two set, or suspended frames are not deleted
3954 terminal
->delete_frame_hook
= &tty_free_frame_resources
;
3955 terminal
->delete_terminal_hook
= &delete_tty
;
3958 /* Initialize hooks in TERMINAL with the values needed for a tty. */
3961 set_tty_hooks (struct terminal
*terminal
)
3963 terminal
->rif
= 0; /* ttys don't support window-based redisplay. */
3965 terminal
->cursor_to_hook
= &tty_cursor_to
;
3966 terminal
->raw_cursor_to_hook
= &tty_raw_cursor_to
;
3968 terminal
->clear_to_end_hook
= &tty_clear_to_end
;
3969 terminal
->clear_frame_hook
= &tty_clear_frame
;
3970 terminal
->clear_end_of_line_hook
= &tty_clear_end_of_line
;
3972 terminal
->ins_del_lines_hook
= &tty_ins_del_lines
;
3974 terminal
->insert_glyphs_hook
= &tty_insert_glyphs
;
3975 terminal
->write_glyphs_hook
= &tty_write_glyphs
;
3976 terminal
->delete_glyphs_hook
= &tty_delete_glyphs
;
3978 terminal
->ring_bell_hook
= &tty_ring_bell
;
3980 terminal
->reset_terminal_modes_hook
= &tty_reset_terminal_modes
;
3981 terminal
->set_terminal_modes_hook
= &tty_set_terminal_modes
;
3982 terminal
->update_begin_hook
= 0; /* Not needed. */
3983 terminal
->update_end_hook
= &tty_update_end
;
3984 terminal
->set_terminal_window_hook
= &tty_set_terminal_window
;
3986 terminal
->mouse_position_hook
= 0; /* Not needed. */
3987 terminal
->frame_rehighlight_hook
= 0; /* Not needed. */
3988 terminal
->frame_raise_lower_hook
= 0; /* Not needed. */
3990 terminal
->set_vertical_scroll_bar_hook
= 0; /* Not needed. */
3991 terminal
->condemn_scroll_bars_hook
= 0; /* Not needed. */
3992 terminal
->redeem_scroll_bar_hook
= 0; /* Not needed. */
3993 terminal
->judge_scroll_bars_hook
= 0; /* Not needed. */
3995 terminal
->read_socket_hook
= &tty_read_avail_input
; /* keyboard.c */
3996 terminal
->frame_up_to_date_hook
= 0; /* Not needed. */
3998 terminal
->delete_frame_hook
= &tty_free_frame_resources
;
3999 terminal
->delete_terminal_hook
= &delete_tty
;
4002 /* If FD is the controlling terminal, drop it. */
4004 dissociate_if_controlling_tty (int fd
)
4006 /* If tcgetpgrp succeeds, fd is the controlling terminal,
4007 so dissociate it by invoking setsid. */
4008 if (tcgetpgrp (fd
) >= 0 && setsid () < 0)
4011 /* setsid failed, presumably because Emacs is already a process
4012 group leader. Fall back on the obsolescent way to dissociate
4013 a controlling tty. */
4014 block_tty_out_signal ();
4015 ioctl (fd
, TIOCNOTTY
, 0);
4016 unblock_tty_out_signal ();
4021 /* Create a termcap display on the tty device with the given name and
4024 If NAME is NULL, then use the controlling tty, i.e., "/dev/tty".
4025 Otherwise NAME should be a path to the tty device file,
4028 TERMINAL_TYPE is the termcap type of the device, e.g. "vt100".
4030 If MUST_SUCCEED is true, then all errors are fatal. */
4033 init_tty (const char *name
, const char *terminal_type
, bool must_succeed
)
4036 char **address
= &area
;
4038 struct tty_display_info
*tty
= NULL
;
4039 struct terminal
*terminal
= NULL
;
4040 bool ctty
= false; /* True if asked to open controlling tty. */
4043 maybe_fatal (must_succeed
, 0,
4044 "Unknown terminal type",
4045 "Unknown terminal type");
4049 if (!strcmp (name
, DEV_TTY
))
4052 /* If we already have a terminal on the given device, use that. If
4053 all such terminals are suspended, create a new one instead. */
4054 /* XXX Perhaps this should be made explicit by having init_tty
4055 always create a new terminal and separating terminal and frame
4056 creation on Lisp level. */
4057 terminal
= get_named_tty (name
);
4061 terminal
= create_terminal ();
4064 maybe_fatal (0, 0, "Attempt to create another terminal %s", "",
4067 tty
= &the_only_display_info
;
4069 tty
= xzalloc (sizeof *tty
);
4071 tty
->top_frame
= Qnil
;
4072 tty
->next
= tty_list
;
4075 terminal
->type
= output_termcap
;
4076 terminal
->display_info
.tty
= tty
;
4077 tty
->terminal
= terminal
;
4079 tty
->Wcm
= xmalloc (sizeof *tty
->Wcm
);
4082 encode_terminal_src_size
= 0;
4083 encode_terminal_dst_size
= 0;
4087 set_tty_hooks (terminal
);
4090 /* Open the terminal device. */
4092 /* If !ctty, don't recognize it as our controlling terminal, and
4093 don't make it the controlling tty if we don't have one now.
4095 Alas, O_IGNORE_CTTY is a GNU extension that seems to be only
4096 defined on Hurd. On other systems, we need to explicitly
4097 dissociate ourselves from the controlling tty when we want to
4098 open a frame on the same terminal. */
4099 int flags
= O_RDWR
| O_NOCTTY
| (ctty
? 0 : O_IGNORE_CTTY
);
4100 int fd
= emacs_open (name
, flags
, 0);
4101 tty
->input
= tty
->output
= fd
< 0 || ! isatty (fd
) ? 0 : fdopen (fd
, "w+");
4105 char const *diagnostic
4106 = tty
->input
? "Not a tty device: %s" : "Could not open file: %s";
4108 maybe_fatal (must_succeed
, terminal
, diagnostic
, diagnostic
, name
);
4111 tty
->name
= xstrdup (name
);
4112 terminal
->name
= xstrdup (name
);
4114 if (!O_IGNORE_CTTY
&& !ctty
)
4115 dissociate_if_controlling_tty (fd
);
4118 tty
->type
= xstrdup (terminal_type
);
4120 add_keyboard_wait_descriptor (fileno (tty
->input
));
4124 /* On some systems, tgetent tries to access the controlling
4126 block_tty_out_signal ();
4127 status
= tgetent (tty
->termcap_term_buffer
, terminal_type
);
4128 if (tty
->termcap_term_buffer
[TERMCAP_BUFFER_SIZE
- 1])
4130 unblock_tty_out_signal ();
4135 maybe_fatal (must_succeed
, terminal
,
4136 "Cannot open terminfo database file",
4137 "Cannot open terminfo database file");
4139 maybe_fatal (must_succeed
, terminal
,
4140 "Cannot open termcap database file",
4141 "Cannot open termcap database file");
4146 maybe_fatal (must_succeed
, terminal
,
4147 "Terminal type %s is not defined",
4148 "Terminal type %s is not defined.\n\
4149 If that is not the actual type of terminal you have,\n\
4150 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
4151 `setenv TERM ...') to specify the correct type. It may be necessary\n"
4153 "to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
4155 "to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
4160 area
= tty
->termcap_strings_buffer
;
4161 tty
->TS_ins_line
= tgetstr ("al", address
);
4162 tty
->TS_ins_multi_lines
= tgetstr ("AL", address
);
4163 tty
->TS_bell
= tgetstr ("bl", address
);
4164 BackTab (tty
) = tgetstr ("bt", address
);
4165 tty
->TS_clr_to_bottom
= tgetstr ("cd", address
);
4166 tty
->TS_clr_line
= tgetstr ("ce", address
);
4167 tty
->TS_clr_frame
= tgetstr ("cl", address
);
4168 ColPosition (tty
) = NULL
; /* tgetstr ("ch", address); */
4169 AbsPosition (tty
) = tgetstr ("cm", address
);
4170 CR (tty
) = tgetstr ("cr", address
);
4171 tty
->TS_set_scroll_region
= tgetstr ("cs", address
);
4172 tty
->TS_set_scroll_region_1
= tgetstr ("cS", address
);
4173 RowPosition (tty
) = tgetstr ("cv", address
);
4174 tty
->TS_del_char
= tgetstr ("dc", address
);
4175 tty
->TS_del_multi_chars
= tgetstr ("DC", address
);
4176 tty
->TS_del_line
= tgetstr ("dl", address
);
4177 tty
->TS_del_multi_lines
= tgetstr ("DL", address
);
4178 tty
->TS_delete_mode
= tgetstr ("dm", address
);
4179 tty
->TS_end_delete_mode
= tgetstr ("ed", address
);
4180 tty
->TS_end_insert_mode
= tgetstr ("ei", address
);
4181 Home (tty
) = tgetstr ("ho", address
);
4182 tty
->TS_ins_char
= tgetstr ("ic", address
);
4183 tty
->TS_ins_multi_chars
= tgetstr ("IC", address
);
4184 tty
->TS_insert_mode
= tgetstr ("im", address
);
4185 tty
->TS_pad_inserted_char
= tgetstr ("ip", address
);
4186 tty
->TS_end_keypad_mode
= tgetstr ("ke", address
);
4187 tty
->TS_keypad_mode
= tgetstr ("ks", address
);
4188 LastLine (tty
) = tgetstr ("ll", address
);
4189 Right (tty
) = tgetstr ("nd", address
);
4190 Down (tty
) = tgetstr ("do", address
);
4192 Down (tty
) = tgetstr ("nl", address
); /* Obsolete name for "do". */
4193 if (tgetflag ("bs"))
4194 Left (tty
) = "\b"; /* Can't possibly be longer! */
4195 else /* (Actually, "bs" is obsolete...) */
4196 Left (tty
) = tgetstr ("le", address
);
4198 Left (tty
) = tgetstr ("bc", address
); /* Obsolete name for "le". */
4199 tty
->TS_pad_char
= tgetstr ("pc", address
);
4200 tty
->TS_repeat
= tgetstr ("rp", address
);
4201 tty
->TS_end_standout_mode
= tgetstr ("se", address
);
4202 tty
->TS_fwd_scroll
= tgetstr ("sf", address
);
4203 tty
->TS_standout_mode
= tgetstr ("so", address
);
4204 tty
->TS_rev_scroll
= tgetstr ("sr", address
);
4205 tty
->Wcm
->cm_tab
= tgetstr ("ta", address
);
4206 tty
->TS_end_termcap_modes
= tgetstr ("te", address
);
4207 tty
->TS_termcap_modes
= tgetstr ("ti", address
);
4208 Up (tty
) = tgetstr ("up", address
);
4209 tty
->TS_visible_bell
= tgetstr ("vb", address
);
4210 tty
->TS_cursor_normal
= tgetstr ("ve", address
);
4211 tty
->TS_cursor_visible
= tgetstr ("vs", address
);
4212 tty
->TS_cursor_invisible
= tgetstr ("vi", address
);
4213 tty
->TS_set_window
= tgetstr ("wi", address
);
4215 tty
->TS_enter_underline_mode
= tgetstr ("us", address
);
4216 tty
->TS_exit_underline_mode
= tgetstr ("ue", address
);
4217 tty
->TS_enter_bold_mode
= tgetstr ("md", address
);
4218 tty
->TS_enter_italic_mode
= tgetstr ("ZH", address
);
4219 tty
->TS_enter_dim_mode
= tgetstr ("mh", address
);
4220 tty
->TS_enter_reverse_mode
= tgetstr ("mr", address
);
4221 tty
->TS_enter_alt_charset_mode
= tgetstr ("as", address
);
4222 tty
->TS_exit_alt_charset_mode
= tgetstr ("ae", address
);
4223 tty
->TS_exit_attribute_mode
= tgetstr ("me", address
);
4225 MultiUp (tty
) = tgetstr ("UP", address
);
4226 MultiDown (tty
) = tgetstr ("DO", address
);
4227 MultiLeft (tty
) = tgetstr ("LE", address
);
4228 MultiRight (tty
) = tgetstr ("RI", address
);
4230 /* SVr4/ANSI color support. If "op" isn't available, don't support
4231 color because we can't switch back to the default foreground and
4233 tty
->TS_orig_pair
= tgetstr ("op", address
);
4234 if (tty
->TS_orig_pair
)
4236 tty
->TS_set_foreground
= tgetstr ("AF", address
);
4237 tty
->TS_set_background
= tgetstr ("AB", address
);
4238 if (!tty
->TS_set_foreground
)
4241 tty
->TS_set_foreground
= tgetstr ("Sf", address
);
4242 tty
->TS_set_background
= tgetstr ("Sb", address
);
4245 tty
->TN_max_colors
= tgetnum ("Co");
4246 tty
->TN_max_pairs
= tgetnum ("pa");
4248 tty
->TN_no_color_video
= tgetnum ("NC");
4249 if (tty
->TN_no_color_video
== -1)
4250 tty
->TN_no_color_video
= 0;
4253 tty_default_color_capabilities (tty
, 1);
4255 MagicWrap (tty
) = tgetflag ("xn");
4256 /* Since we make MagicWrap terminals look like AutoWrap, we need to have
4257 the former flag imply the latter. */
4258 AutoWrap (tty
) = MagicWrap (tty
) || tgetflag ("am");
4259 terminal
->memory_below_frame
= tgetflag ("db");
4260 tty
->TF_hazeltine
= tgetflag ("hz");
4261 terminal
->must_write_spaces
= tgetflag ("in");
4262 tty
->meta_key
= tgetflag ("km") || tgetflag ("MT");
4263 tty
->TF_insmode_motion
= tgetflag ("mi");
4264 tty
->TF_standout_motion
= tgetflag ("ms");
4265 tty
->TF_underscore
= tgetflag ("ul");
4266 tty
->TF_teleray
= tgetflag ("xt");
4271 struct frame
*f
= XFRAME (selected_frame
);
4274 initialize_w32_display (terminal
, &width
, &height
);
4276 FrameRows (tty
) = height
;
4277 FrameCols (tty
) = width
;
4278 tty
->specified_window
= height
;
4280 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
) = vertical_scroll_bar_none
;
4281 terminal
->char_ins_del_ok
= 1;
4287 if (strcmp (terminal_type
, "internal") == 0)
4288 terminal
->type
= output_msdos_raw
;
4289 initialize_msdos_display (terminal
);
4291 get_tty_size (fileno (tty
->input
), &width
, &height
);
4292 FrameCols (tty
) = width
;
4293 FrameRows (tty
) = height
;
4294 terminal
->char_ins_del_ok
= 0;
4295 init_baud_rate (fileno (tty
->input
));
4298 tty
->output
= stdout
;
4300 /* The following two are inaccessible from w32console.c. */
4301 terminal
->delete_frame_hook
= &tty_free_frame_resources
;
4302 terminal
->delete_terminal_hook
= &delete_tty
;
4304 tty
->name
= xstrdup (name
);
4305 terminal
->name
= xstrdup (name
);
4306 tty
->type
= xstrdup (terminal_type
);
4308 add_keyboard_wait_descriptor (0);
4310 tty
->delete_in_insert_mode
= 1;
4313 terminal
->scroll_region_ok
= 0;
4315 /* Seems to insert lines when it's not supposed to, messing up the
4316 display. In doing a trace, it didn't seem to be called much, so I
4317 don't think we're losing anything by turning it off. */
4318 terminal
->line_ins_del_ok
= 0;
4320 tty
->TN_max_colors
= 16; /* Must be non-zero for tty-display-color-p. */
4324 terminal
->mouse_position_hook
= term_mouse_position
;
4325 tty
->mouse_highlight
.mouse_face_window
= Qnil
;
4328 terminal
->kboard
= xmalloc (sizeof *terminal
->kboard
);
4329 init_kboard (terminal
->kboard
);
4330 kset_window_system (terminal
->kboard
, Qnil
);
4331 terminal
->kboard
->next_kboard
= all_kboards
;
4332 all_kboards
= terminal
->kboard
;
4333 terminal
->kboard
->reference_count
++;
4334 /* Don't let the initial kboard remain current longer than necessary.
4335 That would cause problems if a file loaded on startup tries to
4336 prompt in the mini-buffer. */
4337 if (current_kboard
== initial_kboard
)
4338 current_kboard
= terminal
->kboard
;
4340 term_get_fkeys (address
, terminal
->kboard
);
4342 /* Get frame size from system, or else from termcap. */
4345 get_tty_size (fileno (tty
->input
), &width
, &height
);
4346 FrameCols (tty
) = width
;
4347 FrameRows (tty
) = height
;
4350 if (FrameCols (tty
) <= 0)
4351 FrameCols (tty
) = tgetnum ("co");
4352 if (FrameRows (tty
) <= 0)
4353 FrameRows (tty
) = tgetnum ("li");
4355 if (FrameRows (tty
) < 3 || FrameCols (tty
) < 3)
4356 maybe_fatal (must_succeed
, terminal
,
4357 "Screen size %dx%d is too small",
4358 "Screen size %dx%d is too small",
4359 FrameCols (tty
), FrameRows (tty
));
4361 TabWidth (tty
) = tgetnum ("tw");
4364 tty
->TS_bell
= "\07";
4366 if (!tty
->TS_fwd_scroll
)
4367 tty
->TS_fwd_scroll
= Down (tty
);
4369 PC
= tty
->TS_pad_char
? *tty
->TS_pad_char
: 0;
4371 if (TabWidth (tty
) < 0)
4374 /* Turned off since /etc/termcap seems to have :ta= for most terminals
4375 and newer termcap doc does not seem to say there is a default.
4376 if (!tty->Wcm->cm_tab)
4377 tty->Wcm->cm_tab = "\t";
4380 /* We don't support standout modes that use `magic cookies', so
4381 turn off any that do. */
4382 if (tty
->TS_standout_mode
&& tgetnum ("sg") >= 0)
4384 tty
->TS_standout_mode
= 0;
4385 tty
->TS_end_standout_mode
= 0;
4387 if (tty
->TS_enter_underline_mode
&& tgetnum ("ug") >= 0)
4389 tty
->TS_enter_underline_mode
= 0;
4390 tty
->TS_exit_underline_mode
= 0;
4393 /* If there's no standout mode, try to use underlining instead. */
4394 if (tty
->TS_standout_mode
== 0)
4396 tty
->TS_standout_mode
= tty
->TS_enter_underline_mode
;
4397 tty
->TS_end_standout_mode
= tty
->TS_exit_underline_mode
;
4400 /* If no `se' string, try using a `me' string instead.
4401 If that fails, we can't use standout mode at all. */
4402 if (tty
->TS_end_standout_mode
== 0)
4404 char *s
= tgetstr ("me", address
);
4406 tty
->TS_end_standout_mode
= s
;
4408 tty
->TS_standout_mode
= 0;
4411 if (tty
->TF_teleray
)
4413 tty
->Wcm
->cm_tab
= 0;
4414 /* We can't support standout mode, because it uses magic cookies. */
4415 tty
->TS_standout_mode
= 0;
4416 /* But that means we cannot rely on ^M to go to column zero! */
4418 /* LF can't be trusted either -- can alter hpos. */
4419 /* If move at column 0 thru a line with TS_standout_mode. */
4423 tty
->specified_window
= FrameRows (tty
);
4425 if (Wcm_init (tty
) == -1) /* Can't do cursor motion. */
4427 maybe_fatal (must_succeed
, terminal
,
4428 "Terminal type \"%s\" is not powerful enough to run Emacs",
4429 "Terminal type \"%s\" is not powerful enough to run Emacs.\n\
4430 It lacks the ability to position the cursor.\n\
4431 If that is not the actual type of terminal you have,\n\
4432 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
4433 `setenv TERM ...') to specify the correct type. It may be necessary\n"
4435 "to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
4436 # else /* TERMCAP */
4437 "to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
4438 # endif /* TERMINFO */
4442 if (FrameRows (tty
) <= 0 || FrameCols (tty
) <= 0)
4443 maybe_fatal (must_succeed
, terminal
,
4444 "Could not determine the frame size",
4445 "Could not determine the frame size");
4447 tty
->delete_in_insert_mode
4448 = tty
->TS_delete_mode
&& tty
->TS_insert_mode
4449 && !strcmp (tty
->TS_delete_mode
, tty
->TS_insert_mode
);
4451 UseTabs (tty
) = tabs_safe_p (fileno (tty
->input
)) && TabWidth (tty
) == 8;
4453 terminal
->scroll_region_ok
4455 && (tty
->TS_set_window
|| tty
->TS_set_scroll_region
|| tty
->TS_set_scroll_region_1
));
4457 terminal
->line_ins_del_ok
4458 = (((tty
->TS_ins_line
|| tty
->TS_ins_multi_lines
)
4459 && (tty
->TS_del_line
|| tty
->TS_del_multi_lines
))
4460 || (terminal
->scroll_region_ok
4461 && tty
->TS_fwd_scroll
&& tty
->TS_rev_scroll
));
4463 terminal
->char_ins_del_ok
4464 = ((tty
->TS_ins_char
|| tty
->TS_insert_mode
4465 || tty
->TS_pad_inserted_char
|| tty
->TS_ins_multi_chars
)
4466 && (tty
->TS_del_char
|| tty
->TS_del_multi_chars
));
4468 terminal
->fast_clear_end_of_line
= tty
->TS_clr_line
!= 0;
4470 init_baud_rate (fileno (tty
->input
));
4472 #endif /* not DOS_NT */
4474 /* Init system terminal modes (RAW or CBREAK, etc.). */
4475 init_sys_modes (tty
);
4482 vfatal (const char *str
, va_list ap
)
4484 fprintf (stderr
, "emacs: ");
4485 vfprintf (stderr
, str
, ap
);
4486 if (!(strlen (str
) > 0 && str
[strlen (str
) - 1] == '\n'))
4487 fprintf (stderr
, "\n");
4493 /* Auxiliary error-handling function for init_tty.
4494 Delete TERMINAL, then call error or fatal with str1 or str2,
4495 respectively, according to whether MUST_SUCCEED is true. */
4498 maybe_fatal (bool must_succeed
, struct terminal
*terminal
,
4499 const char *str1
, const char *str2
, ...)
4502 va_start (ap
, str2
);
4504 delete_tty (terminal
);
4513 fatal (const char *str
, ...)
4522 /* Delete the given tty terminal, closing all frames on it. */
4525 delete_tty (struct terminal
*terminal
)
4527 struct tty_display_info
*tty
;
4529 /* Protect against recursive calls. delete_frame in
4530 delete_terminal calls us back when it deletes our last frame. */
4531 if (!terminal
->name
)
4534 eassert (terminal
->type
== output_termcap
);
4536 tty
= terminal
->display_info
.tty
;
4538 if (tty
== tty_list
)
4539 tty_list
= tty
->next
;
4542 struct tty_display_info
*p
;
4543 for (p
= tty_list
; p
&& p
->next
!= tty
; p
= p
->next
)
4547 /* This should not happen. */
4550 p
->next
= tty
->next
;
4554 /* reset_sys_modes needs a valid device, so this call needs to be
4555 before delete_terminal. */
4556 reset_sys_modes (tty
);
4558 delete_terminal (terminal
);
4565 delete_keyboard_wait_descriptor (fileno (tty
->input
));
4566 if (tty
->input
!= stdin
)
4567 fclose (tty
->input
);
4569 if (tty
->output
&& tty
->output
!= stdout
&& tty
->output
!= tty
->input
)
4570 fclose (tty
->output
);
4571 if (tty
->termscript
)
4572 fclose (tty
->termscript
);
4574 xfree (tty
->old_tty
);
4582 DEFVAR_BOOL ("system-uses-terminfo", system_uses_terminfo
,
4583 doc
: /* Non-nil means the system uses terminfo rather than termcap.
4584 This variable can be used by terminal emulator packages. */);
4586 system_uses_terminfo
= 1;
4588 system_uses_terminfo
= 0;
4591 DEFVAR_LISP ("suspend-tty-functions", Vsuspend_tty_functions
,
4592 doc
: /* Functions run after suspending a tty.
4593 The functions are run with one argument, the terminal object to be suspended.
4594 See `suspend-tty'. */);
4595 Vsuspend_tty_functions
= Qnil
;
4598 DEFVAR_LISP ("resume-tty-functions", Vresume_tty_functions
,
4599 doc
: /* Functions run after resuming a tty.
4600 The functions are run with one argument, the terminal object that was revived.
4601 See `resume-tty'. */);
4602 Vresume_tty_functions
= Qnil
;
4604 DEFVAR_BOOL ("visible-cursor", visible_cursor
,
4605 doc
: /* Non-nil means to make the cursor very visible.
4606 This only has an effect when running in a text terminal.
4607 What means \"very visible\" is up to your terminal. It may make the cursor
4608 bigger, or it may make it blink, or it may do nothing at all. */);
4611 defsubr (&Stty_display_color_p
);
4612 defsubr (&Stty_display_color_cells
);
4613 defsubr (&Stty_no_underline
);
4614 defsubr (&Stty_type
);
4615 defsubr (&Scontrolling_tty_p
);
4616 defsubr (&Stty_top_frame
);
4617 defsubr (&Ssuspend_tty
);
4618 defsubr (&Sresume_tty
);
4620 defsubr (&Sgpm_mouse_start
);
4621 defsubr (&Sgpm_mouse_stop
);
4622 #endif /* HAVE_GPM */
4625 default_orig_pair
= NULL
;
4626 default_set_foreground
= NULL
;
4627 default_set_background
= NULL
;
4628 #endif /* !DOS_NT */
4630 encode_terminal_src
= NULL
;
4631 encode_terminal_dst
= NULL
;
4633 DEFSYM (Qtty_menu_next_item
, "tty-menu-next-item");
4634 DEFSYM (Qtty_menu_prev_item
, "tty-menu-prev-item");
4635 DEFSYM (Qtty_menu_next_menu
, "tty-menu-next-menu");
4636 DEFSYM (Qtty_menu_prev_menu
, "tty-menu-prev-menu");
4637 DEFSYM (Qtty_menu_select
, "tty-menu-select");
4638 DEFSYM (Qtty_menu_ignore
, "tty-menu-ignore");
4639 DEFSYM (Qtty_menu_exit
, "tty-menu-exit");
4640 DEFSYM (Qtty_menu_mouse_movement
, "tty-menu-mouse-movement");
4641 DEFSYM (Qtty_menu_navigation_map
, "tty-menu-navigation-map");