NCURSES_SP_NAME(slk_attr_set) (NCURSES_SP_DCLx
const attr_t attr,
NCURSES_PAIRS_T pair_arg,
void *opts)
{
int code = ERR;
int color_pair = pair_arg;
T((T_CALLED("slk_attr_set(%p,%s,%d)"),
(void *) SP_PARM,
_traceattr(attr),
color_pair));
set_extended_pair(opts, color_pair);
if (SP_PARM != 0
&& SP_PARM->_slk != 0
&& color_pair >= 0
&& color_pair < SP_PARM->_pair_limit) {
TR(TRACE_ATTRS, ("... current %s", _tracech_t(CHREF(SP_PARM->_slk->attr))));
SetAttr(SP_PARM->_slk->attr, attr);
if (color_pair > 0) {
SetPair(SP_PARM->_slk->attr, color_pair);
}
TR(TRACE_ATTRS, ("new attribute is %s", _tracech_t(CHREF(SP_PARM->_slk->attr))));
code = OK;
}
returnCode(code);
}
slk_color(short color_pair_number)
{
T((T_CALLED("slk_color(%d)"), color_pair_number));
if (SP != 0 && SP->_slk != 0 &&
color_pair_number >= 0 && color_pair_number < COLOR_PAIRS) {
TR(TRACE_ATTRS, ("... current is %s", _tracech_t(CHREF(SP->_slk->attr))));
SetPair(SP->_slk->attr, color_pair_number);
TR(TRACE_ATTRS, ("new attribute is %s", _tracech_t(CHREF(SP->_slk->attr))));
returnCode(OK);
} else
returnCode(ERR);
}
slk_attroff(const chtype attr)
{
T((T_CALLED("slk_attroff(%s)"), _traceattr(attr)));
if (SP != 0 && SP->_slk != 0) {
TR(TRACE_ATTRS, ("... current %s", _tracech_t(CHREF(SP->_slk->attr))));
RemAttr(SP->_slk->attr, attr);
if ((attr & A_COLOR) != 0) {
SetPair(SP->_slk->attr, 0);
}
TR(TRACE_ATTRS, ("new attribute is %s", _tracech_t(CHREF(SP->_slk->attr))));
returnCode(OK);
} else
returnCode(ERR);
}
NCURSES_SP_NAME(slk_attron) (NCURSES_SP_DCLx const chtype attr)
{
T((T_CALLED("slk_attron(%p,%s)"), (void *) SP_PARM, _traceattr(attr)));
if (SP_PARM != 0 && SP_PARM->_slk != 0) {
TR(TRACE_ATTRS, ("... current %s", _tracech_t(CHREF(SP_PARM->_slk->attr))));
AddAttr(SP_PARM->_slk->attr, attr);
if ((attr & A_COLOR) != 0) {
SetPair(SP_PARM->_slk->attr, PAIR_NUMBER(attr));
}
TR(TRACE_ATTRS, ("new attribute is %s", _tracech_t(CHREF(SP_PARM->_slk->attr))));
returnCode(OK);
} else
returnCode(ERR);
}
static NCURSES_INLINE int
#undef wbkgrnd
#endif
wbkgrnd(WINDOW *win, const ARG_CH_T ch)
{
int code = ERR;
int x, y;
NCURSES_CH_T new_bkgd = CHDEREF(ch);
T((T_CALLED("wbkgd(%p,%s)"), (void *) win, _tracech_t(ch)));
if (win) {
NCURSES_CH_T old_bkgrnd;
wgetbkgrnd(win, &old_bkgrnd);
(void) wbkgrndset(win, CHREF(new_bkgd));
(void) wattrset(win, AttrOf(win->_nc_bkgd));
for (y = 0; y <= win->_maxy; y++) {
for (x = 0; x <= win->_maxx; x++) {
if (CharEq(win->_line[y].text[x], old_bkgrnd)) {
win->_line[y].text[x] = win->_nc_bkgd;
} else {
NCURSES_CH_T wch = win->_line[y].text[x];
RemAttr(wch, (~(A_ALTCHARSET | A_CHARTEXT)));
win->_line[y].text[x] = _nc_render(win, wch);
}
}
}
touchwin(win);
_nc_synchook(win);
code = OK;
}
returnCode(code);
}
slk_attr_set(const attr_t attr, short color_pair_number, void *opts)
{
T((T_CALLED("slk_attr_set(%s,%d)"), _traceattr(attr), color_pair_number));
if (SP != 0 && SP->_slk != 0 && !opts &&
color_pair_number >= 0 && color_pair_number < COLOR_PAIRS) {
TR(TRACE_ATTRS, ("... current %s", _tracech_t(CHREF(SP->_slk->attr))));
SetAttr(SP->_slk->attr, attr);
if (color_pair_number > 0) {
SetPair(SP->_slk->attr, color_pair_number);
}
TR(TRACE_ATTRS, ("new attribute is %s", _tracech_t(CHREF(SP->_slk->attr))));
returnCode(OK);
} else
returnCode(ERR);
}
static NCURSES_INLINE NCURSES_CH_T
render_char(WINDOW *win, NCURSES_CH_T ch)
/* compute a rendition of the given char correct for the current context */
{
attr_t a = WINDOW_ATTRS(win);
int pair = GetPair(ch);
if (ISBLANK(ch)
&& AttrOf(ch) == A_NORMAL
&& pair == 0) {
/* color/pair in attrs has precedence over bkgrnd */
ch = win->_nc_bkgd;
SetAttr(ch, a | AttrOf(win->_nc_bkgd));
if ((pair = GET_WINDOW_PAIR(win)) == 0)
pair = GetPair(win->_nc_bkgd);
SetPair(ch, pair);
} else {
/* color in attrs has precedence over bkgrnd */
a |= AttrOf(win->_nc_bkgd) & COLOR_MASK(a);
/* color in ch has precedence */
if (pair == 0) {
if ((pair = GET_WINDOW_PAIR(win)) == 0)
pair = GetPair(win->_nc_bkgd);
}
#if 0
if (pair > 255) {
NCURSES_CH_T fixme = ch;
SetPair(fixme, pair);
}
#endif
AddAttr(ch, (a & COLOR_MASK(AttrOf(ch))));
SetPair(ch, pair);
}
TR(TRACE_VIRTPUT,
("render_char bkg %s (%d), attrs %s (%d) -> ch %s (%d)",
_tracech_t2(1, CHREF(win->_nc_bkgd)),
GetPair(win->_nc_bkgd),
_traceattr(WINDOW_ATTRS(win)),
GET_WINDOW_PAIR(win),
_tracech_t2(3, CHREF(ch)),
GetPair(ch)));
return (ch);
}
NCURSES_SP_NAME(slk_attr_set) (NCURSES_SP_DCLx
const attr_t attr,
short color_pair_number,
void *opts)
{
int code = ERR;
T((T_CALLED("slk_attr_set(%s,%d)"), _traceattr(attr), color_pair_number));
if (SP_PARM != 0
&& SP_PARM->_slk != 0
&& !opts
&& color_pair_number >= 0
&& color_pair_number < SP_PARM->_pair_limit) {
TR(TRACE_ATTRS, ("... current %s", _tracech_t(CHREF(SP_PARM->_slk->attr))));
SetAttr(SP_PARM->_slk->attr, attr);
if (color_pair_number > 0) {
SetPair(SP_PARM->_slk->attr, color_pair_number);
}
TR(TRACE_ATTRS, ("new attribute is %s", _tracech_t(CHREF(SP_PARM->_slk->attr))));
code = OK;
}
returnCode(code);
}
static
#if !USE_WIDEC_SUPPORT /* cannot be inline if it is recursive */
NCURSES_INLINE
#endif
int
waddch_literal(WINDOW *win, NCURSES_CH_T ch)
{
int x;
int y;
struct ldat *line;
x = win->_curx;
y = win->_cury;
CHECK_POSITION(win, x, y);
ch = render_char(win, ch);
line = win->_line + y;
CHANGED_CELL(line, x);
/*
* Build up multibyte characters until we have a wide-character.
*/
if_WIDEC({
if (WINDOW_EXT(win, addch_used) != 0 || !Charable(ch)) {
int len = _nc_build_wch(win, CHREF(ch));
if (len >= -1) {
/* handle EILSEQ */
if (is8bits(CharOf(ch))) {
const char *s = unctrl((chtype) CharOf(ch));
if (s[1] != 0) {
return waddstr(win, s);
}
}
if (len == -1)
return waddch(win, ' ');
} else {
return OK;
}
}
});
mvwin(WINDOW *win, int by, int bx)
{
T((T_CALLED("mvwin(%p,%d,%d)"), win, by, bx));
if (!win || (win->_flags & _ISPAD))
returnCode(ERR);
/*
* mvwin() should only modify the indices. See test/demo_menus.c and
* test/movewindow.c for examples.
*/
#if 0
/* Copying subwindows is allowed, but it is expensive... */
if (win->_flags & _SUBWIN) {
int err = ERR;
WINDOW *parent = win->_parent;
if (parent) { /* Now comes the complicated and costly part, you should really
* try to avoid to move subwindows. Because a subwindow shares
* the text buffers with its parent, one can't do a simple
* memmove of the text buffers. One has to create a copy, then
* to relocate the subwindow and then to do a copy.
*/
if ((by - parent->_begy == win->_pary) &&
(bx - parent->_begx == win->_parx))
err = OK; /* we don't actually move */
else {
WINDOW *clone = dupwin(win);
if (clone) {
/* now we have the clone, so relocate win */
werase(win); /* Erase the original place */
/* fill with parents background */
wbkgrnd(win, CHREF(parent->_nc_bkgd));
wsyncup(win); /* Tell the parent(s) */
err = mvderwin(win,
by - parent->_begy,
bx - parent->_begx);
if (err != ERR) {
err = copywin(clone, win,
0, 0, 0, 0, win->_maxy, win->_maxx, 0);
if (ERR != err)
wsyncup(win);
}
if (ERR == delwin(clone))
err = ERR;
}
}
}
returnCode(err);
}
#endif
if (by + win->_maxy > screen_lines - 1
|| bx + win->_maxx > screen_columns - 1
|| by < 0
|| bx < 0)
returnCode(ERR);
/*
* Whether or not the window is moved, touch the window's contents so
* that a following call to 'wrefresh()' will paint the window at the
* new location. This ensures that if the caller has refreshed another
* window at the same location, that this one will be displayed.
*/
win->_begy = by;
win->_begx = bx;
returnCode(touchwin(win));
}
wbkgd(WINDOW *win, chtype ch)
{
NCURSES_CH_T wch;
SetChar2(wch, ch);
return wbkgrnd(win, CHREF(wch));
}
wbkgdset(WINDOW *win, chtype ch)
{
NCURSES_CH_T wch;
SetChar2(wch, ch);
wbkgrndset(win, CHREF(wch));
}
static int
wadd_wch_literal(WINDOW *win, cchar_t ch)
{
int x;
int y;
struct ldat *line;
x = win->_curx;
y = win->_cury;
CHECK_POSITION(win, x, y);
ch = render_char(win, ch);
line = win->_line + y;
CHANGED_CELL(line, x);
/*
* Non-spacing characters are added to the current cell.
*
* Spacing characters that are wider than one column require some display
* adjustments.
*/
{
int len = wcwidth(CharOf(ch));
int i;
int j;
wchar_t *chars;
if (len == 0) { /* non-spacing */
if ((x > 0 && y >= 0)
|| (win->_maxx >= 0 && win->_cury >= 1)) {
if (x > 0 && y >= 0)
chars = (win->_line[y].text[x - 1].chars);
else
chars = (win->_line[y - 1].text[win->_maxx].chars);
for (i = 0; i < CCHARW_MAX; ++i) {
if (chars[i] == 0) {
TR(TRACE_VIRTPUT,
("added non-spacing %d: %x",
x, (int) CharOf(ch)));
chars[i] = CharOf(ch);
break;
}
}
}
goto testwrapping;
} else if (len > 1) { /* multi-column characters */
/*
* Check if the character will fit on the current line. If it does
* not fit, fill in the remainder of the line with blanks. and
* move to the next line.
*/
if (len > win->_maxx + 1) {
TR(TRACE_VIRTPUT, ("character will not fit"));
return ERR;
} else if (x + len > win->_maxx + 1) {
int count = win->_maxx + 1 - x;
TR(TRACE_VIRTPUT, ("fill %d remaining cells", count));
fill_cells(win, count);
if (wrap_to_next_line(win) == ERR)
return ERR;
x = win->_curx;
y = win->_cury;
line = win->_line + y;
}
/*
* Check for cells which are orphaned by adding this character, set
* those to blanks.
*
* FIXME: this actually could fill j-i cells, more complicated to
* setup though.
*/
for (i = 0; i < len; ++i) {
if (isWidecBase(win->_line[y].text[x + i])) {
break;
} else if (isWidecExt(win->_line[y].text[x + i])) {
for (j = i; x + j <= win->_maxx; ++j) {
if (!isWidecExt(win->_line[y].text[x + j])) {
TR(TRACE_VIRTPUT, ("fill %d orphan cells", j));
fill_cells(win, j);
break;
}
}
break;
}
}
/*
* Finally, add the cells for this character.
*/
for (i = 0; i < len; ++i) {
cchar_t value = ch;
SetWidecExt(value, i);
TR(TRACE_VIRTPUT, ("multicolumn %d:%d (%d,%d)",
i + 1, len,
win->_begy + y, win->_begx + x));
line->text[x] = value;
CHANGED_CELL(line, x);
++x;
}
goto testwrapping;
}
}
/*
* Single-column characters.
*/
line->text[x++] = ch;
/*
* This label is used only for wide-characters.
*/
testwrapping:
TR(TRACE_VIRTPUT, ("cell (%ld, %ld..%d) = %s",
(long) win->_cury, (long) win->_curx, x - 1,
_tracech_t(CHREF(ch))));
if (x > win->_maxx) {
return wrap_to_next_line(win);
}
win->_curx = (NCURSES_SIZE_T) x;
return OK;
}
static
#if !USE_WIDEC_SUPPORT /* cannot be inline if it is recursive */
NCURSES_INLINE
#endif
int
waddch_literal(WINDOW *win, NCURSES_CH_T ch)
{
int x;
int y;
struct ldat *line;
x = win->_curx;
y = win->_cury;
CHECK_POSITION(win, x, y);
ch = render_char(win, ch);
line = win->_line + y;
CHANGED_CELL(line, x);
/*
* Build up multibyte characters until we have a wide-character.
*/
#if NCURSES_SP_FUNCS
#define DeriveSP() SCREEN *sp = _nc_screen_of(win);
#else
#define DeriveSP() /*nothing */
#endif
if_WIDEC({
DeriveSP();
if (WINDOW_EXT(win, addch_used) != 0 || !Charable(ch)) {
int len = _nc_build_wch(win, CHREF(ch));
if (len >= -1) {
attr_t attr = AttrOf(ch);
/* handle EILSEQ (i.e., when len >= -1) */
if (len == -1 && is8bits(CharOf(ch))) {
int rc = OK;
const char *s = NCURSES_SP_NAME(unctrl)
(NCURSES_SP_ARGx (chtype) CharOf(ch));
if (s[1] != '\0') {
while (*s != '\0') {
rc = waddch(win, UChar(*s) | attr);
if (rc != OK)
break;
++s;
}
return rc;
}
}
if (len == -1)
return waddch(win, ' ' | attr);
} else {
return OK;
}
}
});
static inline int
#endif
wborder_set(WINDOW *win,
const ARG_CH_T ls, const ARG_CH_T rs,
const ARG_CH_T ts, const ARG_CH_T bs,
const ARG_CH_T tl, const ARG_CH_T tr,
const ARG_CH_T bl, const ARG_CH_T br)
{
NCURSES_SIZE_T i;
NCURSES_SIZE_T endx, endy;
NCURSES_CH_T wls, wrs, wts, wbs, wtl, wtr, wbl, wbr;
T((T_CALLED("wborder(%p,%s,%s,%s,%s,%s,%s,%s,%s)"),
win,
_tracech_t2(1, ls),
_tracech_t2(2, rs),
_tracech_t2(3, ts),
_tracech_t2(4, bs),
_tracech_t2(5, tl),
_tracech_t2(6, tr),
_tracech_t2(7, bl),
_tracech_t2(8, br)));
if (!win)
returnCode(ERR);
#define RENDER_WITH_DEFAULT(ch,def) \
if (ch == 0) \
SetChar(w ## ch,ChCharOf(def),ChAttrOf(def)); \
else w ## ch = CHDEREF(ch); \
w ## ch = _nc_render(win, w ## ch)
RENDER_WITH_DEFAULT(ls, ACS_VLINE);
RENDER_WITH_DEFAULT(rs, ACS_VLINE);
RENDER_WITH_DEFAULT(ts, ACS_HLINE);
RENDER_WITH_DEFAULT(bs, ACS_HLINE);
RENDER_WITH_DEFAULT(tl, ACS_ULCORNER);
RENDER_WITH_DEFAULT(tr, ACS_URCORNER);
RENDER_WITH_DEFAULT(bl, ACS_LLCORNER);
RENDER_WITH_DEFAULT(br, ACS_LRCORNER);
T(("using %s, %s, %s, %s, %s, %s, %s, %s",
_tracech_t2(1, CHREF(wls)),
_tracech_t2(2, CHREF(wrs)),
_tracech_t2(3, CHREF(wts)),
_tracech_t2(4, CHREF(wbs)),
_tracech_t2(5, CHREF(wtl)),
_tracech_t2(6, CHREF(wtr)),
_tracech_t2(7, CHREF(wbl)),
_tracech_t2(8, CHREF(wbr))));
endx = win->_maxx;
endy = win->_maxy;
for (i = 0; i <= endx; i++) {
win->_line[0].text[i] = wts;
win->_line[endy].text[i] = wbs;
}
win->_line[endy].firstchar = win->_line[0].firstchar = 0;
win->_line[endy].lastchar = win->_line[0].lastchar = endx;
for (i = 0; i <= endy; i++) {
win->_line[i].text[0] = wls;
win->_line[i].text[endx] = wrs;
win->_line[i].firstchar = 0;
win->_line[i].lastchar = endx;
}
win->_line[0].text[0] = wtl;
win->_line[0].text[endx] = wtr;
win->_line[endy].text[0] = wbl;
win->_line[endy].text[endx] = wbr;
_nc_synchook(win);
returnCode(OK);
}
putwin(WINDOW *win, FILE *filep)
{
int code = ERR;
int y;
T((T_CALLED("putwin(%p,%p)"), (void *) win, (void *) filep));
#if NCURSES_EXT_PUTWIN
if (win != 0) {
const char *version = curses_version();
char buffer[1024];
NCURSES_CH_T last_cell;
memset(&last_cell, 0, sizeof(last_cell));
clearerr(filep);
/*
* Our magic number is technically nonprinting, but aside from that,
* all of the file is printable ASCII.
*/
#define PUTS(s) if (fputs(s, filep) == EOF || ferror(filep)) returnCode(code)
PUTS(my_magic);
PUTS(version);
PUTS("\n");
for (y = 0; y < (int) SIZEOF(scr_params); ++y) {
const char *name = scr_params[y].name;
const char *data = (char *) win + scr_params[y].offset;
const void *dp = (const void *) data;
*buffer = '\0';
if (!strncmp(name, "_pad.", 5) && !(win->_flags & _ISPAD)) {
continue;
}
switch (scr_params[y].type) {
case pATTR:
encode_attr(buffer, (*(const attr_t *) dp) & ~A_CHARTEXT, A_NORMAL);
break;
case pBOOL:
if (!(*(const bool *) data)) {
continue;
}
strcpy(buffer, name);
name = "flag";
break;
case pCHAR:
encode_attr(buffer, *(const attr_t *) dp, A_NORMAL);
break;
case pINT:
if (!(*(const int *) dp))
continue;
sprintf(buffer, "%d", *(const int *) dp);
break;
case pSHORT:
if (!(*(const short *) dp))
continue;
sprintf(buffer, "%d", *(const short *) dp);
break;
case pSIZE:
if (!(*(const NCURSES_SIZE_T *) dp))
continue;
sprintf(buffer, "%d", *(const NCURSES_SIZE_T *) dp);
break;
#if NCURSES_WIDECHAR
case pCCHAR:
encode_cell(buffer, (CARG_CH_T) dp, CHREF(last_cell));
break;
#endif
}
/*
* Only write non-default data.
*/
if (*buffer != '\0') {
if (fprintf(filep, "%s=%s\n", name, buffer) <= 0
|| ferror(filep))
returnCode(code);
}
}
/* Write row-data */
fprintf(filep, "rows:\n");
for (y = 0; y <= win->_maxy; y++) {
NCURSES_CH_T *data = win->_line[y].text;
int x;
if (fprintf(filep, "%d:", y + 1) <= 0
|| ferror(filep))
returnCode(code);
for (x = 0; x <= win->_maxx; x++) {
#if NCURSES_WIDECHAR
int len = wcwidth(data[x].chars[0]);
encode_cell(buffer, CHREF(data[x]), CHREF(last_cell));
last_cell = data[x];
PUTS(buffer);
if (len > 1)
x += (len - 1);
#else
encode_cell(buffer, CHREF(data[x]), CHREF(last_cell));
last_cell = data[x];
PUTS(buffer);
#endif
}
PUTS("\n");
}
code = OK;
}
#else
/*
* This is the original putwin():
* A straight binary dump is simple, but its format can depend on whether
* ncurses is compiled with wide-character support, and also may depend
* on the version of ncurses, e.g., if the WINDOW structure is extended.
*/
if (win != 0) {
size_t len = (size_t) (win->_maxx + 1);
clearerr(filep);
if (fwrite(win, sizeof(WINDOW), (size_t) 1, filep) != 1
|| ferror(filep))
returnCode(code);
for (y = 0; y <= win->_maxy; y++) {
if (fwrite(win->_line[y].text,
sizeof(NCURSES_CH_T), len, filep) != len
|| ferror(filep)) {
returnCode(code);
}
}
code = OK;
}
#endif
returnCode(code);
}
