xref: /freebsd/contrib/nvi/vi/vs_refresh.c (revision fe815331bb40604ba31312acf7e4619674631777)
1 /*-
2  * Copyright (c) 1992, 1993, 1994
3  *	The Regents of the University of California.  All rights reserved.
4  * Copyright (c) 1992, 1993, 1994, 1995, 1996
5  *	Keith Bostic.  All rights reserved.
6  *
7  * See the LICENSE file for redistribution information.
8  */
9 
10 #include "config.h"
11 
12 #include <sys/types.h>
13 #include <sys/queue.h>
14 #include <sys/time.h>
15 
16 #include <bitstring.h>
17 #include <ctype.h>
18 #include <libgen.h>
19 #include <limits.h>
20 #include <stdio.h>
21 #include <stdlib.h>
22 #include <string.h>
23 
24 #include "../common/common.h"
25 #include "vi.h"
26 
27 #define	UPDATE_CURSOR	0x01			/* Update the cursor. */
28 #define	UPDATE_SCREEN	0x02			/* Flush to screen. */
29 
30 static void	vs_modeline(SCR *);
31 static int	vs_paint(SCR *, u_int);
32 
33 /*
34  * v_repaint --
35  *	Repaint selected lines from the screen.
36  *
37  * PUBLIC: int vs_repaint(SCR *, EVENT *);
38  */
39 int
40 vs_repaint(
41 	SCR *sp,
42 	EVENT *evp)
43 {
44 	SMAP *smp;
45 
46 	for (; evp->e_flno <= evp->e_tlno; ++evp->e_flno) {
47 		smp = HMAP + evp->e_flno - 1;
48 		SMAP_FLUSH(smp);
49 		if (vs_line(sp, smp, NULL, NULL))
50 			return (1);
51 	}
52 	return (0);
53 }
54 
55 /*
56  * vs_refresh --
57  *	Refresh all screens.
58  *
59  * PUBLIC: int vs_refresh(SCR *, int);
60  */
61 int
62 vs_refresh(
63 	SCR *sp,
64 	int forcepaint)
65 {
66 	GS *gp;
67 	SCR *tsp;
68 	int need_refresh = 0;
69 	u_int priv_paint, pub_paint;
70 
71 	gp = sp->gp;
72 
73 	/*
74 	 * 1: Refresh the screen.
75 	 *
76 	 * If SC_SCR_REDRAW is set in the current screen, repaint everything
77 	 * that we can find, including status lines.
78 	 */
79 	if (F_ISSET(sp, SC_SCR_REDRAW))
80 		TAILQ_FOREACH(tsp, gp->dq, q)
81 			if (tsp != sp)
82 				F_SET(tsp, SC_SCR_REDRAW | SC_STATUS);
83 
84 	/*
85 	 * 2: Related or dirtied screens, or screens with messages.
86 	 *
87 	 * If related screens share a view into a file, they may have been
88 	 * modified as well.  Refresh any screens that aren't exiting that
89 	 * have paint or dirty bits set.  Always update their screens, we
90 	 * are not likely to get another chance.  Finally, if we refresh any
91 	 * screens other than the current one, the cursor will be trashed.
92 	 */
93 	pub_paint = SC_SCR_REFORMAT | SC_SCR_REDRAW;
94 	priv_paint = VIP_CUR_INVALID | VIP_N_REFRESH;
95 	if (O_ISSET(sp, O_NUMBER))
96 		priv_paint |= VIP_N_RENUMBER;
97 	TAILQ_FOREACH(tsp, gp->dq, q)
98 		if (tsp != sp && !F_ISSET(tsp, SC_EXIT | SC_EXIT_FORCE) &&
99 		    (F_ISSET(tsp, pub_paint) ||
100 		    F_ISSET(VIP(tsp), priv_paint))) {
101 			(void)vs_paint(tsp,
102 			    (F_ISSET(VIP(tsp), VIP_CUR_INVALID) ?
103 			    UPDATE_CURSOR : 0) | UPDATE_SCREEN);
104 			F_SET(VIP(sp), VIP_CUR_INVALID);
105 		}
106 
107 	/*
108 	 * 3: Refresh the current screen.
109 	 *
110 	 * Always refresh the current screen, it may be a cursor movement.
111 	 * Also, always do it last -- that way, SC_SCR_REDRAW can be set
112 	 * in the current screen only, and the screen won't flash.
113 	 */
114 	if (vs_paint(sp, UPDATE_CURSOR | (!forcepaint &&
115 	    F_ISSET(sp, SC_SCR_VI) && KEYS_WAITING(sp) ? 0 : UPDATE_SCREEN)))
116 		return (1);
117 
118 	/*
119 	 * 4: Paint any missing status lines.
120 	 *
121 	 * XXX
122 	 * This is fairly evil.  Status lines are written using the vi message
123 	 * mechanism, since we have no idea how long they are.  Since we may be
124 	 * painting screens other than the current one, we don't want to make
125 	 * the user wait.  We depend heavily on there not being any other lines
126 	 * currently waiting to be displayed and the message truncation code in
127 	 * the msgq_status routine working.
128 	 *
129 	 * And, finally, if we updated any status lines, make sure the cursor
130 	 * gets back to where it belongs.
131 	 */
132 	TAILQ_FOREACH(tsp, gp->dq, q)
133 		if (F_ISSET(tsp, SC_STATUS)) {
134 			need_refresh = 1;
135 			vs_resolve(tsp, sp, 0);
136 		}
137 	if (need_refresh)
138 		(void)gp->scr_refresh(sp, 0);
139 
140 	/*
141 	 * A side-effect of refreshing the screen is that it's now ready
142 	 * for everything else, i.e. messages.
143 	 */
144 	F_SET(sp, SC_SCR_VI);
145 	return (0);
146 }
147 
148 /*
149  * vs_paint --
150  *	This is the guts of the vi curses screen code.  The idea is that
151  *	the SCR structure passed in contains the new coordinates of the
152  *	screen.  What makes this hard is that we don't know how big
153  *	characters are, doing input can put the cursor in illegal places,
154  *	and we're frantically trying to avoid repainting unless it's
155  *	absolutely necessary.  If you change this code, you'd better know
156  *	what you're doing.  It's subtle and quick to anger.
157  */
158 static int
159 vs_paint(
160 	SCR *sp,
161 	u_int flags)
162 {
163 	GS *gp;
164 	SMAP *smp, tmp;
165 	VI_PRIVATE *vip;
166 	recno_t lastline, lcnt;
167 	size_t cwtotal, cnt, len, notused, off, y;
168 	int ch = 0, didpaint, isempty, leftright_warp;
169 	CHAR_T *p;
170 
171 #define	 LNO	sp->lno			/* Current file line. */
172 #define	OLNO	vip->olno		/* Remembered file line. */
173 #define	 CNO	sp->cno			/* Current file column. */
174 #define	OCNO	vip->ocno		/* Remembered file column. */
175 #define	SCNO	vip->sc_col		/* Current screen column. */
176 
177 	gp = sp->gp;
178 	vip = VIP(sp);
179 	didpaint = leftright_warp = 0;
180 
181 	/*
182 	 * 5: Reformat the lines.
183 	 *
184 	 * If the lines themselves have changed (:set list, for example),
185 	 * fill in the map from scratch.  Adjust the screen that's being
186 	 * displayed if the leftright flag is set.
187 	 */
188 	if (F_ISSET(sp, SC_SCR_REFORMAT)) {
189 		/* Invalidate the line size cache. */
190 		VI_SCR_CFLUSH(vip);
191 
192 		/* Toss vs_line() cached information. */
193 		if (F_ISSET(sp, SC_SCR_TOP)) {
194 			if (vs_sm_fill(sp, LNO, P_TOP))
195 				return (1);
196 		}
197 		else if (F_ISSET(sp, SC_SCR_CENTER)) {
198 			if (vs_sm_fill(sp, LNO, P_MIDDLE))
199 				return (1);
200 		} else
201 			if (vs_sm_fill(sp, OOBLNO, P_TOP))
202 				return (1);
203 		F_SET(sp, SC_SCR_REDRAW);
204 	}
205 
206 	/*
207 	 * 6: Line movement.
208 	 *
209 	 * Line changes can cause the top line to change as well.  As
210 	 * before, if the movement is large, the screen is repainted.
211 	 *
212 	 * 6a: Small screens.
213 	 *
214 	 * Users can use the window, w300, w1200 and w9600 options to make
215 	 * the screen artificially small.  The behavior of these options
216 	 * in the historic vi wasn't all that consistent, and, in fact, it
217 	 * was never documented how various screen movements affected the
218 	 * screen size.  Generally, one of three things would happen:
219 	 *	1: The screen would expand in size, showing the line
220 	 *	2: The screen would scroll, showing the line
221 	 *	3: The screen would compress to its smallest size and
222 	 *		repaint.
223 	 * In general, scrolling didn't cause compression (200^D was handled
224 	 * the same as ^D), movement to a specific line would (:N where N
225 	 * was 1 line below the screen caused a screen compress), and cursor
226 	 * movement would scroll if it was 11 lines or less, and compress if
227 	 * it was more than 11 lines.  (And, no, I have no idea where the 11
228 	 * comes from.)
229 	 *
230 	 * What we do is try and figure out if the line is less than half of
231 	 * a full screen away.  If it is, we expand the screen if there's
232 	 * room, and then scroll as necessary.  The alternative is to compress
233 	 * and repaint.
234 	 *
235 	 * !!!
236 	 * This code is a special case from beginning to end.  Unfortunately,
237 	 * home modems are still slow enough that it's worth having.
238 	 *
239 	 * XXX
240 	 * If the line a really long one, i.e. part of the line is on the
241 	 * screen but the column offset is not, we'll end up in the adjust
242 	 * code, when we should probably have compressed the screen.
243 	 */
244 	if (IS_SMALL(sp))
245 		if (LNO < HMAP->lno) {
246 			lcnt = vs_sm_nlines(sp, HMAP, LNO, sp->t_maxrows);
247 			if (lcnt <= HALFSCREEN(sp))
248 				for (; lcnt && sp->t_rows != sp->t_maxrows;
249 				     --lcnt, ++sp->t_rows) {
250 					++TMAP;
251 					if (vs_sm_1down(sp))
252 						return (1);
253 				}
254 			else
255 				goto small_fill;
256 		} else if (LNO > TMAP->lno) {
257 			lcnt = vs_sm_nlines(sp, TMAP, LNO, sp->t_maxrows);
258 			if (lcnt <= HALFSCREEN(sp))
259 				for (; lcnt && sp->t_rows != sp->t_maxrows;
260 				     --lcnt, ++sp->t_rows) {
261 					if (vs_sm_next(sp, TMAP, TMAP + 1))
262 						return (1);
263 					++TMAP;
264 					if (vs_line(sp, TMAP, NULL, NULL))
265 						return (1);
266 				}
267 			else {
268 small_fill:			(void)gp->scr_move(sp, LASTLINE(sp), 0);
269 				(void)gp->scr_clrtoeol(sp);
270 				for (; sp->t_rows > sp->t_minrows;
271 				    --sp->t_rows, --TMAP) {
272 					(void)gp->scr_move(sp, TMAP - HMAP, 0);
273 					(void)gp->scr_clrtoeol(sp);
274 				}
275 				if (vs_sm_fill(sp, LNO, P_FILL))
276 					return (1);
277 				F_SET(sp, SC_SCR_REDRAW);
278 				goto adjust;
279 			}
280 		}
281 
282 	/*
283 	 * 6b: Line down, or current screen.
284 	 */
285 	if (LNO >= HMAP->lno) {
286 		/* Current screen. */
287 		if (LNO <= TMAP->lno)
288 			goto adjust;
289 		if (F_ISSET(sp, SC_SCR_TOP))
290 			goto top;
291 		if (F_ISSET(sp, SC_SCR_CENTER))
292 			goto middle;
293 
294 		/*
295 		 * If less than half a screen above the line, scroll down
296 		 * until the line is on the screen.
297 		 */
298 		lcnt = vs_sm_nlines(sp, TMAP, LNO, HALFTEXT(sp));
299 		if (lcnt < HALFTEXT(sp)) {
300 			while (lcnt--)
301 				if (vs_sm_1up(sp))
302 					return (1);
303 			goto adjust;
304 		}
305 		goto bottom;
306 	}
307 
308 	/*
309 	 * 6c: If not on the current screen, may request center or top.
310 	 */
311 	if (F_ISSET(sp, SC_SCR_TOP))
312 		goto top;
313 	if (F_ISSET(sp, SC_SCR_CENTER))
314 		goto middle;
315 
316 	/*
317 	 * 6d: Line up.
318 	 */
319 	lcnt = vs_sm_nlines(sp, HMAP, LNO, HALFTEXT(sp));
320 	if (lcnt < HALFTEXT(sp)) {
321 		/*
322 		 * If less than half a screen below the line, scroll up until
323 		 * the line is the first line on the screen.  Special check so
324 		 * that if the screen has been emptied, we refill it.
325 		 */
326 		if (db_exist(sp, HMAP->lno)) {
327 			while (lcnt--)
328 				if (vs_sm_1down(sp))
329 					return (1);
330 			goto adjust;
331 		} else
332 			goto top;	/* XXX No such line. */
333 
334 		/*
335 		 * If less than a half screen from the bottom of the file,
336 		 * put the last line of the file on the bottom of the screen.
337 		 */
338 bottom:		if (db_last(sp, &lastline))
339 			return (1);
340 		tmp.lno = LNO;
341 		tmp.coff = HMAP->coff;
342 		tmp.soff = 1;
343 		lcnt = vs_sm_nlines(sp, &tmp, lastline, sp->t_rows);
344 		if (lcnt < HALFTEXT(sp)) {
345 			if (vs_sm_fill(sp, lastline, P_BOTTOM))
346 				return (1);
347 			F_SET(sp, SC_SCR_REDRAW);
348 			goto adjust;
349 		}
350 		/* It's not close, just put the line in the middle. */
351 		goto middle;
352 	}
353 
354 	/*
355 	 * If less than half a screen from the top of the file, put the first
356 	 * line of the file at the top of the screen.  Otherwise, put the line
357 	 * in the middle of the screen.
358 	 */
359 	tmp.lno = 1;
360 	tmp.coff = HMAP->coff;
361 	tmp.soff = 1;
362 	lcnt = vs_sm_nlines(sp, &tmp, LNO, HALFTEXT(sp));
363 	if (lcnt < HALFTEXT(sp)) {
364 		if (vs_sm_fill(sp, 1, P_TOP))
365 			return (1);
366 	} else
367 middle:		if (vs_sm_fill(sp, LNO, P_MIDDLE))
368 			return (1);
369 	if (0) {
370 top:		if (vs_sm_fill(sp, LNO, P_TOP))
371 			return (1);
372 	}
373 	F_SET(sp, SC_SCR_REDRAW);
374 
375 	/*
376 	 * At this point we know part of the line is on the screen.  Since
377 	 * scrolling is done using logical lines, not physical, all of the
378 	 * line may not be on the screen.  While that's not necessarily bad,
379 	 * if the part the cursor is on isn't there, we're going to lose.
380 	 * This can be tricky; if the line covers the entire screen, lno
381 	 * may be the same as both ends of the map, that's why we test BOTH
382 	 * the top and the bottom of the map.  This isn't a problem for
383 	 * left-right scrolling, the cursor movement code handles the problem.
384 	 *
385 	 * There's a performance issue here if editing *really* long lines.
386 	 * This gets to the right spot by scrolling, and, in a binary, by
387 	 * scrolling hundreds of lines.  If the adjustment looks like it's
388 	 * going to be a serious problem, refill the screen and repaint.
389 	 */
390 adjust:	if (!O_ISSET(sp, O_LEFTRIGHT) &&
391 	    (LNO == HMAP->lno || LNO == TMAP->lno)) {
392 		cnt = vs_screens(sp, LNO, &CNO);
393 		if (LNO == HMAP->lno && cnt < HMAP->soff)
394 			if ((HMAP->soff - cnt) > HALFTEXT(sp)) {
395 				HMAP->soff = cnt;
396 				vs_sm_fill(sp, OOBLNO, P_TOP);
397 				F_SET(sp, SC_SCR_REDRAW);
398 			} else
399 				while (cnt < HMAP->soff)
400 					if (vs_sm_1down(sp))
401 						return (1);
402 		if (LNO == TMAP->lno && cnt > TMAP->soff)
403 			if ((cnt - TMAP->soff) > HALFTEXT(sp)) {
404 				TMAP->soff = cnt;
405 				vs_sm_fill(sp, OOBLNO, P_BOTTOM);
406 				F_SET(sp, SC_SCR_REDRAW);
407 			} else
408 				while (cnt > TMAP->soff)
409 					if (vs_sm_1up(sp))
410 						return (1);
411 	}
412 
413 	/*
414 	 * If the screen needs to be repainted, skip cursor optimization.
415 	 * However, in the code above we skipped leftright scrolling on
416 	 * the grounds that the cursor code would handle it.  Make sure
417 	 * the right screen is up.
418 	 */
419 	if (F_ISSET(sp, SC_SCR_REDRAW)) {
420 		if (O_ISSET(sp, O_LEFTRIGHT))
421 			goto slow;
422 		goto paint;
423 	}
424 
425 	/*
426 	 * 7: Cursor movements (current screen only).
427 	 */
428 	if (!LF_ISSET(UPDATE_CURSOR))
429 		goto number;
430 
431 	/*
432 	 * Decide cursor position.  If the line has changed, the cursor has
433 	 * moved over a tab, or don't know where the cursor was, reparse the
434 	 * line.  Otherwise, we've just moved over fixed-width characters,
435 	 * and can calculate the left/right scrolling and cursor movement
436 	 * without reparsing the line.  Note that we don't know which (if any)
437 	 * of the characters between the old and new cursor positions changed.
438 	 *
439 	 * XXX
440 	 * With some work, it should be possible to handle tabs quickly, at
441 	 * least in obvious situations, like moving right and encountering
442 	 * a tab, without reparsing the whole line.
443 	 *
444 	 * If the line we're working with has changed, reread it..
445 	 */
446 	if (F_ISSET(vip, VIP_CUR_INVALID) || LNO != OLNO)
447 		goto slow;
448 
449 	/* Otherwise, if nothing's changed, ignore the cursor. */
450 	if (CNO == OCNO)
451 		goto fast;
452 
453 	/*
454 	 * Get the current line.  If this fails, we either have an empty
455 	 * file and can just repaint, or there's a real problem.  This
456 	 * isn't a performance issue because there aren't any ways to get
457 	 * here repeatedly.
458 	 */
459 	if (db_eget(sp, LNO, &p, &len, &isempty)) {
460 		if (isempty)
461 			goto slow;
462 		return (1);
463 	}
464 
465 #ifdef DEBUG
466 	/* Sanity checking. */
467 	if (CNO >= len && len != 0) {
468 		msgq(sp, M_ERR, "Error: %s/%d: cno (%zu) >= len (%zu)",
469 		     basename(__FILE__), __LINE__, CNO, len);
470 		return (1);
471 	}
472 #endif
473 	/*
474 	 * The basic scheme here is to look at the characters in between
475 	 * the old and new positions and decide how big they are on the
476 	 * screen, and therefore, how many screen positions to move.
477 	 */
478 	if (CNO < OCNO) {
479 		/*
480 		 * 7a: Cursor moved left.
481 		 *
482 		 * Point to the old character.  The old cursor position can
483 		 * be past EOL if, for example, we just deleted the rest of
484 		 * the line.  In this case, since we don't know the width of
485 		 * the characters we traversed, we have to do it slowly.
486 		 */
487 		p += OCNO;
488 		cnt = (OCNO - CNO) + 1;
489 		if (OCNO >= len)
490 			goto slow;
491 
492 		/*
493 		 * Quick sanity check -- it's hard to figure out exactly when
494 		 * we cross a screen boundary as we do in the cursor right
495 		 * movement.  If cnt is so large that we're going to cross the
496 		 * boundary no matter what, stop now.
497 		 */
498 		if (SCNO + 1 + MAX_CHARACTER_COLUMNS < cnt)
499 			goto slow;
500 
501 		/*
502 		 * Count up the widths of the characters.  If it's a tab
503 		 * character, go do it the slow way.
504 		 */
505 		for (cwtotal = 0; cnt--; cwtotal += KEY_COL(sp, ch))
506 			if ((ch = *(UCHAR_T *)p--) == '\t')
507 				goto slow;
508 
509 		/*
510 		 * Decrement the screen cursor by the total width of the
511 		 * characters minus 1.
512 		 */
513 		cwtotal -= 1;
514 
515 		/*
516 		 * If we're moving left, and there's a wide character in the
517 		 * current position, go to the end of the character.
518 		 */
519 		if (KEY_COL(sp, ch) > 1)
520 			cwtotal -= KEY_COL(sp, ch) - 1;
521 
522 		/*
523 		 * If the new column moved us off of the current logical line,
524 		 * calculate a new one.  If doing leftright scrolling, we've
525 		 * moved off of the current screen, as well.
526 		 */
527 		if (SCNO < cwtotal)
528 			goto slow;
529 		SCNO -= cwtotal;
530 	} else {
531 		/*
532 		 * 7b: Cursor moved right.
533 		 *
534 		 * Point to the first character to the right.
535 		 */
536 		p += OCNO + 1;
537 		cnt = CNO - OCNO;
538 
539 		/*
540 		 * Count up the widths of the characters.  If it's a tab
541 		 * character, go do it the slow way.  If we cross a
542 		 * screen boundary, we can quit.
543 		 */
544 		for (cwtotal = SCNO; cnt--;) {
545 			if ((ch = *(UCHAR_T *)p++) == '\t')
546 				goto slow;
547 			if ((cwtotal += KEY_COL(sp, ch)) >= SCREEN_COLS(sp))
548 				break;
549 		}
550 
551 		/*
552 		 * Increment the screen cursor by the total width of the
553 		 * characters.
554 		 */
555 		SCNO = cwtotal;
556 
557 		/* See screen change comment in section 6a. */
558 		if (SCNO >= SCREEN_COLS(sp))
559 			goto slow;
560 	}
561 
562 	/*
563 	 * 7c: Fast cursor update.
564 	 *
565 	 * We have the current column, retrieve the current row.
566 	 */
567 fast:	(void)gp->scr_cursor(sp, &y, &notused);
568 	goto done_cursor;
569 
570 	/*
571 	 * 7d: Slow cursor update.
572 	 *
573 	 * Walk through the map and find the current line.
574 	 */
575 slow:	for (smp = HMAP; smp->lno != LNO; ++smp);
576 
577 	/*
578 	 * 7e: Leftright scrolling adjustment.
579 	 *
580 	 * If doing left-right scrolling and the cursor movement has changed
581 	 * the displayed screen, scroll the screen left or right, unless we're
582 	 * updating the info line in which case we just scroll that one line.
583 	 * We adjust the offset up or down until we have a window that covers
584 	 * the current column, making sure that we adjust differently for the
585 	 * first screen as compared to subsequent ones.
586 	 */
587 	if (O_ISSET(sp, O_LEFTRIGHT)) {
588 		/*
589 		 * Get the screen column for this character, and correct
590 		 * for the number option offset.
591 		 */
592 		cnt = vs_columns(sp, NULL, LNO, &CNO, NULL);
593 		if (O_ISSET(sp, O_NUMBER))
594 			cnt -= O_NUMBER_LENGTH;
595 
596 		/* Adjust the window towards the beginning of the line. */
597 		off = smp->coff;
598 		if (off >= cnt) {
599 			do {
600 				if (off >= O_VAL(sp, O_SIDESCROLL))
601 					off -= O_VAL(sp, O_SIDESCROLL);
602 				else {
603 					off = 0;
604 					break;
605 				}
606 			} while (off >= cnt);
607 			goto shifted;
608 		}
609 
610 		/* Adjust the window towards the end of the line. */
611 		if ((off == 0 && off + SCREEN_COLS(sp) < cnt) ||
612 		    (off != 0 && off + sp->cols < cnt)) {
613 			do {
614 				off += O_VAL(sp, O_SIDESCROLL);
615 			} while (off + sp->cols < cnt);
616 
617 shifted:		/* Fill in screen map with the new offset. */
618 			if (F_ISSET(sp, SC_TINPUT_INFO))
619 				smp->coff = off;
620 			else {
621 				for (smp = HMAP; smp <= TMAP; ++smp)
622 					smp->coff = off;
623 				leftright_warp = 1;
624 			}
625 			goto paint;
626 		}
627 
628 		/*
629 		 * We may have jumped here to adjust a leftright screen because
630 		 * redraw was set.  If so, we have to paint the entire screen.
631 		 */
632 		if (F_ISSET(sp, SC_SCR_REDRAW))
633 			goto paint;
634 	}
635 
636 	/*
637 	 * Update the screen lines for this particular file line until we
638 	 * have a new screen cursor position.
639 	 */
640 	for (y = -1,
641 	    vip->sc_smap = NULL; smp <= TMAP && smp->lno == LNO; ++smp) {
642 		if (vs_line(sp, smp, &y, &SCNO))
643 			return (1);
644 		if (y != -1) {
645 			vip->sc_smap = smp;
646 			break;
647 		}
648 	}
649 	goto done_cursor;
650 
651 	/*
652 	 * 8: Repaint the entire screen.
653 	 *
654 	 * Lost big, do what you have to do.  We flush the cache, since
655 	 * SC_SCR_REDRAW gets set when the screen isn't worth fixing, and
656 	 * it's simpler to repaint.  So, don't trust anything that we
657 	 * think we know about it.
658 	 */
659 paint:	for (smp = HMAP; smp <= TMAP; ++smp)
660 		SMAP_FLUSH(smp);
661 	for (y = -1, vip->sc_smap = NULL, smp = HMAP; smp <= TMAP; ++smp) {
662 		if (vs_line(sp, smp, &y, &SCNO))
663 			return (1);
664 		if (y != -1 && vip->sc_smap == NULL)
665 			vip->sc_smap = smp;
666 	}
667 	/*
668 	 * If it's a small screen and we're redrawing, clear the unused lines,
669 	 * ex may have overwritten them.
670 	 */
671 	if (F_ISSET(sp, SC_SCR_REDRAW) && IS_SMALL(sp))
672 		for (cnt = sp->t_rows; cnt <= sp->t_maxrows; ++cnt) {
673 			(void)gp->scr_move(sp, cnt, 0);
674 			(void)gp->scr_clrtoeol(sp);
675 		}
676 
677 	didpaint = 1;
678 
679 done_cursor:
680 	/*
681 	 * Sanity checking.  When the repainting code messes up, the usual
682 	 * result is we don't repaint the cursor and so sc_smap will be
683 	 * NULL.  If we're debugging, die, otherwise restart from scratch.
684 	 */
685 #ifdef DEBUG
686 	if (vip->sc_smap == NULL)
687 		abort();
688 #else
689 	if (vip->sc_smap == NULL) {
690 		F_SET(sp, SC_SCR_REFORMAT);
691 		return (vs_paint(sp, flags));
692 	}
693 #endif
694 
695 	/*
696 	 * 9: Set the remembered cursor values.
697 	 */
698 	OCNO = CNO;
699 	OLNO = LNO;
700 
701 	/*
702 	 * 10: Repaint the line numbers.
703 	 *
704 	 * If O_NUMBER is set and the VIP_N_RENUMBER bit is set, and we
705 	 * didn't repaint the screen, repaint all of the line numbers,
706 	 * they've changed.
707 	 */
708 number:	if (O_ISSET(sp, O_NUMBER) &&
709 	    F_ISSET(vip, VIP_N_RENUMBER) && !didpaint && vs_number(sp))
710 		return (1);
711 
712 	/*
713 	 * 11: Update the mode line, position the cursor, and flush changes.
714 	 *
715 	 * If we warped the screen, we have to refresh everything.
716 	 */
717 	if (leftright_warp)
718 		LF_SET(UPDATE_CURSOR | UPDATE_SCREEN);
719 
720 	if (LF_ISSET(UPDATE_SCREEN) && !IS_ONELINE(sp) &&
721 	    !F_ISSET(vip, VIP_S_MODELINE) && !F_ISSET(sp, SC_TINPUT_INFO))
722 		vs_modeline(sp);
723 
724 	if (LF_ISSET(UPDATE_CURSOR)) {
725 		(void)gp->scr_move(sp, y, SCNO);
726 
727 		/*
728 		 * XXX
729 		 * If the screen shifted, we recalculate the "most favorite"
730 		 * cursor position.  Vi won't know that we've warped the
731 		 * screen, so it's going to have a wrong idea about where the
732 		 * cursor should be.  This is vi's problem, and fixing it here
733 		 * is a gross layering violation.
734 		 */
735 		if (leftright_warp)
736 			(void)vs_column(sp, &sp->rcm);
737 	}
738 
739 	if (LF_ISSET(UPDATE_SCREEN))
740 		(void)gp->scr_refresh(sp, F_ISSET(vip, VIP_N_EX_PAINT));
741 
742 	/* 12: Clear the flags that are handled by this routine. */
743 	F_CLR(sp, SC_SCR_CENTER | SC_SCR_REDRAW | SC_SCR_REFORMAT | SC_SCR_TOP);
744 	F_CLR(vip, VIP_CUR_INVALID |
745 	    VIP_N_EX_PAINT | VIP_N_REFRESH | VIP_N_RENUMBER | VIP_S_MODELINE);
746 
747 	return (0);
748 
749 #undef	 LNO
750 #undef	OLNO
751 #undef	 CNO
752 #undef	OCNO
753 #undef	SCNO
754 }
755 
756 /*
757  * vs_modeline --
758  *	Update the mode line.
759  */
760 static void
761 vs_modeline(SCR *sp)
762 {
763 	static char * const modes[] = {
764 		"215|Append",			/* SM_APPEND */
765 		"216|Change",			/* SM_CHANGE */
766 		"217|Command",			/* SM_COMMAND */
767 		"218|Insert",			/* SM_INSERT */
768 		"219|Replace",			/* SM_REPLACE */
769 	};
770 	GS *gp;
771 	size_t cols, curcol, curlen, endpoint, len, midpoint;
772 	const char *t = NULL;
773 	int ellipsis;
774 	char buf[20];
775 
776 	gp = sp->gp;
777 
778 	/*
779 	 * We put down the file name, the ruler, the mode and the dirty flag.
780 	 * If there's not enough room, there's not enough room, we don't play
781 	 * any special games.  We try to put the ruler in the middle and the
782 	 * mode and dirty flag at the end.
783 	 *
784 	 * !!!
785 	 * Leave the last character blank, in case it's a really dumb terminal
786 	 * with hardware scroll.  Second, don't paint the last character in the
787 	 * screen, SunOS 4.1.1 and Ultrix 4.2 curses won't let you.
788 	 *
789 	 * Move to the last line on the screen.
790 	 */
791 	(void)gp->scr_move(sp, LASTLINE(sp), 0);
792 
793 	/* If more than one screen in the display, show the file name. */
794 	curlen = 0;
795 	if (IS_SPLIT(sp)) {
796 		CHAR_T *wp, *p;
797 		size_t l;
798 
799 		CHAR2INT(sp, sp->frp->name, strlen(sp->frp->name) + 1, wp, l);
800 		p = wp + l;
801 		for (ellipsis = 0, cols = sp->cols / 2; --p > wp;) {
802 			if (*p == '/') {
803 				++p;
804 				break;
805 			}
806 			if ((curlen += KEY_COL(sp, *p)) > cols) {
807 				ellipsis = 3;
808 				curlen +=
809 				    KEY_LEN(sp, '.') * 3 + KEY_LEN(sp, ' ');
810 				while (curlen > cols) {
811 					++p;
812 					curlen -= KEY_COL(sp, *p);
813 				}
814 				break;
815 			}
816 		}
817 		if (ellipsis) {
818 			while (ellipsis--)
819 				(void)gp->scr_addstr(sp,
820 				    KEY_NAME(sp, '.'), KEY_LEN(sp, '.'));
821 			(void)gp->scr_addstr(sp,
822 			    KEY_NAME(sp, ' '), KEY_LEN(sp, ' '));
823 		}
824 		for (; *p != '\0'; ++p)
825 			(void)gp->scr_addstr(sp,
826 			    KEY_NAME(sp, *p), KEY_COL(sp, *p));
827 	}
828 
829 	/* Clear the rest of the line. */
830 	(void)gp->scr_clrtoeol(sp);
831 
832 	/*
833 	 * Display the ruler.  If we're not at the midpoint yet, move there.
834 	 * Otherwise, add in two extra spaces.
835 	 *
836 	 * Adjust the current column for the fact that the editor uses it as
837 	 * a zero-based number.
838 	 *
839 	 * XXX
840 	 * Assume that numbers, commas, and spaces only take up a single
841 	 * column on the screen.
842 	 */
843 	cols = sp->cols - 1;
844 	if (O_ISSET(sp, O_RULER)) {
845 		vs_column(sp, &curcol);
846 		len = snprintf(buf, sizeof(buf), "%lu,%lu",
847 		    (u_long)sp->lno, (u_long)(curcol + 1));
848 
849 		midpoint = (cols - ((len + 1) / 2)) / 2;
850 		if (curlen < midpoint) {
851 			(void)gp->scr_move(sp, LASTLINE(sp), midpoint);
852 			curlen += len;
853 		} else if (curlen + 2 + len < cols) {
854 			(void)gp->scr_addstr(sp, "  ", 2);
855 			curlen += 2 + len;
856 		}
857 		(void)gp->scr_addstr(sp, buf, len);
858 	}
859 
860 	/*
861 	 * Display the mode and the modified flag, as close to the end of the
862 	 * line as possible, but guaranteeing at least two spaces between the
863 	 * ruler and the modified flag.
864 	 */
865 #define	MODESIZE	9
866 	endpoint = cols;
867 	if (O_ISSET(sp, O_SHOWMODE)) {
868 		if (F_ISSET(sp->ep, F_MODIFIED))
869 			--endpoint;
870 		t = msg_cat(sp, modes[sp->showmode], &len);
871 		endpoint -= len;
872 	}
873 
874 	if (endpoint > curlen + 2) {
875 		(void)gp->scr_move(sp, LASTLINE(sp), endpoint);
876 		if (O_ISSET(sp, O_SHOWMODE)) {
877 			if (F_ISSET(sp->ep, F_MODIFIED))
878 				(void)gp->scr_addstr(sp,
879 				    KEY_NAME(sp, '*'), KEY_LEN(sp, '*'));
880 			(void)gp->scr_addstr(sp, t, len);
881 		}
882 	}
883 }
884