![[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 / d / usr / bin / elvis|
Return to redraw.c CVS log | Up to [MW Coherent from dump] / coherent / d / usr / bin / elvis |
1.1 root 1: /* redraw.c */
2:
3: /* Author:
4: * Steve Kirkendall
5: * 16820 SW Tallac Way
6: * Beaverton, OR 97006
7: * [email protected], or ...uunet!tektronix!psueea!jove!kirkenda
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:
23: /* This variable contains the line number that smartdrawtext() knows best */
24: static long smartlno;
25:
26: /* This function remebers where changes were made, so that the screen can be
27: * redraw in a more efficient manner.
28: */
29: static long redrawafter; /* line# of first line that must be redrawn */
30: static long preredraw; /* line# of last line changed, before change */
31: static long postredraw; /* line# of last line changed, after change */
32: void redrawrange(after, pre, post)
33: long after; /* lower bound of redrawafter */
34: long pre; /* upper bound of preredraw */
35: long post; /* upper bound of postredraw */
36: {
37: if (after == redrawafter)
38: {
39: /* multiple insertions/deletions at the same place -- combine
40: * them
41: */
42: preredraw -= (post - pre);
43: if (postredraw < post)
44: {
45: preredraw += (post - postredraw);
46: postredraw = post;
47: }
48: if (redrawafter > preredraw)
49: {
50: redrawafter = preredraw;
51: }
52: if (redrawafter < 1L)
53: {
54: redrawafter = 0L;
55: preredraw = postredraw = INFINITY;
56: }
57: }
58: else if (postredraw > 0L)
59: {
60: /* multiple changes in different places -- redraw everything
61: * after "after".
62: */
63: postredraw = preredraw = INFINITY;
64: if (after < redrawafter)
65: redrawafter = after;
66: }
67: else
68: {
69: /* first change */
70: redrawafter = after;
71: preredraw = pre;
72: postredraw = post;
73: }
74: }
75:
76:
77: #ifndef NO_CHARATTR
78: /* see if a given line uses character attribute strings */
79: static int hasattr(lno, text)
80: long lno; /* the line# of the cursor */
81: REG char *text; /* the text of the line, from fetchline */
82: {
83: static long plno; /* previous line number */
84: static long chgs; /* previous value of changes counter */
85: static int panswer;/* previous answer */
86: char *scan;
87:
88: /* if charattr is off, then the answer is "no, it doesn't" */
89: if (!*o_charattr)
90: {
91: chgs = 0; /* <- forces us to check if charattr is later set */
92: return FALSE;
93: }
94:
95: /* if we already know the answer, return it... */
96: if (lno == plno && chgs == changes)
97: {
98: return panswer;
99: }
100:
101: /* get the line & look for "\fX" */
102: if (!text[0] || !text[1] || !text[2])
103: {
104: panswer = FALSE;
105: }
106: else
107: {
108: for (scan = text; scan[2] && !(scan[0] == '\\' && scan[1] == 'f'); scan++)
109: {
110: }
111: panswer = (scan[2] != '\0');
112: }
113:
114: /* save the results */
115: plno = lno;
116: chgs = changes;
117:
118: /* return the results */
119: return panswer;
120: }
121: #endif
122:
123:
124:
125: /* This function converts a MARK to a column number. It doesn't automatically
126: * adjust for leftcol; that must be done by the calling function
127: */
128: int idx2col(curs, text, inputting)
129: MARK curs; /* the line# & index# of the cursor */
130: REG char *text; /* the text of the line, from fetchline */
131: int inputting; /* boolean: called from input() ? */
132: {
133: static MARK pcursor;/* previous cursor, for possible shortcut */
134: static MARK pcol; /* column number for pcol */
135: static long chgs; /* previous value of changes counter */
136: REG int col; /* used to count column numbers */
137: REG int idx; /* used to count down the index */
138: REG int i;
139:
140: /* for now, assume we have to start counting at the left edge */
141: col = 0;
142: idx = markidx(curs);
143:
144: /* if the file hasn't changed & line number is the same & it has no
145: * embedded character attribute strings, can we do shortcuts?
146: */
147: if (chgs == changes
148: && !((curs ^ pcursor) & ~(BLKSIZE - 1))
149: #ifndef NO_CHARATTR
150: && !hasattr(markline(curs), text)
151: #endif
152: )
153: {
154: /* no movement? */
155: if (curs == pcursor)
156: {
157: /* return the column of the char; for tabs, return its last column */
158: if (text[idx] == '\t' && !inputting && !*o_list)
159: {
160: return pcol + *o_tabstop - (pcol % *o_tabstop) - 1;
161: }
162: else
163: {
164: return pcol;
165: }
166: }
167:
168: /* movement to right? */
169: if (curs > pcursor)
170: {
171: /* start counting from previous place */
172: col = pcol;
173: idx = markidx(curs) - markidx(pcursor);
174: text += markidx(pcursor);
175: }
176: }
177:
178: /* count over to the char after the idx position */
179: while (idx > 0 && (i = *text)) /* yes, ASSIGNMENT! */
180: {
181: if (i == '\t' && !*o_list)
182: {
183: col += *o_tabstop;
184: col -= col % *o_tabstop;
185: }
186: else if (i >= '\0' && i < ' ' || i == '\177')
187: {
188: col += 2;
189: }
190: #ifndef NO_CHARATTR
191: else if (i == '\\' && text[1] == 'f' && text[2] && *o_charattr)
192: {
193: text += 2; /* plus one more at bottom of loop */
194: idx -= 2;
195: }
196: #endif
197: else
198: {
199: col++;
200: }
201: text++;
202: idx--;
203: }
204:
205: /* save stuff to speed next call */
206: pcursor = curs;
207: pcol = col;
208: chgs = changes;
209:
210: /* return the column of the char; for tabs, return its last column */
211: if (*text == '\t' && !inputting && !*o_list)
212: {
213: return col + *o_tabstop - (col % *o_tabstop) - 1;
214: }
215: else
216: {
217: return col;
218: }
219: }
220:
221:
222: /* This function is similar to idx2col except that it takes care of sideways
223: * scrolling - for the given line, at least.
224: */
225: int mark2phys(m, text, inputting)
226: MARK m; /* a mark to convert */
227: char *text; /* the line that m refers to */
228: int inputting; /* boolean: caled from input() ? */
229: {
230: int i;
231:
232: i = idx2col(m, text, inputting);
233: while (i < leftcol)
234: {
235: leftcol -= *o_sidescroll;
236: mustredraw = TRUE;
237: redrawrange(1L, INFINITY, INFINITY);
238: qaddch('\r');
239: /* drawtext(text); */
240: }
241: while (i > rightcol)
242: {
243: leftcol += *o_sidescroll;
244: mustredraw = TRUE;
245: redrawrange(1L, INFINITY, INFINITY);
246: qaddch('\r');
247: /* drawtext(text); */
248: }
249: physcol = i - leftcol;
250: physrow = markline(m) - topline;
251:
252: return physcol;
253: }
254:
255: /* This function draws a single line of text on the screen. The screen's
256: * cursor is assumed to be located at the leftmost column of the appropriate
257: * row.
258: */
259: static void drawtext(text, clr)
260: REG char *text; /* the text to draw */
261: int clr; /* boolean: do a clrtoeol? */
262: {
263: REG int col; /* column number */
264: REG int i;
265: REG int tabstop; /* *o_tabstop */
266: REG int limitcol; /* leftcol or leftcol + COLS */
267: int abnormal; /* boolean: charattr != A_NORMAL? */
268:
269: #ifndef NO_SENTENCE
270: /* if we're hiding format lines, and this is one of them, then hide it */
271: if (*o_hideformat && *text == '.')
272: {
273: clrtoeol();
274: #if OSK
275: qaddch('\l');
276: #else
277: qaddch('\n');
278: #endif
279: return;
280: }
281: #endif
282:
283: /* move some things into registers... */
284: limitcol = leftcol;
285: tabstop = *o_tabstop;
286: abnormal = FALSE;
287:
288: #ifndef CRUNCH
289: if (clr)
290: clrtoeol();
291: #endif
292: /* skip stuff that was scrolled off left edge */
293: for (col = 0;
294: (i = *text) && col < limitcol; /* yes, ASSIGNMENT! */
295: text++)
296: {
297: if (i == '\t' && !*o_list)
298: {
299: col = col + tabstop - (col % tabstop);
300: }
301: else if (i >= 0 && i < ' ' || i == '\177')
302: {
303: col += 2;
304: }
305: #ifndef NO_CHARATTR
306: else if (i == '\\' && text[1] == 'f' && text[2] && *o_charattr)
307: {
308: text += 2; /* plus one more as part of "for" loop */
309:
310: /* since this attribute might carry over, we need it */
311: switch (*text)
312: {
313: case 'R':
314: case 'P':
315: attrset(A_NORMAL);
316: abnormal = FALSE;
317: break;
318:
319: case 'B':
320: attrset(A_BOLD);
321: abnormal = TRUE;
322: break;
323:
324: case 'U':
325: attrset(A_UNDERLINE);
326: abnormal = TRUE;
327: break;
328:
329: case 'I':
330: attrset(A_ALTCHARSET);
331: abnormal = TRUE;
332: break;
333: }
334: }
335: #endif
336: else
337: {
338: col++;
339: }
340: }
341:
342: /* adjust for control char that was partially visible */
343: while (col > limitcol)
344: {
345: qaddch(' ');
346: limitcol++;
347: }
348:
349: /* now for the visible characters */
350: for (limitcol = leftcol + COLS;
351: (i = *text) && col < limitcol;
352: text++)
353: {
354: if (i == '\t' && !*o_list)
355: {
356: i = col + tabstop - (col % tabstop);
357: if (i < limitcol)
358: {
359: #ifdef CRUNCH
360: if (!clr && has_PT && !((i - leftcol) & 7))
361: #else
362: if (has_PT && !((i - leftcol) & 7))
363: #endif
364: {
365: do
366: {
367: qaddch('\t');
368: col += 8; /* not exact! */
369: } while (col < i);
370: col = i; /* NOW it is exact */
371: }
372: else
373: {
374: do
375: {
376: qaddch(' ');
377: col++;
378: } while (col < i);
379: }
380: }
381: else /* tab ending after screen? next line! */
382: {
383: col = limitcol;
384: if (has_AM)
385: {
386: addch('\n'); /* GB */
387: }
388: }
389: }
390: else if (i >= 0 && i < ' ' || i == '\177')
391: {
392: col += 2;
393: qaddch('^');
394: if (col <= limitcol)
395: {
396: qaddch(i ^ '@');
397: }
398: }
399: #ifndef NO_CHARATTR
400: else if (i == '\\' && text[1] == 'f' && text[2] && *o_charattr)
401: {
402: text += 2; /* plus one more as part of "for" loop */
403: switch (*text)
404: {
405: case 'R':
406: case 'P':
407: attrset(A_NORMAL);
408: abnormal = FALSE;
409: break;
410:
411: case 'B':
412: attrset(A_BOLD);
413: abnormal = TRUE;
414: break;
415:
416: case 'U':
417: attrset(A_UNDERLINE);
418: abnormal = TRUE;
419: break;
420:
421: case 'I':
422: attrset(A_ALTCHARSET);
423: abnormal = TRUE;
424: break;
425: }
426: }
427: #endif
428: else
429: {
430: col++;
431: qaddch(i);
432: }
433: }
434:
435: /* get ready for the next line */
436: #ifndef NO_CHARATTR
437: if (abnormal)
438: {
439: attrset(A_NORMAL);
440: }
441: #endif
442: if (*o_list && col < limitcol)
443: {
444: qaddch('$');
445: col++;
446: }
447: #ifdef CRUNCH
448: if (clr && col < limitcol)
449: {
450: clrtoeol();
451: }
452: #endif
453: if (!has_AM || col < limitcol)
454: {
455: addch('\n');
456: }
457: }
458:
459:
460: #ifndef CRUNCH
461: static void nudgecursor(same, scan, new, lno)
462: int same; /* number of chars to be skipped over */
463: char *scan; /* where the same chars end */
464: char *new; /* where the visible part of the line starts */
465: long lno; /* line number of this line */
466: {
467: if (same > 0)
468: {
469: if (same < 5)
470: {
471: /* move the cursor by overwriting */
472: while (same > 0)
473: {
474: qaddch(scan[-same]);
475: same--;
476: }
477: }
478: else
479: {
480: /* move the cursor by calling move() */
481: move((int)(lno - topline), (int)(scan - new));
482: }
483: }
484: }
485: #endif /* not CRUNCH */
486:
487: /* This function draws a single line of text on the screen, possibly with
488: * some cursor optimization. The cursor is repositioned before drawing
489: * begins, so its position before doesn't really matter.
490: */
491: static void smartdrawtext(text, lno)
492: REG char *text; /* the text to draw */
493: long lno; /* line number of the text */
494: {
495: #ifdef CRUNCH
496: move((int)(lno - topline), 0);
497: drawtext(text, TRUE);
498: #else /* not CRUNCH */
499: static char old[256]; /* how the line looked last time */
500: char new[256]; /* how it looks now */
501: char *build; /* used to put chars into new[] */
502: char *scan; /* used for moving thru new[] or old[] */
503: char *end; /* last non-blank changed char */
504: char *shift; /* used to insert/delete chars */
505: int same; /* length of a run of unchanged chars */
506: int limitcol;
507: int col;
508: int i;
509:
510: # ifndef NO_CHARATTR
511: /* if this line has attributes, do it the dumb way instead */
512: if (hasattr(lno, text))
513: {
514: move((int)(lno - topline), 0);
515: drawtext(text, TRUE);
516: return;
517: }
518: # endif
519: # ifndef NO_SENTENCE
520: /* if this line is a format line, & we're hiding format lines, then
521: * let the dumb drawtext() function handle it
522: */
523: if (*o_hideformat && *text == '.')
524: {
525: move((int)(lno - topline), 0);
526: drawtext(text, TRUE);
527: return;
528: }
529: # endif
530:
531: /* skip stuff that was scrolled off left edge */
532: limitcol = leftcol;
533: for (col = 0;
534: (i = *text) && col < limitcol; /* yes, ASSIGNMENT! */
535: text++)
536: {
537: if (i == '\t' && !*o_list)
538: {
539: col = col + *o_tabstop - (col % *o_tabstop);
540: }
541: else if (i >= 0 && i < ' ' || i == '\177')
542: {
543: col += 2;
544: }
545: else
546: {
547: col++;
548: }
549: }
550:
551: /* adjust for control char that was partially visible */
552: build = new;
553: while (col > limitcol)
554: {
555: *build++ = ' ';
556: limitcol++;
557: }
558:
559: /* now for the visible characters */
560: for (limitcol = leftcol + COLS;
561: (i = *text) && col < limitcol;
562: text++)
563: {
564: if (i == '\t' && !*o_list)
565: {
566: i = col + *o_tabstop - (col % *o_tabstop);
567: while (col < i && col < limitcol)
568: {
569: *build++ = ' ';
570: col++;
571: }
572: }
573: else if (i >= 0 && i < ' ' || i == '\177')
574: {
575: col += 2;
576: *build++ = '^';
577: if (col <= limitcol)
578: {
579: *build++ = (i ^ '@');
580: }
581: }
582: else
583: {
584: col++;
585: *build++ = i;
586: }
587: }
588: if (col < limitcol && *o_list)
589: {
590: *build++ = '$';
591: col++;
592: }
593: end = build;
594: while (col < limitcol)
595: {
596: *build++ = ' ';
597: col++;
598: }
599:
600: /* locate the last non-blank character */
601: while (end > new && end[-1] == ' ')
602: {
603: end--;
604: }
605:
606: /* can we optimize the displaying of this line? */
607: if (lno != smartlno)
608: {
609: /* nope, can't optimize - different line */
610: move((int)(lno - topline), 0);
611: for (scan = new, build = old; scan < end; )
612: {
613: qaddch(*scan);
614: *build++ = *scan++;
615: }
616: if (end < new + COLS)
617: {
618: clrtoeol();
619: while (build < old + COLS)
620: {
621: *build++ = ' ';
622: }
623: }
624: smartlno = lno;
625: return;
626: }
627:
628: /* skip any initial unchanged characters */
629: for (scan = new, build = old; scan < end && *scan == *build; scan++, build++)
630: {
631: }
632: move((int)(lno - topline), (int)(scan - new));
633:
634: /* The in-between characters must be changed */
635: same = 0;
636: while (scan < end)
637: {
638: /* is this character a match? */
639: if (scan[0] == build[0])
640: {
641: same++;
642: }
643: else /* do we want to insert? */
644: if (scan < end - 1 && scan[1] == build[0] && (has_IC || has_IM))
645: {
646: nudgecursor(same, scan, new, lno);
647: same = 0;
648:
649: insch(*scan);
650: for (shift = old + COLS; --shift > build; )
651: {
652: shift[0] = shift[-1];
653: }
654: *build = *scan;
655: }
656: else /* do we want to delete? */
657: if (build < old + COLS - 1 && scan[0] == build[1] && has_DC)
658: {
659: nudgecursor(same, scan, new, lno);
660: same = 0;
661:
662: delch();
663: same++;
664: for (shift = build; shift < old + COLS - 1; shift++)
665: {
666: shift[0] = shift[1];
667: }
668: *shift = ' ';
669: }
670: else /* we must overwrite */
671: {
672: nudgecursor(same, scan, new, lno);
673: same = 0;
674:
675: addch(*scan);
676: *build = *scan;
677: }
678:
679: build++;
680: scan++;
681: }
682:
683: /* maybe clear to EOL */
684: while (build < old + COLS && *build == ' ')
685: {
686: build++;
687: }
688: if (build < old + COLS)
689: {
690: nudgecursor(same, scan, new, lno);
691: same = 0;
692:
693: clrtoeol();
694: while (build < old + COLS)
695: {
696: *build++ = ' ';
697: }
698: }
699: #endif /* not CRUNCH */
700: }
701:
702:
703: /* This function is used in visual mode for drawing the screen (or just parts
704: * of the screen, if that's all thats needed). It also takes care of
705: * scrolling.
706: */
707: void redraw(curs, inputting)
708: MARK curs; /* where to leave the screen's cursor */
709: int inputting; /* boolean: being called from input() ? */
710: {
711: char *text; /* a line of text to display */
712: static long chgs; /* previous changes level */
713: long l;
714: int i;
715:
716: /* if curs == MARK_UNSET, then we should reset internal vars */
717: if (curs == MARK_UNSET)
718: {
719: if (topline < 1 || topline > nlines)
720: {
721: topline = 1L;
722: }
723: else
724: {
725: move(LINES - 1, 0);
726: clrtoeol();
727: }
728: leftcol = 0;
729: mustredraw = TRUE;
730: redrawafter = INFINITY;
731: preredraw = 0L;
732: postredraw = 0L;
733: chgs = 0;
734: smartlno = 0L;
735: return;
736: }
737:
738: /* figure out which column the cursor will be in */
739: l = markline(curs);
740: text = fetchline(l);
741: mark2phys(curs, text, inputting);
742:
743: /* adjust topline, if necessary, to get the cursor on the screen */
744: if (l >= topline && l <= botline)
745: {
746: /* it is on the screen already */
747:
748: /* if the file was changed but !mustredraw, then redraw line */
749: if (chgs != changes && !mustredraw)
750: {
751: smartdrawtext(text, l);
752: }
753: }
754: else if (l < topline && l > topline - LINES && (has_SR || has_AL))
755: {
756: /* near top - scroll down */
757: if (!mustredraw)
758: {
759: move(0,0);
760: while (l < topline)
761: {
762: topline--;
763: if (has_SR)
764: {
765: do_SR();
766: }
767: else
768: {
769: insertln();
770: }
771: text = fetchline(topline);
772: drawtext(text, FALSE);
773: do_UP();
774: }
775:
776: /* blank out the last line */
777: move(LINES - 1, 0);
778: clrtoeol();
779: }
780: else
781: {
782: topline = l;
783: redrawafter = INFINITY;
784: preredraw = 0L;
785: postredraw = 0L;
786: }
787: }
788: else if (l > topline && l < botline + LINES)
789: {
790: /* near bottom -- scroll up */
791: if (!mustredraw
792: #if 1
793: || redrawafter == preredraw && preredraw == botline && postredraw == l
794: #endif
795: )
796: {
797: move(LINES - 1,0);
798: clrtoeol();
799: while (l > botline)
800: {
801: topline++; /* <-- also adjusts botline */
802: text = fetchline(botline);
803: drawtext(text, FALSE);
804: }
805: mustredraw = FALSE;
806: }
807: else
808: {
809: topline = l - (LINES - 2);
810: redrawafter = INFINITY;
811: preredraw = 0L;
812: postredraw = 0L;
813: }
814: }
815: else
816: {
817: /* distant line - center it & force a redraw */
818: topline = l - (LINES / 2) - 1;
819: if (topline < 1)
820: {
821: topline = 1;
822: }
823: mustredraw = TRUE;
824: redrawafter = INFINITY;
825: preredraw = 0L;
826: postredraw = 0L;
827: }
828:
829: /* Now... do we really have to redraw? */
830: if (mustredraw)
831: {
832: /* If redrawfter (and friends) aren't set, assume we should
833: * redraw everything.
834: */
835: if (redrawafter == INFINITY)
836: {
837: redrawafter = 0L;
838: preredraw = postredraw = INFINITY;
839: }
840:
841: /* adjust smartlno to correspond with inserted/deleted lines */
842: if (smartlno >= redrawafter)
843: {
844: if (smartlno < preredraw)
845: {
846: smartlno = 0L;
847: }
848: else
849: {
850: smartlno += (postredraw - preredraw);
851: }
852: }
853:
854: /* should we insert some lines into the screen? */
855: if (preredraw < postredraw && preredraw <= botline)
856: {
857: /* lines were inserted into the file */
858:
859: /* decide where insertion should start */
860: if (preredraw < topline)
861: {
862: l = topline;
863: }
864: else
865: {
866: l = preredraw;
867: }
868:
869: /* insert the lines... maybe */
870: if (l + postredraw - preredraw > botline || !has_AL)
871: {
872: /* Whoa! a whole screen full - just redraw */
873: preredraw = postredraw = INFINITY;
874: }
875: else
876: {
877: /* really insert 'em */
878: move((int)(l - topline), 0);
879: for (i = postredraw - preredraw; i > 0; i--)
880: {
881: insertln();
882: }
883:
884: /* NOTE: the contents of those lines will be
885: * drawn as part of the regular redraw loop.
886: */
887:
888: /* clear the last line */
889: move(LINES - 1, 0);
890: clrtoeol();
891: }
892: }
893:
894: /* do we want to delete some lines from the screen? */
895: if (preredraw > postredraw && postredraw <= botline)
896: {
897: if (preredraw > botline || !has_DL)
898: {
899: postredraw = preredraw = INFINITY;
900: }
901: else /* we'd best delete some lines from the screen */
902: {
903: /* clear the last line, so it doesn't look
904: * ugly as it gets pulled up into the screen
905: */
906: move(LINES - 1, 0);
907: clrtoeol();
908:
909: /* delete the lines */
910: move((int)(postredraw - topline), 0);
911: for (l = postredraw;
912: l < preredraw && l <= botline;
913: l++)
914: {
915: deleteln();
916: }
917:
918: /* draw the lines that are now newly visible
919: * at the bottom of the screen
920: */
921: i = LINES - 1 + (postredraw - preredraw);
922: move(i, 0);
923: for (l = topline + i; l <= botline; l++)
924: {
925: /* clear this line */
926: clrtoeol();
927:
928: /* draw the line, or ~ for non-lines */
929: if (l <= nlines)
930: {
931: text = fetchline(l);
932: drawtext(text, FALSE);
933: }
934: else
935: {
936: addstr("~\n");
937: }
938: }
939: }
940: }
941:
942: /* redraw the current line */
943: l = markline(curs);
944: pfetch(l);
945: smartdrawtext(ptext, l);
946:
947: /* decide where we should start redrawing from */
948: if (redrawafter < topline)
949: {
950: l = topline;
951: }
952: else
953: {
954: l = redrawafter;
955: }
956: move((int)(l - topline), 0);
957:
958: /* draw the other lines */
959: for (; l <= botline && l < postredraw; l++)
960: {
961: /* we already drew the current line, so skip it now */
962: if (l == smartlno)
963: {
964: #if OSK
965: qaddch('\l');
966: #else
967: qaddch('\n');
968: #endif
969: continue;
970: }
971:
972: /* draw the line, or ~ for non-lines */
973: if (l <= nlines)
974: {
975: text = fetchline(l);
976: drawtext(text, TRUE);
977: }
978: else
979: {
980: qaddch('~');
981: clrtoeol();
982: addch('\n');
983: }
984: }
985:
986: mustredraw = FALSE;
987: }
988:
989: /* force total (non-partial) redraw next time if not set */
990: redrawafter = INFINITY;
991: preredraw = 0L;
992: postredraw = 0L;
993:
994: /* move the cursor to where it belongs */
995: move((int)(markline(curs) - topline), physcol);
996: wqrefresh(stdscr);
997:
998: chgs = changes;
999: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.