/* vi:set sts=4 sw=4:
 *
 * VIM - Vi IMproved	by Bram Moolenaar
 *
 * Do ":help uganda"  in Vim to read a list of people who contributed.
 * Do ":help credits" in Vim to see a list of people who contributed.
 */

#include "vim.h"
#include "globals.h"
#include "proto.h"
#include "option.h"

static int is_url __ARGS((char_u *p));
static void reset_VIsual __ARGS((void));
static int win_comp_pos __ARGS((void));
static void win_exchange __ARGS((long));
static void win_rotate __ARGS((int, int));
static void win_goto __ARGS((WIN *wp));
static void win_append __ARGS((WIN *, WIN *));
static void win_remove __ARGS((WIN *));
static void win_new_height __ARGS((WIN *, int));

static WIN	*prevwin = NULL;	/* previous window */

#define URL_SLASH	1		/* is_url() has found "://" */
#define URL_BACKSLASH	2		/* is_url() has found ":\\" */

/*
 * all CTRL-W window commands are handled here, called from normal_cmd().
 */
    void
do_window(nchar, Prenum)
    int	    nchar;
    long    Prenum;
{
    long    Prenum1;
    WIN	    *wp;
    char_u  *ptr;
    int	    len;
    int	    type = -1;

    if (Prenum == 0)
	Prenum1 = 1;
    else
	Prenum1 = Prenum;

    switch (nchar)
    {
/* split current window in two parts */
    case 'S':
    case Ctrl('S'):
    case 's':	reset_VIsual();			/* stop Visual mode */
		win_split((int)Prenum, TRUE);
		break;

/* split current window and edit alternate file */
    case K_CCIRCM:
    case '^':
		reset_VIsual();			/* stop Visual mode */
		stuffReadbuff((char_u *)":split #");
		if (Prenum)
		    stuffnumReadbuff(Prenum);	/* buffer number */
		stuffcharReadbuff('\n');
		break;

/* open new window */
    case Ctrl('N'):
    case 'n':	reset_VIsual();			/* stop Visual mode */
		stuffcharReadbuff(':');
		if (Prenum)
		    stuffnumReadbuff(Prenum);	    /* window height */
		stuffReadbuff((char_u *)"new\n");   /* it is ex_docmd.c */
		break;

/* quit current window */
    case Ctrl('Q'):
    case 'q':	reset_VIsual();			/* stop Visual mode */
		stuffReadbuff((char_u *)":quit\n"); /* it is ex_docmd.c */
		break;

/* close current window */
    case Ctrl('C'):
    case 'c':	reset_VIsual();			/* stop Visual mode */
		stuffReadbuff((char_u *)":close\n");	/* it is ex_docmd.c */
		break;

/* close all but current window */
    case Ctrl('O'):
    case 'o':	reset_VIsual();			/* stop Visual mode */
		stuffReadbuff((char_u *)":only\n"); /* it is ex_docmd.c */
		break;

/* cursor to next window */
    case 'j':
    case K_DOWN:
    case Ctrl('J'):
		for (wp = curwin; wp->w_next != NULL && Prenum1-- > 0;
							    wp = wp->w_next)
		    ;
		win_goto(wp);
		break;

/* cursor to next window with wrap around */
    case Ctrl('W'):
    case 'w':
/* cursor to previous window with wrap around */
    case 'W':
		if (lastwin == firstwin)	/* just one window */
		    beep_flush();
		else
		{
		    if (Prenum)			/* go to specified window */
		    {
			for (wp = firstwin; --Prenum > 0; )
			{
			    if (wp->w_next == NULL)
				break;
			    else
				wp = wp->w_next;
			}
		    }
		    else
		    {
			if (nchar == 'W')	    /* go to previous window */
			{
			    wp = curwin->w_prev;
			    if (wp == NULL)
				wp = lastwin;	    /* wrap around */
			}
			else			    /* go to next window */
			{
			    wp = curwin->w_next;
			    if (wp == NULL)
				wp = firstwin;	    /* wrap around */
			}
		    }
		    win_goto(wp);
		}
		break;

/* cursor to window above */
    case 'k':
    case K_UP:
    case Ctrl('K'):
		for (wp = curwin; wp->w_prev != NULL && Prenum1-- > 0;
							    wp = wp->w_prev)
		    ;
		win_goto(wp);
		break;

/* cursor to top window */
    case 't':
    case Ctrl('T'):
		wp = firstwin;
		win_goto(wp);
		break;

/* cursor to bottom window */
    case 'b':
    case Ctrl('B'):
		wp = lastwin;
		win_goto(wp);
		break;

/* cursor to last accessed (previous) window */
    case 'p':
    case Ctrl('P'):
		if (prevwin == NULL)
		    beep_flush();
		else
		{
		    wp = prevwin;
		    win_goto(wp);
		}
		break;

/* exchange current and next window */
    case 'x':
    case Ctrl('X'):
		win_exchange(Prenum);
		break;

/* rotate windows downwards */
    case Ctrl('R'):
    case 'r':	reset_VIsual();			/* stop Visual mode */
		win_rotate(FALSE, (int)Prenum1);    /* downwards */
		break;

/* rotate windows upwards */
    case 'R':	reset_VIsual();			/* stop Visual mode */
		win_rotate(TRUE, (int)Prenum1);	    /* upwards */
		break;

/* make all windows the same height */
    case '=':	win_equal(NULL, TRUE);
		break;

/* increase current window height */
    case '+':	win_setheight(curwin->w_height + (int)Prenum1);
		break;

/* decrease current window height */
    case '-':	win_setheight(curwin->w_height - (int)Prenum1);
		break;

/* set current window height */
    case Ctrl('_'):
    case '_':	win_setheight(Prenum ? (int)Prenum : 9999);
		break;

/* jump to tag and split window if tag exists */
    case ']':
    case Ctrl(']'):
		reset_VIsual();			/* stop Visual mode */
		postponed_split = TRUE;
		stuffcharReadbuff(Ctrl(']'));
		break;

/* edit file name under cursor in a new window */
    case 'f':
    case Ctrl('F'):
		reset_VIsual();			/* stop Visual mode */
		ptr = file_name_at_cursor(FNAME_MESS|FNAME_HYP|FNAME_EXP,
								     Prenum1);
		if (ptr != NULL)
		{
		    setpcmark();
		    if (win_split(0, FALSE) == OK)
			(void)do_ecmd(0, ptr, NULL, NULL, (linenr_t)0,
						       p_hid ? ECMD_HIDE : 0);
		    vim_free(ptr);
		}
		break;

/* Go to the first occurence of the identifier under cursor along path in a
 * new window -- webb
 */
    case 'i':			    /* Go to any match */
    case Ctrl('I'):
		type = FIND_ANY;
		/* FALLTHROUGH */
    case 'd':			    /* Go to definition, using p_def */
    case Ctrl('D'):
		if (type == -1)
		    type = FIND_DEFINE;

		if ((len = find_ident_under_cursor(&ptr, FIND_IDENT)) == 0)
		    break;
		find_pattern_in_path(ptr, len, TRUE,
			Prenum == 0 ? TRUE : FALSE, type,
			Prenum1, ACTION_SPLIT, (linenr_t)1, (linenr_t)MAXLNUM);
		curwin->w_set_curswant = TRUE;
		break;

    default:	beep_flush();
		break;
    }
}

    static void
