/*
* Clear a physical display line, high level.
*/
void
vclrlin(int l, line *tp)
{
vigoto(l, 0);
if ((hold & HOLDAT) == 0)
putchar(tp > dol ? ((UPPERCASE || tilde_glitch) ? '^' : '~') : '@');
if (state == HARDOPEN)
sethard();
vclreol();
}
/*
* Clear a physical display line, high level.
*/
void
vclrlin(int l, line *tp)
{
vigoto(l, 0);
if ((hold & HOLDAT) == 0)
#ifndef UCVISUAL
putchar(tp > dol ? '~' : '@');
#else
putchar(tp > dol ? ((UPPERCASE || xHZ) ? '^' : '~') : '@');
#endif
if (state == HARDOPEN)
sethard();
vclreol();
}
/*
* Redisplay logical line l at physical line p with line number lineno.
*/
int
vreopen(int p, int lineno, int l)
{
register int d;
register struct vlinfo *vp = &vlinfo[l];
if (p < 0)
error("Line too long to fit on screen");
d = vp->vdepth;
if (d == 0 || (vp->vflags & VDIRT))
vp->vdepth = d = vdepth();
vp->vliny = p, vp->vflags &= ~VDIRT;
/*
* Try to win by making the screen larger rather than inserting
* a line and driving text off the bottom.
*/
p = vglitchup(l, 0);
/*
* BUG: Should consider using CE here to clear to end of line.
* As it stands we always strike over the current text.
* Since often the current text is the same as what
* we are overstriking with, it tends not to show.
* On the other hand if it is different and we end up
* spacing out a lot of text, we could have won with
* a CE. This is probably worthwhile at low speed
* only however, since clearly computation will be
* necessary to determine which way to go.
*/
vigoto(p, 0);
pline(lineno);
/*
* When we are typing part of a line for hardcopy open, don't
* want to type the '$' marking an end of line if in list mode.
*/
if (hold & HOLDDOL)
return (d);
if (Putchar == listchar)
putchar('$');
/*
* Optimization of cursor motion may prevent screen rollup if the
* line has blanks/tabs at the end unless we force the cursor to appear
* on the last line segment.
*/
if (vp->vliny + d - 1 > WBOT)
vcsync();
/*
* Switch into hardcopy open mode if we are in one line (adm3)
* open mode and this line is now too long. If in hardcopy
* open mode, then call sethard to move onto the next line
* with appropriate positioning.
*/
if (state == ONEOPEN) {
WCOLS = OCOLUMNS;
if (vdepth() > 1) {
WCOLS = TUBECOLS;
sethard();
} else
WCOLS = TUBECOLS;
} else if (state == HARDOPEN)
sethard();
/*
* Unless we filled (completely) the last line we typed on,
* we have to clear to the end of the line
* in case stuff is left from before.
*/
if (vp->vliny + d > destline) {
if (IN && destcol == WCOLS)
vigoto(vp->vliny + d - 1, 0);
vclreol();
}
return (d);
}
/*ARGSUSED*/
void
vmove(int unused)
{
register int cnt;
if (wdot) {
if (wdot < one || wdot > dol) {
beep();
return;
}
cnt = wdot - dot;
wdot = NOLINE;
if (cnt)
killU();
vupdown(cnt, wcursor);
return;
}
/*
* When we move onto a new line, save information for U undo.
*/
if (vUNDdot != dot) {
vUNDsav = *dot;
vUNDcurs = wcursor;
vUNDdot = dot;
}
/*
* In hardcopy open, type characters to left of cursor
* on new line, or back cursor up if its to left of where we are.
* In any case if the current line is ``rubbled'' i.e. has trashy
* looking overstrikes on it or \'s from deletes, we reprint
* so it is more comprehensible (and also because we can't work
* if we let it get more out of sync since column() won't work right.
*/
if (state == HARDOPEN) {
register char *cp;
if (rubble) {
register int c;
int oldhold = hold;
sethard();
cp = wcursor;
c = *cp;
*cp = 0;
hold |= HOLDDOL;
vreopen(WTOP, lineDOT(), vcline);
hold = oldhold;
*cp = c;
} else if (wcursor > cursor) {
vfixcurs();
for (cp = cursor; *cp && cp < wcursor;) {
int c, n;
nextc(c, cp, n);
cp += n;
c &= TRIM;
putchar(c ? c : ' ');
}
}
}
vsetcurs(wcursor);
}
