1b8ba871bSPeter Wemm /*-
2b8ba871bSPeter Wemm * Copyright (c) 1993, 1994
3b8ba871bSPeter Wemm * The Regents of the University of California. All rights reserved.
4b8ba871bSPeter Wemm * Copyright (c) 1993, 1994, 1995, 1996
5b8ba871bSPeter Wemm * Keith Bostic. All rights reserved.
6b8ba871bSPeter Wemm *
7b8ba871bSPeter Wemm * See the LICENSE file for redistribution information.
8b8ba871bSPeter Wemm */
9b8ba871bSPeter Wemm
10b8ba871bSPeter Wemm #include "config.h"
11b8ba871bSPeter Wemm
12b8ba871bSPeter Wemm #include <sys/types.h>
13b8ba871bSPeter Wemm #include <sys/queue.h>
14b8ba871bSPeter Wemm #include <sys/time.h>
15b8ba871bSPeter Wemm
16b8ba871bSPeter Wemm #include <bitstring.h>
17b8ba871bSPeter Wemm #include <errno.h>
18b8ba871bSPeter Wemm #include <limits.h>
19b8ba871bSPeter Wemm #include <stdio.h>
20b8ba871bSPeter Wemm #include <stdlib.h>
21b8ba871bSPeter Wemm #include <string.h>
22b8ba871bSPeter Wemm
23b8ba871bSPeter Wemm #include "../common/common.h"
24b8ba871bSPeter Wemm #include "vi.h"
25b8ba871bSPeter Wemm
26b8ba871bSPeter Wemm typedef enum { HORIZ_FOLLOW, HORIZ_PRECEDE, VERT_FOLLOW, VERT_PRECEDE } jdir_t;
27b8ba871bSPeter Wemm
28b8ba871bSPeter Wemm static SCR *vs_getbg(SCR *, char *);
29b8ba871bSPeter Wemm static void vs_insert(SCR *sp, GS *gp);
30b8ba871bSPeter Wemm static int vs_join(SCR *, SCR **, jdir_t *);
31b8ba871bSPeter Wemm
32b8ba871bSPeter Wemm /*
33b8ba871bSPeter Wemm * vs_split --
34b8ba871bSPeter Wemm * Create a new screen, horizontally.
35b8ba871bSPeter Wemm *
36b8ba871bSPeter Wemm * PUBLIC: int vs_split(SCR *, SCR *, int);
37b8ba871bSPeter Wemm */
38b8ba871bSPeter Wemm int
vs_split(SCR * sp,SCR * new,int ccl)39b8ba871bSPeter Wemm vs_split(
40b8ba871bSPeter Wemm SCR *sp,
41b8ba871bSPeter Wemm SCR *new,
42b8ba871bSPeter Wemm int ccl) /* Colon-command line split. */
43b8ba871bSPeter Wemm {
44b8ba871bSPeter Wemm GS *gp;
45b8ba871bSPeter Wemm SMAP *smp;
46b8ba871bSPeter Wemm size_t half;
47b8ba871bSPeter Wemm int issmallscreen, splitup;
48b8ba871bSPeter Wemm
49b8ba871bSPeter Wemm gp = sp->gp;
50b8ba871bSPeter Wemm
51b8ba871bSPeter Wemm /* Check to see if it's possible. */
52b8ba871bSPeter Wemm /* XXX: The IS_ONELINE fix will change this, too. */
53b8ba871bSPeter Wemm if (sp->rows < 4) {
54b8ba871bSPeter Wemm msgq(sp, M_ERR,
55b8ba871bSPeter Wemm "222|Screen must be larger than %d lines to split", 4 - 1);
56b8ba871bSPeter Wemm return (1);
57b8ba871bSPeter Wemm }
58b8ba871bSPeter Wemm
59b8ba871bSPeter Wemm /* Wait for any messages in the screen. */
60b8ba871bSPeter Wemm vs_resolve(sp, NULL, 1);
61b8ba871bSPeter Wemm
62b8ba871bSPeter Wemm /* Get a new screen map. */
63b8ba871bSPeter Wemm CALLOC(sp, _HMAP(new), SIZE_HMAP(sp), sizeof(SMAP));
64b8ba871bSPeter Wemm if (_HMAP(new) == NULL)
65b8ba871bSPeter Wemm return (1);
66b8ba871bSPeter Wemm _HMAP(new)->lno = sp->lno;
67b8ba871bSPeter Wemm _HMAP(new)->coff = 0;
68b8ba871bSPeter Wemm _HMAP(new)->soff = 1;
69b8ba871bSPeter Wemm
70b8ba871bSPeter Wemm /* Split the screen in half. */
71b8ba871bSPeter Wemm half = sp->rows / 2;
72b8ba871bSPeter Wemm if (ccl && half > 6)
73b8ba871bSPeter Wemm half = 6;
74b8ba871bSPeter Wemm
75b8ba871bSPeter Wemm /*
76b8ba871bSPeter Wemm * Small screens: see vs_refresh.c section 6a. Set a flag so
77b8ba871bSPeter Wemm * we know to fix the screen up later.
78b8ba871bSPeter Wemm */
79b8ba871bSPeter Wemm issmallscreen = IS_SMALL(sp);
80b8ba871bSPeter Wemm
81b8ba871bSPeter Wemm /* The columns in the screen don't change. */
82b8ba871bSPeter Wemm new->coff = sp->coff;
83b8ba871bSPeter Wemm new->cols = sp->cols;
84b8ba871bSPeter Wemm
85b8ba871bSPeter Wemm /*
86b8ba871bSPeter Wemm * Split the screen, and link the screens together. If creating a
87b8ba871bSPeter Wemm * screen to edit the colon command line or the cursor is in the top
88b8ba871bSPeter Wemm * half of the current screen, the new screen goes under the current
89b8ba871bSPeter Wemm * screen. Else, it goes above the current screen.
90b8ba871bSPeter Wemm *
91b8ba871bSPeter Wemm * Recalculate current cursor position based on sp->lno, we're called
92b8ba871bSPeter Wemm * with the cursor on the colon command line. Then split the screen
93b8ba871bSPeter Wemm * in half and update the shared information.
94b8ba871bSPeter Wemm */
95b8ba871bSPeter Wemm splitup =
96b8ba871bSPeter Wemm !ccl && (vs_sm_cursor(sp, &smp) ? 0 : (smp - HMAP) + 1) >= half;
97b8ba871bSPeter Wemm if (splitup) { /* Old is bottom half. */
98b8ba871bSPeter Wemm new->rows = sp->rows - half; /* New. */
99b8ba871bSPeter Wemm new->roff = sp->roff;
100b8ba871bSPeter Wemm sp->rows = half; /* Old. */
101b8ba871bSPeter Wemm sp->roff += new->rows;
102b8ba871bSPeter Wemm
103b8ba871bSPeter Wemm /*
104b8ba871bSPeter Wemm * If the parent is the bottom half of the screen, shift
105b8ba871bSPeter Wemm * the map down to match on-screen text.
106b8ba871bSPeter Wemm */
107b8ba871bSPeter Wemm memcpy(_HMAP(sp), _HMAP(sp) + new->rows,
108b8ba871bSPeter Wemm (sp->t_maxrows - new->rows) * sizeof(SMAP));
109b8ba871bSPeter Wemm } else { /* Old is top half. */
110b8ba871bSPeter Wemm new->rows = half; /* New. */
111b8ba871bSPeter Wemm sp->rows -= half; /* Old. */
112b8ba871bSPeter Wemm new->roff = sp->roff + sp->rows;
113b8ba871bSPeter Wemm }
114b8ba871bSPeter Wemm
115b8ba871bSPeter Wemm /* Adjust maximum text count. */
116b8ba871bSPeter Wemm sp->t_maxrows = IS_ONELINE(sp) ? 1 : sp->rows - 1;
117b8ba871bSPeter Wemm new->t_maxrows = IS_ONELINE(new) ? 1 : new->rows - 1;
118b8ba871bSPeter Wemm
119b8ba871bSPeter Wemm /*
120b8ba871bSPeter Wemm * Small screens: see vs_refresh.c, section 6a.
121b8ba871bSPeter Wemm *
122b8ba871bSPeter Wemm * The child may have different screen options sizes than the parent,
123b8ba871bSPeter Wemm * so use them. Guarantee that text counts aren't larger than the
124b8ba871bSPeter Wemm * new screen sizes.
125b8ba871bSPeter Wemm */
126b8ba871bSPeter Wemm if (issmallscreen) {
127b8ba871bSPeter Wemm /* Fix the text line count for the parent. */
128b8ba871bSPeter Wemm if (splitup)
129b8ba871bSPeter Wemm sp->t_rows -= new->rows;
130b8ba871bSPeter Wemm
131b8ba871bSPeter Wemm /* Fix the parent screen. */
132b8ba871bSPeter Wemm if (sp->t_rows > sp->t_maxrows)
133b8ba871bSPeter Wemm sp->t_rows = sp->t_maxrows;
134b8ba871bSPeter Wemm if (sp->t_minrows > sp->t_maxrows)
135b8ba871bSPeter Wemm sp->t_minrows = sp->t_maxrows;
136b8ba871bSPeter Wemm
137b8ba871bSPeter Wemm /* Fix the child screen. */
138b8ba871bSPeter Wemm new->t_minrows = new->t_rows = O_VAL(sp, O_WINDOW);
139b8ba871bSPeter Wemm if (new->t_rows > new->t_maxrows)
140b8ba871bSPeter Wemm new->t_rows = new->t_maxrows;
141b8ba871bSPeter Wemm if (new->t_minrows > new->t_maxrows)
142b8ba871bSPeter Wemm new->t_minrows = new->t_maxrows;
143b8ba871bSPeter Wemm } else {
144b8ba871bSPeter Wemm sp->t_minrows = sp->t_rows = IS_ONELINE(sp) ? 1 : sp->rows - 1;
145b8ba871bSPeter Wemm
146b8ba871bSPeter Wemm /*
147b8ba871bSPeter Wemm * The new screen may be a small screen, even if the parent
148b8ba871bSPeter Wemm * was not. Don't complain if O_WINDOW is too large, we're
149b8ba871bSPeter Wemm * splitting the screen so the screen is much smaller than
150b8ba871bSPeter Wemm * normal.
151b8ba871bSPeter Wemm */
152b8ba871bSPeter Wemm new->t_minrows = new->t_rows = O_VAL(sp, O_WINDOW);
153b8ba871bSPeter Wemm if (new->t_rows > new->rows - 1)
154b8ba871bSPeter Wemm new->t_minrows = new->t_rows =
155b8ba871bSPeter Wemm IS_ONELINE(new) ? 1 : new->rows - 1;
156b8ba871bSPeter Wemm }
157b8ba871bSPeter Wemm
158b8ba871bSPeter Wemm /* Adjust the ends of the new and old maps. */
159b8ba871bSPeter Wemm _TMAP(sp) = IS_ONELINE(sp) ?
160b8ba871bSPeter Wemm _HMAP(sp) : _HMAP(sp) + (sp->t_rows - 1);
161b8ba871bSPeter Wemm _TMAP(new) = IS_ONELINE(new) ?
162b8ba871bSPeter Wemm _HMAP(new) : _HMAP(new) + (new->t_rows - 1);
163b8ba871bSPeter Wemm
164b8ba871bSPeter Wemm /* Reset the length of the default scroll. */
165b8ba871bSPeter Wemm if ((sp->defscroll = sp->t_maxrows / 2) == 0)
166b8ba871bSPeter Wemm sp->defscroll = 1;
167b8ba871bSPeter Wemm if ((new->defscroll = new->t_maxrows / 2) == 0)
168b8ba871bSPeter Wemm new->defscroll = 1;
169b8ba871bSPeter Wemm
170b8ba871bSPeter Wemm /* Fit the screen into the logical chain. */
171b8ba871bSPeter Wemm vs_insert(new, sp->gp);
172b8ba871bSPeter Wemm
173b8ba871bSPeter Wemm /* Tell the display that we're splitting. */
174b8ba871bSPeter Wemm (void)gp->scr_split(sp, new);
175b8ba871bSPeter Wemm
176b8ba871bSPeter Wemm /*
177b8ba871bSPeter Wemm * Initialize the screen flags:
178b8ba871bSPeter Wemm *
179b8ba871bSPeter Wemm * If we're in vi mode in one screen, we don't have to reinitialize.
180b8ba871bSPeter Wemm * This isn't just a cosmetic fix. The path goes like this:
181b8ba871bSPeter Wemm *
182b8ba871bSPeter Wemm * return into vi(), SC_SSWITCH set
183b8ba871bSPeter Wemm * call vs_refresh() with SC_STATUS set
184b8ba871bSPeter Wemm * call vs_resolve to display the status message
185b8ba871bSPeter Wemm * call vs_refresh() because the SC_SCR_VI bit isn't set
186b8ba871bSPeter Wemm *
187b8ba871bSPeter Wemm * Things go downhill at this point.
188b8ba871bSPeter Wemm *
189b8ba871bSPeter Wemm * Draw the new screen from scratch, and add a status line.
190b8ba871bSPeter Wemm */
191b8ba871bSPeter Wemm F_SET(new,
192b8ba871bSPeter Wemm SC_SCR_REFORMAT | SC_STATUS |
193b8ba871bSPeter Wemm F_ISSET(sp, SC_EX | SC_VI | SC_SCR_VI | SC_SCR_EX | SC_READONLY));
194b8ba871bSPeter Wemm return (0);
195b8ba871bSPeter Wemm }
196b8ba871bSPeter Wemm
197b8ba871bSPeter Wemm /*
198b8ba871bSPeter Wemm * vs_vsplit --
199b8ba871bSPeter Wemm * Create a new screen, vertically.
200b8ba871bSPeter Wemm *
201b8ba871bSPeter Wemm * PUBLIC: int vs_vsplit(SCR *, SCR *);
202b8ba871bSPeter Wemm */
203b8ba871bSPeter Wemm int
vs_vsplit(SCR * sp,SCR * new)204b8ba871bSPeter Wemm vs_vsplit(SCR *sp, SCR *new)
205b8ba871bSPeter Wemm {
206b8ba871bSPeter Wemm GS *gp;
207b8ba871bSPeter Wemm size_t cols;
208b8ba871bSPeter Wemm
209b8ba871bSPeter Wemm gp = sp->gp;
210b8ba871bSPeter Wemm
211b8ba871bSPeter Wemm /* Check to see if it's possible. */
212b8ba871bSPeter Wemm if (sp->cols / 2 <= MINIMUM_SCREEN_COLS) {
213b8ba871bSPeter Wemm msgq(sp, M_ERR,
214b8ba871bSPeter Wemm "288|Screen must be larger than %d columns to split",
215b8ba871bSPeter Wemm MINIMUM_SCREEN_COLS * 2);
216b8ba871bSPeter Wemm return (1);
217b8ba871bSPeter Wemm }
218b8ba871bSPeter Wemm
219b8ba871bSPeter Wemm /* Wait for any messages in the screen. */
220b8ba871bSPeter Wemm vs_resolve(sp, NULL, 1);
221b8ba871bSPeter Wemm
222b8ba871bSPeter Wemm /* Get a new screen map. */
223b8ba871bSPeter Wemm CALLOC(sp, _HMAP(new), SIZE_HMAP(sp), sizeof(SMAP));
224b8ba871bSPeter Wemm if (_HMAP(new) == NULL)
225b8ba871bSPeter Wemm return (1);
226b8ba871bSPeter Wemm _HMAP(new)->lno = sp->lno;
227b8ba871bSPeter Wemm _HMAP(new)->coff = 0;
228b8ba871bSPeter Wemm _HMAP(new)->soff = 1;
229b8ba871bSPeter Wemm
230b8ba871bSPeter Wemm /*
231b8ba871bSPeter Wemm * Split the screen in half; we have to sacrifice a column to delimit
232b8ba871bSPeter Wemm * the screens.
233b8ba871bSPeter Wemm *
234b8ba871bSPeter Wemm * XXX
235b8ba871bSPeter Wemm * We always split to the right... that makes more sense to me, and
236b8ba871bSPeter Wemm * I don't want to play the stupid games that I play when splitting
237b8ba871bSPeter Wemm * horizontally.
238b8ba871bSPeter Wemm *
239b8ba871bSPeter Wemm * XXX
240b8ba871bSPeter Wemm * We reserve a column for the screen, "knowing" that curses needs
241b8ba871bSPeter Wemm * one. This should be worked out with the display interface.
242b8ba871bSPeter Wemm */
243b8ba871bSPeter Wemm cols = sp->cols / 2;
244b8ba871bSPeter Wemm new->cols = sp->cols - cols - 1;
245b8ba871bSPeter Wemm sp->cols = cols;
246b8ba871bSPeter Wemm new->coff = sp->coff + cols + 1;
247b8ba871bSPeter Wemm sp->cno = 0;
248b8ba871bSPeter Wemm
249b8ba871bSPeter Wemm /* Nothing else changes. */
250b8ba871bSPeter Wemm new->rows = sp->rows;
251b8ba871bSPeter Wemm new->t_rows = sp->t_rows;
252b8ba871bSPeter Wemm new->t_maxrows = sp->t_maxrows;
253b8ba871bSPeter Wemm new->t_minrows = sp->t_minrows;
254b8ba871bSPeter Wemm new->roff = sp->roff;
255b8ba871bSPeter Wemm new->defscroll = sp->defscroll;
256b8ba871bSPeter Wemm _TMAP(new) = _HMAP(new) + (new->t_rows - 1);
257b8ba871bSPeter Wemm
258b8ba871bSPeter Wemm /* Fit the screen into the logical chain. */
259b8ba871bSPeter Wemm vs_insert(new, sp->gp);
260b8ba871bSPeter Wemm
261b8ba871bSPeter Wemm /* Tell the display that we're splitting. */
262b8ba871bSPeter Wemm (void)gp->scr_split(sp, new);
263b8ba871bSPeter Wemm
264b8ba871bSPeter Wemm /* Redraw the old screen from scratch. */
265b8ba871bSPeter Wemm F_SET(sp, SC_SCR_REFORMAT | SC_STATUS);
266b8ba871bSPeter Wemm
267b8ba871bSPeter Wemm /*
268b8ba871bSPeter Wemm * Initialize the screen flags:
269b8ba871bSPeter Wemm *
270b8ba871bSPeter Wemm * If we're in vi mode in one screen, we don't have to reinitialize.
271b8ba871bSPeter Wemm * This isn't just a cosmetic fix. The path goes like this:
272b8ba871bSPeter Wemm *
273b8ba871bSPeter Wemm * return into vi(), SC_SSWITCH set
274b8ba871bSPeter Wemm * call vs_refresh() with SC_STATUS set
275b8ba871bSPeter Wemm * call vs_resolve to display the status message
276b8ba871bSPeter Wemm * call vs_refresh() because the SC_SCR_VI bit isn't set
277b8ba871bSPeter Wemm *
278b8ba871bSPeter Wemm * Things go downhill at this point.
279b8ba871bSPeter Wemm *
280b8ba871bSPeter Wemm * Draw the new screen from scratch, and add a status line.
281b8ba871bSPeter Wemm */
282b8ba871bSPeter Wemm F_SET(new,
283b8ba871bSPeter Wemm SC_SCR_REFORMAT | SC_STATUS |
284b8ba871bSPeter Wemm F_ISSET(sp, SC_EX | SC_VI | SC_SCR_VI | SC_SCR_EX | SC_READONLY));
285b8ba871bSPeter Wemm return (0);
286b8ba871bSPeter Wemm }
287b8ba871bSPeter Wemm
288b8ba871bSPeter Wemm /*
289b8ba871bSPeter Wemm * vs_insert --
290b8ba871bSPeter Wemm * Insert the new screen into the correct place in the logical
291b8ba871bSPeter Wemm * chain.
292b8ba871bSPeter Wemm */
293b8ba871bSPeter Wemm static void
vs_insert(SCR * sp,GS * gp)294b8ba871bSPeter Wemm vs_insert(SCR *sp, GS *gp)
295b8ba871bSPeter Wemm {
296b8ba871bSPeter Wemm SCR *tsp;
297b8ba871bSPeter Wemm
298b8ba871bSPeter Wemm gp = sp->gp;
299b8ba871bSPeter Wemm
300b8ba871bSPeter Wemm /* Move past all screens with lower row numbers. */
301b8ba871bSPeter Wemm TAILQ_FOREACH(tsp, gp->dq, q)
302b8ba871bSPeter Wemm if (tsp->roff >= sp->roff)
303b8ba871bSPeter Wemm break;
304b8ba871bSPeter Wemm /*
305b8ba871bSPeter Wemm * Move past all screens with the same row number and lower
306b8ba871bSPeter Wemm * column numbers.
307b8ba871bSPeter Wemm */
308b8ba871bSPeter Wemm for (; tsp != NULL; tsp = TAILQ_NEXT(tsp, q))
309b8ba871bSPeter Wemm if (tsp->roff != sp->roff || tsp->coff > sp->coff)
310b8ba871bSPeter Wemm break;
311b8ba871bSPeter Wemm
312b8ba871bSPeter Wemm /*
313b8ba871bSPeter Wemm * If we reached the end, this screen goes there. Otherwise,
314b8ba871bSPeter Wemm * put it before or after the screen where we stopped.
315b8ba871bSPeter Wemm */
316b8ba871bSPeter Wemm if (tsp == NULL) {
317b8ba871bSPeter Wemm TAILQ_INSERT_TAIL(gp->dq, sp, q);
318b8ba871bSPeter Wemm } else if (tsp->roff < sp->roff ||
319b8ba871bSPeter Wemm (tsp->roff == sp->roff && tsp->coff < sp->coff)) {
320b8ba871bSPeter Wemm TAILQ_INSERT_AFTER(gp->dq, tsp, sp, q);
321b8ba871bSPeter Wemm } else
322b8ba871bSPeter Wemm TAILQ_INSERT_BEFORE(tsp, sp, q);
323b8ba871bSPeter Wemm }
324b8ba871bSPeter Wemm
325b8ba871bSPeter Wemm /*
326b8ba871bSPeter Wemm * vs_discard --
327b8ba871bSPeter Wemm * Discard the screen, folding the real-estate into a related screen,
328b8ba871bSPeter Wemm * if one exists, and return that screen.
329b8ba871bSPeter Wemm *
330b8ba871bSPeter Wemm * PUBLIC: int vs_discard(SCR *, SCR **);
331b8ba871bSPeter Wemm */
332b8ba871bSPeter Wemm int
vs_discard(SCR * sp,SCR ** spp)333b8ba871bSPeter Wemm vs_discard(SCR *sp, SCR **spp)
334b8ba871bSPeter Wemm {
335b8ba871bSPeter Wemm GS *gp;
336b8ba871bSPeter Wemm SCR *tsp, **lp, *list[100];
337b8ba871bSPeter Wemm jdir_t jdir;
338b8ba871bSPeter Wemm
339b8ba871bSPeter Wemm gp = sp->gp;
340b8ba871bSPeter Wemm
341b8ba871bSPeter Wemm /*
342b8ba871bSPeter Wemm * Save the old screen's cursor information.
343b8ba871bSPeter Wemm *
344b8ba871bSPeter Wemm * XXX
345b8ba871bSPeter Wemm * If called after file_end(), and the underlying file was a tmp
346b8ba871bSPeter Wemm * file, it may have gone away.
347b8ba871bSPeter Wemm */
348b8ba871bSPeter Wemm if (sp->frp != NULL) {
349b8ba871bSPeter Wemm sp->frp->lno = sp->lno;
350b8ba871bSPeter Wemm sp->frp->cno = sp->cno;
351b8ba871bSPeter Wemm F_SET(sp->frp, FR_CURSORSET);
352b8ba871bSPeter Wemm }
353b8ba871bSPeter Wemm
354b8ba871bSPeter Wemm /* If no other screens to join, we're done. */
355b8ba871bSPeter Wemm if (!IS_SPLIT(sp)) {
356b8ba871bSPeter Wemm (void)gp->scr_discard(sp, NULL);
357b8ba871bSPeter Wemm
358b8ba871bSPeter Wemm if (spp != NULL)
359b8ba871bSPeter Wemm *spp = NULL;
360b8ba871bSPeter Wemm return (0);
361b8ba871bSPeter Wemm }
362b8ba871bSPeter Wemm
363b8ba871bSPeter Wemm /*
364b8ba871bSPeter Wemm * Find a set of screens that cover one of the screen's borders.
365b8ba871bSPeter Wemm * Check the vertical axis first, for no particular reason.
366b8ba871bSPeter Wemm *
367b8ba871bSPeter Wemm * XXX
368b8ba871bSPeter Wemm * It's possible (I think?), to create a screen that shares no full
369b8ba871bSPeter Wemm * border with any other set of screens, so we can't discard it. We
370b8ba871bSPeter Wemm * just complain at the user until they clean it up.
371b8ba871bSPeter Wemm */
372b8ba871bSPeter Wemm if (vs_join(sp, list, &jdir))
373b8ba871bSPeter Wemm return (1);
374b8ba871bSPeter Wemm
375b8ba871bSPeter Wemm /*
376b8ba871bSPeter Wemm * Modify the affected screens. Redraw the modified screen(s) from
377b8ba871bSPeter Wemm * scratch, setting a status line. If this is ever a performance
378b8ba871bSPeter Wemm * problem we could play games with the map, but I wrote that code
379b8ba871bSPeter Wemm * before and it was never clean or easy.
380b8ba871bSPeter Wemm *
381b8ba871bSPeter Wemm * Don't clean up the discarded screen's information. If the screen
382b8ba871bSPeter Wemm * isn't exiting, we'll do the work when the user redisplays it.
383b8ba871bSPeter Wemm */
384b8ba871bSPeter Wemm switch (jdir) {
385b8ba871bSPeter Wemm case HORIZ_FOLLOW:
386b8ba871bSPeter Wemm case HORIZ_PRECEDE:
387b8ba871bSPeter Wemm for (lp = &list[0]; (tsp = *lp) != NULL; ++lp) {
388b8ba871bSPeter Wemm /*
389b8ba871bSPeter Wemm * Small screens: see vs_refresh.c section 6a. Adjust
390b8ba871bSPeter Wemm * text line info, unless it's a small screen.
391b8ba871bSPeter Wemm *
392b8ba871bSPeter Wemm * Reset the length of the default scroll.
393b8ba871bSPeter Wemm *
394b8ba871bSPeter Wemm * Reset the map references.
395b8ba871bSPeter Wemm */
396b8ba871bSPeter Wemm tsp->rows += sp->rows;
397b8ba871bSPeter Wemm if (!IS_SMALL(tsp))
398b8ba871bSPeter Wemm tsp->t_rows = tsp->t_minrows = tsp->rows - 1;
399b8ba871bSPeter Wemm tsp->t_maxrows = tsp->rows - 1;
400b8ba871bSPeter Wemm
401b8ba871bSPeter Wemm tsp->defscroll = tsp->t_maxrows / 2;
402b8ba871bSPeter Wemm
403b8ba871bSPeter Wemm *(_HMAP(tsp) + (tsp->t_rows - 1)) = *_TMAP(tsp);
404b8ba871bSPeter Wemm _TMAP(tsp) = _HMAP(tsp) + (tsp->t_rows - 1);
405b8ba871bSPeter Wemm
406b8ba871bSPeter Wemm switch (jdir) {
407b8ba871bSPeter Wemm case HORIZ_FOLLOW:
408b8ba871bSPeter Wemm tsp->roff = sp->roff;
409b8ba871bSPeter Wemm vs_sm_fill(tsp, OOBLNO, P_TOP);
410b8ba871bSPeter Wemm break;
411b8ba871bSPeter Wemm case HORIZ_PRECEDE:
412b8ba871bSPeter Wemm vs_sm_fill(tsp, OOBLNO, P_BOTTOM);
413b8ba871bSPeter Wemm break;
414b8ba871bSPeter Wemm default:
415b8ba871bSPeter Wemm abort();
416b8ba871bSPeter Wemm }
417b8ba871bSPeter Wemm F_SET(tsp, SC_STATUS);
418b8ba871bSPeter Wemm }
419b8ba871bSPeter Wemm break;
420b8ba871bSPeter Wemm case VERT_FOLLOW:
421b8ba871bSPeter Wemm case VERT_PRECEDE:
422b8ba871bSPeter Wemm for (lp = &list[0]; (tsp = *lp) != NULL; ++lp) {
423b8ba871bSPeter Wemm if (jdir == VERT_FOLLOW)
424b8ba871bSPeter Wemm tsp->coff = sp->coff;
425b8ba871bSPeter Wemm tsp->cols += sp->cols + 1; /* XXX: DIVIDER */
426b8ba871bSPeter Wemm vs_sm_fill(tsp, OOBLNO, P_TOP);
427b8ba871bSPeter Wemm F_SET(tsp, SC_STATUS);
428b8ba871bSPeter Wemm }
429b8ba871bSPeter Wemm break;
430b8ba871bSPeter Wemm default:
431b8ba871bSPeter Wemm abort();
432b8ba871bSPeter Wemm }
433b8ba871bSPeter Wemm
434b8ba871bSPeter Wemm /* Find the closest screen that changed and move to it. */
435b8ba871bSPeter Wemm tsp = list[0];
436b8ba871bSPeter Wemm if (spp != NULL)
437b8ba871bSPeter Wemm *spp = tsp;
438b8ba871bSPeter Wemm
439b8ba871bSPeter Wemm /* Tell the display that we're discarding a screen. */
440b8ba871bSPeter Wemm (void)gp->scr_discard(sp, list);
441b8ba871bSPeter Wemm
442b8ba871bSPeter Wemm return (0);
443b8ba871bSPeter Wemm }
444b8ba871bSPeter Wemm
445b8ba871bSPeter Wemm /*
446b8ba871bSPeter Wemm * vs_join --
447b8ba871bSPeter Wemm * Find a set of screens that covers a screen's border.
448b8ba871bSPeter Wemm */
449b8ba871bSPeter Wemm static int
vs_join(SCR * sp,SCR ** listp,jdir_t * jdirp)450b8ba871bSPeter Wemm vs_join(SCR *sp, SCR **listp, jdir_t *jdirp)
451b8ba871bSPeter Wemm {
452b8ba871bSPeter Wemm GS *gp;
453b8ba871bSPeter Wemm SCR **lp, *tsp;
454b8ba871bSPeter Wemm int first;
455b8ba871bSPeter Wemm size_t tlen;
456b8ba871bSPeter Wemm
457b8ba871bSPeter Wemm gp = sp->gp;
458b8ba871bSPeter Wemm
459b8ba871bSPeter Wemm /* Check preceding vertical. */
460b8ba871bSPeter Wemm for (lp = listp, tlen = sp->rows,
461b8ba871bSPeter Wemm tsp = TAILQ_FIRST(gp->dq);
462b8ba871bSPeter Wemm tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) {
463b8ba871bSPeter Wemm if (sp == tsp)
464b8ba871bSPeter Wemm continue;
465b8ba871bSPeter Wemm /* Test if precedes the screen vertically. */
466b8ba871bSPeter Wemm if (tsp->coff + tsp->cols + 1 != sp->coff)
467b8ba871bSPeter Wemm continue;
468b8ba871bSPeter Wemm /*
469b8ba871bSPeter Wemm * Test if a subset on the vertical axis. If overlaps the
470b8ba871bSPeter Wemm * beginning or end, we can't join on this axis at all.
471b8ba871bSPeter Wemm */
472b8ba871bSPeter Wemm if (tsp->roff > sp->roff + sp->rows)
473b8ba871bSPeter Wemm continue;
474b8ba871bSPeter Wemm if (tsp->roff < sp->roff) {
475b8ba871bSPeter Wemm if (tsp->roff + tsp->rows >= sp->roff)
476b8ba871bSPeter Wemm break;
477b8ba871bSPeter Wemm continue;
478b8ba871bSPeter Wemm }
479b8ba871bSPeter Wemm if (tsp->roff + tsp->rows > sp->roff + sp->rows)
480b8ba871bSPeter Wemm break;
481b8ba871bSPeter Wemm #ifdef DEBUG
482b8ba871bSPeter Wemm if (tlen < tsp->rows)
483b8ba871bSPeter Wemm abort();
484b8ba871bSPeter Wemm #endif
485b8ba871bSPeter Wemm tlen -= tsp->rows;
486b8ba871bSPeter Wemm *lp++ = tsp;
487b8ba871bSPeter Wemm }
488b8ba871bSPeter Wemm if (tlen == 0) {
489b8ba871bSPeter Wemm *lp = NULL;
490b8ba871bSPeter Wemm *jdirp = VERT_PRECEDE;
491b8ba871bSPeter Wemm return (0);
492b8ba871bSPeter Wemm }
493b8ba871bSPeter Wemm
494b8ba871bSPeter Wemm /* Check following vertical. */
495b8ba871bSPeter Wemm for (lp = listp, tlen = sp->rows,
496b8ba871bSPeter Wemm tsp = TAILQ_FIRST(gp->dq);
497b8ba871bSPeter Wemm tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) {
498b8ba871bSPeter Wemm if (sp == tsp)
499b8ba871bSPeter Wemm continue;
500b8ba871bSPeter Wemm /* Test if follows the screen vertically. */
501b8ba871bSPeter Wemm if (tsp->coff != sp->coff + sp->cols + 1)
502b8ba871bSPeter Wemm continue;
503b8ba871bSPeter Wemm /*
504b8ba871bSPeter Wemm * Test if a subset on the vertical axis. If overlaps the
505b8ba871bSPeter Wemm * beginning or end, we can't join on this axis at all.
506b8ba871bSPeter Wemm */
507b8ba871bSPeter Wemm if (tsp->roff > sp->roff + sp->rows)
508b8ba871bSPeter Wemm continue;
509b8ba871bSPeter Wemm if (tsp->roff < sp->roff) {
510b8ba871bSPeter Wemm if (tsp->roff + tsp->rows >= sp->roff)
511b8ba871bSPeter Wemm break;
512b8ba871bSPeter Wemm continue;
513b8ba871bSPeter Wemm }
514b8ba871bSPeter Wemm if (tsp->roff + tsp->rows > sp->roff + sp->rows)
515b8ba871bSPeter Wemm break;
516b8ba871bSPeter Wemm #ifdef DEBUG
517b8ba871bSPeter Wemm if (tlen < tsp->rows)
518b8ba871bSPeter Wemm abort();
519b8ba871bSPeter Wemm #endif
520b8ba871bSPeter Wemm tlen -= tsp->rows;
521b8ba871bSPeter Wemm *lp++ = tsp;
522b8ba871bSPeter Wemm }
523b8ba871bSPeter Wemm if (tlen == 0) {
524b8ba871bSPeter Wemm *lp = NULL;
525b8ba871bSPeter Wemm *jdirp = VERT_FOLLOW;
526b8ba871bSPeter Wemm return (0);
527b8ba871bSPeter Wemm }
528b8ba871bSPeter Wemm
529b8ba871bSPeter Wemm /* Check preceding horizontal. */
530b8ba871bSPeter Wemm for (first = 0, lp = listp, tlen = sp->cols,
531b8ba871bSPeter Wemm tsp = TAILQ_FIRST(gp->dq);
532b8ba871bSPeter Wemm tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) {
533b8ba871bSPeter Wemm if (sp == tsp)
534b8ba871bSPeter Wemm continue;
535b8ba871bSPeter Wemm /* Test if precedes the screen horizontally. */
536b8ba871bSPeter Wemm if (tsp->roff + tsp->rows != sp->roff)
537b8ba871bSPeter Wemm continue;
538b8ba871bSPeter Wemm /*
539b8ba871bSPeter Wemm * Test if a subset on the horizontal axis. If overlaps the
540b8ba871bSPeter Wemm * beginning or end, we can't join on this axis at all.
541b8ba871bSPeter Wemm */
542b8ba871bSPeter Wemm if (tsp->coff > sp->coff + sp->cols)
543b8ba871bSPeter Wemm continue;
544b8ba871bSPeter Wemm if (tsp->coff < sp->coff) {
545b8ba871bSPeter Wemm if (tsp->coff + tsp->cols >= sp->coff)
546b8ba871bSPeter Wemm break;
547b8ba871bSPeter Wemm continue;
548b8ba871bSPeter Wemm }
549b8ba871bSPeter Wemm if (tsp->coff + tsp->cols > sp->coff + sp->cols)
550b8ba871bSPeter Wemm break;
551b8ba871bSPeter Wemm #ifdef DEBUG
552b8ba871bSPeter Wemm if (tlen < tsp->cols)
553b8ba871bSPeter Wemm abort();
554b8ba871bSPeter Wemm #endif
555b8ba871bSPeter Wemm tlen -= tsp->cols + first;
556b8ba871bSPeter Wemm first = 1;
557b8ba871bSPeter Wemm *lp++ = tsp;
558b8ba871bSPeter Wemm }
559b8ba871bSPeter Wemm if (tlen == 0) {
560b8ba871bSPeter Wemm *lp = NULL;
561b8ba871bSPeter Wemm *jdirp = HORIZ_PRECEDE;
562b8ba871bSPeter Wemm return (0);
563b8ba871bSPeter Wemm }
564b8ba871bSPeter Wemm
565b8ba871bSPeter Wemm /* Check following horizontal. */
566b8ba871bSPeter Wemm for (first = 0, lp = listp, tlen = sp->cols,
567b8ba871bSPeter Wemm tsp = TAILQ_FIRST(gp->dq);
568b8ba871bSPeter Wemm tsp != NULL; tsp = TAILQ_NEXT(tsp, q)) {
569b8ba871bSPeter Wemm if (sp == tsp)
570b8ba871bSPeter Wemm continue;
571b8ba871bSPeter Wemm /* Test if precedes the screen horizontally. */
572b8ba871bSPeter Wemm if (tsp->roff != sp->roff + sp->rows)
573b8ba871bSPeter Wemm continue;
574b8ba871bSPeter Wemm /*
575b8ba871bSPeter Wemm * Test if a subset on the horizontal axis. If overlaps the
576b8ba871bSPeter Wemm * beginning or end, we can't join on this axis at all.
577b8ba871bSPeter Wemm */
578b8ba871bSPeter Wemm if (tsp->coff > sp->coff + sp->cols)
579b8ba871bSPeter Wemm continue;
580b8ba871bSPeter Wemm if (tsp->coff < sp->coff) {
581b8ba871bSPeter Wemm if (tsp->coff + tsp->cols >= sp->coff)
582b8ba871bSPeter Wemm break;
583b8ba871bSPeter Wemm continue;
584b8ba871bSPeter Wemm }
585b8ba871bSPeter Wemm if (tsp->coff + tsp->cols > sp->coff + sp->cols)
586b8ba871bSPeter Wemm break;
587b8ba871bSPeter Wemm #ifdef DEBUG
588b8ba871bSPeter Wemm if (tlen < tsp->cols)
589b8ba871bSPeter Wemm abort();
590b8ba871bSPeter Wemm #endif
591b8ba871bSPeter Wemm tlen -= tsp->cols + first;
592b8ba871bSPeter Wemm first = 1;
593b8ba871bSPeter Wemm *lp++ = tsp;
594b8ba871bSPeter Wemm }
595b8ba871bSPeter Wemm if (tlen == 0) {
596b8ba871bSPeter Wemm *lp = NULL;
597b8ba871bSPeter Wemm *jdirp = HORIZ_FOLLOW;
598b8ba871bSPeter Wemm return (0);
599b8ba871bSPeter Wemm }
600b8ba871bSPeter Wemm return (1);
601b8ba871bSPeter Wemm }
602b8ba871bSPeter Wemm
603b8ba871bSPeter Wemm /*
604b8ba871bSPeter Wemm * vs_fg --
605b8ba871bSPeter Wemm * Background the current screen, and foreground a new one.
606b8ba871bSPeter Wemm *
607b8ba871bSPeter Wemm * PUBLIC: int vs_fg(SCR *, SCR **, CHAR_T *, int);
608 */
609 int
vs_fg(SCR * sp,SCR ** nspp,CHAR_T * name,int newscreen)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
vs_bg(SCR * sp)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
vs_swap(SCR * sp,SCR ** nspp,char * name)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
vs_resize(SCR * sp,long int count,adj_t adj)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 *
vs_getbg(SCR * sp,char * name)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