reset_VIsual()
{
    if (VIsual_active)
    {
	end_visual_mode();
	update_curbuf(NOT_VALID);	/* delete the inversion */
    }
}

/*
 * split the current window, implements CTRL-W s and :split
 *
 * new_height is the height for the new window, 0 to make half of current
 * height
 * redraw is TRUE when redraw now
 *
 * return FAIL for failure, OK otherwise
 */
    int
win_split(new_height, redraw)
    int	    new_height;
    int	    redraw;
{
    WIN		*wp;
    int		i;
    int		need_status;
    int		do_equal = (p_ea && new_height == 0);
    int		needed;
    int		available;
    int		curwin_height;

	/* add a status line when p_ls == 1 and splitting the first window */
    if (lastwin == firstwin && p_ls == 1 && curwin->w_status_height == 0)
	need_status = STATUS_HEIGHT;
    else
	need_status = 0;

/*
 * check if we are able to split the current window and compute its height
 */
    available = curwin->w_height;
    needed = 2 * MIN_ROWS + STATUS_HEIGHT + need_status;
    if (p_ea)
    {
	for (wp = firstwin; wp != NULL; wp = wp->w_next)
	    if (wp != curwin)
	    {
		available += wp->w_height;
		needed += MIN_ROWS;
	    }
    }
    if (available < needed)
    {
	EMSG(e_noroom);
	return FAIL;
    }
    curwin_height = curwin->w_height;
    if (need_status)
    {
	curwin->w_status_height = STATUS_HEIGHT;
	curwin_height -= STATUS_HEIGHT;
    }
    if (new_height == 0)
	new_height = curwin_height / 2;

    if (new_height > curwin_height - MIN_ROWS - STATUS_HEIGHT)
	new_height = curwin_height - MIN_ROWS - STATUS_HEIGHT;

    if (new_height < MIN_ROWS)
	new_height = MIN_ROWS;

	/* if it doesn't fit in the current window, need win_equal() */
    if (curwin_height - new_height - STATUS_HEIGHT < MIN_ROWS)
	do_equal = TRUE;
/*
 * allocate new window structure and link it in the window list
 */
    if (p_sb)	    /* new window below current one */
	wp = win_alloc(curwin);
    else
	wp = win_alloc(curwin->w_prev);
    if (wp == NULL)
	return FAIL;
/*
 * compute the new screen positions
 */
    win_new_height(wp, new_height);
    win_new_height(curwin, curwin_height - (new_height + STATUS_HEIGHT));
    if (p_sb)	    /* new window below current one */
    {
	wp->w_winpos = curwin->w_winpos + curwin->w_height + STATUS_HEIGHT;
	wp->w_status_height = curwin->w_status_height;
	curwin->w_status_height = STATUS_HEIGHT;
    }
    else	    /* new window above current one */
    {
	wp->w_winpos = curwin->w_winpos;
	wp->w_status_height = STATUS_HEIGHT;
	curwin->w_winpos = wp->w_winpos + wp->w_height + STATUS_HEIGHT;
    }
/*
 * make the contents of the new window the same as the current one
 */
    wp->w_buffer = curbuf;
    curbuf->b_nwindows++;
    wp->w_cursor = curwin->w_cursor;
    wp->w_valid = 0;
    wp->w_curswant = curwin->w_curswant;
    wp->w_set_curswant = curwin->w_set_curswant;
    wp->w_topline = curwin->w_topline;
    wp->w_leftcol = curwin->w_leftcol;
    wp->w_pcmark = curwin->w_pcmark;
    wp->w_prev_pcmark = curwin->w_prev_pcmark;
    wp->w_alt_fnum = curwin->w_alt_fnum;
    wp->w_fraction = curwin->w_fraction;
    wp->w_prev_fraction_row = curwin->w_prev_fraction_row;

    wp->w_arg_idx = curwin->w_arg_idx;
    /*
     * copy tagstack and options from existing window
     */
    for (i = 0; i < curwin->w_tagstacklen; i++)
    {
	wp->w_tagstack[i].fmark = curwin->w_tagstack[i].fmark;
	wp->w_tagstack[i].tagname = vim_strsave(curwin->w_tagstack[i].tagname);
    }
    wp->w_tagstackidx = curwin->w_tagstackidx;
    wp->w_tagstacklen = curwin->w_tagstacklen;
    win_copy_options(curwin, wp);
/*
 * Both windows need redrawing
 */
    wp->w_redr_type = NOT_VALID;
    wp->w_redr_status = TRUE;
    curwin->w_redr_type = NOT_VALID;
    curwin->w_redr_status = TRUE;

    if (need_status)
    {
	msg_pos((int)Rows - 1, sc_col);
	msg_clr_eos();	    /* Old command/ruler may still be there -- webb */
	comp_col();
	msg_pos((int)Rows - 1, 0);  /* put position back at start of line */
    }
/*
 * make the new window the current window and redraw
 */
    if (do_equal)
	win_equal(wp, FALSE);
    win_enter(wp, FALSE);

    if (redraw)
	update_screen(NOT_VALID);
    else
	redraw_later(NOT_VALID);

    return OK;
}

/*
 * Check if "win" is a pointer to an existing window.
 */
    int
win_valid(win)
    WIN	    *win;
{
    WIN	    *wp;

    for (wp = firstwin; wp != NULL; wp = wp->w_next)
	if (wp == win)
	    return TRUE;
    return FALSE;
}

/*
 * Return the number of windows.
 */
    int
win_count()
{
    WIN	    *wp;
    int	    count = 0;

    for (wp = firstwin; wp != NULL; wp = wp->w_next)
	++count;
    return count;
}

/*
 * Make 'count' windows on the screen.
 * Return actual number of windows on the screen.
 * Must be called when there is just one window, filling the whole screen
 * (excluding the command line).
 */
    int
