/* * 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); }