int
wdelch(WINDOW *win)
{
chtype *temp1, *temp2;
chtype *end;
int cury = win->_cury;
short curx = win->_curx;
chtype *cp;
int s;
end = &win->_y[cury][win->_maxx - 1];
temp2 = &win->_y[cury][curx + 1];
temp1 = temp2 - 1;
s = 1;
win->_nbyte = -1;
if (_scrmax > 1) {
if (ISMBIT(*temp1)) {
win->_insmode = TRUE;
if (_mbvalid(win) == ERR)
return (ERR);
curx = win->_curx;
temp1 = &win->_y[cury][curx];
}
if (ISMBIT(*end)) {
for (cp = end; cp >= temp1; --cp)
if (!ISCBIT(*cp))
break;
if (cp + _curs_scrwidth[TYPE(*cp)] > end+1)
end = cp - 1;
}
if (ISMBIT(*temp1))
s = _curs_scrwidth[TYPE(RBYTE(*temp1))];
end -= s - 1;
temp2 = &win->_y[cury][curx+s];
}
while (temp1 < end)
*temp1++ = *temp2++;
while (s--)
*temp1++ = win->_bkgd;
#ifdef _VR3_COMPAT_CODE
if (_y16update)
(*_y16update)(win, 1, win->_maxx - curx, cury, curx);
#endif /* _VR3_COMPAT_CODE */
win->_lastch[cury] = win->_maxx - 1;
if (win->_firstch[cury] > curx)
win->_firstch[cury] = curx;
win->_flags |= _WINCHANGED;
if (win->_sync)
wsyncup(win);
return (win->_immed ? wrefresh(win) : OK);
}
int
winwstr(WINDOW *win, wchar_t *wstr)
{
int counter = 0;
int cy = win->_cury;
chtype *ptr = &(win->_y[cy][win->_curx]),
*pmax = &(win->_y[cy][win->_maxx]);
chtype *p1st = &(win->_y[cy][0]);
wchar_t wc;
int sw, s;
char *cp, cbuf[CSMAX+1];
while (ISCBIT(*ptr) && (p1st < ptr))
ptr--;
while (ptr < pmax) {
wc = RBYTE(*ptr);
sw = mbscrw((int)wc);
(void) mbeucw((int)wc);
cp = cbuf;
for (s = 0; s < sw; s++, ptr++) {
if ((wc = RBYTE(*ptr)) == MBIT)
continue;
/* LINTED */
*cp++ = (char) wc;
if ((wc = LBYTE(*ptr) | MBIT) == MBIT)
continue;
/* LINTED */
*cp++ = (char) wc;
}
*cp = '\0';
if (_curs_mbtowc(&wc, cbuf, CSMAX) <= 0)
break;
*wstr++ = wc;
}
*wstr = (wchar_t)0;
return (counter);
}
/*
* Add ncols worth of data to win, using string as input.
* Return the number of chtypes copied.
* Note: chtype contains 32/16 bit process code.
*/
int
waddwchnstr(WINDOW *win, chtype *string, int ncols)
{
int my_x = win->_curx;
int my_y = win->_cury;
short my_maxx;
int counter;
chtype *ptr = &(win->_y[my_y][my_x]);
chtype *sptr = ptr;
char mbbuf[CSMAX+1];
int mp, s, scrw;
chtype rawc;
chtype attr;
short my_x1 = win->_curx;
while (ISCBIT(*ptr)) {
ptr--;
my_x1--;
}
while (ptr < sptr)
*ptr++ = win->_bkgd;
if (ncols == -1)
ncols = MAXINT;
counter = win->_maxx - my_x;
while ((ncols > 0) && (*string) && (counter > 0)) {
attr = *string & A_WATTRIBUTES;
rawc = *string & A_WCHARTEXT;
/* conver wchar_t to mbuti byte string */
for (mp = 0; mp < sizeof (mbbuf); mp++)
mbbuf[mp] = '\0';
if (_curs_wctomb(mbbuf, rawc) <= 0)
goto out;
/* if there are no cols on screen, end */
if ((scrw = wcscrw(rawc)) > counter)
goto out;
if (rawc & WCHAR_CSMASK) {
/* store multi-byte string into chtype */
for (s = 0, mp = 0; s < scrw; s++, mp += 2) {
*ptr = _CHAR(RBYTE(mbbuf[mp]) |
RBYTE(mbbuf[mp + 1]) << 8) | CBIT;
SETMBIT(*ptr);
if (mp > 0)
SETCBIT(*ptr);
else
CLRCBIT(*ptr);
*ptr |= attr;
ptr++;
}
} else {
/* store single-byte string into chtype */
*ptr = mbbuf[0];
*ptr |= attr;
ptr++;
}
ncols--;
string++;
counter -= scrw;
}
out :
while (ISCBIT(*ptr))
*ptr++ = win->_bkgd;
/* LINTED */
my_maxx = (short) (ptr - sptr + my_x);
if (my_x1 < win->_firstch[my_y])
win->_firstch[my_y] = my_x1;
if (my_maxx > win->_lastch[my_y])
win->_lastch[my_y] = my_maxx;
win->_flags |= _WINCHANGED;
/* sync with ancestor structures */
if (win->_sync)
wsyncup(win);
return (win->_immed ? wrefresh(win) : OK);
}
int
wbkgd(WINDOW *win, chtype nbkgd)
{
short maxx;
int x, y;
chtype *wcp, obkgda, obkgdc, nbkgda,
nbkgdc, acolor, c;
short *begch, *endch;
/* if 'nbkgd' contains color information, but this is not a color */
/* terminal, erase that information. */
if ((nbkgd & A_COLOR) && (cur_term->_pairs_tbl == NULL))
nbkgd &= ~A_COLOR;
if (nbkgd == win->_bkgd)
return (OK);
obkgdc = _CHAR(win->_bkgd);
obkgda = _ATTR(win->_bkgd);
nbkgdc = _CHAR(nbkgd);
nbkgda = _ATTR(nbkgd);
/* switch byte order if necessary */
if (ISCBIT(nbkgdc))
nbkgdc = _CHAR((RBYTE(nbkgdc) << 8) | (LBYTE(nbkgdc)|MBIT)) |
CBIT;
c = RBYTE(nbkgdc);
if ((nbkgdc < ' ' || nbkgdc == _CTRL('?')) ||
_curs_scrwidth[TYPE(c)] > 1)
nbkgdc = obkgdc;
nbkgd = (nbkgdc & ~CBIT) | nbkgda;
win->_bkgd = nbkgd;
/* delete the old background from the attribute field and replace */
/* it with the new background. Note: if the same attribute was */
/* first set by wbkgd() and then by wattron(), or vice versa, it */
/* will be deleted, so the effect of wattron() will be lost. */
/* This applies to both video and color attributes. */
if ((acolor = (win->_attrs & A_COLOR)) != 0) {
if (acolor == (obkgda & A_COLOR)) {
win->_attrs = _ATTR((win->_attrs & ~obkgda) | nbkgda);
} else {
win->_attrs = _ATTR((win->_attrs &
(~obkgda | A_COLOR)) | (nbkgda & ~A_COLOR));
}
} else
win->_attrs = _ATTR((win->_attrs & ~obkgda) | nbkgda);
maxx = win->_maxx - 1;
begch = win->_firstch;
endch = win->_lastch;
for (y = win->_maxy-1; y >= 0; --y, ++begch, ++endch) {
for (x = maxx, wcp = win->_y[y]; x-- >= 0; ++wcp) {
if ((c = _CHAR(*wcp)) == obkgdc)
c = nbkgdc;
if ((acolor = (*wcp & A_COLOR)) != 0) {
if (acolor == (obkgda & A_COLOR))
*wcp = c | _ATTR((*wcp & ~obkgda) |
nbkgda);
else
*wcp = c | _ATTR((*wcp & (~obkgda |
A_COLOR)) | (nbkgda & ~A_COLOR));
} else
*wcp = c | _ATTR((*wcp & ~obkgda) | nbkgda);
}
*begch = 0;
*endch = maxx;
}
win->_flags |= _WINCHANGED;
if (win->_sync)
wsyncup(win);
return (win->_immed ? wrefresh(win) : OK);
}
static void
_updateln(int wy)
{
chtype *wcp, *scp, *wp, *sp, wc, sc;
int wx, lastx, x, mtch, idch, blnkx, idcx, video_attrx,
color_attrx, maxi, endns, begns, wx_sav, multi_col;
bool redraw, changed, didcolor, didvideo;
redraw = (_virtscr->_firstch[wy] == _REDRAW);
endns = _ENDNS[wy];
begns = _BEGNS[wy];
/* easy case */
if (!redraw && (_virtscr->_lastch[wy] == _BLANK) && (begns >= scrco))
return;
/* line images */
wcp = magic_cookie_glitch <= 0 ? _virtscr->_y[wy] : _shove(wy);
scp = curscr->_y[wy];
/* the interval to be updated */
if (redraw || magic_cookie_glitch >= 0) {
wx = 0;
lastx = scrco;
} else {
wx = _virtscr->_firstch[wy];
lastx = _virtscr->_lastch[wy] == _BLANK ? scrco :
_virtscr->_lastch[wy] + 1;
}
/* skip equal parts */
if (!redraw) {
/* skip the starting equal part */
wp = wcp + wx;
sp = scp + wx;
for (; wx < lastx; ++wx)
if (*wp++ != *sp++)
break;
if (wx >= lastx)
return;
/* start update at an entire character */
for (sp = scp+wx, wp = wcp+wx; wp > wcp; --wp, --sp, --wx)
if (!ISCBIT(*wp) && !ISCBIT(*sp))
break;
/* skip the ending equal part */
wp = wcp + lastx - 1;
sp = scp + lastx - 1;
for (; lastx > wx; --lastx)
if (*wp-- != *sp--)
break;
++wp;
++wp;
++sp;
++sp;
for (; lastx < scrco; ++wp, ++sp, ++lastx)
if (!ISCBIT(*wp) && !ISCBIT(*sp))
break;
}
/* place to do clear-eol */
if (!clr_eol || endns >= lastx)
blnkx = scrco;
else
if (_virtscr->_lastch[wy] == _BLANK)
blnkx = -1;
else {
for (blnkx = lastx - 1, wp = wcp + blnkx;
blnkx >= wx; --blnkx, --wp)
if (_DARKCHAR(*wp))
break;
for (sp = scp + blnkx + 1; blnkx < scrco - 1;
++sp, ++blnkx)
if (!ISCBIT(*sp))
break;
if (blnkx + _COST(Clr_eol) >= lastx)
blnkx = scrco;
}
/* on cookie terminals, we may need to do more work */
if (marks) {
/* video_attrx = color_attrx = scrco; */
video_attrx = color_attrx = (lastx >= scrco) ? lastx - 1 :
lastx;
/* find the last video attribute on the line */
wp = wcp + video_attrx;
for (; video_attrx >= wx; --video_attrx, --wp)
if (_VIDEO(*wp) != A_NORMAL)
break;
/* find the last color attribute on the line */
if (color_marks) {
wp = wcp + color_attrx;
for (; color_attrx >= wx; --color_attrx, --wp)
if (_COLOR(*wp) != A_NORMAL)
break;
if (color_attrx < lastx)
color_attrx++;
}
if (video_attrx < lastx)
video_attrx++;
if (video_attrx >= scrco)
--video_attrx;
if (color_marks && color_attrx >= scrco)
--color_attrx;
if (magic_cookie_glitch > 0 && wy == scrli - 1 &&
video_attrx == scrco - 1)
--video_attrx;
if (color_marks && magic_cookie_glitch > 0 &&
wy == scrli - 1 && color_attrx == scrco - 1)
--color_attrx;
for (wp = wcp+video_attrx; wp >= wcp+wx; --wp)
if (!ISCBIT(*wp))
break;
}
/* place for insert/delete chars */
#define SLACK 4
if (redraw || (!SP->dchok && !SP->ichok) || !(_virtscr->_use_idc) ||
endns < wx || (endns >= lastx && (scrco - lastx) > SLACK)) {
idcx = scrco;
} else
if (!marks)
idcx = -1;
else {
/* on cookie term, only do idch where no attrs */
/* are used */
for (idcx = scrco - 1, wp = wcp + idcx; idcx >= wx;
--idcx, --wp)
if (_ATTR(*wp) || _ISMARK1(wy, idcx) ||
_ISMARK2(wy, idcx))
break;
if (idcx >= scrco - SLACK)
idcx = scrco;
}
if (idcx < lastx && endns >= lastx)
lastx = scrco;
/* max amount of insert allow */
if (idcx == scrco || !SP->ichok)
maxi = 0;
else
if (lastx == scrco)
maxi = scrco;
else
maxi = lastx - (endns + 1);
/* go */
wcp += wx;
scp += wx;
didvideo = changed = FALSE;
didcolor = (color_marks) ? FALSE : TRUE;
while (wx < lastx) {
/* skip things that are already right */
if (!redraw) {
multi_col = 0;
wx_sav = wx;
for (; wx < lastx; ++wx, ++wcp, ++scp)
if (*wcp != *scp)
break;
if (wx >= lastx)
goto done;
for (; wx > wx_sav; --wx, --wcp, --scp) {
if (!ISCBIT(*wcp) && !ISCBIT(*scp))
break;
multi_col = 1;
}
}
/* try clear-bol, we'll assume exclusive clr_bol */
if (!changed && !marks && clr_bol && blnkx > wx &&
begns >= wx) {
for (x = wx, wp = wcp; x < lastx; ++x, ++wp)
if (_DARKCHAR(*wp))
break;
/* clearing only whole screen characters */
for (sp = scp+(x-wx); x >= wx; --x, --sp)
if (!ISCBIT(*sp))
break;
x -= 1;
if ((x - (redraw ? 0 : begns)) > _COST(Clr_bol)) {
(void) mvcur(cy, cx, wy, x);
/* MORE?: colors - mvcur will shuts of */
/* colors when msgr is not defined */
/* SS: colors */
if (back_color_erase)
_turn_off_background();
_PUTS(clr_bol, 1);
/* LINTED */
cy = (short) wy;
/* LINTED */
cx = (short) x;
mtch = x - wx;
(void) memcpy((char *) scp, (char *) wcp,
(mtch * sizeof (chtype)));
wcp += mtch;
scp += mtch;
wx = x;
}
}
/* screen image is changing */
changed = TRUE;
/* move to the point to start refresh */
if (cy != wy || cx != wx)
(void) mvcur(cy, cx, wy, wx);
/* LINTED */
cy = (short) wy;
/* LINTED */
cx = (short) wx;
/* update screen image */
while (wx < lastx) {
wc = *wcp;
sc = *scp;
if (!redraw && !multi_col && wc == sc)
break;
/* real video attributes */
if (marks)
curscr->_attrs = _ATTR(sc);
/* blanks only */
if (wx > blnkx) {
/* SS: colors */
if (back_color_erase)
_turn_off_background();
_PUTS(clr_eol, 1);
/* LINTED */
curscr->_curx = (short) wx;
/* LINTED */
curscr->_cury = (short) wy;
(void) wclrtoeol(curscr);
if (marks && wx > 0 && _ATTR(*(scp - 1)) !=
A_NORMAL) {
_VIDS(A_NORMAL, _ATTR(*(scp - 1)));
if (_VIDEO(*scp - 1))
_setmark1(wy, wx, NULL);
if (_COLOR(*scp - 1))
_setmark2(wy, wx, NULL);
}
goto done;
}
/* try insert/delete chars */
if (wx > idcx && !ISCBIT(*scp) &&
(mtch = _useidch(wcp, scp, lastx - wx,
maxi, &idch))) {
maxi -= idch;
wx += mtch;
scp += mtch;
wcp += mtch;
break;
}
/* about to output chars, make sure insert */
/* mode is off */
if (SP->phys_irm)
_OFFINSERT();
/* color and video attributes */
if (_ATTR(wc) != curscr->_attrs) {
bool color_change = FALSE;
bool video_change = FALSE;
if (marks)
if (_VIDEO(wc) != _VIDEO(curscr->_attrs))
video_change = TRUE;
if (color_marks)
if (_COLOR(wc) != _COLOR(curscr->_attrs))
color_change = TRUE;
/* the following may occurs when, for */
/* example the application */
/* is written for color terminal and then */
/* run on a monocrome */
if (marks && !video_change && !color_change)
goto no_change;
/* prevent spilling out of line */
if (marks && !(didcolor && didvideo)) {
if ((video_change && !_ISMARK1(wy,
video_attrx)) || (color_change &&
!_ISMARK2(wy, color_attrx))) {
int tempx;
chtype sa = curscr->_attrs;
bool first = FALSE;
bool second = FALSE;
if (!didvideo && video_change &&
!_ISMARK1(wy, video_attrx)) {
didvideo = TRUE;
(void) mvcur(wy, wx,
wy, video_attrx);
_VIDS(_VIDEO(_virtscr->_y[wy]
[video_attrx]),
_VIDEO(_virtscr->_y[wy]
[video_attrx-1]));
_setmark1(wy, video_attrx,
NULL);
first = TRUE;
}
if (!didcolor && color_change &&
!_ISMARK2(wy, color_attrx)) {
didcolor = TRUE;
tempx = first ? video_attrx : wx;
if (tempx != color_attrx)
(void) mvcur(wy, tempx, wy,
color_attrx);
/*
* sc = _COLOR(curscr->_y[wy][color_attrx]);
*_VIDS(sc, (~sc & A_COLOR));
*/
_VIDS(_COLOR(_virtscr->_y[wy]
[color_attrx]),
_COLOR(_virtscr->_y[wy]
[color_attrx-1]));
_setmark2(wy, color_attrx, NULL);
second = TRUE;
}
(void) mvcur(wy, (second ? color_attrx :
video_attrx), wy, wx);
curscr->_attrs = sa;
}
}
_VIDS(_ATTR(wc), curscr->_attrs);
/* on cookie terminals mark the interval */
if (video_change)
_setmark1(wy, wx, scp);
if (color_change)
_setmark2(wy, wx, scp);
}
/* end-of-line */
no_change:
x = 1;
if (_scrmax > 1)
x = _curs_scrwidth[TYPE(RBYTE(wc))];
if (wx == scrco - x) {
_rmargin(wx);
goto done;
}
if (transparent_underline && erase_overstrike &&
_CHAR(wc) == '_') {
(void) _outch(' ');
(void) mvcur(wy, wx + 1, wy, wx);
}
/* put out the character */
(void) _outwch(tilde_glitch && _CHAR(wc) == '~' ? '`' : wc);
*scp++ = wc;
wcp++;
wx++;
cx++;
/* output entire multi-byte chars */
while (wx < lastx && ISCBIT(*wcp)) {
(void) _outwch(*wcp);
*scp++ = *wcp++;
wx++;
cx++;
}
}
}
done:
if (changed) {
/* update the blank structure */
for (wx = 0, scp = curscr->_y[wy]; wx < scrco; ++wx, ++scp)
if (_DARKCHAR(*scp))
break;
/* LINTED */
_BEGNS[wy] = (short) wx;
if (wx == scrco)
_ENDNS[wy] = -1;
else {
wx = scrco - 1;
scp = curscr->_y[wy] + wx;
for (; wx >= 0; --wx, --scp)
if (_DARKCHAR(*scp))
break;
/* LINTED */
_ENDNS[wy] = (short) wx;
}
/* update the hash structure */
_CURHASH[wy] = _BEGNS[wy] < scrco ? _NOHASH : 0;
}
}
static void
_rmargin(int wx)
{
int x, w, ix;
chtype sc;
chtype *wcp = _virtscr->_y[cy];
/* screen may scroll */
if (cy == scrli - 1) {
/* can't do anything */
if (!SP->ichok)
return;
/* the width of the new character */
w = _curs_scrwidth[TYPE(RBYTE(wcp[wx]))];
/* the place to put it without causing scrolling */
for (x = wx - 1; x > 0; --x)
if (!ISCBIT(wcp[x]))
break;
sc = curscr->_y[cy][x];
(void) mvcur(cy, cx, cy, x);
if (_ATTR(wcp[wx]) != curscr->_attrs)
_VIDS(_ATTR(wcp[wx]), curscr->_attrs);
(void) _outwch(tilde_glitch &&
_CHAR(wcp[wx]) == '~' ? '`' : wcp[wx]);
for (ix = wx + 1; ix < scrco; ++ix) {
(void) _outwch(wcp[ix]);
}
/* insert sc back in and push wcp[wx] right */
(void) mvcur(cy, x+w, cy, x);
/* SS: colors */
if (back_color_erase)
_turn_off_background();
if (SP->imode && !SP->phys_irm)
_ONINSERT();
/* width of the old character that was overwritten */
w = _curs_scrwidth[TYPE(RBYTE(curscr->_y[cy][x]))];
if (insert_character)
for (ix = 0; ix < w; ++ix)
_PUTS(insert_character, 1);
else
if (parm_ich && !SP->imode)
_PUTS(tparm_p1(parm_ich, w), 1);
if (_ATTR(sc) != curscr->_attrs)
_VIDS(_ATTR(sc), curscr->_attrs);
for (ix = x; w > 0; --w, ++ix)
(void) _outwch(curscr->_y[cy][ix]);
/* make sure the video attrs are ok */
if (marks && (_ATTR(sc) || _ATTR(wcp[wx])))
_VIDS(_ATTR(wcp[wx]), ~_ATTR(sc));
/* update screen image */
/* LINTED */
cx = (short) wx;
curscr->_y[cy][wx] = wcp[wx];
for (x = wx + 1; x < scrco; ++x) {
(void) _outwch(wcp[x]);
curscr->_y[cy][x] = wcp[x];
}
return;
}
/* put char out and update screen image */
(void) _outwch(tilde_glitch && _CHAR(wcp[wx]) == '~' ? '`' : wcp[wx]);
curscr->_y[cy][wx] = wcp[wx];
for (x = wx + 1; x < scrco; ++x) {
(void) _outwch(wcp[x]);
curscr->_y[cy][x] = wcp[x];
}
/* make sure that wrap-around happens */
if (!auto_right_margin || eat_newline_glitch) {
(void) _outch('\r');
(void) _outch('\n');
}
cx = 0;
++cy;
}
int
copywin(WINDOW *Srcwin, WINDOW *Dstwin,
int minRowSrc, int minColSrc, int minRowDst,
int minColDst, int maxRowDst, int maxColDst,
int over_lay)
{
int ySrc, yDst, which_copy, t;
int height = (maxRowDst - minRowDst) + 1,
width = (maxColDst - minColDst) + 1;
chtype **_yDst = Dstwin->_y, **_ySrc = Srcwin->_y,
bkSrc = Srcwin->_bkgd, atDst = Dstwin->_attrs,
*spSrc, *spDst, *epSrc, *epDst, *savepS,
*savepD, width_bytes, numcopied;
#ifdef DEBUG
if (outf)
fprintf(outf, "copywin(%0.2o, %0.2o);\n", Srcwin, Dstwin);
#endif /* DEBUG */
/*
* If we are going to be copying from curscr,
* first offset into curscr the offset the Dstwin knows about.
*/
if (Srcwin == curscr)
minRowSrc += Dstwin->_yoffset;
/*
* There are three types of copy.
* 0 - Straight memcpy allowed
* 1 - We have to first check to see if the source character is a blank
* 2 - Dstwin has attributes or bkgd that must changed
* on a char-by-char basis.
*/
if ((which_copy = (over_lay) ? 1 :
(2 * ((Dstwin->_attrs != A_NORMAL) ||
(Dstwin->_bkgd != _BLNKCHAR)))) == 0)
width_bytes = width * (int)sizeof (chtype);
/* for each Row */
for (ySrc = minRowSrc, yDst = minRowDst; height-- > 0; ySrc++, yDst++) {
if (which_copy) {
spSrc = &_ySrc[ySrc][minColSrc];
spDst = &_yDst[yDst][minColDst];
numcopied = width;
epSrc = savepS = &_ySrc[ySrc][maxColDst];
epDst = savepD = &_yDst[yDst][maxColDst];
/* only copy into an area bounded by whole characters */
for (; spDst <= epDst; spSrc++, spDst++)
if (!ISCBIT(*spDst))
break;
if (spDst > epDst)
continue;
for (; epDst >= spDst; --epDst, --epSrc)
if (!ISCBIT(*epDst))
break;
t = _curs_scrwidth[TYPE(RBYTE(*epDst))] - 1;
if (epDst+t <= savepD)
epDst += t, epSrc += t;
else
epDst -= 1, epSrc -= 1;
if (epDst < spDst)
continue;
/* don't copy partial characters */
for (; spSrc <= epSrc; ++spSrc, ++spDst)
if (!ISCBIT(*spSrc))
break;
if (spSrc > epSrc)
continue;
for (; epSrc >= spSrc; --epSrc, --epDst)
if (!ISCBIT(*epSrc))
break;
t = _curs_scrwidth[TYPE(RBYTE(*epSrc))] - 1;
if (epSrc+t <= savepS)
epSrc += t, epDst += t;
else
epSrc -= 1, epDst -= 1;
if (epSrc < spSrc)
continue;
/* make sure that the copied-to place is clean */
if (ISCBIT(*spDst))
(void) _mbclrch(Dstwin, minRowDst,
/*LINTED*/
(intptr_t)(spDst - *_yDst[yDst]));
if (ISCBIT(*epDst))
(void) _mbclrch(Dstwin, minRowDst,
/*LINTED*/
(intptr_t)(epDst - *_yDst[yDst]));
/*LINTED*/
numcopied = (chtype) (epDst - spDst + 1);
if (which_copy == 1) { /* overlay */
for (; numcopied-- > 0; spSrc++, spDst++)
/* Check to see if the char is a "blank/bkgd". */
if (*spSrc != bkSrc)
*spDst = *spSrc | atDst;
} else {
for (; numcopied-- > 0; spSrc++, spDst++)
*spDst = *spSrc | atDst;
}
} else {
/* ... copy all chtypes */
(void) memcpy((char *)&_yDst[yDst][minColDst],
(char *)&_ySrc[ySrc][minColSrc], width_bytes);
}
/* note that the line has changed */
if (minColDst < Dstwin->_firstch[yDst])
/*LINTED*/
Dstwin->_firstch[yDst] = (short)minColDst;
if (maxColDst > Dstwin->_lastch[yDst])
/*LINTED*/
Dstwin->_lastch[yDst] = (short)maxColDst;
}
#ifdef _VR3_COMPAT_CODE
if (_y16update) {
(*_y16update)(Dstwin, (maxRowDst - minRowDst) + 1,
(maxColDst - minColDst) + 1, minRowDst, minColDst);
}
#endif /* _VR3_COMPAT_CODE */
/* note that something in Dstwin has changed */
Dstwin->_flags |= _WINCHANGED;
if (Dstwin->_sync)
wsyncup(Dstwin);
return (Dstwin->_immed ? wrefresh(Dstwin) : OK);
}
static int
_mvright(int cx, int nx, int doit)
{
chtype *scp;
char *mks;
int nt, tx, x, stcost, iscont;
if (!cursor_right && !parm_right_cursor)
return (LARGECOST);
scp = curscr->_y[Newy];
mks = magic_cookie_glitch >= 0 ? SP->_mks[Newy] : NULL;
if (cursor_right) {
/* number of tabs used in stepwise movement */
nt = tab ? (nx / TABSIZE - cx / TABSIZE) : 0;
tx = (nt > 0) ? (cx / TABSIZE + nt) * TABSIZE : cx;
/* calculate stepwise cost */
stcost = nt * _COST(Tab);
iscont = 0;
for (x = tx; x < nx; ++x) {
if (iscont == 0 && !ISCBIT(scp[x]))
iscont = 1;
if ((!ceol_standout_glitch && !mks &&
_ATTR(scp[x]) == curscr->_attrs) ||
ceol_standout_glitch || (mks && !_ISMARK2(x))) {
if (!ISMBIT(scp[x]))
stcost += 1;
else if (iscont && !(nx - x == 1 && nx <
curscr->_maxx && ISCBIT(scp[nx])))
stcost += 1;
else
stcost += _COST(Cursor_right);
} else
stcost += _COST(Cursor_right);
}
} else
stcost = LARGECOST;
if (!doit)
return ((_COST(Parm_right_cursor) < stcost) ?
_COST(Parm_right_cursor) : stcost);
/* actually move */
if (_COST(Parm_right_cursor) < stcost)
_PUTS(tparm_p1(parm_right_cursor, nx-cx), 1);
else {
if (SP->phys_irm)
_OFFINSERT();
for (; nt > 0; --nt)
_PUTS(tab, 1);
iscont = 0;
for (x = tx; x < nx; ++x) {
if (iscont == 0 && !ISCBIT(scp[x]))
iscont = 1;
if ((!ceol_standout_glitch && !mks &&
_ATTR(scp[x]) == curscr->_attrs) ||
ceol_standout_glitch || (mks && !_ISMARK2(x))) {
if (!ISMBIT(scp[x]))
(void) _outwch(_CHAR(scp[x]));
else if (iscont && !(nx - x == 1 &&
nx < curscr->_maxx && ISCBIT(scp[nx])))
(void) _outwch(_CHAR(scp[x]));
else
_PUTS(cursor_right, 1);
} else
_PUTS(cursor_right, 1);
}
}
return (0);
}
