From: Thomas E. Dickey Date: Sun, 26 Apr 2009 01:00:20 +0000 (+0000) Subject: ncurses 5.7 - patch 20090425 X-Git-Tag: v5.8~94 X-Git-Url: http://ncurses.scripts.mit.edu/?p=ncurses.git;a=commitdiff_plain;h=049beef99ef979a45484cba9b56344acbd2f058c ncurses 5.7 - patch 20090425 + continue integrating "sp-funcs" by Juergen Pfeifer (incomplete). --- diff --git a/NEWS b/NEWS index 4f64d613..b5c9782a 100644 --- a/NEWS +++ b/NEWS @@ -25,7 +25,7 @@ -- sale, use or other dealings in this Software without prior written -- -- authorization. -- ------------------------------------------------------------------------------- --- $Id: NEWS,v 1.1382 2009/04/19 14:39:28 tom Exp $ +-- $Id: NEWS,v 1.1383 2009/04/25 21:28:43 tom Exp $ ------------------------------------------------------------------------------- This is a log of changes that ncurses has gone through since Zeyd started @@ -45,6 +45,9 @@ See the AUTHORS file for the corresponding full names. Changes through 1.9.9e did not credit all contributions; it is not possible to add this information. +20090425 + + continue integrating "sp-funcs" by Juergen Pfeifer (incomplete). + 20090419 + build fix for _nc_free_and_exit() change in 20090418 (report by Christian Ebert). diff --git a/dist.mk b/dist.mk index b872947c..99811e41 100644 --- a/dist.mk +++ b/dist.mk @@ -25,7 +25,7 @@ # use or other dealings in this Software without prior written # # authorization. # ############################################################################## -# $Id: dist.mk,v 1.695 2009/04/19 14:38:20 tom Exp $ +# $Id: dist.mk,v 1.696 2009/04/25 17:43:20 tom Exp $ # Makefile for creating ncurses distributions. # # This only needs to be used directly as a makefile by developers, but @@ -37,7 +37,7 @@ SHELL = /bin/sh # These define the major/minor/patch versions of ncurses. NCURSES_MAJOR = 5 NCURSES_MINOR = 7 -NCURSES_PATCH = 20090419 +NCURSES_PATCH = 20090425 # We don't append the patch to the version, since this only applies to releases VERSION = $(NCURSES_MAJOR).$(NCURSES_MINOR) diff --git a/include/MKterm.h.awk.in b/include/MKterm.h.awk.in index 31ee34c9..9f635d65 100644 --- a/include/MKterm.h.awk.in +++ b/include/MKterm.h.awk.in @@ -34,7 +34,7 @@ BEGIN { print "/* and: Thomas E. Dickey 1995-on */" print "/****************************************************************************/" print "" - print "/* $Id: MKterm.h.awk.in,v 1.54 2009/04/18 20:44:15 tom Exp $ */" + print "/* $Id: MKterm.h.awk.in,v 1.55 2009/04/25 18:02:27 tom Exp $ */" print "" print "/*" print "** term.h -- Definition of struct term" @@ -130,11 +130,15 @@ BEGIN { print "" print "#else /* !HAVE_TERMIO_H */" print "" + print "#if __MINGW32__" + print "# include " + print "# define TTY struct termios" + print "#else" print "#undef TERMIOS" print "#include " print "#include " print "#define TTY struct sgttyb" - print "" + print "#endif /* MINGW32 */" print "#endif /* HAVE_TERMIO_H */" print "" print "#endif /* HAVE_TERMIOS_H */" diff --git a/include/curses.h.in b/include/curses.h.in index 0c722bdd..7adcb622 100644 --- a/include/curses.h.in +++ b/include/curses.h.in @@ -32,7 +32,7 @@ * and: Thomas E. Dickey 1996-on * ****************************************************************************/ -/* $Id: curses.h.in,v 1.196 2009/04/18 19:57:58 tom Exp $ */ +/* $Id: curses.h.in,v 1.197 2009/04/25 21:03:34 tom Exp $ */ #ifndef __NCURSES_H #define __NCURSES_H @@ -965,9 +965,12 @@ extern NCURSES_EXPORT(char *) NCURSES_SP_NAME(keybound) (SCREEN*, int, int); extern NCURSES_EXPORT(int) NCURSES_SP_NAME(assume_default_colors) (SCREEN*, int, int); extern NCURSES_EXPORT(int) NCURSES_SP_NAME(define_key) (SCREEN*, const char *, int); extern NCURSES_EXPORT(int) NCURSES_SP_NAME(get_escdelay) (SCREEN*); +extern NCURSES_EXPORT(bool) NCURSES_SP_NAME(is_term_resized) (SCREEN*, int, int); extern NCURSES_EXPORT(int) NCURSES_SP_NAME(key_defined)(SCREEN*, const char *); extern NCURSES_EXPORT(int) NCURSES_SP_NAME(keyok) (SCREEN*, int, bool); extern NCURSES_EXPORT(void) NCURSES_SP_NAME(nofilter) (SCREEN*); /* implemented */ +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(resize_term) (SCREEN*, int, int); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(resizeterm) (SCREEN*, int, int); extern NCURSES_EXPORT(int) NCURSES_SP_NAME(set_escdelay) (SCREEN*, int); extern NCURSES_EXPORT(int) NCURSES_SP_NAME(set_tabsize) (SCREEN*, int); extern NCURSES_EXPORT(int) NCURSES_SP_NAME(use_default_colors) (SCREEN*); diff --git a/ncurses/curses.priv.h b/ncurses/curses.priv.h index a8e0c0bf..acc94be2 100644 --- a/ncurses/curses.priv.h +++ b/ncurses/curses.priv.h @@ -35,7 +35,7 @@ /* - * $Id: curses.priv.h,v 1.408 2009/04/19 14:32:33 tom Exp $ + * $Id: curses.priv.h,v 1.410 2009/04/25 23:38:37 tom Exp $ * * curses.priv.h * @@ -1163,7 +1163,7 @@ extern NCURSES_EXPORT_VAR(SIG_ATOMIC_T) _nc_have_sigwinch; AttrOf(dst) |= (ext + 1) #define if_WIDEC(code) code -#define Charable(ch) ((SP != 0 && SP->_legacy_coding) \ +#define Charable(ch) ((SP_PARM != 0 && SP_PARM->_legacy_coding) \ || (AttrOf(ch) & A_ALTCHARSET) \ || (!isWidecExt(ch) && \ (ch).chars[1] == L'\0' && \ @@ -1418,37 +1418,37 @@ extern NCURSES_EXPORT(void) name (void); \ }\ TR(TRACE_ATTRS, ("new attribute is %s", _traceattr((S))));} -#define DelCharCost(count) \ +#define DelCharCost(sp,count) \ ((parm_dch != 0) \ - ? SP->_dch_cost \ + ? sp->_dch_cost \ : ((delete_character != 0) \ - ? (SP->_dch1_cost * count) \ + ? (sp->_dch1_cost * count) \ : INFINITY)) -#define InsCharCost(count) \ +#define InsCharCost(sp,count) \ ((parm_ich != 0) \ - ? SP->_ich_cost \ + ? sp->_ich_cost \ : ((enter_insert_mode && exit_insert_mode) \ - ? SP->_smir_cost + SP->_rmir_cost + (SP->_ip_cost * count) \ + ? sp->_smir_cost + sp->_rmir_cost + (sp->_ip_cost * count) \ : ((insert_character != 0) \ - ? ((SP->_ich1_cost + SP->_ip_cost) * count) \ + ? ((sp->_ich1_cost + sp->_ip_cost) * count) \ : INFINITY))) #if USE_XMC_SUPPORT -#define UpdateAttrs(c) if (!SameAttrOf(SCREEN_ATTRS(SP), c)) { \ - attr_t chg = AttrOf(SCREEN_ATTRS(SP)); \ +#define UpdateAttrs(sp,c) if (!SameAttrOf(SCREEN_ATTRS(sp), c)) { \ + attr_t chg = AttrOf(SCREEN_ATTRS(sp)); \ VIDATTR(AttrOf(c), GetPair(c)); \ if (magic_cookie_glitch > 0 \ - && XMC_CHANGES((chg ^ AttrOf(SCREEN_ATTRS(SP))))) { \ + && XMC_CHANGES((chg ^ AttrOf(SCREEN_ATTRS(sp))))) { \ T(("%s @%d before glitch %d,%d", \ __FILE__, __LINE__, \ - SP->_cursrow, \ - SP->_curscol)); \ + sp->_cursrow, \ + sp->_curscol)); \ _nc_do_xmc_glitch(chg); \ } \ } #else -#define UpdateAttrs(c) if (!SameAttrOf(SCREEN_ATTRS(SP), c)) \ +#define UpdateAttrs(sp,c) if (!SameAttrOf(SCREEN_ATTRS(sp), c)) \ VIDATTR(AttrOf(c), GetPair(c)); #endif @@ -1721,13 +1721,13 @@ extern NCURSES_EXPORT_VAR(int *) _nc_oldnums; #if BROKEN_LINKER #define SP _nc_screen() extern NCURSES_EXPORT(SCREEN *) _nc_screen (void); -extern NCURSES_EXPORT(int) _nc_alloc_screen (void); -extern NCURSES_EXPORT(void) _nc_set_screen (SCREEN *); +extern NCURSES_EXPORT(int) _nc_alloc_screen (void); +extern NCURSES_EXPORT(void) _nc_set_screen (SCREEN *); #else /* current screen is private data; avoid possible linking conflicts too */ extern NCURSES_EXPORT_VAR(SCREEN *) SP; -#define _nc_alloc_screen() ((SP = typeCalloc(SCREEN, 1)) != 0) -#define _nc_set_screen(sp) SP = sp +#define _nc_alloc_screen() ((SP = typeCalloc(SCREEN, 1)) != 0) +#define _nc_set_screen(sp) SP = sp #endif #define CURRENT_SCREEN SP @@ -1739,8 +1739,8 @@ extern NCURSES_EXPORT_VAR(SCREEN *) SP; * if the application is running multiple screens under X, it's quite possible * they could all have type xterm but have different sizes! So... */ -#define screen_lines(sp) (sp)->_lines -#define screen_columns(sp) (sp)->_columns +#define screen_lines(sp) (sp)->_lines +#define screen_columns(sp) (sp)->_columns extern NCURSES_EXPORT(int) _nc_slk_initialize (WINDOW *, int); @@ -1802,45 +1802,52 @@ extern NCURSES_EXPORT(chtype) NCURSES_SP_NAME(_nc_acs_char)(SCREEN*,int); */ extern NCURSES_EXPORT(SCREEN*) _nc_SP(void); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_vidputs)(SCREEN*,chtype,int(*) (SCREEN*, int)); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_vidattr)(SCREEN *, chtype); - -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_scr_restore)(SCREEN*, const char*); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_scr_init)(SCREEN*,const char*); - -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_restartterm)(SCREEN*,NCURSES_CONST char*,int,int*); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_ripoffline)(SCREEN*, int, int (*)(WINDOW *,int)); +extern NCURSES_EXPORT(WINDOW *) NCURSES_SP_NAME(_nc_makenew) (SCREEN*, int, int, int, int, int); extern NCURSES_EXPORT(bool) NCURSES_SP_NAME(_nc_is_term_resized)(SCREEN*,int,int); +extern NCURSES_EXPORT(char *) NCURSES_SP_NAME(_nc_printf_string)(SCREEN*, const char *, va_list); +extern NCURSES_EXPORT(chtype) NCURSES_SP_NAME(_nc_acs_char)(SCREEN*,int); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_curs_set)(SCREEN*,int); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_get_tty_mode)(SCREEN*,TTY*); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_mcprint)(SCREEN*,char*, int); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_msec_cost)(SCREEN*, const char *, int); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_outch)(SCREEN*, int); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_putp)(SCREEN*, const char *, const char *); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_putp_flush)(SCREEN*, const char *, const char *); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_resetty)(SCREEN*); extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_resize_term)(SCREEN*,int,int); extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_resizeterm)(SCREEN*,int,int); - -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_outch)(SCREEN*, int); -extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_flush)(SCREEN*); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_restartterm)(SCREEN*,NCURSES_CONST char*,int,int*); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_ripoffline)(SCREEN*, int, int (*)(WINDOW *,int)); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_savetty)(SCREEN*); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_scr_init)(SCREEN*,const char*); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_scr_restore)(SCREEN*, const char*); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_scrolln)(SCREEN*, int, int, int, int); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_set_tty_mode)(SCREEN*,TTY*); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_setupscreen)(SCREEN**, int, int, FILE *, bool, int); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_tgetent)(SCREEN*,char*,const char *); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_tigetnum)(SCREEN*,NCURSES_CONST char*); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_tputs)(SCREEN*,const char*,int,int(*)(SCREEN*, int)); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_vid_attr)(SCREEN *, attr_t, short, void *); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_vidattr)(SCREEN *, chtype); +extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_vidputs)(SCREEN*,chtype,int(*) (SCREEN*, int)); +extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_do_color)(SCREEN*, short, short, bool, int (*)(SCREEN*,int)); +extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_do_xmc_glitch)(SCREEN*, attr_t); +extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_flush)(SCREEN*); +extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_free_and_exit)(SCREEN*,int) GCC_NORETURN; extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_freeall)(SCREEN*); -extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_free_and_exit)(SCREEN*, int); extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_hash_map)(SCREEN*); -extern NCURSES_EXPORT(WINDOW *) NCURSES_SP_NAME(_nc_makenew) (SCREEN*, int, int, int, int, int); +extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_init_acs)(SCREEN*); extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_make_oldhash)(SCREEN*, int i); -extern NCURSES_EXPORT(char *) NCURSES_SP_NAME(_nc_printf_string)(SCREEN*, const char *, va_list); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_putp)(SCREEN*, const char *, const char *); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_putp_flush)(SCREEN*, const char *, const char *); -extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_set_buffer)(SCREEN*, FILE *, bool); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_tgetent)(SCREEN*,char*,const char *); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_tputs)(SCREEN*,const char*,int,int(*)(SCREEN*, int)); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_savetty)(SCREEN*); +extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_mvcur_init)(SCREEN*); +extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_mvcur_resume)(SCREEN*); +extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_mvcur_wrap)(SCREEN*); +extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_screen_init)(SCREEN*); +extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_screen_resume)(SCREEN*); extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_screen_wrap)(SCREEN*); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_resetty)(SCREEN*); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_scrolln)(SCREEN*, int, int, int, int); extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_scroll_oldhash)(SCREEN*, int n, int top, int bot); extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_scroll_optimize)(SCREEN*); +extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_set_buffer)(SCREEN*, FILE *, bool); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_mcprint)(SCREEN*,char*, int); -extern NCURSES_EXPORT(char *) NCURSES_SP_NAME(_nc_tgetstr)(SCREEN*,NCURSES_CONST char*,char**); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_tgetflag)(SCREEN*,NCURSES_CONST char*); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_tgetnum)(SCREEN*,NCURSES_CONST char*); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_tigetflag)(SCREEN*,NCURSES_CONST char*); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(_nc_tigetnum)(SCREEN*,NCURSES_CONST char*); -extern NCURSES_EXPORT(char *) NCURSES_SP_NAME(_nc_tigetstr)(SCREEN*, NCURSES_CONST char*); extern NCURSES_EXPORT(void) _nc_cookie_init(SCREEN *sp); extern NCURSES_EXPORT(int) _nc_tinfo_doupdate(SCREEN *sp); extern NCURSES_EXPORT(int) _nc_tinfo_mcprint(SCREEN*,char*,int); @@ -1853,12 +1860,6 @@ extern NCURSES_EXPORT(void) NCURSES_SP_NAME(_nc_linedump)(SCREEN*); extern NCURSES_EXPORT(wchar_t *) NCURSES_SP_NAME(_nc_wunctrl)(SCREEN*, cchar_t *); #endif -/* FIXME - move these to curses.h.in */ -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(getmouse) (SCREEN*, MEVENT *); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(ungetmouse) (SCREEN*, MEVENT *); -extern NCURSES_EXPORT(mmask_t) NCURSES_SP_NAME(mousemask) (SCREEN*, mmask_t, mmask_t *); -extern NCURSES_EXPORT(int) NCURSES_SP_NAME(mouseinterval) (SCREEN*, int); -extern NCURSES_EXPORT(bool) NCURSES_SP_NAME(has_mouse) (SCREEN*); #endif /* NCURSES_SP_FUNCS */ #if NCURSES_SP_FUNCS diff --git a/ncurses/tty/lib_mvcur.c b/ncurses/tty/lib_mvcur.c index 3961f457..157f7eb6 100644 --- a/ncurses/tty/lib_mvcur.c +++ b/ncurses/tty/lib_mvcur.c @@ -110,8 +110,8 @@ * LONG_DIST and (b) further inward from the right or left edge than LONG_DIST, * we'll consider nonlocal. */ -#define NOT_LOCAL(fy, fx, ty, tx) ((tx > LONG_DIST) \ - && (tx < screen_columns(CURRENT_SCREEN) - 1 - LONG_DIST) \ +#define NOT_LOCAL(sp, fy, fx, ty, tx) ((tx > LONG_DIST) \ + && (tx < screen_columns(sp) - 1 - LONG_DIST) \ && (abs(ty-fy) + abs(tx-fx) > LONG_DIST)) /**************************************************************************** @@ -156,10 +156,10 @@ #include #include -MODULE_ID("$Id: lib_mvcur.c,v 1.115 2009/04/18 19:03:05 tom Exp $") +MODULE_ID("$Id: lib_mvcur.c,v 1.117 2009/04/26 00:15:22 tom Exp $") -#define WANT_CHAR(y, x) SP->_newscr->_line[y].text[x] /* desired state */ -#define BAUDRATE cur_term->_baudrate /* bits per second */ +#define WANT_CHAR(sp, y, x) (sp)->_newscr->_line[y].text[x] /* desired state */ +#define BAUDRATE(sp) cur_term->_baudrate /* bits per second */ #if defined(MAIN) || defined(NCURSES_TEST) #include @@ -170,7 +170,7 @@ static float diff; #define OPT_SIZE 512 -static int normalized_cost(const char *const cap, int affcnt); +static int normalized_cost(NCURSES_SP_DCLx const char *const cap, int affcnt); /**************************************************************************** * @@ -180,34 +180,34 @@ static int normalized_cost(const char *const cap, int affcnt); #ifdef TRACE static int -trace_cost_of(const char *capname, const char *cap, int affcnt) +trace_cost_of(NCURSES_SP_DCLx const char *capname, const char *cap, int affcnt) { - int result = _nc_msec_cost(cap, affcnt); + int result = NCURSES_SP_NAME(_nc_msec_cost) (NCURSES_SP_ARGx cap, affcnt); TR(TRACE_CHARPUT | TRACE_MOVE, ("CostOf %s %d %s", capname, result, _nc_visbuf(cap))); return result; } -#define CostOf(cap,affcnt) trace_cost_of(#cap,cap,affcnt); +#define CostOf(cap,affcnt) trace_cost_of(NCURSES_SP_ARGx #cap, cap, affcnt) static int -trace_normalized_cost(const char *capname, const char *cap, int affcnt) +trace_normalized_cost(NCURSES_SP_DCLx const char *capname, const char *cap, int affcnt) { - int result = normalized_cost(cap, affcnt); + int result = normalized_cost(NCURSES_SP_ARGx cap, affcnt); TR(TRACE_CHARPUT | TRACE_MOVE, ("NormalizedCost %s %d %s", capname, result, _nc_visbuf(cap))); return result; } -#define NormalizedCost(cap,affcnt) trace_normalized_cost(#cap,cap,affcnt); +#define NormalizedCost(cap,affcnt) trace_normalized_cost(NCURSES_SP_ARGx #cap, cap, affcnt) #else -#define CostOf(cap,affcnt) _nc_msec_cost(cap,affcnt); -#define NormalizedCost(cap,affcnt) normalized_cost(cap,affcnt); +#define CostOf(cap,affcnt) NCURSES_SP_NAME(_nc_msec_cost)(NCURSES_SP_ARGx cap, affcnt) +#define NormalizedCost(cap,affcnt) normalized_cost(NCURSES_SP_ARGx cap, affcnt) #endif NCURSES_EXPORT(int) -_nc_msec_cost(const char *const cap, int affcnt) +NCURSES_SP_NAME(_nc_msec_cost) (NCURSES_SP_DCLx const char *const cap, int affcnt) /* compute the cost of a given operation */ { if (cap == 0) @@ -231,29 +231,37 @@ _nc_msec_cost(const char *const cap, int affcnt) } #if NCURSES_NO_PADDING - if (!GetNoPadding(SP)) + if (!GetNoPadding(SP_PARM)) #endif cum_cost += number * 10; } else - cum_cost += SP->_char_padding; + cum_cost += SP_PARM->_char_padding; } return ((int) cum_cost); } } +#if NCURSES_SP_FUNCS +NCURSES_EXPORT(int) +_nc_msec_cost(const char *const cap, int affcnt) +{ + return NCURSES_SP_NAME(_nc_msec_cost) (CURRENT_SCREEN, cap, affcnt); +} +#endif + static int -normalized_cost(const char *const cap, int affcnt) +normalized_cost(NCURSES_SP_DCLx const char *const cap, int affcnt) /* compute the effective character-count for an operation (round up) */ { int cost = _nc_msec_cost(cap, affcnt); if (cost != INFINITY) - cost = (cost + SP->_char_padding - 1) / SP->_char_padding; + cost = (cost + SP_PARM->_char_padding - 1) / SP_PARM->_char_padding; return cost; } static void -reset_scroll_region(void) +reset_scroll_region(NCURSES_SP_DCL0) /* Set the scroll-region to a known state (the default) */ { if (change_scroll_region) { @@ -263,7 +271,7 @@ reset_scroll_region(void) } NCURSES_EXPORT(void) -_nc_mvcur_resume(void) +NCURSES_SP_NAME(_nc_mvcur_resume) (NCURSES_SP_DCL0) /* what to do at initialization time and after each shellout */ { /* initialize screen for cursor access */ @@ -281,53 +289,63 @@ _nc_mvcur_resume(void) * they know the screen size. This is useful when you're running * a vt100 emulation through xterm. */ - reset_scroll_region(); - SP->_cursrow = SP->_curscol = -1; + reset_scroll_region(NCURSES_SP_ARG); + SP_PARM->_cursrow = SP_PARM->_curscol = -1; /* restore cursor shape */ - if (SP->_cursor != -1) { - int cursor = SP->_cursor; - SP->_cursor = -1; + if (SP_PARM->_cursor != -1) { + int cursor = SP_PARM->_cursor; + SP_PARM->_cursor = -1; curs_set(cursor); } } +#if NCURSES_SP_FUNCS NCURSES_EXPORT(void) -_nc_mvcur_init(void) +_nc_mvcur_resume(void) +{ + NCURSES_SP_NAME(_nc_mvcur_resume) (CURRENT_SCREEN); +} +#endif + +NCURSES_EXPORT(void) +NCURSES_SP_NAME(_nc_mvcur_init) (NCURSES_SP_DCL0) /* initialize the cost structure */ { - if (isatty(fileno(SP->_ofp))) - SP->_char_padding = ((BAUDBYTE * 1000 * 10) - / (BAUDRATE > 0 ? BAUDRATE : 9600)); + if (isatty(fileno(SP_PARM->_ofp))) + SP_PARM->_char_padding = ((BAUDBYTE * 1000 * 10) + / (BAUDRATE(SP_PARM) > 0 + ? BAUDRATE(SP_PARM) + : 9600)); else - SP->_char_padding = 1; /* must be nonzero */ - if (SP->_char_padding <= 0) - SP->_char_padding = 1; /* must be nonzero */ - TR(TRACE_CHARPUT | TRACE_MOVE, ("char_padding %d msecs", SP->_char_padding)); + SP_PARM->_char_padding = 1; /* must be nonzero */ + if (SP_PARM->_char_padding <= 0) + SP_PARM->_char_padding = 1; /* must be nonzero */ + TR(TRACE_CHARPUT | TRACE_MOVE, ("char_padding %d msecs", SP_PARM->_char_padding)); /* non-parameterized local-motion strings */ - SP->_cr_cost = CostOf(carriage_return, 0); - SP->_home_cost = CostOf(cursor_home, 0); - SP->_ll_cost = CostOf(cursor_to_ll, 0); + SP_PARM->_cr_cost = CostOf(carriage_return, 0); + SP_PARM->_home_cost = CostOf(cursor_home, 0); + SP_PARM->_ll_cost = CostOf(cursor_to_ll, 0); #if USE_HARD_TABS if (getenv("NCURSES_NO_HARD_TABS") == 0) { - SP->_ht_cost = CostOf(tab, 0); - SP->_cbt_cost = CostOf(back_tab, 0); + SP_PARM->_ht_cost = CostOf(tab, 0); + SP_PARM->_cbt_cost = CostOf(back_tab, 0); } else { - SP->_ht_cost = INFINITY; - SP->_cbt_cost = INFINITY; + SP_PARM->_ht_cost = INFINITY; + SP_PARM->_cbt_cost = INFINITY; } #endif /* USE_HARD_TABS */ - SP->_cub1_cost = CostOf(cursor_left, 0); - SP->_cuf1_cost = CostOf(cursor_right, 0); - SP->_cud1_cost = CostOf(cursor_down, 0); - SP->_cuu1_cost = CostOf(cursor_up, 0); - - SP->_smir_cost = CostOf(enter_insert_mode, 0); - SP->_rmir_cost = CostOf(exit_insert_mode, 0); - SP->_ip_cost = 0; + SP_PARM->_cub1_cost = CostOf(cursor_left, 0); + SP_PARM->_cuf1_cost = CostOf(cursor_right, 0); + SP_PARM->_cud1_cost = CostOf(cursor_down, 0); + SP_PARM->_cuu1_cost = CostOf(cursor_up, 0); + + SP_PARM->_smir_cost = CostOf(enter_insert_mode, 0); + SP_PARM->_rmir_cost = CostOf(exit_insert_mode, 0); + SP_PARM->_ip_cost = 0; if (insert_padding) { - SP->_ip_cost = CostOf(insert_padding, 0); + SP_PARM->_ip_cost = CostOf(insert_padding, 0); } /* @@ -336,7 +354,7 @@ _nc_mvcur_init(void) * can treat it like absolute screen addressing. This seems to be true * for all cursor_mem_address terminal types in the terminfo database. */ - SP->_address_cursor = cursor_address ? cursor_address : cursor_mem_address; + SP_PARM->_address_cursor = cursor_address ? cursor_address : cursor_mem_address; /* * Parametrized local-motion strings. This static cost computation @@ -362,40 +380,42 @@ _nc_mvcur_init(void) * All these averages depend on the assumption that all parameter values * are equally probable. */ - SP->_cup_cost = CostOf(TPARM_2(SP->_address_cursor, 23, 23), 1); - SP->_cub_cost = CostOf(TPARM_1(parm_left_cursor, 23), 1); - SP->_cuf_cost = CostOf(TPARM_1(parm_right_cursor, 23), 1); - SP->_cud_cost = CostOf(TPARM_1(parm_down_cursor, 23), 1); - SP->_cuu_cost = CostOf(TPARM_1(parm_up_cursor, 23), 1); - SP->_hpa_cost = CostOf(TPARM_1(column_address, 23), 1); - SP->_vpa_cost = CostOf(TPARM_1(row_address, 23), 1); + SP_PARM->_cup_cost = CostOf(TPARM_2(SP_PARM->_address_cursor, 23, 23), 1); + SP_PARM->_cub_cost = CostOf(TPARM_1(parm_left_cursor, 23), 1); + SP_PARM->_cuf_cost = CostOf(TPARM_1(parm_right_cursor, 23), 1); + SP_PARM->_cud_cost = CostOf(TPARM_1(parm_down_cursor, 23), 1); + SP_PARM->_cuu_cost = CostOf(TPARM_1(parm_up_cursor, 23), 1); + SP_PARM->_hpa_cost = CostOf(TPARM_1(column_address, 23), 1); + SP_PARM->_vpa_cost = CostOf(TPARM_1(row_address, 23), 1); /* non-parameterized screen-update strings */ - SP->_ed_cost = NormalizedCost(clr_eos, 1); - SP->_el_cost = NormalizedCost(clr_eol, 1); - SP->_el1_cost = NormalizedCost(clr_bol, 1); - SP->_dch1_cost = NormalizedCost(delete_character, 1); - SP->_ich1_cost = NormalizedCost(insert_character, 1); + SP_PARM->_ed_cost = NormalizedCost(clr_eos, 1); + SP_PARM->_el_cost = NormalizedCost(clr_eol, 1); + SP_PARM->_el1_cost = NormalizedCost(clr_bol, 1); + SP_PARM->_dch1_cost = NormalizedCost(delete_character, 1); + SP_PARM->_ich1_cost = NormalizedCost(insert_character, 1); /* * If this is a bce-terminal, we want to bias the choice so we use clr_eol * rather than spaces at the end of a line. */ if (back_color_erase) - SP->_el_cost = 0; + SP_PARM->_el_cost = 0; /* parameterized screen-update strings */ - SP->_dch_cost = NormalizedCost(TPARM_1(parm_dch, 23), 1); - SP->_ich_cost = NormalizedCost(TPARM_1(parm_ich, 23), 1); - SP->_ech_cost = NormalizedCost(TPARM_1(erase_chars, 23), 1); - SP->_rep_cost = NormalizedCost(TPARM_2(repeat_char, ' ', 23), 1); - - SP->_cup_ch_cost = NormalizedCost(TPARM_2(SP->_address_cursor, 23, 23), 1); - SP->_hpa_ch_cost = NormalizedCost(TPARM_1(column_address, 23), 1); - SP->_cuf_ch_cost = NormalizedCost(TPARM_1(parm_right_cursor, 23), 1); - SP->_inline_cost = min(SP->_cup_ch_cost, - min(SP->_hpa_ch_cost, - SP->_cuf_ch_cost)); + SP_PARM->_dch_cost = NormalizedCost(TPARM_1(parm_dch, 23), 1); + SP_PARM->_ich_cost = NormalizedCost(TPARM_1(parm_ich, 23), 1); + SP_PARM->_ech_cost = NormalizedCost(TPARM_1(erase_chars, 23), 1); + SP_PARM->_rep_cost = NormalizedCost(TPARM_2(repeat_char, ' ', 23), 1); + + SP_PARM->_cup_ch_cost = NormalizedCost( + TPARM_2(SP_PARM->_address_cursor, + 23, 23), 1); + SP_PARM->_hpa_ch_cost = NormalizedCost(TPARM_1(column_address, 23), 1); + SP_PARM->_cuf_ch_cost = NormalizedCost(TPARM_1(parm_right_cursor, 23), 1); + SP_PARM->_inline_cost = min(SP_PARM->_cup_ch_cost, + min(SP_PARM->_hpa_ch_cost, + SP_PARM->_cuf_ch_cost)); /* * If save_cursor is used within enter_ca_mode, we should not use it for @@ -412,25 +432,34 @@ _nc_mvcur_init(void) } /* - * A different, possibly better way to arrange this would be to set - * SP->_endwin = TRUE at window initialization time and let this be + * A different, possibly better way to arrange this would be to set the + * SCREEN's _endwin to TRUE at window initialization time and let this be * called by doupdate's return-from-shellout code. */ _nc_mvcur_resume(); } +#if NCURSES_SP_FUNCS NCURSES_EXPORT(void) -_nc_mvcur_wrap(void) +_nc_mvcur_init(void) +{ + NCURSES_SP_NAME(_nc_mvcur_init) (CURRENT_SCREEN); + _nc_mvcur_resume(); +} +#endif + +NCURSES_EXPORT(void) +NCURSES_SP_NAME(_nc_mvcur_wrap) (NCURSES_SP_DCL0) /* wrap up cursor-addressing mode */ { /* leave cursor at screen bottom */ mvcur(-1, -1, screen_lines(CURRENT_SCREEN) - 1, 0); /* set cursor to normal mode */ - if (SP->_cursor != -1) { - int cursor = SP->_cursor; + if (SP_PARM->_cursor != -1) { + int cursor = SP_PARM->_cursor; curs_set(1); - SP->_cursor = cursor; + SP_PARM->_cursor = cursor; } if (exit_ca_mode) { @@ -448,6 +477,14 @@ _nc_mvcur_wrap(void) _nc_outch('\r'); } +#if NCURSES_SP_FUNCS +NCURSES_EXPORT(void) +_nc_mvcur_wrap(void) +{ + NCURSES_SP_NAME(_nc_mvcur_wrap) (CURRENT_SCREEN); +} +#endif + /**************************************************************************** * * Optimized cursor movement @@ -487,8 +524,13 @@ repeated_append(string_desc * target, int total, int num, int repeat, const char #define LASTTAB(fr) ((fr > 0) ? ((fr - 1) / init_tabs) * init_tabs : -1) static int -relative_move(string_desc * target, int from_y, int from_x, int to_y, int - to_x, bool ovw) +relative_move(NCURSES_SP_DCLx + string_desc * target, + int from_y, + int from_x, + int to_y, + int to_x, + bool ovw) /* move via local motions (cuu/cuu1/cud/cud1/cub1/cub/cuf1/cuf/vpa/hpa) */ { string_desc save; @@ -501,38 +543,38 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int if (row_address != 0 && _nc_safe_strcat(target, TPARM_1(row_address, to_y))) { - vcost = SP->_vpa_cost; + vcost = SP_PARM->_vpa_cost; } if (to_y > from_y) { n = (to_y - from_y); if (parm_down_cursor - && SP->_cud_cost < vcost + && SP_PARM->_cud_cost < vcost && _nc_safe_strcat(_nc_str_copy(target, &save), TPARM_1(parm_down_cursor, n))) { - vcost = SP->_cud_cost; + vcost = SP_PARM->_cud_cost; } if (cursor_down - && (*cursor_down != '\n' || SP->_nl) - && (n * SP->_cud1_cost < vcost)) { + && (*cursor_down != '\n' || SP_PARM->_nl) + && (n * SP_PARM->_cud1_cost < vcost)) { vcost = repeated_append(_nc_str_copy(target, &save), 0, - SP->_cud1_cost, n, cursor_down); + SP_PARM->_cud1_cost, n, cursor_down); } } else { /* (to_y < from_y) */ n = (from_y - to_y); if (parm_up_cursor - && SP->_cuu_cost < vcost + && SP_PARM->_cuu_cost < vcost && _nc_safe_strcat(_nc_str_copy(target, &save), TPARM_1(parm_up_cursor, n))) { - vcost = SP->_cuu_cost; + vcost = SP_PARM->_cuu_cost; } - if (cursor_up && (n * SP->_cuu1_cost < vcost)) { + if (cursor_up && (n * SP_PARM->_cuu1_cost < vcost)) { vcost = repeated_append(_nc_str_copy(target, &save), 0, - SP->_cuu1_cost, n, cursor_up); + SP_PARM->_cuu1_cost, n, cursor_up); } } @@ -551,17 +593,17 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int if (column_address && _nc_safe_strcat(_nc_str_copy(target, &save), TPARM_1(column_address, to_x))) { - hcost = SP->_hpa_cost; + hcost = SP_PARM->_hpa_cost; } if (to_x > from_x) { n = to_x - from_x; if (parm_right_cursor - && SP->_cuf_cost < hcost + && SP_PARM->_cuf_cost < hcost && _nc_safe_strcat(_nc_str_copy(target, &save), TPARM_1(parm_right_cursor, n))) { - hcost = SP->_cuf_cost; + hcost = SP_PARM->_cuf_cost; } if (cursor_right) { @@ -576,7 +618,7 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int for (fr = from_x; (nxt = NEXTTAB(fr)) <= to_x; fr = nxt) { lhcost = repeated_append(&check, lhcost, - SP->_ht_cost, 1, tab); + SP_PARM->_ht_cost, 1, tab); if (lhcost == INFINITY) break; } @@ -600,7 +642,7 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int && n < (int) check.s_size && vcost == 0 && str[0] == '\0') { - int wanted = CharOf(WANT_CHAR(to_y, from_x)); + int wanted = CharOf(WANT_CHAR(SP_PARM, to_y, from_x)); if (is8bits(wanted) && isdigit(wanted)) ovw = FALSE; } @@ -617,8 +659,8 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int int i; for (i = 0; i < n; i++) { - NCURSES_CH_T ch = WANT_CHAR(to_y, from_x + i); - if (!SameAttrOf(ch, SCREEN_ATTRS(SP)) + NCURSES_CH_T ch = WANT_CHAR(SP_PARM, to_y, from_x + i); + if (!SameAttrOf(ch, SCREEN_ATTRS(SP_PARM)) #if USE_WIDEC_SUPPORT || !Charable(ch) #endif @@ -632,13 +674,13 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int int i; for (i = 0; i < n; i++) - *check.s_tail++ = (char) CharOf(WANT_CHAR(to_y, + *check.s_tail++ = (char) CharOf(WANT_CHAR(SP_PARM, to_y, from_x + i)); *check.s_tail = '\0'; check.s_size -= n; - lhcost += n * SP->_char_padding; + lhcost += n * SP_PARM->_char_padding; } else { - lhcost = repeated_append(&check, lhcost, SP->_cuf1_cost, + lhcost = repeated_append(&check, lhcost, SP_PARM->_cuf1_cost, n, cursor_right); } @@ -651,10 +693,10 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int n = from_x - to_x; if (parm_left_cursor - && SP->_cub_cost < hcost + && SP_PARM->_cub_cost < hcost && _nc_safe_strcat(_nc_str_copy(target, &save), TPARM_1(parm_left_cursor, n))) { - hcost = SP->_cub_cost; + hcost = SP_PARM->_cub_cost; } if (cursor_left) { @@ -668,7 +710,8 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int for (fr = from_x; (nxt = LASTTAB(fr)) >= to_x; fr = nxt) { lhcost = repeated_append(&check, lhcost, - SP->_cbt_cost, 1, back_tab); + SP_PARM->_cbt_cost, + 1, back_tab); if (lhcost == INFINITY) break; } @@ -677,7 +720,9 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int } #endif /* USE_HARD_TABS */ - lhcost = repeated_append(&check, lhcost, SP->_cub1_cost, n, cursor_left); + lhcost = repeated_append(&check, lhcost, + SP_PARM->_cub1_cost, + n, cursor_left); if (lhcost < hcost && _nc_safe_strcat(_nc_str_copy(target, &save), str)) { @@ -706,7 +751,7 @@ relative_move(string_desc * target, int from_y, int from_x, int to_y, int */ static NCURSES_INLINE int -onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw) +onscreen_mvcur(NCURSES_SP_DCLx int yold, int xold, int ynew, int xnew, bool ovw) /* onscreen move from (yold, xold) to (ynew, xnew) */ { string_desc result; @@ -724,9 +769,9 @@ onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw) #define InitResult _nc_str_init(&result, buffer, sizeof(buffer)) /* tactic #0: use direct cursor addressing */ - if (_nc_safe_strcpy(InitResult, TPARM_2(SP->_address_cursor, ynew, xnew))) { + if (_nc_safe_strcpy(InitResult, TPARM_2(SP_PARM->_address_cursor, ynew, xnew))) { tactic = 0; - usecost = SP->_cup_cost; + usecost = SP_PARM->_cup_cost; #if defined(TRACE) || defined(NCURSES_TEST) if (!(_nc_optimize_enable & OPTIMIZE_MVCUR)) @@ -741,7 +786,7 @@ onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw) * (like, say, local-movement \n getting mapped to some obscure * character because A_ALTCHARSET is on). */ - if (yold == -1 || xold == -1 || NOT_LOCAL(yold, xold, ynew, xnew)) { + if (yold == -1 || xold == -1 || NOT_LOCAL(SP_PARM, yold, xold, ynew, xnew)) { #if defined(MAIN) || defined(NCURSES_TEST) if (!profiling) { (void) fputs("nonlocal\n", stderr); @@ -755,7 +800,8 @@ onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw) #ifndef NO_OPTIMIZE /* tactic #1: use local movement */ if (yold != -1 && xold != -1 - && ((newcost = relative_move(NullResult, yold, xold, ynew, xnew, + && ((newcost = relative_move(NCURSES_SP_ARGx + NullResult, yold, xold, ynew, xnew, ovw)) != INFINITY) && newcost < usecost) { tactic = 1; @@ -764,47 +810,50 @@ onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw) /* tactic #2: use carriage-return + local movement */ if (yold != -1 && carriage_return - && ((newcost = relative_move(NullResult, yold, 0, ynew, xnew, ovw)) + && ((newcost = relative_move(NCURSES_SP_ARGx + NullResult, yold, 0, ynew, xnew, ovw)) != INFINITY) - && SP->_cr_cost + newcost < usecost) { + && SP_PARM->_cr_cost + newcost < usecost) { tactic = 2; - usecost = SP->_cr_cost + newcost; + usecost = SP_PARM->_cr_cost + newcost; } /* tactic #3: use home-cursor + local movement */ if (cursor_home - && ((newcost = relative_move(NullResult, 0, 0, ynew, xnew, ovw)) != INFINITY) - && SP->_home_cost + newcost < usecost) { + && ((newcost = relative_move(NCURSES_SP_ARGx + NullResult, 0, 0, ynew, xnew, ovw)) != INFINITY) + && SP_PARM->_home_cost + newcost < usecost) { tactic = 3; - usecost = SP->_home_cost + newcost; + usecost = SP_PARM->_home_cost + newcost; } /* tactic #4: use home-down + local movement */ if (cursor_to_ll - && ((newcost = relative_move(NullResult, - screen_lines(CURRENT_SCREEN) - 1, 0, ynew, + && ((newcost = relative_move(NCURSES_SP_ARGx + NullResult, + screen_lines(SP_PARM) - 1, 0, ynew, xnew, ovw)) != INFINITY) - && SP->_ll_cost + newcost < usecost) { + && SP_PARM->_ll_cost + newcost < usecost) { tactic = 4; - usecost = SP->_ll_cost + newcost; + usecost = SP_PARM->_ll_cost + newcost; } /* * tactic #5: use left margin for wrap to right-hand side, * unless strange wrap behavior indicated by xenl might hose us. */ - t5_cr_cost = (xold > 0 ? SP->_cr_cost : 0); + t5_cr_cost = (xold > 0 ? SP_PARM->_cr_cost : 0); if (auto_left_margin && !eat_newline_glitch && yold > 0 && cursor_left - && ((newcost = relative_move(NullResult, + && ((newcost = relative_move(NCURSES_SP_ARGx NullResult, yold - 1, - screen_columns(CURRENT_SCREEN) - 1, + screen_columns(SP_PARM) - 1, ynew, xnew, ovw)) != INFINITY) - && t5_cr_cost + SP->_cub1_cost + newcost < usecost) { + && t5_cr_cost + SP_PARM->_cub1_cost + newcost < usecost) { tactic = 5; - usecost = t5_cr_cost + SP->_cub1_cost + newcost; + usecost = t5_cr_cost + SP_PARM->_cub1_cost + newcost; } /* @@ -814,35 +863,35 @@ onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw) InitResult; switch (tactic) { case 1: - (void) relative_move(&result, yold, xold, ynew, xnew, ovw); + (void) relative_move(NCURSES_SP_ARGx + &result, yold, xold, + ynew, xnew, ovw); break; case 2: (void) _nc_safe_strcpy(&result, carriage_return); - (void) relative_move(&result, yold, 0, ynew, xnew, ovw); + (void) relative_move(NCURSES_SP_ARGx + &result, yold, 0, + ynew, xnew, ovw); break; case 3: (void) _nc_safe_strcpy(&result, cursor_home); - (void) relative_move(&result, 0, 0, ynew, xnew, ovw); + (void) relative_move(NCURSES_SP_ARGx + &result, 0, 0, + ynew, xnew, ovw); break; case 4: (void) _nc_safe_strcpy(&result, cursor_to_ll); - (void) relative_move(&result, - screen_lines(CURRENT_SCREEN) - 1, - 0, - ynew, - xnew, - ovw); + (void) relative_move(NCURSES_SP_ARGx &result, + screen_lines(SP_PARM) - 1, 0, + ynew, xnew, ovw); break; case 5: if (xold > 0) (void) _nc_safe_strcat(&result, carriage_return); (void) _nc_safe_strcat(&result, cursor_left); - (void) relative_move(&result, - yold - 1, - screen_columns(CURRENT_SCREEN) - 1, - ynew, - xnew, - ovw); + (void) relative_move(NCURSES_SP_ARGx &result, + yold - 1, screen_columns(SP_PARM) - 1, + ynew, xnew, ovw); break; } #endif /* !NO_OPTIMIZE */ @@ -861,8 +910,8 @@ onscreen_mvcur(int yold, int xold, int ynew, int xnew, bool ovw) if (usecost != INFINITY) { TPUTS_TRACE("mvcur"); tputs(buffer, 1, _nc_outch); - SP->_cursrow = ynew; - SP->_curscol = xnew; + SP_PARM->_cursrow = ynew; + SP_PARM->_curscol = xnew; return (OK); } else return (ERR); @@ -890,9 +939,9 @@ NCURSES_SP_NAME(mvcur) (NCURSES_SP_DCLx * column position implied by wraparound or the lack thereof and * rolling up the screen to get ynew on the screen. */ - if (xnew >= screen_columns(CURRENT_SCREEN)) { - ynew += xnew / screen_columns(CURRENT_SCREEN); - xnew %= screen_columns(CURRENT_SCREEN); + if (xnew >= screen_columns(SP_PARM)) { + ynew += xnew / screen_columns(SP_PARM); + xnew %= screen_columns(SP_PARM); } /* @@ -909,14 +958,14 @@ NCURSES_SP_NAME(mvcur) (NCURSES_SP_DCLx (void) VIDATTR(A_NORMAL, 0); } - if (xold >= screen_columns(CURRENT_SCREEN)) { + if (xold >= screen_columns(SP_PARM)) { int l; if (SP_PARM->_nl) { - l = (xold + 1) / screen_columns(CURRENT_SCREEN); + l = (xold + 1) / screen_columns(SP_PARM); yold += l; - if (yold >= screen_lines(CURRENT_SCREEN)) - l -= (yold - screen_lines(CURRENT_SCREEN) - 1); + if (yold >= screen_lines(SP_PARM)) + l -= (yold - screen_lines(SP_PARM) - 1); if (l > 0) { if (carriage_return) { @@ -945,13 +994,13 @@ NCURSES_SP_NAME(mvcur) (NCURSES_SP_DCLx } } - if (yold > screen_lines(CURRENT_SCREEN) - 1) - yold = screen_lines(CURRENT_SCREEN) - 1; - if (ynew > screen_lines(CURRENT_SCREEN) - 1) - ynew = screen_lines(CURRENT_SCREEN) - 1; + if (yold > screen_lines(SP_PARM) - 1) + yold = screen_lines(SP_PARM) - 1; + if (ynew > screen_lines(SP_PARM) - 1) + ynew = screen_lines(SP_PARM) - 1; /* destination location is on screen now */ - code = onscreen_mvcur(yold, xold, ynew, xnew, TRUE); + code = onscreen_mvcur(NCURSES_SP_ARGx yold, xold, ynew, xnew, TRUE); /* * Restore attributes if we disabled them before moving. @@ -1236,25 +1285,25 @@ main(int argc GCC_UNUSED, char *argv[]GCC_UNUSED) speeds[i], overhead, totalest); } } else if (buf[0] == 'c') { - (void) printf("char padding: %d\n", SP->_char_padding); - (void) printf("cr cost: %d\n", SP->_cr_cost); - (void) printf("cup cost: %d\n", SP->_cup_cost); - (void) printf("home cost: %d\n", SP->_home_cost); - (void) printf("ll cost: %d\n", SP->_ll_cost); + (void) printf("char padding: %d\n", CURRENT_SCREEN->_char_padding); + (void) printf("cr cost: %d\n", CURRENT_SCREEN->_cr_cost); + (void) printf("cup cost: %d\n", CURRENT_SCREEN->_cup_cost); + (void) printf("home cost: %d\n", CURRENT_SCREEN->_home_cost); + (void) printf("ll cost: %d\n", CURRENT_SCREEN->_ll_cost); #if USE_HARD_TABS - (void) printf("ht cost: %d\n", SP->_ht_cost); - (void) printf("cbt cost: %d\n", SP->_cbt_cost); + (void) printf("ht cost: %d\n", CURRENT_SCREEN->_ht_cost); + (void) printf("cbt cost: %d\n", CURRENT_SCREEN->_cbt_cost); #endif /* USE_HARD_TABS */ - (void) printf("cub1 cost: %d\n", SP->_cub1_cost); - (void) printf("cuf1 cost: %d\n", SP->_cuf1_cost); - (void) printf("cud1 cost: %d\n", SP->_cud1_cost); - (void) printf("cuu1 cost: %d\n", SP->_cuu1_cost); - (void) printf("cub cost: %d\n", SP->_cub_cost); - (void) printf("cuf cost: %d\n", SP->_cuf_cost); - (void) printf("cud cost: %d\n", SP->_cud_cost); - (void) printf("cuu cost: %d\n", SP->_cuu_cost); - (void) printf("hpa cost: %d\n", SP->_hpa_cost); - (void) printf("vpa cost: %d\n", SP->_vpa_cost); + (void) printf("cub1 cost: %d\n", CURRENT_SCREEN->_cub1_cost); + (void) printf("cuf1 cost: %d\n", CURRENT_SCREEN->_cuf1_cost); + (void) printf("cud1 cost: %d\n", CURRENT_SCREEN->_cud1_cost); + (void) printf("cuu1 cost: %d\n", CURRENT_SCREEN->_cuu1_cost); + (void) printf("cub cost: %d\n", CURRENT_SCREEN->_cub_cost); + (void) printf("cuf cost: %d\n", CURRENT_SCREEN->_cuf_cost); + (void) printf("cud cost: %d\n", CURRENT_SCREEN->_cud_cost); + (void) printf("cuu cost: %d\n", CURRENT_SCREEN->_cuu_cost); + (void) printf("hpa cost: %d\n", CURRENT_SCREEN->_hpa_cost); + (void) printf("vpa cost: %d\n", CURRENT_SCREEN->_vpa_cost); } else if (buf[0] == 'x' || buf[0] == 'q') break; else diff --git a/ncurses/tty/tty_update.c b/ncurses/tty/tty_update.c index 7a0636f2..5ba824b7 100644 --- a/ncurses/tty/tty_update.c +++ b/ncurses/tty/tty_update.c @@ -39,7 +39,7 @@ * * The routine doupdate() and its dependents. * All physical output is concentrated here (except _nc_outch() - * in lib_tputs.c). + * in lib_tputs.c). * *-----------------------------------------------------------------*/ @@ -77,9 +77,8 @@ #endif #include -#include -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 @@ -92,7 +91,7 @@ MODULE_ID("$Id: tty_update.c,v 1.250 2009/04/18 23:32:17 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); @@ -105,18 +104,20 @@ 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 @@ -128,7 +129,7 @@ static void TransformLine(int const lineno); ****************************************************************************/ 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]; @@ -138,10 +139,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(_nc_flush) (NCURSES_SP_ARG); *(s = buf) = 0; do { int ask = sizeof(buf) - 1 - (s - buf); @@ -171,7 +172,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 */ /**************************************************************************** @@ -181,19 +182,19 @@ 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)); + 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; @@ -203,7 +204,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. @@ -233,12 +234,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 { @@ -250,7 +251,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 @@ -260,8 +261,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)]; } @@ -274,9 +275,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 = ' '; @@ -291,20 +292,20 @@ 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(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); @@ -312,7 +313,7 @@ PutAttrChar(CARG_CH_T ch) } static bool -check_pending(void) +check_pending(NCURSES_SP_DCL0) /* check for pending input */ { bool have_pending = FALSE; @@ -322,13 +323,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; @@ -356,15 +357,15 @@ 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; } @@ -375,26 +376,33 @@ 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); - 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); } } @@ -402,7 +410,7 @@ PutCharLR(NCURSES_SP_DCLx 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) { /* @@ -418,41 +426,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))))); + (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"); } /* @@ -462,19 +474,19 @@ PutChar(NCURSES_SP_DCLx 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 pair, &fg, &bg); if (fg != C_MASK || bg != C_MASK) return FALSE; } @@ -536,8 +548,8 @@ EmitRange(NCURSES_SP_DCLx const NCURSES_CH_T * ntext, int num) */ 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)); /* @@ -546,19 +558,21 @@ EmitRange(NCURSES_SP_DCLx const NCURSES_CH_T * ntext, int num) * 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; @@ -597,8 +611,8 @@ PutRange(NCURSES_SP_DCLx { 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) { @@ -610,7 +624,7 @@ PutRange(NCURSES_SP_DCLx } 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; } @@ -679,10 +693,10 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0) 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; @@ -731,8 +745,8 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0) * 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; } @@ -741,14 +755,14 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0) 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; @@ -787,7 +801,7 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0) */ while (n >= 0 && ISBLANK(lastline[n]) - && SAFE(AttrOf(lastline[n]))) { + && SAFE(SP_PARM, AttrOf(lastline[n]))) { RemAttr(lastline[n--], turnon); } @@ -795,7 +809,7 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0) 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", @@ -803,7 +817,7 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0) (ISBLANK(lastline[n + k]) ? "" : ":nonblank"), - (SAFE(AttrOf(lastline[n + k])) + (SAFE(SP_PARM, AttrOf(lastline[n + k])) ? "" : ":unsafe"))); break; @@ -866,7 +880,7 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0) } 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); @@ -883,7 +897,7 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0) * Here is our line-breakout optimization. */ if (changedlines == CHECK_INTERVAL) { - if (check_pending()) + if (check_pending(NCURSES_SP_ARG)) goto cleanup; changedlines = 0; } @@ -922,7 +936,7 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0) curscr->_curx = newscr->_curx; curscr->_cury = newscr->_cury; - GoTo(curscr->_cury, curscr->_curx); + GoTo(NCURSES_SP_ARGx curscr->_cury, curscr->_curx); } cleanup: @@ -935,9 +949,9 @@ NCURSES_SP_NAME(doupdate) (NCURSES_SP_DCL0) #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 @@ -994,21 +1008,21 @@ ClrBlank(WINDOW *win) 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(""))); } @@ -1040,7 +1054,7 @@ ClrToEOL(NCURSES_SP_DCLx NCURSES_CH_T blank, bool needclear) } 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); @@ -1063,10 +1077,13 @@ ClrToEOS(NCURSES_SP_DCLx NCURSES_CH_T blank) { 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); @@ -1096,7 +1113,7 @@ ClrBottom(NCURSES_SP_DCLx int total) 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++) { @@ -1114,7 +1131,7 @@ ClrBottom(NCURSES_SP_DCLx int total) /* 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++) @@ -1127,15 +1144,15 @@ ClrBottom(NCURSES_SP_DCLx 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) newscr->_line[r].text[c] +#define xmc_turn_off(sp,a,b) xmc_turn_on(sp,b,a) #endif /* USE_XMC_SUPPORT */ /* @@ -1165,7 +1182,7 @@ TransformLine(NCURSES_SP_DCLx int const lineno) 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) @@ -1212,10 +1229,11 @@ TransformLine(NCURSES_SP_DCLx int const lineno) 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 /* @@ -1230,7 +1248,7 @@ TransformLine(NCURSES_SP_DCLx int const lineno) * 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; @@ -1240,10 +1258,12 @@ TransformLine(NCURSES_SP_DCLx 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(SP_PARM) - 1), + && xmc_turn_on(SP_PARM, + xmc_new(SP_PARM, lineno - 1, + screen_columns(SP_PARM) - 1), newLine[n])))) { n = m; } @@ -1256,10 +1276,12 @@ TransformLine(NCURSES_SP_DCLx int const lineno) */ 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; } @@ -1270,7 +1292,7 @@ TransformLine(NCURSES_SP_DCLx 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; @@ -1297,13 +1319,13 @@ TransformLine(NCURSES_SP_DCLx int const lineno) 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); } @@ -1326,7 +1348,7 @@ TransformLine(NCURSES_SP_DCLx int const lineno) 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; @@ -1335,9 +1357,13 @@ TransformLine(NCURSES_SP_DCLx int const lineno) 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)); @@ -1358,24 +1384,32 @@ TransformLine(NCURSES_SP_DCLx int const lineno) 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; @@ -1396,9 +1430,13 @@ TransformLine(NCURSES_SP_DCLx int const lineno) 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) { @@ -1409,21 +1447,25 @@ TransformLine(NCURSES_SP_DCLx 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(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 { /* @@ -1434,8 +1476,8 @@ TransformLine(NCURSES_SP_DCLx 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); } } } @@ -1477,38 +1519,40 @@ ClearScreen(NCURSES_SP_DCLx NCURSES_CH_T blank) 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++) { @@ -1527,9 +1571,9 @@ ClearScreen(NCURSES_SP_DCLx 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", SP_PARM, line, count)); /* Prefer parm_ich as it has the smallest cost - no need to shift * the whole line on each character. */ @@ -1538,7 +1582,7 @@ InsStr(NCURSES_CH_T * line, int count) 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--; } @@ -1546,7 +1590,7 @@ InsStr(NCURSES_CH_T * line, int 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); @@ -1560,7 +1604,7 @@ InsStr(NCURSES_CH_T * line, int count) 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); @@ -1569,7 +1613,7 @@ InsStr(NCURSES_CH_T * line, int count) count--; } } - position_check(SP_PARM->_cursrow, SP_PARM->_curscol, "InsStr"); + position_check(SP_PARM, SP_PARM->_cursrow, SP_PARM->_curscol, "InsStr"); } /* @@ -1580,12 +1624,12 @@ 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, + TR(TRACE_UPDATE, ("DelChar(%p, %d) called, position = (%ld,%ld)", + SP_PARM, count, (long) newscr->_cury, (long) newscr->_curx)); @@ -1645,35 +1689,35 @@ scroll_csr_forward(NCURSES_SP_DCLx 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); @@ -1682,10 +1726,10 @@ scroll_csr_forward(NCURSES_SP_DCLx 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)); } @@ -1708,35 +1752,35 @@ scroll_csr_backward(NCURSES_SP_DCLx 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); @@ -1745,10 +1789,10 @@ scroll_csr_backward(NCURSES_SP_DCLx 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)); } @@ -1760,15 +1804,15 @@ scroll_csr_backward(NCURSES_SP_DCLx /* 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); @@ -1782,8 +1826,8 @@ scroll_idl(int n, int del, int ins, NCURSES_CH_T blank) } } - 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); @@ -1864,7 +1908,7 @@ NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx } 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. @@ -1873,11 +1917,11 @@ NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx && (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); } } @@ -1888,7 +1932,8 @@ NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx 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"); @@ -1912,7 +1957,7 @@ NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx } 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. @@ -1921,7 +1966,7 @@ NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx && (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); } } @@ -1933,7 +1978,7 @@ NCURSES_SP_NAME(_nc_scrolln) (NCURSES_SP_DCLx _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); } @@ -1947,26 +1992,28 @@ _nc_scrolln(int n, int top, int bot, int 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); + 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); } } } @@ -1988,17 +2035,36 @@ _nc_screen_resume(void) 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) { @@ -2015,7 +2081,7 @@ NCURSES_SP_NAME(_nc_screen_wrap) (NCURSES_SP_DCL0) } #endif if (SP_PARM->_color_defs) { - _nc_reset_colors(); + _nc_reset_colors (); } } @@ -2029,18 +2095,30 @@ _nc_screen_wrap(void) #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 */