aboutsummaryrefslogtreecommitdiff
path: root/ncurses/tty/tty_update.c
diff options
context:
space:
mode:
authorEd Schouten <ed@FreeBSD.org>2011-04-30 10:55:14 +0000
committerEd Schouten <ed@FreeBSD.org>2011-04-30 10:55:14 +0000
commit0294a182a1629b1d854b84906e73487d6cb75fba (patch)
treee563e21bcc0164ba11452983316bda26eebb1d3c /ncurses/tty/tty_update.c
parent22b11c4db16996bf8d4878fab98762c348676df3 (diff)
downloadsrc-0294a182a1629b1d854b84906e73487d6cb75fba.tar.gz
src-0294a182a1629b1d854b84906e73487d6cb75fba.zip
Import a stock copy of ncurses 5.8 into the vendor space.vendor/ncurses/5.8-20110226
It seems both local changes we made to 5.7 have already been fixed upstream properly, so there is no need to preserve the changes. Also, with SVN we import full source trees. Unlike CVS, where we removed unneeded cruft.
Notes
Notes: svn path=/vendor/ncurses/dist/; revision=221243 svn path=/vendor/ncurses/5.8-20110226/; revision=221244; tag=vendor/ncurses/5.8-20110226
Diffstat (limited to 'ncurses/tty/tty_update.c')
-rw-r--r--ncurses/tty/tty_update.c1228
1 files changed, 740 insertions, 488 deletions
diff --git a/ncurses/tty/tty_update.c b/ncurses/tty/tty_update.c
index 6a3a0c8e9341..f0d2369c18d6 100644
--- a/ncurses/tty/tty_update.c
+++ b/ncurses/tty/tty_update.c
@@ -1,5 +1,5 @@
/****************************************************************************
- * Copyright (c) 1998-2007,2008 Free Software Foundation, Inc. *
+ * Copyright (c) 1998-2009,2010 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 *
@@ -30,6 +30,7 @@
* Author: Zeyd M. Ben-Halim <zmbenhal@netcom.com> 1992,1995 *
* and: Eric S. Raymond <esr@snark.thyrsus.com> *
* and: Thomas E. Dickey 1996-on *
+ * and: Juergen Pfeifer 2009 *
****************************************************************************/
/*-----------------------------------------------------------------
@@ -38,12 +39,16 @@
*
* The routine doupdate() and its dependents.
* All physical output is concentrated here (except _nc_outch()
- * in lib_tputs.c).
+ * in lib_tputs.c).
*
*-----------------------------------------------------------------*/
#include <curses.priv.h>
+#ifndef CUR
+#define CUR SP_TERMTYPE
+#endif
+
#if defined __HAIKU__ && defined __BEOS__
#undef __BEOS__
#endif
@@ -76,9 +81,8 @@
#endif
#include <ctype.h>
-#include <term.h>
-MODULE_ID("$Id: tty_update.c,v 1.246 2008/08/30 20:08:19 tom Exp $")
+MODULE_ID("$Id: tty_update.c,v 1.264 2010/12/19 01:21:02 tom Exp $")
/*
* This define controls the line-breakout optimization. Every once in a
@@ -91,7 +95,7 @@ MODULE_ID("$Id: tty_update.c,v 1.246 2008/08/30 20:08:19 tom Exp $")
*/
#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);
@@ -103,13 +107,23 @@ static NCURSES_CH_T normal = NewChar(BLANK_TEXT);
*/
/* #define POSITION_DEBUG */
-static NCURSES_INLINE NCURSES_CH_T ClrBlank(WINDOW *win);
+static NCURSES_INLINE NCURSES_CH_T ClrBlank(NCURSES_SP_DCLx WINDOW *win);
+
+#if NCURSES_SP_FUNCS
+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 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
#ifdef POSITION_DEBUG
/****************************************************************************
@@ -119,7 +133,7 @@ static void TransformLine(int const lineno);
****************************************************************************/
static void
-position_check(int expected_y, int expected_x, char *legend)
+position_check(NCURSES_SP_DCLx int expected_y, int expected_x, char *legend)
/* check to see if the real cursor position matches the virtual */
{
char buf[20];
@@ -129,10 +143,10 @@ position_check(int expected_y, int expected_x, char *legend)
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(putp) (NCURSES_SP_ARGx "\033[6n"); /* only works on ANSI-compatibles */
+ NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
*(s = buf) = 0;
do {
int ask = sizeof(buf) - 1 - (s - buf);
@@ -152,8 +166,12 @@ position_check(int expected_y, int expected_x, char *legend)
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);
+ NCURSES_SP_NAME(beep) (NCURSES_SP_ARG);
+ NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
+ tparm("\033[%d;%dH",
+ expected_y + 1,
+ expected_x + 1),
+ 1, NCURSES_SP_NAME(_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 {
@@ -162,7 +180,7 @@ position_check(int expected_y, int expected_x, char *legend)
}
}
#else
-#define position_check(expected_y, expected_x, legend) /* nothing */
+#define position_check(sp, expected_y, expected_x, legend) /* nothing */
#endif /* POSITION_DEBUG */
/****************************************************************************
@@ -172,19 +190,22 @@ position_check(int expected_y, int expected_x, char *legend)
****************************************************************************/
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));
+ TR(TRACE_MOVE, ("GoTo(%p, %d, %d) from (%d, %d)",
+ (void *) SP_PARM, 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");
+ TINFO_MVCUR(NCURSES_SP_ARGx
+ 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;
@@ -194,7 +215,7 @@ PutAttrChar(CARG_CH_T 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.
@@ -224,12 +245,12 @@ PutAttrChar(CARG_CH_T ch)
*/
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 {
@@ -241,7 +262,7 @@ PutAttrChar(CARG_CH_T ch)
#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
@@ -251,8 +272,8 @@ PutAttrChar(CARG_CH_T ch)
* 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)];
}
@@ -265,9 +286,9 @@ PutAttrChar(CARG_CH_T 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 = ' ';
@@ -282,28 +303,28 @@ PutAttrChar(CARG_CH_T ch)
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(NCURSES_SP_ARGx 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);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx char_padding);
}
}
static bool
-check_pending(void)
+check_pending(NCURSES_SP_DCL0)
/* check for pending input */
{
bool have_pending = FALSE;
@@ -313,13 +334,13 @@ check_pending(void)
* 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;
@@ -347,43 +368,52 @@ check_pending(void)
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;
}
/* put char at lower right corner */
static void
-PutCharLR(const ARG_CH_T ch)
+PutCharLR(NCURSES_SP_DCLx const ARG_CH_T ch)
{
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);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_am_mode);
- PutAttrChar(ch);
- SP->_curscol--;
- position_check(SP->_cursrow, SP->_curscol, "exit_am_mode");
+ PutAttrChar(NCURSES_SP_ARGx ch);
+ SP_PARM->_curscol--;
+ position_check(SP_PARM,
+ SP_PARM->_cursrow,
+ SP_PARM->_curscol,
+ "exit_am_mode");
TPUTS_TRACE("enter_am_mode");
- putp(enter_am_mode);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx enter_am_mode);
} else if ((enter_insert_mode && exit_insert_mode)
|| insert_character || parm_ich) {
- GoTo(screen_lines - 1, screen_columns - 2);
- PutAttrChar(ch);
- GoTo(screen_lines - 1, screen_columns - 2);
- InsStr(newscr->_line[screen_lines - 1].text + screen_columns - 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
+ NewScreen(SP_PARM)->_line[screen_lines(SP_PARM) - 1].text +
+ screen_columns(SP_PARM) - 2, 1);
}
}
@@ -391,7 +421,7 @@ PutCharLR(const ARG_CH_T ch)
* 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) {
/*
@@ -407,40 +437,45 @@ wrap_cursor(void)
* 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)))));
- (void) VIDATTR(A_NORMAL, 0);
+ (unsigned long) AttrOf(SCREEN_ATTRS(SP_PARM)),
+ _traceattr(AttrOf(SCREEN_ATTRS(SP_PARM)))));
+ (void) VIDATTR(SP_PARM, 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(const ARG_CH_T ch)
+PutChar(NCURSES_SP_DCLx const ARG_CH_T ch)
/* insert character, handling automargin stuff */
{
- if (SP->_cursrow == screen_lines - 1 && SP->_curscol == screen_columns - 1)
- PutCharLR(ch);
- else
- PutAttrChar(ch);
+ if (SP_PARM->_cursrow == screen_lines(SP_PARM) - 1 &&
+ SP_PARM->_curscol == screen_columns(SP_PARM) - 1) {
+ PutCharLR(NCURSES_SP_ARGx ch);
+ } else {
+ PutAttrChar(NCURSES_SP_ARGx ch);
+ }
- if (SP->_curscol >= screen_columns)
- wrap_cursor();
+ if (SP_PARM->_curscol >= screen_columns(SP_PARM))
+ wrap_cursor(NCURSES_SP_ARG);
- position_check(SP->_cursrow, SP->_curscol, "PutChar");
+ position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "PutChar");
}
/*
@@ -450,19 +485,21 @@ PutChar(const ARG_CH_T ch)
* 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
+ (short) pair,
+ &fg, &bg);
if (fg != C_MASK || bg != C_MASK)
return FALSE;
}
@@ -488,7 +525,7 @@ can_clear_with(ARG_CH_T ch)
* This code is optimized using ech and rep.
*/
static int
-EmitRange(const NCURSES_CH_T * ntext, int num)
+EmitRange(NCURSES_SP_DCLx const NCURSES_CH_T * ntext, int num)
{
int i;
@@ -500,13 +537,13 @@ EmitRange(const NCURSES_CH_T * ntext, int num)
NCURSES_CH_T ntext0;
while (num > 1 && !CharEq(ntext[0], ntext[1])) {
- PutChar(CHREF(ntext[0]));
+ PutChar(NCURSES_SP_ARGx CHREF(ntext[0]));
ntext++;
num--;
}
ntext0 = ntext[0];
if (num == 1) {
- PutChar(CHREF(ntext0));
+ PutChar(NCURSES_SP_ARGx CHREF(ntext0));
return 0;
}
runcount = 2;
@@ -523,10 +560,11 @@ EmitRange(const NCURSES_CH_T * ntext, int num)
* which it would be marginally advantageous.
*/
if (erase_chars
- && runcount > SP->_ech_cost + SP->_cup_ch_cost
- && can_clear_with(CHREF(ntext0))) {
- UpdateAttrs(ntext0);
- putp(TPARM_1(erase_chars, runcount));
+ && runcount > SP_PARM->_ech_cost + SP_PARM->_cup_ch_cost
+ && can_clear_with(NCURSES_SP_ARGx CHREF(ntext0))) {
+ UpdateAttrs(SP_PARM, ntext0);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx
+ TPARM_1(erase_chars, runcount));
/*
* If this is the last part of the given interval,
@@ -534,27 +572,34 @@ EmitRange(const NCURSES_CH_T * ntext, int num)
* last update on the line.
*/
if (runcount < num) {
- GoTo(SP->_cursrow, SP->_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->_rep_cost) {
- bool wrap_possible = (SP->_curscol + runcount >= screen_columns);
+ } else if (repeat_char && runcount > SP_PARM->_rep_cost) {
+ bool wrap_possible = (SP_PARM->_curscol + runcount >=
+ screen_columns(SP_PARM));
int rep_count = runcount;
if (wrap_possible)
rep_count--;
- UpdateAttrs(ntext0);
- tputs(TPARM_2(repeat_char, CharOf(ntext0), rep_count),
- rep_count, _nc_outch);
- SP->_curscol += rep_count;
+ UpdateAttrs(SP_PARM, ntext0);
+ NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
+ TPARM_2(repeat_char,
+ CharOf(ntext0),
+ rep_count),
+ rep_count,
+ NCURSES_SP_NAME(_nc_outch));
+ SP_PARM->_curscol += rep_count;
if (wrap_possible)
- PutChar(CHREF(ntext0));
+ PutChar(NCURSES_SP_ARGx CHREF(ntext0));
} else {
for (i = 0; i < runcount; i++)
- PutChar(CHREF(ntext[i]));
+ PutChar(NCURSES_SP_ARGx CHREF(ntext[i]));
}
ntext += runcount;
num -= runcount;
@@ -563,7 +608,7 @@ EmitRange(const NCURSES_CH_T * ntext, int num)
}
for (i = 0; i < num; i++)
- PutChar(CHREF(ntext[i]));
+ PutChar(NCURSES_SP_ARGx CHREF(ntext[i]));
return 0;
}
@@ -576,39 +621,43 @@ EmitRange(const NCURSES_CH_T * ntext, int num)
* Returns: same as EmitRange
*/
static int
-PutRange(const NCURSES_CH_T * otext,
+PutRange(NCURSES_SP_DCLx
+ 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));
+ TR(TRACE_CHARPUT, ("PutRange(%p, %p, %p, %d, %d, %d)",
+ (void *) SP_PARM,
+ (const void *) otext,
+ (const void *) ntext,
+ row, first, last));
if (otext != ntext
- && (last - first + 1) > SP->_inline_cost) {
+ && (last - first + 1) > SP_PARM->_inline_cost) {
for (j = first, same = 0; j <= last; j++) {
if (!same && isWidecExt(otext[j]))
continue;
if (CharEq(otext[j], ntext[j])) {
same++;
} else {
- if (same > SP->_inline_cost) {
- EmitRange(ntext + first, j - same - first);
- GoTo(row, first = j);
+ if (same > SP_PARM->_inline_cost) {
+ EmitRange(NCURSES_SP_ARGx ntext + first, j - same - first);
+ GoTo(NCURSES_SP_ARGx row, first = j);
}
same = 0;
}
}
- i = EmitRange(ntext + first, j - same - first);
+ i = EmitRange(NCURSES_SP_ARGx ntext + first, j - same - first);
/*
* Always return 1 for the next GoTo() after a PutRange() if we found
* identical characters at end of interval
*/
return (same == 0 ? i : 1);
}
- return EmitRange(ntext + first, last - first + 1);
+ return EmitRange(NCURSES_SP_ARGx ntext + first, last - first + 1);
}
/* leave unbracketed here so 'indent' works */
@@ -618,7 +667,7 @@ PutRange(const NCURSES_CH_T * otext,
if_USE_SCROLL_HINTS(win->_line[row].oldindex = row)
NCURSES_EXPORT(int)
-doupdate(void)
+TINFO_DOUPDATE(NCURSES_SP_DCL0)
{
int i;
int nonempty;
@@ -626,30 +675,49 @@ doupdate(void)
struct tms before, after;
#endif /* USE_TRACE_TIMES */
- T((T_CALLED("doupdate()")));
+ T((T_CALLED("_nc_tinfo:doupdate(%p)"), (void *) SP_PARM));
- if (curscr == 0
- || newscr == 0)
+#if !USE_REENTRANT
+ /*
+ * It is "legal" but unlikely that an application could assign a new
+ * value to one of the standard windows. Check for that possibility
+ * and try to recover.
+ *
+ * We do not allow applications to assign new values in the reentrant
+ * model.
+ */
+#define SyncScreens(internal,exported) \
+ if (internal == 0) internal = exported; \
+ if (internal != exported) exported = internal
+
+ SyncScreens(CurScreen(SP_PARM), curscr);
+ SyncScreens(NewScreen(SP_PARM), newscr);
+ SyncScreens(StdScreen(SP_PARM), stdscr);
+#endif
+
+ if (CurScreen(SP_PARM) == 0
+ || NewScreen(SP_PARM) == 0
+ || StdScreen(SP_PARM) == 0)
returnCode(ERR);
#ifdef TRACE
if (USE_TRACEF(TRACE_UPDATE)) {
- if (curscr->_clear)
+ if (CurScreen(SP_PARM)->_clear)
_tracef("curscr is clear");
else
- _tracedump("curscr", curscr);
- _tracedump("newscr", newscr);
+ _tracedump("curscr", CurScreen(SP_PARM));
+ _tracedump("newscr", NewScreen(SP_PARM));
_nc_unlock_global(tracef);
}
#endif /* TRACE */
_nc_signal_handler(FALSE);
- if (SP->_fifohold)
- SP->_fifohold--;
+ if (SP_PARM->_fifohold)
+ SP_PARM->_fifohold--;
#if USE_SIZECHANGE
- if (SP->_endwin || _nc_handle_sigwinch(SP)) {
+ if (SP_PARM->_endwin || _nc_handle_sigwinch(SP_PARM)) {
/*
* This is a transparent extension: XSI does not address it,
* and applications need not know that ncurses can do it.
@@ -658,20 +726,20 @@ doupdate(void)
* (this can happen in an xterm, for example), and resize the
* ncurses data structures accordingly.
*/
- _nc_update_screensize(SP);
+ _nc_update_screensize(SP_PARM);
}
#endif
- if (SP->_endwin) {
+ 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();
- SP->_mouse_resume(SP);
+ 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->_endwin = FALSE;
+ SP_PARM->_endwin = FALSE;
}
#if USE_TRACE_TIMES
/* zero the metering machinery */
@@ -695,11 +763,11 @@ doupdate(void)
int j, k;
attr_t rattr = A_NORMAL;
- for (i = 0; i < screen_lines; i++) {
- for (j = 0; j < screen_columns; j++) {
+ for (i = 0; i < screen_lines(SP_PARM); i++) {
+ for (j = 0; j < screen_columns(SP_PARM); j++) {
bool failed = FALSE;
- NCURSES_CH_T *thisline = newscr->_line[i].text;
- attr_t thisattr = AttrOf(thisline[j]) & SP->_xmc_triggers;
+ NCURSES_CH_T *thisline = NewScreen(SP_PARM)->_line[i].text;
+ attr_t thisattr = AttrOf(thisline[j]) & SP_PARM->_xmc_triggers;
attr_t turnon = thisattr & ~rattr;
/* is an attribute turned on here? */
@@ -717,8 +785,8 @@ doupdate(void)
* 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)) {
+#define SAFE(scr,a) (!((a) & (scr)->_xmc_triggers))
+ if (ISBLANK(thisline[j]) && SAFE(SP_PARM, turnon)) {
RemAttr(thisline[j], turnon);
continue;
}
@@ -727,14 +795,14 @@ doupdate(void)
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;
@@ -745,10 +813,11 @@ doupdate(void)
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) {
+ for (m = i; m < screen_lines(SP_PARM); m++) {
+ for (; n < screen_columns(SP_PARM); n++) {
+ attr_t testattr =
+ AttrOf(NewScreen(SP_PARM)->_line[m].text[n]);
+ if ((testattr & SP_PARM->_xmc_triggers) == rattr) {
end_onscreen = TRUE;
TR(TRACE_ATTRS,
("Range attributed with %s ends at (%d, %d)",
@@ -764,7 +833,8 @@ doupdate(void)
foundit:;
if (end_onscreen) {
- NCURSES_CH_T *lastline = newscr->_line[m].text;
+ NCURSES_CH_T *lastline =
+ NewScreen(SP_PARM)->_line[m].text;
/*
* If there are safely-attributed blanks at the end of
@@ -773,15 +843,15 @@ doupdate(void)
*/
while (n >= 0
&& ISBLANK(lastline[n])
- && SAFE(AttrOf(lastline[n]))) {
+ && SAFE(SP_PARM, 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
+ 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",
@@ -789,7 +859,7 @@ doupdate(void)
(ISBLANK(lastline[n + k])
? ""
: ":nonblank"),
- (SAFE(AttrOf(lastline[n + k]))
+ (SAFE(SP_PARM, AttrOf(lastline[n + k]))
? ""
: ":unsafe")));
break;
@@ -806,12 +876,12 @@ doupdate(void)
_traceattr(turnon), i, j));
/* turn off new attributes over span */
- for (p = i; p < screen_lines; p++) {
- for (; q < screen_columns; q++) {
+ for (p = i; p < screen_lines(SP_PARM); p++) {
+ for (; q < screen_columns(SP_PARM); q++) {
attr_t testattr = AttrOf(newscr->_line[p].text[q]);
- if ((testattr & SP->_xmc_triggers) == rattr)
+ if ((testattr & SP_PARM->_xmc_triggers) == rattr)
goto foundend;
- RemAttr(newscr->_line[p].text[q], turnon);
+ RemAttr(NewScreen(SP_PARM)->_line[p].text[q], turnon);
}
q = 0;
}
@@ -837,7 +907,7 @@ doupdate(void)
/* show altered highlights after magic-cookie check */
if (USE_TRACEF(TRACE_UPDATE)) {
_tracef("After magic-cookie check...");
- _tracedump("newscr", newscr);
+ _tracedump("newscr", NewScreen(SP_PARM));
_nc_unlock_global(tracef);
}
#endif /* TRACE */
@@ -845,23 +915,23 @@ doupdate(void)
#endif /* USE_XMC_SUPPORT */
nonempty = 0;
- if (curscr->_clear || newscr->_clear) { /* force refresh ? */
- ClrUpdate();
- curscr->_clear = FALSE; /* reset flag */
- newscr->_clear = FALSE; /* reset flag */
+ if (CurScreen(SP_PARM)->_clear || NewScreen(SP_PARM)->_clear) { /* force refresh ? */
+ ClrUpdate(NCURSES_SP_ARG);
+ CurScreen(SP_PARM)->_clear = FALSE; /* reset flag */
+ NewScreen(SP_PARM)->_clear = FALSE; /* reset flag */
} else {
int changedlines = CHECK_INTERVAL;
- if (check_pending())
+ if (check_pending(NCURSES_SP_ARG))
goto cleanup;
- nonempty = min(screen_lines, newscr->_maxy + 1);
+ nonempty = min(screen_lines(SP_PARM), NewScreen(SP_PARM)->_maxy + 1);
- if (SP->_scrolling) {
- _nc_scroll_optimize();
+ if (SP_PARM->_scrolling) {
+ NCURSES_SP_NAME(_nc_scroll_optimize) (NCURSES_SP_ARG);
}
- nonempty = ClrBottom(nonempty);
+ nonempty = ClrBottom(NCURSES_SP_ARGx nonempty);
TR(TRACE_UPDATE, ("Transforming lines, nonempty %d", nonempty));
for (i = 0; i < nonempty; i++) {
@@ -869,7 +939,7 @@ doupdate(void)
* Here is our line-breakout optimization.
*/
if (changedlines == CHECK_INTERVAL) {
- if (check_pending())
+ if (check_pending(NCURSES_SP_ARG))
goto cleanup;
changedlines = 0;
}
@@ -880,35 +950,35 @@ doupdate(void)
* is normally set by _nc_scroll_window in the
* vertical-movement optimization code,
*/
- if (newscr->_line[i].firstchar != _NOCHANGE
- || curscr->_line[i].firstchar != _NOCHANGE) {
- TransformLine(i);
+ if (NewScreen(SP_PARM)->_line[i].firstchar != _NOCHANGE
+ || CurScreen(SP_PARM)->_line[i].firstchar != _NOCHANGE) {
+ TransformLine(NCURSES_SP_ARGx i);
changedlines++;
}
/* mark line changed successfully */
- if (i <= newscr->_maxy) {
- MARK_NOCHANGE(newscr, i);
+ if (i <= NewScreen(SP_PARM)->_maxy) {
+ MARK_NOCHANGE(NewScreen(SP_PARM), i);
}
- if (i <= curscr->_maxy) {
- MARK_NOCHANGE(curscr, i);
+ if (i <= CurScreen(SP_PARM)->_maxy) {
+ MARK_NOCHANGE(CurScreen(SP_PARM), i);
}
}
}
/* put everything back in sync */
- for (i = nonempty; i <= newscr->_maxy; i++) {
- MARK_NOCHANGE(newscr, i);
+ for (i = nonempty; i <= NewScreen(SP_PARM)->_maxy; i++) {
+ MARK_NOCHANGE(NewScreen(SP_PARM), i);
}
- for (i = nonempty; i <= curscr->_maxy; i++) {
- MARK_NOCHANGE(curscr, i);
+ for (i = nonempty; i <= CurScreen(SP_PARM)->_maxy; i++) {
+ MARK_NOCHANGE(CurScreen(SP_PARM), i);
}
- if (!newscr->_leaveok) {
- curscr->_curx = newscr->_curx;
- curscr->_cury = newscr->_cury;
+ if (!NewScreen(SP_PARM)->_leaveok) {
+ CurScreen(SP_PARM)->_curx = NewScreen(SP_PARM)->_curx;
+ CurScreen(SP_PARM)->_cury = NewScreen(SP_PARM)->_cury;
- GoTo(curscr->_cury, curscr->_curx);
+ GoTo(NCURSES_SP_ARGx CurScreen(SP_PARM)->_cury, CurScreen(SP_PARM)->_curx);
}
cleanup:
@@ -921,10 +991,10 @@ doupdate(void)
#if USE_XMC_SUPPORT
if (magic_cookie_glitch != 0)
#endif
- UpdateAttrs(normal);
+ UpdateAttrs(SP_PARM, normal);
- _nc_flush();
- WINDOW_ATTRS(curscr) = WINDOW_ATTRS(newscr);
+ NCURSES_SP_NAME(_nc_flush) (NCURSES_SP_ARG);
+ WINDOW_ATTRS(CurScreen(SP_PARM)) = WINDOW_ATTRS(NewScreen(SP_PARM));
#if USE_TRACE_TIMES
(void) times(&after);
@@ -940,6 +1010,14 @@ doupdate(void)
returnCode(OK);
}
+#if NCURSES_SP_FUNCS && !defined(USE_TERM_DRIVER)
+NCURSES_EXPORT(int)
+doupdate(void)
+{
+ return TINFO_DOUPDATE(CURRENT_SCREEN);
+}
+#endif
+
/*
* ClrBlank(win)
*
@@ -951,14 +1029,14 @@ doupdate(void)
* 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)
+#define BCE_BKGD(sp,win) (((win) == CurScreen(sp) ? StdScreen(sp) : (win))->_nc_bkgd)
static NCURSES_INLINE NCURSES_CH_T
-ClrBlank(WINDOW *win)
+ClrBlank(NCURSES_SP_DCLx WINDOW *win)
{
NCURSES_CH_T blank = blankchar;
if (back_color_erase)
- AddAttr(blank, (AttrOf(BCE_BKGD(win)) & BCE_ATTRS));
+ AddAttr(blank, (AttrOf(BCE_BKGD(SP_PARM, win)) & BCE_ATTRS));
return blank;
}
@@ -970,23 +1048,24 @@ ClrBlank(WINDOW *win)
*/
static void
-ClrUpdate(void)
+ClrUpdate(NCURSES_SP_DCL0)
{
- int i;
- NCURSES_CH_T blank = ClrBlank(stdscr);
- int nonempty = min(screen_lines, newscr->_maxy + 1);
-
TR(TRACE_UPDATE, (T_CALLED("ClrUpdate")));
+ if (0 != SP_PARM) {
+ int i;
+ NCURSES_CH_T blank = ClrBlank(NCURSES_SP_ARGx StdScreen(SP_PARM));
+ int nonempty = min(screen_lines(SP_PARM),
+ NewScreen(SP_PARM)->_maxy + 1);
- ClearScreen(blank);
-
- TR(TRACE_UPDATE, ("updating screen from scratch"));
+ ClearScreen(NCURSES_SP_ARGx blank);
- nonempty = ClrBottom(nonempty);
+ TR(TRACE_UPDATE, ("updating screen from scratch"));
- for (i = 0; i < nonempty; i++)
- TransformLine(i);
+ nonempty = ClrBottom(NCURSES_SP_ARGx nonempty);
+ for (i = 0; i < nonempty; i++)
+ TransformLine(NCURSES_SP_ARGx i);
+ }
TR(TRACE_UPDATE, (T_RETURN("")));
}
@@ -997,35 +1076,36 @@ ClrUpdate(void)
*/
static void
-ClrToEOL(NCURSES_CH_T blank, bool needclear)
+ClrToEOL(NCURSES_SP_DCLx NCURSES_CH_T blank, bool needclear)
{
int j;
- if (curscr != 0
- && SP->_cursrow >= 0) {
- for (j = SP->_curscol; j < screen_columns; j++) {
- if (j >= 0) {
- NCURSES_CH_T *cp = &(curscr->_line[SP->_cursrow].text[j]);
-
- if (!CharEq(*cp, blank)) {
- *cp = blank;
- needclear = TRUE;
+ if (SP_PARM != 0) {
+ if (CurScreen(SP_PARM) != 0
+ && SP_PARM->_cursrow >= 0) {
+ for (j = SP_PARM->_curscol; j < screen_columns(SP_PARM); j++) {
+ if (j >= 0) {
+ NCURSES_CH_T *cp =
+ &(CurScreen(SP_PARM)->_line[SP_PARM->_cursrow].text[j]);
+
+ if (!CharEq(*cp, blank)) {
+ *cp = blank;
+ needclear = TRUE;
+ }
}
}
}
- } else {
- needclear = TRUE;
}
- if (needclear) {
- UpdateAttrs(blank);
+ if (needclear && (SP_PARM != 0)) {
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("clr_eol");
- if (clr_eol && SP->_el_cost <= (screen_columns - SP->_curscol)) {
- putp(clr_eol);
+ if (clr_eol && SP_PARM->_el_cost <= (screen_columns(SP_PARM) - SP_PARM->_curscol)) {
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx clr_eol);
} else {
- int count = (screen_columns - SP->_curscol);
+ int count = (screen_columns(SP_PARM) - SP_PARM->_curscol);
while (count-- > 0)
- PutChar(CHREF(blank));
+ PutChar(NCURSES_SP_ARGx CHREF(blank));
}
}
}
@@ -1037,23 +1117,29 @@ ClrToEOL(NCURSES_CH_T blank, bool needclear)
*/
static void
-ClrToEOS(NCURSES_CH_T blank)
+ClrToEOS(NCURSES_SP_DCLx NCURSES_CH_T blank)
{
int row, col;
- row = SP->_cursrow;
- col = SP->_curscol;
+ 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 - row, _nc_outch);
+ NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
+ clr_eos,
+ screen_lines(SP_PARM) - row,
+ NCURSES_SP_NAME(_nc_outch));
- while (col < screen_columns)
- curscr->_line[row].text[col++] = blank;
+ while (col < screen_columns(SP_PARM))
+ CurScreen(SP_PARM)->_line[row].text[col++] = blank;
- for (row++; row < screen_lines; row++) {
- for (col = 0; col < screen_columns; col++)
- curscr->_line[row].text[col] = blank;
+ for (row++; row < screen_lines(SP_PARM); row++) {
+ for (col = 0; col < screen_columns(SP_PARM); col++)
+ CurScreen(SP_PARM)->_line[row].text[col] = blank;
}
}
@@ -1065,26 +1151,26 @@ ClrToEOS(NCURSES_CH_T blank)
* screen, checking if each is blank, and one or more are changed.
*/
static int
-ClrBottom(int total)
+ClrBottom(NCURSES_SP_DCLx int total)
{
int row;
int col;
int top = total;
- int last = min(screen_columns, newscr->_maxx + 1);
- NCURSES_CH_T blank = newscr->_line[total - 1].text[last - 1];
+ int last = min(screen_columns(SP_PARM), NewScreen(SP_PARM)->_maxx + 1);
+ NCURSES_CH_T blank = NewScreen(SP_PARM)->_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++) {
- ok = (CharEq(newscr->_line[row].text[col], blank));
+ ok = (CharEq(NewScreen(SP_PARM)->_line[row].text[col], blank));
}
if (!ok)
break;
for (col = 0; ok && col < last; col++) {
- ok = (CharEq(curscr->_line[row].text[col], blank));
+ ok = (CharEq(CurScreen(SP_PARM)->_line[row].text[col], blank));
}
if (!ok)
top = row;
@@ -1092,11 +1178,11 @@ ClrBottom(int total)
/* don't use clr_eos for just one line if clr_eol available */
if (top < total) {
- GoTo(top, 0);
- ClrToEOS(blank);
- if (SP->oldhash && SP->newhash) {
- for (row = top; row < screen_lines; row++)
- SP->oldhash[row] = SP->newhash[row];
+ 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++)
+ SP_PARM->oldhash[row] = SP_PARM->newhash[row];
}
}
}
@@ -1105,22 +1191,22 @@ ClrBottom(int total)
#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) NewScreen(sp)->_line[r].text[c]
+#define xmc_turn_off(sp,a,b) xmc_turn_on(sp,b,a)
#endif /* USE_XMC_SUPPORT */
/*
** TransformLine(lineno)
**
** Transform the given line in curscr to the one in newscr, using
-** Insert/Delete Character if _nc_idcok && has_ic().
+** Insert/Delete Character if idcok && has_ic().
**
** firstChar = position of first different character in line
** oLastChar = position of last different character in old line
@@ -1135,19 +1221,19 @@ ClrBottom(int total)
*/
static void
-TransformLine(int const lineno)
+TransformLine(NCURSES_SP_DCLx int const lineno)
{
int firstChar, oLastChar, nLastChar;
- NCURSES_CH_T *newLine = newscr->_line[lineno].text;
- NCURSES_CH_T *oldLine = curscr->_line[lineno].text;
+ NCURSES_CH_T *newLine = NewScreen(SP_PARM)->_line[lineno].text;
+ NCURSES_CH_T *oldLine = CurScreen(SP_PARM)->_line[lineno].text;
int n;
bool attrchanged = FALSE;
- TR(TRACE_UPDATE, (T_CALLED("TransformLine(%d)"), lineno));
+ TR(TRACE_UPDATE, (T_CALLED("TransformLine(%p, %d)"), (void *) SP_PARM, lineno));
/* copy new hash value to old one */
- if (SP->oldhash && SP->newhash)
- SP->oldhash[lineno] = SP->newhash[lineno];
+ if (SP_PARM->oldhash && SP_PARM->newhash)
+ SP_PARM->oldhash[lineno] = SP_PARM->newhash[lineno];
/*
* If we have colors, there is the possibility of having two color pairs
@@ -1155,19 +1241,20 @@ TransformLine(int const lineno)
* for this case, and update the old line with the new line's colors when
* they are equivalent.
*/
- if (SP->_coloron) {
+ if (SP_PARM->_coloron) {
int oldPair;
int newPair;
- for (n = 0; n < screen_columns; n++) {
+ for (n = 0; n < screen_columns(SP_PARM); n++) {
if (!CharEq(newLine[n], oldLine[n])) {
oldPair = GetPair(oldLine[n]);
newPair = GetPair(newLine[n]);
if (oldPair != newPair
&& unColor(oldLine[n]) == unColor(newLine[n])) {
- if (oldPair < COLOR_PAIRS
- && newPair < COLOR_PAIRS
- && SP->_color_pairs[oldPair] == SP->_color_pairs[newPair]) {
+ if (oldPair < SP_PARM->_pair_limit
+ && newPair < SP_PARM->_pair_limit
+ && (SP_PARM->_color_pairs[oldPair] ==
+ SP_PARM->_color_pairs[newPair])) {
SetPair(oldLine[n], GetPair(newLine[n]));
}
}
@@ -1177,7 +1264,7 @@ TransformLine(int const lineno)
if (ceol_standout_glitch && clr_eol) {
firstChar = 0;
- while (firstChar < screen_columns) {
+ while (firstChar < screen_columns(SP_PARM)) {
if (!SameAttrOf(newLine[firstChar], oldLine[firstChar])) {
attrchanged = TRUE;
break;
@@ -1189,9 +1276,13 @@ TransformLine(int const lineno)
firstChar = 0;
if (attrchanged) { /* we may have to disregard the whole line */
- GoTo(lineno, firstChar);
- ClrToEOL(ClrBlank(curscr), FALSE);
- PutRange(oldLine, newLine, lineno, 0, (screen_columns - 1));
+ GoTo(NCURSES_SP_ARGx lineno, firstChar);
+ ClrToEOL(NCURSES_SP_ARGx
+ ClrBlank(NCURSES_SP_ARGx
+ CurScreen(SP_PARM)), FALSE);
+ PutRange(NCURSES_SP_ARGx
+ oldLine, newLine, lineno, 0,
+ screen_columns(SP_PARM) - 1);
#if USE_XMC_SUPPORT
/*
@@ -1206,8 +1297,8 @@ TransformLine(int const lineno)
* following operation.
*/
} else if (magic_cookie_glitch > 0) {
- GoTo(lineno, firstChar);
- for (n = 0; n < screen_columns; n++) {
+ GoTo(NCURSES_SP_ARGx lineno, firstChar);
+ for (n = 0; n < screen_columns(SP_PARM); n++) {
int m = n + magic_cookie_glitch;
/* check for turn-on:
@@ -1216,26 +1307,30 @@ TransformLine(int const lineno)
*/
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 - 1),
+ && xmc_turn_on(SP_PARM,
+ xmc_new(SP_PARM, lineno - 1,
+ screen_columns(SP_PARM) - 1),
newLine[n])))) {
n = m;
}
- PutChar(CHREF(newLine[n]));
+ PutChar(NCURSES_SP_ARGx CHREF(newLine[n]));
/* check for turn-off:
* If we are writing an attributed non-blank, where the
* next cell is blank, and not attributed.
*/
if (!ISBLANK(newLine[n])
- && ((n + 1 < screen_columns
- && xmc_turn_off(newLine[n], newLine[n + 1]))
- || (n + 1 >= screen_columns
- && lineno + 1 < screen_lines
- && xmc_turn_off(newLine[n], xmc_new(lineno + 1, 0))))) {
+ && ((n + 1 < screen_columns(SP_PARM)
+ && 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(SP_PARM,
+ newLine[n],
+ xmc_new(SP_PARM, lineno + 1, 0))))) {
n = m;
}
@@ -1246,38 +1341,42 @@ TransformLine(int const lineno)
/* 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; oFirstChar < screen_columns; oFirstChar++)
+ for (oFirstChar = 0;
+ oFirstChar < screen_columns(SP_PARM);
+ oFirstChar++)
if (!CharEq(oldLine[oFirstChar], blank))
break;
- for (nFirstChar = 0; nFirstChar < screen_columns; nFirstChar++)
+ for (nFirstChar = 0;
+ nFirstChar < screen_columns(SP_PARM);
+ nFirstChar++)
if (!CharEq(newLine[nFirstChar], blank))
break;
if (nFirstChar == oFirstChar) {
firstChar = nFirstChar;
/* find the first differing character */
- while (firstChar < screen_columns
+ while (firstChar < screen_columns(SP_PARM)
&& CharEq(newLine[firstChar], oldLine[firstChar]))
firstChar++;
} else if (oFirstChar > nFirstChar) {
firstChar = nFirstChar;
} else { /* oFirstChar < nFirstChar */
firstChar = oFirstChar;
- if (SP->_el1_cost < nFirstChar - oFirstChar) {
- if (nFirstChar >= screen_columns
- && SP->_el_cost <= SP->_el1_cost) {
- GoTo(lineno, 0);
- UpdateAttrs(blank);
+ if (SP_PARM->_el1_cost < nFirstChar - oFirstChar) {
+ if (nFirstChar >= screen_columns(SP_PARM)
+ && SP_PARM->_el_cost <= SP_PARM->_el1_cost) {
+ GoTo(NCURSES_SP_ARGx lineno, 0);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("clr_eol");
- putp(clr_eol);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx 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);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx clr_bol);
}
while (firstChar < nFirstChar)
@@ -1286,64 +1385,81 @@ TransformLine(int const lineno)
}
} else {
/* find the first differing character */
- while (firstChar < screen_columns
+ while (firstChar < screen_columns(SP_PARM)
&& CharEq(newLine[firstChar], oldLine[firstChar]))
firstChar++;
}
/* if there wasn't one, we're done */
- if (firstChar >= screen_columns) {
+ if (firstChar >= screen_columns(SP_PARM)) {
TR(TRACE_UPDATE, (T_RETURN("")));
return;
}
- blank = newLine[screen_columns - 1];
+ 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 - 1;
+ nLastChar = screen_columns(SP_PARM) - 1;
while (nLastChar > firstChar
&& CharEq(newLine[nLastChar], oldLine[nLastChar]))
nLastChar--;
if (nLastChar >= firstChar) {
- GoTo(lineno, firstChar);
- PutRange(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));
+ (unsigned) (nLastChar - firstChar + 1) * sizeof(NCURSES_CH_T));
}
TR(TRACE_UPDATE, (T_RETURN("")));
return;
}
/* find last non-blank character on old line */
- oLastChar = screen_columns - 1;
+ oLastChar = screen_columns(SP_PARM) - 1;
while (oLastChar > firstChar && CharEq(oldLine[oLastChar], blank))
oLastChar--;
/* find last non-blank character on new line */
- nLastChar = screen_columns - 1;
+ nLastChar = screen_columns(SP_PARM) - 1;
while (nLastChar > firstChar && CharEq(newLine[nLastChar], blank))
nLastChar--;
if ((nLastChar == firstChar)
- && (SP->_el_cost < (oLastChar - nLastChar))) {
- GoTo(lineno, firstChar);
+ && (SP_PARM->_el_cost < (oLastChar - nLastChar))) {
+ GoTo(NCURSES_SP_ARGx lineno, firstChar);
if (!CharEq(newLine[firstChar], blank))
- PutChar(CHREF(newLine[firstChar]));
- ClrToEOL(blank, FALSE);
+ 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);
- if ((oLastChar - nLastChar) > SP->_el_cost) {
- if (PutRange(oldLine, newLine, lineno, firstChar, nLastChar))
- GoTo(lineno, nLastChar + 1);
- ClrToEOL(blank, FALSE);
+ || !(SP_PARM->_nc_sp_idcok
+ && NCURSES_SP_NAME(has_ic) (NCURSES_SP_ARG)))) {
+ GoTo(NCURSES_SP_ARGx lineno, firstChar);
+ if ((oLastChar - nLastChar) > SP_PARM->_el_cost) {
+ 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(oldLine, newLine, lineno, firstChar, n);
+ PutRange(NCURSES_SP_ARGx
+ oldLine,
+ newLine,
+ lineno,
+ firstChar,
+ n);
}
} else {
int nLastNonblank = nLastChar;
@@ -1364,8 +1480,13 @@ TransformLine(int const lineno)
n = min(oLastChar, nLastChar);
if (n >= firstChar) {
- GoTo(lineno, firstChar);
- PutRange(oldLine, newLine, lineno, firstChar, n);
+ GoTo(NCURSES_SP_ARGx lineno, firstChar);
+ PutRange(NCURSES_SP_ARGx
+ oldLine,
+ newLine,
+ lineno,
+ firstChar,
+ n);
}
if (oLastChar < nLastChar) {
@@ -1376,21 +1497,26 @@ TransformLine(int const lineno)
--oLastChar;
}
#endif
- GoTo(lineno, n + 1);
+ GoTo(NCURSES_SP_ARGx lineno, n + 1);
if ((nLastChar < nLastNonblank)
- || InsCharCost(nLastChar - oLastChar) > (m - n)) {
- PutRange(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)
- > SP->_el_cost + nLastNonblank - (n + 1)) {
- if (PutRange(oldLine, newLine, lineno,
+ 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);
- ClrToEOL(blank, FALSE);
+ GoTo(NCURSES_SP_ARGx lineno, nLastNonblank + 1);
+ ClrToEOL(NCURSES_SP_ARGx blank, FALSE);
} else {
/*
* The delete-char sequence will
@@ -1400,18 +1526,18 @@ TransformLine(int const lineno)
* 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);
}
}
}
}
/* update the code's internal representation */
- if (screen_columns > firstChar)
+ if (screen_columns(SP_PARM) > firstChar)
memcpy(oldLine + firstChar,
newLine + firstChar,
- (screen_columns - firstChar) * sizeof(NCURSES_CH_T));
+ (unsigned) (screen_columns(SP_PARM) - firstChar) * sizeof(NCURSES_CH_T));
TR(TRACE_UPDATE, (T_RETURN("")));
return;
}
@@ -1424,7 +1550,7 @@ TransformLine(int const lineno)
*/
static void
-ClearScreen(NCURSES_CH_T blank)
+ClearScreen(NCURSES_SP_DCLx NCURSES_CH_T blank)
{
int i, j;
bool fast_clear = (clear_screen || clr_eos || clr_eol);
@@ -1432,9 +1558,13 @@ ClearScreen(NCURSES_CH_T blank)
TR(TRACE_UPDATE, ("ClearScreen() called"));
#if NCURSES_EXT_FUNCS
- if (SP->_coloron
- && !SP->_default_color) {
- _nc_do_color(GET_SCREEN_PAIR(SP), 0, FALSE, _nc_outch);
+ if (SP_PARM->_coloron
+ && !SP_PARM->_default_color) {
+ NCURSES_SP_NAME(_nc_do_color) (NCURSES_SP_ARGx
+ (short) GET_SCREEN_PAIR(SP_PARM),
+ 0,
+ FALSE,
+ NCURSES_SP_NAME(_nc_outch));
if (!back_color_erase) {
fast_clear = FALSE;
}
@@ -1443,42 +1573,46 @@ ClearScreen(NCURSES_CH_T blank)
if (fast_clear) {
if (clear_screen) {
- UpdateAttrs(blank);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("clear_screen");
- putp(clear_screen);
- SP->_cursrow = SP->_curscol = 0;
- position_check(SP->_cursrow, SP->_curscol, "ClearScreen");
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx clear_screen);
+ SP_PARM->_cursrow = SP_PARM->_curscol = 0;
+ position_check(SP_PARM,
+ SP_PARM->_cursrow,
+ SP_PARM->_curscol,
+ "ClearScreen");
} else if (clr_eos) {
- SP->_cursrow = SP->_curscol = -1;
- GoTo(0, 0);
-
- UpdateAttrs(blank);
+ SP_PARM->_cursrow = SP_PARM->_curscol = -1;
+ GoTo(NCURSES_SP_ARGx 0, 0);
+ UpdateAttrs(SP_PARM, blank);
TPUTS_TRACE("clr_eos");
- tputs(clr_eos, screen_lines, _nc_outch);
+ NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
+ clr_eos,
+ screen_lines(SP_PARM),
+ NCURSES_SP_NAME(_nc_outch));
} else if (clr_eol) {
- SP->_cursrow = SP->_curscol = -1;
-
- UpdateAttrs(blank);
- for (i = 0; i < screen_lines; i++) {
- GoTo(i, 0);
+ SP_PARM->_cursrow = SP_PARM->_curscol = -1;
+ UpdateAttrs(SP_PARM, blank);
+ for (i = 0; i < screen_lines(SP_PARM); i++) {
+ GoTo(NCURSES_SP_ARGx i, 0);
TPUTS_TRACE("clr_eol");
- putp(clr_eol);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx clr_eol);
}
- GoTo(0, 0);
+ GoTo(NCURSES_SP_ARGx 0, 0);
}
} else {
- UpdateAttrs(blank);
- for (i = 0; i < screen_lines; i++) {
- GoTo(i, 0);
- for (j = 0; j < screen_columns; j++)
- PutChar(CHREF(blank));
+ UpdateAttrs(SP_PARM, blank);
+ for (i = 0; i < screen_lines(SP_PARM); i++) {
+ 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; i++) {
- for (j = 0; j < screen_columns; j++)
- curscr->_line[i].text[j] = blank;
+ for (i = 0; i < screen_lines(SP_PARM); i++) {
+ for (j = 0; j < screen_columns(SP_PARM); j++)
+ CurScreen(SP_PARM)->_line[i].text[j] = blank;
}
TR(TRACE_UPDATE, ("screen cleared"));
@@ -1492,49 +1626,54 @@ ClearScreen(NCURSES_CH_T blank)
*/
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",
+ (void *) SP_PARM,
+ (void *) line, count));
/* Prefer parm_ich as it has the smallest cost - no need to shift
* the whole line on each character. */
/* The order must match that of InsCharCost. */
if (parm_ich) {
TPUTS_TRACE("parm_ich");
- tputs(TPARM_1(parm_ich, count), count, _nc_outch);
+ NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
+ TPARM_1(parm_ich, count),
+ count,
+ NCURSES_SP_NAME(_nc_outch));
while (count) {
- PutAttrChar(CHREF(*line));
+ PutAttrChar(NCURSES_SP_ARGx CHREF(*line));
line++;
count--;
}
} else if (enter_insert_mode && exit_insert_mode) {
TPUTS_TRACE("enter_insert_mode");
- putp(enter_insert_mode);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx enter_insert_mode);
while (count) {
- PutAttrChar(CHREF(*line));
+ PutAttrChar(NCURSES_SP_ARGx CHREF(*line));
if (insert_padding) {
TPUTS_TRACE("insert_padding");
- putp(insert_padding);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx insert_padding);
}
line++;
count--;
}
TPUTS_TRACE("exit_insert_mode");
- putp(exit_insert_mode);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_insert_mode);
} else {
while (count) {
TPUTS_TRACE("insert_character");
- putp(insert_character);
- PutAttrChar(CHREF(*line));
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx insert_character);
+ PutAttrChar(NCURSES_SP_ARGx CHREF(*line));
if (insert_padding) {
TPUTS_TRACE("insert_padding");
- putp(insert_padding);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx insert_padding);
}
line++;
count--;
}
}
- position_check(SP->_cursrow, SP->_curscol, "InsStr");
+ position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "InsStr");
}
/*
@@ -1545,22 +1684,25 @@ InsStr(NCURSES_CH_T * line, int count)
*/
static void
-DelChar(int count)
+DelChar(NCURSES_SP_DCLx int count)
{
int n;
- TR(TRACE_UPDATE, ("DelChar(%d) called, position = (%ld,%ld)",
- count,
- (long) newscr->_cury,
- (long) newscr->_curx));
+ TR(TRACE_UPDATE, ("DelChar(%p, %d) called, position = (%ld,%ld)",
+ (void *) SP_PARM, count,
+ (long) NewScreen(SP_PARM)->_cury,
+ (long) NewScreen(SP_PARM)->_curx));
if (parm_dch) {
TPUTS_TRACE("parm_dch");
- tputs(TPARM_1(parm_dch, count), count, _nc_outch);
+ NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
+ TPARM_1(parm_dch, count),
+ count,
+ NCURSES_SP_NAME(_nc_outch));
} else {
for (n = 0; n < count; n++) {
TPUTS_TRACE("delete_character");
- putp(delete_character);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx delete_character);
}
}
}
@@ -1599,54 +1741,66 @@ DelChar(int count)
/* Try to scroll up assuming given csr (miny, maxy). Returns ERR on failure */
static int
-scroll_csr_forward(int n, int top, int bot, int miny, int maxy, NCURSES_CH_T blank)
+scroll_csr_forward(NCURSES_SP_DCLx
+ int n,
+ int top,
+ int bot,
+ int miny,
+ int maxy,
+ NCURSES_CH_T blank)
{
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);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx 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);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx 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);
+ NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
+ TPARM_2(parm_index, n, 0),
+ n,
+ NCURSES_SP_NAME(_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);
+ NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
+ TPARM_2(parm_delete_line, n, 0),
+ n,
+ NCURSES_SP_NAME(_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);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx 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);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx delete_line);
}
} else
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);
- for (j = 0; j < screen_columns; j++)
- PutChar(CHREF(blank));
+ GoTo(NCURSES_SP_ARGx bot - i, 0);
+ for (j = 0; j < screen_columns(SP_PARM); j++)
+ PutChar(NCURSES_SP_ARGx CHREF(blank));
}
}
#endif
@@ -1656,55 +1810,66 @@ scroll_csr_forward(int n, int top, int bot, int miny, int maxy, NCURSES_CH_T bla
/* Try to scroll down assuming given csr (miny, maxy). Returns ERR on failure */
/* n > 0 */
static int
-scroll_csr_backward(int n, int top, int bot, int miny, int maxy,
+scroll_csr_backward(NCURSES_SP_DCLx
+ int n,
+ int top,
+ int bot,
+ int miny,
+ int maxy,
NCURSES_CH_T 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);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx 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);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx 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);
+ NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
+ TPARM_2(parm_rindex, n, 0),
+ n,
+ NCURSES_SP_NAME(_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);
+ NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
+ TPARM_2(parm_insert_line, n, 0),
+ n,
+ NCURSES_SP_NAME(_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);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx 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);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx insert_line);
}
} else
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);
- for (j = 0; j < screen_columns; j++)
- PutChar(CHREF(blank));
+ GoTo(NCURSES_SP_ARGx top + i, 0);
+ for (j = 0; j < screen_columns(SP_PARM); j++)
+ PutChar(NCURSES_SP_ARGx CHREF(blank));
}
}
#endif
@@ -1714,40 +1879,46 @@ scroll_csr_backward(int n, int top, int bot, int miny, int maxy,
/* 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);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx delete_line);
} else if (parm_delete_line) {
TPUTS_TRACE("parm_delete_line");
- tputs(TPARM_2(parm_delete_line, n, 0), n, _nc_outch);
+ NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
+ TPARM_2(parm_delete_line, n, 0),
+ n,
+ NCURSES_SP_NAME(_nc_outch));
} else { /* if (delete_line) */
for (i = 0; i < n; i++) {
TPUTS_TRACE("delete_line");
- putp(delete_line);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx 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);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx insert_line);
} else if (parm_insert_line) {
TPUTS_TRACE("parm_insert_line");
- tputs(TPARM_2(parm_insert_line, n, 0), n, _nc_outch);
+ NCURSES_SP_NAME(tputs) (NCURSES_SP_ARGx
+ TPARM_2(parm_insert_line, n, 0),
+ n,
+ NCURSES_SP_NAME(_nc_outch));
} else { /* if (insert_line) */
for (i = 0; i < n; i++) {
TPUTS_TRACE("insert_line");
- putp(insert_line);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx insert_line);
}
}
@@ -1763,15 +1934,25 @@ scroll_idl(int n, int del, int ins, NCURSES_CH_T blank)
* save/restore cursor capabilities if the terminal has them.
*/
NCURSES_EXPORT(int)
-_nc_scrolln(int n, int top, int bot, int maxy)
+NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx
+ int n,
+ int top,
+ int bot,
+ int maxy)
/* scroll region from top to bot by n lines */
{
- NCURSES_CH_T blank = ClrBlank(stdscr);
+ NCURSES_CH_T blank;
int i;
bool cursor_saved = FALSE;
int res;
- TR(TRACE_MOVE, ("mvcur_scrolln(%d, %d, %d, %d)", n, top, bot, maxy));
+ TR(TRACE_MOVE, ("_nc_scrolln(%p, %d, %d, %d, %d)",
+ (void *) SP_PARM, n, top, bot, maxy));
+
+ if (!IsValidScreen(SP_PARM))
+ return (ERR);
+
+ blank = ClrBlank(NCURSES_SP_ARGx StdScreen(SP_PARM));
#if USE_XMC_SUPPORT
/*
@@ -1787,34 +1968,36 @@ _nc_scrolln(int n, int top, int bot, int maxy)
* Explicitly clear if stuff pushed off top of region might
* be saved by the terminal.
*/
- res = scroll_csr_forward(n, top, bot, 0, maxy, blank);
+ res = scroll_csr_forward(NCURSES_SP_ARGx n, top, bot, 0, maxy, blank);
if (res == ERR && change_scroll_region) {
if ((((n == 1 && scroll_forward) || parm_index)
- && (SP->_cursrow == bot || SP->_cursrow == bot - 1))
+ && (SP_PARM->_cursrow == bot || SP_PARM->_cursrow == bot - 1))
&& save_cursor && restore_cursor) {
cursor_saved = TRUE;
TPUTS_TRACE("save_cursor");
- putp(save_cursor);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx save_cursor);
}
TPUTS_TRACE("change_scroll_region");
- putp(TPARM_2(change_scroll_region, top, bot));
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx
+ TPARM_2(change_scroll_region, top, bot));
if (cursor_saved) {
TPUTS_TRACE("restore_cursor");
- putp(restore_cursor);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx restore_cursor);
} else {
- SP->_cursrow = SP->_curscol = -1;
+ SP_PARM->_cursrow = SP_PARM->_curscol = -1;
}
- res = scroll_csr_forward(n, top, bot, top, bot, blank);
+ res = scroll_csr_forward(NCURSES_SP_ARGx n, top, bot, top, bot, blank);
TPUTS_TRACE("change_scroll_region");
- putp(TPARM_2(change_scroll_region, 0, maxy));
- SP->_cursrow = SP->_curscol = -1;
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx
+ TPARM_2(change_scroll_region, 0, maxy));
+ SP_PARM->_cursrow = SP_PARM->_curscol = -1;
}
- if (res == ERR && _nc_idlok)
- res = scroll_idl(n, top, bot - n + 1, blank);
+ if (res == ERR && SP_PARM->_nc_sp_idlok)
+ res = scroll_idl(NCURSES_SP_ARGx n, top, bot - n + 1, blank);
/*
* Clear the newly shifted-in text.
@@ -1823,44 +2006,49 @@ _nc_scrolln(int n, int top, int bot, int maxy)
&& (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);
- ClrToEOS(blank2);
+ GoTo(NCURSES_SP_ARGx bot - n + 1, 0);
+ ClrToEOS(NCURSES_SP_ARGx blank2);
} else {
for (i = 0; i < n; i++) {
- GoTo(bot - i, 0);
- ClrToEOL(blank2, FALSE);
+ GoTo(NCURSES_SP_ARGx bot - i, 0);
+ ClrToEOL(NCURSES_SP_ARGx blank2, FALSE);
}
}
}
} else { /* (n < 0) - scroll down (backward) */
- res = scroll_csr_backward(-n, top, bot, 0, maxy, blank);
+ res = scroll_csr_backward(NCURSES_SP_ARGx -n, top, bot, 0, maxy, blank);
if (res == ERR && change_scroll_region) {
- if (top != 0 && (SP->_cursrow == top || SP->_cursrow == top - 1)
+ if (top != 0
+ && (SP_PARM->_cursrow == top ||
+ SP_PARM->_cursrow == top - 1)
&& save_cursor && restore_cursor) {
cursor_saved = TRUE;
TPUTS_TRACE("save_cursor");
- putp(save_cursor);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx save_cursor);
}
TPUTS_TRACE("change_scroll_region");
- putp(TPARM_2(change_scroll_region, top, bot));
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx
+ TPARM_2(change_scroll_region, top, bot));
if (cursor_saved) {
TPUTS_TRACE("restore_cursor");
- putp(restore_cursor);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx restore_cursor);
} else {
- SP->_cursrow = SP->_curscol = -1;
+ SP_PARM->_cursrow = SP_PARM->_curscol = -1;
}
- res = scroll_csr_backward(-n, top, bot, top, bot, blank);
+ res = scroll_csr_backward(NCURSES_SP_ARGx
+ -n, top, bot, top, bot, blank);
TPUTS_TRACE("change_scroll_region");
- putp(TPARM_2(change_scroll_region, 0, maxy));
- SP->_cursrow = SP->_curscol = -1;
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx
+ TPARM_2(change_scroll_region, 0, maxy));
+ SP_PARM->_cursrow = SP_PARM->_curscol = -1;
}
- if (res == ERR && _nc_idlok)
- res = scroll_idl(-n, bot + n + 1, top, blank);
+ if (res == ERR && SP_PARM->_nc_sp_idlok)
+ res = scroll_idl(NCURSES_SP_ARGx -n, bot + n + 1, top, blank);
/*
* Clear the newly shifted-in text.
@@ -1869,8 +2057,8 @@ _nc_scrolln(int n, int top, int bot, int maxy)
&& (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);
- ClrToEOL(blank2, FALSE);
+ GoTo(NCURSES_SP_ARGx i + top, 0);
+ ClrToEOL(NCURSES_SP_ARGx blank2, FALSE);
}
}
}
@@ -1878,99 +2066,163 @@ _nc_scrolln(int n, int top, int bot, int maxy)
if (res == ERR)
return (ERR);
- _nc_scroll_window(curscr, n, top, bot, blank);
+ _nc_scroll_window(CurScreen(SP_PARM), n,
+ (NCURSES_SIZE_T) top,
+ (NCURSES_SIZE_T) 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);
}
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(int)
+_nc_scrolln(int n, int top, int bot, int maxy)
+{
+ return NCURSES_SP_NAME(_nc_scrolln) (CURRENT_SCREEN, n, top, bot, maxy);
+}
+#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);
- newscr->_clear = TRUE;
+ SetAttr(SCREEN_ATTRS(SP_PARM), A_NORMAL);
+ NewScreen(SP_PARM)->_clear = TRUE;
/* reset color pairs and definitions */
- if (SP->_coloron || SP->_color_defs)
- _nc_reset_colors();
+ if (SP_PARM->_coloron || SP_PARM->_color_defs)
+ NCURSES_SP_NAME(_nc_reset_colors) (NCURSES_SP_ARG);
/* 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
+ (short) n,
+ SP_PARM->_color_table[n].r,
+ SP_PARM->_color_table[n].g,
+ SP_PARM->_color_table[n].b);
}
}
}
if (exit_attribute_mode)
- putp(exit_attribute_mode);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_attribute_mode);
else {
/* turn off attributes */
if (exit_alt_charset_mode)
- putp(exit_alt_charset_mode);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_alt_charset_mode);
if (exit_standout_mode)
- putp(exit_standout_mode);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_standout_mode);
if (exit_underline_mode)
- putp(exit_underline_mode);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_underline_mode);
}
if (exit_insert_mode)
- putp(exit_insert_mode);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx exit_insert_mode);
if (enter_am_mode && exit_am_mode)
- putp(auto_right_margin ? enter_am_mode : exit_am_mode);
+ NCURSES_SP_NAME(putp) (NCURSES_SP_ARGx
+ (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)
-_nc_screen_wrap(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->_coloron
- && !SP->_default_color) {
+ if (SP_PARM->_coloron
+ && !SP_PARM->_default_color) {
static const NCURSES_CH_T blank = NewChar(BLANK_TEXT);
- SP->_default_color = TRUE;
- _nc_do_color(-1, 0, FALSE, _nc_outch);
- SP->_default_color = FALSE;
-
- mvcur(SP->_cursrow, SP->_curscol, screen_lines - 1, 0);
-
- ClrToEOL(blank, TRUE);
+ SP_PARM->_default_color = TRUE;
+ NCURSES_SP_NAME(_nc_do_color) (NCURSES_SP_ARGx
+ -1,
+ 0,
+ FALSE,
+ NCURSES_SP_NAME(_nc_outch));
+ SP_PARM->_default_color = FALSE;
+
+ TINFO_MVCUR(NCURSES_SP_ARGx
+ SP_PARM->_cursrow,
+ SP_PARM->_curscol,
+ screen_lines(SP_PARM) - 1,
+ 0);
+
+ ClrToEOL(NCURSES_SP_ARGx blank, TRUE);
}
#endif
- if (SP->_color_defs) {
- _nc_reset_colors();
+ if (SP_PARM->_color_defs) {
+ NCURSES_SP_NAME(_nc_reset_colors) (NCURSES_SP_ARG);
}
}
+#if NCURSES_SP_FUNCS
+NCURSES_EXPORT(void)
+_nc_screen_wrap(void)
+{
+ NCURSES_SP_NAME(_nc_screen_wrap) (CURRENT_SCREEN);
+}
+#endif
+
#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 */