Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/mg/window.c	Lines:	0	207	0.0 %
Date:	2017-11-07	Branches:	0	100	0.0 %


/*	$OpenBSD: window.c,v 1.36 2015/11/18 18:21:06 jasper Exp $	*/

/* This file is in the public domain. */

/*
 *		Window handling.
 */

#include <sys/queue.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>

#include "def.h"

struct mgwin *
new_window(struct buffer *bp)
{
	struct mgwin *wp;

	wp = calloc(1, sizeof(struct mgwin));
	if (wp == NULL)
		return (NULL);

	wp->w_bufp = bp;
	wp->w_dotp = NULL;
	wp->w_doto = 0;
	wp->w_markp = NULL;
	wp->w_marko = 0;
	wp->w_rflag = 0;
	wp->w_frame = 0;
	wp->w_wrapline = NULL;
	wp->w_dotline = wp->w_markline = 1;
	if (bp)
		bp->b_nwnd++;
	return (wp);
}

/*
 * Reposition dot in the current window to line "n".  If the argument is
 * positive, it is that line.  If it is negative it is that line from the
 * bottom.  If it is 0 the window is centered (this is what the standard
 * redisplay code does).
 */
/* ARGSUSED */
int
reposition(int f, int n)
{
	curwp->w_frame = (f & FFARG) ? (n >= 0 ? n + 1 : n) : 0;
	curwp->w_rflag |= WFFRAME;
	sgarbf = TRUE;
	return (TRUE);
}

/*
 * Refresh the display.  A call is made to the "ttresize" entry in the
 * terminal handler, which tries to reset "nrow" and "ncol".  They will,
 * however, never be set outside of the NROW or NCOL range.  If the display
 * changed size, arrange that everything is redone, then call "update" to
 * fix the display.  We do this so the new size can be displayed.  In the
 * normal case the call to "update" in "main.c" refreshes the screen, and
 * all of the windows need not be recomputed. This call includes a
 * 'force' parameter to ensure that the redraw is done, even after a
 * a suspend/continue (where the window size parameters will already
 * be updated). Note that when you get to the "display unusable"
 * message, the screen will be messed up. If you make the window bigger
 * again, and send another command, everything will get fixed!
 */
int
redraw(int f, int n)
{
	return (do_redraw(f, n, FALSE));
}

/* ARGSUSED */
int
do_redraw(int f, int n, int force)
{
	struct mgwin	*wp;
	int		 oldnrow, oldncol;

	oldnrow = nrow;
	oldncol = ncol;
	ttresize();
	if (nrow != oldnrow || ncol != oldncol || force) {

		/* find last */
		wp = wheadp;
		while (wp->w_wndp != NULL)
			wp = wp->w_wndp;

		/* check if too small */
		if (nrow < wp->w_toprow + 3) {
			dobeep();
			ewprintf("Display unusable");
			return (FALSE);
		}
		wp->w_ntrows = nrow - wp->w_toprow - 2;
		sgarbf = TRUE;
		update(CMODE);
	} else
		sgarbf = TRUE;
	return (TRUE);
}

/*
 * The command to make the next window (next => down the screen) the current
 * window. There are no real errors, although the command does nothing if
 * there is only 1 window on the screen.
 */
/* ARGSUSED */
int
nextwind(int f, int n)
{
	struct mgwin	*wp;

	if ((wp = curwp->w_wndp) == NULL)
		wp = wheadp;
	curwp = wp;
	curbp = wp->w_bufp;
	return (TRUE);
}

/* not in GNU Emacs */
/*
 * This command makes the previous window (previous => up the screen) the
 * current window. There are no errors, although the command does not do
 * a lot if there is only 1 window.
 */
/* ARGSUSED */
int
prevwind(int f, int n)
{
	struct mgwin	*wp1, *wp2;

	wp1 = wheadp;
	wp2 = curwp;
	if (wp1 == wp2)
		wp2 = NULL;
	while (wp1->w_wndp != wp2)
		wp1 = wp1->w_wndp;
	curwp = wp1;
	curbp = wp1->w_bufp;
	return (TRUE);
}