make_windows(count)
    int	    count;
{
    int	    maxcount;
    int	    todo;
    int	    p_sb_save;

/*
 * Each window needs at least MIN_ROWS lines and a status line.
 * Add 4 lines for one window, otherwise we may end up with all one-line
 * windows. Use value of 'winheight' if it is set
 */
    maxcount = (curwin->w_height + curwin->w_status_height -
			(p_wh ? (p_wh - 1) : 4)) / (MIN_ROWS + STATUS_HEIGHT);
    if (maxcount < 2)
	maxcount = 2;
    if (count > maxcount)
	count = maxcount;

    /*
     * add status line now, otherwise first window will be too big
     */
    if ((p_ls == 2 || (count > 1 && p_ls == 1)) && curwin->w_status_height == 0)
    {
	curwin->w_status_height = STATUS_HEIGHT;
	win_new_height(curwin, curwin->w_height - STATUS_HEIGHT);
    }

#ifdef AUTOCMD
/*
 * Don't execute autocommands while creating the windows.  Must do that
 * when putting the buffers in the windows.
 */
    ++autocmd_busy;
#endif

/*
 * set 'splitbelow' off for a moment, don't want that now
 */
    p_sb_save = p_sb;
    p_sb = FALSE;
	/* todo is number of windows left to create */
    for (todo = count - 1; todo > 0; --todo)
	if (win_split(curwin->w_height - (curwin->w_height - todo
		* STATUS_HEIGHT) / (todo + 1) - STATUS_HEIGHT, FALSE) == FAIL)
	    break;
    p_sb = p_sb_save;

#ifdef AUTOCMD
    --autocmd_busy;
#endif

	/* return actual number of windows */
    return (count - todo);
}

/*
 * Exchange current and next window
 */
    static void
win_exchange(Prenum)
    long	Prenum;
{
    WIN	    *wp;
    WIN	    *wp2;
    int	    temp;

    if (lastwin == firstwin)	    /* just one window */
    {
	beep_flush();
	return;
    }

/*
 * find window to exchange with
 */
    if (Prenum)
    {
	wp = firstwin;
	while (wp != NULL && --Prenum > 0)
	    wp = wp->w_next;
    }
    else if (curwin->w_next != NULL)	/* Swap with next */
	wp = curwin->w_next;
    else    /* Swap last window with previous */
	wp = curwin->w_prev;

    if (wp == curwin || wp == NULL)
	return;

/*
 * 1. remove curwin from the list. Remember after which window it was in wp2
 * 2. insert curwin before wp in the list
 * if wp != wp2
 *    3. remove wp from the list
 *    4. insert wp after wp2
 * 5. exchange the status line height
 */
    wp2 = curwin->w_prev;
    win_remove(curwin);
    win_append(wp->w_prev, curwin);
    if (wp != wp2)
    {
	win_remove(wp);
	win_append(wp2, wp);
    }
    temp = curwin->w_status_height;
    curwin->w_status_height = wp->w_status_height;
    wp->w_status_height = temp;

    win_comp_pos();		/* recompute window positions */

    win_enter(wp, TRUE);
    update_screen(CLEAR);
}

/*
 * rotate windows: if upwards TRUE the second window becomes the first one
 *		   if upwards FALSE the first window becomes the second one
 */
    static void
win_rotate(upwards, count)
    int	    upwards;
    int	    count;
{
    WIN		 *wp;
    int		 height;

    if (firstwin == lastwin)		/* nothing to do */
    {
	beep_flush();
	return;
    }
    while (count--)
    {
	if (upwards)		/* first window becomes last window */
	{
	    wp = firstwin;
	    win_remove(wp);
	    win_append(lastwin, wp);
	    wp = lastwin->w_prev;	    /* previously last window */
	}
	else			/* last window becomes first window */
	{
	    wp = lastwin;
	    win_remove(lastwin);
	    win_append(NULL, wp);
	    wp = firstwin;		    /* previously last window */
	}
	    /* exchange status height of old and new last window */
	height = lastwin->w_status_height;
	lastwin->w_status_height = wp->w_status_height;
	wp->w_status_height = height;

	    /* recompute w_winpos for all windows */
	(void) win_comp_pos();
    }

    update_screen(CLEAR);
}

/*
 * Make all windows the same height.
 * 'next_curwin' will soon be the current window, make sure it has enough
 * rows.
 */
    void
win_equal(next_curwin, redraw)
    WIN	    *next_curwin;	    /* pointer to current window to be */
    int	    redraw;
{
    int	    total;
    int	    less;
    int	    wincount;
    int	    winpos;
    int	    temp;
    WIN	    *wp;
    int	    new_height;

/*
 * count the number of lines available
 */
    total = 0;
    wincount = 0;
    for (wp = firstwin; wp; wp = wp->w_next)
    {
	total += wp->w_height - MIN_ROWS;
	wincount++;
    }

/*
 * If next_curwin given and 'winheight' set, make next_curwin p_wh lines.
 */
    less = 0;
    if (next_curwin != NULL)
    {
	if (p_wh)
	{
	    if (p_wh - MIN_ROWS > total)    /* all lines go to current window */
		less = total;
	    else
	    {
		less = p_wh - MIN_ROWS - total / wincount;
		if (less < 0)
		    less = 0;
	    }
	}
    }

/*
 * spread the available lines over the windows
 */
    winpos = 0;
    for (wp = firstwin; wp != NULL; wp = wp->w_next)
    {
	if (wp == next_curwin && less)
	{
	    less = 0;
	    temp = p_wh - MIN_ROWS;
	    if (temp > total)
		temp = total;
	}
	else
	    temp = (total - less + ((unsigned)wincount >> 1)) / wincount;
	new_height = MIN_ROWS + temp;
	if (wp->w_winpos != winpos || wp->w_height != new_height)
	{
	    wp->w_redr_type = NOT_VALID;
	    wp->w_redr_status = TRUE;
	}
	wp->w_winpos = winpos;
	win_new_height(wp, new_height);
	total -= temp;
	--wincount;
	winpos += wp->w_height + wp->w_status_height;
    }
    if (redraw)
	redraw_later(CLEAR);
}

/*
 * close all windows for buffer 'buf'
 */
    void
close_windows(buf)
    BUF	    *buf;
{
    WIN	    *win;

    ++RedrawingDisabled;
    for (win = firstwin; win != NULL && lastwin != firstwin; )
    {
	if (win->w_buffer == buf)
	{
	    close_window(win, FALSE);
	    win = firstwin;	    /* go back to the start */
	}
	else
	    win = win->w_next;
    }
    --RedrawingDisabled;
}

/*
 * close window "win"
 * If "free_buf" is TRUE related buffer may be freed.
 *
 * called by :quit, :close, :xit, :wq and findtag()
 */
    void
