/* $OpenBSD: tty_update.c,v 1.16 2010/01/12 23:22:07 nicm Exp $ */

/****************************************************************************

 * Copyright (c) 1998-2007,2008 Free Software Foundation, Inc.              *

 *                                                                          *

 * Permission is hereby granted, free of charge, to any person obtaining a  *

 * copy of this software and associated documentation files (the            *

 * "Software"), to deal in the Software without restriction, including      *

 * without limitation the rights to use, copy, modify, merge, publish,      *

 * distribute, distribute with modifications, sublicense, and/or sell       *

 * copies of the Software, and to permit persons to whom the Software is    *

 * furnished to do so, subject to the following conditions:                 *

 *                                                                          *

 * The above copyright notice and this permission notice shall be included  *

 * in all copies or substantial portions of the Software.                   *

 *                                                                          *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS  *

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF               *

 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.   *

 * IN NO EVENT SHALL THE ABOVE COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,   *

 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR    *

 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR    *

 * THE USE OR OTHER DEALINGS IN THE SOFTWARE.                               *

 *                                                                          *

 * Except as contained in this notice, the name(s) of the above copyright   *

 * holders shall not be used in advertising or otherwise to promote the     *

 * sale, use or other dealings in this Software without prior written       *

 * authorization.                                                           *

 ****************************************************************************/

/****************************************************************************

 *  Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995               *

 *     and: Eric S. Raymond <esr@snark.thyrsus.com>                         *

 *     and: Thomas E. Dickey                        1996-on                 *

 ****************************************************************************/

/*-----------------------------------------------------------------

 *

 *	lib_doupdate.c

 *

 * 	The routine doupdate() and its dependents.

 * 	All physical output is concentrated here (except _nc_outch()

  *	in lib_tputs.c).

 *

 *-----------------------------------------------------------------*/

#include <curses.priv.h>

#if defined __HAIKU__ && defined __BEOS__

#undef __BEOS__

#endif

#ifdef __BEOS__

#undef false

#undef true

#include <OS.h>

#endif

#if defined(TRACE) && HAVE_SYS_TIMES_H && HAVE_TIMES

#define USE_TRACE_TIMES 1

#else

#define USE_TRACE_TIMES 0

#endif

#if HAVE_SYS_TIME_H && HAVE_SYS_TIME_SELECT

#include <sys/time.h>

#endif

#if USE_TRACE_TIMES

#include <sys/times.h>

#endif

#if USE_FUNC_POLL

#elif HAVE_SELECT

#if HAVE_SYS_SELECT_H

#include <sys/select.h>

#endif

#endif

#include <ctype.h>

#include <term.h>

MODULE_ID("$Id: tty_update.c,v 1.16 2010/01/12 23:22:07 nicm Exp $")

/*

 * This define controls the line-breakout optimization.  Every once in a

 * while during screen refresh, we want to check for input and abort the

 * update if there's some waiting.  CHECK_INTERVAL controls the number of

 * changed lines to be emitted between input checks.

 *

 * Note: Input-check-and-abort is no longer done if the screen is being

 * updated from scratch.  This is a feature, not a bug.

 */

#define CHECK_INTERVAL	5

#define FILL_BCE() (SP->_coloron && !SP->_default_color && !back_color_erase)

static const NCURSES_CH_T blankchar = NewChar(BLANK_TEXT);

static NCURSES_CH_T normal = NewChar(BLANK_TEXT);

/*

 * Enable checking to see if doupdate and friends are tracking the true

 * cursor position correctly.  NOTE: this is a debugging hack which will

 * work ONLY on ANSI-compatible terminals!

 */

/* #define POSITION_DEBUG */

static NCURSES_INLINE NCURSES_CH_T ClrBlank(WINDOW *win);

static int ClrBottom(int total);

static void ClearScreen(NCURSES_CH_T blank);

static void ClrUpdate(void);

static void DelChar(int count);

static void InsStr(NCURSES_CH_T * line, int count);

