/* Terminal control module for terminals described by TERMCAP
- Copyright (C) 1985, 86, 87, 93, 94, 95, 98, 2000, 2001, 2002
- Free Software Foundation, Inc.
+ Copyright (C) 1985, 1986, 1987, 1993, 1994, 1995, 1998, 2000, 2001,
+ 2002, 2003, 2004, 2005, 2006 Free Software Foundation, Inc.
This file is part of GNU Emacs.
You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING. If not, write to
-the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
-Boston, MA 02111-1307, USA. */
+the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
+Boston, MA 02110-1301, USA. */
/* New redisplay, TTY faces by Gerd Moellmann <gerd@gnu.org>. */
#define OUTPUT1_IF(a) do { if (a) tputs (a, 1, cmputc); } while (0)
+/* Display space properties */
+
+extern Lisp_Object Qspace, QCalign_to, QCwidth;
+
/* Function to use to ring the bell. */
Lisp_Object Vring_bell_function;
+/* If true, use "vs", otherwise use "ve" to make the cursor visible. */
+
+static int visible_cursor;
+
/* Terminal characteristics that higher levels want to look at.
These are all extern'd in termchar.h */
void (*write_glyphs_hook) P_ ((struct glyph *, int));
void (*delete_glyphs_hook) P_ ((int));
-int (*read_socket_hook) P_ ((int, struct input_event *, int, int));
+int (*read_socket_hook) P_ ((int, int, struct input_event *));
void (*frame_up_to_date_hook) P_ ((struct frame *));
{
if (FRAME_TERMCAP_P (XFRAME (selected_frame)))
{
- OUTPUT_IF (TS_termcap_modes);
- OUTPUT_IF (TS_cursor_visible);
+ if (TS_termcap_modes)
+ OUTPUT (TS_termcap_modes);
+ else
+ {
+ /* Output enough newlines to scroll all the old screen contents
+ off the screen, so it won't be overwritten and lost. */
+ int i;
+ for (i = 0; i < FRAME_LINES (XFRAME (selected_frame)); i++)
+ putchar ('\n');
+ }
+
+ OUTPUT_IF (visible_cursor ? TS_cursor_visible : TS_cursor_normal);
OUTPUT_IF (TS_keypad_mode);
losecursor ();
}
{
tty_cursor_hidden = 0;
OUTPUT_IF (TS_cursor_normal);
- OUTPUT_IF (TS_cursor_visible);
+ if (visible_cursor)
+ OUTPUT_IF (TS_cursor_visible);
}
}
}
}
\f
-/* Encode SRC_LEN glyphs starting at SRC to terminal output codes and
- store them at DST. Do not write more than DST_LEN bytes. That may
- require stopping before all SRC_LEN input glyphs have been
- converted.
+/* Buffer to store the source and result of code conversion for terminal. */
+static unsigned char *encode_terminal_buf;
+/* Allocated size of the above buffer. */
+static int encode_terminal_bufsize;
- We store the number of glyphs actually converted in *CONSUMED. The
- return value is the number of bytes store in DST. */
+/* Encode SRC_LEN glyphs starting at SRC to terminal output codes.
+ Set CODING->produced to the byte-length of the resulting byte
+ sequence, and return a pointer to that byte sequence. */
-int
-encode_terminal_code (src, dst, src_len, dst_len, consumed)
+unsigned char *
+encode_terminal_code (src, src_len, coding)
struct glyph *src;
int src_len;
- unsigned char *dst;
- int dst_len, *consumed;
+ struct coding_system *coding;
{
- struct glyph *src_start = src, *src_end = src + src_len;
- unsigned char *dst_start = dst, *dst_end = dst + dst_len;
+ struct glyph *src_end = src + src_len;
register GLYPH g;
- unsigned char workbuf[MAX_MULTIBYTE_LENGTH];
- const unsigned char *buf;
- int len;
+ unsigned char *buf;
+ int nchars, nbytes, required;
register int tlen = GLYPH_TABLE_LENGTH;
register Lisp_Object *tbase = GLYPH_TABLE_BASE;
- int result;
- struct coding_system *coding;
- /* If terminal_coding does any conversion, use it, otherwise use
- safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
- because it always return 1 if the member src_multibyte is 1. */
- coding = (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
- ? &terminal_coding
- : &safe_terminal_coding);
+ /* Allocate sufficient size of buffer to store all characters in
+ multibyte-form. But, it may be enlarged on demand if
+ Vglyph_table contains a string. */
+ required = MAX_MULTIBYTE_LENGTH * src_len;
+ if (encode_terminal_bufsize < required)
+ {
+ if (encode_terminal_bufsize == 0)
+ encode_terminal_buf = xmalloc (required);
+ else
+ encode_terminal_buf = xrealloc (encode_terminal_buf, required);
+ encode_terminal_bufsize = required;
+ }
+ buf = encode_terminal_buf;
+ nchars = 0;
while (src < src_end)
{
/* We must skip glyphs to be padded for a wide character. */
if (g < 0 || g >= tlen)
{
/* This glyph doesn't has an entry in Vglyph_table. */
- if (! CHAR_VALID_P (src->u.ch, 0))
- {
- len = 1;
- buf = " ";
- coding->src_multibyte = 0;
- }
+ if (CHAR_VALID_P (src->u.ch, 0))
+ buf += CHAR_STRING (src->u.ch, buf);
else
- {
- len = CHAR_STRING (src->u.ch, workbuf);
- buf = workbuf;
- coding->src_multibyte = 1;
- }
+ *buf++ = SPACEGLYPH;
+ nchars++;
}
else
{
if (GLYPH_SIMPLE_P (tbase, tlen, g))
{
- /* We set the multi-byte form of a character in G
- (that should be an ASCII character) at
- WORKBUF. */
- workbuf[0] = FAST_GLYPH_CHAR (g);
- len = 1;
- buf = workbuf;
- coding->src_multibyte = 0;
+ int c = FAST_GLYPH_CHAR (g);
+
+ if (CHAR_VALID_P (c, 0))
+ buf += CHAR_STRING (c, buf);
+ else
+ *buf++ = SPACEGLYPH;
+ nchars++;
}
else
{
/* We have a string in Vglyph_table. */
- len = GLYPH_LENGTH (tbase, g);
- buf = GLYPH_STRING (tbase, g);
- coding->src_multibyte = STRING_MULTIBYTE (tbase[g]);
+ Lisp_Object string;
+
+ string = tbase[g];
+ if (! STRING_MULTIBYTE (string))
+ string = string_to_multibyte (string);
+ nbytes = buf - encode_terminal_buf;
+ if (encode_terminal_bufsize < nbytes + SBYTES (string))
+ {
+ encode_terminal_bufsize = nbytes + SBYTES (string);
+ encode_terminal_buf = xrealloc (encode_terminal_buf,
+ encode_terminal_bufsize);
+ buf = encode_terminal_buf + nbytes;
+ }
+ bcopy (SDATA (string), buf, SBYTES (string));
+ buf += SBYTES (string);
+ nchars += SCHARS (string);
}
}
-
- result = encode_coding (coding, buf, dst, len, dst_end - dst);
- len -= coding->consumed;
- dst += coding->produced;
- if (result == CODING_FINISH_INSUFFICIENT_DST
- || (result == CODING_FINISH_INSUFFICIENT_SRC
- && len > dst_end - dst))
- /* The remaining output buffer is too short. We must
- break the loop here without increasing SRC so that the
- next call of this function starts from the same glyph. */
- break;
-
- if (len > 0)
- {
- /* This is the case that a code of the range 0200..0237
- exists in buf. We must just write out such a code. */
- buf += coding->consumed;
- while (len--)
- *dst++ = *buf++;
- }
}
src++;
}
- *consumed = src - src_start;
- return (dst - dst_start);
-}
+ nbytes = buf - encode_terminal_buf;
+ coding->src_multibyte = 1;
+ coding->dst_multibyte = 0;
+ if (SYMBOLP (coding->pre_write_conversion)
+ && ! NILP (Ffboundp (coding->pre_write_conversion)))
+ {
+ run_pre_write_conversin_on_c_str (&encode_terminal_buf,
+ &encode_terminal_bufsize,
+ nchars, nbytes, coding);
+ nchars = coding->produced_char;
+ nbytes = coding->produced;
+ }
+ required = nbytes + encoding_buffer_size (coding, nbytes);
+ if (encode_terminal_bufsize < required)
+ {
+ encode_terminal_bufsize = required;
+ encode_terminal_buf = xrealloc (encode_terminal_buf, required);
+ }
+ encode_coding (coding, encode_terminal_buf, encode_terminal_buf + nbytes,
+ nbytes, encode_terminal_bufsize - nbytes);
+ return encode_terminal_buf + nbytes;
+}
void
write_glyphs (string, len)
register struct glyph *string;
register int len;
{
- int produced, consumed;
struct frame *sf = XFRAME (selected_frame);
struct frame *f = updating_frame ? updating_frame : sf;
- unsigned char conversion_buffer[1024];
- int conversion_buffer_size = sizeof conversion_buffer;
+ unsigned char *conversion_buffer;
+ struct coding_system *coding;
if (write_glyphs_hook
&& ! FRAME_TERMCAP_P (f))
cmplus (len);
+ /* If terminal_coding does any conversion, use it, otherwise use
+ safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
+ because it always return 1 if the member src_multibyte is 1. */
+ coding = (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
+ ? &terminal_coding : &safe_terminal_coding);
/* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
the tail. */
- terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
+ coding->mode &= ~CODING_MODE_LAST_BLOCK;
while (len > 0)
{
highlight_if_desired ();
turn_on_face (f, face_id);
- while (n > 0)
+ if (n == len)
+ /* This is the last run. */
+ coding->mode |= CODING_MODE_LAST_BLOCK;
+ conversion_buffer = encode_terminal_code (string, n, coding);
+ if (coding->produced > 0)
{
- /* We use a fixed size (1024 bytes) of conversion buffer.
- Usually it is sufficient, but if not, we just repeat the
- loop. */
- produced = encode_terminal_code (string, conversion_buffer,
- n, conversion_buffer_size,
- &consumed);
- if (produced > 0)
- {
- fwrite (conversion_buffer, 1, produced, stdout);
- if (ferror (stdout))
- clearerr (stdout);
- if (termscript)
- fwrite (conversion_buffer, 1, produced, termscript);
- }
- len -= consumed;
- n -= consumed;
- string += consumed;
+ fwrite (conversion_buffer, 1, coding->produced, stdout);
+ if (ferror (stdout))
+ clearerr (stdout);
+ if (termscript)
+ fwrite (conversion_buffer, 1, coding->produced, termscript);
}
+ len -= n;
+ string += n;
/* Turn appearance modes off. */
turn_off_face (f, face_id);
turn_off_highlight ();
}
- /* We may have to output some codes to terminate the writing. */
- if (CODING_REQUIRE_FLUSHING (&terminal_coding))
- {
- terminal_coding.mode |= CODING_MODE_LAST_BLOCK;
- encode_coding (&terminal_coding, "", conversion_buffer,
- 0, conversion_buffer_size);
- if (terminal_coding.produced > 0)
- {
- fwrite (conversion_buffer, 1, terminal_coding.produced, stdout);
- if (ferror (stdout))
- clearerr (stdout);
- if (termscript)
- fwrite (conversion_buffer, 1, terminal_coding.produced,
- termscript);
- }
- }
-
cmcheckmagic ();
}
char *buf;
struct glyph *glyph = NULL;
struct frame *f, *sf;
+ unsigned char *conversion_buffer;
+ unsigned char space[1];
+ struct coding_system *coding;
if (len <= 0)
return;
turn_on_insert ();
cmplus (len);
- /* The bit CODING_MODE_LAST_BLOCK should be set to 1 only at the tail. */
- terminal_coding.mode &= ~CODING_MODE_LAST_BLOCK;
+
+ if (! start)
+ space[0] = SPACEGLYPH;
+
+ /* If terminal_coding does any conversion, use it, otherwise use
+ safe_terminal_coding. We can't use CODING_REQUIRE_ENCODING here
+ because it always return 1 if the member src_multibyte is 1. */
+ coding = (terminal_coding.common_flags & CODING_REQUIRE_ENCODING_MASK
+ ? &terminal_coding : &safe_terminal_coding);
+ /* The mode bit CODING_MODE_LAST_BLOCK should be set to 1 only at
+ the tail. */
+ coding->mode &= ~CODING_MODE_LAST_BLOCK;
+
while (len-- > 0)
{
- int produced, consumed;
- unsigned char conversion_buffer[1024];
- int conversion_buffer_size = sizeof conversion_buffer;
-
OUTPUT1_IF (TS_ins_char);
if (!start)
{
- conversion_buffer[0] = SPACEGLYPH;
- produced = 1;
+ conversion_buffer = space;
+ coding->produced = 1;
}
else
{
if (len <= 0)
/* This is the last glyph. */
- terminal_coding.mode |= CODING_MODE_LAST_BLOCK;
+ coding->mode |= CODING_MODE_LAST_BLOCK;
- /* The size of conversion buffer (1024 bytes) is surely
- sufficient for just one glyph. */
- produced = encode_terminal_code (glyph, conversion_buffer, 1,
- conversion_buffer_size, &consumed);
+ conversion_buffer = encode_terminal_code (glyph, 1, coding);
}
- if (produced > 0)
+ if (coding->produced > 0)
{
- fwrite (conversion_buffer, 1, produced, stdout);
+ fwrite (conversion_buffer, 1, coding->produced, stdout);
if (ferror (stdout))
clearerr (stdout);
if (termscript)
- fwrite (conversion_buffer, 1, produced, termscript);
+ fwrite (conversion_buffer, 1, coding->produced, termscript);
}
OUTPUT1_IF (TS_pad_inserted_char);
{"k6", "f6"},
{"k7", "f7"},
{"k8", "f8"},
- {"k9", "f9"}
+ {"k9", "f9"},
+
+ {"&0", "S-cancel"}, /*shifted cancel key*/
+ {"&9", "S-begin"}, /*shifted begin key*/
+ {"*0", "S-find"}, /*shifted find key*/
+ {"*1", "S-execute"}, /*shifted execute? actually shifted command key*/
+ {"*4", "S-delete"}, /*shifted delete-character key*/
+ {"*7", "S-end"}, /*shifted end key*/
+ {"*8", "S-clearline"}, /*shifted clear-to end-of-line key*/
+ {"#1", "S-help"}, /*shifted help key*/
+ {"#2", "S-home"}, /*shifted home key*/
+ {"#3", "S-insert"}, /*shifted insert-character key*/
+ {"#4", "S-left"}, /*shifted left-arrow key*/
+ {"%d", "S-menu"}, /*shifted menu? actually shifted options key*/
+ {"%c", "S-next"}, /*shifted next key*/
+ {"%e", "S-prior"}, /*shifted previous key*/
+ {"%f", "S-print"}, /*shifted print key*/
+ {"%g", "S-redo"}, /*shifted redo key*/
+ {"%i", "S-right"}, /*shifted right-arrow key*/
+ {"!3", "S-undo"} /*shifted undo key*/
};
static char **term_get_fkeys_arg;
Character Display Information
***********************************************************************/
+/* Avoid name clash with functions defined in xterm.c */
+#ifdef static
+#define append_glyph append_glyph_term
+#define produce_stretch_glyph produce_stretch_glyph_term
+#endif
+
static void append_glyph P_ ((struct it *));
+static void produce_stretch_glyph P_ ((struct it *));
/* Append glyphs to IT's glyph_row. Called from produce_glyphs for
- terminal frames if IT->glyph_row != NULL. IT->c is the character
- for which to produce glyphs; IT->face_id contains the character's
- face. Padding glyphs are appended if IT->c has a IT->pixel_width >
- 1. */
+ terminal frames if IT->glyph_row != NULL. IT->char_to_display is
+ the character for which to produce glyphs; IT->face_id contains the
+ character's face. Padding glyphs are appended if IT->c has a
+ IT->pixel_width > 1. */
static void
append_glyph (it)
{
glyph->type = CHAR_GLYPH;
glyph->pixel_width = 1;
- glyph->u.ch = it->c;
+ glyph->u.ch = it->char_to_display;
glyph->face_id = it->face_id;
glyph->padding_p = i > 0;
glyph->charpos = CHARPOS (it->position);
/* If a hook is installed, let it do the work. */
xassert (it->what == IT_CHARACTER
|| it->what == IT_COMPOSITION
- || it->what == IT_IMAGE
|| it->what == IT_STRETCH);
+ if (it->what == IT_STRETCH)
+ {
+ produce_stretch_glyph (it);
+ goto done;
+ }
+
/* Nothing but characters are supported on terminal frames. For a
composition sequence, it->c is the first character of the
sequence. */
xassert (it->what == IT_CHARACTER
|| it->what == IT_COMPOSITION);
+ /* Maybe translate single-byte characters to multibyte. */
+ it->char_to_display = it->c;
+
if (it->c >= 040 && it->c < 0177)
{
it->pixel_width = it->nglyphs = 1;
{
int n = nspaces;
- it->c = ' ';
+ it->char_to_display = ' ';
it->pixel_width = it->len = 1;
while (n--)
append_glyph (it);
-
- it->c = '\t';
}
it->pixel_width = nspaces;
}
else if (SINGLE_BYTE_CHAR_P (it->c))
{
- /* Coming here means that it->c is from display table, thus we
- must send the code as is to the terminal. Although there's
- no way to know how many columns it occupies on a screen, it
- is a good assumption that a single byte code has 1-column
- width. */
- it->pixel_width = it->nglyphs = 1;
- if (it->glyph_row)
- append_glyph (it);
+ if (unibyte_display_via_language_environment
+ && (it->c >= 0240
+ || !NILP (Vnonascii_translation_table)))
+ {
+ int charset;
+
+ it->char_to_display = unibyte_char_to_multibyte (it->c);
+ charset = CHAR_CHARSET (it->char_to_display);
+ it->pixel_width = CHARSET_WIDTH (charset);
+ it->nglyphs = it->pixel_width;
+ if (it->glyph_row)
+ append_glyph (it);
+ }
+ else
+ {
+ /* Coming here means that it->c is from display table, thus we
+ must send the code as is to the terminal. Although there's
+ no way to know how many columns it occupies on a screen, it
+ is a good assumption that a single byte code has 1-column
+ width. */
+ it->pixel_width = it->nglyphs = 1;
+ if (it->glyph_row)
+ append_glyph (it);
+ }
}
else
{
append_glyph (it);
}
+ done:
/* Advance current_x by the pixel width as a convenience for
the caller. */
if (it->area == TEXT_AREA)
}
+/* Produce a stretch glyph for iterator IT. IT->object is the value
+ of the glyph property displayed. The value must be a list
+ `(space KEYWORD VALUE ...)' with the following KEYWORD/VALUE pairs
+ being recognized:
+
+ 1. `:width WIDTH' specifies that the space should be WIDTH *
+ canonical char width wide. WIDTH may be an integer or floating
+ point number.
+
+ 2. `:align-to HPOS' specifies that the space should be wide enough
+ to reach HPOS, a value in canonical character units. */
+
+static void
+produce_stretch_glyph (it)
+ struct it *it;
+{
+ /* (space :width WIDTH ...) */
+ Lisp_Object prop, plist;
+ int width = 0, align_to = -1;
+ int zero_width_ok_p = 0;
+ double tem;
+
+ /* List should start with `space'. */
+ xassert (CONSP (it->object) && EQ (XCAR (it->object), Qspace));
+ plist = XCDR (it->object);
+
+ /* Compute the width of the stretch. */
+ if ((prop = Fplist_get (plist, QCwidth), !NILP (prop))
+ && calc_pixel_width_or_height (&tem, it, prop, 0, 1, 0))
+ {
+ /* Absolute width `:width WIDTH' specified and valid. */
+ zero_width_ok_p = 1;
+ width = (int)(tem + 0.5);
+ }
+ else if ((prop = Fplist_get (plist, QCalign_to), !NILP (prop))
+ && calc_pixel_width_or_height (&tem, it, prop, 0, 1, &align_to))
+ {
+ if (it->glyph_row == NULL || !it->glyph_row->mode_line_p)
+ align_to = (align_to < 0
+ ? 0
+ : align_to - window_box_left_offset (it->w, TEXT_AREA));
+ else if (align_to < 0)
+ align_to = window_box_left_offset (it->w, TEXT_AREA);
+ width = max (0, (int)(tem + 0.5) + align_to - it->current_x);
+ zero_width_ok_p = 1;
+ }
+ else
+ /* Nothing specified -> width defaults to canonical char width. */
+ width = FRAME_COLUMN_WIDTH (it->f);
+
+ if (width <= 0 && (width < 0 || !zero_width_ok_p))
+ width = 1;
+
+ if (width > 0 && it->glyph_row)
+ {
+ Lisp_Object o_object = it->object;
+ Lisp_Object object = it->stack[it->sp - 1].string;
+ int n = width;
+
+ if (!STRINGP (object))
+ object = it->w->buffer;
+ it->object = object;
+ it->char_to_display = ' ';
+ it->pixel_width = it->len = 1;
+ while (n--)
+ append_glyph (it);
+ it->object = o_object;
+ }
+ it->pixel_width = width;
+ it->nglyphs = width;
+}
+
+
/* Get information about special display element WHAT in an
environment described by IT. WHAT is one of IT_TRUNCATION or
IT_CONTINUATION. Maybe produce glyphs for WHAT if IT has a
enum display_element_type what;
{
struct it temp_it;
+ GLYPH glyph;
temp_it = *it;
temp_it.dp = NULL;
&& INTEGERP (DISP_CONTINUE_GLYPH (it->dp))
&& GLYPH_CHAR_VALID_P (XINT (DISP_CONTINUE_GLYPH (it->dp))))
{
- temp_it.c = FAST_GLYPH_CHAR (XINT (DISP_CONTINUE_GLYPH (it->dp)));
- temp_it.len = CHAR_BYTES (temp_it.c);
+ glyph = XINT (DISP_CONTINUE_GLYPH (it->dp));
+ glyph = spec_glyph_lookup_face (XWINDOW (it->window), glyph);
}
else
- temp_it.c = '\\';
-
- produce_glyphs (&temp_it);
- it->pixel_width = temp_it.pixel_width;
- it->nglyphs = temp_it.pixel_width;
+ glyph = '\\';
}
else if (what == IT_TRUNCATION)
{
&& INTEGERP (DISP_TRUNC_GLYPH (it->dp))
&& GLYPH_CHAR_VALID_P (XINT (DISP_TRUNC_GLYPH (it->dp))))
{
- temp_it.c = FAST_GLYPH_CHAR (XINT (DISP_TRUNC_GLYPH (it->dp)));
- temp_it.len = CHAR_BYTES (temp_it.c);
+ glyph = XINT (DISP_TRUNC_GLYPH (it->dp));
+ glyph = spec_glyph_lookup_face (XWINDOW (it->window), glyph);
}
else
- temp_it.c = '$';
-
- produce_glyphs (&temp_it);
- it->pixel_width = temp_it.pixel_width;
- it->nglyphs = temp_it.pixel_width;
+ glyph = '$';
}
else
abort ();
+
+ temp_it.c = FAST_GLYPH_CHAR (glyph);
+ temp_it.face_id = FAST_GLYPH_FACE (glyph);
+ temp_it.len = CHAR_BYTES (temp_it.c);
+
+ produce_glyphs (&temp_it);
+ it->pixel_width = temp_it.pixel_width;
+ it->nglyphs = temp_it.pixel_width;
}
? (TN_no_color_video & (ATTR)) == 0 \
: 1)
-/* Turn appearances of face FACE_ID on tty frame F on. */
+/* Turn appearances of face FACE_ID on tty frame F on.
+ FACE_ID is a realized face ID number, in the face cache. */
static void
turn_on_face (f, face_id)
if (TN_max_colors > 0)
{
- char *p;
+ char *ts, *p;
- if (fg >= 0 && TS_set_foreground)
+ ts = standout_mode ? TS_set_background : TS_set_foreground;
+ if (fg >= 0 && ts)
{
- p = tparam (TS_set_foreground, NULL, 0, (int) fg);
+ p = tparam (ts, NULL, 0, (int) fg);
OUTPUT (p);
xfree (p);
}
- if (bg >= 0 && TS_set_background)
+ ts = standout_mode ? TS_set_foreground : TS_set_background;
+ if (bg >= 0 && ts)
{
- p = tparam (TS_set_background, NULL, 0, (int) bg);
+ p = tparam (ts, NULL, 0, (int) bg);
OUTPUT (p);
xfree (p);
}
tty_setup_colors (mode)
int mode;
{
+ /* Canonicalize all negative values of MODE. */
+ if (mode < -1)
+ mode = -1;
+
switch (mode)
{
case -1: /* no colors at all */
tty_color_mode_alist = Fintern_soft (build_string ("tty-color-mode-alist"),
Qnil);
- if (NATNUMP (val))
+ if (INTEGERP (val))
color_mode = val;
else
{
color_mode_spec = Qnil;
else
color_mode_spec = Fassq (val, XSYMBOL (tty_color_mode_alist)->value);
- current_mode_spec = assq_no_quit (Qtty_color_mode, f->param_alist);
if (CONSP (color_mode_spec))
color_mode = XCDR (color_mode_spec);
else
color_mode = Qnil;
}
+
+ current_mode_spec = assq_no_quit (Qtty_color_mode, f->param_alist);
+
if (CONSP (current_mode_spec))
current_mode = XCDR (current_mode_spec);
else
current_mode = Qnil;
- if (NATNUMP (color_mode))
+ if (INTEGERP (color_mode))
mode = XINT (color_mode);
else
mode = 0; /* meaning default */
- if (NATNUMP (current_mode))
+ if (INTEGERP (current_mode))
old_mode = XINT (current_mode);
else
old_mode = 0;
int status;
struct frame *sf = XFRAME (selected_frame);
+ encode_terminal_bufsize = 0;
+
#ifdef WINDOWSNT
initialize_w32_display ();
exit (1);
}
+DEFUN ("tty-no-underline", Ftty_no_underline, Stty_no_underline, 0, 0, 0,
+ doc: /* Declare that this terminal does not handle underlining.
+This is used to override the terminfo data, for certain terminals that
+do not really do underlining, but say that they do. */)
+ ()
+{
+ TS_enter_underline_mode = 0;
+ return Qnil;
+}
+
void
syms_of_term ()
{
The function should accept no arguments. */);
Vring_bell_function = Qnil;
+ DEFVAR_BOOL ("visible-cursor", &visible_cursor,
+ doc: /* Non-nil means to make the cursor very visible.
+This only has an effect when running in a text terminal.
+What means \"very visible\" is up to your terminal. It may make the cursor
+bigger, or it may make it blink, or it may do nothing at all. */);
+ visible_cursor = 1;
+
defsubr (&Stty_display_color_p);
defsubr (&Stty_display_color_cells);
+ defsubr (&Stty_no_underline);
}
+/* arch-tag: 498e7449-6f2e-45e2-91dd-b7d4ca488193
+ (do not change this comment) */