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