/*
 * This command makes the current window the only window on the screen.  Try
 * to set the framing so that "." does not have to move on the display.  Some
 * care has to be taken to keep the values of dot and mark in the buffer
 * structures right if the destruction of a window makes a buffer become
 * undisplayed.
 */
/* ARGSUSED */
int
onlywind(int f, int n)
{
	struct mgwin	*wp;
	struct line	*lp;
	int		 i;

	while (wheadp != curwp) {
		wp = wheadp;
		wheadp = wp->w_wndp;
		if (--wp->w_bufp->b_nwnd == 0) {
			wp->w_bufp->b_dotp = wp->w_dotp;
			wp->w_bufp->b_doto = wp->w_doto;
			wp->w_bufp->b_markp = wp->w_markp;
			wp->w_bufp->b_marko = wp->w_marko;
			wp->w_bufp->b_dotline = wp->w_dotline;
			wp->w_bufp->b_markline = wp->w_markline;
		}
		free(wp);
	}
	while (curwp->w_wndp != NULL) {
		wp = curwp->w_wndp;
		curwp->w_wndp = wp->w_wndp;
		if (--wp->w_bufp->b_nwnd == 0) {
			wp->w_bufp->b_dotp = wp->w_dotp;
			wp->w_bufp->b_doto = wp->w_doto;
			wp->w_bufp->b_markp = wp->w_markp;
			wp->w_bufp->b_marko = wp->w_marko;
			wp->w_bufp->b_dotline = wp->w_dotline;
			wp->w_bufp->b_markline = wp->w_markline;
		}
		free(wp);
	}
	lp = curwp->w_linep;
	i = curwp->w_toprow;
	while (i != 0 && lback(lp) != curbp->b_headp) {
		--i;
		lp = lback(lp);
	}
	curwp->w_toprow = 0;

	/* 2 = mode, echo */
	curwp->w_ntrows = nrow - 2;
	curwp->w_linep = lp;
	curwp->w_rflag |= WFMODE | WFFULL;
	return (TRUE);
}

/*
 * Split the current window.  A window smaller than 3 lines cannot be split.
 * The only other error that is possible is a "malloc" failure allocating the
 * structure for the new window.
 * If called with a FFOTHARG, flags on the new window are set to 'n'.
 */
/* ARGSUSED */
int
splitwind(int f, int n)
{
	struct mgwin	*wp, *wp1, *wp2;
	struct line	*lp;
	int		 ntru, ntrd, ntrl;

	if (curwp->w_ntrows < 3) {
		dobeep();
		ewprintf("Cannot split a %d line window", curwp->w_ntrows);
		return (FALSE);
	}
	wp = new_window(curbp);
	if (wp == NULL) {
		dobeep();
		ewprintf("Unable to create a window");
		return (FALSE);
	}

	/* use the current dot and mark */
	wp->w_dotp = curwp->w_dotp;
	wp->w_doto = curwp->w_doto;
	wp->w_markp = curwp->w_markp;
	wp->w_marko = curwp->w_marko;
	wp->w_dotline = curwp->w_dotline;
	wp->w_markline = curwp->w_markline;

	/* figure out which half of the screen we're in */
	ntru = (curwp->w_ntrows - 1) / 2;	/* Upper size */
	ntrl = (curwp->w_ntrows - 1) - ntru;	/* Lower size */

	for (lp = curwp->w_linep, ntrd = 0; lp != curwp->w_dotp;
	    lp = lforw(lp))
		ntrd++;

	lp = curwp->w_linep;

	/* old is upper window */
	if (ntrd <= ntru) {
		/* hit mode line */
		if (ntrd == ntru)
			lp = lforw(lp);
		curwp->w_ntrows = ntru;
		wp->w_wndp = curwp->w_wndp;
		curwp->w_wndp = wp;
		wp->w_toprow = curwp->w_toprow + ntru + 1;
		wp->w_ntrows = ntrl;
	/* old is lower window */
	} else {
		wp1 = NULL;
		wp2 = wheadp;
		while (wp2 != curwp) {
			wp1 = wp2;
			wp2 = wp2->w_wndp;
		}
		if (wp1 == NULL)
			wheadp = wp;
		else
			wp1->w_wndp = wp;
		wp->w_wndp = curwp;
		wp->w_toprow = curwp->w_toprow;
		wp->w_ntrows = ntru;

		/* mode line */
		++ntru;
		curwp->w_toprow += ntru;
		curwp->w_ntrows = ntrl;
		while (ntru--)
			lp = lforw(lp);
	}

	/* adjust the top lines if necessary */
	curwp->w_linep = lp;
	wp->w_linep = lp;

	curwp->w_rflag |= WFMODE | WFFULL;
	wp->w_rflag |= WFMODE | WFFULL;
	/* if FFOTHARG, set flags) */
	if (f & FFOTHARG)
		wp->w_flag = n;

	return (TRUE);
}

