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