xref: /dragonfly/contrib/nvi2/vi/vs_split.c (revision a3b6ff64)
1 /*-
2  * Copyright (c) 1993, 1994
3  *	The Regents of the University of California.  All rights reserved.
4  * Copyright (c) 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 <errno.h>
18 #include <limits.h>
19 #include <stdio.h>
20 #include <stdlib.h>
21 #include <string.h>
22 
23 #include "../common/common.h"
24 #include "vi.h"
25 
26 typedef enum { HORIZ_FOLLOW, HORIZ_PRECEDE, VERT_FOLLOW, VERT_PRECEDE } jdir_t;
27 
28 static SCR	*vs_getbg(SCR *, char *);
29 static void      vs_insert(SCR *sp, GS *gp);
30 static int	 vs_join(SCR *, SCR **, jdir_t *);
31 
32 /*
33  * vs_split --
34  *	Create a new screen, horizontally.
35  *
36  * PUBLIC: int vs_split(SCR *, SCR *, int);
37  */
38 int
39 vs_split(
40 	SCR *sp,
41 	SCR *new,
42 	int ccl)		/* Colon-command line split. */
43 {
44 	GS *gp;
45 	SMAP *smp;
46 	size_t half;
47 	int issmallscreen, splitup;
48 
49 	gp = sp->gp;
50 
51 	/* Check to see if it's possible. */
52 	/* XXX: The IS_ONELINE fix will change this, too. */
53 	if (sp->rows < 4) {
54 		msgq(sp, M_ERR,
55 		    "222|Screen must be larger than %d lines to split", 4 - 1);
56 		return (1);
57 	}
58 
59 	/* Wait for any messages in the screen. */
60 	vs_resolve(sp, NULL, 1);
61 
62 	/* Get a new screen map. */
63 	CALLOC(sp, _HMAP(new), SIZE_HMAP(sp), sizeof(SMAP));
64 	if (_HMAP(new) == NULL)
65 		return (1);
66 	_HMAP(new)->lno = sp->lno;
67 	_HMAP(new)->coff = 0;
68 	_HMAP(new)->soff = 1;
69 
70 	/* Split the screen in half. */
71 	half = sp->rows / 2;
72 	if (ccl && half > 6)
73 		half = 6;
74 
75 	/*
76 	 * Small screens: see vs_refresh.c section 6a.  Set a flag so
77 	 * we know to fix the screen up later.
78 	 */
79 	issmallscreen = IS_SMALL(sp);
80 
81 	/* The columns in the screen don't change. */
82 	new->coff = sp->coff;
83 	new->cols = sp->cols;
84 
85 	/*
86 	 * Split the screen, and link the screens together.  If creating a
87 	 * screen to edit the colon command line or the cursor is in the top
88 	 * half of the current screen, the new screen goes under the current
89 	 * screen.  Else, it goes above the current screen.
90 	 *
91 	 * Recalculate current cursor position based on sp->lno, we're called
92 	 * with the cursor on the colon command line.  Then split the screen
93 	 * in half and update the shared information.
94 	 */
95 	splitup =
96 	    !ccl && (vs_sm_cursor(sp, &smp) ? 0 : (smp - HMAP) + 1) >= half;
97 	if (splitup) {				/* Old is bottom half. */
98 		new->rows = sp->rows - half;	/* New. */
99 		new->roff = sp->roff;
100 		sp->rows = half;		/* Old. */
101 		sp->roff += new->rows;
102 
103 		/*
104 		 * If the parent is the bottom half of the screen, shift
105 		 * the map down to match on-screen text.
106 		 */
107 		memcpy(_HMAP(sp), _HMAP(sp) + new->rows,
108 		    (sp->t_maxrows - new->rows) * sizeof(SMAP));
109 	} else {				/* Old is top half. */
110 		new->rows = half;		/* New. */
111 		sp->rows -= half;		/* Old. */
112 		new->roff = sp->roff + sp->rows;
113 	}
114 
115 	/* Adjust maximum text count. */
116 	sp->t_maxrows = IS_ONELINE(sp) ? 1 : sp->rows - 1;
117 	new->t_maxrows = IS_ONELINE(new) ? 1 : new->rows - 1;
118 
119 	/*
120 	 * Small screens: see vs_refresh.c, section 6a.
121 	 *
122 	 * The child may have different screen options sizes than the parent,
123 	 * so use them.  Guarantee that text counts aren't larger than the
124 	 * new screen sizes.
125 	 */
126 	if (issmallscreen) {
127 		/* Fix the text line count for the parent. */
128 		if (splitup)
129 			sp->t_rows -= new->rows;
130 
131 		/* Fix the parent screen. */
132 		if (sp->t_rows > sp->t_maxrows)
133 			sp->t_rows = sp->t_maxrows;
134 		if (sp->t_minrows > sp->t_maxrows)
135 			sp->t_minrows = sp->t_maxrows;
136 
137 		/* Fix the child screen. */
138 		new->t_minrows = new->t_rows = O_VAL(sp, O_WINDOW);
139 		if (new->t_rows > new->t_maxrows)
140 			new->t_rows = new->t_maxrows;
141 		if (new->t_minrows > new->t_maxrows)
142 			new->t_minrows = new->t_maxrows;
143 	} else {
144 		sp->t_minrows = sp->t_rows = IS_ONELINE(sp) ? 1 : sp->rows - 1;
145 
146 		/*
147 		 * The new screen may be a small screen, even if the parent
148 		 * was not.  Don't complain if O_WINDOW is too large, we're
149 		 * splitting the screen so the screen is much smaller than
150 		 * normal.
151 		 */
152 		new->t_minrows = new->t_rows = O_VAL(sp, O_WINDOW);
153 		if (new->t_rows > new->rows - 1)
154 			new->t_minrows = new->t_rows =
155 			    IS_ONELINE(new) ? 1 : new->rows - 1;
156 	}
157 
158 	/* Adjust the ends of the new and old maps. */
159 	_TMAP(sp) = IS_ONELINE(sp) ?
160 	    _HMAP(sp) : _HMAP(sp) + (sp->t_rows - 1);
161 	_TMAP(new) = IS_ONELINE(new) ?
162 	    _HMAP(new) : _HMAP(new) + (new->t_rows - 1);
163 
164 	/* Reset the length of the default scroll. */
165 	if ((sp->defscroll = sp->t_maxrows / 2) == 0)
166 		sp->defscroll = 1;
167 	if ((new->defscroll = new->t_maxrows / 2) == 0)
168 		new->defscroll = 1;
169 
170 	/* Fit the screen into the logical chain. */
171 	vs_insert(new, sp->gp);
172 
173 	/* Tell the display that we're splitting. */
174 	(void)gp->scr_split(sp, new);
175 
176 	/*
177 	 * Initialize the screen flags:
178 	 *
179 	 * If we're in vi mode in one screen, we don't have to reinitialize.
180 	 * This isn't just a cosmetic fix.  The path goes like this:
181 	 *
182 	 *	return into vi(), SC_SSWITCH set
183 	 *	call vs_refresh() with SC_STATUS set
184 	 *	call vs_resolve to display the status message
185 	 *	call vs_refresh() because the SC_SCR_VI bit isn't set
186 	 *
187 	 * Things go downhill at this point.
188 	 *
189 	 * Draw the new screen from scratch, and add a status line.
190 	 */
191 	F_SET(new,
192 	    SC_SCR_REFORMAT | SC_STATUS |
193 	    F_ISSET(sp, SC_EX | SC_VI | SC_SCR_VI | SC_SCR_EX | SC_READONLY));
194 	return (0);
195 }
196 
197 /*
198  * vs_vsplit --
199  *	Create a new screen, vertically.
200  *
201  * PUBLIC: int vs_vsplit(SCR *, SCR *);
202  */
203 int
204 vs_vsplit(SCR *sp, SCR *new)
205 {
206 	GS *gp;
207 	size_t cols;
208 
209 	gp = sp->gp;
210 
211 	/* Check to see if it's possible. */
212 	if (sp->cols / 2 <= MINIMUM_SCREEN_COLS) {
213 		msgq(sp, M_ERR,
214 		    "288|Screen must be larger than %d columns to split",
215 		    MINIMUM_SCREEN_COLS * 2);
216 		return (1);
217 	}
218 
219 	/* Wait for any messages in the screen. */
220 	vs_resolve(sp, NULL, 1);
221 
222 	/* Get a new screen map. */
223 	CALLOC(sp, _HMAP(new), SIZE_HMAP(sp), sizeof(SMAP));
224 	if (_HMAP(new) == NULL)
225 		return (1);
226 	_HMAP(new)->lno = sp->lno;
227 	_HMAP(new)->coff = 0;
228 	_HMAP(new)->soff = 1;
229 
230 	/*
231 	 * Split the screen in half; we have to sacrifice a column to delimit
232 	 * the screens.
233 	 *
234 	 * XXX
235 	 * We always split to the right... that makes more sense to me, and
236 	 * I don't want to play the stupid games that I play when splitting
237 	 * horizontally.
238 	 *
239 	 * XXX
240 	 * We reserve a column for the screen, "knowing" that curses needs
241 	 * one.  This should be worked out with the display interface.
242 	 */
243 	cols = sp->cols / 2;
244 	new->cols = sp->cols - cols - 1;
245 	sp->cols = cols;
246 	new->coff = sp->coff + cols + 1;
247 	sp->cno = 0;
248 
249 	/* Nothing else changes. */
250 	new->rows = sp->rows;
251 	new->t_rows = sp->t_rows;
252 	new->t_maxrows = sp->t_maxrows;
253 	new->t_minrows = sp->t_minrows;
254 	new->roff = sp->roff;
255 	new->defscroll = sp->defscroll;
256 	_TMAP(new) = _HMAP(new) + (new->t_rows - 1);
257 
258 	/* Fit the screen into the logical chain. */
259 	vs_insert(new, sp->gp);
260 
261 	/* Tell the display that we're splitting. */
262 	(void)gp->scr_split(sp, new);
263 
264 	/* Redraw the old screen from scratch. */
265 	F_SET(sp, SC_SCR_REFORMAT | SC_STATUS);
266 
267 	/*
268 	 * Initialize the screen flags:
269 	 *
270 	 * If we're in vi mode in one screen, we don't have to reinitialize.
271 	 * This isn't just a cosmetic fix.  The path goes like this:
272 	 *
273 	 *	return into vi(), SC_SSWITCH set
274 	 *	call vs_refresh() with SC_STATUS set
275 	 *	call vs_resolve to display the status message
276 	 *	call vs_refresh() because the SC_SCR_VI bit isn't set
277 	 *
278 	 * Things go downhill at this point.
279 	 *
280 	 * Draw the new screen from scratch, and add a status line.
281 	 */
282 	F_SET(new,
283 	    SC_SCR_REFORMAT | SC_STATUS |
284 	    F_ISSET(sp, SC_EX | SC_VI | SC_SCR_VI | SC_SCR_EX | SC_READONLY));
285 	return (0);
286 }
287 
288 /*
289  * vs_insert --
290  *	Insert the new screen into the correct place in the logical
291  *	chain.
292  */
293 static void
294 vs_insert(SCR *sp, GS *gp)
295 {
296 	SCR *tsp;
297 
298 	gp = sp->gp;
299 
300 	/* Move past all screens with lower row numbers. */
301 	TAILQ_FOREACH(tsp, gp->dq, q)
302 		if (tsp->roff >= sp->roff)
303 			break;
304 	/*
305 	 * Move past all screens with the same row number and lower
306 	 * column numbers.
307 	 */
308 	for (; tsp != NULL; tsp = TAILQ_NEXT(tsp, q))
309 		if (tsp->roff != sp->roff || tsp->coff > sp->coff)
310 			break;
311 
312 	/*
313 	 * If we reached the end, this screen goes there.  Otherwise,
314 	 * put it before or after the screen where we stopped.
315 	 */
316 	if (tsp == NULL) {
317 		TAILQ_INSERT_TAIL(gp->dq, sp, q);
318 	} else if (tsp->roff < sp->roff ||
319 	    (tsp->roff == sp->roff && tsp->coff < sp->coff)) {
320 		TAILQ_INSERT_AFTER(gp->dq, tsp, sp, q);
321 	} else
322 		TAILQ_INSERT_BEFORE(tsp, sp, q);
323 }
324 
325 /*
326  * vs_discard --
327  *	Discard the screen, folding the real-estate into a related screen,
328  *	if one exists, and return that screen.
329  *
330  * PUBLIC: int vs_discard(SCR *, SCR **);
331  */
332 int
333 vs_discard(SCR *sp, SCR **spp)
334 {
335 	GS *gp;
336 	SCR *tsp, **lp, *list[100];
337 	jdir_t jdir;
338 
339 	gp = sp->gp;
340 
341 	/*
342 	 * Save the old screen's cursor information.
343 	 *
344 	 * XXX
345 	 * If called after file_end(), and the underlying file was a tmp
346 	 * file, it may have gone away.
347 	 */
348 	if (sp->frp != NULL) {
349 		sp->frp->lno = sp->lno;
350 		sp->frp->cno = sp->cno;
351 		F_SET(sp->frp, FR_CURSORSET);
352 	}
353 
354 	/* If no other screens to join, we're done. */
355 	if (!IS_SPLIT(sp)) {
356 		(void)gp->scr_discard(sp, NULL);
357 
358 		if (spp != NULL)
359 			*spp = NULL;
360 		return (0);
361 	}
362 
363 	/*
364 	 * Find a set of screens that cover one of the screen's borders.
365 	 * Check the vertical axis first, for no particular reason.
366 	 *
367 	 * XXX
368 	 * It's possible (I think?), to create a screen that shares no full
369 	 * border with any other set of screens, so we can't discard it.  We
370 	 * just complain at the user until they clean it up.
371 	 */
372 	if (vs_join(sp, list, &jdir))
373 		return (1);
374 
375 	/*
376 	 * Modify the affected screens.  Redraw the modified screen(s) from
377 	 * scratch, setting a status line.  If this is ever a performance
378 	 * problem we could play games with the map, but I wrote that code
379 	 * before and it was never clean or easy.
380 	 *
381 	 * Don't clean up the discarded screen's information.  If the screen
382 	 * isn't exiting, we'll do the work when the user redisplays it.
383 	 */
384 	switch (jdir) {
385 	case HORIZ_FOLLOW:
386 	case HORIZ_PRECEDE:
387 		for (lp = &list[0]; (tsp = *lp) != NULL; ++lp) {
388 			/*
389 			 * Small screens: see vs_refresh.c section 6a.  Adjust
390 			 * text line info, unless it's a small screen.
391 			 *
392 			 * Reset the length of the default scroll.
393 			 *
394 			 * Reset the map references.
395 			 */
396 			tsp->rows += sp->rows;
397 			if (!IS_SMALL(tsp))
398 				tsp->t_rows = tsp->t_minrows = tsp->rows - 1;
399 			tsp->t_maxrows = tsp->rows - 1;
400 
401 			tsp->defscroll = tsp->t_maxrows / 2;
402 
403 			*(_HMAP(tsp) + (tsp->t_rows - 1)) = *_TMAP(tsp);
404 			_TMAP(tsp) = _HMAP(tsp) + (tsp->t_rows - 1);
405 
406 			switch (jdir) {
407 			case HORIZ_FOLLOW:
408 				tsp->roff = sp->roff;
409 				vs_sm_fill(tsp, OOBLNO, P_TOP);
410 				break;
411 			case HORIZ_PRECEDE:
412 				vs_sm_fill(tsp, OOBLNO, P_BOTTOM);
413 				break;
414 			default:
415 				abort();
416 			}
417 			F_SET(tsp, SC_STATUS);
418 		}
419 		break;
420 	case VERT_FOLLOW:
421 	case VERT_PRECEDE:
422 		for (lp = &list[0]; (tsp = *lp) != NULL; ++lp) {
423 			if (jdir == VERT_FOLLOW)
424 				tsp->coff = sp->coff;
425 			tsp->cols += sp->cols + 1;	/* XXX: DIVIDER */
426 			vs_sm_fill(tsp, OOBLNO, P_TOP);
427 			F_SET(tsp, SC_STATUS);
428 		}
429 		break;
430 	default:
431 		abort();
432 	}
433 
434 	/* Find the closest screen that changed and move to it. */
435 	tsp = list[0];
436 	if (spp != NULL)
437 		*spp = tsp;
438 
439 	/* Tell the display that we're discarding a screen. */
440 	(void)gp->scr_discard(sp, list);
441 
442 	return (0);
443 }
444 
445 /*
446  * vs_join --
447  *	Find a set of screens that covers a screen's border.
448  */
449 static int
450 vs_join(SCR *sp, SCR **listp, jdir_t *jdirp)
451 {
452 	GS *gp;
453 	SCR **lp, *tsp;
454 	int first;
455 	size_t tlen;
456 
457 	gp = sp->gp;
458 
459 	/* Check preceding vertical. */
460 	for (lp = listp, tlen = sp->rows,
461 	    tsp = TAILQ_FIRST(gp->dq);
462 	    tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) {
463 		if (sp == tsp)
464 			continue;
465 		/* Test if precedes the screen vertically. */
466 		if (tsp->coff + tsp->cols + 1 != sp->coff)
467 			continue;
468 		/*
469 		 * Test if a subset on the vertical axis.  If overlaps the
470 		 * beginning or end, we can't join on this axis at all.
471 		 */
472 		if (tsp->roff > sp->roff + sp->rows)
473 			continue;
474 		if (tsp->roff < sp->roff) {
475 			if (tsp->roff + tsp->rows >= sp->roff)
476 				break;
477 			continue;
478 		}
479 		if (tsp->roff + tsp->rows > sp->roff + sp->rows)
480 			break;
481 #ifdef DEBUG
482 		if (tlen < tsp->rows)
483 			abort();
484 #endif
485 		tlen -= tsp->rows;
486 		*lp++ = tsp;
487 	}
488 	if (tlen == 0) {
489 		*lp = NULL;
490 		*jdirp = VERT_PRECEDE;
491 		return (0);
492 	}
493 
494 	/* Check following vertical. */
495 	for (lp = listp, tlen = sp->rows,
496 	    tsp = TAILQ_FIRST(gp->dq);
497 	    tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) {
498 		if (sp == tsp)
499 			continue;
500 		/* Test if follows the screen vertically. */
501 		if (tsp->coff != sp->coff + sp->cols + 1)
502 			continue;
503 		/*
504 		 * Test if a subset on the vertical axis.  If overlaps the
505 		 * beginning or end, we can't join on this axis at all.
506 		 */
507 		if (tsp->roff > sp->roff + sp->rows)
508 			continue;
509 		if (tsp->roff < sp->roff) {
510 			if (tsp->roff + tsp->rows >= sp->roff)
511 				break;
512 			continue;
513 		}
514 		if (tsp->roff + tsp->rows > sp->roff + sp->rows)
515 			break;
516 #ifdef DEBUG
517 		if (tlen < tsp->rows)
518 			abort();
519 #endif
520 		tlen -= tsp->rows;
521 		*lp++ = tsp;
522 	}
523 	if (tlen == 0) {
524 		*lp = NULL;
525 		*jdirp = VERT_FOLLOW;
526 		return (0);
527 	}
528 
529 	/* Check preceding horizontal. */
530 	for (first = 0, lp = listp, tlen = sp->cols,
531 	    tsp = TAILQ_FIRST(gp->dq);
532 	    tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) {
533 		if (sp == tsp)
534 			continue;
535 		/* Test if precedes the screen horizontally. */
536 		if (tsp->roff + tsp->rows != sp->roff)
537 			continue;
538 		/*
539 		 * Test if a subset on the horizontal axis.  If overlaps the
540 		 * beginning or end, we can't join on this axis at all.
541 		 */
542 		if (tsp->coff > sp->coff + sp->cols)
543 			continue;
544 		if (tsp->coff < sp->coff) {
545 			if (tsp->coff + tsp->cols >= sp->coff)
546 				break;
547 			continue;
548 		}
549 		if (tsp->coff + tsp->cols > sp->coff + sp->cols)
550 			break;
551 #ifdef DEBUG
552 		if (tlen < tsp->cols)
553 			abort();
554 #endif
555 		tlen -= tsp->cols + first;
556 		first = 1;
557 		*lp++ = tsp;
558 	}
559 	if (tlen == 0) {
560 		*lp = NULL;
561 		*jdirp = HORIZ_PRECEDE;
562 		return (0);
563 	}
564 
565 	/* Check following horizontal. */
566 	for (first = 0, lp = listp, tlen = sp->cols,
567 	    tsp = TAILQ_FIRST(gp->dq);
568 	    tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) {
569 		if (sp == tsp)
570 			continue;
571 		/* Test if precedes the screen horizontally. */
572 		if (tsp->roff != sp->roff + sp->rows)
573 			continue;
574 		/*
575 		 * Test if a subset on the horizontal axis.  If overlaps the
576 		 * beginning or end, we can't join on this axis at all.
577 		 */
578 		if (tsp->coff > sp->coff + sp->cols)
579 			continue;
580 		if (tsp->coff < sp->coff) {
581 			if (tsp->coff + tsp->cols >= sp->coff)
582 				break;
583 			continue;
584 		}
585 		if (tsp->coff + tsp->cols > sp->coff + sp->cols)
586 			break;
587 #ifdef DEBUG
588 		if (tlen < tsp->cols)
589 			abort();
590 #endif
591 		tlen -= tsp->cols + first;
592 		first = 1;
593 		*lp++ = tsp;
594 	}
595 	if (tlen == 0) {
596 		*lp = NULL;
597 		*jdirp = HORIZ_FOLLOW;
598 		return (0);
599 	}
600 	return (1);
601 }
602 
603 /*
604  * vs_fg --
605  *	Background the current screen, and foreground a new one.
606  *
607  * PUBLIC: int vs_fg(SCR *, SCR **, CHAR_T *, int);
608  */
609 int
610 vs_fg(SCR *sp, SCR **nspp, CHAR_T *name, int newscreen)
611 {
612 	GS *gp;
613 	SCR *nsp;
614 	char *np;
615 	size_t nlen;
616 
617 	gp = sp->gp;
618 
619 	if (name)
620 	    INT2CHAR(sp, name, STRLEN(name) + 1, np, nlen);
621 	else
622 	    np = NULL;
623 	if (newscreen)
624 		/* Get the specified background screen. */
625 		nsp = vs_getbg(sp, np);
626 	else
627 		/* Swap screens. */
628 		if (vs_swap(sp, &nsp, np))
629 			return (1);
630 
631 	if ((*nspp = nsp) == NULL) {
632 		msgq_wstr(sp, M_ERR, name,
633 		    name == NULL ?
634 		    "223|There are no background screens" :
635 		    "224|There's no background screen editing a file named %s");
636 		return (1);
637 	}
638 
639 	if (newscreen) {
640 		/* Remove the new screen from the background queue. */
641 		TAILQ_REMOVE(gp->hq, nsp, q);
642 
643 		/* Split the screen; if we fail, hook the screen back in. */
644 		if (vs_split(sp, nsp, 0)) {
645 			TAILQ_INSERT_TAIL(gp->hq, nsp, q);
646 			return (1);
647 		}
648 	} else {
649 		/* Move the old screen to the background queue. */
650 		TAILQ_REMOVE(gp->dq, sp, q);
651 		TAILQ_INSERT_TAIL(gp->hq, sp, q);
652 	}
653 	return (0);
654 }
655 
656 /*
657  * vs_bg --
658  *	Background the screen, and switch to the next one.
659  *
660  * PUBLIC: int vs_bg(SCR *);
661  */
662 int
663 vs_bg(SCR *sp)
664 {
665 	GS *gp;
666 	SCR *nsp;
667 
668 	gp = sp->gp;
669 
670 	/* Try and join with another screen. */
671 	if (vs_discard(sp, &nsp))
672 		return (1);
673 	if (nsp == NULL) {
674 		msgq(sp, M_ERR,
675 		    "225|You may not background your only displayed screen");
676 		return (1);
677 	}
678 
679 	/* Move the old screen to the background queue. */
680 	TAILQ_REMOVE(gp->dq, sp, q);
681 	TAILQ_INSERT_TAIL(gp->hq, sp, q);
682 
683 	/* Toss the screen map. */
684 	free(_HMAP(sp));
685 	_HMAP(sp) = NULL;
686 
687 	/* Switch screens. */
688 	sp->nextdisp = nsp;
689 	F_SET(sp, SC_SSWITCH);
690 
691 	return (0);
692 }
693 
694 /*
695  * vs_swap --
696  *	Swap the current screen with a backgrounded one.
697  *
698  * PUBLIC: int vs_swap(SCR *, SCR **, char *);
699  */
700 int
701 vs_swap(SCR *sp, SCR **nspp, char *name)
702 {
703 	GS *gp;
704 	SCR *nsp, *list[2];
705 
706 	gp = sp->gp;
707 
708 	/* Get the specified background screen. */
709 	if ((*nspp = nsp = vs_getbg(sp, name)) == NULL)
710 		return (0);
711 
712 	/*
713 	 * Save the old screen's cursor information.
714 	 *
715 	 * XXX
716 	 * If called after file_end(), and the underlying file was a tmp
717 	 * file, it may have gone away.
718 	 */
719 	if (sp->frp != NULL) {
720 		sp->frp->lno = sp->lno;
721 		sp->frp->cno = sp->cno;
722 		F_SET(sp->frp, FR_CURSORSET);
723 	}
724 
725 	/* Switch screens. */
726 	sp->nextdisp = nsp;
727 	F_SET(sp, SC_SSWITCH);
728 
729 	/* Initialize terminal information. */
730 	VIP(nsp)->srows = VIP(sp)->srows;
731 
732 	/* Initialize screen information. */
733 	nsp->cols = sp->cols;
734 	nsp->rows = sp->rows;	/* XXX: Only place in vi that sets rows. */
735 	nsp->roff = sp->roff;
736 
737 	/*
738 	 * Small screens: see vs_refresh.c, section 6a.
739 	 *
740 	 * The new screens may have different screen options sizes than the
741 	 * old one, so use them.  Make sure that text counts aren't larger
742 	 * than the new screen sizes.
743 	 */
744 	if (IS_SMALL(nsp)) {
745 		nsp->t_minrows = nsp->t_rows = O_VAL(nsp, O_WINDOW);
746 		if (nsp->t_rows > sp->t_maxrows)
747 			nsp->t_rows = nsp->t_maxrows;
748 		if (nsp->t_minrows > sp->t_maxrows)
749 			nsp->t_minrows = nsp->t_maxrows;
750 	} else
751 		nsp->t_rows = nsp->t_maxrows = nsp->t_minrows = nsp->rows - 1;
752 
753 	/* Reset the length of the default scroll. */
754 	nsp->defscroll = nsp->t_maxrows / 2;
755 
756 	/* Allocate a new screen map. */
757 	CALLOC_RET(nsp, _HMAP(nsp), SIZE_HMAP(nsp), sizeof(SMAP));
758 	_TMAP(nsp) = _HMAP(nsp) + (nsp->t_rows - 1);
759 
760 	/* Fill the map. */
761 	nsp->gp = sp->gp;
762 	if (vs_sm_fill(nsp, nsp->lno, P_FILL))
763 		return (1);
764 
765 	/*
766 	 * The new screen replaces the old screen in the parent/child list.
767 	 * We insert the new screen after the old one.  If we're exiting,
768 	 * the exit will delete the old one, if we're foregrounding, the fg
769 	 * code will move the old one to the background queue.
770 	 */
771 	TAILQ_REMOVE(gp->hq, nsp, q);
772 	TAILQ_INSERT_AFTER(gp->dq, sp, nsp, q);
773 
774 	/*
775 	 * Don't change the screen's cursor information other than to
776 	 * note that the cursor is wrong.
777 	 */
778 	F_SET(VIP(nsp), VIP_CUR_INVALID);
779 
780 	/* Draw the new screen from scratch, and add a status line. */
781 	F_SET(nsp, SC_SCR_REDRAW | SC_STATUS);
782 
783 	list[0] = nsp; list[1] = NULL;
784 	(void)gp->scr_discard(sp, list);
785 
786 	return (0);
787 }
788 
789 /*
790  * vs_resize --
791  *	Change the absolute size of the current screen.
792  *
793  * PUBLIC: int vs_resize(SCR *, long, adj_t);
794  */
795 int
796 vs_resize(SCR *sp, long int count, adj_t adj)
797 {
798 	GS *gp;
799 	SCR *g, *s, *prev, *next, *list[3] = {NULL, NULL, NULL};
800 	size_t g_off, s_off;
801 
802 	gp = sp->gp;
803 
804 	/*
805 	 * Figure out which screens will grow, which will shrink, and
806 	 * make sure it's possible.
807 	 */
808 	if (count == 0)
809 		return (0);
810 	if (adj == A_SET) {
811 		if (sp->t_maxrows == count)
812 			return (0);
813 		if (sp->t_maxrows > count) {
814 			adj = A_DECREASE;
815 			count = sp->t_maxrows - count;
816 		} else {
817 			adj = A_INCREASE;
818 			count = count - sp->t_maxrows;
819 		}
820 	}
821 
822 	/* Find first overlapping screen */
823 	for (next = TAILQ_NEXT(sp, q); next != NULL &&
824 	     (next->coff >= sp->coff + sp->cols ||
825 	      next->coff + next->cols <= sp->coff);
826 	     next = TAILQ_NEXT(next, q));
827 	/* See if we can use it */
828 	if (next != NULL &&
829 	    (sp->coff != next->coff || sp->cols != next->cols))
830 		next = NULL;
831 	for (prev = TAILQ_PREV(sp, _dqh, q); prev != NULL &&
832 	     (prev->coff >= sp->coff + sp->cols ||
833 	      prev->coff + prev->cols <= sp->coff);
834 	     prev = TAILQ_PREV(prev, _dqh, q));
835 	if (prev != NULL &&
836 	    (sp->coff != prev->coff || sp->cols != prev->cols))
837 		prev = NULL;
838 
839 	g_off = s_off = 0;
840 	if (adj == A_DECREASE) {
841 		if (count < 0)
842 			count = -count;
843 		s = sp;
844 		if (s->t_maxrows < MINIMUM_SCREEN_ROWS + count)
845 			goto toosmall;
846 		if ((g = prev) == NULL) {
847 			if ((g = next) == NULL)
848 				goto toobig;
849 			g_off = -count;
850 		} else
851 			s_off = count;
852 	} else {
853 		g = sp;
854 		if ((s = next) != NULL &&
855 		    s->t_maxrows >= MINIMUM_SCREEN_ROWS + count)
856 				s_off = count;
857 		else
858 			s = NULL;
859 		if (s == NULL) {
860 			if ((s = prev) == NULL) {
861 toobig:				msgq(sp, M_BERR, adj == A_DECREASE ?
862 				    "227|The screen cannot shrink" :
863 				    "228|The screen cannot grow");
864 				return (1);
865 			}
866 			if (s->t_maxrows < MINIMUM_SCREEN_ROWS + count) {
867 toosmall:			msgq(sp, M_BERR,
868 				    "226|The screen can only shrink to %d rows",
869 				    MINIMUM_SCREEN_ROWS);
870 				return (1);
871 			}
872 			g_off = -count;
873 		}
874 	}
875 
876 	/*
877 	 * Fix up the screens; we could optimize the reformatting of the
878 	 * screen, but this isn't likely to be a common enough operation
879 	 * to make it worthwhile.
880 	 */
881 	s->rows += -count;
882 	s->roff += s_off;
883 	g->rows += count;
884 	g->roff += g_off;
885 
886 	g->t_rows += count;
887 	if (g->t_minrows == g->t_maxrows)
888 		g->t_minrows += count;
889 	g->t_maxrows += count;
890 	_TMAP(g) += count;
891 	F_SET(g, SC_SCR_REFORMAT | SC_STATUS);
892 
893 	s->t_rows -= count;
894 	s->t_maxrows -= count;
895 	if (s->t_minrows > s->t_maxrows)
896 		s->t_minrows = s->t_maxrows;
897 	_TMAP(s) -= count;
898 	F_SET(s, SC_SCR_REFORMAT | SC_STATUS);
899 
900 	/* XXXX */
901 	list[0] = g; list[1] = s;
902 	gp->scr_discard(0, list);
903 
904 	return (0);
905 }
906 
907 /*
908  * vs_getbg --
909  *	Get the specified background screen, or, if name is NULL, the first
910  *	background screen.
911  */
912 static SCR *
913 vs_getbg(SCR *sp, char *name)
914 {
915 	GS *gp;
916 	SCR *nsp;
917 	char *p;
918 
919 	gp = sp->gp;
920 
921 	/* If name is NULL, return the first background screen on the list. */
922 	if (name == NULL)
923 		return (TAILQ_FIRST(gp->hq));
924 
925 	/* Search for a full match. */
926 	TAILQ_FOREACH(nsp, gp->hq, q)
927 		if (!strcmp(nsp->frp->name, name))
928 			break;
929 	if (nsp != NULL)
930 		return (nsp);
931 
932 	/* Search for a last-component match. */
933 	TAILQ_FOREACH(nsp, gp->hq, q) {
934 		if ((p = strrchr(nsp->frp->name, '/')) == NULL)
935 			p = nsp->frp->name;
936 		else
937 			++p;
938 		if (!strcmp(p, name))
939 			break;
940 	}
941 	if (nsp != NULL)
942 		return (nsp);
943 
944 	return (NULL);
945 }
946