/*
 * Enlarge the current window.  Find the window that loses space.  Make sure
 * it is big enough.  If so, hack the window descriptions, and ask redisplay
 * to do all the hard work.  You don't just set "force reframe" because dot
 * would move.
 */
/* ARGSUSED */
int
enlargewind(int f, int n)
{
	struct mgwin	*adjwp;
	struct line	*lp;
	int		 i;

	if (n < 0)
		return (shrinkwind(f, -n));
	if (wheadp->w_wndp == NULL) {
		dobeep();
		ewprintf("Only one window");
		return (FALSE);
	}
	if ((adjwp = curwp->w_wndp) == NULL) {
		adjwp = wheadp;
		while (adjwp->w_wndp != curwp)
			adjwp = adjwp->w_wndp;
	}
	if (adjwp->w_ntrows <= n) {
		dobeep();
		ewprintf("Impossible change");
		return (FALSE);
	}

	/* shrink below */
	if (curwp->w_wndp == adjwp) {
		lp = adjwp->w_linep;
		for (i = 0; i < n && lp != adjwp->w_bufp->b_headp; ++i)
			lp = lforw(lp);
		adjwp->w_linep = lp;
		adjwp->w_toprow += n;
	/* shrink above */
	} else {
		lp = curwp->w_linep;
		for (i = 0; i < n && lback(lp) != curbp->b_headp; ++i)
			lp = lback(lp);
		curwp->w_linep = lp;
		curwp->w_toprow -= n;
	}
	curwp->w_ntrows += n;
	adjwp->w_ntrows -= n;
	curwp->w_rflag |= WFMODE | WFFULL;
	adjwp->w_rflag |= WFMODE | WFFULL;
	return (TRUE);
}

/*
 * Shrink the current window.  Find the window that gains space.  Hack at the
 * window descriptions. Ask the redisplay to do all the hard work.
 */
int
shrinkwind(int f, int n)
{
	struct mgwin	*adjwp;
	struct line	*lp;
	int		 i;

	if (n < 0)
		return (enlargewind(f, -n));
	if (wheadp->w_wndp == NULL) {
		dobeep();
		ewprintf("Only one window");
		return (FALSE);
	}
	/*
	 * Bit of flakiness - FFRAND means it was an internal call, and
	 * to be trusted implicitly about sizes.
	 */
	if (!(f & FFRAND) && curwp->w_ntrows <= n) {
		dobeep();
		ewprintf("Impossible change");
		return (FALSE);
	}
	if ((adjwp = curwp->w_wndp) == NULL) {
		adjwp = wheadp;
		while (adjwp->w_wndp != curwp)
			adjwp = adjwp->w_wndp;
	}

	/* grow below */
	if (curwp->w_wndp == adjwp) {
		lp = adjwp->w_linep;
		for (i = 0; i < n && lback(lp) != adjwp->w_bufp->b_headp; ++i)
			lp = lback(lp);
		adjwp->w_linep = lp;
		adjwp->w_toprow -= n;
	/* grow above */
	} else {
		lp = curwp->w_linep;
		for (i = 0; i < n && lp != curbp->b_headp; ++i)
			lp = lforw(lp);
		curwp->w_linep = lp;
		curwp->w_toprow += n;
	}
	curwp->w_ntrows -= n;
	adjwp->w_ntrows += n;
	curwp->w_rflag |= WFMODE | WFFULL;
	adjwp->w_rflag |= WFMODE | WFFULL;
	return (TRUE);
}