static void TransformLine(int const lineno);

#ifdef POSITION_DEBUG

/****************************************************************************

 *

 * Debugging code.  Only works on ANSI-standard terminals.

 *

 ****************************************************************************/

static void

position_check(int expected_y, int expected_x, char *legend)

/* check to see if the real cursor position matches the virtual */

{

    char buf[20];

    char *s;

    int y, x;

    if (!_nc_tracing || (expected_y < 0 && expected_x < 0))

	return;

    _nc_flush();

    memset(buf, '\0', sizeof(buf));

    putp("\033[6n");		/* only works on ANSI-compatibles */

    _nc_flush();

    *(s = buf) = 0;

    do {

	int ask = sizeof(buf) - 1 - (s - buf);

	int got = read(0, s, ask);

	if (got == 0)

	    break;

	s += got;

    } while (strchr(buf, 'R') == 0);

    _tracef("probe returned %s", _nc_visbuf(buf));

    /* try to interpret as a position report */

    if (sscanf(buf, "\033[%d;%dR", &y, &x) != 2) {

	_tracef("position probe failed in %s", legend);

    } else {

	if (expected_x < 0)

	    expected_x = x - 1;

	if (expected_y < 0)

	    expected_y = y - 1;

	if (y - 1 != expected_y || x - 1 != expected_x) {

	    beep();

	    tputs(tparm("\033[%d;%dH", expected_y + 1, expected_x + 1), 1, _nc_outch);

	    _tracef("position seen (%d, %d) doesn't match expected one (%d, %d) in %s",

		    y - 1, x - 1, expected_y, expected_x, legend);

	} else {

	    _tracef("position matches OK in %s", legend);

	}

    }

}

#else

#define position_check(expected_y, expected_x, legend)	/* nothing */

#endif /* POSITION_DEBUG */

/****************************************************************************

 *

 * Optimized update code

 *

 ****************************************************************************/

static NCURSES_INLINE void

GoTo(int const row, int const col)

{

    TR(TRACE_MOVE, ("GoTo(%d, %d) from (%d, %d)",

		    row, col, SP->_cursrow, SP->_curscol));

    position_check(SP->_cursrow, SP->_curscol, "GoTo");

    position_check(SP->_cursrow, SP->_curscol, "GoTo2");

}

static NCURSES_INLINE void

PutAttrChar(CARG_CH_T ch)

{

    int chlen = 1;

    TR(TRACE_CHARPUT, ("PutAttrChar(%s) at (%d, %d)",

		       _tracech_t(ch),

		       SP->_cursrow, SP->_curscol));

#if USE_WIDEC_SUPPORT

    /*

     * If this is not a valid character, there is nothing more to do.

     */

	TR(TRACE_CHARPUT, ("...skip"));

    }

    /*

     * Determine the number of character cells which the 'ch' value will use

     * on the screen.  It should be at least one.

     */

	static const NCURSES_CH_T blank = NewChar(BLANK_TEXT);

	/*

	 * If the character falls into any of these special cases, do

	 * not force the result to a blank:

	 *

	 * a) it is printable (this works around a bug in wcwidth()).

	 * b) use_legacy_coding() has been called to modify the treatment

	 *    of codes 128-255.

	 * c) the acs_map[] has been initialized to allow codes 0-31

	 *    to be rendered.  This supports Linux console's "PC"

	 *    characters.  Codes 128-255 are allowed though this is

	 *    not checked.

	 */

	    ;

	} else {

	    ch = CHREF(blank);

	    TR(TRACE_CHARPUT, ("forced to blank"));

	}

	chlen = 1;

    }

#endif

#if USE_WIDEC_SUPPORT

	/*

	 * This is crude & ugly, but works most of the time.  It checks if the

	 * acs_chars string specified that we have a mapping for this

	 * character, and uses the wide-character mapping when we expect the

	 * normal one to be broken (by mis-design ;-).

	 */

	}