close_window(win, free_buf)
    WIN	    *win;
    int	    free_buf;
{
    WIN	    *wp;
#ifdef AUTOCMD
    int	    other_buffer = FALSE;
#endif

    if (lastwin == firstwin)
    {
	EMSG("Cannot close last window");
	return;
    }

#ifdef AUTOCMD
    if (win == curwin)
    {
	/*
	 * Guess which window is going to be the new current window.
	 * This may change because of the autocommands (sigh).
	 */
	if ((!p_sb && win->w_next != NULL) || win->w_prev == NULL)
	    wp = win->w_next;
	else
	    wp = win->w_prev;

	/*
	 * Be careful: If autocommands delete the window, return now.
	 */
	if (wp->w_buffer != curbuf)
	{
	    other_buffer = TRUE;
	    apply_autocmds(EVENT_BUFLEAVE, NULL, NULL, FALSE);
	    if (!win_valid(win))
		return;
	}
	apply_autocmds(EVENT_WINLEAVE, NULL, NULL, FALSE);
	if (!win_valid(win))
	    return;
    }
#endif

/*
 * Remove the window.
 * if 'splitbelow' the free space goes to the window above it.
 * if 'nosplitbelow' the free space goes to the window below it.
 * This makes opening a window and closing it immediately keep the same window
 * layout.
 */
				    /* freed space goes to next window */
    if ((!p_sb && win->w_next != NULL) || win->w_prev == NULL)
    {
	wp = win->w_next;
	wp->w_winpos = win->w_winpos;
    }
    else			    /* freed space goes to previous window */
	wp = win->w_prev;
    win_new_height(wp, wp->w_height + win->w_height + win->w_status_height);

/*
 * Close the link to the buffer.
 */
    close_buffer(win, win->w_buffer, free_buf, FALSE);

    win_free(win);
    if (win == curwin)
	curwin = NULL;
    if (p_ea)
	win_equal(wp, FALSE);
    if (curwin == NULL)
    {
	win_enter(wp, FALSE);
#ifdef AUTOCMD
	if (other_buffer)
	    /* careful: after this wp and win may be invalid! */
	    apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE);
#endif
    }

    /*
     * if last window has status line now and we don't want one,
     * remove the status line
     */
    if (lastwin->w_status_height &&
			(p_ls == 0 || (p_ls == 1 && firstwin == lastwin)))
    {
	win_new_height(lastwin, lastwin->w_height + lastwin->w_status_height);
	lastwin->w_status_height = 0;
	comp_col();
    }

    update_screen(NOT_VALID);
}

/*
 * close all windows except current one
 * buffers in the windows become hidden
 *
 * called by :only and do_arg_all();
 */
    void
close_others(message)
    int	    message;
{
    WIN	    *wp;
    WIN	    *nextwp;

    if (lastwin == firstwin)
    {
	if (message
#ifdef AUTOCMD
		    && !autocmd_busy
#endif
				    )
	    MSG("Already only one window");
	return;
    }

    for (wp = firstwin; wp != NULL; wp = nextwp)
    {
	nextwp = wp->w_next;
	if (wp == curwin)		/* don't close current window */
	    continue;
	/*
	 * Close the link to the buffer.
	 */
	close_buffer(wp, wp->w_buffer, FALSE, FALSE);

	/*
	 * Remove the window. All lines go to current window.
	 */
	win_new_height(curwin,
		       curwin->w_height + wp->w_height + wp->w_status_height);
	win_free(wp);
    }

    /*
     * If current window has status line and we don't want one,
     * remove the status line.
     */
    if (curwin->w_status_height && p_ls != 2)
    {
	win_new_height(curwin, curwin->w_height + curwin->w_status_height);
	curwin->w_status_height = 0;
    }
    curwin->w_winpos = 0;	/* put current window at top of the screen */
    if (message)
	update_screen(NOT_VALID);
}

/*
 * init the cursor in the window
 *
 * called when a new file is being edited
 */
    void
win_init(wp)
    WIN	    *wp;
{
    wp->w_redr_type = NOT_VALID;
    wp->w_cursor.lnum = 1;
    wp->w_curswant = wp->w_cursor.col = 0;
    wp->w_pcmark.lnum = 1;	/* pcmark not cleared but set to line 1 */
    wp->w_pcmark.col = 0;
    wp->w_prev_pcmark.lnum = 0;
    wp->w_prev_pcmark.col = 0;
    wp->w_topline = 1;
    wp->w_botline = 2;
#ifdef FKMAP
    if (curwin->w_p_rl)
	wp->w_p_pers = W_CONV + W_R_L;
    else
	wp->w_p_pers = W_CONV;
#endif
}

/*
 * Go to another window.
 * When jumping to another buffer, stop visual mode.  Do this before
 * changing windows so we can yank the selection into the '*' register.
 */
    static void
win_goto(wp)
    WIN	    *wp;
{
    if (wp->w_buffer != curbuf && VIsual_active)
    {
	end_visual_mode();
	redraw_curbuf_later(NOT_VALID);
    }
    win_enter(wp, TRUE);
}

/*
 * Go to window nr "winnr" (counting top to bottom).
 */
    WIN *
win_goto_nr(winnr)
    int	    winnr;
{
    WIN	    *wp;

    for (wp = firstwin; wp != NULL; wp = wp->w_next)
	if (--winnr == 0)
	    break;
    return wp;
}

/*
 * Make window wp the current window.
 * Can be called when curwin == NULL, if curwin already has been closed.
 */
    void
win_enter(wp, undo_sync)
    WIN	    *wp;
    int	    undo_sync;
{
#ifdef AUTOCMD
    int		other_buffer = FALSE;
#endif

    if (wp == curwin)		/* nothing to do */
	return;

#ifdef AUTOCMD
    if (curwin != NULL)
    {
	/*
	 * Be careful: If autocommands delete the window, return now.
	 */
	if (wp->w_buffer != curbuf)
	{
	    apply_autocmds(EVENT_BUFLEAVE, NULL, NULL, FALSE);
	    other_buffer = TRUE;
	    if (!win_valid(wp))
		return;
	}
	apply_autocmds(EVENT_WINLEAVE, NULL, NULL, FALSE);
	if (!win_valid(wp))
	    return;
    }
#endif

	/* sync undo before leaving the current buffer */
    if (undo_sync && curbuf != wp->w_buffer)
	u_sync();
	/* may have to copy the buffer options when 'cpo' contains 'S' */
    if (wp->w_buffer != curbuf)
	buf_copy_options(curbuf, wp->w_buffer, TRUE, FALSE);
    if (curwin != NULL)
	prevwin = curwin;	/* remember for CTRL-W p */
    curwin = wp;
    curbuf = wp->w_buffer;
    changed_line_abv_curs();	/* assume cursor position needs updating */

#ifdef AUTOCMD
    apply_autocmds(EVENT_WINENTER, NULL, NULL, FALSE);
    if (other_buffer)
	apply_autocmds(EVENT_BUFENTER, NULL, NULL, FALSE);
#endif

    maketitle();
	    /* set window height to desired minimal value */
    if (p_wh && curwin->w_height < p_wh)
	win_setheight((int)p_wh);
#ifdef USE_MOUSE
    setmouse();			/* in case jumped to/from help buffer */
#endif
}