/*
 * Delete current window. Call shrink-window to do the screen updating, then
 * throw away the window.
 */
/* ARGSUSED */
int
delwind(int f, int n)
{
	struct mgwin	*wp, *nwp;

	wp = curwp;		/* Cheap...		 */

	/* shrinkwind returning false means only one window... */
	if (shrinkwind(FFRAND, wp->w_ntrows + 1) == FALSE)
		return (FALSE);
	if (--wp->w_bufp->b_nwnd == 0) {
		wp->w_bufp->b_dotp = wp->w_dotp;
		wp->w_bufp->b_doto = wp->w_doto;
		wp->w_bufp->b_markp = wp->w_markp;
		wp->w_bufp->b_marko = wp->w_marko;
		wp->w_bufp->b_dotline = wp->w_dotline;
		wp->w_bufp->b_markline = wp->w_markline;
	}

	/* since shrinkwind did't crap out, we know we have a second window */
	if (wp == wheadp)
		wheadp = curwp = wp->w_wndp;
	else if ((curwp = wp->w_wndp) == NULL)
		curwp = wheadp;
	curbp = curwp->w_bufp;
	for (nwp = wheadp; nwp != NULL; nwp = nwp->w_wndp)
		if (nwp->w_wndp == wp) {
			nwp->w_wndp = wp->w_wndp;
			break;
		}
	free(wp);
	return (TRUE);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: window.c,v 1.36 2015/11/18 18:21:06 jasper Exp $ */
2
3			/* This file is in the public domain. */
4
5			/*
6			* Window handling.
7			*/
8
9			#include <sys/queue.h>
10			#include <signal.h>
11			#include <stdio.h>
12			#include <stdlib.h>
13
14			#include "def.h"
15
16			struct mgwin *
17			new_window(struct buffer *bp)
18			{
19			struct mgwin *wp;
20
21			wp = calloc(1, sizeof(struct mgwin));
22			if (wp == NULL)
23			return (NULL);
24
25			wp->w_bufp = bp;
26			wp->w_dotp = NULL;
27			wp->w_doto = 0;
28			wp->w_markp = NULL;
29			wp->w_marko = 0;
30			wp->w_rflag = 0;
31			wp->w_frame = 0;
32			wp->w_wrapline = NULL;
33			wp->w_dotline = wp->w_markline = 1;
34			if (bp)
35			bp->b_nwnd++;
36			return (wp);
37			}
38
39			/*
40			* Reposition dot in the current window to line "n". If the argument is
41			* positive, it is that line. If it is negative it is that line from the
42			* bottom. If it is 0 the window is centered (this is what the standard
43			* redisplay code does).
44			*/
45			/* ARGSUSED */
46			int
47			reposition(int f, int n)
48			{
49			curwp->w_frame = (f & FFARG) ? (n >= 0 ? n + 1 : n) : 0;
50			curwp->w_rflag \|= WFFRAME;
51			sgarbf = TRUE;
52			return (TRUE);
53			}
54
55			/*
56			* Refresh the display. A call is made to the "ttresize" entry in the
57			* terminal handler, which tries to reset "nrow" and "ncol". They will,
58			* however, never be set outside of the NROW or NCOL range. If the display
59			* changed size, arrange that everything is redone, then call "update" to
60			* fix the display. We do this so the new size can be displayed. In the
61			* normal case the call to "update" in "main.c" refreshes the screen, and
62			* all of the windows need not be recomputed. This call includes a
63			* 'force' parameter to ensure that the redraw is done, even after a
64			* a suspend/continue (where the window size parameters will already
65			* be updated). Note that when you get to the "display unusable"
66			* message, the screen will be messed up. If you make the window bigger
67			* again, and send another command, everything will get fixed!
68			*/
69			int
70			redraw(int f, int n)
71			{
72			return (do_redraw(f, n, FALSE));
73			}
74
75			/* ARGSUSED */
76			int
77			do_redraw(int f, int n, int force)
78			{
79			struct mgwin *wp;
80			int oldnrow, oldncol;
81
82			oldnrow = nrow;
83			oldncol = ncol;
84			ttresize();
85			if (nrow != oldnrow \|\| ncol != oldncol \|\| force) {
86
87			/* find last */
88			wp = wheadp;
89			while (wp->w_wndp != NULL)
90			wp = wp->w_wndp;
91
92			/* check if too small */
93			if (nrow < wp->w_toprow + 3) {
94			dobeep();
95			ewprintf("Display unusable");
96			return (FALSE);
97			}
98			wp->w_ntrows = nrow - wp->w_toprow - 2;
99			sgarbf = TRUE;
100			update(CMODE);
101			} else
102			sgarbf = TRUE;
103			return (TRUE);
104			}
105
106			/*
107			* The command to make the next window (next => down the screen) the current
108			* window. There are no real errors, although the command does nothing if
109			* there is only 1 window on the screen.
110			*/
111			/* ARGSUSED */
112			int
113			nextwind(int f, int n)
114			{
115			struct mgwin *wp;
116
117			if ((wp = curwp->w_wndp) == NULL)
118			wp = wheadp;
119			curwp = wp;
120			curbp = wp->w_bufp;
121			return (TRUE);
122			}
123
124			/* not in GNU Emacs */
125			/*
126			* This command makes the previous window (previous => up the screen) the
127			* current window. There are no errors, although the command does not do
128			* a lot if there is only 1 window.
129			*/
130			/* ARGSUSED */
131			int
132			prevwind(int f, int n)
133			{
134			struct mgwin wp1, wp2;
135
136			wp1 = wheadp;
137			wp2 = curwp;
138			if (wp1 == wp2)
139			wp2 = NULL;
140			while (wp1->w_wndp != wp2)
141			wp1 = wp1->w_wndp;
142			curwp = wp1;
143			curbp = wp1->w_bufp;
144			return (TRUE);
145			}
146
147			/*
148			* This command makes the current window the only window on the screen. Try
149			* to set the framing so that "." does not have to move on the display. Some
150			* care has to be taken to keep the values of dot and mark in the buffer
151			* structures right if the destruction of a window makes a buffer become
152			* undisplayed.
153			*/
154			/* ARGSUSED */
155			int
156			onlywind(int f, int n)
157			{
158			struct mgwin *wp;
159			struct line *lp;
160			int i;
161
162			while (wheadp != curwp) {
163			wp = wheadp;
164			wheadp = wp->w_wndp;
165			if (--wp->w_bufp->b_nwnd == 0) {
166			wp->w_bufp->b_dotp = wp->w_dotp;
167			wp->w_bufp->b_doto = wp->w_doto;
168			wp->w_bufp->b_markp = wp->w_markp;
169			wp->w_bufp->b_marko = wp->w_marko;
170			wp->w_bufp->b_dotline = wp->w_dotline;
171			wp->w_bufp->b_markline = wp->w_markline;
172			}
173			free(wp);
174			}
175			while (curwp->w_wndp != NULL) {
176			wp = curwp->w_wndp;
177			curwp->w_wndp = wp->w_wndp;
178			if (--wp->w_bufp->b_nwnd == 0) {
179			wp->w_bufp->b_dotp = wp->w_dotp;
180			wp->w_bufp->b_doto = wp->w_doto;
181			wp->w_bufp->b_markp = wp->w_markp;
182			wp->w_bufp->b_marko = wp->w_marko;
183			wp->w_bufp->b_dotline = wp->w_dotline;
184			wp->w_bufp->b_markline = wp->w_markline;
185			}
186			free(wp);
187			}
188			lp = curwp->w_linep;
189			i = curwp->w_toprow;
190			while (i != 0 && lback(lp) != curbp->b_headp) {
191			--i;
192			lp = lback(lp);
193			}
194			curwp->w_toprow = 0;
195
196			/* 2 = mode, echo */
197			curwp->w_ntrows = nrow - 2;
198			curwp->w_linep = lp;
199			curwp->w_rflag \|= WFMODE \| WFFULL;
200			return (TRUE);
201			}
202
203			/*
204			* Split the current window. A window smaller than 3 lines cannot be split.
205			* The only other error that is possible is a "malloc" failure allocating the
206			* structure for the new window.
207			* If called with a FFOTHARG, flags on the new window are set to 'n'.
208			*/
209			/* ARGSUSED */
210			int
211			splitwind(int f, int n)
212			{
213			struct mgwin wp, wp1, *wp2;
214			struct line *lp;
215			int ntru, ntrd, ntrl;
216
217			if (curwp->w_ntrows < 3) {
218			dobeep();
219			ewprintf("Cannot split a %d line window", curwp->w_ntrows);
220			return (FALSE);
221			}
222			wp = new_window(curbp);
223			if (wp == NULL) {
224			dobeep();
225			ewprintf("Unable to create a window");
226			return (FALSE);
227			}
228
229			/* use the current dot and mark */
230			wp->w_dotp = curwp->w_dotp;
231			wp->w_doto = curwp->w_doto;
232			wp->w_markp = curwp->w_markp;
233			wp->w_marko = curwp->w_marko;
234			wp->w_dotline = curwp->w_dotline;
235			wp->w_markline = curwp->w_markline;
236
237			/* figure out which half of the screen we're in */
238			ntru = (curwp->w_ntrows - 1) / 2; /* Upper size */
239			ntrl = (curwp->w_ntrows - 1) - ntru; /* Lower size */
240
241			for (lp = curwp->w_linep, ntrd = 0; lp != curwp->w_dotp;
242			lp = lforw(lp))
243			ntrd++;
244
245			lp = curwp->w_linep;
246
247			/* old is upper window */
248			if (ntrd <= ntru) {
249			/* hit mode line */
250			if (ntrd == ntru)
251			lp = lforw(lp);
252			curwp->w_ntrows = ntru;
253			wp->w_wndp = curwp->w_wndp;
254			curwp->w_wndp = wp;
255			wp->w_toprow = curwp->w_toprow + ntru + 1;
256			wp->w_ntrows = ntrl;
257			/* old is lower window */
258			} else {
259			wp1 = NULL;
260			wp2 = wheadp;
261			while (wp2 != curwp) {
262			wp1 = wp2;
263			wp2 = wp2->w_wndp;
264			}
265			if (wp1 == NULL)
266			wheadp = wp;
267			else
268			wp1->w_wndp = wp;
269			wp->w_wndp = curwp;
270			wp->w_toprow = curwp->w_toprow;
271			wp->w_ntrows = ntru;
272
273			/* mode line */
274			++ntru;
275			curwp->w_toprow += ntru;
276			curwp->w_ntrows = ntrl;
277			while (ntru--)
278			lp = lforw(lp);
279			}
280
281			/* adjust the top lines if necessary */
282			curwp->w_linep = lp;
283			wp->w_linep = lp;
284
285			curwp->w_rflag \|= WFMODE \| WFFULL;
286			wp->w_rflag \|= WFMODE \| WFFULL;
287			/* if FFOTHARG, set flags) */
288			if (f & FFOTHARG)
289			wp->w_flag = n;
290
291			return (TRUE);
292			}
293
294			/*
295			* Enlarge the current window. Find the window that loses space. Make sure
296			* it is big enough. If so, hack the window descriptions, and ask redisplay
297			* to do all the hard work. You don't just set "force reframe" because dot
298			* would move.
299			*/
300			/* ARGSUSED */
301			int
302			enlargewind(int f, int n)
303			{
304			struct mgwin *adjwp;
305			struct line *lp;
306			int i;
307
308			if (n < 0)
309			return (shrinkwind(f, -n));
310			if (wheadp->w_wndp == NULL) {
311			dobeep();
312			ewprintf("Only one window");
313			return (FALSE);
314			}
315			if ((adjwp = curwp->w_wndp) == NULL) {
316			adjwp = wheadp;
317			while (adjwp->w_wndp != curwp)
318			adjwp = adjwp->w_wndp;
319			}
320			if (adjwp->w_ntrows <= n) {
321			dobeep();
322			ewprintf("Impossible change");
323			return (FALSE);
324			}
325
326			/* shrink below */
327			if (curwp->w_wndp == adjwp) {
328			lp = adjwp->w_linep;
329			for (i = 0; i < n && lp != adjwp->w_bufp->b_headp; ++i)
330			lp = lforw(lp);
331			adjwp->w_linep = lp;
332			adjwp->w_toprow += n;
333			/* shrink above */
334			} else {
335			lp = curwp->w_linep;
336			for (i = 0; i < n && lback(lp) != curbp->b_headp; ++i)
337			lp = lback(lp);
338			curwp->w_linep = lp;
339			curwp->w_toprow -= n;
340			}
341			curwp->w_ntrows += n;
342			adjwp->w_ntrows -= n;
343			curwp->w_rflag \|= WFMODE \| WFFULL;
344			adjwp->w_rflag \|= WFMODE \| WFFULL;
345			return (TRUE);
346			}
347
348			/*
349			* Shrink the current window. Find the window that gains space. Hack at the
350			* window descriptions. Ask the redisplay to do all the hard work.
351			*/
352			int
353			shrinkwind(int f, int n)
354			{
355			struct mgwin *adjwp;
356			struct line *lp;
357			int i;
358
359			if (n < 0)
360			return (enlargewind(f, -n));
361			if (wheadp->w_wndp == NULL) {
362			dobeep();
363			ewprintf("Only one window");
364			return (FALSE);
365			}
366			/*
367			* Bit of flakiness - FFRAND means it was an internal call, and
368			* to be trusted implicitly about sizes.
369			*/
370			if (!(f & FFRAND) && curwp->w_ntrows <= n) {
371			dobeep();
372			ewprintf("Impossible change");
373			return (FALSE);
374			}
375			if ((adjwp = curwp->w_wndp) == NULL) {
376			adjwp = wheadp;
377			while (adjwp->w_wndp != curwp)
378			adjwp = adjwp->w_wndp;
379			}
380
381			/* grow below */
382			if (curwp->w_wndp == adjwp) {
383			lp = adjwp->w_linep;
384			for (i = 0; i < n && lback(lp) != adjwp->w_bufp->b_headp; ++i)
385			lp = lback(lp);
386			adjwp->w_linep = lp;
387			adjwp->w_toprow -= n;
388			/* grow above */
389			} else {
390			lp = curwp->w_linep;
391			for (i = 0; i < n && lp != curbp->b_headp; ++i)
392			lp = lforw(lp);
393			curwp->w_linep = lp;
394			curwp->w_toprow += n;
395			}
396			curwp->w_ntrows -= n;
397			adjwp->w_ntrows += n;
398			curwp->w_rflag \|= WFMODE \| WFFULL;
399			adjwp->w_rflag \|= WFMODE \| WFFULL;
400			return (TRUE);
401			}
402
403			/*
404			* Delete current window. Call shrink-window to do the screen updating, then
405			* throw away the window.
406			*/
407			/* ARGSUSED */
408			int
409			delwind(int f, int n)
410			{
411			struct mgwin wp, nwp;
412
413			wp = curwp; /* Cheap... */
414
415			/* shrinkwind returning false means only one window... */
416			if (shrinkwind(FFRAND, wp->w_ntrows + 1) == FALSE)
417			return (FALSE);
418			if (--wp->w_bufp->b_nwnd == 0) {
419			wp->w_bufp->b_dotp = wp->w_dotp;
420			wp->w_bufp->b_doto = wp->w_doto;
421			wp->w_bufp->b_markp = wp->w_markp;
422			wp->w_bufp->b_marko = wp->w_marko;
423			wp->w_bufp->b_dotline = wp->w_dotline;
424			wp->w_bufp->b_markline = wp->w_markline;
425			}
426
427			/* since shrinkwind did't crap out, we know we have a second window */
428			if (wp == wheadp)
429			wheadp = curwp = wp->w_wndp;
430			else if ((curwp = wp->w_wndp) == NULL)
431			curwp = wheadp;
432			curbp = curwp->w_bufp;
433			for (nwp = wheadp; nwp != NULL; nwp = nwp->w_wndp)
434			if (nwp->w_wndp == wp) {
435			nwp->w_wndp = wp->w_wndp;
436			break;
437			}
438			free(wp);
439			return (TRUE);
440			}