#endif

	/*

	 * If we (still) have alternate character set, it is the normal 8bit

	 * flavor.  The _screen_acs_map[] array tells if the character was

	 * really in acs_chars, needed because of the way wide/normal line

	 * drawing flavors are integrated.

	 */

	    }

	}

	ch = CHREF(my_ch);

    }

	ch = CHREF(tilde);

    }

#if !USE_WIDEC_SUPPORT

    /* FIXME - we do this special case for signal handling, should see how to

     * make it work for wide characters.

     */

    if (SP->_outch != 0) {

	SP->_outch(UChar(ch));

    } else

#endif

    {

	COUNT_OUTCHARS(1);

    }

	TPUTS_TRACE("char_padding");

    }

}

static bool

check_pending(void)

/* check for pending input */

{

    bool have_pending = FALSE;

    /*

     * Only carry out this check when the flag is zero, otherwise we'll

     * have the refreshing slow down drastically (or stop) if there's an

     * unread character available.

     */

#if USE_FUNC_POLL

	    have_pending = TRUE;

	}

#elif defined(__BEOS__)

	/*

	 * BeOS's select() is declared in socket.h, so the configure script does

	 * not see it.  That's just as well, since that function works only for

	 * sockets.  This (using snooze and ioctl) was distilled from Be's patch

	 * for ncurses which uses a separate thread to simulate select().

	 *

	 * FIXME: the return values from the ioctl aren't very clear if we get

	 * interrupted.

	 */

	int n = 0;

	int howmany = ioctl(0, 'ichr', &n);

	if (howmany >= 0 && n > 0) {

	    have_pending = TRUE;

	}

#elif HAVE_SELECT

	fd_set fdset;

	struct timeval ktimeout;

	ktimeout.tv_sec =

	    ktimeout.tv_usec = 0;

	FD_ZERO(&fdset);

	FD_SET(SP->_checkfd, &fdset);

	if (select(SP->_checkfd + 1, &fdset, NULL, NULL, &ktimeout) != 0) {

	    have_pending = TRUE;

	}

#endif

    }

    }

}

/* put char at lower right corner */

static void

PutCharLR(const ARG_CH_T ch)

{

	/* we can put the char directly */

	/* we can suppress automargin */

	TPUTS_TRACE("exit_am_mode");

	position_check(SP->_cursrow, SP->_curscol, "exit_am_mode");

	TPUTS_TRACE("enter_am_mode");

    }

}

/*

 * Wrap the cursor position, i.e., advance to the beginning of the next line.

 */

static void

wrap_cursor(void)

{

	/*

	 * xenl can manifest two different ways.  The vt100 way is that, when

	 * you'd expect the cursor to wrap, it stays hung at the right margin

	 * (on top of the character just emitted) and doesn't wrap until the

	 * *next* graphic char is emitted.  The c100 way is to ignore LF

	 * received just after an am wrap.

	 *

	 * An aggressive way to handle this would be to emit CR/LF after the

	 * char and then assume the wrap is done, you're on the first position

	 * of the next line, and the terminal out of its weird state.  Here

	 * it's safe to just tell the code that the cursor is in hyperspace and

	 * let the next mvcur() call straighten things out.

	 */

	/*

	 * We've actually moved - but may have to work around problems with

	 * video attributes not working.

	 */

	    TR(TRACE_CHARPUT, ("turning off (%#lx) %s before wrapping",

			       (unsigned long) AttrOf(SCREEN_ATTRS(SP)),

			       _traceattr(AttrOf(SCREEN_ATTRS(SP)))));

	}

    } else {

    }

    position_check(SP->_cursrow, SP->_curscol, "wrap_cursor");

}

static NCURSES_INLINE void

PutChar(const ARG_CH_T ch)

/* insert character, handling automargin stuff */

{

    else

    position_check(SP->_cursrow, SP->_curscol, "PutChar");

}