/*
 * allocate a window structure and link it in the window list
 */
    WIN *
win_alloc(after)
    WIN	    *after;
{
    WIN	    *newwin;

/*
 * allocate window structure and linesizes arrays
 */
    newwin = (WIN *)alloc_clear((unsigned)sizeof(WIN));
    if (newwin)
    {
/*
 * link the window in the window list
 */
	win_append(after, newwin);

	win_alloc_lsize(newwin);

	/* position the display and the cursor at the top of the file. */
	newwin->w_topline = 1;
	newwin->w_botline = 2;
	newwin->w_cursor.lnum = 1;

	/* We won't calculate w_fraction until resizing the window */
	newwin->w_fraction = 0;
	newwin->w_prev_fraction_row = -1;

#ifdef USE_GUI
	if (gui.in_use)
	{
	    gui_create_scrollbar(&newwin->w_scrollbars[SBAR_LEFT], newwin);
	    gui_create_scrollbar(&newwin->w_scrollbars[SBAR_RIGHT], newwin);
	}
#endif
    }
    return newwin;
}

/*
 * remove window 'wp' from the window list and free the structure
 */
    void
win_free(wp)
    WIN	    *wp;
{
    int	    i;

#ifdef HAVE_PERL_INTERP
    perl_win_free(wp);
#endif

#ifdef HAVE_PYTHON
    python_window_free(wp);
#endif

    if (prevwin == wp)
	prevwin = NULL;
    win_free_lsize(wp);

    for (i = 0; i < wp->w_tagstacklen; ++i)
	free(wp->w_tagstack[i].tagname);

#ifdef USE_GUI
    if (gui.in_use)
    {
	gui_mch_destroy_scrollbar(&wp->w_scrollbars[SBAR_LEFT]);
	gui_mch_destroy_scrollbar(&wp->w_scrollbars[SBAR_RIGHT]);
    }
#endif /* USE_GUI */

    win_remove(wp);
    vim_free(wp);
}

    static void
win_append(after, wp)
    WIN	    *after, *wp;
{
    WIN	    *before;

    if (after == NULL)	    /* after NULL is in front of the first */
	before = firstwin;
    else
	before = after->w_next;

    wp->w_next = before;
    wp->w_prev = after;
    if (after == NULL)
	firstwin = wp;
    else
	after->w_next = wp;
    if (before == NULL)
	lastwin = wp;
    else
	before->w_prev = wp;
}

/*
 * remove window from the window list
 */
    static void
win_remove(wp)
    WIN	    *wp;
{
    if (wp->w_prev)
	wp->w_prev->w_next = wp->w_next;
    else
	firstwin = wp->w_next;
    if (wp->w_next)
	wp->w_next->w_prev = wp->w_prev;
    else
	lastwin = wp->w_prev;
}

/*
 * allocate lsize arrays for a window
 * return FAIL for failure, OK for success
 */
    int
win_alloc_lsize(wp)
    WIN	    *wp;
{
    wp->w_lsize_valid = 0;
    wp->w_lsize_lnum = (linenr_t *) malloc((size_t) (Rows * sizeof(linenr_t)));
    wp->w_lsize = (char_u *)malloc((size_t) Rows);
    if (wp->w_lsize_lnum == NULL || wp->w_lsize == NULL)
    {
	win_free_lsize(wp);	/* one of the two may have worked */
	return FAIL;
    }
    return OK;
}

/*
 * free lsize arrays for a window
 */
    void
win_free_lsize(wp)
    WIN	    *wp;
{
    vim_free(wp->w_lsize_lnum);
    vim_free(wp->w_lsize);
    wp->w_lsize_lnum = NULL;
    wp->w_lsize = NULL;
}

/*
 * call this fuction whenever Rows changes value
 */
    void
screen_new_rows()
{
    WIN	    *wp;
    int	    extra_lines;

    if (firstwin == NULL)	/* not initialized yet */
	return;
/*
 * the number of extra lines is the difference between the position where
 * the command line should be and where it is now
 */
    extra_lines = Rows - p_ch -
	   (lastwin->w_winpos + lastwin->w_height + lastwin->w_status_height);
    if (extra_lines < 0)			/* reduce windows height */
    {
	for (wp = lastwin; wp; wp = wp->w_prev)
	{
	    if (wp->w_height - MIN_ROWS < -extra_lines)
	    {
		extra_lines += wp->w_height - MIN_ROWS;
		win_new_height(wp, MIN_ROWS);
	    }
	    else
	    {
		win_new_height(wp, wp->w_height + extra_lines);
		break;
	    }
	}
	(void)win_comp_pos();		    /* compute w_winpos */
    }
    else if (extra_lines > 0)		    /* increase height of last window */
	win_new_height(lastwin, lastwin->w_height + extra_lines);

    compute_cmdrow();

    if (p_ea)
	win_equal(curwin, FALSE);
}

/*
 * update the w_winpos field for all windows
 * returns the row just after the last window
 */
    static int
win_comp_pos()
{
    WIN	    *wp;
    int	    row;

    row = 0;
    for (wp = firstwin; wp != NULL; wp = wp->w_next)
    {
	if (wp->w_winpos != row)	/* if position changes, redraw */
	{
	    wp->w_winpos = row;
	    wp->w_redr_type = NOT_VALID;
	    wp->w_redr_status = TRUE;
	}
	row += wp->w_height + wp->w_status_height;
    }
    return row;
}

/*
 * set current window height
 */
    void
