![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ex_vadj.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 3BSD / cmd / ex|
Return to ex_vadj.c CVS log | Up to [CSRG BSD Unix] / 3BSD / cmd / ex |
1.1 root 1: /* Copyright (c) 1979 Regents of the University of California */
2: #include "ex.h"
3: #include "ex_tty.h"
4: #include "ex_vis.h"
5:
6: /*
7: * Routines to deal with management of logical versus physical
8: * display, opening and redisplaying lines on the screen, and
9: * use of intelligent terminal operations. Routines to deal with
10: * screen cleanup after a change.
11: */
12:
13: /*
14: * Display a new line at physical line p, returning
15: * the depth of the newly displayed line. We may decide
16: * to expand the window on an intelligent terminal if it is
17: * less than a full screen by deleting a line above the top of the
18: * window before doing an insert line to keep all the good text
19: * on the screen in which case the line may actually end up
20: * somewhere other than line p.
21: */
22: vopen(tp, p)
23: line *tp;
24: int p;
25: {
26: register int cnt;
27: register struct vlinfo *vp, *vpc;
28:
29: #ifdef ADEBUG
30: if (trace != NULL)
31: tfixnl(), fprintf(trace, "vopen(%d, %d)\n", lineno(tp), p);
32: #endif
33: if (state != VISUAL) {
34: if (vcnt)
35: if (hold & HOLDROL)
36: vup1();
37: else
38: vclean();
39:
40: /*
41: * Forget all that we once knew.
42: */
43: vcnt = vcline = 0;
44: p = WBOT; LASTLINE = WBOT + 1;
45: state = bastate;
46: WTOP = basWTOP;
47: WLINES = basWLINES;
48: }
49: vpc = &vlinfo[vcline];
50: for (vp = &vlinfo[vcnt]; vp >= vpc; vp--)
51: vlcopy(vp[1], vp[0]);
52: vcnt++;
53: if (Pline == numbline)
54: /*
55: * Dirtying all the lines is rather inefficient
56: * internally, but number mode is used rarely
57: * and so its not worth optimizing.
58: */
59: vdirty(vcline+1, WECHO);
60: getline(*tp);
61:
62: /*
63: * If we are opening at the top of the window, can try a window
64: * expansion at the top.
65: */
66: if (state == VISUAL && vcline == 0 && vcnt > 1 && p > ZERO) {
67: cnt = p + vdepth() - LINE(1);
68: if (cnt > 0) {
69: p -= cnt;
70: if (p < ZERO)
71: p = ZERO;
72: WTOP = p;
73: WLINES = WBOT - WTOP + 1;
74: }
75: }
76: vpc->vliny = p, vpc->vdepth = 0, vpc->vflags = 0;
77: cnt = vreopen(p, lineno(tp), vcline);
78: if (vcline + 1 == vcnt)
79: LINE(vcnt) = LINE(vcline) + cnt;
80: }
81:
82: /*
83: * Redisplay logical line l at physical line p with line number lineno.
84: */
85: vreopen(p, lineno, l)
86: int p, lineno, l;
87: {
88: register int d;
89: register struct vlinfo *vp = &vlinfo[l];
90:
91: #ifdef ADEBUG
92: if (trace)
93: tfixnl(), fprintf(trace, "vreopen(%d, %d, %d)\n", p, lineno, l);
94: #endif
95: d = vp->vdepth;
96: if (d == 0 || (vp->vflags & VDIRT))
97: vp->vdepth = d = vdepth();
98: vp->vliny = p, vp->vflags &= ~VDIRT;
99:
100: /*
101: * Try to win by making the screen larger rather than inserting
102: * a line and driving text off the bottom.
103: */
104: p = vglitchup(l, 0);
105:
106: /*
107: * BUG: Should consider using CE here to clear to end of line.
108: * As it stands we always strike over the current text.
109: * Since often the current text is the same as what
110: * we are overstriking with, it tends not to show.
111: * On the other hand if it is different and we end up
112: * spacing out a lot of text, we could have won with
113: * a CE. This is probably worthwhile at low speed
114: * only however, since clearly computation will be
115: * necessary to determine which way to go.
116: */
117: vigoto(p, 0);
118: pline(lineno);
119:
120: /*
121: * When we are typing part of a line for hardcopy open, don't
122: * want to type the '$' marking an end of line if in list mode.
123: */
124: if (hold & HOLDDOL)
125: return (d);
126: if (Putchar == listchar)
127: putchar('$');
128:
129: /*
130: * Optimization of cursor motion may prevent screen rollup if the
131: * line has blanks/tabs at the end unless we force the cursor to appear
132: * on the last line segment.
133: */
134: if (vp->vliny + d - 1 > WBOT)
135: vcsync();
136:
137: /*
138: * Switch into hardcopy open mode if we are in one line (adm3)
139: * open mode and this line is now too long. If in hardcopy
140: * open mode, then call sethard to move onto the next line
141: * with appropriate positioning.
142: */
143: if (state == ONEOPEN) {
144: WCOLS = OCOLUMNS;
145: if (vdepth() > 1) {
146: WCOLS = TUBECOLS;
147: sethard();
148: } else
149: WCOLS = TUBECOLS;
150: } else if (state == HARDOPEN)
151: sethard();
152:
153: /*
154: * Unless we filled (completely) the last line we typed on,
155: * we have to clear to the end of the line
156: * in case stuff is left from before.
157: */
158: if (vp->vliny + d > destline) {
159: if (IN && destcol == WCOLS)
160: vigoto(vp->vliny + d - 1, 0);
161: vclreol();
162: }
163: return (d);
164: }
165:
166: /*
167: * Real work for winning growing of window at top
168: * when inserting in the middle of a partially full
169: * screen on an intelligent terminal. We have as argument
170: * the logical line number to be inserted after, and the offset
171: * from that line where the insert will go.
172: * We look at the picture of depths and positions, and if we can
173: * delete some (blank) lines from the top of the screen so that
174: * later inserts will not push stuff off the bottom.
175: */
176: vglitchup(l, o)
177: int l, o;
178: {
179: register struct vlinfo *vp = &vlinfo[l];
180: register int need;
181: register int p = vp->vliny;
182: short oldhold, oldheldech;
183: bool glitched = 0;
184:
185: if (l < vcnt - 1) {
186: need = p + vp->vdepth - (vp+1)->vliny;
187: if (need > 0) {
188: if (state == VISUAL && WTOP - ZERO >= need && AL && DL) {
189: glitched++;
190: WTOP -= need;
191: WLINES = WBOT - WTOP + 1;
192: p -= need;
193: if (p + o == WTOP) {
194: vp->vliny = WTOP;
195: return (WTOP + o);
196: }
197: vdellin(WTOP, need, -1);
198: oldheldech = heldech;
199: oldhold = hold;
200: hold |= HOLDECH;
201: }
202: vinslin((vp+1)->vliny, need, l);
203: if (glitched) {
204: hold = oldhold;
205: heldech = oldheldech;
206: }
207: }
208: } else
209: vp[1].vliny = vp[0].vliny + vp->vdepth;
210: return (p + o);
211: }
212:
213: /*
214: * Insert cnt blank lines before line p,
215: * logically and (if supported) physically.
216: */
217: vinslin(p, cnt, l)
218: register int p, cnt;
219: int l;
220: {
221: register int i;
222: bool could = 1;
223:
224: #ifdef ADEBUG
225: if (trace)
226: tfixnl(), fprintf(trace, "vinslin(%d, %d, %d)\n", p, cnt, l);
227: #endif
228: if (p + cnt > WBOT && CD) {
229: /*
230: * Really quick -- clear to end of screen.
231: */
232: cnt = WECHO + 1 - p;
233: vgoto(p, 0), vputp(CD, cnt);
234: vclrech(1);
235: vadjAL(p, cnt);
236: } else if (AL) {
237: /*
238: * Use insert line.
239: */
240: vgoto(p, 0), vputp(AL, WECHO + 1 - p);
241: for (i = cnt - 1; i > 0; i--) {
242: vgoto(outline+1, 0), vputp(AL, WECHO + 1 - outline);
243: if ((hold & HOLDAT) == 0)
244: putchar('@');
245: }
246: vadjAL(p, cnt);
247: } else if (SR && p == WTOP) {
248: /*
249: * Use reverse scroll mode of the terminal, at
250: * the top of the window.
251: */
252: for (i = cnt; i > 0; i--) {
253: vgoto(p, 0), vputp(SR, 0);
254: if (i > 1 && (hold & HOLDAT) == 0)
255: putchar('@');
256: /*
257: * If we are at the top of the screen, and the
258: * terminal retains display above, then we
259: * should try to clear to end of line.
260: * Have to use CE since we don't remember what is
261: * actually on the line.
262: */
263: if (CE && (DA || p != 0))
264: vputp(CE, 1);
265: }
266: vadjAL(p, cnt);
267: } else
268: could = 0;
269: vopenup(cnt, could, l);
270: }
271:
272: /*
273: * Logically open up after line l, cnt of them.
274: * We need to know if it was done ``physically'' since in this
275: * case we accept what the hardware gives us. If we have to do
276: * it ourselves (brute force) we will squish out @ lines in the process
277: * if this will save us work.
278: */
279: vopenup(cnt, could, l)
280: int cnt;
281: bool could;
282: {
283: register struct vlinfo *vc = &vlinfo[l + 1];
284: register struct vlinfo *ve = &vlinfo[vcnt];
285:
286: #ifdef ADEBUG
287: if (trace)
288: tfixnl(), fprintf(trace, "vopenup(%d, %d, %d)\n", cnt, could, l);
289: #endif
290: if (could)
291: /*
292: * This will push @ lines down the screen,
293: * just as the hardware did. Since the default
294: * for intelligent terminals is to never have @
295: * lines on the screen, this should never happen,
296: * and the code makes no special effort to be nice in this
297: * case, e.g. squishing out the @ lines by delete lines
298: * before doing append lines.
299: */
300: for (; vc <= ve; vc++)
301: vc->vliny += cnt;
302: else {
303: /*
304: * Will have to clean up brute force eventually,
305: * so push the line data around as little as possible.
306: */
307: vc->vliny += cnt, vc->vflags |= VDIRT;
308: while (vc < ve) {
309: register int i = vc->vliny + vc->vdepth;
310:
311: vc++;
312: if (i <= vc->vliny)
313: break;
314: vc->vliny = i, vc->vflags |= VDIRT;
315: }
316: }
317: vscrap();
318: }
319:
320: /*
321: * Adjust data structure internally to account for insertion of
322: * blank lines on the screen.
323: */
324: vadjAL(p, cnt)
325: int p, cnt;
326: {
327: char *tlines[TUBELINES];
328: register int from, to;
329:
330: #ifdef ADEBUG
331: if (trace)
332: tfixnl(), fprintf(trace, "vadjal(%d, %d)\n", p, cnt);
333: #endif
334: copy(tlines, vtube, sizeof vtube); /*SASSIGN*/
335: for (from = p, to = p + cnt; to <= WECHO; from++, to++)
336: vtube[to] = tlines[from];
337: for (to = p; from <= WECHO; from++, to++) {
338: vtube[to] = tlines[from];
339: vclrbyte(vtube[to], WCOLS);
340: }
341: /*
342: * Have to clear the echo area since its contents aren't
343: * necessarily consistent with the rest of the display.
344: */
345: vclrech(0);
346: }
347:
348: /*
349: * Roll the screen up logically and physically
350: * so that line dl is the bottom line on the screen.
351: */
352: vrollup(dl)
353: int dl;
354: {
355: register int cnt;
356: register int dc = destcol;
357:
358: #ifdef ADEBUG
359: if (trace)
360: tfixnl(), fprintf(trace, "vrollup(%d)\n", dl);
361: #endif
362: cnt = dl - (splitw ? WECHO : WBOT);
363: if (splitw && (state == VISUAL || state == CRTOPEN))
364: holdupd = 1;
365: vscroll(cnt);
366: vmoveitup(cnt, 1);
367: destline = dl - cnt, destcol = dc;
368: }
369:
370: vup1()
371: {
372:
373: vrollup(WBOT + 1);
374: }
375:
376: /*
377: * Scroll the screen up cnt lines physically.
378: * If doclr is true, do a clear eol if the terminal
379: * has standout (to prevent it from scrolling up)
380: */
381: vmoveitup(cnt, doclr)
382: register int cnt;
383: bool doclr;
384: {
385:
386: if (cnt == 0)
387: return;
388: #ifdef ADEBUG
389: if (trace)
390: tfixnl(), fprintf(trace, "vmoveitup(%d)\n", cnt);
391: #endif
392: if (doclr && (SO || SE))
393: vclrech(0);
394: if (SF) {
395: while (cnt > 0)
396: vputp(SF, 0), cnt--;
397: return;
398: }
399: destline = WECHO + cnt;
400: destcol = (NONL ? 0 : outcol % WCOLS);
401: fgoto();
402: if (state == ONEOPEN || state == HARDOPEN) {
403: outline = destline = 0;
404: vclrbyte(vtube[0], WCOLS);
405: }
406: }
407:
408: /*
409: * Scroll the screen up cnt lines logically.
410: */
411: vscroll(cnt)
412: register int cnt;
413: {
414: register int from, to;
415: char *tlines[TUBELINES];
416:
417: #ifdef ADEBUG
418: if (trace)
419: fprintf(trace, "vscroll(%d)\n", cnt);
420: #endif
421: if (cnt < 0 || cnt > TUBELINES)
422: error("Internal error: vscroll");
423: if (cnt == 0)
424: return;
425: copy(tlines, vtube, sizeof vtube);
426: for (to = ZERO, from = ZERO + cnt; to <= WECHO - cnt; to++, from++)
427: vtube[to] = tlines[from];
428: for (from = ZERO; to <= WECHO; to++, from++) {
429: vtube[to] = tlines[from];
430: vclrbyte(vtube[to], WCOLS);
431: }
432: for (from = 0; from <= vcnt; from++)
433: LINE(from) -= cnt;
434: }
435:
436: /*
437: * Discard logical lines due to physical wandering off the screen.
438: */
439: vscrap()
440: {
441: register int i, j;
442:
443: #ifdef ADEBUG
444: if (trace)
445: tfixnl(), fprintf(trace, "vscrap\n"), tvliny();
446: #endif
447: if (splitw)
448: return;
449: if (vcnt && WBOT != WECHO && LINE(0) < WTOP && LINE(0) >= ZERO) {
450: WTOP = LINE(0);
451: WLINES = WBOT - WTOP + 1;
452: }
453: for (j = 0; j < vcnt; j++)
454: if (LINE(j) >= WTOP) {
455: if (j == 0)
456: break;
457: /*
458: * Discard the first j physical lines off the top.
459: */
460: vcnt -= j, vcline -= j;
461: for (i = 0; i <= vcnt; i++)
462: vlcopy(vlinfo[i], vlinfo[i + j]);
463: break;
464: }
465: /*
466: * Discard lines off the bottom.
467: */
468: if (vcnt) {
469: for (j = 0; j <= vcnt; j++)
470: if (LINE(j) > WBOT || LINE(j) + DEPTH(j) - 1 > WBOT) {
471: vcnt = j;
472: break;
473: }
474: LASTLINE = LINE(vcnt-1) + DEPTH(vcnt-1);
475: }
476: #ifdef ADEBUG
477: if (trace)
478: tvliny();
479: #endif
480: /*
481: * May have no lines!
482: */
483: }
484:
485: /*
486: * Repaint the screen, with cursor at curs, aftern an arbitrary change.
487: * Handle notification on large changes.
488: */
489: vrepaint(curs)
490: char *curs;
491: {
492:
493: wdot = NOLINE;
494: /*
495: * In open want to notify first.
496: */
497: noteit(0);
498: vscrap();
499:
500: /*
501: * Deal with a totally useless display.
502: */
503: if (vcnt == 0 || vcline < 0 || vcline > vcnt || holdupd && state != VISUAL) {
504: register line *odol = dol;
505:
506: vcnt = 0;
507: if (holdupd)
508: if (state == VISUAL)
509: ignore(peekkey());
510: else
511: vup1();
512: holdupd = 0;
513: if (odol == zero)
514: fixzero();
515: vcontext(dot, '.');
516: noteit(1);
517: if (noteit(1) == 0 && odol == zero) {
518: CATCH
519: error("No lines in buffer");
520: ENDCATCH
521: linebuf[0] = 0;
522: splitw = 0;
523: }
524: vnline(curs);
525: return;
526: }
527:
528: /*
529: * Have some useful displayed text; refresh it.
530: */
531: getDOT();
532:
533: /*
534: * This is for boundary conditions in open mode.
535: */
536: if (FLAGS(0) & VDIRT)
537: vsync(WTOP);
538:
539: /*
540: * If the current line is after the last displayed line
541: * or the bottom of the screen, then special effort is needed
542: * to get it on the screen. We first try a redraw at the
543: * last line on the screen, hoping it will fill in where @
544: * lines are now. If this doesn't work, then roll it onto
545: * the screen.
546: */
547: if (vcline >= vcnt || LINE(vcline) > WBOT) {
548: short oldhold = hold;
549: hold |= HOLDAT, vredraw(LASTLINE), hold = oldhold;
550: if (vcline >= vcnt) {
551: register int i = vcline - vcnt + 1;
552:
553: dot -= i;
554: vcline -= i;
555: vroll(i);
556: } else
557: vsyncCL();
558: } else
559: vsync(vcline > 0 ? LINE(vcline - 1) : WTOP);
560:
561: /*
562: * Notification on large change for visual
563: * has to be done last or we may lose
564: * the echo area with redisplay.
565: */
566: noteit(1);
567:
568: /*
569: * Finally. Move the cursor onto the current line.
570: */
571: vnline(curs);
572: }
573:
574: /*
575: * Fully cleanup the screen, leaving no @ lines except at end when
576: * line after last won't completely fit. The routine vsync is
577: * more conservative and much less work on dumb terminals.
578: */
579: vredraw(p)
580: register int p;
581: {
582: register int l;
583: register line *tp;
584: char temp[LBSIZE];
585: bool anydl = 0;
586: short oldhold = hold;
587:
588: #ifdef ADEBUG
589: if (trace)
590: tfixnl(), fprintf(trace, "vredraw(%d)\n", p), tvliny();
591: #endif
592: if (holdupd) {
593: holdupd = 3;
594: return;
595: }
596: if (state == HARDOPEN || splitw)
597: return;
598: if (p < 0 /* || p > WECHO */)
599: error("Internal error: vredraw");
600:
601: /*
602: * Trim the ragged edges (lines which are off the screen but
603: * not yet logically discarded), save the current line, and
604: * search for first logical line affected by the redraw.
605: */
606: vscrap();
607: CP(temp, linebuf);
608: l = 0;
609: tp = dot - vcline;
610: if (vcnt == 0)
611: LINE(0) = WTOP;
612: while (l < vcnt && LINE(l) < p)
613: l++, tp++;
614:
615: /*
616: * We hold off echo area clearing during the redraw in deference
617: * to a final clear of the echo area at the end if appropriate.
618: */
619: heldech = 0;
620: hold |= HOLDECH;
621: for (; l < vcnt && Peekkey != ATTN; l++) {
622: if (l == vcline)
623: strcLIN(temp);
624: else
625: getline(*tp);
626:
627: /*
628: * Delete junk between displayed lines.
629: */
630: if (LINE(l) != LINE(l + 1) && LINE(l) != p) {
631: if (anydl == 0 && DB && CD) {
632: hold = oldhold;
633: vclrech(0);
634: anydl = 1;
635: hold |= HOLDECH;
636: heldech = 0;
637: }
638: vdellin(p, LINE(l) - p, l);
639: }
640:
641: /*
642: * If line image is not know to be up to date, then
643: * redisplay it; else just skip onward.
644: */
645: LINE(l) = p;
646: if (FLAGS(l) & VDIRT) {
647: DEPTH(l) = vdepth();
648: if (l != vcline && p + DEPTH(l) - 1 > WBOT) {
649: vscrap();
650: break;
651: }
652: FLAGS(l) &= ~VDIRT;
653: vreopen(p, lineno(tp), l);
654: p = LINE(l) + DEPTH(l);
655: } else
656: p += DEPTH(l);
657: tp++;
658: }
659:
660: /*
661: * That takes care of lines which were already partially displayed.
662: * Now try to fill the rest of the screen with text.
663: */
664: if (state == VISUAL && p <= WBOT) {
665: int ovcline = vcline;
666:
667: vcline = l;
668: for (; tp <= dol && Peekkey != ATTN; tp++) {
669: getline(*tp);
670: if (p + vdepth() - 1 > WBOT)
671: break;
672: vopen(tp, p);
673: p += DEPTH(vcline);
674: vcline++;
675: }
676: vcline = ovcline;
677: }
678:
679: /*
680: * Thats all the text we can get on.
681: * Now rest of lines (if any) get either a ~ if they
682: * are past end of file, or an @ if the next line won't fit.
683: */
684: for (; p <= WBOT && Peekkey != ATTN; p++)
685: vclrlin(p, tp);
686: strcLIN(temp);
687: hold = oldhold;
688: if (heldech)
689: vclrech(0);
690: #ifdef ADEBUG
691: if (trace)
692: tvliny();
693: #endif
694: }
695:
696: /*
697: * Do the real work in deleting cnt lines starting at line p from
698: * the display. First affected line is line l.
699: */
700: vdellin(p, cnt, l)
701: int p, cnt, l;
702: {
703: register int i;
704:
705: if (cnt == 0)
706: return;
707: if (DL == NOSTR || cnt < 0) {
708: /*
709: * Can't do it; just remember that line l is munged.
710: */
711: FLAGS(l) |= VDIRT;
712: return;
713: }
714: #ifdef ADEBUG
715: if (trace)
716: tfixnl(), fprintf(trace, "vdellin(%d, %d, %d)\n", p, cnt, l);
717: #endif
718: /*
719: * Send the deletes to the screen and then adjust logical
720: * and physical internal data structures.
721: */
722: vgoto(p, 0);
723: for (i = 0; i < cnt; i++)
724: vputp(DL, WECHO - p);
725: vadjDL(p, cnt);
726: vcloseup(l, cnt);
727: }
728: /*
729: * Adjust internal physical screen image to account for deleted lines.
730: */
731: vadjDL(p, cnt)
732: int p, cnt;
733: {
734: char *tlines[TUBELINES];
735: register int from, to;
736:
737: #ifdef ADEBUG
738: if (trace)
739: tfixnl(), fprintf(trace, "vadjDL(%d, %d)\n", p, cnt);
740: #endif
741: /*
742: * Would like to use structured assignment but early
743: * v7 compiler (released with phototypesetter for v6)
744: * can't hack it.
745: */
746: copy(tlines, vtube, sizeof vtube); /*SASSIGN*/
747: for (from = p + cnt, to = p; from <= WECHO; from++, to++)
748: vtube[to] = tlines[from];
749: for (from = p; to <= WECHO; from++, to++) {
750: vtube[to] = tlines[from];
751: vclrbyte(vtube[to], WCOLS);
752: }
753: }
754: /*
755: * Sync the screen, like redraw but more lazy and willing to leave
756: * @ lines on the screen. VsyncCL syncs starting at the current line.
757: * In any case, if the redraw option is set then all syncs map to redraws
758: * as if vsync didn't exist.
759: */
760: vsyncCL()
761: {
762:
763: vsync(LINE(vcline));
764: }
765:
766: vsync(p)
767: register int p;
768: {
769:
770: if (value(REDRAW))
771: vredraw(p);
772: else
773: vsync1(p);
774: }
775:
776: /*
777: * The guts of a sync. Similar to redraw but
778: * just less ambitous.
779: */
780: vsync1(p)
781: register int p;
782: {
783: register int l;
784: char temp[LBSIZE];
785: register struct vlinfo *vp = &vlinfo[0];
786: short oldhold = hold;
787:
788: #ifdef ADEBUG
789: if (trace)
790: tfixnl(), fprintf(trace, "vsync1(%d)\n", p), tvliny();
791: #endif
792: if (holdupd) {
793: if (holdupd < 3)
794: holdupd = 2;
795: return;
796: }
797: if (state == HARDOPEN || splitw)
798: return;
799: vscrap();
800: CP(temp, linebuf);
801: if (vcnt == 0)
802: LINE(0) = WTOP;
803: l = 0;
804: while (l < vcnt && vp->vliny < p)
805: l++, vp++;
806: heldech = 0;
807: hold |= HOLDECH;
808: while (p <= WBOT && Peekkey != ATTN) {
809: /*
810: * Want to put a line here if not in visual and first line
811: * or if there are lies left and this line starts before
812: * the current line, or if this line is piled under the
813: * next line (vreplace does this and we undo it).
814: */
815: if (l == 0 && state != VISUAL ||
816: (l < vcnt && (vp->vliny <= p || vp[0].vliny == vp[1].vliny))) {
817: if (l == 0 || vp->vliny < p || (vp->vflags & VDIRT)) {
818: if (l == vcline)
819: strcLIN(temp);
820: else
821: getline(dot[l - vcline]);
822: /*
823: * Be careful that a long line doesn't cause the
824: * screen to shoot up.
825: */
826: if (l != vcline && (vp->vflags & VDIRT)) {
827: vp->vdepth = vdepth();
828: vp->vflags &= ~VDIRT;
829: if (p + vp->vdepth - 1 > WBOT)
830: break;
831: }
832: vreopen(p, lineDOT() + (l - vcline), l);
833: }
834: p = vp->vliny + vp->vdepth;
835: vp++;
836: l++;
837: } else
838: /*
839: * A physical line between logical lines,
840: * so we settle for an @ at the beginning.
841: */
842: vclrlin(p, dot + (l - vcline)), p++;
843: }
844: strcLIN(temp);
845: hold = oldhold;
846: if (heldech)
847: vclrech(0);
848: }
849:
850: /*
851: * Subtract (logically) cnt physical lines from the
852: * displayed position of lines starting with line l.
853: */
854: vcloseup(l, cnt)
855: int l;
856: register int cnt;
857: {
858: register int i;
859:
860: #ifdef ADEBUG
861: if (trace)
862: tfixnl(), fprintf(trace, "vcloseup(%d, %d)\n", l, cnt);
863: #endif
864: for (i = l + 1; i <= vcnt; i++)
865: LINE(i) -= cnt;
866: }
867:
868: /*
869: * Workhorse for rearranging line descriptors on changes.
870: * The idea here is that, starting with line l, cnt lines
871: * have been replaced with newcnt lines. All of these may
872: * be ridiculous, i.e. l may be -1000, cnt 50 and newcnt 0,
873: * since we may be called from an undo after the screen has
874: * moved a lot. Thus we have to be careful.
875: *
876: * Many boundary conditions here.
877: */
878: vreplace(l, cnt, newcnt)
879: int l, cnt, newcnt;
880: {
881: register int from, to, i;
882: bool savenote = 0;
883:
884: #ifdef ADEBUG
885: if (trace) {
886: tfixnl(), fprintf(trace, "vreplace(%d, %d, %d)\n", l, cnt, newcnt);
887: tvliny();
888: }
889: #endif
890: if (l >= vcnt)
891: return;
892: if (l < 0) {
893: if (l + cnt < 0) {
894: /*
895: * Nothing on the screen is relevant.
896: * Settle for redrawing from scratch (later).
897: */
898: vcnt = 0;
899: return;
900: }
901: /*
902: * Normalize l to top of screen; the add is
903: * really a subtract from cnt since l is negative.
904: */
905: cnt += l;
906: l = 0;
907:
908: /*
909: * Unseen lines were affect so notify (later).
910: */
911: savenote++;
912: }
913:
914: /*
915: * These shouldn't happen
916: * but would cause great havoc.
917: */
918: if (cnt < 0)
919: cnt = 0;
920: if (newcnt < 0)
921: newcnt = 0;
922:
923: /*
924: * Surely worthy of note if more than report
925: * lines were changed.
926: */
927: if (cnt > value(REPORT) || newcnt > value(REPORT))
928: savenote++;
929:
930: /*
931: * Same number of lines affeted as on screen, and we
932: * can insert and delete lines. Thus we just type
933: * over them, since otherwise we will push them
934: * slowly off the screen, a clear lose.
935: */
936: if (cnt == newcnt || vcnt - l == newcnt && AL && DL) {
937: if (cnt > 1 && l + cnt > vcnt)
938: savenote++;
939: vdirty(l, newcnt);
940: } else {
941: /*
942: * Lines are going away, squish them out.
943: */
944: if (cnt > 0) {
945: /*
946: * If non-displayed lines went away,
947: * always notify.
948: */
949: if (cnt > 1 && l + cnt > vcnt)
950: savenote++;
951: if (l + cnt >= vcnt)
952: cnt = vcnt - l;
953: else
954: for (from = l + cnt, to = l; from <= vcnt; to++, from++)
955: vlcopy(vlinfo[to], vlinfo[from]);
956: vcnt -= cnt;
957: }
958: /*
959: * Open up space for new lines appearing.
960: * All new lines are piled in the same place,
961: * and will be unpiled by vredraw/vsync, which
962: * inserts lines in front as it unpiles.
963: */
964: if (newcnt > 0) {
965: /*
966: * Newlines are appearing which may not show,
967: * so notify (this is only approximately correct
968: * when long lines are present).
969: */
970: if (newcnt > 1 && l + newcnt > vcnt + 1)
971: savenote++;
972:
973: /*
974: * If there will be more lines than fit, then
975: * just throw way the rest of the stuff on the screen.
976: */
977: if (l + newcnt > WBOT && AL && DL) {
978: vcnt = l;
979: goto skip;
980: }
981: from = vcnt, to = vcnt + newcnt;
982: i = TUBELINES - to;
983: if (i < 0)
984: from += i, to += i;
985: vcnt = to;
986: for (; from >= l; from--, to--)
987: vlcopy(vlinfo[to], vlinfo[from]);
988: for (from = to + 1, to = l; to < l + newcnt && to <= WBOT + 1; to++) {
989: LINE(to) = LINE(from);
990: DEPTH(to) = 0;
991: FLAGS(to) = VDIRT;
992: }
993: }
994: }
995: skip:
996: if (Pline == numbline && cnt != newcnt)
997: /*
998: * When lines positions are shifted, the numbers
999: * will be wrong.
1000: */
1001: vdirty(l, WECHO);
1002: if (!savenote)
1003: notecnt = 0;
1004: #ifdef ADEBUG
1005: if (trace)
1006: tvliny();
1007: #endif
1008: }
1009:
1010: /*
1011: * Start harcopy open.
1012: * Print an image of the line to the left of the cursor
1013: * under the full print of the line and position the cursor.
1014: * If we are in a scroll ^D within hardcopy open then all this
1015: * is suppressed.
1016: */
1017: sethard()
1018: {
1019:
1020: if (state == VISUAL)
1021: return;
1022: rubble = 0;
1023: state = HARDOPEN;
1024: if (hold & HOLDROL)
1025: return;
1026: vup1();
1027: LINE(0) = WBOT;
1028: if (Pline == numbline)
1029: vgoto(WBOT, 0), printf("%6d ", lineDOT());
1030: }
1031:
1032: /*
1033: * Mark the lines starting at base for i lines
1034: * as dirty so that they will be checked for correct
1035: * display at next sync/redraw.
1036: */
1037: vdirty(base, i)
1038: register int base, i;
1039: {
1040: register int l;
1041:
1042: for (l = base; l < vcnt; l++) {
1043: if (--i < 0)
1044: return;
1045: FLAGS(l) |= VDIRT;
1046: }
1047: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.