/*

 * Check whether the given character can be output by clearing commands.  This

 * includes test for being a space and not including any 'bad' attributes, such

 * as A_REVERSE.  All attribute flags which don't affect appearance of a space

 * or can be output by clearing (A_COLOR in case of bce-terminal) are excluded.

 */

static NCURSES_INLINE bool

can_clear_with(ARG_CH_T ch)

{

#if NCURSES_EXT_FUNCS

	int pair;

	}

#else

	if (AttrOfD(ch) & A_COLOR)

	    return FALSE;

#endif

    }

}

/*

 * Issue a given span of characters from an array.

 * Must be functionally equivalent to:

 *	for (i = 0; i < num; i++)

 *	    PutChar(ntext[i]);

 * but can leave the cursor positioned at the middle of the interval.

 *

 * Returns: 0 - cursor is at the end of interval

 *	    1 - cursor is somewhere in the middle

 *

 * This code is optimized using ech and rep.

 */

static int

EmitRange(const NCURSES_CH_T * ntext, int num)

{

    int i;

    TR(TRACE_CHARPUT, ("EmitRange %d:%s", num, _nc_viscbuf(ntext, num)));

	    int runcount;

	    }

	    }

	    runcount = 2;

	    /*

	     * The cost expression in the middle isn't exactly right.

	     * _cup_ch_cost is an upper bound on the cost for moving to the

	     * end of the erased area, but not the cost itself (which we

	     * can't compute without emitting the move).  This may result

	     * in erase_chars not getting used in some situations for

	     * which it would be marginally advantageous.

	     */

		/*

		 * If this is the last part of the given interval,

		 * don't bother moving cursor, since it can be the

		 * last update on the line.

		 */

		} else {

		}

		int rep_count = runcount;

		      rep_count, _nc_outch);

	    }

	}

    }

}

/*

 * Output the line in the given range [first .. last]

 *

 * If there's a run of identical characters that's long enough to justify

 * cursor movement, use that also.

 *

 * Returns: same as EmitRange

 */

static int

PutRange(const NCURSES_CH_T * otext,

	 const NCURSES_CH_T * ntext,

	 int row,

	 int first, int last)

{

    int i, j, same;

    TR(TRACE_CHARPUT, ("PutRange(%p, %p, %d, %d, %d)",

		       otext, ntext, row, first, last));

		continue;

		}

		same = 0;

	    }

	}

	/*

	 * Always return 1 for the next GoTo() after a PutRange() if we found

	 * identical characters at end of interval

	 */

    }

}

/* leave unbracketed here so 'indent' works */

#define MARK_NOCHANGE(win,row) \

		win->_line[row].firstchar = _NOCHANGE; \

		win->_line[row].lastchar = _NOCHANGE; \

		if_USE_SCROLL_HINTS(win->_line[row].oldindex = row)

NCURSES_EXPORT(int)

doupdate(void)

{

    int i;

    int nonempty;

#if USE_TRACE_TIMES

    struct tms before, after;

#endif /* USE_TRACE_TIMES */

    T((T_CALLED("doupdate()")));

#ifdef TRACE

    if (USE_TRACEF(TRACE_UPDATE)) {

	if (curscr->_clear)

	    _tracef("curscr is clear");

	else

	    _tracedump("curscr", curscr);

	_tracedump("newscr", newscr);

	_nc_unlock_global(tracef);

    }

#endif /* TRACE */

#if USE_SIZECHANGE

	/*

	 * This is a transparent extension:  XSI does not address it,

	 * and applications need not know that ncurses can do it.

	 *

	 * Check if the terminal size has changed while curses was off

	 * (this can happen in an xterm, for example), and resize the

	 * ncurses data structures accordingly.

	 */

    }

#endif

	T(("coming back from shell mode"));

    }

#if USE_TRACE_TIMES

    /* zero the metering machinery */

    RESET_OUTCHARS();

    (void) times(&before);