win_setheight(height)
    int	    height;
{
    WIN	    *wp;
    int	    room;		/* total number of lines available */
    int	    take;		/* number of lines taken from other windows */
    int	    room_cmdline;	/* lines available from cmdline */
    int	    row;
    int	    run;

    if (height < MIN_ROWS)	/* need at least some lines */
	height = MIN_ROWS;
/*
 * compute the room we have from all the windows
 */
    room = MIN_ROWS;		/* count the MIN_ROWS for the current window */
    for (wp = firstwin; wp != NULL; wp = wp->w_next)
	room += wp->w_height - MIN_ROWS;
/*
 * compute the room available from the command line
 */
    room_cmdline = Rows - p_ch - cmdline_row;
/*
 * limit new height to the room available
 */
    if (height > room + room_cmdline)	    /* can't make it that large */
	height = room + room_cmdline;	    /* use all available room */
/*
 * compute the number of lines we will take from the windows (can be negative)
 */
    take = height - curwin->w_height;
    if (take == 0)			    /* no change, nothing to do */
	return;

    if (take > 0)
    {
	take -= room_cmdline;		    /* use lines from cmdline first */
	if (take < 0)
	    take = 0;
    }
/*
 * set the current window to the new height
 */
    win_new_height(curwin, height);

/*
 * First take lines from the windows below the current window.
 * If that is not enough, takes lines from windows above the current window.
 */
    for (run = 0; run < 2; ++run)
    {
	if (run == 0)
	    wp = curwin->w_next;	/* 1st run: start with next window */
	else
	    wp = curwin->w_prev;	/* 2nd run: start with prev window */
	while (wp != NULL && take != 0)
	{
	    if (wp->w_height - take < MIN_ROWS)
	    {
		take -= wp->w_height - MIN_ROWS;
		win_new_height(wp, MIN_ROWS);
	    }
	    else
	    {
		win_new_height(wp, wp->w_height - take);
		take = 0;
	    }
	    if (run == 0)
		wp = wp->w_next;
	    else
		wp = wp->w_prev;
	}
    }

/* recompute the window positions */
    row = win_comp_pos();

/*
 * If there is extra space created between the last window and the command line,
 * clear it.
 */
    if (full_screen)
	screen_fill(row, cmdline_row, 0, (int)Columns, ' ', ' ', 0);
    cmdline_row = row;

    update_screen(NOT_VALID);
}

#ifdef USE_MOUSE
    void
win_drag_status_line(offset)
    int	    offset;
{
    WIN	    *wp;
    int	    room;
    int	    row;
    int	    up;		    /* if TRUE, drag status line up, otherwise down */

    if (offset < 0)
    {
	up = TRUE;
	offset = -offset;
    }
    else
	up = FALSE;

    if (up) /* drag up */
    {
	room = 0;
	for (wp = curwin; wp != NULL && room < offset; wp = wp->w_prev)
	    room += wp->w_height - MIN_ROWS;
	wp = curwin->w_next;		    /* put wp at window that grows */
    }
    else    /* drag down */
    {
	/*
	 * Only dragging the last status line can reduce p_ch.
	 */
	room = Rows - cmdline_row;
	if (curwin->w_next == NULL)
	    room -= 1;
	else
	    room -= p_ch;
	for (wp = curwin->w_next; wp != NULL && room < offset; wp = wp->w_next)
	    room += wp->w_height - MIN_ROWS;
	wp = curwin;			    /* put wp at window that grows */
    }

    if (room < offset)	    /* Not enough room */
	offset = room;	    /* Move as far as we can */
    if (offset <= 0)
	return;

    if (wp != NULL)	    /* grow window wp by offset lines */
	win_new_height(wp, wp->w_height + offset);

    if (up)
	wp = curwin;		    /* current window gets smaller */
    else
	wp = curwin->w_next;	    /* next window gets smaller */

    while (wp != NULL && offset > 0)
    {
	if (wp->w_height - offset < MIN_ROWS)
	{
	    offset -= wp->w_height - MIN_ROWS;
	    win_new_height(wp, MIN_ROWS);
	}
	else
	{
	    win_new_height(wp, wp->w_height - offset);
	    offset = 0;
	}
	if (up)
	    wp = wp->w_prev;
	else
	    wp = wp->w_next;
    }
    row = win_comp_pos();
    screen_fill(row, cmdline_row, 0, (int)Columns, ' ', ' ', 0);
    cmdline_row = row;
    p_ch = Rows - cmdline_row;
    update_screen(NOT_VALID);
    showmode();
}
#endif /* USE_MOUSE */

/*
 * Set new window height.
 */
    static void
win_new_height(wp, height)
    WIN	    *wp;
    int	    height;
{
    linenr_t	lnum;
    int		sline, line_size = 1;
#define FRACTION_MULT	16384L

    if (wp->w_wrow != wp->w_prev_fraction_row && wp->w_height > 0)
	wp->w_fraction = ((long)wp->w_wrow * FRACTION_MULT
				    + FRACTION_MULT / 2) / (long)wp->w_height;

    wp->w_height = height;

    lnum = wp->w_cursor.lnum;
    if (lnum < 1)		/* can happen when starting up */
	lnum = 1;
    wp->w_wrow = ((long)wp->w_fraction * (long)height - 1L) / FRACTION_MULT;
    line_size = plines_win_col(wp, lnum, (long)(wp->w_cursor.col)) - 1;
    sline = wp->w_wrow - line_size;
    if (sline < 0)
    {
	/*
	 * Cursor line would go off top of screen if w_wrow was this high.
	 */
	wp->w_wrow = line_size;
    }
    else
    {
	while (sline > 0 && lnum > 1)
	    sline -= (line_size = plines_win(wp, --lnum));
	if (sline < 0)
	{
	    /*
	     * Line we want at top would go off top of screen.	Use next line
	     * instead.
	     */
	    lnum++;
	    wp->w_wrow -= line_size + sline;
	}
	else if (sline > 0)
	{
	    /* First line of file reached, use that as topline. */
	    lnum = 1;
	    wp->w_wrow -= sline;
	}
    }
    set_topline(wp, lnum);
    if (wp == curwin)
    {
	if (p_so)
	    update_topline();
	curs_columns(FALSE);	    /* validate w_wrow */
    }
    wp->w_prev_fraction_row = wp->w_wrow;

    win_comp_scroll(wp);
    if (wp->w_redr_type < VALID)
	wp->w_redr_type = VALID;
    wp->w_redr_status = TRUE;
    invalidate_botline_win(wp);
}

    void
win_comp_scroll(wp)
    WIN	    *wp;
{
    wp->w_p_scroll = ((unsigned)wp->w_height >> 1);
    if (wp->w_p_scroll == 0)
	wp->w_p_scroll = 1;
}

/*
 * command_height: called whenever p_ch has been changed
 */
    void
command_height(old_p_ch)
    long    old_p_ch;
{
    if (!starting)
    {
	cmdline_row = Rows - p_ch;
	if (p_ch > old_p_ch)		    /* p_ch got bigger */
	{
	    if (lastwin->w_height - (p_ch - old_p_ch) < MIN_ROWS)
	    {
		emsg(e_noroom);
		p_ch = lastwin->w_height - MIN_ROWS + old_p_ch;
	    }
	    /* clear the lines added to cmdline */
	    if (full_screen)
		screen_fill((int)(cmdline_row), (int)Rows, 0,
						   (int)Columns, ' ', ' ', 0);
	    msg_row = cmdline_row;
	}
	else if (msg_row < cmdline_row)
	    msg_row = cmdline_row;
	redraw_cmdline = TRUE;
    }
    win_new_height(lastwin, (int)(lastwin->w_height + old_p_ch - p_ch));
}

    void
