![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to redraw.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / g / usr / bin / vi|
Return to redraw.c CVS log | Up to [MW Coherent from dump] / coherent / g / usr / bin / vi |
1.1 root 1: /* redraw.c */
2:
3: /* Author:
4: * Steve Kirkendall
5: * 14407 SW Teal Blvd. #C
6: * Beaverton, OR 97005
7: * [email protected]
8: */
9:
10:
11: /* This file contains functions that draw text on the screen. The major entry
12: * points are:
13: * redrawrange() - called from modify.c to give hints about what parts
14: * of the screen need to be redrawn.
15: * redraw() - redraws the screen (or part of it) and positions
16: * the cursor where it belongs.
17: * idx2col() - converts a markidx() value to a logical column number.
18: */
19:
20: #include "config.h"
21: #include "vi.h"
22: #ifdef CRUNCH
23: # define NEAR LINES
24: #else
25: # define NEAR (*o_nearscroll&0xff)
26: #endif
27:
28: /* This variable contains the line number that smartdrawtext() knows best */
29: static long smartlno;
30:
31: /* This function remembers where changes were made, so that the screen can be
32: * redraw in a more efficient manner.
33: */
34: static long redrawafter; /* line# of first line that must be redrawn */
35: static long preredraw; /* line# of last line changed, before change */
36: static long postredraw; /* line# of last line changed, after change */
37: static int mustredraw; /* boolean: anything forcing a screen update? */
38: void redrawrange(after, pre, post)
39: long after; /* lower bound of redrawafter */
40: long pre; /* upper bound of preredraw */
41: long post; /* upper bound of postredraw */
42: {
43: if (after == redrawafter)
44: {
45: /* multiple insertions/deletions at the same place -- combine
46: * them
47: */
48: preredraw -= (post - pre);
49: if (postredraw < post)
50: {
51: preredraw += (post - postredraw);
52: postredraw = post;
53: }
54: if (redrawafter > preredraw)
55: {
56: redrawafter = preredraw;
57: }
58: if (redrawafter < 1L)
59: {
60: redrawafter = 0L;
61: preredraw = postredraw = INFINITY;
62: }
63: }
64: else if (postredraw > 0L)
65: {
66: /* multiple changes in different places -- redraw everything
67: * after "after".
68: */
69: postredraw = preredraw = INFINITY;
70: if (after < redrawafter)
71: redrawafter = after;
72: }
73: else
74: {
75: /* first change */
76: redrawafter = after;
77: preredraw = pre;
78: postredraw = post;
79: }
80: mustredraw = TRUE;
81: }
82:
83:
84: #ifndef NO_CHARATTR
85: /* see if a given line uses character attribute strings */
86: static int hasattr(lno, text)
87: long lno; /* the line# of the cursor */
88: REG char *text; /* the text of the line, from fetchline */
89: {
90: static long plno; /* previous line number */
91: static long chgs; /* previous value of changes counter */
92: static int panswer;/* previous answer */
93: char *scan;
94:
95: /* if charattr is off, then the answer is "no, it doesn't" */
96: if (!*o_charattr)
97: {
98: chgs = 0; /* <- forces us to check if charattr is later set */
99: return FALSE;
100: }
101:
102: /* if we already know the answer, return it... */
103: if (lno == plno && chgs == changes)
104: {
105: return panswer;
106: }
107:
108: /* get the line & look for "\fX" */
109: if (!text[0] || !text[1] || !text[2])
110: {
111: panswer = FALSE;
112: }
113: else
114: {
115: for (scan = text; scan[2] && !(scan[0] == '\\' && scan[1] == 'f'); scan++)
116: {
117: }
118: panswer = (scan[2] != '\0');
119: }
120:
121: /* save the results */
122: plno = lno;
123: chgs = changes;
124:
125: /* return the results */
126: return panswer;
127: }
128: #endif
129:
130:
131: #ifndef NO_VISIBLE
132: /* This function checks to make sure that the correct lines are shown in
133: * reverse-video. This is used to handle the "v" and "V" commands.
134: */
135: static long vizlow, vizhigh; /* the starting and ending lines */
136: static int vizleft, vizright; /* starting & ending indicies */
137: static int vizchange; /* boolean: must use stupid drawtext? */
138: static void setviz(curs)
139: MARK curs;
140: {
141: long newlow, newhigh;
142: long extra = 0L;
143:
144: /* for now, assume the worst... */
145: vizchange = TRUE;
146:
147: /* set newlow & newhigh according to V_from and cursor */
148: if (!V_from)
149: {
150: /* no lines should have reverse-video */
151: if (vizlow)
152: {
153: redrawrange(vizlow, vizhigh + 1L, vizhigh + 1L);
154: vizlow = vizhigh = 0L;
155: }
156: else
157: {
158: vizchange = FALSE;
159: }
160: return;
161: }
162:
163: /* figure out which lines *SHOULD* have hilites */
164: if (V_from < curs)
165: {
166: newlow = markline(V_from);
167: newhigh = markline(curs);
168: vizleft = markidx(V_from);
169: vizright = markidx(curs) + 1;
170: }
171: else
172: {
173: newlow = markline(curs);
174: newhigh = markline(V_from);
175: vizleft = markidx(curs);
176: vizright = markidx(V_from) + 1;
177: }
178:
179: /* adjust for line-mode hiliting */
180: if (V_linemd)
181: {
182: vizleft = 0;
183: vizright = BLKSIZE - 1;
184: }
185: else
186: {
187: extra = 1L;
188: }
189:
190: /* arrange for the necessary lines to be redrawn */
191: if (vizlow == 0L)
192: {
193: /* just starting to redraw */
194: redrawrange(newlow, newhigh, newhigh);
195: }
196: else
197: {
198: /* Were new lines added/removed at the front? */
199: if (newlow != vizlow)
200: {
201: if (newlow < vizlow)
202: redrawrange(newlow, vizlow + extra, vizlow + extra);
203: else
204: redrawrange(vizlow, newlow + extra, newlow + extra);
205: }
206:
207: /* Were new lines added/removed at the back? */
208: if (newhigh != vizhigh)
209: {
210: if (newhigh < vizhigh)
211: redrawrange(newhigh + 1L - extra, vizhigh + 1L, vizhigh + 1L);
212: else
213: redrawrange(vizhigh + 1L - extra, newhigh, newhigh);
214: }
215: }
216:
217: /* remember which lines will contain hilighted text now */
218: vizlow = newlow;
219: vizhigh = newhigh;
220: }
221: #endif /* !NO_VISIBLE */
222:
223:
224: /* This function converts a MARK to a column number. It doesn't automatically
225: * adjust for leftcol; that must be done by the calling function
226: */
227: int idx2col(curs, text, inputting)
228: MARK curs; /* the line# & index# of the cursor */
229: REG char *text; /* the text of the line, from fetchline */
230: int inputting; /* boolean: called from input() ? */
231: {
232: static MARK pcursor;/* previous cursor, for possible shortcut */
233: static MARK pcol; /* column number for pcol */
234: static long chgs; /* previous value of changes counter */
235: REG int col; /* used to count column numbers */
236: REG int idx; /* used to count down the index */
237: REG int i;
238:
239: /* for now, assume we have to start counting at the left edge */
240: col = 0;
241: idx = markidx(curs);
242:
243: /* if the file hasn't changed & line number is the same & it has no
244: * embedded character attribute strings, can we do shortcuts?
245: */
246: if (chgs == changes
247: && !((curs ^ pcursor) & ~(BLKSIZE - 1))
248: #ifndef NO_CHARATTR
249: && !hasattr(markline(curs), text)
250: #endif
251: )
252: {
253: /* no movement? */
254: if (curs == pcursor)
255: {
256: /* return the column of the char; for tabs, return its last column */
257: if (text[idx] == '\t' && !inputting && !*o_list)
258: {
259: return pcol + *o_tabstop - (pcol % *o_tabstop) - 1;
260: }
261: else
262: {
263: return pcol;
264: }
265: }
266:
267: /* movement to right? */
268: if (curs > pcursor)
269: {
270: /* start counting from previous place */
271: col = pcol;
272: idx = markidx(curs) - markidx(pcursor);
273: text += markidx(pcursor);
274: }
275: }
276:
277: /* count over to the char after the idx position */
278: while (idx > 0 && (i = *text)) /* yes, ASSIGNMENT! */
279: {
280: if (i == '\t' && !*o_list)
281: {
282: col += *o_tabstop;
283: col -= col % *o_tabstop;
284: }
285: else if (i >= '\0' && i < ' ' || i == '\177')
286: {
287: col += 2;
288: }
289: #ifndef NO_CHARATTR
290: else if (i == '\\' && text[1] == 'f' && text[2] && *o_charattr)
291: {
292: text += 2; /* plus one more at bottom of loop */
293: idx -= 2;
294: }
295: #endif
296: else
297: {
298: col++;
299: }
300: text++;
301: idx--;
302: }
303:
304: /* save stuff to speed next call */
305: pcursor = curs;
306: pcol = col;
307: chgs = changes;
308:
309: /* return the column of the char; for tabs, return its last column */
310: if (*text == '\t' && !inputting && !*o_list)
311: {
312: return col + *o_tabstop - (col % *o_tabstop) - 1;
313: }
314: else
315: {
316: return col;
317: }
318: }
319:
320:
321: /* This function is similar to idx2col except that it takes care of sideways
322: * scrolling - for the given line, at least.
323: */
324: int mark2phys(m, text, inputting)
325: MARK m; /* a mark to convert */
326: char *text; /* the line that m refers to */
327: int inputting; /* boolean: caled from input() ? */
328: {
329: int i;
330:
331: i = idx2col(m, text, inputting);
332: while (i < leftcol)
333: {
334: leftcol -= *o_sidescroll;
335: mustredraw = TRUE;
336: redrawrange(1L, INFINITY, INFINITY);
337: }
338: while (i > rightcol)
339: {
340: leftcol += *o_sidescroll;
341: mustredraw = TRUE;
342: redrawrange(1L, INFINITY, INFINITY);
343: }
344: physrow = markline(m) - topline;
345: physcol = i - leftcol;
346: if (*o_number)
347: physcol += 8;
348:
349: return physcol;
350: }
351:
352: /* This function draws a single line of text on the screen. The screen's
353: * cursor is assumed to be located at the leftmost column of the appropriate
354: * row.
355: */
356: static void drawtext(text, lno, clr)
357: REG char *text; /* the text to draw */
358: long lno; /* the number of the line to draw */
359: int clr; /* boolean: do a clrtoeol? */
360: {
361: REG int col; /* column number */
362: REG int i;
363: REG int tabstop; /* *o_tabstop */
364: REG int limitcol; /* leftcol or leftcol + COLS */
365: int abnormal; /* boolean: charattr != A_NORMAL? */
366: #ifndef NO_VISIBLE
367: int rev; /* boolean: standout mode, too? */
368: int idx = 0;
369: #endif
370: char numstr[9];
371:
372: /* show the line number, if necessary */
373: if (*o_number)
374: {
375: sprintf(numstr, "%6ld ", lno);
376: qaddstr(numstr);
377: }
378:
379: #ifndef NO_SENTENCE
380: /* if we're hiding format lines, and this is one of them, then hide it */
381: if (*o_hideformat && *text == '.')
382: {
383: clrtoeol();
384: #if OSK
385: qaddch('\l');
386: #else
387: qaddch('\n');
388: #endif
389: return;
390: }
391: #endif
392:
393: /* move some things into registers... */
394: limitcol = leftcol;
395: tabstop = *o_tabstop;
396: abnormal = FALSE;
397:
398: #ifndef CRUNCH
399: if (clr)
400: clrtoeol();
401: #endif
402:
403: /* skip stuff that was scrolled off left edge */
404: for (col = 0;
405: (i = *text) && col < limitcol; /* yes, ASSIGNMENT! */
406: text++)
407: {
408: #ifndef NO_VISIBLE
409: idx++;
410: #endif
411: if (i == '\t' && !*o_list)
412: {
413: col = col + tabstop - (col % tabstop);
414: }
415: else if (i >= 0 && i < ' ' || i == '\177')
416: {
417: col += 2;
418: }
419: #ifndef NO_CHARATTR
420: else if (i == '\\' && text[1] == 'f' && text[2] && *o_charattr)
421: {
422: text += 2; /* plus one more as part of "for" loop */
423:
424: /* since this attribute might carry over, we need it */
425: switch (*text)
426: {
427: case 'R':
428: case 'P':
429: attrset(A_NORMAL);
430: abnormal = FALSE;
431: break;
432:
433: case 'B':
434: attrset(A_BOLD);
435: abnormal = TRUE;
436: break;
437:
438: case 'U':
439: attrset(A_UNDERLINE);
440: abnormal = TRUE;
441: break;
442:
443: case 'I':
444: attrset(A_ALTCHARSET);
445: abnormal = TRUE;
446: break;
447: }
448: }
449: #endif
450: else
451: {
452: col++;
453: }
454: }
455:
456: #ifndef NO_VISIBLE
457: /* Should we start hiliting at the first char of this line? */
458: if ((lno > vizlow && lno <= vizhigh
459: || lno == vizlow && vizleft < idx)
460: && !(lno == vizhigh && vizright < idx))
461: {
462: do_VISIBLE();
463: rev = TRUE;
464: }
465: #endif
466:
467: /* adjust for control char that was partially visible */
468: while (col > limitcol)
469: {
470: qaddch(' ');
471: limitcol++;
472: }
473:
474: /* now for the visible characters */
475: limitcol = leftcol + COLS;
476: if (*o_number)
477: limitcol -= 8;
478: for (; (i = *text) && col < limitcol; text++)
479: {
480: #ifndef NO_VISIBLE
481: /* maybe turn hilite on/off in the middle of the line */
482: if (lno == vizlow && vizleft == idx)
483: {
484: do_VISIBLE();
485: rev = TRUE;
486: }
487: if (lno == vizhigh && vizright == idx)
488: {
489: do_SE();
490: rev = FALSE;
491: }
492: idx++;
493:
494: /* if hiliting, never emit physical tabs */
495: if (rev && i == '\t' && !*o_list)
496: {
497: i = col + tabstop - (col % tabstop);
498: do
499: {
500: qaddch(' ');
501: col++;
502: } while (col < i && col < limitcol);
503: }
504: else
505: #endif /* !NO_VISIBLE */
506: if (i == '\t' && !*o_list)
507: {
508: i = col + tabstop - (col % tabstop);
509: if (i < limitcol)
510: {
511: #ifdef CRUNCH
512: if (!clr && has_PT && !((i - leftcol) & 7))
513: #else
514: if (has_PT && !((i - leftcol) & 7))
515: #endif
516: {
517: do
518: {
519: qaddch('\t');
520: col += 8; /* not exact! */
521: } while (col < i);
522: col = i; /* NOW it is exact */
523: }
524: else
525: {
526: do
527: {
528: qaddch(' ');
529: col++;
530: } while (col < i && col < limitcol);
531: }
532: }
533: else /* tab ending after screen? next line! */
534: {
535: col = limitcol;
536: if (has_AM)
537: {
538: addch('\n'); /* GB */
539: }
540: }
541: }
542: else if (i >= 0 && i < ' ' || i == '\177')
543: {
544: col += 2;
545: qaddch('^');
546: if (col <= limitcol)
547: {
548: qaddch(i ^ '@');
549: }
550: }
551: #ifndef NO_CHARATTR
552: else if (i == '\\' && text[1] == 'f' && text[2] && *o_charattr)
553: {
554: text += 2; /* plus one more as part of "for" loop */
555: switch (*text)
556: {
557: case 'R':
558: case 'P':
559: attrset(A_NORMAL);
560: abnormal = FALSE;
561: break;
562:
563: case 'B':
564: attrset(A_BOLD);
565: abnormal = TRUE;
566: break;
567:
568: case 'U':
569: attrset(A_UNDERLINE);
570: abnormal = TRUE;
571: break;
572:
573: case 'I':
574: attrset(A_ALTCHARSET);
575: abnormal = TRUE;
576: break;
577: }
578: }
579: #endif
580: else
581: {
582: col++;
583: qaddch(i);
584: }
585: }
586:
587: /* get ready for the next line */
588: #ifndef NO_CHARATTR
589: if (abnormal)
590: {
591: attrset(A_NORMAL);
592: }
593: #endif
594: if (*o_list && col < limitcol)
595: {
596: qaddch('$');
597: col++;
598: }
599:
600: #ifndef NO_VISIBLE
601: /* did we hilite this whole line? If so, STOP! */
602: if (rev)
603: {
604: do_SE();
605: }
606: #endif
607:
608: #ifdef CRUNCH
609: if (clr && col < limitcol)
610: {
611: clrtoeol();
612: }
613: #endif
614: if (!has_AM || col < limitcol)
615: {
616: addch('\n');
617: }
618:
619: wqrefresh();
620: }
621:
622:
623: #ifndef CRUNCH
624: static void nudgecursor(same, scan, new, lno)
625: int same; /* number of chars to be skipped over */
626: char *scan; /* where the same chars end */
627: char *new; /* where the visible part of the line starts */
628: long lno; /* line number of this line */
629: {
630: int col;
631:
632: if (same > 0)
633: {
634: if (same < 5)
635: {
636: /* move the cursor by overwriting */
637: while (same > 0)
638: {
639: qaddch(scan[-same]);
640: same--;
641: }
642: }
643: else
644: {
645: /* move the cursor by calling move() */
646: col = (int)(scan - new);
647: if (*o_number)
648: col += 8;
649: move((int)(lno - topline), col);
650: }
651: }
652: }
653: #endif /* not CRUNCH */
654:
655: /* This function draws a single line of text on the screen, possibly with
656: * some cursor optimization. The cursor is repositioned before drawing
657: * begins, so its position before doesn't really matter.
658: */
659: static void smartdrawtext(text, lno, showit)
660: REG char *text; /* the text to draw */
661: long lno; /* line number of the text */
662: int showit; /* boolean: output line? (else just remember it) */
663: {
664: #ifdef CRUNCH
665: move((int)(lno - topline), 0);
666: if (showit)
667: {
668: drawtext(text, lno, TRUE);
669: }
670: #else /* not CRUNCH */
671: static char old[256]; /* how the line looked last time */
672: char new[256]; /* how it looks now */
673: char *build; /* used to put chars into new[] */
674: char *scan; /* used for moving thru new[] or old[] */
675: char *end; /* last non-blank changed char */
676: char *shift; /* used to insert/delete chars */
677: int same; /* length of a run of unchanged chars */
678: int limitcol;
679: int col;
680: int i;
681: char numstr[9];
682:
683: # ifndef NO_CHARATTR
684: /* if this line has attributes, do it the dumb way instead */
685: if (hasattr(lno, text))
686: {
687: move((int)(lno - topline), 0);
688: drawtext(text, lno, TRUE);
689: return;
690: }
691: # endif
692: # ifndef NO_SENTENCE
693: /* if this line is a format line, & we're hiding format lines, then
694: * let the dumb drawtext() function handle it
695: */
696: if (*o_hideformat && *text == '.')
697: {
698: move((int)(lno - topline), 0);
699: drawtext(text, lno, TRUE);
700: return;
701: }
702: # endif
703: # ifndef NO_VISIBLE
704: if (vizchange)
705: {
706: move((int)(lno - topline), 0);
707: drawtext(text, lno, TRUE);
708: smartlno = 0L;
709: return;
710: }
711: # endif
712:
713: /* skip stuff that was scrolled off left edge */
714: limitcol = leftcol;
715: for (col = 0;
716: (i = *text) && col < limitcol; /* yes, ASSIGNMENT! */
717: text++)
718: {
719: if (i == '\t' && !*o_list)
720: {
721: col = col + *o_tabstop - (col % *o_tabstop);
722: }
723: else if (i >= 0 && i < ' ' || i == '\177')
724: {
725: col += 2;
726: }
727: else
728: {
729: col++;
730: }
731: }
732:
733: /* adjust for control char that was partially visible */
734: build = new;
735: while (col > limitcol)
736: {
737: *build++ = ' ';
738: limitcol++;
739: }
740:
741: /* now for the visible characters */
742: limitcol = leftcol + COLS;
743: if (*o_number)
744: limitcol -= 8;
745: for (; (i = *text) && col < limitcol; text++)
746: {
747: if (i == '\t' && !*o_list)
748: {
749: i = col + *o_tabstop - (col % *o_tabstop);
750: while (col < i && col < limitcol)
751: {
752: *build++ = ' ';
753: col++;
754: }
755: }
756: else if (i >= 0 && i < ' ' || i == '\177')
757: {
758: col += 2;
759: *build++ = '^';
760: if (col <= limitcol)
761: {
762: *build++ = (i ^ '@');
763: }
764: }
765: else
766: {
767: col++;
768: *build++ = i;
769: }
770: }
771: if (col < limitcol && *o_list)
772: {
773: *build++ = '$';
774: col++;
775: }
776: end = build;
777: while (col < limitcol)
778: {
779: *build++ = ' ';
780: col++;
781: }
782:
783: /* if we're just supposed to remember this line, then remember it */
784: if (!showit)
785: {
786: smartlno = lno;
787: strncpy(old, new, COLS);
788: return;
789: }
790:
791: /* locate the last non-blank character */
792: while (end > new && end[-1] == ' ')
793: {
794: end--;
795: }
796:
797: /* can we optimize the displaying of this line? */
798: if (lno != smartlno)
799: {
800: /* nope, can't optimize - different line */
801: move((int)(lno - topline), 0);
802:
803: /* show the line number, if necessary */
804: if (*o_number)
805: {
806: sprintf(numstr, "%6ld ", lno);
807: qaddstr(numstr);
808: }
809:
810: /* show the new line */
811: for (scan = new, build = old; scan < end; )
812: {
813: qaddch(*scan);
814: *build++ = *scan++;
815: }
816: if (end < new + COLS - (*o_number ? 8 : 0))
817: {
818: clrtoeol();
819: while (build < old + COLS)
820: {
821: *build++ = ' ';
822: }
823: }
824: smartlno = lno;
825: return;
826: }
827:
828: /* skip any initial unchanged characters */
829: for (scan = new, build = old; scan < end && *scan == *build; scan++, build++)
830: {
831: }
832: i = (scan - new);
833: if (*o_number)
834: i += 8;
835: move((int)(lno - topline), i);
836:
837: /* The in-between characters must be changed */
838: same = 0;
839: while (scan < end)
840: {
841: /* is this character a match? */
842: if (scan[0] == build[0])
843: {
844: same++;
845: }
846: else /* do we want to insert? */
847: if (scan < end - 1 && scan[1] == build[0] && (has_IC || has_IM))
848: {
849: nudgecursor(same, scan, new, lno);
850: same = 0;
851:
852: insch(*scan);
853: for (shift = old + COLS; --shift > build; )
854: {
855: shift[0] = shift[-1];
856: }
857: *build = *scan;
858: }
859: else /* do we want to delete? */
860: if (build < old + COLS - 1 && scan[0] == build[1] && has_DC)
861: {
862: nudgecursor(same, scan, new, lno);
863: same = 0;
864:
865: delch();
866: same++;
867: for (shift = build; shift < old + COLS - 1; shift++)
868: {
869: shift[0] = shift[1];
870: }
871: if (*o_number)
872: shift -= 8;
873: *shift = ' ';
874: }
875: else /* we must overwrite */
876: {
877: nudgecursor(same, scan, new, lno);
878: same = 0;
879:
880: addch(*scan);
881: *build = *scan;
882: }
883:
884: build++;
885: scan++;
886: }
887:
888: /* maybe clear to EOL */
889: end = old + COLS - (*o_number ? 8 : 0);
890: while (build < end && *build == ' ')
891: {
892: build++;
893: }
894: if (build < end)
895: {
896: nudgecursor(same, scan, new, lno);
897: same = 0;
898:
899: clrtoeol();
900: while (build < old + COLS)
901: {
902: *build++ = ' ';
903: }
904: }
905: #endif /* not CRUNCH */
906: }
907:
908:
909: /* This function is used in visual mode for drawing the screen (or just parts
910: * of the screen, if that's all thats needed). It also takes care of
911: * scrolling.
912: */
913: void redraw(curs, inputting)
914: MARK curs; /* where to leave the screen's cursor */
915: int inputting; /* boolean: being called from input() ? */
916: {
917: char *text; /* a line of text to display */
918: static long chgs; /* previous changes level */
919: long l;
920: int i;
921: #ifndef CRUNCH
922: static long showtop; /* top line in window */
923: static long showbottom; /* bottom line in window */
924: #endif
925:
926: /* if curs == MARK_UNSET, then we should reset internal vars */
927: if (curs == MARK_UNSET)
928: {
929: if (topline < 1 || topline > nlines)
930: {
931: topline = 1L;
932: }
933: else
934: {
935: move(LINES - 1, 0);
936: clrtoeol();
937: }
938: leftcol = 0;
939: mustredraw = TRUE;
940: redrawafter = INFINITY;
941: preredraw = 0L;
942: postredraw = 0L;
943: chgs = 0;
944: smartlno = 0L;
945: #ifndef NO_VISIBLE
946: vizlow = vizhigh = 0L;
947: vizchange = FALSE;
948: #endif
949: #ifndef CRUNCH
950: showtop = 0;
951: showbottom = INFINITY;
952: #endif
953: return;
954: }
955:
956: #ifndef NO_VISIBLE
957: /* adjustments to hilited area may force extra lines to be redrawn. */
958: setviz(curs);
959: #endif
960:
961: /* figure out which column the cursor will be in */
962: l = markline(curs);
963: text = fetchline(l);
964: mark2phys(curs, text, inputting);
965:
966: #ifndef NO_COLOR
967: fixcolor();
968: #endif
969:
970: /* adjust topline, if necessary, to get the cursor on the screen */
971: if (l >= topline && l <= botline)
972: {
973: /* it is on the screen already */
974:
975: /* if the file was changed but !mustredraw, then redraw line */
976: if (!mustredraw && (chgs != changes
977: #ifndef NO_VISIBLE
978: || V_from
979: #endif
980: #ifndef CRUNCH
981: || l < showtop || l > showbottom
982: #endif
983: ))
984: {
985: smartdrawtext(text, l, (chgs != changes));
986: }
987: }
988: else if (l < topline && l >= topline - NEAR && (has_SR || has_AL))
989: {
990: /* near top - scroll down */
991: if (!mustredraw)
992: {
993: move(0,0);
994: while (l < topline)
995: {
996: topline--;
997: if (has_SR)
998: {
999: do_SR();
1000: }
1001: else
1002: {
1003: insertln();
1004: }
1005: text = fetchline(topline);
1006: drawtext(text, topline, FALSE);
1007: do_UP();
1008: }
1009:
1010: /* blank out the last line */
1011: move(LINES - 1, 0);
1012: clrtoeol();
1013: }
1014: else
1015: {
1016: topline = l;
1017: redrawrange(0L, INFINITY, INFINITY);
1018: }
1019: }
1020: else if (l > topline && l <= botline + NEAR)
1021: {
1022: /* near bottom -- scroll up */
1023: if (!mustredraw)
1024: {
1025: move(LINES - 1,0);
1026: clrtoeol();
1027: while (l > botline)
1028: {
1029: topline++; /* <-- also adjusts botline */
1030: text = fetchline(botline);
1031: drawtext(text, botline, FALSE);
1032: }
1033: #ifndef CRUNCH
1034: showbottom = l;
1035: #endif
1036: }
1037: else
1038: {
1039: topline = l - (LINES - 2);
1040: redrawrange(0L, INFINITY, INFINITY);
1041: }
1042: }
1043: else
1044: {
1045: /* distant line - center it & force a redraw */
1046: topline = l - (LINES / 2) - 1;
1047: if (topline < 1)
1048: {
1049: topline = 1;
1050: }
1051: redrawrange(0L, INFINITY, INFINITY);
1052: smartlno = 0L;
1053: changes++;
1054: }
1055:
1056: #ifndef CRUNCH
1057: /* make sure the current line is included in the "window" */
1058: if (l < showtop)
1059: {
1060: redrawrange(l, showtop, showtop);
1061: showtop = l;
1062: }
1063: if (l > showbottom)
1064: {
1065: redrawrange(showbottom, l, l);
1066: showbottom = l;
1067: }
1068: #endif
1069:
1070:
1071: /* Now... do we really have to redraw? */
1072: if (mustredraw)
1073: {
1074: /* If redrawfter (and friends) aren't set, assume we should
1075: * redraw everything.
1076: */
1077: if (redrawafter == INFINITY)
1078: {
1079: redrawafter = 0L;
1080: preredraw = postredraw = INFINITY;
1081: }
1082:
1083: #ifndef CRUNCH
1084: /* shrink the window, if possible */
1085: if (showtop < topline)
1086: {
1087: showtop = topline;
1088: }
1089: if (showbottom > botline)
1090: {
1091: showbottom = botline;
1092: }
1093: if (postredraw == INFINITY)
1094: {
1095: /* these will be set to more reasonable values later */
1096: showtop = INFINITY;
1097: showbottom = 0L;
1098: }
1099: #endif
1100:
1101: /* adjust smartlno to correspond with inserted/deleted lines */
1102: if (smartlno >= redrawafter)
1103: {
1104: if (smartlno < preredraw && postredraw != preredraw) /*!!!*/
1105: {
1106: smartlno = 0L;
1107: }
1108: else
1109: {
1110: smartlno += (postredraw - preredraw);
1111: }
1112: }
1113:
1114: /* should we insert some lines into the screen? */
1115: if (preredraw < postredraw && preredraw <= botline)
1116: {
1117: /* lines were inserted into the file */
1118:
1119: /* decide where insertion should start */
1120: if (preredraw < topline)
1121: {
1122: l = topline;
1123: }
1124: else
1125: {
1126: l = preredraw;
1127: }
1128:
1129: /* insert the lines... maybe */
1130: if (l + postredraw - preredraw > botline || !has_AL || *o_number)
1131: {
1132: /* Whoa! a whole screen full - just redraw */
1133: preredraw = postredraw = INFINITY;
1134: }
1135: else
1136: {
1137: /* really insert 'em */
1138: move((int)(l - topline), 0);
1139: for (i = postredraw - preredraw; i > 0; i--)
1140: {
1141: insertln();
1142: }
1143:
1144: /* NOTE: the contents of those lines will be
1145: * drawn as part of the regular redraw loop.
1146: */
1147:
1148: /* clear the last line */
1149: move(LINES - 1, 0);
1150: clrtoeol();
1151: }
1152: }
1153:
1154: /* do we want to delete some lines from the screen? */
1155: if (preredraw > postredraw && postredraw <= botline)
1156: {
1157: if (preredraw > botline || !has_DL || *o_number)
1158: {
1159: postredraw = preredraw = INFINITY;
1160: }
1161: else /* we'd best delete some lines from the screen */
1162: {
1163: /* clear the last line, so it doesn't look
1164: * ugly as it gets pulled up into the screen
1165: */
1166: move(LINES - 1, 0);
1167: clrtoeol();
1168:
1169: /* delete the lines */
1170: move((int)(postredraw - topline), 0);
1171: for (l = postredraw;
1172: l < preredraw && l <= botline;
1173: l++)
1174: {
1175: deleteln();
1176: }
1177:
1178: /* draw the lines that are now newly visible
1179: * at the bottom of the screen
1180: */
1181: i = LINES - 1 + (postredraw - preredraw);
1182: move(i, 0);
1183: for (l = topline + i; l <= botline; l++)
1184: {
1185: /* clear this line */
1186: clrtoeol();
1187:
1188: /* draw the line, or ~ for non-lines */
1189: if (l <= nlines)
1190: {
1191: text = fetchline(l);
1192: drawtext(text, l, FALSE);
1193: }
1194: else
1195: {
1196: addstr("~\n");
1197: }
1198: }
1199: }
1200: }
1201:
1202: /* redraw the current line */
1203: l = markline(curs);
1204: pfetch(l);
1205: smartdrawtext(ptext, l, TRUE);
1206:
1207: #ifndef CRUNCH
1208: /* decide which lines must be in the "window" around the cursor */
1209: l = markline(curs);
1210: if ((*o_window & 0xff) + 1 == LINES)
1211: {
1212: showtop = 1;
1213: showbottom = INFINITY;
1214: }
1215: else if (l < showtop || l > showbottom)
1216: {
1217: l -= (*o_window & 0xff) / 2;
1218: if (l < topline)
1219: {
1220: l = topline;
1221: }
1222: if (l < showtop)
1223: {
1224: showtop = l;
1225: }
1226: l += (*o_window & 0xff) - 1;
1227: if (l > botline)
1228: {
1229: showtop = showtop - l + botline;
1230: l = botline;
1231: }
1232: if (l > showbottom)
1233: {
1234: showbottom = l;
1235: }
1236: }
1237: #endif
1238:
1239: /* decide where we should start redrawing from */
1240: if (redrawafter < topline)
1241: {
1242: l = topline;
1243: }
1244: else
1245: {
1246: l = redrawafter;
1247: }
1248: if (l <= botline && l < postredraw && (l != smartlno || botline != smartlno))
1249: {
1250: /* draw the other lines */
1251: move((int)(l - topline), 0);
1252: for (; l <= botline && l < postredraw; l++)
1253: {
1254: /* we already drew the current line, so skip it now */
1255: if (l == smartlno)
1256: {
1257: #if OSK
1258: qaddch('\l');
1259: #else
1260: qaddch('\n');
1261: #endif
1262: continue;
1263: }
1264:
1265: /* draw the line, or ~ for non-lines */
1266: if (l > nlines)
1267: {
1268: qaddch('~');
1269: clrtoeol();
1270: addch('\n');
1271: }
1272: #ifndef CRUNCH
1273: else if (l < showtop || l > showbottom)
1274: {
1275: qaddch('@');
1276: clrtoeol();
1277: addch('\n');
1278: }
1279: #endif
1280: else
1281: {
1282: text = fetchline(l);
1283: drawtext(text, l, TRUE);
1284: }
1285: }
1286: }
1287:
1288: mustredraw = FALSE;
1289: }
1290:
1291: /* force total (non-partial) redraw next time if not set */
1292: redrawafter = INFINITY;
1293: preredraw = 0L;
1294: postredraw = 0L;
1295:
1296: /* move the cursor to where it belongs */
1297: move((int)(markline(curs) - topline), physcol);
1298: wqrefresh();
1299:
1300: chgs = changes;
1301: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.