static void
enable_xterm_mouse(SCREEN *sp, int enable)
{
#if USE_EMX_MOUSE
sp->_emxmouse_activated = enable;
#else
putp(TPARM_1(sp->_mouse_xtermcap, enable));
#endif
sp->_mouse_active = enable;
}
static void
set_foreground_color(NCURSES_SP_DCLx int fg, NCURSES_SP_OUTC outc)
{
#ifdef USE_TERM_DRIVER
CallDriver_3(SP_PARM, td_color, TRUE, fg, outc);
#else
if (set_a_foreground) {
TPUTS_TRACE("set_a_foreground");
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
TPARM_1(set_a_foreground, fg),
1, outc);
} else {
TPUTS_TRACE("set_foreground");
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
TPARM_1(set_foreground, toggled_colors(fg)),
1, outc);
}
#endif
}
static void
enable_xterm_mouse(SCREEN *sp, int enable)
{
#if USE_EMX_MOUSE
sp->_emxmouse_activated = enable;
#else
NCURSES_PUTP2("xterm-mouse", TPARM_1(sp->_mouse_xtermcap, enable));
#endif
sp->_mouse_active = enable;
}
static void
set_background_color(NCURSES_SP_DCLx int bg, NCURSES_SP_OUTC outc)
{
#ifdef USE_TERM_DRIVER
CallDriver_3(SP_PARM, color, FALSE, bg, outc);
#else
if (set_a_background) {
TPUTS_TRACE("set_a_background");
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
TPARM_1(set_a_background, bg),
1, outc);
} else {
TPUTS_TRACE("set_background");
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
TPARM_1(set_background, toggled_colors(bg)),
1, outc);
}
#endif
}
static void
enable_xterm_mouse(SCREEN *sp, int enable)
{
#if USE_EMX_MOUSE
sp->_emxmouse_activated = enable;
#else
NCURSES_SP_NAME(_nc_putp) (NCURSES_SP_ARGx
"xterm-mouse",
TPARM_1(sp->_mouse_xtermcap, enable));
#endif
sp->_mouse_active = enable;
}
static int
relative_move(string_desc * target, int from_y, int from_x, int to_y, int
to_x, bool ovw)
/* move via local motions (cuu/cuu1/cud/cud1/cub1/cub/cuf1/cuf/vpa/hpa) */
{
string_desc save;
int n, vcost = 0, hcost = 0;
(void) _nc_str_copy(&save, target);
if (to_y != from_y) {
vcost = INFINITY;
if (row_address != 0
&& _nc_safe_strcat(target, TPARM_1(row_address, to_y))) {
vcost = SP->_vpa_cost;
}
if (to_y > from_y) {
n = (to_y - from_y);
if (parm_down_cursor
&& SP->_cud_cost < vcost
&& _nc_safe_strcat(_nc_str_copy(target, &save),
TPARM_1(parm_down_cursor, n))) {
vcost = SP->_cud_cost;
}
if (cursor_down
&& (*cursor_down != '\n' || SP->_nl)
&& (n * SP->_cud1_cost < vcost)) {
vcost = repeated_append(_nc_str_copy(target, &save), 0,
SP->_cud1_cost, n, cursor_down);
}
} else { /* (to_y < from_y) */
n = (from_y - to_y);
if (parm_up_cursor
&& SP->_cuu_cost < vcost
&& _nc_safe_strcat(_nc_str_copy(target, &save),
TPARM_1(parm_up_cursor, n))) {
vcost = SP->_cuu_cost;
}
if (cursor_up && (n * SP->_cuu1_cost < vcost)) {
vcost = repeated_append(_nc_str_copy(target, &save), 0,
SP->_cuu1_cost, n, cursor_up);
}
}
if (vcost == INFINITY)
return (INFINITY);
}
save = *target;
if (to_x != from_x) {
char str[OPT_SIZE];
string_desc check;
hcost = INFINITY;
if (column_address
&& _nc_safe_strcat(_nc_str_copy(target, &save),
TPARM_1(column_address, to_x))) {
hcost = SP->_hpa_cost;
}
if (to_x > from_x) {
n = to_x - from_x;
if (parm_right_cursor
&& SP->_cuf_cost < hcost
&& _nc_safe_strcat(_nc_str_copy(target, &save),
TPARM_1(parm_right_cursor, n))) {
hcost = SP->_cuf_cost;
}
if (cursor_right) {
int lhcost = 0;
(void) _nc_str_init(&check, str, sizeof(str));
#if USE_HARD_TABS
/* use hard tabs, if we have them, to do as much as possible */
if (init_tabs > 0 && tab) {
int nxt, fr;
for (fr = from_x; (nxt = NEXTTAB(fr)) <= to_x; fr = nxt) {
lhcost = repeated_append(&check, lhcost,
SP->_ht_cost, 1, tab);
if (lhcost == INFINITY)
break;
}
n = to_x - fr;
from_x = fr;
}
#endif /* USE_HARD_TABS */
if (n <= 0 || n >= (int) check.s_size)
ovw = FALSE;
#if BSD_TPUTS
/*
* If we're allowing BSD-style padding in tputs, don't generate
* a string with a leading digit. Otherwise, that will be
* interpreted as a padding value rather than sent to the
* screen.
*/
if (ovw
&& n > 0
&& n < (int) check.s_size
&& vcost == 0
&& str[0] == '\0') {
int wanted = CharOf(WANT_CHAR(to_y, from_x));
if (is8bits(wanted) && isdigit(wanted))
ovw = FALSE;
}
#endif
/*
* If we have no attribute changes, overwrite is cheaper.
* Note: must suppress this by passing in ovw = FALSE whenever
* WANT_CHAR would return invalid data. In particular, this
* is true between the time a hardware scroll has been done
* and the time the structure WANT_CHAR would access has been
* updated.
*/
if (ovw) {
int i;
for (i = 0; i < n; i++) {
NCURSES_CH_T ch = WANT_CHAR(to_y, from_x + i);
if (!SameAttrOf(ch, SCREEN_ATTRS(SP))
#if USE_WIDEC_SUPPORT
|| !Charable(ch)
#endif
) {
ovw = FALSE;
break;
}
}
}
if (ovw) {
int i;
for (i = 0; i < n; i++)
*check.s_tail++ = CharOf(WANT_CHAR(to_y, from_x + i));
*check.s_tail = '\0';
check.s_size -= n;
lhcost += n * SP->_char_padding;
} else {
lhcost = repeated_append(&check, lhcost, SP->_cuf1_cost,
n, cursor_right);
}
if (lhcost < hcost
&& _nc_safe_strcat(_nc_str_copy(target, &save), str)) {
hcost = lhcost;
}
}
} else { /* (to_x < from_x) */
n = from_x - to_x;
if (parm_left_cursor
&& SP->_cub_cost < hcost
&& _nc_safe_strcat(_nc_str_copy(target, &save),
TPARM_1(parm_left_cursor, n))) {
hcost = SP->_cub_cost;
}
if (cursor_left) {
int lhcost = 0;
(void) _nc_str_init(&check, str, sizeof(str));
#if USE_HARD_TABS
if (init_tabs > 0 && back_tab) {
int nxt, fr;
for (fr = from_x; (nxt = LASTTAB(fr)) >= to_x; fr = nxt) {
lhcost = repeated_append(&check, lhcost,
SP->_cbt_cost, 1, back_tab);
if (lhcost == INFINITY)
break;
}
n = fr - to_x;
}
#endif /* USE_HARD_TABS */
lhcost = repeated_append(&check, lhcost, SP->_cub1_cost, n, cursor_left);
if (lhcost < hcost
&& _nc_safe_strcat(_nc_str_copy(target, &save), str)) {
hcost = lhcost;
}
}
}
if (hcost == INFINITY)
return (INFINITY);
}
return (vcost + hcost);
}
_nc_mvcur_init(void)
/* initialize the cost structure */
{
if (isatty(fileno(SP->_ofp)))
SP->_char_padding = ((BAUDBYTE * 1000 * 10)
/ (BAUDRATE > 0 ? BAUDRATE : 9600));
else
SP->_char_padding = 1; /* must be nonzero */
if (SP->_char_padding <= 0)
SP->_char_padding = 1; /* must be nonzero */
TR(TRACE_CHARPUT | TRACE_MOVE, ("char_padding %d msecs", SP->_char_padding));
/* non-parameterized local-motion strings */
SP->_cr_cost = CostOf(carriage_return, 0);
SP->_home_cost = CostOf(cursor_home, 0);
SP->_ll_cost = CostOf(cursor_to_ll, 0);
#if USE_HARD_TABS
if (getenv("NCURSES_NO_HARD_TABS") == 0) {
SP->_ht_cost = CostOf(tab, 0);
SP->_cbt_cost = CostOf(back_tab, 0);
} else {
SP->_ht_cost = INFINITY;
SP->_cbt_cost = INFINITY;
}
#endif /* USE_HARD_TABS */
SP->_cub1_cost = CostOf(cursor_left, 0);
SP->_cuf1_cost = CostOf(cursor_right, 0);
SP->_cud1_cost = CostOf(cursor_down, 0);
SP->_cuu1_cost = CostOf(cursor_up, 0);
SP->_smir_cost = CostOf(enter_insert_mode, 0);
SP->_rmir_cost = CostOf(exit_insert_mode, 0);
SP->_ip_cost = 0;
if (insert_padding) {
SP->_ip_cost = CostOf(insert_padding, 0);
}
/*
* Assumption: if the terminal has memory_relative addressing, the
* initialization strings or smcup will set single-page mode so we
* can treat it like absolute screen addressing. This seems to be true
* for all cursor_mem_address terminal types in the terminfo database.
*/
SP->_address_cursor = cursor_address ? cursor_address : cursor_mem_address;
/*
* Parametrized local-motion strings. This static cost computation
* depends on the following assumptions:
*
* (1) They never have * padding. In the entire master terminfo database
* as of March 1995, only the obsolete Zenith Z-100 pc violates this.
* (Proportional padding is found mainly in insert, delete and scroll
* capabilities).
*
* (2) The average case of cup has two two-digit parameters. Strictly,
* the average case for a 24 * 80 screen has ((10*10*(1 + 1)) +
* (14*10*(1 + 2)) + (10*70*(2 + 1)) + (14*70*4)) / (24*80) = 3.458
* digits of parameters. On a 25x80 screen the average is 3.6197.
* On larger screens the value gets much closer to 4.
*
* (3) The average case of cub/cuf/hpa/ech/rep has 2 digits of parameters
* (strictly, (((10 * 1) + (70 * 2)) / 80) = 1.8750).
*
* (4) The average case of cud/cuu/vpa has 2 digits of parameters
* (strictly, (((10 * 1) + (14 * 2)) / 24) = 1.5833).
*
* All these averages depend on the assumption that all parameter values
* are equally probable.
*/
SP->_cup_cost = CostOf(TPARM_2(SP->_address_cursor, 23, 23), 1);
SP->_cub_cost = CostOf(TPARM_1(parm_left_cursor, 23), 1);
SP->_cuf_cost = CostOf(TPARM_1(parm_right_cursor, 23), 1);
SP->_cud_cost = CostOf(TPARM_1(parm_down_cursor, 23), 1);
SP->_cuu_cost = CostOf(TPARM_1(parm_up_cursor, 23), 1);
SP->_hpa_cost = CostOf(TPARM_1(column_address, 23), 1);
SP->_vpa_cost = CostOf(TPARM_1(row_address, 23), 1);
/* non-parameterized screen-update strings */
SP->_ed_cost = NormalizedCost(clr_eos, 1);
SP->_el_cost = NormalizedCost(clr_eol, 1);
SP->_el1_cost = NormalizedCost(clr_bol, 1);
SP->_dch1_cost = NormalizedCost(delete_character, 1);
SP->_ich1_cost = NormalizedCost(insert_character, 1);
/*
* If this is a bce-terminal, we want to bias the choice so we use clr_eol
* rather than spaces at the end of a line.
*/
if (back_color_erase)
SP->_el_cost = 0;
/* parameterized screen-update strings */
SP->_dch_cost = NormalizedCost(TPARM_1(parm_dch, 23), 1);
SP->_ich_cost = NormalizedCost(TPARM_1(parm_ich, 23), 1);
SP->_ech_cost = NormalizedCost(TPARM_1(erase_chars, 23), 1);
SP->_rep_cost = NormalizedCost(TPARM_2(repeat_char, ' ', 23), 1);
SP->_cup_ch_cost = NormalizedCost(TPARM_2(SP->_address_cursor, 23, 23), 1);
SP->_hpa_ch_cost = NormalizedCost(TPARM_1(column_address, 23), 1);
SP->_cuf_ch_cost = NormalizedCost(TPARM_1(parm_right_cursor, 23), 1);
SP->_inline_cost = min(SP->_cup_ch_cost,
min(SP->_hpa_ch_cost,
SP->_cuf_ch_cost));
/*
* If save_cursor is used within enter_ca_mode, we should not use it for
* scrolling optimization, since the corresponding restore_cursor is not
* nested on the various terminals (vt100, xterm, etc.) which use this
* feature.
*/
if (save_cursor != 0
&& enter_ca_mode != 0
&& strstr(enter_ca_mode, save_cursor) != 0) {
T(("...suppressed sc/rc capability due to conflict with smcup/rmcup"));
save_cursor = 0;
restore_cursor = 0;
}
/*
* A different, possibly better way to arrange this would be to set
* SP->_endwin = TRUE at window initialization time and let this be
* called by doupdate's return-from-shellout code.
*/
_nc_mvcur_resume();
}
/*
** move_to(from-row, from-column, to-row, to-column, selection)
**
** move the cursor from (rf, cf) to (rt, ct) using sel
*/
static void
move_to(
int rf,
int cf,
int rt,
int ct,
int sel)
{
char *s;
if (sel & 16) { /* use (cup) */
s = TPARM_2(cursor_address, rt, ct);
tputs(s, lines, tc_putch);
return;
}
if (sel & 8) { /* use (hpa) (vpa) */
if (column_address) {
s = TPARM_1(column_address, ct);
tputs(s, 1, tc_putch);
cf = ct;
}
if (row_address) {
s = TPARM_1(row_address, rt);
tputs(s, 1, tc_putch);
rf = rt;
}
}
if (sel & 4) { /* parameterized relative cursor movement */
if (parm_right_cursor)
if (cf < ct) {
s = TPARM_1(parm_right_cursor, ct - cf);
tputs(s, ct - cf, tc_putch);
cf = ct;
}
if (parm_left_cursor)
if (cf > ct) {
s = TPARM_1(parm_left_cursor, cf - ct);
tputs(s, cf - ct, tc_putch);
cf = ct;
}
if (parm_down_cursor)
if (rf < rt) {
s = TPARM_1(parm_down_cursor, rt - rf);
tputs(s, rt - rf, tc_putch);
rf = rt;
}
if (parm_up_cursor)
if (rf > rt) {
s = TPARM_1(parm_up_cursor, rf - rt);
tputs(s, rf - rt, tc_putch);
rf = rt;
}
}
if (sel & 2) {
if (cursor_left)
while (cf > ct) {
tc_putp(cursor_left);
cf--;
}
/*
do vertical motion next. Just in case cursor_down has a
side effect of changing the column. This could happen if
the tty handler translates NL to CRNL.
*/
if (cursor_down)
while (rf < rt) {
tc_putp(cursor_down);
rf++;
}
if (cursor_up)
while (rf > rt) {
tc_putp(cursor_up);
rf--;
}
if (cursor_right)
while (cf < ct) {
tc_putp(cursor_right);
cf++;
}
}
/* last chance */
if (rf > rt) {
if (can_go_home) { /* a bit drastic but ... */
go_home();
cf = 0;
rf = 0;
} else if (cursor_up) {
while (rf > rt) {
tc_putp(cursor_up);
rf--;
}
}
}
if (ct == 0 && rt > rf) {
put_crlf();
cf = 0;
rf++;
}
if (ct == 0 && cf != 0) {
put_cr();
cf = 0;
}
while (rf < rt) {
put_lf();
rf++;
}
while (cf > ct) {
put_str("\b");
cf--;
}
if (cursor_right) {
while (cf < ct) {
tc_putp(cursor_right);
cf++;
}
} else {
/* go ahead and trash my display */
while (cf < ct) {
putchp(' ');
cf++;
}
}
}
static int
tput(int argc, char *argv[])
{
NCURSES_CONST char *name;
char *s;
int i, j, c;
int status;
FILE *f;
#if !PURE_TERMINFO
bool termcap = FALSE;
#endif
if ((name = argv[0]) == 0)
name = "";
check_aliases(name);
if (is_reset || is_init) {
if (init_prog != 0) {
system(init_prog);
}
FLUSH;
if (is_reset && reset_1string != 0) {
PUTS(reset_1string);
} else if (init_1string != 0) {
PUTS(init_1string);
}
FLUSH;
if (is_reset && reset_2string != 0) {
PUTS(reset_2string);
} else if (init_2string != 0) {
PUTS(init_2string);
}
FLUSH;
#ifdef set_lr_margin
if (set_lr_margin != 0) {
PUTS(TPARM_2(set_lr_margin, 0, columns - 1));
} else
#endif
#ifdef set_left_margin_parm
if (set_left_margin_parm != 0
&& set_right_margin_parm != 0) {
PUTS(TPARM_1(set_left_margin_parm, 0));
PUTS(TPARM_1(set_right_margin_parm, columns - 1));
} else
#endif
if (clear_margins != 0
&& set_left_margin != 0
&& set_right_margin != 0) {
PUTS(clear_margins);
if (carriage_return != 0) {
PUTS(carriage_return);
} else {
PUTCHAR('\r');
}
PUTS(set_left_margin);
if (parm_right_cursor) {
PUTS(TPARM_1(parm_right_cursor, columns - 1));
} else {
for (i = 0; i < columns - 1; i++) {
PUTCHAR(' ');
}
}
PUTS(set_right_margin);
if (carriage_return != 0) {
PUTS(carriage_return);
} else {
PUTCHAR('\r');
}
}
FLUSH;
if (init_tabs != 8) {
if (clear_all_tabs != 0 && set_tab != 0) {
for (i = 0; i < columns - 1; i += 8) {
if (parm_right_cursor) {
PUTS(TPARM_1(parm_right_cursor, 8));
} else {
for (j = 0; j < 8; j++)
PUTCHAR(' ');
}
PUTS(set_tab);
}
FLUSH;
}
}
if (is_reset && reset_file != 0) {
f = fopen(reset_file, "r");
if (f == 0) {
quit(4 + errno, "Can't open reset_file: '%s'", reset_file);
}
while ((c = fgetc(f)) != EOF) {
PUTCHAR(c);
}
fclose(f);
} else if (init_file != 0) {
f = fopen(init_file, "r");
if (f == 0) {
quit(4 + errno, "Can't open init_file: '%s'", init_file);
}
while ((c = fgetc(f)) != EOF) {
PUTCHAR(c);
}
fclose(f);
}
FLUSH;
if (is_reset && reset_3string != 0) {
PUTS(reset_3string);
} else if (init_3string != 0) {
PUTS(init_3string);
}
FLUSH;
return 0;
}
if (strcmp(name, "longname") == 0) {
PUTS(longname());
return 0;
}
#if !PURE_TERMINFO
retry:
#endif
if ((status = tigetflag(name)) != -1) {
return exit_code(BOOLEAN, status);
} else if ((status = tigetnum(name)) != CANCELLED_NUMERIC) {
(void) printf("%d\n", status);
return exit_code(NUMBER, 0);
} else if ((s = tigetstr(name)) == CANCELLED_STRING) {
#if !PURE_TERMINFO
if (!termcap) {
const struct name_table_entry *np;
termcap = TRUE;
if ((np = _nc_find_entry(name, _nc_get_hash_table(termcap))) != 0) {
switch (np->nte_type) {
case BOOLEAN:
if (bool_from_termcap[np->nte_index])
name = boolnames[np->nte_index];
break;
case NUMBER:
if (num_from_termcap[np->nte_index])
name = numnames[np->nte_index];
break;
case STRING:
if (str_from_termcap[np->nte_index])
name = strnames[np->nte_index];
break;
}
goto retry;
}
}
#endif
quit(4, "unknown terminfo capability '%s'", name);
} else if (s != ABSENT_STRING) {
if (argc > 1) {
int k;
int popcount;
long numbers[1 + NUM_PARM];
char *strings[1 + NUM_PARM];
char *p_is_s[NUM_PARM];
/* Nasty hack time. The tparm function needs to see numeric
* parameters as numbers, not as pointers to their string
* representations
*/
for (k = 1; k < argc; k++) {
char *tmp = 0;
strings[k] = argv[k];
numbers[k] = strtol(argv[k], &tmp, 0);
if (tmp == 0 || *tmp != 0)
numbers[k] = 0;
}
for (k = argc; k <= NUM_PARM; k++) {
numbers[k] = 0;
strings[k] = 0;
}
switch (tparm_type(name)) {
case Num_Str:
s = TPARM_2(s, numbers[1], strings[2]);
break;
case Num_Str_Str:
s = TPARM_3(s, numbers[1], strings[2], strings[3]);
break;
case Numbers:
default:
(void) _nc_tparm_analyze(s, p_is_s, &popcount);
#define myParam(n) (p_is_s[n - 1] != 0 ? ((TPARM_ARG) strings[n]) : numbers[n])
s = TPARM_9(s,
myParam(1),
myParam(2),
myParam(3),
myParam(4),
myParam(5),
myParam(6),
myParam(7),
myParam(8),
myParam(9));
break;
}
}
/* use putp() in order to perform padding */
putp(s);
return exit_code(STRING, 0);
}
return exit_code(STRING, 1);
}
NCURSES_SP_NAME(_nc_do_color) (NCURSES_SP_DCLx
int old_pair,
int pair,
int reverse,
NCURSES_SP_OUTC outc)
{
#ifdef USE_TERM_DRIVER
CallDriver_4(SP_PARM, td_docolor, old_pair, pair, reverse, outc);
#else
NCURSES_COLOR_T fg = COLOR_DEFAULT;
NCURSES_COLOR_T bg = COLOR_DEFAULT;
NCURSES_COLOR_T old_fg = -1;
NCURSES_COLOR_T old_bg = -1;
if (!ValidPair(pair)) {
return;
} else if (pair != 0) {
if (set_color_pair) {
TPUTS_TRACE("set_color_pair");
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
TPARM_1(set_color_pair, pair),
1, outc);
return;
} else if (SP_PARM != 0) {
if (pair_content((NCURSES_COLOR_T) pair, &fg, &bg) == ERR)
return;
}
}
if (old_pair >= 0
&& SP_PARM != 0
&& pair_content((NCURSES_COLOR_T) old_pair, &old_fg, &old_bg) != ERR) {
if ((isDefaultColor(fg) && !isDefaultColor(old_fg))
|| (isDefaultColor(bg) && !isDefaultColor(old_bg))) {
#if NCURSES_EXT_FUNCS
/*
* A minor optimization - but extension. If "AX" is specified in
* the terminal description, treat it as screen's indicator of ECMA
* SGR 39 and SGR 49, and assume the two sequences are independent.
*/
if (SP_PARM->_has_sgr_39_49
&& isDefaultColor(old_bg)
&& !isDefaultColor(old_fg)) {
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx "\033[39m", 1, outc);
} else if (SP_PARM->_has_sgr_39_49
&& isDefaultColor(old_fg)
&& !isDefaultColor(old_bg)) {
NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx "\033[49m", 1, outc);
} else
#endif
reset_color_pair(NCURSES_SP_ARG);
}
} else {
reset_color_pair(NCURSES_SP_ARG);
}
#if NCURSES_EXT_FUNCS
if (isDefaultColor(fg))
fg = (NCURSES_COLOR_T) default_fg(NCURSES_SP_ARG);
if (isDefaultColor(bg))
bg = (NCURSES_COLOR_T) default_bg(NCURSES_SP_ARG);
#endif
if (reverse) {
NCURSES_COLOR_T xx = fg;
fg = bg;
bg = xx;
}
TR(TRACE_ATTRS, ("setting colors: pair = %d, fg = %d, bg = %d", pair,
fg, bg));
if (!isDefaultColor(fg)) {
set_foreground_color(NCURSES_SP_ARGx fg, outc);
}
if (!isDefaultColor(bg)) {
set_background_color(NCURSES_SP_ARGx bg, outc);
}
#endif
}
/* Output startup string. */
bool
send_init_strings(int fd GCC_UNUSED, TTY * old_settings)
{
int i;
bool need_flush = FALSE;
(void) old_settings;
#ifdef TAB3
if (old_settings != 0 &&
old_settings->c_oflag & (TAB3 | ONLCR | OCRNL | ONLRET)) {
old_settings->c_oflag &= (TAB3 | ONLCR | OCRNL | ONLRET);
SET_TTY(fd, old_settings);
}
#endif
if (use_reset || use_init) {
if (VALID_STRING(init_prog)) {
IGNORE_RC(system(init_prog));
}
need_flush |= sent_string((use_reset && (reset_1string != 0))
? reset_1string
: init_1string);
need_flush |= sent_string((use_reset && (reset_2string != 0))
? reset_2string
: init_2string);
#if defined(set_lr_margin)
if (VALID_STRING(set_lr_margin)) {
need_flush |= sent_string(TPARM_2(set_lr_margin, 0,
columns - 1));
} else
#endif
#if defined(set_left_margin_parm) && defined(set_right_margin_parm)
if (VALID_STRING(set_left_margin_parm)
&& VALID_STRING(set_right_margin_parm)) {
need_flush |= sent_string(TPARM_1(set_left_margin_parm, 0));
need_flush |= sent_string(TPARM_1(set_right_margin_parm,
columns - 1));
} else
#endif
if (VALID_STRING(clear_margins)
&& VALID_STRING(set_left_margin)
&& VALID_STRING(set_right_margin)) {
need_flush |= sent_string(clear_margins);
need_flush |= to_left_margin();
need_flush |= sent_string(set_left_margin);
if (VALID_STRING(parm_right_cursor)) {
need_flush |= sent_string(TPARM_1(parm_right_cursor,
columns - 1));
} else {
for (i = 0; i < columns - 1; i++) {
out_char(' ');
need_flush = TRUE;
}
}
need_flush |= sent_string(set_right_margin);
need_flush |= to_left_margin();
}
need_flush |= reset_tabstops(columns);
need_flush |= cat_file((use_reset && reset_file) ? reset_file : init_file);
need_flush |= sent_string((use_reset && (reset_3string != 0))
? reset_3string
: init_3string);
}
return need_flush;
}