last_status()
{
    if (lastwin->w_status_height)
    {
		    /* remove status line */
	if (p_ls == 0 || (p_ls == 1 && firstwin == lastwin))
	{
	    win_new_height(lastwin, lastwin->w_height + 1);
	    lastwin->w_status_height = 0;
	}
    }
    else
    {
		    /* add status line */
	if (p_ls == 2 || (p_ls == 1 && firstwin != lastwin))
	{
	    if (lastwin->w_height <= MIN_ROWS)	    /* can't do it */
		emsg(e_noroom);
	    else
	    {
		win_new_height(lastwin, lastwin->w_height - 1);
		lastwin->w_status_height = 1;
	    }
	}
    }
}

/*
 * file_name_at_cursor()
 *
 * Return the name of the file under (or to the right of) the cursor.
 *
 * get_file_name_in_path()
 *
 * Return the name of the file at (or to the right of) ptr[col].
 *
 * The p_path variable is searched if the file name does not start with '/'.
 * The string returned has been alloc'ed and should be freed by the caller.
 * NULL is returned if the file name or file is not found.
 *
 * options:
 * FNAME_MESS	    give error messages
 * FNAME_EXP	    expand to path
 * FNAME_HYP	    check for hypertext link
 */
    char_u *
file_name_at_cursor(options, count)
    int	    options;
    long    count;
{
    return get_file_name_in_path(ml_get_curline(),
					curwin->w_cursor.col, options, count);
}

    char_u *
get_file_name_in_path(line, col, options, count)
    char_u  *line;
    int	    col;
    int	    options;
    long    count;
{
    char_u  *dir;
    char_u  *ptr;
    char_u  *file_name;
    char_u  save_char;
    char_u  *curr_path = NULL;
    int	    curr_path_len;
    int	    len;

    /*
     * search forward for what could be the start of a file name
     */
    ptr = line + col;
    while (*ptr != NUL && !isfilechar(*ptr))
	++ptr;
    if (*ptr == NUL)		/* nothing found */
    {
	if (options & FNAME_MESS)
	    EMSG("No file name under cursor");
	return NULL;
    }

    /*
     * search backward for first char of the file name
     */
    while (ptr > line && isfilechar(ptr[-1]))
	--ptr;

    /*
     * Go one char back to ":" before "//" even when ':' is not in 'isfname'.
     */
    if ((options & FNAME_HYP) && ptr > line && is_url(ptr - 1))
	--ptr;

    /*
     * Search forward for the last char of the file name.
     * Also allow "://" when ':' is not in 'isfname'.
     */
    len = 0;
    while (isfilechar(ptr[len]) || ((options & FNAME_HYP) && is_url(ptr + len)))
	++len;

    if (options & FNAME_HYP)
    {
	/* For hypertext links, ignore the name of the machine.
	 * Such a link looks like "type://machine/path". Only "/path" is used.
	 * First search for the string "://", then for the extra '/'
	 */
	if ((file_name = vim_strchr(ptr, ':')) != NULL &&
		((is_url(file_name) == URL_SLASH &&
		  (file_name = vim_strchr(file_name + 3, '/')) != NULL) ||
		 (is_url(file_name) == URL_BACKSLASH &&
		  (file_name = vim_strchr(file_name + 3, '\\')) != NULL)) &&
		file_name < ptr + len)
	{
	    len -= file_name - ptr;
	    ptr = file_name;
	    if (ptr[1] == '~')	    /* skip '/' for /~user/path */
	    {
		++ptr;
		--len;
	    }
	}
    }

    if (!(options & FNAME_EXP))
	return vim_strnsave(ptr, len);

	/* copy file name into NameBuff, expanding environment variables */
    save_char = ptr[len];
    ptr[len] = NUL;
    expand_env(ptr, NameBuff, MAXPATHL);
    ptr[len] = save_char;

    if (mch_isFullName(NameBuff))	    /* absolute path */
    {
	if ((file_name = vim_strsave(NameBuff)) == NULL)
	    return NULL;
	if (mch_getperm(file_name) >= 0)
	    return file_name;
	if (options & FNAME_MESS)
	{
	    sprintf((char *)IObuff, "Can't find file `%s'", NameBuff);
	    emsg(IObuff);
	}
    }
    else			    /* relative path, use 'path' option */
    {
	if (curbuf->b_fname != NULL)
	{
	    curr_path = curbuf->b_fname;
	    ptr = gettail(curr_path);
	    curr_path_len = ptr - curr_path;
	}
	else
	    curr_path_len = 0;
	if ((file_name = alloc((int)(curr_path_len + STRLEN(p_path) +
					    STRLEN(NameBuff) + 3))) == NULL)
	    return NULL;

	for (dir = p_path; *dir && !got_int; )
	{
	    len = copy_option_part(&dir, file_name, 31000, " ,");
	    /* len == 0 means: use current directory */
	    if (len != 0)
	    {
		/* Look for file relative to current file */
		if (file_name[0] == '.' && curr_path_len > 0 &&
					(len == 1 || ispathsep(file_name[1])))
		{
		    if (len == 1)	/* just a "." */
			len = 0;
		    else		/* "./path": move "path" */
		    {
			len -= 2;
			vim_memmove(file_name + curr_path_len, file_name + 2,
								 (size_t)len);
		    }
		    STRNCPY(file_name, curr_path, curr_path_len);
		    len += curr_path_len;
		}
		if (!ispathsep(file_name[len - 1]))
		    file_name[len++] = PATHSEP;
		file_name[len] = '\0';

		/*
		 * Handle "**" in the path: 'wildcard in path'.
		 */
		if (mch_has_wildcard(file_name))
		{
		    char_u *p;

		    if (file_name[0] == '/' || file_name[0] == '\\')
			p = get_file_name_in_wildcard_path((char_u *)"/",
						    file_name + 1, 0, &count);
		    else
			p = get_file_name_in_wildcard_path((char_u *)"",
							file_name, 0, &count);
		    if (p != NULL)
		    {
			vim_free(file_name);
			return p;
		    }
		    continue;
		}
	    }
	    STRCPY(file_name + len, NameBuff);

	    /*
	     * Translate names like "src/a/../b/file.c" into "src/b/file.c".
	     */
	    simplify_filename(file_name);
	    if (mch_getperm(file_name) >= 0 && --count == 0)
		return file_name;
	}
	if (options & FNAME_MESS)
	    EMSG2("Can't find file \"%s\" in path", NameBuff);
    }
    vim_free(file_name);	    /* file doesn't exist */
    return NULL;
}