#endif /* USE_TRACE_TIMES */

    /*

     * This is the support for magic-cookie terminals.  The theory:  we scan

     * the virtual screen looking for attribute turnons.  Where we find one,

     * check to make sure it's realizable by seeing if the required number of

     * un-attributed blanks are present before and after the attributed range;

     * try to shift the range boundaries over blanks (not changing the screen

     * display) so this becomes true.  If it is, shift the beginning attribute

     * change appropriately (the end one, if we've gotten this far, is

     * guaranteed room for its cookie).  If not, nuke the added attributes out

     * of the span.

     */

#if USE_XMC_SUPPORT

    if (magic_cookie_glitch > 0) {

	int j, k;

	attr_t rattr = A_NORMAL;

	for (i = 0; i < screen_lines; i++) {

	    for (j = 0; j < screen_columns; j++) {

		bool failed = FALSE;

		NCURSES_CH_T *thisline = newscr->_line[i].text;

		attr_t thisattr = AttrOf(thisline[j]) & SP->_xmc_triggers;

		attr_t turnon = thisattr & ~rattr;

		/* is an attribute turned on here? */

		if (turnon == 0) {

		    rattr = thisattr;

		    continue;

		}

		TR(TRACE_ATTRS, ("At (%d, %d): from %s...", i, j, _traceattr(rattr)));

		TR(TRACE_ATTRS, ("...to %s", _traceattr(turnon)));

		/*

		 * If the attribute change location is a blank with a "safe"

		 * attribute, undo the attribute turnon.  This may ensure

		 * there's enough room to set the attribute before the first

		 * non-blank in the run.

		 */

#define SAFE(a)	(!((a) & SP->_xmc_triggers))

		if (ISBLANK(thisline[j]) && SAFE(turnon)) {

		    RemAttr(thisline[j], turnon);

		    continue;

		}

		/* check that there's enough room at start of span */

		for (k = 1; k <= magic_cookie_glitch; k++) {

		    if (j - k < 0

			|| !ISBLANK(thisline[j - k])

			|| !SAFE(AttrOf(thisline[j - k]))) {

			failed = TRUE;

			TR(TRACE_ATTRS, ("No room at start in %d,%d%s%s",

					 i, j - k,

					 (ISBLANK(thisline[j - k])

					  ? ""

					  : ":nonblank"),

					 (SAFE(AttrOf(thisline[j - k]))

					  ? ""

					  : ":unsafe")));

			break;

		    }

		}

		if (!failed) {

		    bool end_onscreen = FALSE;

		    int m, n = j;

		    /* find end of span, if it's onscreen */

		    for (m = i; m < screen_lines; m++) {

			for (; n < screen_columns; n++) {

			    attr_t testattr = AttrOf(newscr->_line[m].text[n]);

			    if ((testattr & SP->_xmc_triggers) == rattr) {

				end_onscreen = TRUE;

				TR(TRACE_ATTRS,

				   ("Range attributed with %s ends at (%d, %d)",

				    _traceattr(turnon), m, n));

				goto foundit;

			    }

			}

			n = 0;

		    }

		    TR(TRACE_ATTRS,

		       ("Range attributed with %s ends offscreen",

			_traceattr(turnon)));

		  foundit:;

		    if (end_onscreen) {

			NCURSES_CH_T *lastline = newscr->_line[m].text;

			/*

			 * If there are safely-attributed blanks at the end of

			 * the range, shorten the range.  This will help ensure

			 * that there is enough room at end of span.

			 */

			while (n >= 0

			       && ISBLANK(lastline[n])

			       && SAFE(AttrOf(lastline[n]))) {

			    RemAttr(lastline[n--], turnon);

			}

			/* check that there's enough room at end of span */

			for (k = 1; k <= magic_cookie_glitch; k++) {

			    if (n + k >= screen_columns

				|| !ISBLANK(lastline[n + k])

				|| !SAFE(AttrOf(lastline[n + k]))) {

				failed = TRUE;

				TR(TRACE_ATTRS,

				   ("No room at end in %d,%d%s%s",

				    i, j - k,

				    (ISBLANK(lastline[n + k])

				     ? ""

				     : ":nonblank"),

				    (SAFE(AttrOf(lastline[n + k]))

				     ? ""

				     : ":unsafe")));

				break;

			    }

			}

		    }

		}

		if (failed) {

		    int p, q = j;

		    TR(TRACE_ATTRS,

		       ("Clearing %s beginning at (%d, %d)",

			_traceattr(turnon), i, j));

		    /* turn off new attributes over span */

		    for (p = i; p < screen_lines; p++) {

			for (; q < screen_columns; q++) {

			    attr_t testattr = AttrOf(newscr->_line[p].text[q]);

			    if ((testattr & SP->_xmc_triggers) == rattr)

				goto foundend;

			    RemAttr(newscr->_line[p].text[q], turnon);

			}

			q = 0;

		    }

		  foundend:;

		} else {

		    TR(TRACE_ATTRS,

		       ("Cookie space for %s found before (%d, %d)",

			_traceattr(turnon), i, j));

		    /*

		     * Back up the start of range so there's room for cookies

		     * before the first nonblank character.

		     */

		    for (k = 1; k <= magic_cookie_glitch; k++)

			AddAttr(thisline[j - k], turnon);

		}

		rattr = thisattr;

	    }

	}

#ifdef TRACE

	/* show altered highlights after magic-cookie check */

	if (USE_TRACEF(TRACE_UPDATE)) {

	    _tracef("After magic-cookie check...");

	    _tracedump("newscr", newscr);

	    _nc_unlock_global(tracef);

	}

#endif /* TRACE */

    }

