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