/*
 * get_file_name_in_wildcard_path(): expand path recursively while searching
 *				     files in path
 *
 * The syntax '**' means the whole subtree.
 * To avoid endless recursion, a counter restricts the depth to 100 levels.
 * In the following pseudo code '+/' will mean '*' followed by '/'
 *
 * in the case of 'set path=,/foo/bar/+/+/,'
 * the function call hierarchy will be
 *   get_file_name_in_wildcard_path("/", "foo/bar/+/+/", NameBuff, 0);
 *   get_file_name_in_wildcard_path("/foo/", "bar/+/+/", NameBuff, 0);
 *   get_file_name_in_wildcard_path("/foo/bar/", "+/+/", NameBuff, 0);
 * which in turn will call
 *   get_file_name_in_wildcard_path("/foo/bar/dir/", "+/", NameBuff, 1);
 * for each directory 'dir' in '/foo/bar/+'.  It's the next call,
 *   get_file_name_in_wildcard_path("/foo/bar/dir/dir2/", "", NameBuff, 2);
 * that will try to find the file 'NameBuff' in the given directory.
 *
 * pseudo code:
 *
 *  get_file_name_in_wildcard_path(path_so_far, wildcards, level)
 *  {
 *    if (level > 100)
 *	return NULL;
 *
 *    file_name = path_so_far + first_segment(wildcards);
 *    rest_of_wildcards = all_but_first_segment(wildcards);
 *
 *    result = expand(file_name);
 *
 *    if (!rest_of_wildcards) {
 *	foreach_path_in(result) {
 *	  if (exists&readable(path + NameBuff))
 *	    return path+NameBuff;
 *	}
 *    } else {
 *	foreach_path_in(result) {
 *	  c = get_file_name_in_wildcard_path(path, rest_of_wildcards, level+1);
 *	  if (c)
 *	    return c;
 *	}
 *    }
 *    if (infinite_recursion(wildcards)) {
 *	foreach_path_in(result) {
 *	  c = get_file_name_in_wildcard_path(path, wildcards, level+1);
 *	  if (c)
 *	    return c;
 *	}
 *    }
 *    return NULL;
 *  }
 */
    char_u *
get_file_name_in_wildcard_path(path_so_far, wildcards, level, countptr)
    char_u  *path_so_far;
    char_u  *wildcards;
    int	    level;
    long    *countptr;
{
    char_u  *file_name;
    int	    len;
    char_u  *rest_of_wildcards;
    int	    nFiles = 0;
    char_u  **ppFiles;
    int	    i;
    char_u  *c;

    mch_breakcheck();
    if (level > 100 || got_int)
	return NULL;

    if ((file_name = alloc((int)MAXPATHL)) == NULL)
	return NULL;

    STRCPY(file_name, path_so_far);
    len = STRLEN(file_name);
    if (!ispathsep(file_name[len-1]))
    {
	file_name[len++] = PATHSEP;
	file_name[len] = '\0';
    }
    rest_of_wildcards = wildcards;
    if (rest_of_wildcards)
    {
	if (STRNCMP(rest_of_wildcards, "**", 2) == 0)
	    rest_of_wildcards++;
	while (*rest_of_wildcards && !ispathsep(*rest_of_wildcards))
	    file_name[len++] = *rest_of_wildcards++;
	/* file_name[len++] = *rest_of_wildcards++; */
	rest_of_wildcards++;
	file_name[len] = '\0';
    }

    ++expand_interactively;
    expand_wildcards(1, &file_name, &nFiles, &ppFiles, EW_FILE|EW_DIR);
    --expand_interactively;

    if (!*rest_of_wildcards)
    {
	for (i = 0; i < nFiles; ++i)
	{
	    if (!mch_isdir(ppFiles[i]))
		continue;   /* not a directory */
	    STRCPY(file_name, ppFiles[i]);
	    if (!ispathsep(file_name[STRLEN(file_name)-1]))
		STRCAT(file_name, PATHSEPSTR);
	    STRCAT(file_name, NameBuff);
	    if (mch_getperm(file_name) >= 0 && --*countptr == 0)
	    {
		FreeWild(nFiles, ppFiles);
		return file_name;
	    }
	}
    }
    else
    {
	for (i = 0; i < nFiles; ++i)
	{
	    if (!mch_isdir(ppFiles[i]))
		continue;   /* not a directory */
	    c = get_file_name_in_wildcard_path(ppFiles[i],
					rest_of_wildcards, level+1, countptr);
	    if (c)
	    {
		FreeWild(nFiles, ppFiles);
		vim_free(file_name);
		return c;
	    }
	}
    }

    if (STRNCMP(wildcards, "**", 2) == 0)
    {
	for (i = 0; i < nFiles; ++i)
	{
	    if (!mch_isdir(ppFiles[i]))
		continue;   /* not a directory */
	    c = get_file_name_in_wildcard_path(ppFiles[i],
						wildcards, level+1, countptr);
	    if (c)
	    {
		FreeWild(nFiles, ppFiles);
		vim_free(file_name);
		return c;
	    }
	}
    }

    FreeWild(nFiles, ppFiles);

    vim_free(file_name);
    return NULL;
}

/*
 * Check if the "://" of a URL is at the pointer, return URL_SLASH.
 * Also check for ":\\", which MS Internet Explorer accepts, return
 * URL_BACKSLASH.
 */
    static int
is_url(p)
    char_u  *p;
{
    if (STRNCMP(p, "://", (size_t)3) == 0)
	return URL_SLASH;
    else if (STRNCMP(p, ":\\\\", (size_t)3) == 0)
	return URL_BACKSLASH;
    return 0;
}

/*
 * Return the minimal number of rows that is needed on the screen to display
 * the current number of windows.
 */
    int
min_rows()
{
    WIN	    *wp;
    int	    total;

    if (firstwin == NULL)	/* not initialized yet */
	return MIN_ROWS + 1;	/* one window plus command line */

    total = p_ch;	/* count the room for the status line */
    for (wp = firstwin; wp != NULL; wp = wp->w_next)
	total += MIN_ROWS + wp->w_status_height;
    return total;
}

/*
 * Return TRUE if there is only one window, not counting a help window, unless
 * it is the current window.
 */
    int
only_one_window()
{
    int	    count = 0;
    WIN	    *wp;

    for (wp = firstwin; wp != NULL; wp = wp->w_next)
	if (!wp->w_buffer->b_help || wp == curwin)
	    ++count;
    return (count <= 1);
}