#endif /* USE_XMC_SUPPORT */

    nonempty = 0;

	int changedlines = CHECK_INTERVAL;

	}

	TR(TRACE_UPDATE, ("Transforming lines, nonempty %d", nonempty));

	    /*

	     * Here is our line-breakout optimization.

	     */

		changedlines = 0;

	    }

	    /*

	     * newscr->line[i].firstchar is normally set

	     * by wnoutrefresh.  curscr->line[i].firstchar

	     * is normally set by _nc_scroll_window in the

	     * vertical-movement optimization code,

	     */

	    }

	    /* mark line changed successfully */

	    }

	    }

	}

    }

    /* put everything back in sync */

    }

    }

    }

  cleanup:

    /*

     * We would like to keep the physical screen in normal mode in case we get

     * other processes writing to the screen.  This goal cannot be met for

     * magic cookies since it interferes with attributes that may propagate

     * past the current position.

     */

#if USE_XMC_SUPPORT

    if (magic_cookie_glitch != 0)

#endif

#if USE_TRACE_TIMES

    (void) times(&after);

    TR(TRACE_TIMES,

       ("Update cost: %ld chars, %ld clocks system time, %ld clocks user time",

	_nc_outchars,

	(long) (after.tms_stime - before.tms_stime),

	(long) (after.tms_utime - before.tms_utime)));

#endif /* USE_TRACE_TIMES */

}

/*

 *	ClrBlank(win)

 *

 *	Returns the attributed character that corresponds to the "cleared"

 *	screen.  If the terminal has the back-color-erase feature, this will be

 *	colored according to the wbkgd() call.

 *

 *	We treat 'curscr' specially because it isn't supposed to be set directly

 *	in the wbkgd() call.  Assume 'stdscr' for this case.

 */

#define BCE_ATTRS (A_NORMAL|A_COLOR)

#define BCE_BKGD(win) (((win) == curscr ? stdscr : (win))->_nc_bkgd)

static NCURSES_INLINE NCURSES_CH_T

ClrBlank(WINDOW *win)

{

}

/*

**	ClrUpdate()

**

**	Update by clearing and redrawing the entire screen.

**

*/

static void

ClrUpdate(void)

{

    int i;

    TR(TRACE_UPDATE, (T_CALLED("ClrUpdate")));

    TR(TRACE_UPDATE, ("updating screen from scratch"));

    TR(TRACE_UPDATE, (T_RETURN("")));

}