1 /* Terminal control module for terminals described by TERMCAP
2 Copyright (C) 1985-1987, 1993-1995, 1998, 2000-2011
3 Free Software Foundation, Inc.
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>. */
37 #include "character.h"
40 #include "composite.h"
44 #include "termhooks.h"
45 #include "dispextern.h"
48 #include "blockinput.h"
49 #include "syssignal.h"
51 #include "intervals.h"
54 static int been_here
= -1;
70 /* The name of the default console device. */
72 #define DEV_TTY "CONOUT$"
74 #define DEV_TTY "/dev/tty"
77 static void tty_set_scroll_region (struct frame
*f
, int start
, int stop
);
78 static void turn_on_face (struct frame
*, int face_id
);
79 static void turn_off_face (struct frame
*, int face_id
);
80 static void tty_show_cursor (struct tty_display_info
*);
81 static void tty_hide_cursor (struct tty_display_info
*);
82 static void tty_background_highlight (struct tty_display_info
*tty
);
83 static void clear_tty_hooks (struct terminal
*terminal
);
84 static void set_tty_hooks (struct terminal
*terminal
);
85 static void dissociate_if_controlling_tty (int fd
);
86 static void delete_tty (struct terminal
*);
87 static void maybe_fatal (int must_succeed
, struct terminal
*terminal
,
88 const char *str1
, const char *str2
, ...) NO_RETURN
;
89 static void vfatal (const char *str
, va_list ap
) NO_RETURN
;
92 #define OUTPUT(tty, a) \
93 emacs_tputs ((tty), a, \
94 (int) (FRAME_LINES (XFRAME (selected_frame)) \
98 #define OUTPUT1(tty, a) emacs_tputs ((tty), a, 1, cmputc)
99 #define OUTPUTL(tty, a, lines) emacs_tputs ((tty), a, lines, cmputc)
101 #define OUTPUT_IF(tty, a) \
107 #define OUTPUT1_IF(tty, a) do { if (a) emacs_tputs ((tty), a, 1, cmputc); } while (0)
109 /* Display space properties */
111 /* Chain of all tty device parameters. */
112 struct tty_display_info
*tty_list
;
114 /* Meaning of bits in no_color_video. Each bit set means that the
115 corresponding attribute cannot be combined with colors. */
119 NC_STANDOUT
= 1 << 0,
120 NC_UNDERLINE
= 1 << 1,
127 NC_ALT_CHARSET
= 1 << 8
132 /* The largest frame width in any call to calculate_costs. */
136 /* The largest frame height in any call to calculate_costs. */
140 /* Non-zero if we have dropped our controlling tty and therefore
141 should not open a frame on stdout. */
142 static int no_controlling_tty
;
147 #include <sys/fcntl.h>
149 /* The device for which we have enabled gpm support (or NULL). */
150 struct tty_display_info
*gpm_tty
= NULL
;
152 /* Last recorded mouse coordinates. */
153 static int last_mouse_x
, last_mouse_y
;
154 #endif /* HAVE_GPM */
156 /* Ring the bell on a tty. */
159 tty_ring_bell (struct frame
*f
)
161 struct tty_display_info
*tty
= FRAME_TTY (f
);
165 OUTPUT (tty
, (tty
->TS_visible_bell
&& visible_bell
166 ? tty
->TS_visible_bell
168 fflush (tty
->output
);
172 /* Set up termcap modes for Emacs. */
175 tty_set_terminal_modes (struct terminal
*terminal
)
177 struct tty_display_info
*tty
= terminal
->display_info
.tty
;
181 if (tty
->TS_termcap_modes
)
182 OUTPUT (tty
, tty
->TS_termcap_modes
);
185 /* Output enough newlines to scroll all the old screen contents
186 off the screen, so it won't be overwritten and lost. */
189 for (i
= 0; i
< FRAME_LINES (XFRAME (selected_frame
)); i
++)
193 OUTPUT_IF (tty
, visible_cursor
? tty
->TS_cursor_visible
: tty
->TS_cursor_normal
);
194 OUTPUT_IF (tty
, tty
->TS_keypad_mode
);
196 fflush (tty
->output
);
200 /* Reset termcap modes before exiting Emacs. */
203 tty_reset_terminal_modes (struct terminal
*terminal
)
205 struct tty_display_info
*tty
= terminal
->display_info
.tty
;
209 tty_turn_off_highlight (tty
);
210 tty_turn_off_insert (tty
);
211 OUTPUT_IF (tty
, tty
->TS_end_keypad_mode
);
212 OUTPUT_IF (tty
, tty
->TS_cursor_normal
);
213 OUTPUT_IF (tty
, tty
->TS_end_termcap_modes
);
214 OUTPUT_IF (tty
, tty
->TS_orig_pair
);
215 /* Output raw CR so kernel can track the cursor hpos. */
218 fflush (tty
->output
);
222 /* Flag the end of a display update on a termcap terminal. */
225 tty_update_end (struct frame
*f
)
227 struct tty_display_info
*tty
= FRAME_TTY (f
);
229 if (!XWINDOW (selected_window
)->cursor_off_p
)
230 tty_show_cursor (tty
);
231 tty_turn_off_insert (tty
);
232 tty_background_highlight (tty
);
235 /* The implementation of set_terminal_window for termcap frames. */
238 tty_set_terminal_window (struct frame
*f
, int size
)
240 struct tty_display_info
*tty
= FRAME_TTY (f
);
242 tty
->specified_window
= size
? size
: FRAME_LINES (f
);
243 if (FRAME_SCROLL_REGION_OK (f
))
244 tty_set_scroll_region (f
, 0, tty
->specified_window
);
248 tty_set_scroll_region (struct frame
*f
, int start
, int stop
)
251 struct tty_display_info
*tty
= FRAME_TTY (f
);
253 if (tty
->TS_set_scroll_region
)
254 buf
= tparam (tty
->TS_set_scroll_region
, 0, 0, start
, stop
- 1, 0, 0);
255 else if (tty
->TS_set_scroll_region_1
)
256 buf
= tparam (tty
->TS_set_scroll_region_1
, 0, 0,
257 FRAME_LINES (f
), start
,
258 FRAME_LINES (f
) - stop
,
261 buf
= tparam (tty
->TS_set_window
, 0, 0, start
, 0, stop
, FRAME_COLS (f
));
270 tty_turn_on_insert (struct tty_display_info
*tty
)
272 if (!tty
->insert_mode
)
273 OUTPUT (tty
, tty
->TS_insert_mode
);
274 tty
->insert_mode
= 1;
278 tty_turn_off_insert (struct tty_display_info
*tty
)
280 if (tty
->insert_mode
)
281 OUTPUT (tty
, tty
->TS_end_insert_mode
);
282 tty
->insert_mode
= 0;
285 /* Handle highlighting. */
288 tty_turn_off_highlight (struct tty_display_info
*tty
)
290 if (tty
->standout_mode
)
291 OUTPUT_IF (tty
, tty
->TS_end_standout_mode
);
292 tty
->standout_mode
= 0;
296 tty_turn_on_highlight (struct tty_display_info
*tty
)
298 if (!tty
->standout_mode
)
299 OUTPUT_IF (tty
, tty
->TS_standout_mode
);
300 tty
->standout_mode
= 1;
304 tty_toggle_highlight (struct tty_display_info
*tty
)
306 if (tty
->standout_mode
)
307 tty_turn_off_highlight (tty
);
309 tty_turn_on_highlight (tty
);
313 /* Make cursor invisible. */
316 tty_hide_cursor (struct tty_display_info
*tty
)
318 if (tty
->cursor_hidden
== 0)
320 tty
->cursor_hidden
= 1;
321 OUTPUT_IF (tty
, tty
->TS_cursor_invisible
);
326 /* Ensure that cursor is visible. */
329 tty_show_cursor (struct tty_display_info
*tty
)
331 if (tty
->cursor_hidden
)
333 tty
->cursor_hidden
= 0;
334 OUTPUT_IF (tty
, tty
->TS_cursor_normal
);
336 OUTPUT_IF (tty
, tty
->TS_cursor_visible
);
341 /* Set standout mode to the state it should be in for
342 empty space inside windows. What this is,
343 depends on the user option inverse-video. */
346 tty_background_highlight (struct tty_display_info
*tty
)
349 tty_turn_on_highlight (tty
);
351 tty_turn_off_highlight (tty
);
354 /* Set standout mode to the mode specified for the text to be output. */
357 tty_highlight_if_desired (struct tty_display_info
*tty
)
360 tty_turn_on_highlight (tty
);
362 tty_turn_off_highlight (tty
);
366 /* Move cursor to row/column position VPOS/HPOS. HPOS/VPOS are
367 frame-relative coordinates. */
370 tty_cursor_to (struct frame
*f
, int vpos
, int hpos
)
372 struct tty_display_info
*tty
= FRAME_TTY (f
);
374 /* Detect the case where we are called from reset_sys_modes
375 and the costs have never been calculated. Do nothing. */
376 if (! tty
->costs_set
)
379 if (curY (tty
) == vpos
380 && curX (tty
) == hpos
)
382 if (!tty
->TF_standout_motion
)
383 tty_background_highlight (tty
);
384 if (!tty
->TF_insmode_motion
)
385 tty_turn_off_insert (tty
);
386 cmgoto (tty
, vpos
, hpos
);
389 /* Similar but don't take any account of the wasted characters. */
392 tty_raw_cursor_to (struct frame
*f
, int row
, int col
)
394 struct tty_display_info
*tty
= FRAME_TTY (f
);
396 if (curY (tty
) == row
397 && curX (tty
) == col
)
399 if (!tty
->TF_standout_motion
)
400 tty_background_highlight (tty
);
401 if (!tty
->TF_insmode_motion
)
402 tty_turn_off_insert (tty
);
403 cmgoto (tty
, row
, col
);
406 /* Erase operations */
408 /* Clear from cursor to end of frame on a termcap device. */
411 tty_clear_to_end (struct frame
*f
)
414 struct tty_display_info
*tty
= FRAME_TTY (f
);
416 if (tty
->TS_clr_to_bottom
)
418 tty_background_highlight (tty
);
419 OUTPUT (tty
, tty
->TS_clr_to_bottom
);
423 for (i
= curY (tty
); i
< FRAME_LINES (f
); i
++)
426 clear_end_of_line (f
, FRAME_COLS (f
));
431 /* Clear an entire termcap frame. */
434 tty_clear_frame (struct frame
*f
)
436 struct tty_display_info
*tty
= FRAME_TTY (f
);
438 if (tty
->TS_clr_frame
)
440 tty_background_highlight (tty
);
441 OUTPUT (tty
, tty
->TS_clr_frame
);
451 /* An implementation of clear_end_of_line for termcap frames.
453 Note that the cursor may be moved, on terminals lacking a `ce' string. */
456 tty_clear_end_of_line (struct frame
*f
, int first_unused_hpos
)
459 struct tty_display_info
*tty
= FRAME_TTY (f
);
461 /* Detect the case where we are called from reset_sys_modes
462 and the costs have never been calculated. Do nothing. */
463 if (! tty
->costs_set
)
466 if (curX (tty
) >= first_unused_hpos
)
468 tty_background_highlight (tty
);
469 if (tty
->TS_clr_line
)
471 OUTPUT1 (tty
, tty
->TS_clr_line
);
474 { /* have to do it the hard way */
475 tty_turn_off_insert (tty
);
477 /* Do not write in last row last col with Auto-wrap on. */
479 && curY (tty
) == FrameRows (tty
) - 1
480 && first_unused_hpos
== FrameCols (tty
))
483 for (i
= curX (tty
); i
< first_unused_hpos
; i
++)
486 fputc (' ', tty
->termscript
);
487 fputc (' ', tty
->output
);
489 cmplus (tty
, first_unused_hpos
- curX (tty
));
493 /* Buffers to store the source and result of code conversion for terminal. */
494 static unsigned char *encode_terminal_src
;
495 static unsigned char *encode_terminal_dst
;
496 /* Allocated sizes of the above buffers. */
497 static int encode_terminal_src_size
;
498 static int encode_terminal_dst_size
;
500 /* Encode SRC_LEN glyphs starting at SRC to terminal output codes.
501 Set CODING->produced to the byte-length of the resulting byte
502 sequence, and return a pointer to that byte sequence. */
505 encode_terminal_code (struct glyph
*src
, int src_len
, struct coding_system
*coding
)
507 struct glyph
*src_end
= src
+ src_len
;
509 int nchars
, nbytes
, required
;
510 register int tlen
= GLYPH_TABLE_LENGTH
;
511 register Lisp_Object
*tbase
= GLYPH_TABLE_BASE
;
512 Lisp_Object charset_list
;
514 /* Allocate sufficient size of buffer to store all characters in
515 multibyte-form. But, it may be enlarged on demand if
516 Vglyph_table contains a string or a composite glyph is
518 required
= MAX_MULTIBYTE_LENGTH
* src_len
;
519 if (encode_terminal_src_size
< required
)
521 if (encode_terminal_src
)
522 encode_terminal_src
= xrealloc (encode_terminal_src
, required
);
524 encode_terminal_src
= xmalloc (required
);
525 encode_terminal_src_size
= required
;
528 charset_list
= coding_charset_list (coding
);
530 buf
= encode_terminal_src
;
532 while (src
< src_end
)
534 if (src
->type
== COMPOSITE_GLYPH
)
536 struct composition
*cmp
IF_LINT (= NULL
);
537 Lisp_Object gstring
IF_LINT (= Qnil
);
540 nbytes
= buf
- encode_terminal_src
;
541 if (src
->u
.cmp
.automatic
)
543 gstring
= composition_gstring_from_id (src
->u
.cmp
.id
);
544 required
= src
->slice
.cmp
.to
+ 1 - src
->slice
.cmp
.from
;
548 cmp
= composition_table
[src
->u
.cmp
.id
];
549 required
= MAX_MULTIBYTE_LENGTH
* cmp
->glyph_len
;
552 if (encode_terminal_src_size
< nbytes
+ required
)
554 encode_terminal_src_size
= nbytes
+ required
;
555 encode_terminal_src
= xrealloc (encode_terminal_src
,
556 encode_terminal_src_size
);
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
);
578 if (char_charset (c
, charset_list
, NULL
))
580 if (CHAR_WIDTH (c
) == 0
581 && i
> 0 && COMPOSITION_GLYPH (cmp
, i
- 1) == '\t')
582 /* Should be left-padded */
584 buf
+= CHAR_STRING (' ', buf
);
590 buf
+= CHAR_STRING (c
, buf
);
594 /* We must skip glyphs to be padded for a wide character. */
595 else if (! CHAR_GLYPH_PADDING_P (*src
))
602 SET_GLYPH_FROM_CHAR_GLYPH (g
, src
[0]);
604 if (GLYPH_INVALID_P (g
) || GLYPH_SIMPLE_P (tbase
, tlen
, g
))
606 /* This glyph doesn't have an entry in Vglyph_table. */
611 /* This glyph has an entry in Vglyph_table,
612 so process any alias before testing for simpleness. */
613 GLYPH_FOLLOW_ALIASES (tbase
, tlen
, g
);
615 if (GLYPH_SIMPLE_P (tbase
, tlen
, g
))
616 /* We set the multi-byte form of a character in G
617 (that should be an ASCII character) at WORKBUF. */
620 /* We have a string in Vglyph_table. */
621 string
= tbase
[GLYPH_CHAR (g
)];
626 nbytes
= buf
- encode_terminal_src
;
627 if (encode_terminal_src_size
< nbytes
+ MAX_MULTIBYTE_LENGTH
)
629 encode_terminal_src_size
= nbytes
+ MAX_MULTIBYTE_LENGTH
;
630 encode_terminal_src
= xrealloc (encode_terminal_src
,
631 encode_terminal_src_size
);
632 buf
= encode_terminal_src
+ nbytes
;
635 || char_charset (c
, charset_list
, NULL
))
637 /* Store the multibyte form of C at BUF. */
638 buf
+= CHAR_STRING (c
, buf
);
643 /* C is not encodable. */
646 while (src
+ 1 < src_end
&& CHAR_GLYPH_PADDING_P (src
[1]))
656 if (! STRING_MULTIBYTE (string
))
657 string
= string_to_multibyte (string
);
658 nbytes
= buf
- encode_terminal_src
;
659 if (encode_terminal_src_size
< nbytes
+ SBYTES (string
))
661 encode_terminal_src_size
= nbytes
+ SBYTES (string
);
662 encode_terminal_src
= xrealloc (encode_terminal_src
,
663 encode_terminal_src_size
);
664 buf
= encode_terminal_src
+ nbytes
;
666 memcpy (buf
, SDATA (string
), SBYTES (string
));
667 buf
+= SBYTES (string
);
668 nchars
+= SCHARS (string
);
676 coding
->produced
= 0;
680 nbytes
= buf
- encode_terminal_src
;
681 coding
->source
= encode_terminal_src
;
682 if (encode_terminal_dst_size
== 0)
684 encode_terminal_dst_size
= encode_terminal_src_size
;
685 if (encode_terminal_dst
)
686 encode_terminal_dst
= xrealloc (encode_terminal_dst
,
687 encode_terminal_dst_size
);
689 encode_terminal_dst
= xmalloc (encode_terminal_dst_size
);
691 coding
->destination
= encode_terminal_dst
;
692 coding
->dst_bytes
= encode_terminal_dst_size
;
693 encode_coding_object (coding
, Qnil
, 0, 0, nchars
, nbytes
, Qnil
);
694 /* coding->destination may have been reallocated. */
695 encode_terminal_dst
= coding
->destination
;
696 encode_terminal_dst_size
= coding
->dst_bytes
;
698 return (encode_terminal_dst
);
703 /* An implementation of write_glyphs for termcap frames. */
706 tty_write_glyphs (struct frame
*f
, struct glyph
*string
, int len
)
708 unsigned char *conversion_buffer
;
709 struct coding_system
*coding
;
711 struct tty_display_info
*tty
= FRAME_TTY (f
);
713 tty_turn_off_insert (tty
);
714 tty_hide_cursor (tty
);
716 /* Don't dare write in last column of bottom line, if Auto-Wrap,
717 since that would scroll the whole frame on some terminals. */
720 && curY (tty
) + 1 == FRAME_LINES (f
)
721 && (curX (tty
) + len
) == FRAME_COLS (f
))
728 /* If terminal_coding does any conversion, use it, otherwise use
729 safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
730 because it always return 1 if the member src_multibyte is 1. */
731 coding
= (FRAME_TERMINAL_CODING (f
)->common_flags
& CODING_REQUIRE_ENCODING_MASK
732 ? FRAME_TERMINAL_CODING (f
) : &safe_terminal_coding
);
733 /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
735 coding
->mode
&= ~CODING_MODE_LAST_BLOCK
;
739 /* Identify a run of glyphs with the same face. */
740 int face_id
= string
->face_id
;
743 for (n
= 1; n
< len
; ++n
)
744 if (string
[n
].face_id
!= face_id
)
747 /* Turn appearance modes of the face of the run on. */
748 tty_highlight_if_desired (tty
);
749 turn_on_face (f
, face_id
);
752 /* This is the last run. */
753 coding
->mode
|= CODING_MODE_LAST_BLOCK
;
754 conversion_buffer
= encode_terminal_code (string
, n
, coding
);
755 if (coding
->produced
> 0)
758 fwrite (conversion_buffer
, 1, coding
->produced
, tty
->output
);
759 if (ferror (tty
->output
))
760 clearerr (tty
->output
);
762 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
;
969 register int i
= n
> 0 ? n
: -n
;
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_lines
= max (max_frame_lines
, FRAME_LINES (frame
));
1158 max_frame_cols
= max (max_frame_cols
, FRAME_COLS (frame
));
1160 if (char_ins_del_vector
!= 0)
1162 = (int *) xrealloc (char_ins_del_vector
,
1164 + 2 * max_frame_cols
* sizeof (int)));
1167 = (int *) xmalloc (sizeof (int)
1168 + 2 * max_frame_cols
* sizeof (int));
1170 memset (char_ins_del_vector
, 0,
1171 (sizeof (int) + 2 * max_frame_cols
* sizeof (int)));
1174 if (f
&& (!tty
->TS_ins_line
&& !tty
->TS_del_line
))
1175 do_line_insertion_deletion_costs (frame
,
1176 tty
->TS_rev_scroll
, tty
->TS_ins_multi_lines
,
1177 tty
->TS_fwd_scroll
, tty
->TS_del_multi_lines
,
1180 do_line_insertion_deletion_costs (frame
,
1181 tty
->TS_ins_line
, tty
->TS_ins_multi_lines
,
1182 tty
->TS_del_line
, tty
->TS_del_multi_lines
,
1185 calculate_ins_del_char_costs (frame
);
1187 /* Don't use TS_repeat if its padding is worse than sending the chars */
1188 if (tty
->TS_repeat
&& per_line_cost (tty
->TS_repeat
) * baud_rate
< 9000)
1189 tty
->RPov
= string_cost (tty
->TS_repeat
);
1191 tty
->RPov
= FRAME_COLS (frame
) * 2;
1193 cmcostinit (FRAME_TTY (frame
)); /* set up cursor motion costs */
1198 const char *cap
, *name
;
1201 /* Termcap capability names that correspond directly to X keysyms.
1202 Some of these (marked "terminfo") aren't supplied by old-style
1203 (Berkeley) termcap entries. They're listed in X keysym order;
1204 except we put the keypad keys first, so that if they clash with
1205 other keys (as on the IBM PC keyboard) they get overridden.
1208 static const struct fkey_table keys
[] =
1210 {"kh", "home"}, /* termcap */
1211 {"kl", "left"}, /* termcap */
1212 {"ku", "up"}, /* termcap */
1213 {"kr", "right"}, /* termcap */
1214 {"kd", "down"}, /* termcap */
1215 {"%8", "prior"}, /* terminfo */
1216 {"%5", "next"}, /* terminfo */
1217 {"@7", "end"}, /* terminfo */
1218 {"@1", "begin"}, /* terminfo */
1219 {"*6", "select"}, /* terminfo */
1220 {"%9", "print"}, /* terminfo */
1221 {"@4", "execute"}, /* terminfo --- actually the `command' key */
1223 * "insert" --- see below
1225 {"&8", "undo"}, /* terminfo */
1226 {"%0", "redo"}, /* terminfo */
1227 {"%7", "menu"}, /* terminfo --- actually the `options' key */
1228 {"@0", "find"}, /* terminfo */
1229 {"@2", "cancel"}, /* terminfo */
1230 {"%1", "help"}, /* terminfo */
1232 * "break" goes here, but can't be reliably intercepted with termcap
1234 {"&4", "reset"}, /* terminfo --- actually `restart' */
1236 * "system" and "user" --- no termcaps
1238 {"kE", "clearline"}, /* terminfo */
1239 {"kA", "insertline"}, /* terminfo */
1240 {"kL", "deleteline"}, /* terminfo */
1241 {"kI", "insertchar"}, /* terminfo */
1242 {"kD", "deletechar"}, /* terminfo */
1243 {"kB", "backtab"}, /* terminfo */
1245 * "kp_backtab", "kp-space", "kp-tab" --- no termcaps
1247 {"@8", "kp-enter"}, /* terminfo */
1249 * "kp-f1", "kp-f2", "kp-f3" "kp-f4",
1250 * "kp-multiply", "kp-add", "kp-separator",
1251 * "kp-subtract", "kp-decimal", "kp-divide", "kp-0";
1252 * --- no termcaps for any of these.
1254 {"K4", "kp-1"}, /* terminfo */
1256 * "kp-2" --- no termcap
1258 {"K5", "kp-3"}, /* terminfo */
1260 * "kp-4" --- no termcap
1262 {"K2", "kp-5"}, /* terminfo */
1264 * "kp-6" --- no termcap
1266 {"K1", "kp-7"}, /* terminfo */
1268 * "kp-8" --- no termcap
1270 {"K3", "kp-9"}, /* terminfo */
1272 * "kp-equal" --- no termcap
1284 {"&0", "S-cancel"}, /*shifted cancel key*/
1285 {"&9", "S-begin"}, /*shifted begin key*/
1286 {"*0", "S-find"}, /*shifted find key*/
1287 {"*1", "S-execute"}, /*shifted execute? actually shifted command key*/
1288 {"*4", "S-delete"}, /*shifted delete-character key*/
1289 {"*7", "S-end"}, /*shifted end key*/
1290 {"*8", "S-clearline"}, /*shifted clear-to end-of-line key*/
1291 {"#1", "S-help"}, /*shifted help key*/
1292 {"#2", "S-home"}, /*shifted home key*/
1293 {"#3", "S-insert"}, /*shifted insert-character key*/
1294 {"#4", "S-left"}, /*shifted left-arrow key*/
1295 {"%d", "S-menu"}, /*shifted menu? actually shifted options key*/
1296 {"%c", "S-next"}, /*shifted next key*/
1297 {"%e", "S-prior"}, /*shifted previous key*/
1298 {"%f", "S-print"}, /*shifted print key*/
1299 {"%g", "S-redo"}, /*shifted redo key*/
1300 {"%i", "S-right"}, /*shifted right-arrow key*/
1301 {"!3", "S-undo"} /*shifted undo key*/
1305 static char **term_get_fkeys_address
;
1306 static KBOARD
*term_get_fkeys_kboard
;
1307 static Lisp_Object
term_get_fkeys_1 (void);
1309 /* Find the escape codes sent by the function keys for Vinput_decode_map.
1310 This function scans the termcap function key sequence entries, and
1311 adds entries to Vinput_decode_map for each function key it finds. */
1314 term_get_fkeys (char **address
, KBOARD
*kboard
)
1316 /* We run the body of the function (term_get_fkeys_1) and ignore all Lisp
1317 errors during the call. The only errors should be from Fdefine_key
1318 when given a key sequence containing an invalid prefix key. If the
1319 termcap defines function keys which use a prefix that is already bound
1320 to a command by the default bindings, we should silently ignore that
1321 function key specification, rather than giving the user an error and
1322 refusing to run at all on such a terminal. */
1324 term_get_fkeys_address
= address
;
1325 term_get_fkeys_kboard
= kboard
;
1326 internal_condition_case (term_get_fkeys_1
, Qerror
, Fidentity
);
1330 term_get_fkeys_1 (void)
1334 char **address
= term_get_fkeys_address
;
1335 KBOARD
*kboard
= term_get_fkeys_kboard
;
1337 /* This can happen if CANNOT_DUMP or with strange options. */
1338 if (!KEYMAPP (KVAR (kboard
, Vinput_decode_map
)))
1339 KVAR (kboard
, Vinput_decode_map
) = Fmake_sparse_keymap (Qnil
);
1341 for (i
= 0; i
< (sizeof (keys
)/sizeof (keys
[0])); i
++)
1343 char *sequence
= tgetstr (keys
[i
].cap
, address
);
1345 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (sequence
),
1346 Fmake_vector (make_number (1),
1347 intern (keys
[i
].name
)));
1350 /* The uses of the "k0" capability are inconsistent; sometimes it
1351 describes F10, whereas othertimes it describes F0 and "k;" describes F10.
1352 We will attempt to politely accommodate both systems by testing for
1353 "k;", and if it is present, assuming that "k0" denotes F0, otherwise F10.
1356 const char *k_semi
= tgetstr ("k;", address
);
1357 const char *k0
= tgetstr ("k0", address
);
1358 const char *k0_name
= "f10";
1363 /* Define f0 first, so that f10 takes precedence in case the
1364 key sequences happens to be the same. */
1365 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (k0
),
1366 Fmake_vector (make_number (1), intern ("f0")));
1367 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (k_semi
),
1368 Fmake_vector (make_number (1), intern ("f10")));
1371 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (k0
),
1372 Fmake_vector (make_number (1), intern (k0_name
)));
1375 /* Set up cookies for numbered function keys above f10. */
1377 char fcap
[3], fkey
[4];
1379 fcap
[0] = 'F'; fcap
[2] = '\0';
1380 for (i
= 11; i
< 64; i
++)
1383 fcap
[1] = '1' + i
- 11;
1385 fcap
[1] = 'A' + i
- 20;
1387 fcap
[1] = 'a' + i
- 46;
1390 char *sequence
= tgetstr (fcap
, address
);
1393 sprintf (fkey
, "f%d", i
);
1394 Fdefine_key (KVAR (kboard
, Vinput_decode_map
), build_string (sequence
),
1395 Fmake_vector (make_number (1),
1403 * Various mappings to try and get a better fit.
1406 #define CONDITIONAL_REASSIGN(cap1, cap2, sym) \
1407 if (!tgetstr (cap1, address)) \
1409 char *sequence = tgetstr (cap2, address); \
1411 Fdefine_key (KVAR (kboard, Vinput_decode_map), build_string (sequence), \
1412 Fmake_vector (make_number (1), \
1416 /* if there's no key_next keycap, map key_npage to `next' keysym */
1417 CONDITIONAL_REASSIGN ("%5", "kN", "next");
1418 /* if there's no key_prev keycap, map key_ppage to `previous' keysym */
1419 CONDITIONAL_REASSIGN ("%8", "kP", "prior");
1420 /* if there's no key_dc keycap, map key_ic to `insert' keysym */
1421 CONDITIONAL_REASSIGN ("kD", "kI", "insert");
1422 /* if there's no key_end keycap, map key_ll to 'end' keysym */
1423 CONDITIONAL_REASSIGN ("@7", "kH", "end");
1425 /* IBM has their own non-standard dialect of terminfo.
1426 If the standard name isn't found, try the IBM name. */
1427 CONDITIONAL_REASSIGN ("kB", "KO", "backtab");
1428 CONDITIONAL_REASSIGN ("@4", "kJ", "execute"); /* actually "action" */
1429 CONDITIONAL_REASSIGN ("@4", "kc", "execute"); /* actually "command" */
1430 CONDITIONAL_REASSIGN ("%7", "ki", "menu");
1431 CONDITIONAL_REASSIGN ("@7", "kw", "end");
1432 CONDITIONAL_REASSIGN ("F1", "k<", "f11");
1433 CONDITIONAL_REASSIGN ("F2", "k>", "f12");
1434 CONDITIONAL_REASSIGN ("%1", "kq", "help");
1435 CONDITIONAL_REASSIGN ("*6", "kU", "select");
1436 #undef CONDITIONAL_REASSIGN
1441 #endif /* not DOS_NT */
1444 /***********************************************************************
1445 Character Display Information
1446 ***********************************************************************/
1447 static void append_glyph (struct it
*);
1448 static void produce_stretch_glyph (struct it
*);
1449 static void append_composite_glyph (struct it
*);
1450 static void produce_composite_glyph (struct it
*);
1451 static void append_glyphless_glyph (struct it
*, int, const char *);
1452 static void produce_glyphless_glyph (struct it
*, int, Lisp_Object
);
1454 /* Append glyphs to IT's glyph_row. Called from produce_glyphs for
1455 terminal frames if IT->glyph_row != NULL. IT->char_to_display is
1456 the character for which to produce glyphs; IT->face_id contains the
1457 character's face. Padding glyphs are appended if IT->c has a
1458 IT->pixel_width > 1. */
1461 append_glyph (struct it
*it
)
1463 struct glyph
*glyph
, *end
;
1466 xassert (it
->glyph_row
);
1467 glyph
= (it
->glyph_row
->glyphs
[it
->area
]
1468 + it
->glyph_row
->used
[it
->area
]);
1469 end
= it
->glyph_row
->glyphs
[1 + it
->area
];
1471 /* If the glyph row is reversed, we need to prepend the glyph rather
1473 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
1476 int move_by
= it
->pixel_width
;
1478 /* Make room for the new glyphs. */
1479 if (move_by
> end
- glyph
) /* don't overstep end of this area */
1480 move_by
= end
- glyph
;
1481 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
1483 glyph
= it
->glyph_row
->glyphs
[it
->area
];
1484 end
= glyph
+ move_by
;
1487 /* BIDI Note: we put the glyphs of a "multi-pixel" character left to
1488 right, even in the REVERSED_P case, since (a) all of its u.ch are
1489 identical, and (b) the PADDING_P flag needs to be set for the
1490 leftmost one, because we write to the terminal left-to-right. */
1492 i
< it
->pixel_width
&& glyph
< end
;
1495 glyph
->type
= CHAR_GLYPH
;
1496 glyph
->pixel_width
= 1;
1497 glyph
->u
.ch
= it
->char_to_display
;
1498 glyph
->face_id
= it
->face_id
;
1499 glyph
->padding_p
= i
> 0;
1500 glyph
->charpos
= CHARPOS (it
->position
);
1501 glyph
->object
= it
->object
;
1504 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
1505 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
1507 glyph
->bidi_type
= it
->bidi_it
.type
;
1511 glyph
->resolved_level
= 0;
1512 glyph
->bidi_type
= UNKNOWN_BT
;
1515 ++it
->glyph_row
->used
[it
->area
];
1520 /* Produce glyphs for the display element described by IT. *IT
1521 specifies what we want to produce a glyph for (character, image, ...),
1522 and where in the glyph matrix we currently are (glyph row and hpos).
1523 produce_glyphs fills in output fields of *IT with information such as the
1524 pixel width and height of a character, and maybe output actual glyphs at
1525 the same time if IT->glyph_row is non-null. For an overview, see
1526 the explanation in dispextern.h, before the definition of the
1527 display_element_type enumeration.
1529 produce_glyphs also stores the result of glyph width, ascent
1530 etc. computations in *IT.
1532 IT->glyph_row may be null, in which case produce_glyphs does not
1533 actually fill in the glyphs. This is used in the move_* functions
1534 in xdisp.c for text width and height computations.
1536 Callers usually don't call produce_glyphs directly;
1537 instead they use the macro PRODUCE_GLYPHS. */
1540 produce_glyphs (struct it
*it
)
1542 /* If a hook is installed, let it do the work. */
1544 /* Nothing but characters are supported on terminal frames. */
1545 xassert (it
->what
== IT_CHARACTER
1546 || it
->what
== IT_COMPOSITION
1547 || it
->what
== IT_STRETCH
);
1549 if (it
->what
== IT_STRETCH
)
1551 produce_stretch_glyph (it
);
1555 if (it
->what
== IT_COMPOSITION
)
1557 produce_composite_glyph (it
);
1561 if (it
->what
== IT_GLYPHLESS
)
1563 produce_glyphless_glyph (it
, 0, Qnil
);
1567 if (it
->char_to_display
>= 040 && it
->char_to_display
< 0177)
1569 it
->pixel_width
= it
->nglyphs
= 1;
1573 else if (it
->char_to_display
== '\n')
1574 it
->pixel_width
= it
->nglyphs
= 0;
1575 else if (it
->char_to_display
== '\t')
1577 int absolute_x
= (it
->current_x
1578 + it
->continuation_lines_width
);
1580 = (((1 + absolute_x
+ it
->tab_width
- 1)
1585 /* If part of the TAB has been displayed on the previous line
1586 which is continued now, continuation_lines_width will have
1587 been incremented already by the part that fitted on the
1588 continued line. So, we will get the right number of spaces
1590 nspaces
= next_tab_x
- absolute_x
;
1596 it
->char_to_display
= ' ';
1597 it
->pixel_width
= it
->len
= 1;
1603 it
->pixel_width
= nspaces
;
1604 it
->nglyphs
= nspaces
;
1606 else if (CHAR_BYTE8_P (it
->char_to_display
))
1608 /* Coming here means that we must send the raw 8-bit byte as is
1609 to the terminal. Although there's no way to know how many
1610 columns it occupies on a screen, it is a good assumption that
1611 a single byte code has 1-column width. */
1612 it
->pixel_width
= it
->nglyphs
= 1;
1618 Lisp_Object charset_list
= FRAME_TERMINAL (it
->f
)->charset_list
;
1620 if (char_charset (it
->char_to_display
, charset_list
, NULL
))
1622 it
->pixel_width
= CHAR_WIDTH (it
->char_to_display
);
1623 it
->nglyphs
= it
->pixel_width
;
1629 Lisp_Object acronym
= lookup_glyphless_char_display (-1, it
);
1631 xassert (it
->what
== IT_GLYPHLESS
);
1632 produce_glyphless_glyph (it
, 1, acronym
);
1637 /* Advance current_x by the pixel width as a convenience for
1639 if (it
->area
== TEXT_AREA
)
1640 it
->current_x
+= it
->pixel_width
;
1641 it
->ascent
= it
->max_ascent
= it
->phys_ascent
= it
->max_phys_ascent
= 0;
1642 it
->descent
= it
->max_descent
= it
->phys_descent
= it
->max_phys_descent
= 1;
1646 /* Produce a stretch glyph for iterator IT. IT->object is the value
1647 of the glyph property displayed. The value must be a list
1648 `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
1651 1. `:width WIDTH' specifies that the space should be WIDTH *
1652 canonical char width wide. WIDTH may be an integer or floating
1655 2. `:align-to HPOS' specifies that the space should be wide enough
1656 to reach HPOS, a value in canonical character units. */
1659 produce_stretch_glyph (struct it
*it
)
1661 /* (space :width WIDTH ...) */
1662 Lisp_Object prop
, plist
;
1663 int width
= 0, align_to
= -1;
1664 int zero_width_ok_p
= 0;
1667 /* List should start with `space'. */
1668 xassert (CONSP (it
->object
) && EQ (XCAR (it
->object
), Qspace
));
1669 plist
= XCDR (it
->object
);
1671 /* Compute the width of the stretch. */
1672 if ((prop
= Fplist_get (plist
, QCwidth
), !NILP (prop
))
1673 && calc_pixel_width_or_height (&tem
, it
, prop
, 0, 1, 0))
1675 /* Absolute width `:width WIDTH' specified and valid. */
1676 zero_width_ok_p
= 1;
1677 width
= (int)(tem
+ 0.5);
1679 else if ((prop
= Fplist_get (plist
, QCalign_to
), !NILP (prop
))
1680 && calc_pixel_width_or_height (&tem
, it
, prop
, 0, 1, &align_to
))
1682 if (it
->glyph_row
== NULL
|| !it
->glyph_row
->mode_line_p
)
1683 align_to
= (align_to
< 0
1685 : align_to
- window_box_left_offset (it
->w
, TEXT_AREA
));
1686 else if (align_to
< 0)
1687 align_to
= window_box_left_offset (it
->w
, TEXT_AREA
);
1688 width
= max (0, (int)(tem
+ 0.5) + align_to
- it
->current_x
);
1689 zero_width_ok_p
= 1;
1692 /* Nothing specified -> width defaults to canonical char width. */
1693 width
= FRAME_COLUMN_WIDTH (it
->f
);
1695 if (width
<= 0 && (width
< 0 || !zero_width_ok_p
))
1698 if (width
> 0 && it
->line_wrap
!= TRUNCATE
1699 && it
->current_x
+ width
> it
->last_visible_x
)
1700 width
= it
->last_visible_x
- it
->current_x
- 1;
1702 if (width
> 0 && it
->glyph_row
)
1704 Lisp_Object o_object
= it
->object
;
1705 Lisp_Object object
= it
->stack
[it
->sp
- 1].string
;
1708 if (!STRINGP (object
))
1709 object
= it
->w
->buffer
;
1710 it
->object
= object
;
1711 it
->char_to_display
= ' ';
1712 it
->pixel_width
= it
->len
= 1;
1715 it
->object
= o_object
;
1717 it
->pixel_width
= width
;
1718 it
->nglyphs
= width
;
1722 /* Append glyphs to IT's glyph_row for the composition IT->cmp_id.
1723 Called from produce_composite_glyph for terminal frames if
1724 IT->glyph_row != NULL. IT->face_id contains the character's
1728 append_composite_glyph (struct it
*it
)
1730 struct glyph
*glyph
;
1732 xassert (it
->glyph_row
);
1733 glyph
= it
->glyph_row
->glyphs
[it
->area
] + it
->glyph_row
->used
[it
->area
];
1734 if (glyph
< it
->glyph_row
->glyphs
[1 + it
->area
])
1736 /* If the glyph row is reversed, we need to prepend the glyph
1737 rather than append it. */
1738 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
1742 /* Make room for the new glyph. */
1743 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
1745 glyph
= it
->glyph_row
->glyphs
[it
->area
];
1747 glyph
->type
= COMPOSITE_GLYPH
;
1748 glyph
->pixel_width
= it
->pixel_width
;
1749 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
1750 if (it
->cmp_it
.ch
< 0)
1752 glyph
->u
.cmp
.automatic
= 0;
1753 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
1757 glyph
->u
.cmp
.automatic
= 1;
1758 glyph
->u
.cmp
.id
= it
->cmp_it
.id
;
1759 glyph
->slice
.cmp
.from
= it
->cmp_it
.from
;
1760 glyph
->slice
.cmp
.to
= it
->cmp_it
.to
- 1;
1763 glyph
->face_id
= it
->face_id
;
1764 glyph
->padding_p
= 0;
1765 glyph
->charpos
= CHARPOS (it
->position
);
1766 glyph
->object
= it
->object
;
1769 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
1770 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
1772 glyph
->bidi_type
= it
->bidi_it
.type
;
1776 glyph
->resolved_level
= 0;
1777 glyph
->bidi_type
= UNKNOWN_BT
;
1780 ++it
->glyph_row
->used
[it
->area
];
1786 /* Produce a composite glyph for iterator IT. IT->cmp_id is the ID of
1787 the composition. We simply produces components of the composition
1788 assuming that the terminal has a capability to layout/render it
1792 produce_composite_glyph (struct it
*it
)
1794 if (it
->cmp_it
.ch
< 0)
1796 struct composition
*cmp
= composition_table
[it
->cmp_it
.id
];
1798 it
->pixel_width
= cmp
->width
;
1802 Lisp_Object gstring
= composition_gstring_from_id (it
->cmp_it
.id
);
1804 it
->pixel_width
= composition_gstring_width (gstring
, it
->cmp_it
.from
,
1805 it
->cmp_it
.to
, NULL
);
1809 append_composite_glyph (it
);
1813 /* Append a glyph for a glyphless character to IT->glyph_row. FACE_ID
1814 is a face ID to be used for the glyph. What is actually appended
1815 are glyphs of type CHAR_GLYPH whose characters are in STR (which
1816 comes from it->nglyphs bytes). */
1819 append_glyphless_glyph (struct it
*it
, int face_id
, const char *str
)
1821 struct glyph
*glyph
, *end
;
1824 xassert (it
->glyph_row
);
1825 glyph
= it
->glyph_row
->glyphs
[it
->area
] + it
->glyph_row
->used
[it
->area
];
1826 end
= it
->glyph_row
->glyphs
[1 + it
->area
];
1828 /* If the glyph row is reversed, we need to prepend the glyph rather
1830 if (it
->glyph_row
->reversed_p
&& it
->area
== TEXT_AREA
)
1833 int move_by
= it
->pixel_width
;
1835 /* Make room for the new glyphs. */
1836 if (move_by
> end
- glyph
) /* don't overstep end of this area */
1837 move_by
= end
- glyph
;
1838 for (g
= glyph
- 1; g
>= it
->glyph_row
->glyphs
[it
->area
]; g
--)
1840 glyph
= it
->glyph_row
->glyphs
[it
->area
];
1841 end
= glyph
+ move_by
;
1846 glyph
->type
= CHAR_GLYPH
;
1847 glyph
->pixel_width
= 1;
1848 glyph
->face_id
= face_id
;
1849 glyph
->padding_p
= 0;
1850 glyph
->charpos
= CHARPOS (it
->position
);
1851 glyph
->object
= it
->object
;
1854 glyph
->resolved_level
= it
->bidi_it
.resolved_level
;
1855 if ((it
->bidi_it
.type
& 7) != it
->bidi_it
.type
)
1857 glyph
->bidi_type
= it
->bidi_it
.type
;
1861 glyph
->resolved_level
= 0;
1862 glyph
->bidi_type
= UNKNOWN_BT
;
1865 /* BIDI Note: we put the glyphs of characters left to right, even in
1866 the REVERSED_P case because we write to the terminal
1868 for (i
= 0; i
< it
->nglyphs
&& glyph
< end
; ++i
)
1871 glyph
[0] = glyph
[-1];
1872 glyph
->u
.ch
= str
[i
];
1873 ++it
->glyph_row
->used
[it
->area
];
1878 /* Produce glyphs for a glyphless character for iterator IT.
1879 IT->glyphless_method specifies which method to use for displaying
1880 the character. See the description of enum
1881 glyphless_display_method in dispextern.h for the details.
1883 FOR_NO_FONT is nonzero if and only if this is for a character that
1884 is not supproted by the coding system of the terminal. ACRONYM, if
1885 non-nil, is an acronym string for the character.
1887 The glyphs actually produced are of type CHAR_GLYPH. */
1890 produce_glyphless_glyph (struct it
*it
, int for_no_font
, Lisp_Object acronym
)
1895 char const *str
= " ";
1897 /* Get a face ID for the glyph by utilizing a cache (the same way as
1898 done for `escape-glyph' in get_next_display_element). */
1899 if (it
->f
== last_glyphless_glyph_frame
1900 && it
->face_id
== last_glyphless_glyph_face_id
)
1902 face_id
= last_glyphless_glyph_merged_face_id
;
1906 /* Merge the `glyphless-char' face into the current face. */
1907 face_id
= merge_faces (it
->f
, Qglyphless_char
, 0, it
->face_id
);
1908 last_glyphless_glyph_frame
= it
->f
;
1909 last_glyphless_glyph_face_id
= it
->face_id
;
1910 last_glyphless_glyph_merged_face_id
= face_id
;
1913 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_THIN_SPACE
)
1915 /* As there's no way to produce a thin space, we produce a space
1916 of canonical width. */
1919 else if (it
->glyphless_method
== GLYPHLESS_DISPLAY_EMPTY_BOX
)
1921 len
= CHAR_WIDTH (it
->c
);
1926 sprintf (buf
, "[%.*s]", len
, str
);
1932 if (it
->glyphless_method
== GLYPHLESS_DISPLAY_ACRONYM
)
1934 if (! STRINGP (acronym
) && CHAR_TABLE_P (Vglyphless_char_display
))
1935 acronym
= CHAR_TABLE_REF (Vglyphless_char_display
, it
->c
);
1937 str
= STRINGP (acronym
) ? SSDATA (acronym
) : "";
1938 for (len
= 0; len
< 6 && str
[len
] && ASCII_BYTE_P (str
[len
]); len
++)
1939 buf
[1 + len
] = str
[len
];
1945 xassert (it
->glyphless_method
== GLYPHLESS_DISPLAY_HEX_CODE
);
1946 len
= (it
->c
< 0x10000 ? sprintf (buf
, "\\u%04X", it
->c
)
1947 : it
->c
<= MAX_UNICODE_CHAR
? sprintf (buf
, "\\U%06X", it
->c
)
1948 : sprintf (buf
, "\\x%06X", it
->c
));
1953 it
->pixel_width
= len
;
1955 if (len
> 0 && it
->glyph_row
)
1956 append_glyphless_glyph (it
, face_id
, str
);
1960 /* Get information about special display element WHAT in an
1961 environment described by IT. WHAT is one of IT_TRUNCATION or
1962 IT_CONTINUATION. Maybe produce glyphs for WHAT if IT has a
1963 non-null glyph_row member. This function ensures that fields like
1964 face_id, c, len of IT are left untouched. */
1967 produce_special_glyphs (struct it
*it
, enum display_element_type what
)
1975 temp_it
.what
= IT_CHARACTER
;
1977 temp_it
.object
= make_number (0);
1978 memset (&temp_it
.current
, 0, sizeof temp_it
.current
);
1980 if (what
== IT_CONTINUATION
)
1982 /* Continuation glyph. For R2L lines, we mirror it by hand. */
1983 if (it
->bidi_it
.paragraph_dir
== R2L
)
1984 SET_GLYPH_FROM_CHAR (glyph
, '/');
1986 SET_GLYPH_FROM_CHAR (glyph
, '\\');
1988 && (gc
= DISP_CONTINUE_GLYPH (it
->dp
), GLYPH_CODE_P (gc
))
1989 && GLYPH_CODE_CHAR_VALID_P (gc
))
1991 /* FIXME: Should we mirror GC for R2L lines? */
1992 SET_GLYPH_FROM_GLYPH_CODE (glyph
, gc
);
1993 spec_glyph_lookup_face (XWINDOW (it
->window
), &glyph
);
1996 else if (what
== IT_TRUNCATION
)
1998 /* Truncation glyph. */
1999 SET_GLYPH_FROM_CHAR (glyph
, '$');
2001 && (gc
= DISP_TRUNC_GLYPH (it
->dp
), GLYPH_CODE_P (gc
))
2002 && GLYPH_CODE_CHAR_VALID_P (gc
))
2004 /* FIXME: Should we mirror GC for R2L lines? */
2005 SET_GLYPH_FROM_GLYPH_CODE (glyph
, gc
);
2006 spec_glyph_lookup_face (XWINDOW (it
->window
), &glyph
);
2012 temp_it
.c
= temp_it
.char_to_display
= GLYPH_CHAR (glyph
);
2013 temp_it
.face_id
= GLYPH_FACE (glyph
);
2014 temp_it
.len
= CHAR_BYTES (temp_it
.c
);
2016 produce_glyphs (&temp_it
);
2017 it
->pixel_width
= temp_it
.pixel_width
;
2018 it
->nglyphs
= temp_it
.pixel_width
;
2023 /***********************************************************************
2025 ***********************************************************************/
2027 /* Value is non-zero if attribute ATTR may be used. ATTR should be
2028 one of the enumerators from enum no_color_bit, or a bit set built
2029 from them. Some display attributes may not be used together with
2030 color; the termcap capability `NC' specifies which ones. */
2032 #define MAY_USE_WITH_COLORS_P(tty, ATTR) \
2033 (tty->TN_max_colors > 0 \
2034 ? (tty->TN_no_color_video & (ATTR)) == 0 \
2037 /* Turn appearances of face FACE_ID on tty frame F on.
2038 FACE_ID is a realized face ID number, in the face cache. */
2041 turn_on_face (struct frame
*f
, int face_id
)
2043 struct face
*face
= FACE_FROM_ID (f
, face_id
);
2044 long fg
= face
->foreground
;
2045 long bg
= face
->background
;
2046 struct tty_display_info
*tty
= FRAME_TTY (f
);
2048 /* Do this first because TS_end_standout_mode may be the same
2049 as TS_exit_attribute_mode, which turns all appearances off. */
2050 if (MAY_USE_WITH_COLORS_P (tty
, NC_REVERSE
))
2052 if (tty
->TN_max_colors
> 0)
2054 if (fg
>= 0 && bg
>= 0)
2056 /* If the terminal supports colors, we can set them
2057 below without using reverse video. The face's fg
2058 and bg colors are set as they should appear on
2059 the screen, i.e. they take the inverse-video'ness
2060 of the face already into account. */
2062 else if (inverse_video
)
2064 if (fg
== FACE_TTY_DEFAULT_FG_COLOR
2065 || bg
== FACE_TTY_DEFAULT_BG_COLOR
)
2066 tty_toggle_highlight (tty
);
2070 if (fg
== FACE_TTY_DEFAULT_BG_COLOR
2071 || bg
== FACE_TTY_DEFAULT_FG_COLOR
)
2072 tty_toggle_highlight (tty
);
2077 /* If we can't display colors, use reverse video
2078 if the face specifies that. */
2081 if (fg
== FACE_TTY_DEFAULT_FG_COLOR
2082 || bg
== FACE_TTY_DEFAULT_BG_COLOR
)
2083 tty_toggle_highlight (tty
);
2087 if (fg
== FACE_TTY_DEFAULT_BG_COLOR
2088 || bg
== FACE_TTY_DEFAULT_FG_COLOR
)
2089 tty_toggle_highlight (tty
);
2094 if (face
->tty_bold_p
&& MAY_USE_WITH_COLORS_P (tty
, NC_BOLD
))
2095 OUTPUT1_IF (tty
, tty
->TS_enter_bold_mode
);
2097 if (face
->tty_dim_p
&& MAY_USE_WITH_COLORS_P (tty
, NC_DIM
))
2098 OUTPUT1_IF (tty
, tty
->TS_enter_dim_mode
);
2100 /* Alternate charset and blinking not yet used. */
2101 if (face
->tty_alt_charset_p
2102 && MAY_USE_WITH_COLORS_P (tty
, NC_ALT_CHARSET
))
2103 OUTPUT1_IF (tty
, tty
->TS_enter_alt_charset_mode
);
2105 if (face
->tty_blinking_p
2106 && MAY_USE_WITH_COLORS_P (tty
, NC_BLINK
))
2107 OUTPUT1_IF (tty
, tty
->TS_enter_blink_mode
);
2109 if (face
->tty_underline_p
&& MAY_USE_WITH_COLORS_P (tty
, NC_UNDERLINE
))
2110 OUTPUT1_IF (tty
, tty
->TS_enter_underline_mode
);
2112 if (tty
->TN_max_colors
> 0)
2117 ts
= tty
->standout_mode
? tty
->TS_set_background
: tty
->TS_set_foreground
;
2120 p
= tparam (ts
, NULL
, 0, (int) fg
, 0, 0, 0);
2125 ts
= tty
->standout_mode
? tty
->TS_set_foreground
: tty
->TS_set_background
;
2128 p
= tparam (ts
, NULL
, 0, (int) bg
, 0, 0, 0);
2136 /* Turn off appearances of face FACE_ID on tty frame F. */
2139 turn_off_face (struct frame
*f
, int face_id
)
2141 struct face
*face
= FACE_FROM_ID (f
, face_id
);
2142 struct tty_display_info
*tty
= FRAME_TTY (f
);
2144 xassert (face
!= NULL
);
2146 if (tty
->TS_exit_attribute_mode
)
2148 /* Capability "me" will turn off appearance modes double-bright,
2149 half-bright, reverse-video, standout, underline. It may or
2150 may not turn off alt-char-mode. */
2151 if (face
->tty_bold_p
2153 || face
->tty_reverse_p
2154 || face
->tty_alt_charset_p
2155 || face
->tty_blinking_p
2156 || face
->tty_underline_p
)
2158 OUTPUT1_IF (tty
, tty
->TS_exit_attribute_mode
);
2159 if (strcmp (tty
->TS_exit_attribute_mode
, tty
->TS_end_standout_mode
) == 0)
2160 tty
->standout_mode
= 0;
2163 if (face
->tty_alt_charset_p
)
2164 OUTPUT_IF (tty
, tty
->TS_exit_alt_charset_mode
);
2168 /* If we don't have "me" we can only have those appearances
2169 that have exit sequences defined. */
2170 if (face
->tty_alt_charset_p
)
2171 OUTPUT_IF (tty
, tty
->TS_exit_alt_charset_mode
);
2173 if (face
->tty_underline_p
)
2174 OUTPUT_IF (tty
, tty
->TS_exit_underline_mode
);
2177 /* Switch back to default colors. */
2178 if (tty
->TN_max_colors
> 0
2179 && ((face
->foreground
!= FACE_TTY_DEFAULT_COLOR
2180 && face
->foreground
!= FACE_TTY_DEFAULT_FG_COLOR
)
2181 || (face
->background
!= FACE_TTY_DEFAULT_COLOR
2182 && face
->background
!= FACE_TTY_DEFAULT_BG_COLOR
)))
2183 OUTPUT1_IF (tty
, tty
->TS_orig_pair
);
2187 /* Return non-zero if the terminal on frame F supports all of the
2188 capabilities in CAPS simultaneously, with foreground and background
2189 colors FG and BG. */
2192 tty_capable_p (struct tty_display_info
*tty
, unsigned int caps
,
2193 unsigned long fg
, unsigned long bg
)
2195 #define TTY_CAPABLE_P_TRY(tty, cap, TS, NC_bit) \
2196 if ((caps & (cap)) && (!(TS) || !MAY_USE_WITH_COLORS_P(tty, NC_bit))) \
2199 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_INVERSE
, tty
->TS_standout_mode
, NC_REVERSE
);
2200 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_UNDERLINE
, tty
->TS_enter_underline_mode
, NC_UNDERLINE
);
2201 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_BOLD
, tty
->TS_enter_bold_mode
, NC_BOLD
);
2202 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_DIM
, tty
->TS_enter_dim_mode
, NC_DIM
);
2203 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_BLINK
, tty
->TS_enter_blink_mode
, NC_BLINK
);
2204 TTY_CAPABLE_P_TRY (tty
, TTY_CAP_ALT_CHARSET
, tty
->TS_enter_alt_charset_mode
, NC_ALT_CHARSET
);
2210 /* Return non-zero if the terminal is capable to display colors. */
2212 DEFUN ("tty-display-color-p", Ftty_display_color_p
, Stty_display_color_p
,
2214 doc
: /* Return non-nil if the tty device TERMINAL can display colors.
2216 TERMINAL can be a terminal object, a frame, or nil (meaning the
2217 selected frame's terminal). This function always returns nil if
2218 TERMINAL does not refer to a text-only terminal. */)
2219 (Lisp_Object terminal
)
2221 struct terminal
*t
= get_tty_terminal (terminal
, 0);
2225 return t
->display_info
.tty
->TN_max_colors
> 0 ? Qt
: Qnil
;
2228 /* Return the number of supported colors. */
2229 DEFUN ("tty-display-color-cells", Ftty_display_color_cells
,
2230 Stty_display_color_cells
, 0, 1, 0,
2231 doc
: /* Return the number of colors supported by the tty device TERMINAL.
2233 TERMINAL can be a terminal object, a frame, or nil (meaning the
2234 selected frame's terminal). This function always returns 0 if
2235 TERMINAL does not refer to a text-only terminal. */)
2236 (Lisp_Object terminal
)
2238 struct terminal
*t
= get_tty_terminal (terminal
, 0);
2240 return make_number (0);
2242 return make_number (t
->display_info
.tty
->TN_max_colors
);
2247 /* Declare here rather than in the function, as in the rest of Emacs,
2248 to work around an HPUX compiler bug (?). See
2249 http://lists.gnu.org/archive/html/emacs-devel/2007-08/msg00410.html */
2250 static int default_max_colors
;
2251 static int default_max_pairs
;
2252 static int default_no_color_video
;
2253 static char *default_orig_pair
;
2254 static char *default_set_foreground
;
2255 static char *default_set_background
;
2257 /* Save or restore the default color-related capabilities of this
2260 tty_default_color_capabilities (struct tty_display_info
*tty
, int save
)
2265 xfree (default_orig_pair
);
2266 default_orig_pair
= tty
->TS_orig_pair
? xstrdup (tty
->TS_orig_pair
) : NULL
;
2268 xfree (default_set_foreground
);
2269 default_set_foreground
= tty
->TS_set_foreground
? xstrdup (tty
->TS_set_foreground
)
2272 xfree (default_set_background
);
2273 default_set_background
= tty
->TS_set_background
? xstrdup (tty
->TS_set_background
)
2276 default_max_colors
= tty
->TN_max_colors
;
2277 default_max_pairs
= tty
->TN_max_pairs
;
2278 default_no_color_video
= tty
->TN_no_color_video
;
2282 tty
->TS_orig_pair
= default_orig_pair
;
2283 tty
->TS_set_foreground
= default_set_foreground
;
2284 tty
->TS_set_background
= default_set_background
;
2285 tty
->TN_max_colors
= default_max_colors
;
2286 tty
->TN_max_pairs
= default_max_pairs
;
2287 tty
->TN_no_color_video
= default_no_color_video
;
2291 /* Setup one of the standard tty color schemes according to MODE.
2292 MODE's value is generally the number of colors which we want to
2293 support; zero means set up for the default capabilities, the ones
2294 we saw at init_tty time; -1 means turn off color support. */
2296 tty_setup_colors (struct tty_display_info
*tty
, int mode
)
2298 /* Canonicalize all negative values of MODE. */
2304 case -1: /* no colors at all */
2305 tty
->TN_max_colors
= 0;
2306 tty
->TN_max_pairs
= 0;
2307 tty
->TN_no_color_video
= 0;
2308 tty
->TS_set_foreground
= tty
->TS_set_background
= tty
->TS_orig_pair
= NULL
;
2310 case 0: /* default colors, if any */
2312 tty_default_color_capabilities (tty
, 0);
2314 case 8: /* 8 standard ANSI colors */
2315 tty
->TS_orig_pair
= "\033[0m";
2317 tty
->TS_set_foreground
= "\033[3%p1%dm";
2318 tty
->TS_set_background
= "\033[4%p1%dm";
2320 tty
->TS_set_foreground
= "\033[3%dm";
2321 tty
->TS_set_background
= "\033[4%dm";
2323 tty
->TN_max_colors
= 8;
2324 tty
->TN_max_pairs
= 64;
2325 tty
->TN_no_color_video
= 0;
2331 set_tty_color_mode (struct tty_display_info
*tty
, struct frame
*f
)
2333 Lisp_Object tem
, val
;
2334 Lisp_Object color_mode
;
2336 Lisp_Object tty_color_mode_alist
2337 = Fintern_soft (build_string ("tty-color-mode-alist"), Qnil
);
2339 tem
= assq_no_quit (Qtty_color_mode
, f
->param_alist
);
2340 val
= CONSP (tem
) ? XCDR (tem
) : Qnil
;
2344 else if (SYMBOLP (tty_color_mode_alist
))
2346 tem
= Fassq (val
, Fsymbol_value (tty_color_mode_alist
));
2347 color_mode
= CONSP (tem
) ? XCDR (tem
) : Qnil
;
2352 mode
= INTEGERP (color_mode
) ? XINT (color_mode
) : 0;
2354 if (mode
!= tty
->previous_color_mode
)
2356 Lisp_Object funsym
= intern ("tty-set-up-initial-frame-faces");
2357 tty
->previous_color_mode
= mode
;
2358 tty_setup_colors (tty
, mode
);
2359 /* This recomputes all the faces given the new color definitions. */
2360 safe_call (1, &funsym
);
2364 #endif /* !DOS_NT */
2368 /* Return the tty display object specified by TERMINAL. */
2371 get_tty_terminal (Lisp_Object terminal
, int throw)
2373 struct terminal
*t
= get_terminal (terminal
, throw);
2375 if (t
&& t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
)
2378 error ("Device %d is not a termcap terminal device", t
->id
);
2386 /* Return an active termcap device that uses the tty device with the
2389 This function ignores suspended devices.
2391 Returns NULL if the named terminal device is not opened. */
2394 get_named_tty (const char *name
)
2401 for (t
= terminal_list
; t
; t
= t
->next_terminal
)
2403 if ((t
->type
== output_termcap
|| t
->type
== output_msdos_raw
)
2404 && !strcmp (t
->display_info
.tty
->name
, name
)
2405 && TERMINAL_ACTIVE_P (t
))
2413 DEFUN ("tty-type", Ftty_type
, Stty_type
, 0, 1, 0,
2414 doc
: /* Return the type of the tty device that TERMINAL uses.
2415 Returns nil if TERMINAL is not on a tty device.
2417 TERMINAL can be a terminal object, a frame, or nil (meaning the
2418 selected frame's terminal). */)
2419 (Lisp_Object terminal
)
2421 struct terminal
*t
= get_terminal (terminal
, 1);
2423 if (t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
)
2426 if (t
->display_info
.tty
->type
)
2427 return build_string (t
->display_info
.tty
->type
);
2432 DEFUN ("controlling-tty-p", Fcontrolling_tty_p
, Scontrolling_tty_p
, 0, 1, 0,
2433 doc
: /* Return non-nil if TERMINAL is the controlling tty of the Emacs process.
2435 TERMINAL can be a terminal object, a frame, or nil (meaning the
2436 selected frame's terminal). This function always returns nil if
2437 TERMINAL is not on a tty device. */)
2438 (Lisp_Object terminal
)
2440 struct terminal
*t
= get_terminal (terminal
, 1);
2442 if ((t
->type
!= output_termcap
&& t
->type
!= output_msdos_raw
)
2443 || strcmp (t
->display_info
.tty
->name
, DEV_TTY
) != 0)
2449 DEFUN ("tty-no-underline", Ftty_no_underline
, Stty_no_underline
, 0, 1, 0,
2450 doc
: /* Declare that the tty used by TERMINAL does not handle underlining.
2451 This is used to override the terminfo data, for certain terminals that
2452 do not really do underlining, but say that they do. This function has
2453 no effect if used on a non-tty terminal.
2455 TERMINAL can be a terminal object, a frame or nil (meaning the
2456 selected frame's terminal). This function always returns nil if
2457 TERMINAL does not refer to a text-only terminal. */)
2458 (Lisp_Object terminal
)
2460 struct terminal
*t
= get_terminal (terminal
, 1);
2462 if (t
->type
== output_termcap
)
2463 t
->display_info
.tty
->TS_enter_underline_mode
= 0;
2469 DEFUN ("suspend-tty", Fsuspend_tty
, Ssuspend_tty
, 0, 1, 0,
2470 doc
: /* Suspend the terminal device TTY.
2472 The device is restored to its default state, and Emacs ceases all
2473 access to the tty device. Frames that use the device are not deleted,
2474 but input is not read from them and if they change, their display is
2477 TTY may be a terminal object, a frame, or nil for the terminal device
2478 of the currently selected frame.
2480 This function runs `suspend-tty-functions' after suspending the
2481 device. The functions are run with one arg, the id of the suspended
2484 `suspend-tty' does nothing if it is called on a device that is already
2487 A suspended tty may be resumed by calling `resume-tty' on it. */)
2490 struct terminal
*t
= get_tty_terminal (tty
, 1);
2494 error ("Unknown tty device");
2496 f
= t
->display_info
.tty
->input
;
2500 /* First run `suspend-tty-functions' and then clean up the tty
2501 state because `suspend-tty-functions' might need to change
2503 if (!NILP (Vrun_hooks
))
2505 Lisp_Object args
[2];
2506 args
[0] = intern ("suspend-tty-functions");
2507 XSETTERMINAL (args
[1], t
);
2508 Frun_hook_with_args (2, args
);
2511 reset_sys_modes (t
->display_info
.tty
);
2512 delete_keyboard_wait_descriptor (fileno (f
));
2516 if (f
!= t
->display_info
.tty
->output
)
2517 fclose (t
->display_info
.tty
->output
);
2520 t
->display_info
.tty
->input
= 0;
2521 t
->display_info
.tty
->output
= 0;
2523 if (FRAMEP (t
->display_info
.tty
->top_frame
))
2524 FRAME_SET_VISIBLE (XFRAME (t
->display_info
.tty
->top_frame
), 0);
2528 /* Clear display hooks to prevent further output. */
2529 clear_tty_hooks (t
);
2534 DEFUN ("resume-tty", Fresume_tty
, Sresume_tty
, 0, 1, 0,
2535 doc
: /* Resume the previously suspended terminal device TTY.
2536 The terminal is opened and reinitialized. Frames that are on the
2537 suspended terminal are revived.
2539 It is an error to resume a terminal while another terminal is active
2542 This function runs `resume-tty-functions' after resuming the terminal.
2543 The functions are run with one arg, the id of the resumed terminal
2546 `resume-tty' does nothing if it is called on a device that is not
2549 TTY may be a terminal object, a frame, or nil (meaning the selected
2550 frame's terminal). */)
2553 struct terminal
*t
= get_tty_terminal (tty
, 1);
2557 error ("Unknown tty device");
2559 if (!t
->display_info
.tty
->input
)
2561 if (get_named_tty (t
->display_info
.tty
->name
))
2562 error ("Cannot resume display while another display is active on the same device");
2565 t
->display_info
.tty
->output
= stdout
;
2566 t
->display_info
.tty
->input
= stdin
;
2568 fd
= emacs_open (t
->display_info
.tty
->name
, O_RDWR
| O_NOCTTY
, 0);
2571 error ("Can not reopen tty device %s: %s", t
->display_info
.tty
->name
, strerror (errno
));
2573 if (strcmp (t
->display_info
.tty
->name
, DEV_TTY
))
2574 dissociate_if_controlling_tty (fd
);
2576 t
->display_info
.tty
->output
= fdopen (fd
, "w+");
2577 t
->display_info
.tty
->input
= t
->display_info
.tty
->output
;
2580 add_keyboard_wait_descriptor (fd
);
2582 if (FRAMEP (t
->display_info
.tty
->top_frame
))
2584 struct frame
*f
= XFRAME (t
->display_info
.tty
->top_frame
);
2586 int old_height
= FRAME_COLS (f
);
2587 int old_width
= FRAME_LINES (f
);
2589 /* Check if terminal/window size has changed while the frame
2591 get_tty_size (fileno (t
->display_info
.tty
->input
), &width
, &height
);
2592 if (width
!= old_width
|| height
!= old_height
)
2593 change_frame_size (f
, height
, width
, 0, 0, 0);
2594 FRAME_SET_VISIBLE (XFRAME (t
->display_info
.tty
->top_frame
), 1);
2597 init_sys_modes (t
->display_info
.tty
);
2599 /* Run `resume-tty-functions'. */
2600 if (!NILP (Vrun_hooks
))
2602 Lisp_Object args
[2];
2603 args
[0] = intern ("resume-tty-functions");
2604 XSETTERMINAL (args
[1], t
);
2605 Frun_hook_with_args (2, args
);
2615 /***********************************************************************
2617 ***********************************************************************/
2621 term_mouse_moveto (int x
, int y
)
2623 /* TODO: how to set mouse position?
2626 name = (const char *) ttyname (0);
2627 fd = open (name, O_WRONLY);
2628 SOME_FUNCTION (x, y, fd);
2631 last_mouse_y = y; */
2634 /* Implementation of draw_row_with_mouse_face for TTY/GPM. */
2636 tty_draw_row_with_mouse_face (struct window
*w
, struct glyph_row
*row
,
2637 int start_hpos
, int end_hpos
,
2638 enum draw_glyphs_face draw
)
2640 int nglyphs
= end_hpos
- start_hpos
;
2641 struct frame
*f
= XFRAME (WINDOW_FRAME (w
));
2642 struct tty_display_info
*tty
= FRAME_TTY (f
);
2643 int face_id
= tty
->mouse_highlight
.mouse_face_face_id
;
2644 int save_x
, save_y
, pos_x
, pos_y
;
2646 if (end_hpos
>= row
->used
[TEXT_AREA
])
2647 nglyphs
= row
->used
[TEXT_AREA
] - start_hpos
;
2649 pos_y
= row
->y
+ WINDOW_TOP_EDGE_Y (w
);
2650 pos_x
= row
->used
[LEFT_MARGIN_AREA
] + start_hpos
+ WINDOW_LEFT_EDGE_X (w
);
2652 /* Save current cursor co-ordinates. */
2653 save_y
= curY (tty
);
2654 save_x
= curX (tty
);
2655 cursor_to (f
, pos_y
, pos_x
);
2657 if (draw
== DRAW_MOUSE_FACE
)
2658 tty_write_glyphs_with_face (f
, row
->glyphs
[TEXT_AREA
] + start_hpos
,
2660 else if (draw
== DRAW_NORMAL_TEXT
)
2661 write_glyphs (f
, row
->glyphs
[TEXT_AREA
] + start_hpos
, nglyphs
);
2663 cursor_to (f
, save_y
, save_x
);
2667 term_mouse_movement (FRAME_PTR frame
, Gpm_Event
*event
)
2669 /* Has the mouse moved off the glyph it was on at the last sighting? */
2670 if (event
->x
!= last_mouse_x
|| event
->y
!= last_mouse_y
)
2672 frame
->mouse_moved
= 1;
2673 note_mouse_highlight (frame
, event
->x
, event
->y
);
2674 /* Remember which glyph we're now on. */
2675 last_mouse_x
= event
->x
;
2676 last_mouse_y
= event
->y
;
2682 /* Return the current position of the mouse.
2684 Set *f to the frame the mouse is in, or zero if the mouse is in no
2685 Emacs frame. If it is set to zero, all the other arguments are
2688 Set *bar_window to Qnil, and *x and *y to the column and
2689 row of the character cell the mouse is over.
2691 Set *timeptr to the time the mouse was at the returned position.
2693 This clears mouse_moved until the next motion
2696 term_mouse_position (FRAME_PTR
*fp
, int insist
, Lisp_Object
*bar_window
,
2697 enum scroll_bar_part
*part
, Lisp_Object
*x
,
2698 Lisp_Object
*y
, unsigned long *timeptr
)
2702 *fp
= SELECTED_FRAME ();
2703 (*fp
)->mouse_moved
= 0;
2708 XSETINT (*x
, last_mouse_x
);
2709 XSETINT (*y
, last_mouse_y
);
2710 gettimeofday(&now
, 0);
2711 *timeptr
= (now
.tv_sec
* 1000) + (now
.tv_usec
/ 1000);
2714 /* Prepare a mouse-event in *RESULT for placement in the input queue.
2716 If the event is a button press, then note that we have grabbed
2720 term_mouse_click (struct input_event
*result
, Gpm_Event
*event
,
2726 result
->kind
= GPM_CLICK_EVENT
;
2727 for (i
= 0, j
= GPM_B_LEFT
; i
< 3; i
++, j
>>= 1 )
2729 if (event
->buttons
& j
) {
2730 result
->code
= i
; /* button number */
2734 gettimeofday(&now
, 0);
2735 result
->timestamp
= (now
.tv_sec
* 1000) + (now
.tv_usec
/ 1000);
2737 if (event
->type
& GPM_UP
)
2738 result
->modifiers
= up_modifier
;
2739 else if (event
->type
& GPM_DOWN
)
2740 result
->modifiers
= down_modifier
;
2742 result
->modifiers
= 0;
2744 if (event
->type
& GPM_SINGLE
)
2745 result
->modifiers
|= click_modifier
;
2747 if (event
->type
& GPM_DOUBLE
)
2748 result
->modifiers
|= double_modifier
;
2750 if (event
->type
& GPM_TRIPLE
)
2751 result
->modifiers
|= triple_modifier
;
2753 if (event
->type
& GPM_DRAG
)
2754 result
->modifiers
|= drag_modifier
;
2756 if (!(event
->type
& (GPM_MOVE
| GPM_DRAG
))) {
2759 if (event
->modifiers
& (1 << 0))
2760 result
->modifiers
|= shift_modifier
;
2763 if (event
->modifiers
& (1 << 2))
2764 result
->modifiers
|= ctrl_modifier
;
2766 /* 1 << KG_ALT || KG_ALTGR */
2767 if (event
->modifiers
& (1 << 3)
2768 || event
->modifiers
& (1 << 1))
2769 result
->modifiers
|= meta_modifier
;
2772 XSETINT (result
->x
, event
->x
);
2773 XSETINT (result
->y
, event
->y
);
2774 XSETFRAME (result
->frame_or_window
, f
);
2780 handle_one_term_event (struct tty_display_info
*tty
, Gpm_Event
*event
, struct input_event
* hold_quit
)
2782 struct frame
*f
= XFRAME (tty
->top_frame
);
2783 struct input_event ie
;
2791 if (event
->type
& (GPM_MOVE
| GPM_DRAG
)) {
2792 previous_help_echo_string
= help_echo_string
;
2793 help_echo_string
= Qnil
;
2795 Gpm_DrawPointer (event
->x
, event
->y
, fileno (tty
->output
));
2797 if (!term_mouse_movement (f
, event
))
2798 help_echo_string
= previous_help_echo_string
;
2800 /* If the contents of the global variable help_echo_string
2801 has changed, generate a HELP_EVENT. */
2802 if (!NILP (help_echo_string
)
2803 || !NILP (previous_help_echo_string
))
2810 term_mouse_click (&ie
, event
, f
);
2814 if (ie
.kind
!= NO_EVENT
)
2816 kbd_buffer_store_event_hold (&ie
, hold_quit
);
2821 && !(hold_quit
&& hold_quit
->kind
!= NO_EVENT
))
2826 XSETFRAME (frame
, f
);
2830 gen_help_event (help_echo_string
, frame
, help_echo_window
,
2831 help_echo_object
, help_echo_pos
);
2838 DEFUN ("gpm-mouse-start", Fgpm_mouse_start
, Sgpm_mouse_start
,
2840 doc
: /* Open a connection to Gpm.
2841 Gpm-mouse can only be activated for one tty at a time. */)
2844 struct frame
*f
= SELECTED_FRAME ();
2845 struct tty_display_info
*tty
2846 = ((f
)->output_method
== output_termcap
2847 ? (f
)->terminal
->display_info
.tty
: NULL
);
2848 Gpm_Connect connection
;
2851 error ("Gpm-mouse only works in the GNU/Linux console");
2853 return Qnil
; /* Already activated, nothing to do. */
2855 error ("Gpm-mouse can only be activated for one tty at a time");
2857 connection
.eventMask
= ~0;
2858 connection
.defaultMask
= ~GPM_HARD
;
2859 connection
.maxMod
= ~0;
2860 connection
.minMod
= 0;
2863 if (Gpm_Open (&connection
, 0) < 0)
2864 error ("Gpm-mouse failed to connect to the gpm daemon");
2868 /* `init_sys_modes' arranges for mouse movements sent through gpm_fd
2869 to generate SIGIOs. Apparently we need to call reset_sys_modes
2870 before calling init_sys_modes. */
2871 reset_sys_modes (tty
);
2872 init_sys_modes (tty
);
2873 add_gpm_wait_descriptor (gpm_fd
);
2882 delete_gpm_wait_descriptor (fd
);
2883 while (Gpm_Close()); /* close all the stack */
2887 DEFUN ("gpm-mouse-stop", Fgpm_mouse_stop
, Sgpm_mouse_stop
,
2889 doc
: /* Close a connection to Gpm. */)
2892 struct frame
*f
= SELECTED_FRAME ();
2893 struct tty_display_info
*tty
2894 = ((f
)->output_method
== output_termcap
2895 ? (f
)->terminal
->display_info
.tty
: NULL
);
2897 if (!tty
|| gpm_tty
!= tty
)
2898 return Qnil
; /* Not activated on this terminal, nothing to do. */
2903 #endif /* HAVE_GPM */
2907 /***********************************************************************
2909 ***********************************************************************/
2911 /* Initialize the tty-dependent part of frame F. The frame must
2912 already have its device initialized. */
2915 create_tty_output (struct frame
*f
)
2917 struct tty_output
*t
;
2919 if (! FRAME_TERMCAP_P (f
))
2922 t
= xmalloc (sizeof (struct tty_output
));
2923 memset (t
, 0, sizeof (struct tty_output
));
2925 t
->display_info
= FRAME_TERMINAL (f
)->display_info
.tty
;
2927 f
->output_data
.tty
= t
;
2930 /* Delete frame F's face cache, and its tty-dependent part. */
2933 tty_free_frame_resources (struct frame
*f
)
2935 if (! FRAME_TERMCAP_P (f
))
2938 if (FRAME_FACE_CACHE (f
))
2939 free_frame_faces (f
);
2941 xfree (f
->output_data
.tty
);
2946 /* Delete frame F's face cache. */
2949 tty_free_frame_resources (struct frame
*f
)
2951 if (! FRAME_TERMCAP_P (f
) && ! FRAME_MSDOS_P (f
))
2954 if (FRAME_FACE_CACHE (f
))
2955 free_frame_faces (f
);
2959 /* Reset the hooks in TERMINAL. */
2962 clear_tty_hooks (struct terminal
*terminal
)
2965 terminal
->cursor_to_hook
= 0;
2966 terminal
->raw_cursor_to_hook
= 0;
2967 terminal
->clear_to_end_hook
= 0;
2968 terminal
->clear_frame_hook
= 0;
2969 terminal
->clear_end_of_line_hook
= 0;
2970 terminal
->ins_del_lines_hook
= 0;
2971 terminal
->insert_glyphs_hook
= 0;
2972 terminal
->write_glyphs_hook
= 0;
2973 terminal
->delete_glyphs_hook
= 0;
2974 terminal
->ring_bell_hook
= 0;
2975 terminal
->reset_terminal_modes_hook
= 0;
2976 terminal
->set_terminal_modes_hook
= 0;
2977 terminal
->update_begin_hook
= 0;
2978 terminal
->update_end_hook
= 0;
2979 terminal
->set_terminal_window_hook
= 0;
2980 terminal
->mouse_position_hook
= 0;
2981 terminal
->frame_rehighlight_hook
= 0;
2982 terminal
->frame_raise_lower_hook
= 0;
2983 terminal
->fullscreen_hook
= 0;
2984 terminal
->set_vertical_scroll_bar_hook
= 0;
2985 terminal
->condemn_scroll_bars_hook
= 0;
2986 terminal
->redeem_scroll_bar_hook
= 0;
2987 terminal
->judge_scroll_bars_hook
= 0;
2988 terminal
->read_socket_hook
= 0;
2989 terminal
->frame_up_to_date_hook
= 0;
2991 /* Leave these two set, or suspended frames are not deleted
2993 terminal
->delete_frame_hook
= &tty_free_frame_resources
;
2994 terminal
->delete_terminal_hook
= &delete_tty
;
2997 /* Initialize hooks in TERMINAL with the values needed for a tty. */
3000 set_tty_hooks (struct terminal
*terminal
)
3002 terminal
->rif
= 0; /* ttys don't support window-based redisplay. */
3004 terminal
->cursor_to_hook
= &tty_cursor_to
;
3005 terminal
->raw_cursor_to_hook
= &tty_raw_cursor_to
;
3007 terminal
->clear_to_end_hook
= &tty_clear_to_end
;
3008 terminal
->clear_frame_hook
= &tty_clear_frame
;
3009 terminal
->clear_end_of_line_hook
= &tty_clear_end_of_line
;
3011 terminal
->ins_del_lines_hook
= &tty_ins_del_lines
;
3013 terminal
->insert_glyphs_hook
= &tty_insert_glyphs
;
3014 terminal
->write_glyphs_hook
= &tty_write_glyphs
;
3015 terminal
->delete_glyphs_hook
= &tty_delete_glyphs
;
3017 terminal
->ring_bell_hook
= &tty_ring_bell
;
3019 terminal
->reset_terminal_modes_hook
= &tty_reset_terminal_modes
;
3020 terminal
->set_terminal_modes_hook
= &tty_set_terminal_modes
;
3021 terminal
->update_begin_hook
= 0; /* Not needed. */
3022 terminal
->update_end_hook
= &tty_update_end
;
3023 terminal
->set_terminal_window_hook
= &tty_set_terminal_window
;
3025 terminal
->mouse_position_hook
= 0; /* Not needed. */
3026 terminal
->frame_rehighlight_hook
= 0; /* Not needed. */
3027 terminal
->frame_raise_lower_hook
= 0; /* Not needed. */
3029 terminal
->set_vertical_scroll_bar_hook
= 0; /* Not needed. */
3030 terminal
->condemn_scroll_bars_hook
= 0; /* Not needed. */
3031 terminal
->redeem_scroll_bar_hook
= 0; /* Not needed. */
3032 terminal
->judge_scroll_bars_hook
= 0; /* Not needed. */
3034 terminal
->read_socket_hook
= &tty_read_avail_input
; /* keyboard.c */
3035 terminal
->frame_up_to_date_hook
= 0; /* Not needed. */
3037 terminal
->delete_frame_hook
= &tty_free_frame_resources
;
3038 terminal
->delete_terminal_hook
= &delete_tty
;
3041 /* Drop the controlling terminal if fd is the same device. */
3043 dissociate_if_controlling_tty (int fd
)
3046 int pgid
= tcgetpgrp (fd
); /* If tcgetpgrp succeeds, fd is the ctty. */
3051 no_controlling_tty
= 1;
3052 #elif defined (CYGWIN)
3054 no_controlling_tty
= 1;
3056 #ifdef TIOCNOTTY /* Try BSD ioctls. */
3057 sigblock (sigmask (SIGTTOU
));
3058 fd
= emacs_open (DEV_TTY
, O_RDWR
, 0);
3059 if (fd
!= -1 && ioctl (fd
, TIOCNOTTY
, 0) != -1)
3061 no_controlling_tty
= 1;
3065 sigunblock (sigmask (SIGTTOU
));
3067 /* Unknown system. */
3069 #endif /* ! TIOCNOTTY */
3072 #endif /* !DOS_NT */
3075 /* Create a termcap display on the tty device with the given name and
3078 If NAME is NULL, then use the controlling tty, i.e., "/dev/tty".
3079 Otherwise NAME should be a path to the tty device file,
3082 TERMINAL_TYPE is the termcap type of the device, e.g. "vt100".
3084 If MUST_SUCCEED is true, then all errors are fatal. */
3087 init_tty (const char *name
, const char *terminal_type
, int must_succeed
)
3090 char **address
= &area
;
3091 int buffer_size
= 4096;
3092 register char *p
= NULL
;
3094 struct tty_display_info
*tty
= NULL
;
3095 struct terminal
*terminal
= NULL
;
3096 int ctty
= 0; /* 1 if asked to open controlling tty. */
3099 maybe_fatal (must_succeed
, 0,
3100 "Unknown terminal type",
3101 "Unknown terminal type");
3105 if (!strcmp (name
, DEV_TTY
))
3108 /* If we already have a terminal on the given device, use that. If
3109 all such terminals are suspended, create a new one instead. */
3110 /* XXX Perhaps this should be made explicit by having init_tty
3111 always create a new terminal and separating terminal and frame
3112 creation on Lisp level. */
3113 terminal
= get_named_tty (name
);
3117 terminal
= create_terminal ();
3120 maybe_fatal (1, 0, "Attempt to create another terminal %s", "",
3123 tty
= &the_only_display_info
;
3125 tty
= (struct tty_display_info
*) xmalloc (sizeof (struct tty_display_info
));
3127 memset (tty
, 0, sizeof (struct tty_display_info
));
3128 tty
->next
= tty_list
;
3131 terminal
->type
= output_termcap
;
3132 terminal
->display_info
.tty
= tty
;
3133 tty
->terminal
= terminal
;
3135 tty
->Wcm
= (struct cm
*) xmalloc (sizeof (struct cm
));
3138 encode_terminal_src_size
= 0;
3139 encode_terminal_dst_size
= 0;
3142 terminal
->mouse_position_hook
= term_mouse_position
;
3143 tty
->mouse_highlight
.mouse_face_window
= Qnil
;
3148 set_tty_hooks (terminal
);
3154 #ifdef O_IGNORE_CTTY
3156 /* Open the terminal device. Don't recognize it as our
3157 controlling terminal, and don't make it the controlling tty
3158 if we don't have one at the moment. */
3159 fd
= emacs_open (name
, O_RDWR
| O_IGNORE_CTTY
| O_NOCTTY
, 0);
3162 /* Alas, O_IGNORE_CTTY is a GNU extension that seems to be only
3163 defined on Hurd. On other systems, we need to explicitly
3164 dissociate ourselves from the controlling tty when we want to
3165 open a frame on the same terminal. */
3166 fd
= emacs_open (name
, O_RDWR
| O_NOCTTY
, 0);
3167 #endif /* O_IGNORE_CTTY */
3169 tty
->name
= xstrdup (name
);
3170 terminal
->name
= xstrdup (name
);
3173 maybe_fatal (must_succeed
, terminal
,
3174 "Could not open file: %s",
3175 "Could not open file: %s",
3180 maybe_fatal (must_succeed
, terminal
,
3181 "Not a tty device: %s",
3182 "Not a tty device: %s",
3186 #ifndef O_IGNORE_CTTY
3188 dissociate_if_controlling_tty (fd
);
3191 file
= fdopen (fd
, "w+");
3196 tty
->type
= xstrdup (terminal_type
);
3198 add_keyboard_wait_descriptor (fileno (tty
->input
));
3202 tty
->termcap_term_buffer
= (char *) xmalloc (buffer_size
);
3204 /* On some systems, tgetent tries to access the controlling
3206 sigblock (sigmask (SIGTTOU
));
3207 status
= tgetent (tty
->termcap_term_buffer
, terminal_type
);
3208 sigunblock (sigmask (SIGTTOU
));
3213 maybe_fatal (must_succeed
, terminal
,
3214 "Cannot open terminfo database file",
3215 "Cannot open terminfo database file");
3217 maybe_fatal (must_succeed
, terminal
,
3218 "Cannot open termcap database file",
3219 "Cannot open termcap database file");
3224 maybe_fatal (must_succeed
, terminal
,
3225 "Terminal type %s is not defined",
3226 "Terminal type %s is not defined.\n\
3227 If that is not the actual type of terminal you have,\n\
3228 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
3229 `setenv TERM ...') to specify the correct type. It may be necessary\n"
3231 "to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
3233 "to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
3239 if (strlen (tty
->termcap_term_buffer
) >= buffer_size
)
3241 buffer_size
= strlen (tty
->termcap_term_buffer
);
3243 tty
->termcap_strings_buffer
= area
= (char *) xmalloc (buffer_size
);
3244 tty
->TS_ins_line
= tgetstr ("al", address
);
3245 tty
->TS_ins_multi_lines
= tgetstr ("AL", address
);
3246 tty
->TS_bell
= tgetstr ("bl", address
);
3247 BackTab (tty
) = tgetstr ("bt", address
);
3248 tty
->TS_clr_to_bottom
= tgetstr ("cd", address
);
3249 tty
->TS_clr_line
= tgetstr ("ce", address
);
3250 tty
->TS_clr_frame
= tgetstr ("cl", address
);
3251 ColPosition (tty
) = NULL
; /* tgetstr ("ch", address); */
3252 AbsPosition (tty
) = tgetstr ("cm", address
);
3253 CR (tty
) = tgetstr ("cr", address
);
3254 tty
->TS_set_scroll_region
= tgetstr ("cs", address
);
3255 tty
->TS_set_scroll_region_1
= tgetstr ("cS", address
);
3256 RowPosition (tty
) = tgetstr ("cv", address
);
3257 tty
->TS_del_char
= tgetstr ("dc", address
);
3258 tty
->TS_del_multi_chars
= tgetstr ("DC", address
);
3259 tty
->TS_del_line
= tgetstr ("dl", address
);
3260 tty
->TS_del_multi_lines
= tgetstr ("DL", address
);
3261 tty
->TS_delete_mode
= tgetstr ("dm", address
);
3262 tty
->TS_end_delete_mode
= tgetstr ("ed", address
);
3263 tty
->TS_end_insert_mode
= tgetstr ("ei", address
);
3264 Home (tty
) = tgetstr ("ho", address
);
3265 tty
->TS_ins_char
= tgetstr ("ic", address
);
3266 tty
->TS_ins_multi_chars
= tgetstr ("IC", address
);
3267 tty
->TS_insert_mode
= tgetstr ("im", address
);
3268 tty
->TS_pad_inserted_char
= tgetstr ("ip", address
);
3269 tty
->TS_end_keypad_mode
= tgetstr ("ke", address
);
3270 tty
->TS_keypad_mode
= tgetstr ("ks", address
);
3271 LastLine (tty
) = tgetstr ("ll", address
);
3272 Right (tty
) = tgetstr ("nd", address
);
3273 Down (tty
) = tgetstr ("do", address
);
3275 Down (tty
) = tgetstr ("nl", address
); /* Obsolete name for "do" */
3276 if (tgetflag ("bs"))
3277 Left (tty
) = "\b"; /* can't possibly be longer! */
3278 else /* (Actually, "bs" is obsolete...) */
3279 Left (tty
) = tgetstr ("le", address
);
3281 Left (tty
) = tgetstr ("bc", address
); /* Obsolete name for "le" */
3282 tty
->TS_pad_char
= tgetstr ("pc", address
);
3283 tty
->TS_repeat
= tgetstr ("rp", address
);
3284 tty
->TS_end_standout_mode
= tgetstr ("se", address
);
3285 tty
->TS_fwd_scroll
= tgetstr ("sf", address
);
3286 tty
->TS_standout_mode
= tgetstr ("so", address
);
3287 tty
->TS_rev_scroll
= tgetstr ("sr", address
);
3288 tty
->Wcm
->cm_tab
= tgetstr ("ta", address
);
3289 tty
->TS_end_termcap_modes
= tgetstr ("te", address
);
3290 tty
->TS_termcap_modes
= tgetstr ("ti", address
);
3291 Up (tty
) = tgetstr ("up", address
);
3292 tty
->TS_visible_bell
= tgetstr ("vb", address
);
3293 tty
->TS_cursor_normal
= tgetstr ("ve", address
);
3294 tty
->TS_cursor_visible
= tgetstr ("vs", address
);
3295 tty
->TS_cursor_invisible
= tgetstr ("vi", address
);
3296 tty
->TS_set_window
= tgetstr ("wi", address
);
3298 tty
->TS_enter_underline_mode
= tgetstr ("us", address
);
3299 tty
->TS_exit_underline_mode
= tgetstr ("ue", address
);
3300 tty
->TS_enter_bold_mode
= tgetstr ("md", address
);
3301 tty
->TS_enter_dim_mode
= tgetstr ("mh", address
);
3302 tty
->TS_enter_blink_mode
= tgetstr ("mb", address
);
3303 tty
->TS_enter_reverse_mode
= tgetstr ("mr", address
);
3304 tty
->TS_enter_alt_charset_mode
= tgetstr ("as", address
);
3305 tty
->TS_exit_alt_charset_mode
= tgetstr ("ae", address
);
3306 tty
->TS_exit_attribute_mode
= tgetstr ("me", address
);
3308 MultiUp (tty
) = tgetstr ("UP", address
);
3309 MultiDown (tty
) = tgetstr ("DO", address
);
3310 MultiLeft (tty
) = tgetstr ("LE", address
);
3311 MultiRight (tty
) = tgetstr ("RI", address
);
3313 /* SVr4/ANSI color suppert. If "op" isn't available, don't support
3314 color because we can't switch back to the default foreground and
3316 tty
->TS_orig_pair
= tgetstr ("op", address
);
3317 if (tty
->TS_orig_pair
)
3319 tty
->TS_set_foreground
= tgetstr ("AF", address
);
3320 tty
->TS_set_background
= tgetstr ("AB", address
);
3321 if (!tty
->TS_set_foreground
)
3324 tty
->TS_set_foreground
= tgetstr ("Sf", address
);
3325 tty
->TS_set_background
= tgetstr ("Sb", address
);
3328 tty
->TN_max_colors
= tgetnum ("Co");
3329 tty
->TN_max_pairs
= tgetnum ("pa");
3331 tty
->TN_no_color_video
= tgetnum ("NC");
3332 if (tty
->TN_no_color_video
== -1)
3333 tty
->TN_no_color_video
= 0;
3336 tty_default_color_capabilities (tty
, 1);
3338 MagicWrap (tty
) = tgetflag ("xn");
3339 /* Since we make MagicWrap terminals look like AutoWrap, we need to have
3340 the former flag imply the latter. */
3341 AutoWrap (tty
) = MagicWrap (tty
) || tgetflag ("am");
3342 terminal
->memory_below_frame
= tgetflag ("db");
3343 tty
->TF_hazeltine
= tgetflag ("hz");
3344 terminal
->must_write_spaces
= tgetflag ("in");
3345 tty
->meta_key
= tgetflag ("km") || tgetflag ("MT");
3346 tty
->TF_insmode_motion
= tgetflag ("mi");
3347 tty
->TF_standout_motion
= tgetflag ("ms");
3348 tty
->TF_underscore
= tgetflag ("ul");
3349 tty
->TF_teleray
= tgetflag ("xt");
3354 struct frame
*f
= XFRAME (selected_frame
);
3356 initialize_w32_display (terminal
);
3358 FrameRows (tty
) = FRAME_LINES (f
);
3359 FrameCols (tty
) = FRAME_COLS (f
);
3360 tty
->specified_window
= FRAME_LINES (f
);
3362 FRAME_CAN_HAVE_SCROLL_BARS (f
) = 0;
3363 FRAME_VERTICAL_SCROLL_BAR_TYPE (f
) = vertical_scroll_bar_none
;
3364 terminal
->char_ins_del_ok
= 1;
3370 if (strcmp (terminal_type
, "internal") == 0)
3371 terminal
->type
= output_msdos_raw
;
3372 initialize_msdos_display (terminal
);
3374 get_tty_size (fileno (tty
->input
), &width
, &height
);
3375 FrameCols (tty
) = width
;
3376 FrameRows (tty
) = height
;
3377 terminal
->char_ins_del_ok
= 0;
3378 init_baud_rate (fileno (tty
->input
));
3381 tty
->output
= stdout
;
3383 /* The following two are inaccessible from w32console.c. */
3384 terminal
->delete_frame_hook
= &tty_free_frame_resources
;
3385 terminal
->delete_terminal_hook
= &delete_tty
;
3387 tty
->name
= xstrdup (name
);
3388 terminal
->name
= xstrdup (name
);
3389 tty
->type
= xstrdup (terminal_type
);
3391 add_keyboard_wait_descriptor (0);
3393 tty
->delete_in_insert_mode
= 1;
3396 terminal
->scroll_region_ok
= 0;
3398 /* Seems to insert lines when it's not supposed to, messing up the
3399 display. In doing a trace, it didn't seem to be called much, so I
3400 don't think we're losing anything by turning it off. */
3401 terminal
->line_ins_del_ok
= 0;
3403 tty
->TN_max_colors
= 16; /* Required to be non-zero for tty-display-color-p */
3406 terminal
->kboard
= (KBOARD
*) xmalloc (sizeof (KBOARD
));
3407 init_kboard (terminal
->kboard
);
3408 KVAR (terminal
->kboard
, Vwindow_system
) = Qnil
;
3409 terminal
->kboard
->next_kboard
= all_kboards
;
3410 all_kboards
= terminal
->kboard
;
3411 terminal
->kboard
->reference_count
++;
3412 /* Don't let the initial kboard remain current longer than necessary.
3413 That would cause problems if a file loaded on startup tries to
3414 prompt in the mini-buffer. */
3415 if (current_kboard
== initial_kboard
)
3416 current_kboard
= terminal
->kboard
;
3418 term_get_fkeys (address
, terminal
->kboard
);
3420 /* Get frame size from system, or else from termcap. */
3423 get_tty_size (fileno (tty
->input
), &width
, &height
);
3424 FrameCols (tty
) = width
;
3425 FrameRows (tty
) = height
;
3428 if (FrameCols (tty
) <= 0)
3429 FrameCols (tty
) = tgetnum ("co");
3430 if (FrameRows (tty
) <= 0)
3431 FrameRows (tty
) = tgetnum ("li");
3433 if (FrameRows (tty
) < 3 || FrameCols (tty
) < 3)
3434 maybe_fatal (must_succeed
, terminal
,
3435 "Screen size %dx%d is too small",
3436 "Screen size %dx%d is too small",
3437 FrameCols (tty
), FrameRows (tty
));
3439 TabWidth (tty
) = tgetnum ("tw");
3442 tty
->TS_bell
= "\07";
3444 if (!tty
->TS_fwd_scroll
)
3445 tty
->TS_fwd_scroll
= Down (tty
);
3447 PC
= tty
->TS_pad_char
? *tty
->TS_pad_char
: 0;
3449 if (TabWidth (tty
) < 0)
3452 /* Turned off since /etc/termcap seems to have :ta= for most terminals
3453 and newer termcap doc does not seem to say there is a default.
3454 if (!tty->Wcm->cm_tab)
3455 tty->Wcm->cm_tab = "\t";
3458 /* We don't support standout modes that use `magic cookies', so
3459 turn off any that do. */
3460 if (tty
->TS_standout_mode
&& tgetnum ("sg") >= 0)
3462 tty
->TS_standout_mode
= 0;
3463 tty
->TS_end_standout_mode
= 0;
3465 if (tty
->TS_enter_underline_mode
&& tgetnum ("ug") >= 0)
3467 tty
->TS_enter_underline_mode
= 0;
3468 tty
->TS_exit_underline_mode
= 0;
3471 /* If there's no standout mode, try to use underlining instead. */
3472 if (tty
->TS_standout_mode
== 0)
3474 tty
->TS_standout_mode
= tty
->TS_enter_underline_mode
;
3475 tty
->TS_end_standout_mode
= tty
->TS_exit_underline_mode
;
3478 /* If no `se' string, try using a `me' string instead.
3479 If that fails, we can't use standout mode at all. */
3480 if (tty
->TS_end_standout_mode
== 0)
3482 char *s
= tgetstr ("me", address
);
3484 tty
->TS_end_standout_mode
= s
;
3486 tty
->TS_standout_mode
= 0;
3489 if (tty
->TF_teleray
)
3491 tty
->Wcm
->cm_tab
= 0;
3492 /* We can't support standout mode, because it uses magic cookies. */
3493 tty
->TS_standout_mode
= 0;
3494 /* But that means we cannot rely on ^M to go to column zero! */
3496 /* LF can't be trusted either -- can alter hpos */
3497 /* if move at column 0 thru a line with TS_standout_mode */
3501 /* Special handling for certain terminal types known to need it */
3503 if (!strcmp (terminal_type
, "supdup"))
3505 terminal
->memory_below_frame
= 1;
3506 tty
->Wcm
->cm_losewrap
= 1;
3508 if (!strncmp (terminal_type
, "c10", 3)
3509 || !strcmp (terminal_type
, "perq"))
3511 /* Supply a makeshift :wi string.
3512 This string is not valid in general since it works only
3513 for windows starting at the upper left corner;
3514 but that is all Emacs uses.
3516 This string works only if the frame is using
3517 the top of the video memory, because addressing is memory-relative.
3518 So first check the :ti string to see if that is true.
3520 It would be simpler if the :wi string could go in the termcap
3521 entry, but it can't because it is not fully valid.
3522 If it were in the termcap entry, it would confuse other programs. */
3523 if (!tty
->TS_set_window
)
3525 const char *m
= tty
->TS_termcap_modes
;
3526 while (*m
&& strcmp (m
, "\033v "))
3529 tty
->TS_set_window
= "\033v%C %C %C %C ";
3531 /* Termcap entry often fails to have :in: flag */
3532 terminal
->must_write_spaces
= 1;
3533 /* :ti string typically fails to have \E^G! in it */
3534 /* This limits scope of insert-char to one line. */
3535 strcpy (area
, tty
->TS_termcap_modes
);
3536 strcat (area
, "\033\007!");
3537 tty
->TS_termcap_modes
= area
;
3538 area
+= strlen (area
) + 1;
3539 p
= AbsPosition (tty
);
3540 /* Change all %+ parameters to %C, to handle
3541 values above 96 correctly for the C100. */
3544 if (p
[0] == '%' && p
[1] == '+')
3550 tty
->specified_window
= FrameRows (tty
);
3552 if (Wcm_init (tty
) == -1) /* can't do cursor motion */
3554 maybe_fatal (must_succeed
, terminal
,
3555 "Terminal type \"%s\" is not powerful enough to run Emacs",
3556 "Terminal type \"%s\" is not powerful enough to run Emacs.\n\
3557 It lacks the ability to position the cursor.\n\
3558 If that is not the actual type of terminal you have,\n\
3559 use the Bourne shell command `TERM=... export TERM' (C-shell:\n\
3560 `setenv TERM ...') to specify the correct type. It may be necessary\n"
3562 "to do `unset TERMINFO' (C-shell: `unsetenv TERMINFO') as well.",
3563 # else /* TERMCAP */
3564 "to do `unset TERMCAP' (C-shell: `unsetenv TERMCAP') as well.",
3565 # endif /* TERMINFO */
3569 if (FrameRows (tty
) <= 0 || FrameCols (tty
) <= 0)
3570 maybe_fatal (must_succeed
, terminal
,
3571 "Could not determine the frame size",
3572 "Could not determine the frame size");
3574 tty
->delete_in_insert_mode
3575 = tty
->TS_delete_mode
&& tty
->TS_insert_mode
3576 && !strcmp (tty
->TS_delete_mode
, tty
->TS_insert_mode
);
3578 tty
->se_is_so
= (tty
->TS_standout_mode
3579 && tty
->TS_end_standout_mode
3580 && !strcmp (tty
->TS_standout_mode
, tty
->TS_end_standout_mode
));
3582 UseTabs (tty
) = tabs_safe_p (fileno (tty
->input
)) && TabWidth (tty
) == 8;
3584 terminal
->scroll_region_ok
3586 && (tty
->TS_set_window
|| tty
->TS_set_scroll_region
|| tty
->TS_set_scroll_region_1
));
3588 terminal
->line_ins_del_ok
3589 = (((tty
->TS_ins_line
|| tty
->TS_ins_multi_lines
)
3590 && (tty
->TS_del_line
|| tty
->TS_del_multi_lines
))
3591 || (terminal
->scroll_region_ok
3592 && tty
->TS_fwd_scroll
&& tty
->TS_rev_scroll
));
3594 terminal
->char_ins_del_ok
3595 = ((tty
->TS_ins_char
|| tty
->TS_insert_mode
3596 || tty
->TS_pad_inserted_char
|| tty
->TS_ins_multi_chars
)
3597 && (tty
->TS_del_char
|| tty
->TS_del_multi_chars
));
3599 terminal
->fast_clear_end_of_line
= tty
->TS_clr_line
!= 0;
3601 init_baud_rate (fileno (tty
->input
));
3603 #endif /* not DOS_NT */
3605 /* Init system terminal modes (RAW or CBREAK, etc.). */
3606 init_sys_modes (tty
);
3613 vfatal (const char *str
, va_list ap
)
3615 fprintf (stderr
, "emacs: ");
3616 vfprintf (stderr
, str
, ap
);
3617 if (!(strlen (str
) > 0 && str
[strlen (str
) - 1] == '\n'))
3618 fprintf (stderr
, "\n");
3625 /* Auxiliary error-handling function for init_tty.
3626 Delete TERMINAL, then call error or fatal with str1 or str2,
3627 respectively, according to MUST_SUCCEED. */
3630 maybe_fatal (int must_succeed
, struct terminal
*terminal
,
3631 const char *str1
, const char *str2
, ...)
3634 va_start (ap
, str2
);
3636 delete_tty (terminal
);
3648 fatal (const char *str
, ...)
3658 /* Delete the given tty terminal, closing all frames on it. */
3661 delete_tty (struct terminal
*terminal
)
3663 struct tty_display_info
*tty
;
3665 /* Protect against recursive calls. delete_frame in
3666 delete_terminal calls us back when it deletes our last frame. */
3667 if (!terminal
->name
)
3670 if (terminal
->type
!= output_termcap
)
3673 tty
= terminal
->display_info
.tty
;
3675 if (tty
== tty_list
)
3676 tty_list
= tty
->next
;
3679 struct tty_display_info
*p
;
3680 for (p
= tty_list
; p
&& p
->next
!= tty
; p
= p
->next
)
3684 /* This should not happen. */
3687 p
->next
= tty
->next
;
3691 /* reset_sys_modes needs a valid device, so this call needs to be
3692 before delete_terminal. */
3693 reset_sys_modes (tty
);
3695 delete_terminal (terminal
);
3702 delete_keyboard_wait_descriptor (fileno (tty
->input
));
3703 if (tty
->input
!= stdin
)
3704 fclose (tty
->input
);
3706 if (tty
->output
&& tty
->output
!= stdout
&& tty
->output
!= tty
->input
)
3707 fclose (tty
->output
);
3708 if (tty
->termscript
)
3709 fclose (tty
->termscript
);
3711 xfree (tty
->old_tty
);
3713 xfree (tty
->termcap_strings_buffer
);
3714 xfree (tty
->termcap_term_buffer
);
3716 memset (tty
, 0, sizeof (struct tty_display_info
));
3722 /* Mark the pointers in the tty_display_info objects.
3723 Called by the Fgarbage_collector. */
3728 struct tty_display_info
*tty
;
3730 for (tty
= tty_list
; tty
; tty
= tty
->next
)
3731 mark_object (tty
->top_frame
);
3739 DEFVAR_BOOL ("system-uses-terminfo", system_uses_terminfo
,
3740 doc
: /* Non-nil means the system uses terminfo rather than termcap.
3741 This variable can be used by terminal emulator packages. */);
3743 system_uses_terminfo
= 1;
3745 system_uses_terminfo
= 0;
3748 DEFVAR_LISP ("suspend-tty-functions", Vsuspend_tty_functions
,
3749 doc
: /* Functions to be run after suspending a tty.
3750 The functions are run with one argument, the terminal object to be suspended.
3751 See `suspend-tty'. */);
3752 Vsuspend_tty_functions
= Qnil
;
3755 DEFVAR_LISP ("resume-tty-functions", Vresume_tty_functions
,
3756 doc
: /* Functions to be run after resuming a tty.
3757 The functions are run with one argument, the terminal object that was revived.
3758 See `resume-tty'. */);
3759 Vresume_tty_functions
= Qnil
;
3761 DEFVAR_BOOL ("visible-cursor", visible_cursor
,
3762 doc
: /* Non-nil means to make the cursor very visible.
3763 This only has an effect when running in a text terminal.
3764 What means \"very visible\" is up to your terminal. It may make the cursor
3765 bigger, or it may make it blink, or it may do nothing at all. */);
3768 defsubr (&Stty_display_color_p
);
3769 defsubr (&Stty_display_color_cells
);
3770 defsubr (&Stty_no_underline
);
3771 defsubr (&Stty_type
);
3772 defsubr (&Scontrolling_tty_p
);
3773 defsubr (&Ssuspend_tty
);
3774 defsubr (&Sresume_tty
);
3776 defsubr (&Sgpm_mouse_start
);
3777 defsubr (&Sgpm_mouse_stop
);
3778 #endif /* HAVE_GPM */
3781 default_orig_pair
= NULL
;
3782 default_set_foreground
= NULL
;
3783 default_set_background
= NULL
;
3784 #endif /* !DOS_NT */
3786 encode_terminal_src
= NULL
;
3787 encode_terminal_dst
= NULL
;