/* Execute the modeline settings, but don't set window-local
* options if we are using the current window for another buffer. */
- do_modelines(aco.save_curwin == NULL ? OPT_NOWIN : 0);
+ do_modelines(curwin == aucmd_win ? OPT_NOWIN : 0);
/* restore the current window */
aucmd_restbuf(&aco);
/*
* Prepare for executing autocommands for (hidden) buffer "buf".
- * Search a window for the current buffer. Save the cursor position and
- * screen offset.
+ * Search for a visible window containing the current buffer. If there isn't
+ * one then use "aucmd_win".
* Set "curbuf" and "curwin" to match "buf".
* When FEAT_AUTOCMD is not defined another version is used, see below.
*/
buf_T *buf; /* new curbuf */
{
win_T *win;
-
- aco->new_curbuf = buf;
+#ifdef FEAT_WINDOWS
+ int save_ea;
+#endif
/* Find a window that is for the new buffer */
if (buf == curbuf) /* be quick when buf is curbuf */
win = NULL;
#endif
- /*
- * Prefer to use an existing window for the buffer, it has the least side
- * effects (esp. if "buf" is curbuf).
- * Otherwise, use curwin for "buf". It might make some items in the
- * window invalid. At least save the cursor and topline.
- */
+ /* Allocate "aucmd_win" when needed. If this fails (out of memory) fall
+ * back to using the current window. */
+ if (win == NULL && aucmd_win == NULL)
+ {
+ win_alloc_aucmd_win();
+ if (aucmd_win == NULL)
+ win = curwin;
+ }
+
+ aco->save_curwin = curwin;
+ aco->save_curbuf = curbuf;
if (win != NULL)
{
- /* there is a window for "buf", make it the curwin */
- aco->save_curwin = curwin;
+ /* There is a window for "buf" in the current tab page, make it the
+ * curwin. This is preferred, it has the least side effects (esp. if
+ * "buf" is curbuf). */
curwin = win;
- aco->save_buf = win->w_buffer;
- aco->new_curwin = win;
}
else
{
- /* there is no window for "buf", use curwin */
- aco->save_curwin = NULL;
- aco->save_buf = curbuf;
- --curbuf->b_nwindows;
+ /* There is no window for "buf", use "aucmd_win". To minimize the side
+ * effects, insert it in a the current tab page.
+ * Anything related to a window (e.g., setting folds) may have
+ * unexpected results. */
+ curwin = aucmd_win;
curwin->w_buffer = buf;
++buf->b_nwindows;
- /* save cursor and topline, set them to safe values */
- aco->save_cursor = curwin->w_cursor;
- curwin->w_cursor.lnum = 1;
- curwin->w_cursor.col = 0;
- aco->save_topline = curwin->w_topline;
- curwin->w_topline = 1;
-#ifdef FEAT_DIFF
- aco->save_topfill = curwin->w_topfill;
- curwin->w_topfill = 0;
+#ifdef FEAT_WINDOWS
+ /* Split the current window, put the aucmd_win in the upper half. */
+ make_snapshot(SNAP_AUCMD_IDX);
+ save_ea = p_ea;
+ p_ea = FALSE;
+ (void)win_split_ins(0, WSP_TOP, aucmd_win, 0);
+ (void)win_comp_pos(); /* recompute window positions */
+ p_ea = save_ea;
+#endif
+ /* set cursor and topline to safe values */
+ curwin_init();
+#ifdef FEAT_VERTSPLIT
+ curwin->w_wincol = 0;
+ curwin->w_width = Columns;
#endif
}
-
curbuf = buf;
+ aco->new_curwin = curwin;
+ aco->new_curbuf = curbuf;
}
/*
aucmd_restbuf(aco)
aco_save_T *aco; /* structure holding saved values */
{
- if (aco->save_curwin != NULL)
+#ifdef FEAT_WINDOWS
+ int dummy;
+#endif
+
+ if (aco->new_curwin == aucmd_win)
+ {
+ --curbuf->b_nwindows;
+#ifdef FEAT_WINDOWS
+ /* Find "aucmd_win", it can't be closed, but it may be in another tab
+ * page. */
+ if (curwin != aucmd_win)
+ {
+ tabpage_T *tp;
+ win_T *wp;
+
+ FOR_ALL_TAB_WINDOWS(tp, wp)
+ {
+ if (wp == aucmd_win)
+ {
+ if (tp != curtab)
+ goto_tabpage_tp(tp);
+ win_goto(aucmd_win);
+ break;
+ }
+ }
+ }
+
+ /* Remove the window and frame from the tree of frames. */
+ (void)winframe_remove(curwin, &dummy, NULL);
+ win_remove(curwin, NULL);
+ last_status(FALSE); /* may need to remove last status line */
+ restore_snapshot(SNAP_AUCMD_IDX, FALSE);
+ (void)win_comp_pos(); /* recompute window positions */
+
+ if (win_valid(aco->save_curwin))
+ curwin = aco->save_curwin;
+ else
+ /* Hmm, original window disappeared. Just use the first one. */
+ curwin = firstwin;
+# ifdef FEAT_EVAL
+ vars_clear(&aucmd_win->w_vars.dv_hashtab); /* free all w: variables */
+# endif
+#else
+ curwin = aco->save_curwin;
+#endif
+ curbuf = curwin->w_buffer;
+
+ /* the buffer contents may have changed */
+ check_cursor();
+ if (curwin->w_topline > curbuf->b_ml.ml_line_count)
+ {
+ curwin->w_topline = curbuf->b_ml.ml_line_count;
+#ifdef FEAT_DIFF
+ curwin->w_topfill = 0;
+#endif
+ }
+#if defined(FEAT_GUI)
+ /* Hide the scrollbars from the aucmd_win and update. */
+ gui_mch_enable_scrollbar(&aucmd_win->w_scrollbars[SBAR_LEFT], FALSE);
+ gui_mch_enable_scrollbar(&aucmd_win->w_scrollbars[SBAR_RIGHT], FALSE);
+ gui_may_update_scrollbars();
+#endif
+ }
+ else
{
/* restore curwin */
#ifdef FEAT_WINDOWS
if (win_valid(aco->save_curwin))
#endif
{
- /* restore the buffer which was previously edited by curwin, if
- * it's still the same window and it's valid */
+ /* Restore the buffer which was previously edited by curwin, if
+ * it was chagned, we are still the same window and the buffer is
+ * valid. */
if (curwin == aco->new_curwin
- && buf_valid(aco->save_buf)
- && aco->save_buf->b_ml.ml_mfp != NULL)
+ && curbuf != aco->new_curbuf
+ && buf_valid(aco->new_curbuf)
+ && aco->new_curbuf->b_ml.ml_mfp != NULL)
{
--curbuf->b_nwindows;
- curbuf = aco->save_buf;
+ curbuf = aco->new_curbuf;
curwin->w_buffer = curbuf;
++curbuf->b_nwindows;
}
curbuf = curwin->w_buffer;
}
}
- else
- {
- /* restore buffer for curwin if it still exists and is loaded */
- if (buf_valid(aco->save_buf) && aco->save_buf->b_ml.ml_mfp != NULL)
- {
- --curbuf->b_nwindows;
- curbuf = aco->save_buf;
- curwin->w_buffer = curbuf;
- ++curbuf->b_nwindows;
- curwin->w_cursor = aco->save_cursor;
- check_cursor();
- /* check topline < line_count, in case lines got deleted */
- if (aco->save_topline <= curbuf->b_ml.ml_line_count)
- {
- curwin->w_topline = aco->save_topline;
-#ifdef FEAT_DIFF
- curwin->w_topfill = aco->save_topfill;
-#endif
- }
- else
- {
- curwin->w_topline = curbuf->b_ml.ml_line_count;
-#ifdef FEAT_DIFF
- curwin->w_topfill = 0;
-#endif
- }
- }
- }
}
static int autocmd_nested = FALSE;
aco_save_T *aco; /* structure to save values in */
buf_T *buf; /* new curbuf */
{
- aco->save_buf = curbuf;
+ aco->save_curbuf = curbuf;
+ --curbuf->b_nwindows;
curbuf = buf;
curwin->w_buffer = buf;
+ ++curbuf->b_nwindows;
}
/*
aucmd_restbuf(aco)
aco_save_T *aco; /* structure holding saved values */
{
- curbuf = aco->save_buf;
+ --curbuf->b_nwindows;
+ curbuf = aco->save_curbuf;
curwin->w_buffer = curbuf;
+ ++curbuf->b_nwindows;
}
#endif /* FEAT_AUTOCMD */
static int path_is_url __ARGS((char_u *p));
#if defined(FEAT_WINDOWS) || defined(PROTO)
-static int win_split_ins __ARGS((int size, int flags, win_T *newwin, int dir));
static void win_init __ARGS((win_T *newp, win_T *oldp, int flags));
+static void win_init_some __ARGS((win_T *newp, win_T *oldp));
static void frame_comp_pos __ARGS((frame_T *topfrp, int *row, int *col));
static void frame_setheight __ARGS((frame_T *curfrp, int height));
#ifdef FEAT_VERTSPLIT
static void win_totop __ARGS((int size, int flags));
static void win_equal_rec __ARGS((win_T *next_curwin, int current, frame_T *topfr, int dir, int col, int row, int width, int height));
static int last_window __ARGS((void));
+static int one_window __ARGS((void));
static win_T *win_free_mem __ARGS((win_T *win, int *dirp, tabpage_T *tp));
-static win_T *winframe_remove __ARGS((win_T *win, int *dirp, tabpage_T *tp));
static frame_T *win_altframe __ARGS((win_T *win, tabpage_T *tp));
static tabpage_T *alt_tabpage __ARGS((void));
static win_T *frame2win __ARGS((frame_T *frp));
#endif
#endif
static int win_alloc_firstwin __ARGS((win_T *oldwin));
+static void new_frame __ARGS((win_T *wp));
#if defined(FEAT_WINDOWS) || defined(PROTO)
static tabpage_T *alloc_tabpage __ARGS((void));
static int leave_tabpage __ARGS((buf_T *new_curbuf));
static int frame_minheight __ARGS((frame_T *topfrp, win_T *next_curwin));
static void win_enter_ext __ARGS((win_T *wp, int undo_sync, int no_curwin));
static void win_free __ARGS((win_T *wp, tabpage_T *tp));
-static void win_append __ARGS((win_T *, win_T *));
-static void win_remove __ARGS((win_T *, tabpage_T *tp));
static void frame_append __ARGS((frame_T *after, frame_T *frp));
static void frame_insert __ARGS((frame_T *before, frame_T *frp));
static void frame_remove __ARGS((frame_T *frp));
static void frame_add_height __ARGS((frame_T *frp, int n));
static void last_status_rec __ARGS((frame_T *fr, int statusline));
-static void make_snapshot __ARGS((void));
static void make_snapshot_rec __ARGS((frame_T *fr, frame_T **frp));
-static void clear_snapshot __ARGS((tabpage_T *tp));
+static void clear_snapshot __ARGS((tabpage_T *tp, int idx));
static void clear_snapshot_rec __ARGS((frame_T *fr));
-static void restore_snapshot __ARGS((int close_curwin));
static int check_snapshot_rec __ARGS((frame_T *sn, frame_T *fr));
static win_T *restore_snapshot_rec __ARGS((frame_T *sn, frame_T *fr));
#endif /* FEAT_WINDOWS */
-static win_T *win_alloc __ARGS((win_T *after));
+static win_T *win_alloc __ARGS((win_T *after, int hidden));
static void win_new_height __ARGS((win_T *, int));
#define URL_SLASH 1 /* path_is_url() has found "://" */
/* cursor to previous window with wrap around */
case 'W':
CHECK_CMDWIN
- if (lastwin == firstwin && Prenum != 1) /* just one window */
+ if (firstwin == lastwin && Prenum != 1) /* just one window */
beep_flush();
else
{
/* move window to new tab page */
case 'T':
- if (firstwin == lastwin)
+ if (one_window())
MSG(_(m_onlyone));
else
{
/* When creating the help window make a snapshot of the window layout.
* Otherwise clear the snapshot, it's now invalid. */
if (flags & WSP_HELP)
- make_snapshot();
+ make_snapshot(SNAP_HELP_IDX);
else
- clear_snapshot(curtab);
+ clear_snapshot(curtab, SNAP_HELP_IDX);
return win_split_ins(size, flags, NULL, 0);
}
* top/left/right/bottom.
* return FAIL for failure, OK otherwise
*/
- static int
+ int
win_split_ins(size, flags, newwin, dir)
int size;
int flags;
{
/* new window below/right of current one */
if (newwin == NULL)
- wp = win_alloc(oldwin);
+ wp = win_alloc(oldwin, FALSE);
else
win_append(oldwin, wp);
}
else
{
if (newwin == NULL)
- wp = win_alloc(oldwin->w_prev);
+ wp = win_alloc(oldwin->w_prev, FALSE);
else
win_append(oldwin->w_prev, wp);
}
if (wp == NULL)
return FAIL;
+ new_frame(wp);
+ if (wp->w_frame == NULL)
+ {
+ win_free(wp, NULL);
+ return FAIL;
+ }
+
/* make the contents of the new window the same as the current one */
win_init(wp, curwin, flags);
}
}
if (newwin == NULL)
- {
- /* Create a frame for the new window. */
- frp = (frame_T *)alloc_clear((unsigned)sizeof(frame_T));
- frp->fr_layout = FR_LEAF;
- frp->fr_win = wp;
- wp->w_frame = frp;
- }
+ frp = wp->w_frame;
else
frp = newwin->w_frame;
frp->fr_parent = curfrp->fr_parent;
return OK;
}
+
/*
* Initialize window "newp" from window "oldp".
* Used when splitting a window and when creating a new tab page.
if (oldp->w_localdir != NULL)
newp->w_localdir = vim_strsave(oldp->w_localdir);
- /* Use the same argument list. */
- newp->w_alist = oldp->w_alist;
- ++newp->w_alist->al_refcount;
- newp->w_arg_idx = oldp->w_arg_idx;
-
- /*
- * copy tagstack and options from existing window
- */
+ /* copy tagstack and folds */
for (i = 0; i < oldp->w_tagstacklen; i++)
{
newp->w_tagstack[i] = oldp->w_tagstack[i];
}
newp->w_tagstackidx = oldp->w_tagstackidx;
newp->w_tagstacklen = oldp->w_tagstacklen;
- win_copy_options(oldp, newp);
# ifdef FEAT_FOLDING
copyFoldingState(oldp, newp);
# endif
+
+ win_init_some(newp, oldp);
+}
+
+/*
+ * Initialize window "newp" from window"old".
+ * Only the essential things are copied.
+ */
+ static void
+win_init_some(newp, oldp)
+ win_T *newp;
+ win_T *oldp;
+{
+ /* Use the same argument list. */
+ newp->w_alist = oldp->w_alist;
+ ++newp->w_alist->al_refcount;
+ newp->w_arg_idx = oldp->w_arg_idx;
+
+ /* copy options from existing window */
+ win_copy_options(oldp, newp);
}
#endif /* FEAT_WINDOWS */
#if defined(FEAT_GUI) && defined(FEAT_VERTSPLIT)
/* When 'guioptions' includes 'L' or 'R' may have to remove or add
* scrollbars. Have to update them anyway. */
- if (gui.in_use)
- {
- out_flush();
- gui_init_which_components(NULL);
- gui_update_scrollbars(TRUE);
- }
- need_mouse_correct = TRUE;
+ gui_may_update_scrollbars();
#endif
-
}
/*
}
/*
- * Return TRUE if the current window is the only window that exists.
+ * Return TRUE if the current window is the only window that exists (ignoring
+ * "aucmd_win").
* Returns FALSE if there is a window, possibly in another tab page.
*/
static int
last_window()
{
- return (lastwin == firstwin && first_tabpage->tp_next == NULL);
+ return (one_window() && first_tabpage->tp_next == NULL);
+}
+
+/*
+ * Return TRUE if there is only one window other than "aucmd_win" in the
+ * current tab page.
+ */
+ static int
+one_window()
+{
+#ifdef FEAT_AUTOCMD
+ win_T *wp;
+ int seen_one = FALSE;
+
+ FOR_ALL_WINDOWS(wp)
+ {
+ if (wp != aucmd_win)
+ {
+ if (seen_one)
+ return FALSE;
+ seen_one = TRUE;
+ }
+ }
+ return TRUE;
+#else
+ return firstwin == lastwin;
+#endif
}
/*
return;
}
+#ifdef FEAT_AUTOCMD
+ if (win == aucmd_win)
+ {
+ EMSG(_("E813: Cannot close autocmd window"));
+ return;
+ }
+ if ((firstwin == aucmd_win || lastwin == aucmd_win) && one_window())
+ {
+ EMSG(_("E814: Cannot close window, only autocmd window would remain"));
+ return;
+ }
+#endif
+
/*
* When closing the last window in a tab page first go to another tab
* page and then close the window and the tab page. This avoids that
if (win->w_buffer->b_help)
help_window = TRUE;
else
- clear_snapshot(curtab);
+ clear_snapshot(curtab, SNAP_HELP_IDX);
#ifdef FEAT_AUTOCMD
if (win == curwin)
/* After closing the help window, try restoring the window layout from
* before it was opened. */
if (help_window)
- restore_snapshot(close_curwin);
+ restore_snapshot(SNAP_HELP_IDX, close_curwin);
#if defined(FEAT_GUI) && defined(FEAT_VERTSPLIT)
/* When 'guioptions' includes 'L' or 'R' may have to remove scrollbars. */
while (firstwin != NULL)
(void)win_free_mem(firstwin, &dummy, NULL);
+
+# ifdef FEAT_AUTOCMD
+ if (aucmd_win != NULL)
+ {
+ (void)win_free_mem(aucmd_win, &dummy, NULL);
+ aucmd_win = NULL;
+ }
+# endif
}
#endif
* Remove a window and its frame from the tree of frames.
* Returns a pointer to the window that got the freed up space.
*/
- static win_T *
+ win_T *
winframe_remove(win, dirp, tp)
win_T *win;
int *dirp UNUSED; /* set to 'v' or 'h' for direction if 'ea' */
win_T *nextwp;
int r;
- if (lastwin == firstwin)
+ if (one_window())
{
if (message
#ifdef FEAT_AUTOCMD
first_tabpage->tp_topframe = topframe;
curtab = first_tabpage;
#endif
+
return OK;
}
+#if defined(FEAT_AUTOCMD) || defined(PROTO)
+/*
+ * Init "aucmd_win". This can only be done after the first
+ * window is fully initialized, thus it can't be in win_alloc_first().
+ */
+ void
+win_alloc_aucmd_win()
+{
+ aucmd_win = win_alloc(NULL, TRUE);
+ if (aucmd_win != NULL)
+ {
+ win_init_some(aucmd_win, curwin);
+# ifdef FEAT_SCROLLBIND
+ aucmd_win->w_p_scb = FALSE;
+# endif
+ new_frame(aucmd_win);
+ }
+}
+#endif
+
/*
* Allocate the first window or the first window in a new tab page.
* When "oldwin" is NULL create an empty buffer for it.
win_alloc_firstwin(oldwin)
win_T *oldwin;
{
- curwin = win_alloc(NULL);
+ curwin = win_alloc(NULL, FALSE);
if (oldwin == NULL)
{
/* Very first window, need to create an empty buffer for it and
}
#endif
- topframe = (frame_T *)alloc_clear((unsigned)sizeof(frame_T));
- if (topframe == NULL)
+ new_frame(curwin);
+ if (curwin->w_frame == NULL)
return FAIL;
- topframe->fr_layout = FR_LEAF;
+ topframe = curwin->w_frame;
#ifdef FEAT_VERTSPLIT
topframe->fr_width = Columns;
#endif
topframe->fr_height = Rows - p_ch;
topframe->fr_win = curwin;
- curwin->w_frame = topframe;
return OK;
}
+/*
+ * Create a frame for window "wp".
+ */
+ static void
+new_frame(win_T *wp)
+{
+ frame_T *frp = (frame_T *)alloc_clear((unsigned)sizeof(frame_T));
+
+ wp->w_frame = frp;
+ if (frp != NULL)
+ {
+ frp->fr_layout = FR_LEAF;
+ frp->fr_win = wp;
+ }
+}
+
/*
* Initialize the window and frame size to the maximum.
*/
free_tabpage(tp)
tabpage_T *tp;
{
+ int idx;
+
# ifdef FEAT_DIFF
diff_clear(tp);
# endif
- clear_snapshot(tp);
+ for (idx = 0; idx < SNAP_COUNT; ++idx)
+ clear_snapshot(tp, idx);
#ifdef FEAT_EVAL
vars_clear(&tp->tp_vars.dv_hashtab); /* free all t: variables */
#endif
#if defined(FEAT_GUI)
/* When 'guioptions' includes 'L' or 'R' may have to remove or add
* scrollbars. Have to update them anyway. */
- if (gui.in_use && starting == 0)
- {
- gui_init_which_components(NULL);
- gui_update_scrollbars(TRUE);
- }
- need_mouse_correct = TRUE;
+ gui_may_update_scrollbars();
#endif
redraw_all_later(CLEAR);
#if defined(FEAT_GUI)
/* When 'guioptions' includes 'L' or 'R' may have to remove or add
* scrollbars. Have to update them anyway. */
- if (gui.in_use && starting == 0)
- {
- gui_init_which_components(NULL);
- gui_update_scrollbars(TRUE);
- }
- need_mouse_correct = TRUE;
+ gui_may_update_scrollbars();
#endif
redraw_all_later(CLEAR);
#endif
/*
- * allocate a window structure and link it in the window list
+ * Allocate a window structure and link it in the window list when "hidden" is
+ * FALSE.
*/
static win_T *
-win_alloc(after)
+win_alloc(after, hidden)
win_T *after UNUSED;
+ int hidden UNUSED;
{
win_T *newwin;
* link the window in the window list
*/
#ifdef FEAT_WINDOWS
- win_append(after, newwin);
+ if (!hidden)
+ win_append(after, newwin);
#endif
#ifdef FEAT_VERTSPLIT
newwin->w_wincol = 0;
/*
* Append window "wp" in the window list after window "after".
*/
- static void
+ void
win_append(after, wp)
win_T *after, *wp;
{
/*
* Remove a window from the window list.
*/
- static void
+ void
win_remove(wp, tp)
win_T *wp;
tabpage_T *tp; /* tab page "win" is in, NULL for current */
/*
* Return TRUE if there is only one window (in the current tab page), not
* counting a help or preview window, unless it is the current window.
+ * Does not count "aucmd_win".
*/
int
only_one_window()
return FALSE;
for (wp = firstwin; wp != NULL; wp = wp->w_next)
- if (!((wp->w_buffer->b_help && !curbuf->b_help)
+ if ((!((wp->w_buffer->b_help && !curbuf->b_help)
# ifdef FEAT_QUICKFIX
|| wp->w_p_pvw
# endif
) || wp == curwin)
+# ifdef FEAT_AUTOCMD
+ && wp != aucmd_win
+# endif
+ )
++count;
return (count <= 1);
#else
/*
* Create a snapshot of the current frame sizes.
*/
- static void
-make_snapshot()
+ void
+make_snapshot(idx)
+ int idx;
{
- clear_snapshot(curtab);
- make_snapshot_rec(topframe, &curtab->tp_snapshot);
+ clear_snapshot(curtab, idx);
+ make_snapshot_rec(topframe, &curtab->tp_snapshot[idx]);
}
static void
* Remove any existing snapshot.
*/
static void
-clear_snapshot(tp)
+clear_snapshot(tp, idx)
tabpage_T *tp;
+ int idx;
{
- clear_snapshot_rec(tp->tp_snapshot);
- tp->tp_snapshot = NULL;
+ clear_snapshot_rec(tp->tp_snapshot[idx]);
+ tp->tp_snapshot[idx] = NULL;
}
static void
* This is only done if the screen size didn't change and the window layout is
* still the same.
*/
- static void
-restore_snapshot(close_curwin)
+ void
+restore_snapshot(idx, close_curwin)
+ int idx;
int close_curwin; /* closing current window */
{
win_T *wp;
- if (curtab->tp_snapshot != NULL
+ if (curtab->tp_snapshot[idx] != NULL
# ifdef FEAT_VERTSPLIT
- && curtab->tp_snapshot->fr_width == topframe->fr_width
+ && curtab->tp_snapshot[idx]->fr_width == topframe->fr_width
# endif
- && curtab->tp_snapshot->fr_height == topframe->fr_height
- && check_snapshot_rec(curtab->tp_snapshot, topframe) == OK)
+ && curtab->tp_snapshot[idx]->fr_height == topframe->fr_height
+ && check_snapshot_rec(curtab->tp_snapshot[idx], topframe) == OK)
{
- wp = restore_snapshot_rec(curtab->tp_snapshot, topframe);
+ wp = restore_snapshot_rec(curtab->tp_snapshot[idx], topframe);
win_comp_pos();
if (wp != NULL && close_curwin)
win_goto(wp);
redraw_all_later(CLEAR);
}
- clear_snapshot(curtab);
+ clear_snapshot(curtab, idx);
}
/*
projects / vim / commitdiff