*
* The routine doupdate() and its dependents.
* All physical output is concentrated here (except _nc_outch()
- * in lib_tputs.c).
+ * in lib_tputs.c).
*
*-----------------------------------------------------------------*/
#endif
#include <ctype.h>
-#include <term.h>
-MODULE_ID("$Id: tty_update.c,v 1.250 2009/04/18 23:32:17 tom Exp $")
+MODULE_ID("$Id: tty_update.c,v 1.251 2009/04/25 23:46:09 tom Exp $")
/*
* This define controls the line-breakout optimization. Every once in a
*/
#define CHECK_INTERVAL 5
-#define FILL_BCE() (SP->_coloron && !SP->_default_color && !back_color_erase)
+#define FILL_BCE(sp) (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);
/* #define POSITION_DEBUG */
static NCURSES_INLINE NCURSES_CH_T ClrBlank(WINDOW *win);
-static void DelChar(int count);
-static void InsStr(NCURSES_CH_T * line, int count);
#if NCURSES_SP_FUNCS
-static void ClearScreen(SCREEN *, NCURSES_CH_T blank);
static int ClrBottom(SCREEN *, int total);
+static void ClearScreen(SCREEN *, NCURSES_CH_T blank);
static void ClrUpdate(SCREEN *);
+static void DelChar(SCREEN *, int count);
+static void InsStr(SCREEN *, NCURSES_CH_T * line, int count);
static void TransformLine(SCREEN *, int const lineno);
#else
-static void ClearScreen(NCURSES_CH_T blank);
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);
#endif
****************************************************************************/
static void
-position_check(int expected_y, int expected_x, char *legend)
+position_check(SCREEN *sp, int expected_y, int expected_x, char *legend)
/* check to see if the real cursor position matches the virtual */
{
char buf[20];
if (!_nc_tracing || (expected_y < 0 && expected_x < 0))
return;
- _nc_flush();
+ NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
memset(buf, '\0', sizeof(buf));
putp("\033[6n"); /* only works on ANSI-compatibles */
- _nc_flush();
+ NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
*(s = buf) = 0;
do {
int ask = sizeof(buf) - 1 - (s - buf);
}
}
#else
-#define position_check(expected_y, expected_x, legend) /* nothing */
+#define position_check(sp, expected_y, expected_x, legend) /* nothing */
#endif /* POSITION_DEBUG */
/****************************************************************************
****************************************************************************/
static NCURSES_INLINE void
-GoTo(int const row, int const col)
+GoTo(NCURSES_SP_DCLx int const row, int const col)
{
TR(TRACE_MOVE, ("GoTo(%d, %d) from (%d, %d)",
- row, col, SP->_cursrow, SP->_curscol));
+ row, col, SP_PARM->_cursrow, SP_PARM->_curscol));
- position_check(SP->_cursrow, SP->_curscol, "GoTo");
+ position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "GoTo");
- mvcur(SP->_cursrow, SP->_curscol, row, col);
- position_check(SP->_cursrow, SP->_curscol, "GoTo2");
+ mvcur(SP_PARM->_cursrow, SP_PARM->_curscol, row, col);
+ position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "GoTo2");
}
static NCURSES_INLINE void
-PutAttrChar(CARG_CH_T ch)
+PutAttrChar(NCURSES_SP_DCLx CARG_CH_T ch)
{
int chlen = 1;
NCURSES_CH_T my_ch;
TR(TRACE_CHARPUT, ("PutAttrChar(%s) at (%d, %d)",
_tracech_t(ch),
- SP->_cursrow, SP->_curscol));
+ SP_PARM->_cursrow, SP_PARM->_curscol));
#if USE_WIDEC_SUPPORT
/*
* If this is not a valid character, there is nothing more to do.
*/
if (is8bits(CharOf(CHDEREF(ch)))
&& (isprint(CharOf(CHDEREF(ch)))
- || (SP->_legacy_coding > 0 && CharOf(CHDEREF(ch)) >= 160)
- || (SP->_legacy_coding > 1 && CharOf(CHDEREF(ch)) >= 128)
+ || (SP_PARM->_legacy_coding > 0 && CharOf(CHDEREF(ch)) >= 160)
+ || (SP_PARM->_legacy_coding > 1 && CharOf(CHDEREF(ch)) >= 128)
|| (AttrOf(attr) & A_ALTCHARSET
&& ((CharOfD(ch) < ACS_LEN
- && SP->_acs_map != 0
- && SP->_acs_map[CharOfD(ch)] != 0)
+ && SP_PARM->_acs_map != 0
+ && SP_PARM->_acs_map[CharOfD(ch)] != 0)
|| (CharOfD(ch) >= 128))))) {
;
} else {
#endif
if ((AttrOf(attr) & A_ALTCHARSET)
- && SP->_acs_map != 0
+ && SP_PARM->_acs_map != 0
&& CharOfD(ch) < ACS_LEN) {
my_ch = CHDEREF(ch); /* work around const param */
#if USE_WIDEC_SUPPORT
* character, and uses the wide-character mapping when we expect the
* normal one to be broken (by mis-design ;-).
*/
- if (SP->_screen_acs_fix
- && SP->_screen_acs_map[CharOf(my_ch)]) {
+ if (SP_PARM->_screen_acs_fix
+ && SP_PARM->_screen_acs_map[CharOf(my_ch)]) {
RemAttr(attr, A_ALTCHARSET);
my_ch = _nc_wacs[CharOf(my_ch)];
}
*/
if (AttrOf(attr) & A_ALTCHARSET) {
int j = CharOfD(ch);
- chtype temp = UChar(SP->_acs_map[j]);
+ chtype temp = UChar(SP_PARM->_acs_map[j]);
- if (!(SP->_screen_acs_map[j])) {
+ if (!(SP_PARM->_screen_acs_map[j])) {
RemAttr(attr, A_ALTCHARSET);
if (temp == 0)
temp = ' ';
ch = CHREF(tilde);
}
- UpdateAttrs(attr);
+ UpdateAttrs(SP_PARM, attr);
#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));
+ if (SP_PARM->_outch != 0) {
+ SP_PARM->_outch(UChar(ch));
} else
#endif
{
- PUTC(CHDEREF(ch), SP->_ofp); /* macro's fastest... */
+ PUTC(CHDEREF(ch), SP_PARM->_ofp); /* macro's fastest... */
COUNT_OUTCHARS(1);
}
- SP->_curscol += chlen;
+ SP_PARM->_curscol += chlen;
if (char_padding) {
TPUTS_TRACE("char_padding");
putp(char_padding);
}
static bool
-check_pending(void)
+check_pending(NCURSES_SP_DCL0)
/* check for pending input */
{
bool have_pending = FALSE;
* have the refreshing slow down drastically (or stop) if there's an
* unread character available.
*/
- if (SP->_fifohold != 0)
+ if (SP_PARM->_fifohold != 0)
return FALSE;
- if (SP->_checkfd >= 0) {
+ if (SP_PARM->_checkfd >= 0) {
#if USE_FUNC_POLL
struct pollfd fds[1];
- fds[0].fd = SP->_checkfd;
+ fds[0].fd = SP_PARM->_checkfd;
fds[0].events = POLLIN;
if (poll(fds, 1, 0) > 0) {
have_pending = TRUE;
ktimeout.tv_usec = 0;
FD_ZERO(&fdset);
- FD_SET(SP->_checkfd, &fdset);
- if (select(SP->_checkfd + 1, &fdset, NULL, NULL, &ktimeout) != 0) {
+ FD_SET(SP_PARM->_checkfd, &fdset);
+ if (select(SP_PARM->_checkfd + 1, &fdset, NULL, NULL, &ktimeout) != 0) {
have_pending = TRUE;
}
#endif
}
if (have_pending) {
- SP->_fifohold = 5;
- _nc_flush();
+ SP_PARM->_fifohold = 5;
+ NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
}
return FALSE;
}
{
if (!auto_right_margin) {
/* we can put the char directly */
- PutAttrChar(ch);
+ PutAttrChar(NCURSES_SP_ARGx ch);
} else if (enter_am_mode && exit_am_mode) {
/* we can suppress automargin */
TPUTS_TRACE("exit_am_mode");
putp(exit_am_mode);
- PutAttrChar(ch);
+ PutAttrChar(NCURSES_SP_ARGx ch);
SP_PARM->_curscol--;
- position_check(SP_PARM->_cursrow, SP_PARM->_curscol, "exit_am_mode");
+ position_check(SP_PARM,
+ SP_PARM->_cursrow,
+ SP_PARM->_curscol,
+ "exit_am_mode");
TPUTS_TRACE("enter_am_mode");
putp(enter_am_mode);
} else if ((enter_insert_mode && exit_insert_mode)
|| insert_character || parm_ich) {
- GoTo(screen_lines(SP_PARM) - 1, screen_columns(SP_PARM) - 2);
- PutAttrChar(ch);
- GoTo(screen_lines(SP_PARM) - 1, screen_columns(SP_PARM) - 2);
- InsStr(newscr->_line[screen_lines(SP_PARM) - 1].text
- + screen_columns(SP_PARM) - 2,
- 1);
+ GoTo(NCURSES_SP_ARGx
+ screen_lines(SP_PARM) - 1,
+ screen_columns(SP_PARM) - 2);
+ PutAttrChar(NCURSES_SP_ARGx ch);
+ GoTo(NCURSES_SP_ARGx
+ screen_lines(SP_PARM) - 1,
+ screen_columns(SP_PARM) - 2);
+ InsStr(NCURSES_SP_ARGx
+ newscr->_line[screen_lines(SP_PARM) - 1].text +
+ screen_columns(SP_PARM) - 2, 1);
}
}
* Wrap the cursor position, i.e., advance to the beginning of the next line.
*/
static void
-wrap_cursor(void)
+wrap_cursor(NCURSES_SP_DCL0)
{
if (eat_newline_glitch) {
/*
* it's safe to just tell the code that the cursor is in hyperspace and
* let the next mvcur() call straighten things out.
*/
- SP->_curscol = -1;
- SP->_cursrow = -1;
+ SP_PARM->_curscol = -1;
+ SP_PARM->_cursrow = -1;
} else if (auto_right_margin) {
- SP->_curscol = 0;
- SP->_cursrow++;
+ SP_PARM->_curscol = 0;
+ SP_PARM->_cursrow++;
/*
* We've actually moved - but may have to work around problems with
* video attributes not working.
*/
- if (!move_standout_mode && AttrOf(SCREEN_ATTRS(SP))) {
+ if (!move_standout_mode && AttrOf(SCREEN_ATTRS(SP_PARM))) {
TR(TRACE_CHARPUT, ("turning off (%#lx) %s before wrapping",
- (unsigned long) AttrOf(SCREEN_ATTRS(SP)),
- _traceattr(AttrOf(SCREEN_ATTRS(SP)))));
+ (unsigned long) AttrOf(SCREEN_ATTRS(SP_PARM)),
+ _traceattr(AttrOf(SCREEN_ATTRS(SP_PARM)))));
(void) VIDATTR(A_NORMAL, 0);
}
} else {
- SP->_curscol--;
+ SP_PARM->_curscol--;
}
- position_check(SP->_cursrow, SP->_curscol, "wrap_cursor");
+ position_check(SP_PARM,
+ SP_PARM->_cursrow,
+ SP_PARM->_curscol,
+ "wrap_cursor");
}
static NCURSES_INLINE void
PutChar(NCURSES_SP_DCLx const ARG_CH_T ch)
/* insert character, handling automargin stuff */
{
- if (SP_PARM->_cursrow == screen_lines(SP_PARM) - 1
- && SP_PARM->_curscol == screen_columns(SP_PARM) - 1)
+ if (SP_PARM->_cursrow == screen_lines(SP_PARM) - 1 &&
+ SP_PARM->_curscol == screen_columns(SP_PARM) - 1) {
PutCharLR(NCURSES_SP_ARGx ch);
- else
- PutAttrChar(ch);
+ } else {
+ PutAttrChar(NCURSES_SP_ARGx ch);
+ }
if (SP_PARM->_curscol >= screen_columns(SP_PARM))
- wrap_cursor();
+ wrap_cursor(NCURSES_SP_ARG);
- position_check(SP_PARM->_cursrow, SP_PARM->_curscol, "PutChar");
+ position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "PutChar");
}
/*
* 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)
+can_clear_with(NCURSES_SP_DCLx ARG_CH_T ch)
{
- if (!back_color_erase && SP->_coloron) {
+ if (!back_color_erase && SP_PARM->_coloron) {
#if NCURSES_EXT_FUNCS
int pair;
- if (!SP->_default_color)
+ if (!SP_PARM->_default_color)
return FALSE;
- if (SP->_default_fg != C_MASK || SP->_default_bg != C_MASK)
+ if (SP_PARM->_default_fg != C_MASK || SP_PARM->_default_bg != C_MASK)
return FALSE;
if ((pair = GetPair(CHDEREF(ch))) != 0) {
short fg, bg;
- pair_content(pair, &fg, &bg);
+ NCURSES_SP_NAME(pair_content) (NCURSES_SP_ARGx pair, &fg, &bg);
if (fg != C_MASK || bg != C_MASK)
return FALSE;
}
*/
if (erase_chars
&& runcount > SP_PARM->_ech_cost + SP_PARM->_cup_ch_cost
- && can_clear_with(CHREF(ntext0))) {
- UpdateAttrs(ntext0);
+ && can_clear_with(NCURSES_SP_ARGx CHREF(ntext0))) {
+ UpdateAttrs(SP_PARM, ntext0);
putp(TPARM_1(erase_chars, runcount));
/*
* last update on the line.
*/
if (runcount < num) {
- GoTo(SP_PARM->_cursrow, SP_PARM->_curscol + runcount);
+ GoTo(NCURSES_SP_ARGx
+ SP_PARM->_cursrow,
+ SP_PARM->_curscol + runcount);
} else {
return 1; /* cursor stays in the middle */
}
} else if (repeat_char && runcount > SP_PARM->_rep_cost) {
- bool wrap_possible = (SP_PARM->_curscol + runcount
- >= screen_columns(SP_PARM));
+ bool wrap_possible = (SP_PARM->_curscol + runcount >=
+ screen_columns(SP_PARM));
int rep_count = runcount;
if (wrap_possible)
rep_count--;
- UpdateAttrs(ntext0);
+ UpdateAttrs(SP_PARM, ntext0);
tputs(TPARM_2(repeat_char, CharOf(ntext0), rep_count),
rep_count, _nc_outch);
SP_PARM->_curscol += rep_count;
{
int i, j, same;
- TR(TRACE_CHARPUT, ("PutRange(%p, %p, %d, %d, %d)",
- otext, ntext, row, first, last));
+ TR(TRACE_CHARPUT, ("PutRange(%p, %p, %p, %d, %d, %d)",
+ SP_PARM, otext, ntext, row, first, last));
if (otext != ntext
&& (last - first + 1) > SP_PARM->_inline_cost) {
} else {
if (same > SP_PARM->_inline_cost) {
EmitRange(NCURSES_SP_ARGx ntext + first, j - same - first);
- GoTo(row, first = j);
+ GoTo(NCURSES_SP_ARGx row, first = j);
}
same = 0;
}
if (SP_PARM->_endwin) {
T(("coming back from shell mode"));
- reset_prog_mode();
+ NCURSES_SP_NAME(reset_prog_mode) (NCURSES_SP_ARG);
- _nc_mvcur_resume();
- _nc_screen_resume();
+ NCURSES_SP_NAME(_nc_mvcur_resume) (NCURSES_SP_ARG);
+ NCURSES_SP_NAME(_nc_screen_resume) (NCURSES_SP_ARG);
SP_PARM->_mouse_resume(SP_PARM);
SP_PARM->_endwin = FALSE;
* there's enough room to set the attribute before the first
* non-blank in the run.
*/
-#define SAFE(a) (!((a) & SP_PARM->_xmc_triggers))
- if (ISBLANK(thisline[j]) && SAFE(turnon)) {
+#define SAFE(scr,a) (!((a) & (scr)->_xmc_triggers))
+ if (ISBLANK(thisline[j]) && SAFE(SP_PARM, turnon)) {
RemAttr(thisline[j], turnon);
continue;
}
for (k = 1; k <= magic_cookie_glitch; k++) {
if (j - k < 0
|| !ISBLANK(thisline[j - k])
- || !SAFE(AttrOf(thisline[j - k]))) {
+ || !SAFE(SP_PARM, 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]))
+ (SAFE(SP_PARM, AttrOf(thisline[j - k]))
? ""
: ":unsafe")));
break;
*/
while (n >= 0
&& ISBLANK(lastline[n])
- && SAFE(AttrOf(lastline[n]))) {
+ && SAFE(SP_PARM, AttrOf(lastline[n]))) {
RemAttr(lastline[n--], turnon);
}
for (k = 1; k <= magic_cookie_glitch; k++) {
if (n + k >= screen_columns(SP_PARM)
|| !ISBLANK(lastline[n + k])
- || !SAFE(AttrOf(lastline[n + k]))) {
+ || !SAFE(SP_PARM, AttrOf(lastline[n + k]))) {
failed = TRUE;
TR(TRACE_ATTRS,
("No room at end in %d,%d%s%s",
(ISBLANK(lastline[n + k])
? ""
: ":nonblank"),
- (SAFE(AttrOf(lastline[n + k]))
+ (SAFE(SP_PARM, AttrOf(lastline[n + k]))
? ""
: ":unsafe")));
break;
} else {
int changedlines = CHECK_INTERVAL;
- if (check_pending())
+ if (check_pending(NCURSES_SP_ARG))
goto cleanup;
nonempty = min(screen_lines(SP_PARM), newscr->_maxy + 1);
* Here is our line-breakout optimization.
*/
if (changedlines == CHECK_INTERVAL) {
- if (check_pending())
+ if (check_pending(NCURSES_SP_ARG))
goto cleanup;
changedlines = 0;
}
curscr->_curx = newscr->_curx;
curscr->_cury = newscr->_cury;
- GoTo(curscr->_cury, curscr->_curx);
+ GoTo(NCURSES_SP_ARGx curscr->_cury, curscr->_curx);
}
cleanup:
#if USE_XMC_SUPPORT
if (magic_cookie_glitch != 0)
#endif
- UpdateAttrs(normal);
+ UpdateAttrs(SP_PARM, normal);
- _nc_flush();
+ NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
WINDOW_ATTRS(curscr) = WINDOW_ATTRS(newscr);
#if USE_TRACE_TIMES
static void
ClrUpdate(NCURSES_SP_DCL0)
{
- int i;
- NCURSES_CH_T blank = ClrBlank(stdscr);
- int nonempty = min(screen_lines(SP_PARM), newscr->_maxy + 1);
-
TR(TRACE_UPDATE, (T_CALLED("ClrUpdate")));
+ if (0 != SP_PARM) {
+ int i;
+ NCURSES_CH_T blank = ClrBlank(stdscr);
+ int nonempty = min(screen_lines(SP_PARM), newscr->_maxy + 1);
- ClearScreen(NCURSES_SP_ARGx blank);
-
- TR(TRACE_UPDATE, ("updating screen from scratch"));
+ ClearScreen(NCURSES_SP_ARGx blank);
- nonempty = ClrBottom(NCURSES_SP_ARGx nonempty);
+ TR(TRACE_UPDATE, ("updating screen from scratch"));
- for (i = 0; i < nonempty; i++)
- TransformLine(NCURSES_SP_ARGx i);
+ nonempty = ClrBottom(NCURSES_SP_ARGx nonempty);
+ for (i = 0; i < nonempty; i++)
+ TransformLine(NCURSES_SP_ARGx i);
+ }
TR(TRACE_UPDATE, (T_RETURN("")));
}
}
if (needclear) {
- UpdateAttrs(blank);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("clr_eol");
if (clr_eol && SP_PARM->_el_cost <= (screen_columns(SP_PARM) - SP_PARM->_curscol)) {
putp(clr_eol);
{
int row, col;
+ if (0 == SP_PARM)
+ return;
+
row = SP_PARM->_cursrow;
col = SP_PARM->_curscol;
- UpdateAttrs(blank);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("clr_eos");
tputs(clr_eos, screen_lines(SP_PARM) - row, _nc_outch);
NCURSES_CH_T blank = newscr->_line[total - 1].text[last - 1];
bool ok;
- if (clr_eos && can_clear_with(CHREF(blank))) {
+ if (clr_eos && can_clear_with(NCURSES_SP_ARGx CHREF(blank))) {
for (row = total - 1; row >= 0; row--) {
for (col = 0, ok = TRUE; ok && col < last; col++) {
/* don't use clr_eos for just one line if clr_eol available */
if (top < total) {
- GoTo(top, 0);
+ GoTo(NCURSES_SP_ARGx top, 0);
ClrToEOS(NCURSES_SP_ARGx blank);
if (SP_PARM->oldhash && SP_PARM->newhash) {
for (row = top; row < screen_lines(SP_PARM); row++)
#if USE_XMC_SUPPORT
#if USE_WIDEC_SUPPORT
-#define check_xmc_transition(a, b) \
- ((((a)->attr ^ (b)->attr) & ~((a)->attr) & SP->_xmc_triggers) != 0)
-#define xmc_turn_on(a,b) check_xmc_transition(&(a), &(b))
+#define check_xmc_transition(sp, a, b) \
+ ((((a)->attr ^ (b)->attr) & ~((a)->attr) & (sp)->_xmc_triggers) != 0)
+#define xmc_turn_on(sp,a,b) check_xmc_transition(sp,&(a), &(b))
#else
-#define xmc_turn_on(a,b) ((((a)^(b)) & ~(a) & SP->_xmc_triggers) != 0)
+#define xmc_turn_on(sp,a,b) ((((a)^(b)) & ~(a) & (sp)->_xmc_triggers) != 0)
#endif
-#define xmc_new(r,c) newscr->_line[r].text[c]
-#define xmc_turn_off(a,b) xmc_turn_on(b,a)
+#define xmc_new(sp,r,c) newscr->_line[r].text[c]
+#define xmc_turn_off(sp,a,b) xmc_turn_on(sp,b,a)
#endif /* USE_XMC_SUPPORT */
/*
int n;
bool attrchanged = FALSE;
- TR(TRACE_UPDATE, (T_CALLED("TransformLine(%d)"), lineno));
+ TR(TRACE_UPDATE, (T_CALLED("TransformLine(%p, %d)"), SP_PARM, lineno));
/* copy new hash value to old one */
if (SP_PARM->oldhash && SP_PARM->newhash)
firstChar = 0;
if (attrchanged) { /* we may have to disregard the whole line */
- GoTo(lineno, firstChar);
+ GoTo(NCURSES_SP_ARGx lineno, firstChar);
ClrToEOL(NCURSES_SP_ARGx ClrBlank(curscr), FALSE);
- PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
- 0, (screen_columns(SP_PARM) - 1));
+ PutRange(NCURSES_SP_ARGx
+ oldLine, newLine, lineno, 0,
+ screen_columns(SP_PARM) - 1);
#if USE_XMC_SUPPORT
/*
* following operation.
*/
} else if (magic_cookie_glitch > 0) {
- GoTo(lineno, firstChar);
+ GoTo(NCURSES_SP_ARGx lineno, firstChar);
for (n = 0; n < screen_columns(SP_PARM); n++) {
int m = n + magic_cookie_glitch;
*/
if (ISBLANK(newLine[n])
&& ((n > 0
- && xmc_turn_on(newLine[n - 1], newLine[n]))
+ && xmc_turn_on(SP_PARM, newLine[n - 1], newLine[n]))
|| (n == 0
&& lineno > 0
- && xmc_turn_on(xmc_new(lineno - 1, screen_columns(SP_PARM) - 1),
+ && xmc_turn_on(SP_PARM,
+ xmc_new(SP_PARM, lineno - 1,
+ screen_columns(SP_PARM) - 1),
newLine[n])))) {
n = m;
}
*/
if (!ISBLANK(newLine[n])
&& ((n + 1 < screen_columns(SP_PARM)
- && xmc_turn_off(newLine[n], newLine[n + 1]))
+ && xmc_turn_off(SP_PARM, newLine[n], newLine[n + 1]))
|| (n + 1 >= screen_columns(SP_PARM)
&& lineno + 1 < screen_lines(SP_PARM)
- && xmc_turn_off(newLine[n], xmc_new(lineno + 1, 0))))) {
+ && xmc_turn_off(SP_PARM,
+ newLine[n],
+ xmc_new(SP_PARM, lineno + 1, 0))))) {
n = m;
}
/* it may be cheap to clear leading whitespace with clr_bol */
blank = newLine[0];
- if (clr_bol && can_clear_with(CHREF(blank))) {
+ if (clr_bol && can_clear_with(NCURSES_SP_ARGx CHREF(blank))) {
int oFirstChar, nFirstChar;
for (oFirstChar = 0;
if (SP_PARM->_el1_cost < nFirstChar - oFirstChar) {
if (nFirstChar >= screen_columns(SP_PARM)
&& SP_PARM->_el_cost <= SP_PARM->_el1_cost) {
- GoTo(lineno, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx lineno, 0);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("clr_eol");
putp(clr_eol);
} else {
- GoTo(lineno, nFirstChar - 1);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx lineno, nFirstChar - 1);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("clr_bol");
putp(clr_bol);
}
blank = newLine[screen_columns(SP_PARM) - 1];
- if (!can_clear_with(CHREF(blank))) {
+ if (!can_clear_with(NCURSES_SP_ARGx CHREF(blank))) {
/* find the last differing character */
nLastChar = screen_columns(SP_PARM) - 1;
nLastChar--;
if (nLastChar >= firstChar) {
- GoTo(lineno, firstChar);
- PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
- firstChar, nLastChar);
+ GoTo(NCURSES_SP_ARGx lineno, firstChar);
+ PutRange(NCURSES_SP_ARGx
+ oldLine,
+ newLine,
+ lineno,
+ firstChar,
+ nLastChar);
memcpy(oldLine + firstChar,
newLine + firstChar,
(nLastChar - firstChar + 1) * sizeof(NCURSES_CH_T));
if ((nLastChar == firstChar)
&& (SP_PARM->_el_cost < (oLastChar - nLastChar))) {
- GoTo(lineno, firstChar);
+ GoTo(NCURSES_SP_ARGx lineno, firstChar);
if (!CharEq(newLine[firstChar], blank))
PutChar(NCURSES_SP_ARGx CHREF(newLine[firstChar]));
ClrToEOL(NCURSES_SP_ARGx blank, FALSE);
} else if ((nLastChar != oLastChar)
&& (!CharEq(newLine[nLastChar], oldLine[oLastChar])
|| !(_nc_idcok && has_ic()))) {
- GoTo(lineno, firstChar);
+ GoTo(NCURSES_SP_ARGx lineno, firstChar);
if ((oLastChar - nLastChar) > SP_PARM->_el_cost) {
- if (PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
- firstChar, nLastChar)) {
- GoTo(lineno, nLastChar + 1);
+ if (PutRange(NCURSES_SP_ARGx
+ oldLine,
+ newLine,
+ lineno,
+ firstChar,
+ nLastChar)) {
+ GoTo(NCURSES_SP_ARGx lineno, nLastChar + 1);
}
ClrToEOL(NCURSES_SP_ARGx blank, FALSE);
} else {
n = max(nLastChar, oLastChar);
- PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
- firstChar, n);
+ PutRange(NCURSES_SP_ARGx
+ oldLine,
+ newLine,
+ lineno,
+ firstChar,
+ n);
}
} else {
int nLastNonblank = nLastChar;
n = min(oLastChar, nLastChar);
if (n >= firstChar) {
- GoTo(lineno, firstChar);
- PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
- firstChar, n);
+ GoTo(NCURSES_SP_ARGx lineno, firstChar);
+ PutRange(NCURSES_SP_ARGx
+ oldLine,
+ newLine,
+ lineno,
+ firstChar,
+ n);
}
if (oLastChar < nLastChar) {
--oLastChar;
}
#endif
- GoTo(lineno, n + 1);
+ GoTo(NCURSES_SP_ARGx lineno, n + 1);
if ((nLastChar < nLastNonblank)
- || InsCharCost(nLastChar - oLastChar) > (m - n)) {
- PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
- n + 1, m);
+ || InsCharCost(SP_PARM, nLastChar - oLastChar) > (m - n)) {
+ PutRange(NCURSES_SP_ARGx
+ oldLine,
+ newLine,
+ lineno,
+ n + 1,
+ m);
} else {
- InsStr(&newLine[n + 1], nLastChar - oLastChar);
+ InsStr(NCURSES_SP_ARGx &newLine[n + 1], nLastChar - oLastChar);
}
} else if (oLastChar > nLastChar) {
- GoTo(lineno, n + 1);
- if (DelCharCost(oLastChar - nLastChar)
+ GoTo(NCURSES_SP_ARGx lineno, n + 1);
+ if (DelCharCost(SP_PARM, oLastChar - nLastChar)
> SP_PARM->_el_cost + nLastNonblank - (n + 1)) {
if (PutRange(NCURSES_SP_ARGx oldLine, newLine, lineno,
n + 1, nLastNonblank))
- GoTo(lineno, nLastNonblank + 1);
+ GoTo(NCURSES_SP_ARGx lineno, nLastNonblank + 1);
ClrToEOL(NCURSES_SP_ARGx blank, FALSE);
} else {
/*
* setting the video attributes from
* the last character on the row.
*/
- UpdateAttrs(blank);
- DelChar(oLastChar - nLastChar);
+ UpdateAttrs(SP_PARM, blank);
+ DelChar(NCURSES_SP_ARGx oLastChar - nLastChar);
}
}
}
if (fast_clear) {
if (clear_screen) {
- UpdateAttrs(blank);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("clear_screen");
putp(clear_screen);
SP_PARM->_cursrow = SP_PARM->_curscol = 0;
- position_check(SP_PARM->_cursrow, SP_PARM->_curscol,
+ position_check(SP_PARM,
+ SP_PARM->_cursrow,
+ SP_PARM->_curscol,
"ClearScreen");
} else if (clr_eos) {
SP_PARM->_cursrow = SP_PARM->_curscol = -1;
- GoTo(0, 0);
+ GoTo(NCURSES_SP_ARGx 0, 0);
- UpdateAttrs(blank);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("clr_eos");
tputs(clr_eos, screen_lines(SP_PARM), _nc_outch);
} else if (clr_eol) {
SP_PARM->_cursrow = SP_PARM->_curscol = -1;
- UpdateAttrs(blank);
+ UpdateAttrs(SP_PARM, blank);
for (i = 0; i < screen_lines(SP_PARM); i++) {
- GoTo(i, 0);
+ GoTo(NCURSES_SP_ARGx i, 0);
TPUTS_TRACE("clr_eol");
putp(clr_eol);
}
- GoTo(0, 0);
+ GoTo(NCURSES_SP_ARGx 0, 0);
}
} else {
- UpdateAttrs(blank);
+ UpdateAttrs(SP_PARM, blank);
for (i = 0; i < screen_lines(SP_PARM); i++) {
- GoTo(i, 0);
+ GoTo(NCURSES_SP_ARGx i, 0);
for (j = 0; j < screen_columns(SP_PARM); j++)
PutChar(NCURSES_SP_ARGx CHREF(blank));
}
- GoTo(0, 0);
+ GoTo(NCURSES_SP_ARGx 0, 0);
}
for (i = 0; i < screen_lines(SP_PARM); i++) {
*/
static void
-InsStr(NCURSES_CH_T * line, int count)
+InsStr(NCURSES_SP_DCLx NCURSES_CH_T * line, int count)
{
- TR(TRACE_UPDATE, ("InsStr(%p,%d) called", line, count));
+ TR(TRACE_UPDATE, ("InsStr(%p, %p,%d) called", SP_PARM, line, count));
/* Prefer parm_ich as it has the smallest cost - no need to shift
* the whole line on each character. */
TPUTS_TRACE("parm_ich");
tputs(TPARM_1(parm_ich, count), count, _nc_outch);
while (count) {
- PutAttrChar(CHREF(*line));
+ PutAttrChar(NCURSES_SP_ARGx CHREF(*line));
line++;
count--;
}
TPUTS_TRACE("enter_insert_mode");
putp(enter_insert_mode);
while (count) {
- PutAttrChar(CHREF(*line));
+ PutAttrChar(NCURSES_SP_ARGx CHREF(*line));
if (insert_padding) {
TPUTS_TRACE("insert_padding");
putp(insert_padding);
while (count) {
TPUTS_TRACE("insert_character");
putp(insert_character);
- PutAttrChar(CHREF(*line));
+ PutAttrChar(NCURSES_SP_ARGx CHREF(*line));
if (insert_padding) {
TPUTS_TRACE("insert_padding");
putp(insert_padding);
count--;
}
}
- position_check(SP_PARM->_cursrow, SP_PARM->_curscol, "InsStr");
+ position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "InsStr");
}
/*
*/
static void
-DelChar(int count)
+DelChar(NCURSES_SP_DCLx int count)
{
int n;
- TR(TRACE_UPDATE, ("DelChar(%d) called, position = (%ld,%ld)",
- count,
+ TR(TRACE_UPDATE, ("DelChar(%p, %d) called, position = (%ld,%ld)",
+ SP_PARM, count,
(long) newscr->_cury,
(long) newscr->_curx));
int i;
if (n == 1 && scroll_forward && top == miny && bot == maxy) {
- GoTo(bot, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx bot, 0);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("scroll_forward");
putp(scroll_forward);
} else if (n == 1 && delete_line && bot == maxy) {
- GoTo(top, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx top, 0);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("delete_line");
putp(delete_line);
} else if (parm_index && top == miny && bot == maxy) {
- GoTo(bot, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx bot, 0);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("parm_index");
tputs(TPARM_2(parm_index, n, 0), n, _nc_outch);
} else if (parm_delete_line && bot == maxy) {
- GoTo(top, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx top, 0);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("parm_delete_line");
tputs(TPARM_2(parm_delete_line, n, 0), n, _nc_outch);
} else if (scroll_forward && top == miny && bot == maxy) {
- GoTo(bot, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx bot, 0);
+ UpdateAttrs(SP_PARM, blank);
for (i = 0; i < n; i++) {
TPUTS_TRACE("scroll_forward");
putp(scroll_forward);
}
} else if (delete_line && bot == maxy) {
- GoTo(top, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx top, 0);
+ UpdateAttrs(SP_PARM, blank);
for (i = 0; i < n; i++) {
TPUTS_TRACE("delete_line");
putp(delete_line);
return ERR;
#if NCURSES_EXT_FUNCS
- if (FILL_BCE()) {
+ if (FILL_BCE(SP_PARM)) {
int j;
for (i = 0; i < n; i++) {
- GoTo(bot - i, 0);
+ GoTo(NCURSES_SP_ARGx bot - i, 0);
for (j = 0; j < screen_columns(SP_PARM); j++)
PutChar(NCURSES_SP_ARGx CHREF(blank));
}
int i;
if (n == 1 && scroll_reverse && top == miny && bot == maxy) {
- GoTo(top, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx top, 0);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("scroll_reverse");
putp(scroll_reverse);
} else if (n == 1 && insert_line && bot == maxy) {
- GoTo(top, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx top, 0);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("insert_line");
putp(insert_line);
} else if (parm_rindex && top == miny && bot == maxy) {
- GoTo(top, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx top, 0);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("parm_rindex");
tputs(TPARM_2(parm_rindex, n, 0), n, _nc_outch);
} else if (parm_insert_line && bot == maxy) {
- GoTo(top, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx top, 0);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("parm_insert_line");
tputs(TPARM_2(parm_insert_line, n, 0), n, _nc_outch);
} else if (scroll_reverse && top == miny && bot == maxy) {
- GoTo(top, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx top, 0);
+ UpdateAttrs(SP_PARM, blank);
for (i = 0; i < n; i++) {
TPUTS_TRACE("scroll_reverse");
putp(scroll_reverse);
}
} else if (insert_line && bot == maxy) {
- GoTo(top, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx top, 0);
+ UpdateAttrs(SP_PARM, blank);
for (i = 0; i < n; i++) {
TPUTS_TRACE("insert_line");
putp(insert_line);
return ERR;
#if NCURSES_EXT_FUNCS
- if (FILL_BCE()) {
+ if (FILL_BCE(SP_PARM)) {
int j;
for (i = 0; i < n; i++) {
- GoTo(top + i, 0);
+ GoTo(NCURSES_SP_ARGx top + i, 0);
for (j = 0; j < screen_columns(SP_PARM); j++)
PutChar(NCURSES_SP_ARGx CHREF(blank));
}
/* scroll by using delete_line at del and insert_line at ins */
/* n > 0 */
static int
-scroll_idl(int n, int del, int ins, NCURSES_CH_T blank)
+scroll_idl(NCURSES_SP_DCLx int n, int del, int ins, NCURSES_CH_T blank)
{
int i;
if (!((parm_delete_line || delete_line) && (parm_insert_line || insert_line)))
return ERR;
- GoTo(del, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx del, 0);
+ UpdateAttrs(SP_PARM, blank);
if (n == 1 && delete_line) {
TPUTS_TRACE("delete_line");
putp(delete_line);
}
}
- GoTo(ins, 0);
- UpdateAttrs(blank);
+ GoTo(NCURSES_SP_ARGx ins, 0);
+ UpdateAttrs(SP_PARM, blank);
if (n == 1 && insert_line) {
TPUTS_TRACE("insert_line");
putp(insert_line);
}
if (res == ERR && _nc_idlok)
- res = scroll_idl(n, top, bot - n + 1, blank);
+ res = scroll_idl(NCURSES_SP_ARGx n, top, bot - n + 1, blank);
/*
* Clear the newly shifted-in text.
&& (non_dest_scroll_region || (memory_below && bot == maxy))) {
static const NCURSES_CH_T blank2 = NewChar(BLANK_TEXT);
if (bot == maxy && clr_eos) {
- GoTo(bot - n + 1, 0);
+ GoTo(NCURSES_SP_ARGx bot - n + 1, 0);
ClrToEOS(NCURSES_SP_ARGx blank2);
} else {
for (i = 0; i < n; i++) {
- GoTo(bot - i, 0);
+ GoTo(NCURSES_SP_ARGx bot - i, 0);
ClrToEOL(NCURSES_SP_ARGx blank2, FALSE);
}
}
if (res == ERR && change_scroll_region) {
if (top != 0
- && (SP_PARM->_cursrow == top || SP_PARM->_cursrow == top - 1)
+ && (SP_PARM->_cursrow == top ||
+ SP_PARM->_cursrow == top - 1)
&& save_cursor && restore_cursor) {
cursor_saved = TRUE;
TPUTS_TRACE("save_cursor");
}
if (res == ERR && _nc_idlok)
- res = scroll_idl(-n, bot + n + 1, top, blank);
+ res = scroll_idl(NCURSES_SP_ARGx -n, bot + n + 1, top, blank);
/*
* Clear the newly shifted-in text.
&& (non_dest_scroll_region || (memory_above && top == 0))) {
static const NCURSES_CH_T blank2 = NewChar(BLANK_TEXT);
for (i = 0; i < -n; i++) {
- GoTo(i + top, 0);
+ GoTo(NCURSES_SP_ARGx i + top, 0);
ClrToEOL(NCURSES_SP_ARGx blank2, FALSE);
}
}
_nc_scroll_window(curscr, n, top, bot, blank);
/* shift hash values too - they can be reused */
- _nc_scroll_oldhash(n, top, bot);
+ NCURSES_SP_NAME(_nc_scroll_oldhash) (NCURSES_SP_ARGx n, top, bot);
return (OK);
}
#endif
NCURSES_EXPORT(void)
-_nc_screen_resume(void)
+NCURSES_SP_NAME(_nc_screen_resume) (NCURSES_SP_DCL0)
{
+ assert(SP_PARM);
+
/* make sure terminal is in a sane known state */
- SetAttr(SCREEN_ATTRS(SP), A_NORMAL);
+ SetAttr(SCREEN_ATTRS(SP_PARM), A_NORMAL);
newscr->_clear = TRUE;
/* reset color pairs and definitions */
- if (SP->_coloron || SP->_color_defs)
- _nc_reset_colors();
+ if (SP_PARM->_coloron || SP_PARM->_color_defs)
+ _nc_reset_colors ();
/* restore user-defined colors, if any */
- if (SP->_color_defs < 0) {
+ if (SP_PARM->_color_defs < 0) {
int n;
- SP->_color_defs = -(SP->_color_defs);
- for (n = 0; n < SP->_color_defs; ++n) {
- if (SP->_color_table[n].init) {
- init_color(n,
- SP->_color_table[n].r,
- SP->_color_table[n].g,
- SP->_color_table[n].b);
+ SP_PARM->_color_defs = -(SP_PARM->_color_defs);
+ for (n = 0; n < SP_PARM->_color_defs; ++n) {
+ if (SP_PARM->_color_table[n].init) {
+ NCURSES_SP_NAME(init_color) (NCURSES_SP_ARGx n,
+ SP_PARM->_color_table[n].r,
+ SP_PARM->_color_table[n].g,
+ SP_PARM->_color_table[n].b);
}
}
}
putp(auto_right_margin ? enter_am_mode : exit_am_mode);
}
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(void)
+_nc_screen_resume(void)
+{
+ NCURSES_SP_NAME(_nc_screen_resume) (CURRENT_SCREEN);
+}
+#endif
+
+NCURSES_EXPORT(void)
+NCURSES_SP_NAME(_nc_screen_init) (NCURSES_SP_DCL0)
+{
+ NCURSES_SP_NAME(_nc_screen_resume) (NCURSES_SP_ARG);
+}
+
+#if NCURSES_SP_FUNCS
NCURSES_EXPORT(void)
_nc_screen_init(void)
{
- _nc_screen_resume();
+ NCURSES_SP_NAME(_nc_screen_init) (CURRENT_SCREEN);
}
+#endif
/* wrap up screen handling */
NCURSES_EXPORT(void)
NCURSES_SP_NAME(_nc_screen_wrap) (NCURSES_SP_DCL0)
{
- UpdateAttrs(normal);
+ if (SP_PARM == 0)
+ return;
+
+ UpdateAttrs(SP_PARM, normal);
#if NCURSES_EXT_FUNCS
if (SP_PARM->_coloron
&& !SP_PARM->_default_color) {
}
#endif
if (SP_PARM->_color_defs) {
- _nc_reset_colors();
+ _nc_reset_colors ();
}
}
#if USE_XMC_SUPPORT
NCURSES_EXPORT(void)
-_nc_do_xmc_glitch(attr_t previous)
+NCURSES_SP_NAME(_nc_do_xmc_glitch) (NCURSES_SP_DCLx attr_t previous)
{
- attr_t chg = XMC_CHANGES(previous ^ AttrOf(SCREEN_ATTRS(SP)));
-
- while (chg != 0) {
- if (chg & 1) {
- SP->_curscol += magic_cookie_glitch;
- if (SP->_curscol >= SP->_columns)
- wrap_cursor();
- TR(TRACE_UPDATE, ("bumped to %d,%d after cookie", SP->_cursrow, SP->_curscol));
+ if (SP_PARM != 0) {
+ attr_t chg = XMC_CHANGES(previous ^ AttrOf(SCREEN_ATTRS(SP_PARM)));
+
+ while (chg != 0) {
+ if (chg & 1) {
+ SP_PARM->_curscol += magic_cookie_glitch;
+ if (SP_PARM->_curscol >= SP_PARM->_columns)
+ wrap_cursor(NCURSES_SP_ARG);
+ TR(TRACE_UPDATE, ("bumped to %d,%d after cookie",
+ SP_PARM->_cursrow, SP_PARM->_curscol));
+ }
+ chg >>= 1;
}
- chg >>= 1;
}
}
+
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(void)
+_nc_do_xmc_glitch(attr_t previous)
+{
+ NCURSES_SP_NAME(_nc_do_xmc_glitch) (CURRENT_SCREEN, previous);
+}
+#endif
+
#endif /* USE_XMC_SUPPORT */
projects / ncurses.git / blobdiff