Adding upstream version 2:9.0.1378.upstream/2%9.0.1378upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 3352 insertions, 0 deletions

diff --git a/src/drawscreen.c b/src/drawscreen.c
new file mode 100644
index 0000000..13892bb
--- /dev/null
+++ b/src/drawscreen.c
@@ -0,0 +1,3352 @@
+/* vi:set ts=8 sts=4 sw=4 noet:
+ *
+ * VIM - Vi IMproved	by Bram Moolenaar
+ *
+ * Do ":help uganda"  in Vim to read copying and usage conditions.
+ * Do ":help credits" in Vim to see a list of people who contributed.
+ * See README.txt for an overview of the Vim source code.
+ */
+
+/*
+ * drawscreen.c: Code for updating all the windows on the screen.
+ * This is the top level, drawline.c is the middle and screen.c the lower
+ * level.
+ *
+ * update_screen() is the function that updates all windows and status lines.
+ * It is called form the main loop when must_redraw is non-zero.  It may be
+ * called from other places when an immediate screen update is needed.
+ *
+ * The part of the buffer that is displayed in a window is set with:
+ * - w_topline (first buffer line in window)
+ * - w_topfill (filler lines above the first line)
+ * - w_leftcol (leftmost window cell in window),
+ * - w_skipcol (skipped window cells of first line)
+ *
+ * Commands that only move the cursor around in a window, do not need to take
+ * action to update the display.  The main loop will check if w_topline is
+ * valid and update it (scroll the window) when needed.
+ *
+ * Commands that scroll a window change w_topline and must call
+ * check_cursor() to move the cursor into the visible part of the window, and
+ * call redraw_later(UPD_VALID) to have the window displayed by update_screen()
+ * later.
+ *
+ * Commands that change text in the buffer must call changed_bytes() or
+ * changed_lines() to mark the area that changed and will require updating
+ * later.  The main loop will call update_screen(), which will update each
+ * window that shows the changed buffer.  This assumes text above the change
+ * can remain displayed as it is.  Text after the change may need updating for
+ * scrolling, folding and syntax highlighting.
+ *
+ * Commands that change how a window is displayed (e.g., setting 'list') or
+ * invalidate the contents of a window in another way (e.g., change fold
+ * settings), must call redraw_later(UPD_NOT_VALID) to have the whole window
+ * redisplayed by update_screen() later.
+ *
+ * Commands that change how a buffer is displayed (e.g., setting 'tabstop')
+ * must call redraw_curbuf_later(UPD_NOT_VALID) to have all the windows for the
+ * buffer redisplayed by update_screen() later.
+ *
+ * Commands that change highlighting and possibly cause a scroll too must call
+ * redraw_later(UPD_SOME_VALID) to update the whole window but still use
+ * scrolling to avoid redrawing everything.  But the length of displayed lines
+ * must not change, use UPD_NOT_VALID then.
+ *
+ * Commands that move the window position must call redraw_later(UPD_NOT_VALID).
+ * TODO: should minimize redrawing by scrolling when possible.
+ *
+ * Commands that change everything (e.g., resizing the screen) must call
+ * redraw_all_later(UPD_NOT_VALID) or redraw_all_later(UPD_CLEAR).
+ *
+ * Things that are handled indirectly:
+ * - When messages scroll the screen up, msg_scrolled will be set and
+ *   update_screen() called to redraw.
+ */
+
+#include "vim.h"
+
+static void win_update(win_T *wp);
+#ifdef FEAT_STL_OPT
+static void redraw_custom_statusline(win_T *wp);
+#endif
+#if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD)
+static int  did_update_one_window;
+#endif
+
+/*
+ * Based on the current value of curwin->w_topline, transfer a screenfull
+ * of stuff from Filemem to ScreenLines[], and update curwin->w_botline.
+ * Return OK when the screen was updated, FAIL if it was not done.
+ */
+    int
+update_screen(int type_arg)
+{
+    int		type = type_arg;
+    win_T	*wp;
+    static int	did_intro = FALSE;
+#ifdef FEAT_GUI
+    int		did_one = FALSE;
+    int		did_undraw = FALSE;
+    int		gui_cursor_col = 0;
+    int		gui_cursor_row = 0;
+#endif
+    int		no_update = FALSE;
+    int		save_pum_will_redraw = pum_will_redraw;
+
+    // Don't do anything if the screen structures are (not yet) valid.
+    if (!screen_valid(TRUE))
+	return FAIL;
+
+    if (type == UPD_VALID_NO_UPDATE)
+    {
+	no_update = TRUE;
+	type = 0;
+    }
+
+#ifdef FEAT_EVAL
+    {
+	buf_T *buf;
+
+	// Before updating the screen, notify any listeners of changed text.
+	FOR_ALL_BUFFERS(buf)
+	    invoke_listeners(buf);
+    }
+#endif
+
+#ifdef FEAT_DIFF
+    // May have postponed updating diffs.
+    if (need_diff_redraw)
+	diff_redraw(TRUE);
+#endif
+
+    if (must_redraw)
+    {
+	if (type < must_redraw)	    // use maximal type
+	    type = must_redraw;
+
+	// must_redraw is reset here, so that when we run into some weird
+	// reason to redraw while busy redrawing (e.g., asynchronous
+	// scrolling), or update_topline() in win_update() will cause a
+	// scroll, the screen will be redrawn later or in win_update().
+	must_redraw = 0;
+    }
+
+    // May need to update w_lines[].
+    if (curwin->w_lines_valid == 0 && type < UPD_NOT_VALID
+#ifdef FEAT_TERMINAL
+	    && !term_do_update_window(curwin)
+#endif
+		)
+	type = UPD_NOT_VALID;
+
+    // Postpone the redrawing when it's not needed and when being called
+    // recursively.
+    if (!redrawing() || updating_screen)
+    {
+	redraw_later(type);		// remember type for next time
+	must_redraw = type;
+	if (type > UPD_INVERTED_ALL)
+	    curwin->w_lines_valid = 0;	// don't use w_lines[].wl_size now
+	return FAIL;
+    }
+    updating_screen = TRUE;
+
+#ifdef FEAT_PROP_POPUP
+    // Update popup_mask if needed.  This may set w_redraw_top and w_redraw_bot
+    // in some windows.
+    may_update_popup_mask(type);
+#endif
+
+#ifdef FEAT_SYN_HL
+    ++display_tick;	    // let syntax code know we're in a next round of
+			    // display updating
+#endif
+    if (no_update)
+	++no_win_do_lines_ins;
+
+    // if the screen was scrolled up when displaying a message, scroll it down
+    if (msg_scrolled)
+    {
+	clear_cmdline = TRUE;
+	if (type != UPD_CLEAR)
+	{
+	    if (msg_scrolled > Rows - 5)	    // redrawing is faster
+	    {
+		type = UPD_NOT_VALID;
+		redraw_as_cleared();
+	    }
+	    else
+	    {
+		check_for_delay(FALSE);
+		if (screen_ins_lines(0, 0, msg_scrolled, (int)Rows, 0, NULL)
+								       == FAIL)
+		{
+		    type = UPD_NOT_VALID;
+		    redraw_as_cleared();
+		}
+		FOR_ALL_WINDOWS(wp)
+		{
+		    if (wp->w_winrow < msg_scrolled)
+		    {
+			if (W_WINROW(wp) + wp->w_height > msg_scrolled
+				&& wp->w_redr_type < UPD_REDRAW_TOP
+				&& wp->w_lines_valid > 0
+				&& wp->w_topline == wp->w_lines[0].wl_lnum)
+			{
+			    wp->w_upd_rows = msg_scrolled - W_WINROW(wp);
+			    wp->w_redr_type = UPD_REDRAW_TOP;
+			}
+			else
+			{
+			    wp->w_redr_type = UPD_NOT_VALID;
+			    if (W_WINROW(wp) + wp->w_height
+					 + wp->w_status_height <= msg_scrolled)
+				wp->w_redr_status = TRUE;
+			}
+		    }
+		}
+		if (!no_update)
+		    redraw_cmdline = TRUE;
+		redraw_tabline = TRUE;
+	    }
+	}
+	msg_scrolled = 0;
+	need_wait_return = FALSE;
+    }
+
+    // reset cmdline_row now (may have been changed temporarily)
+    compute_cmdrow();
+
+    // Check for changed highlighting
+    if (need_highlight_changed)
+	highlight_changed();
+
+    if (type == UPD_CLEAR)		// first clear screen
+    {
+	screenclear();		// will reset clear_cmdline
+	type = UPD_NOT_VALID;
+	// must_redraw may be set indirectly, avoid another redraw later
+	must_redraw = 0;
+    }
+
+    if (clear_cmdline)		// going to clear cmdline (done below)
+	check_for_delay(FALSE);
+
+#ifdef FEAT_LINEBREAK
+    // Force redraw when width of 'number' or 'relativenumber' column
+    // changes.
+    if (curwin->w_redr_type < UPD_NOT_VALID
+	   && curwin->w_nrwidth != ((curwin->w_p_nu || curwin->w_p_rnu)
+				    ? number_width(curwin) : 0))
+	curwin->w_redr_type = UPD_NOT_VALID;
+#endif
+
+    // Only start redrawing if there is really something to do.
+    if (type == UPD_INVERTED)
+	update_curswant();
+    if (curwin->w_redr_type < type
+	    && !((type == UPD_VALID
+		    && curwin->w_lines[0].wl_valid
+#ifdef FEAT_DIFF
+		    && curwin->w_topfill == curwin->w_old_topfill
+		    && curwin->w_botfill == curwin->w_old_botfill
+#endif
+		    && curwin->w_topline == curwin->w_lines[0].wl_lnum)
+		|| (type == UPD_INVERTED
+		    && VIsual_active
+		    && curwin->w_old_cursor_lnum == curwin->w_cursor.lnum
+		    && curwin->w_old_visual_mode == VIsual_mode
+		    && (curwin->w_valid & VALID_VIRTCOL)
+		    && curwin->w_old_curswant == curwin->w_curswant)
+		))
+	curwin->w_redr_type = type;
+
+    // Redraw the tab pages line if needed.
+    if (redraw_tabline || type >= UPD_NOT_VALID)
+	draw_tabline();
+
+#ifdef FEAT_SYN_HL
+    // Correct stored syntax highlighting info for changes in each displayed
+    // buffer.  Each buffer must only be done once.
+    FOR_ALL_WINDOWS(wp)
+    {
+	if (wp->w_buffer->b_mod_set)
+	{
+	    win_T	*wwp;
+
+	    // Check if we already did this buffer.
+	    for (wwp = firstwin; wwp != wp; wwp = wwp->w_next)
+		if (wwp->w_buffer == wp->w_buffer)
+		    break;
+	    if (wwp == wp && syntax_present(wp))
+		syn_stack_apply_changes(wp->w_buffer);
+	}
+    }
+#endif
+
+    if (pum_redraw_in_same_position())
+	// Avoid flicker if the popup menu is going to be redrawn in the same
+	// position.
+	pum_will_redraw = TRUE;
+
+    // Go from top to bottom through the windows, redrawing the ones that need
+    // it.
+#if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD)
+    did_update_one_window = FALSE;
+#endif
+#ifdef FEAT_SEARCH_EXTRA
+    screen_search_hl.rm.regprog = NULL;
+#endif
+    FOR_ALL_WINDOWS(wp)
+    {
+	if (wp->w_redr_type != 0)
+	{
+	    cursor_off();
+#ifdef FEAT_GUI
+	    if (!did_one)
+	    {
+		did_one = TRUE;
+
+		// Remove the cursor before starting to do anything, because
+		// scrolling may make it difficult to redraw the text under
+		// it.
+		// Also remove the cursor if it needs to be hidden due to an
+		// ongoing cursor-less sleep.
+		if (gui.in_use && (wp == curwin || cursor_is_sleeping()))
+		{
+		    gui_cursor_col = gui.cursor_col;
+		    gui_cursor_row = gui.cursor_row;
+		    gui_undraw_cursor();
+		    did_undraw = TRUE;
+		}
+	    }
+#endif
+	    win_update(wp);
+	}
+
+	// redraw status line after the window to minimize cursor movement
+	if (wp->w_redr_status)
+	{
+	    cursor_off();
+	    win_redr_status(wp, TRUE); // any popup menu will be redrawn below
+	}
+    }
+#if defined(FEAT_SEARCH_EXTRA)
+    end_search_hl();
+#endif
+
+    // May need to redraw the popup menu.
+    pum_will_redraw = save_pum_will_redraw;
+    pum_may_redraw();
+
+    // Reset b_mod_set flags.  Going through all windows is probably faster
+    // than going through all buffers (there could be many buffers).
+    FOR_ALL_WINDOWS(wp)
+	wp->w_buffer->b_mod_set = FALSE;
+
+#ifdef FEAT_PROP_POPUP
+    // Display popup windows on top of the windows and command line.
+    update_popups(win_update);
+#endif
+
+#ifdef FEAT_TERMINAL
+    FOR_ALL_WINDOWS(wp)
+	// If this window contains a terminal, after redrawing all windows, the
+	// dirty row range can be reset.
+	term_did_update_window(wp);
+#endif
+
+    after_updating_screen(TRUE);
+
+    // Clear or redraw the command line.  Done last, because scrolling may
+    // mess up the command line.
+    if (clear_cmdline || redraw_cmdline || redraw_mode)
+	showmode();
+
+    if (no_update)
+	--no_win_do_lines_ins;
+
+    // May put up an introductory message when not editing a file
+    if (!did_intro)
+	maybe_intro_message();
+    did_intro = TRUE;
+
+#ifdef FEAT_GUI
+    // Redraw the cursor and update the scrollbars when all screen updating is
+    // done.
+    if (gui.in_use)
+    {
+	if (did_undraw && !gui_mch_is_blink_off())
+	{
+	    mch_disable_flush();
+	    out_flush();	// required before updating the cursor
+	    mch_enable_flush();
+
+	    // Put the GUI position where the cursor was, gui_update_cursor()
+	    // uses that.
+	    gui.col = gui_cursor_col;
+	    gui.row = gui_cursor_row;
+	    gui.col = mb_fix_col(gui.col, gui.row);
+	    gui_update_cursor(FALSE, FALSE);
+	    gui_may_flush();
+	    screen_cur_col = gui.col;
+	    screen_cur_row = gui.row;
+	}
+	else
+	    out_flush();
+	gui_update_scrollbars(FALSE);
+    }
+#endif
+    return OK;
+}
+
+/*
+ * Return the row for drawing the statusline and the ruler of window "wp".
+ */
+    int
+statusline_row(win_T *wp)
+{
+#if defined(FEAT_PROP_POPUP)
+    // If the window is really zero height the winbar isn't displayed.
+    if (wp->w_frame->fr_height == wp->w_status_height && !popup_is_popup(wp))
+	return wp->w_winrow;
+#endif
+    return W_WINROW(wp) + wp->w_height;
+}
+
+/*
+ * Redraw the status line of window wp.
+ *
+ * If inversion is possible we use it. Else '=' characters are used.
+ * If "ignore_pum" is TRUE, also redraw statusline when the popup menu is
+ * displayed.
+ */
+    void
+win_redr_status(win_T *wp, int ignore_pum UNUSED)
+{
+    int		row;
+    char_u	*p;
+    int		len;
+    int		fillchar;
+    int		attr;
+    int		this_ru_col;
+    static int  busy = FALSE;
+
+    // It's possible to get here recursively when 'statusline' (indirectly)
+    // invokes ":redrawstatus".  Simply ignore the call then.
+    if (busy)
+	return;
+    busy = TRUE;
+
+    row = statusline_row(wp);
+
+    wp->w_redr_status = FALSE;
+    if (wp->w_status_height == 0)
+    {
+	// no status line, can only be last window
+	redraw_cmdline = TRUE;
+    }
+    else if (!redrawing()
+	    // don't update status line when popup menu is visible and may be
+	    // drawn over it, unless it will be redrawn later
+	    || (!ignore_pum && pum_visible()))
+    {
+	// Don't redraw right now, do it later.
+	wp->w_redr_status = TRUE;
+    }
+#ifdef FEAT_STL_OPT
+    else if (*p_stl != NUL || *wp->w_p_stl != NUL)
+    {
+	// redraw custom status line
+	redraw_custom_statusline(wp);
+    }
+#endif
+    else
+    {
+	fillchar = fillchar_status(&attr, wp);
+
+	get_trans_bufname(wp->w_buffer);
+	p = NameBuff;
+	len = (int)STRLEN(p);
+
+	if ((bt_help(wp->w_buffer)
+#ifdef FEAT_QUICKFIX
+		    || wp->w_p_pvw
+#endif
+		    || bufIsChanged(wp->w_buffer)
+		    || wp->w_buffer->b_p_ro)
+		&& len < MAXPATHL - 1)
+	    *(p + len++) = ' ';
+	if (bt_help(wp->w_buffer))
+	{
+	    vim_snprintf((char *)p + len, MAXPATHL - len, "%s", _("[Help]"));
+	    len += (int)STRLEN(p + len);
+	}
+#ifdef FEAT_QUICKFIX
+	if (wp->w_p_pvw)
+	{
+	    vim_snprintf((char *)p + len, MAXPATHL - len, "%s", _("[Preview]"));
+	    len += (int)STRLEN(p + len);
+	}
+#endif
+	if (bufIsChanged(wp->w_buffer) && !bt_terminal(wp->w_buffer))
+	{
+	    vim_snprintf((char *)p + len, MAXPATHL - len, "%s", "[+]");
+	    len += (int)STRLEN(p + len);
+	}
+	if (wp->w_buffer->b_p_ro)
+	{
+	    vim_snprintf((char *)p + len, MAXPATHL - len, "%s", _("[RO]"));
+	    len += (int)STRLEN(p + len);
+	}
+
+	this_ru_col = ru_col - (Columns - wp->w_width);
+	if (this_ru_col < (wp->w_width + 1) / 2)
+	    this_ru_col = (wp->w_width + 1) / 2;
+	if (this_ru_col <= 1)
+	{
+	    p = (char_u *)"<";		// No room for file name!
+	    len = 1;
+	}
+	else if (has_mbyte)
+	{
+	    int	clen = 0, i;
+
+	    // Count total number of display cells.
+	    clen = mb_string2cells(p, -1);
+
+	    // Find first character that will fit.
+	    // Going from start to end is much faster for DBCS.
+	    for (i = 0; p[i] != NUL && clen >= this_ru_col - 1;
+		    i += (*mb_ptr2len)(p + i))
+		clen -= (*mb_ptr2cells)(p + i);
+	    len = clen;
+	    if (i > 0)
+	    {
+		p = p + i - 1;
+		*p = '<';
+		++len;
+	    }
+
+	}
+	else if (len > this_ru_col - 1)
+	{
+	    p += len - (this_ru_col - 1);
+	    *p = '<';
+	    len = this_ru_col - 1;
+	}
+
+	screen_puts(p, row, wp->w_wincol, attr);
+	screen_fill(row, row + 1, len + wp->w_wincol,
+			this_ru_col + wp->w_wincol, fillchar, fillchar, attr);
+
+	if (get_keymap_str(wp, (char_u *)"<%s>", NameBuff, MAXPATHL)
+		&& (this_ru_col - len) > (int)(STRLEN(NameBuff) + 1))
+	    screen_puts(NameBuff, row, (int)(this_ru_col - STRLEN(NameBuff)
+						   - 1 + wp->w_wincol), attr);
+
+	win_redr_ruler(wp, TRUE, ignore_pum);
+
+	// Draw the 'showcmd' information if 'showcmdloc' == "statusline".
+	if (p_sc && *p_sloc == 's')
+	{
+	    int	width = MIN(10, this_ru_col - len - 2);
+
+	    if (width > 0)
+		screen_puts_len(showcmd_buf, width, row,
+				wp->w_wincol + this_ru_col - width - 1, attr);
+	}
+    }
+
+    /*
+     * May need to draw the character below the vertical separator.
+     */
+    if (wp->w_vsep_width != 0 && wp->w_status_height != 0 && redrawing())
+    {
+	if (stl_connected(wp))
+	    fillchar = fillchar_status(&attr, wp);
+	else
+	    fillchar = fillchar_vsep(&attr, wp);
+	screen_putchar(fillchar, row, W_ENDCOL(wp), attr);
+    }
+    busy = FALSE;
+}
+
+#ifdef FEAT_STL_OPT
+/*
+ * Redraw the status line according to 'statusline' and take care of any
+ * errors encountered.
+ */
+    static void
+redraw_custom_statusline(win_T *wp)
+{
+    static int	    entered = FALSE;
+
+    // When called recursively return.  This can happen when the statusline
+    // contains an expression that triggers a redraw.
+    if (entered)
+	return;
+    entered = TRUE;
+
+    win_redr_custom(wp, FALSE);
+    entered = FALSE;
+}
+#endif
+
+/*
+ * Show current status info in ruler and various other places
+ * If always is FALSE, only show ruler if position has changed.
+ */
+    void
+showruler(int always)
+{
+    if (!always && !redrawing())
+	return;
+    if (pum_visible())
+    {
+	// Don't redraw right now, do it later.
+	curwin->w_redr_status = TRUE;
+	return;
+    }
+#if defined(FEAT_STL_OPT)
+    if ((*p_stl != NUL || *curwin->w_p_stl != NUL) && curwin->w_status_height)
+	redraw_custom_statusline(curwin);
+    else
+#endif
+	win_redr_ruler(curwin, always, FALSE);
+
+    if (need_maketitle
+#ifdef FEAT_STL_OPT
+	    || (p_icon && (stl_syntax & STL_IN_ICON))
+	    || (p_title && (stl_syntax & STL_IN_TITLE))
+#endif
+       )
+	maketitle();
+
+    // Redraw the tab pages line if needed.
+    if (redraw_tabline)
+	draw_tabline();
+}
+
+    void
+win_redr_ruler(win_T *wp, int always, int ignore_pum)
+{
+#define RULER_BUF_LEN 70
+    char_u	buffer[RULER_BUF_LEN];
+    int		row;
+    int		fillchar;
+    int		attr;
+    int		empty_line = FALSE;
+    colnr_T	virtcol;
+    int		i;
+    size_t	len;
+    int		o;
+    int		this_ru_col;
+    int		off = 0;
+    int		width;
+
+    // If 'ruler' off don't do anything
+    if (!p_ru)
+	return;
+
+    /*
+     * Check if cursor.lnum is valid, since win_redr_ruler() may be called
+     * after deleting lines, before cursor.lnum is corrected.
+     */
+    if (wp->w_cursor.lnum > wp->w_buffer->b_ml.ml_line_count)
+	return;
+
+    // Don't draw the ruler while doing insert-completion, it might overwrite
+    // the (long) mode message.
+    if (wp == lastwin && lastwin->w_status_height == 0)
+	if (edit_submode != NULL)
+	    return;
+    // Don't draw the ruler when the popup menu is visible, it may overlap.
+    // Except when the popup menu will be redrawn anyway.
+    if (!ignore_pum && pum_visible())
+	return;
+
+#ifdef FEAT_STL_OPT
+    if (*p_ruf)
+    {
+	win_redr_custom(wp, TRUE);
+	return;
+    }
+#endif
+
+    /*
+     * Check if not in Insert mode and the line is empty (will show "0-1").
+     */
+    if ((State & MODE_INSERT) == 0
+		&& *ml_get_buf(wp->w_buffer, wp->w_cursor.lnum, FALSE) == NUL)
+	empty_line = TRUE;
+
+    /*
+     * Only draw the ruler when something changed.
+     */
+    validate_virtcol_win(wp);
+    if (       redraw_cmdline
+	    || always
+	    || wp->w_cursor.lnum != wp->w_ru_cursor.lnum
+	    || wp->w_cursor.col != wp->w_ru_cursor.col
+	    || wp->w_virtcol != wp->w_ru_virtcol
+	    || wp->w_cursor.coladd != wp->w_ru_cursor.coladd
+	    || wp->w_topline != wp->w_ru_topline
+	    || wp->w_buffer->b_ml.ml_line_count != wp->w_ru_line_count
+#ifdef FEAT_DIFF
+	    || wp->w_topfill != wp->w_ru_topfill
+#endif
+	    || empty_line != wp->w_ru_empty)
+    {
+	cursor_off();
+	if (wp->w_status_height)
+	{
+	    row = statusline_row(wp);
+	    fillchar = fillchar_status(&attr, wp);
+	    off = wp->w_wincol;
+	    width = wp->w_width;
+	}
+	else
+	{
+	    row = Rows - 1;
+	    fillchar = ' ';
+	    attr = 0;
+	    width = Columns;
+	    off = 0;
+	}
+
+	// In list mode virtcol needs to be recomputed
+	virtcol = wp->w_virtcol;
+	if (wp->w_p_list && wp->w_lcs_chars.tab1 == NUL)
+	{
+	    wp->w_p_list = FALSE;
+	    getvvcol(wp, &wp->w_cursor, NULL, &virtcol, NULL);
+	    wp->w_p_list = TRUE;
+	}
+
+	/*
+	 * Some sprintfs return the length, some return a pointer.
+	 * To avoid portability problems we use strlen() here.
+	 */
+	vim_snprintf((char *)buffer, RULER_BUF_LEN, "%ld,",
+		(wp->w_buffer->b_ml.ml_flags & ML_EMPTY)
+		    ? 0L
+		    : (long)(wp->w_cursor.lnum));
+	len = STRLEN(buffer);
+	col_print(buffer + len, RULER_BUF_LEN - len,
+			empty_line ? 0 : (int)wp->w_cursor.col + 1,
+			(int)virtcol + 1);
+
+	/*
+	 * Add a "50%" if there is room for it.
+	 * On the last line, don't print in the last column (scrolls the
+	 * screen up on some terminals).
+	 */
+	i = (int)STRLEN(buffer);
+	get_rel_pos(wp, buffer + i + 1, RULER_BUF_LEN - i - 1);
+	o = i + vim_strsize(buffer + i + 1);
+	if (wp->w_status_height == 0)	// can't use last char of screen
+	    ++o;
+	this_ru_col = ru_col - (Columns - width);
+	if (this_ru_col < 0)
+	    this_ru_col = 0;
+	// Never use more than half the window/screen width, leave the other
+	// half for the filename.
+	if (this_ru_col < (width + 1) / 2)
+	    this_ru_col = (width + 1) / 2;
+	if (this_ru_col + o < width)
+	{
+	    // need at least 3 chars left for get_rel_pos() + NUL
+	    while (this_ru_col + o < width && RULER_BUF_LEN > i + 4)
+	    {
+		if (has_mbyte)
+		    i += (*mb_char2bytes)(fillchar, buffer + i);
+		else
+		    buffer[i++] = fillchar;
+		++o;
+	    }
+	    get_rel_pos(wp, buffer + i, RULER_BUF_LEN - i);
+	}
+	// Truncate at window boundary.
+	if (has_mbyte)
+	{
+	    o = 0;
+	    for (i = 0; buffer[i] != NUL; i += (*mb_ptr2len)(buffer + i))
+	    {
+		o += (*mb_ptr2cells)(buffer + i);
+		if (this_ru_col + o > width)
+		{
+		    buffer[i] = NUL;
+		    break;
+		}
+	    }
+	}
+	else if (this_ru_col + (int)STRLEN(buffer) > width)
+	    buffer[width - this_ru_col] = NUL;
+
+	screen_puts(buffer, row, this_ru_col + off, attr);
+	i = redraw_cmdline;
+	screen_fill(row, row + 1,
+		this_ru_col + off + (int)STRLEN(buffer),
+		(off + width),
+		fillchar, fillchar, attr);
+	// don't redraw the cmdline because of showing the ruler
+	redraw_cmdline = i;
+	wp->w_ru_cursor = wp->w_cursor;
+	wp->w_ru_virtcol = wp->w_virtcol;
+	wp->w_ru_empty = empty_line;
+	wp->w_ru_topline = wp->w_topline;
+	wp->w_ru_line_count = wp->w_buffer->b_ml.ml_line_count;
+#ifdef FEAT_DIFF
+	wp->w_ru_topfill = wp->w_topfill;
+#endif
+    }
+}
+
+/*
+ * To be called when "updating_screen" was set before and now the postponed
+ * side effects may take place.
+ */
+    void
+after_updating_screen(int may_resize_shell UNUSED)
+{
+    updating_screen = FALSE;
+#ifdef FEAT_GUI
+    if (may_resize_shell)
+	gui_may_resize_shell();
+#endif
+#ifdef FEAT_TERMINAL
+    term_check_channel_closed_recently();
+#endif
+
+#ifdef HAVE_DROP_FILE
+    // If handle_drop() was called while updating_screen was TRUE need to
+    // handle the drop now.
+    handle_any_postponed_drop();
+#endif
+}
+
+/*
+ * Update all windows that are editing the current buffer.
+ */
+    void
+update_curbuf(int type)
+{
+    redraw_curbuf_later(type);
+    update_screen(type);
+}
+
+#if defined(FEAT_MENU) || defined(FEAT_FOLDING)
+/*
+ * Copy "text" to ScreenLines using "attr".
+ * Returns the next screen column.
+ */
+    static int
+text_to_screenline(win_T *wp, char_u *text, int col)
+{
+    int		off = (int)(current_ScreenLine - ScreenLines);
+
+    if (has_mbyte)
+    {
+	int	cells;
+	int	u8c, u8cc[MAX_MCO];
+	int	i;
+	int	idx;
+	int	c_len;
+	char_u	*p;
+# ifdef FEAT_ARABIC
+	int	prev_c = 0;		// previous Arabic character
+	int	prev_c1 = 0;		// first composing char for prev_c
+# endif
+
+# ifdef FEAT_RIGHTLEFT
+	if (wp->w_p_rl)
+	    idx = off;
+	else
+# endif
+	    idx = off + col;
+
+	// Store multibyte characters in ScreenLines[] et al. correctly.
+	for (p = text; *p != NUL; )
+	{
+	    cells = (*mb_ptr2cells)(p);
+	    c_len = (*mb_ptr2len)(p);
+	    if (col + cells > wp->w_width
+# ifdef FEAT_RIGHTLEFT
+		    - (wp->w_p_rl ? col : 0)
+# endif
+		    )
+		break;
+	    ScreenLines[idx] = *p;
+	    if (enc_utf8)
+	    {
+		u8c = utfc_ptr2char(p, u8cc);
+		if (*p < 0x80 && u8cc[0] == 0)
+		{
+		    ScreenLinesUC[idx] = 0;
+#ifdef FEAT_ARABIC
+		    prev_c = u8c;
+#endif
+		}
+		else
+		{
+#ifdef FEAT_ARABIC
+		    if (p_arshape && !p_tbidi && ARABIC_CHAR(u8c))
+		    {
+			// Do Arabic shaping.
+			int	pc, pc1, nc;
+			int	pcc[MAX_MCO];
+			int	firstbyte = *p;
+
+			// The idea of what is the previous and next
+			// character depends on 'rightleft'.
+			if (wp->w_p_rl)
+			{
+			    pc = prev_c;
+			    pc1 = prev_c1;
+			    nc = utf_ptr2char(p + c_len);
+			    prev_c1 = u8cc[0];
+			}
+			else
+			{
+			    pc = utfc_ptr2char(p + c_len, pcc);
+			    nc = prev_c;
+			    pc1 = pcc[0];
+			}
+			prev_c = u8c;
+
+			u8c = arabic_shape(u8c, &firstbyte, &u8cc[0],
+								 pc, pc1, nc);
+			ScreenLines[idx] = firstbyte;
+		    }
+		    else
+			prev_c = u8c;
+#endif
+		    // Non-BMP character: display as ? or fullwidth ?.
+		    ScreenLinesUC[idx] = u8c;
+		    for (i = 0; i < Screen_mco; ++i)
+		    {
+			ScreenLinesC[i][idx] = u8cc[i];
+			if (u8cc[i] == 0)
+			    break;
+		    }
+		}
+		if (cells > 1)
+		    ScreenLines[idx + 1] = 0;
+	    }
+	    else if (enc_dbcs == DBCS_JPNU && *p == 0x8e)
+		// double-byte single width character
+		ScreenLines2[idx] = p[1];
+	    else if (cells > 1)
+		// double-width character
+		ScreenLines[idx + 1] = p[1];
+	    col += cells;
+	    idx += cells;
+	    p += c_len;
+	}
+    }
+    else
+    {
+	int len = (int)STRLEN(text);
+
+	if (len > wp->w_width - col)
+	    len = wp->w_width - col;
+	if (len > 0)
+	{
+#ifdef FEAT_RIGHTLEFT
+	    if (wp->w_p_rl)
+		mch_memmove(current_ScreenLine, text, len);
+	    else
+#endif
+		mch_memmove(current_ScreenLine + col, text, len);
+	    col += len;
+	}
+    }
+    return col;
+}
+#endif
+
+#ifdef FEAT_MENU
+/*
+ * Draw the window toolbar.
+ */
+    static void
+redraw_win_toolbar(win_T *wp)
+{
+    vimmenu_T	*menu;
+    int		item_idx = 0;
+    int		item_count = 0;
+    int		col = 0;
+    int		next_col;
+    int		off = (int)(current_ScreenLine - ScreenLines);
+    int		fill_attr = syn_name2attr((char_u *)"ToolbarLine");
+    int		button_attr = syn_name2attr((char_u *)"ToolbarButton");
+
+    vim_free(wp->w_winbar_items);
+    FOR_ALL_CHILD_MENUS(wp->w_winbar, menu)
+	++item_count;
+    wp->w_winbar_items = ALLOC_CLEAR_MULT(winbar_item_T, item_count + 1);
+
+    // TODO: use fewer spaces if there is not enough room
+    for (menu = wp->w_winbar->children;
+			  menu != NULL && col < wp->w_width; menu = menu->next)
+    {
+	space_to_screenline(off + col, fill_attr);
+	if (++col >= wp->w_width)
+	    break;
+	if (col > 1)
+	{
+	    space_to_screenline(off + col, fill_attr);
+	    if (++col >= wp->w_width)
+		break;
+	}
+
+	wp->w_winbar_items[item_idx].wb_startcol = col;
+	space_to_screenline(off + col, button_attr);
+	if (++col >= wp->w_width)
+	    break;
+
+	next_col = text_to_screenline(wp, menu->name, col);
+	while (col < next_col)
+	{
+	    ScreenAttrs[off + col] = button_attr;
+	    ++col;
+	}
+	wp->w_winbar_items[item_idx].wb_endcol = col;
+	wp->w_winbar_items[item_idx].wb_menu = menu;
+	++item_idx;
+
+	if (col >= wp->w_width)
+	    break;
+	space_to_screenline(off + col, button_attr);
+	++col;
+    }
+    while (col < wp->w_width)
+    {
+	space_to_screenline(off + col, fill_attr);
+	++col;
+    }
+    wp->w_winbar_items[item_idx].wb_menu = NULL; // end marker
+
+    screen_line(wp, wp->w_winrow, wp->w_wincol, wp->w_width, wp->w_width, 0);
+}
+#endif
+
+#if defined(FEAT_FOLDING) || defined(PROTO)
+/*
+ * Copy "buf[len]" to ScreenLines["off"] and set attributes to "attr".
+ */
+    static void
+copy_text_attr(
+    int		off,
+    char_u	*buf,
+    int		len,
+    int		attr)
+{
+    int		i;
+
+    mch_memmove(ScreenLines + off, buf, (size_t)len);
+    if (enc_utf8)
+	vim_memset(ScreenLinesUC + off, 0, sizeof(u8char_T) * (size_t)len);
+    for (i = 0; i < len; ++i)
+	ScreenAttrs[off + i] = attr;
+}
+
+/*
+ * Display one folded line.
+ */
+    static void
+fold_line(
+    win_T	*wp,
+    long	fold_count,
+    foldinfo_T	*foldinfo,
+    linenr_T	lnum,
+    int		row)
+{
+    // Max value of 'foldcolumn' is 12 and maximum number of bytes in a
+    // multi-byte character is MAX_MCO.
+    char_u	buf[MAX_MCO * 12 + 1];
+    pos_T	*top, *bot;
+    linenr_T	lnume = lnum + fold_count - 1;
+    int		len;
+    char_u	*text;
+    int		fdc;
+    int		col;
+    int		txtcol;
+    int		off = (int)(current_ScreenLine - ScreenLines);
+    int		ri;
+
+    // Build the fold line:
+    // 1. Add the cmdwin_type for the command-line window
+    // 2. Add the 'foldcolumn'
+    // 3. Add the 'number' or 'relativenumber' column
+    // 4. Compose the text
+    // 5. Add the text
+    // 6. set highlighting for the Visual area an other text
+    col = 0;
+
+    // 1. Add the cmdwin_type for the command-line window
+    // Ignores 'rightleft', this window is never right-left.
+    if (cmdwin_type != 0 && wp == curwin)
+    {
+	ScreenLines[off] = cmdwin_type;
+	ScreenAttrs[off] = HL_ATTR(HLF_AT);
+	if (enc_utf8)
+	    ScreenLinesUC[off] = 0;
+	++col;
+    }
+
+#ifdef FEAT_RIGHTLEFT
+# define RL_MEMSET(p, v, l) \
+    do { \
+	if (wp->w_p_rl) \
+	    for (ri = 0; ri < (l); ++ri) \
+	       ScreenAttrs[off + (wp->w_width - (p) - (l)) + ri] = v; \
+	 else \
+	    for (ri = 0; ri < (l); ++ri) \
+	       ScreenAttrs[off + (p) + ri] = v; \
+    } while (0)
+#else
+# define RL_MEMSET(p, v, l) \
+    do { \
+	for (ri = 0; ri < l; ++ri) \
+	    ScreenAttrs[off + (p) + ri] = v; \
+    } while (0)
+#endif
+
+    // 2. Add the 'foldcolumn'
+    //    Reduce the width when there is not enough space.
+    fdc = compute_foldcolumn(wp, col);
+    if (fdc > 0)
+    {
+	char_u	*p;
+	int	i;
+	int	idx;
+
+	fill_foldcolumn(buf, wp, TRUE, lnum);
+	p = buf;
+	for (i = 0; i < fdc; i++)
+	{
+	    int		ch;
+
+	    if (has_mbyte)
+		ch = mb_ptr2char_adv(&p);
+	    else
+		ch = *p++;
+#ifdef FEAT_RIGHTLEFT
+	    if (wp->w_p_rl)
+		idx = off + wp->w_width - i - 1 - col;
+	    else
+#endif
+		idx = off + col + i;
+	    if (enc_utf8)
+	    {
+		if (ch >= 0x80)
+		{
+		    ScreenLinesUC[idx] = ch;
+		    ScreenLinesC[0][idx] = 0;
+		    ScreenLines[idx] = 0x80;
+		}
+		else
+		{
+		    ScreenLines[idx] = ch;
+		    ScreenLinesUC[idx] = 0;
+		}
+	    }
+	    else
+		ScreenLines[idx] = ch;
+	}
+
+	RL_MEMSET(col, HL_ATTR(HLF_FC), fdc);
+	col += fdc;
+    }
+
+    // Set all attributes of the 'number' or 'relativenumber' column and the
+    // text
+    RL_MEMSET(col, HL_ATTR(HLF_FL), wp->w_width - col);
+
+#ifdef FEAT_SIGNS
+    // If signs are being displayed, add two spaces.
+    if (signcolumn_on(wp))
+    {
+	len = wp->w_width - col;
+	if (len > 0)
+	{
+	    if (len > 2)
+		len = 2;
+# ifdef FEAT_RIGHTLEFT
+	    if (wp->w_p_rl)
+		// the line number isn't reversed
+		copy_text_attr(off + wp->w_width - len - col,
+					(char_u *)"  ", len, HL_ATTR(HLF_FL));
+	    else
+# endif
+		copy_text_attr(off + col, (char_u *)"  ", len, HL_ATTR(HLF_FL));
+	    col += len;
+	}
+    }
+#endif
+
+    // 3. Add the 'number' or 'relativenumber' column
+    if (wp->w_p_nu || wp->w_p_rnu)
+    {
+	len = wp->w_width - col;
+	if (len > 0)
+	{
+	    int	    w = number_width(wp);
+	    long    num;
+	    char    *fmt = "%*ld ";
+
+	    if (len > w + 1)
+		len = w + 1;
+
+	    if (wp->w_p_nu && !wp->w_p_rnu)
+		// 'number' + 'norelativenumber'
+		num = (long)lnum;
+	    else
+	    {
+		// 'relativenumber', don't use negative numbers
+		num = labs((long)get_cursor_rel_lnum(wp, lnum));
+		if (num == 0 && wp->w_p_nu && wp->w_p_rnu)
+		{
+		    // 'number' + 'relativenumber': cursor line shows absolute
+		    // line number
+		    num = lnum;
+		    fmt = "%-*ld ";
+		}
+	    }
+
+	    sprintf((char *)buf, fmt, w, num);
+#ifdef FEAT_RIGHTLEFT
+	    if (wp->w_p_rl)
+		// the line number isn't reversed
+		copy_text_attr(off + wp->w_width - len - col, buf, len,
+							     HL_ATTR(HLF_FL));
+	    else
+#endif
+		copy_text_attr(off + col, buf, len, HL_ATTR(HLF_FL));
+	    col += len;
+	}
+    }
+
+    // 4. Compose the folded-line string with 'foldtext', if set.
+    text = get_foldtext(wp, lnum, lnume, foldinfo, buf);
+
+    txtcol = col;	// remember where text starts
+
+    // 5. move the text to current_ScreenLine.  Fill up with "fold" from
+    //    'fillchars'.
+    //    Right-left text is put in columns 0 - number-col, normal text is put
+    //    in columns number-col - window-width.
+    col = text_to_screenline(wp, text, col);
+
+    // Fill the rest of the line with the fold filler
+#ifdef FEAT_RIGHTLEFT
+    if (wp->w_p_rl)
+	col -= txtcol;
+#endif
+    while (col < wp->w_width
+#ifdef FEAT_RIGHTLEFT
+		    - (wp->w_p_rl ? txtcol : 0)
+#endif
+	    )
+    {
+	int c = wp->w_fill_chars.fold;
+
+	if (enc_utf8)
+	{
+	    if (c >= 0x80)
+	    {
+		ScreenLinesUC[off + col] = c;
+		ScreenLinesC[0][off + col] = 0;
+		ScreenLines[off + col] = 0x80; // avoid storing zero
+	    }
+	    else
+	    {
+		ScreenLinesUC[off + col] = 0;
+		ScreenLines[off + col] = c;
+	    }
+	    col++;
+	}
+	else
+	    ScreenLines[off + col++] = c;
+    }
+
+    if (text != buf)
+	vim_free(text);
+
+    // 6. set highlighting for the Visual area an other text.
+    // If all folded lines are in the Visual area, highlight the line.
+    if (VIsual_active && wp->w_buffer == curwin->w_buffer)
+    {
+	if (LTOREQ_POS(curwin->w_cursor, VIsual))
+	{
+	    // Visual is after curwin->w_cursor
+	    top = &curwin->w_cursor;
+	    bot = &VIsual;
+	}
+	else
+	{
+	    // Visual is before curwin->w_cursor
+	    top = &VIsual;
+	    bot = &curwin->w_cursor;
+	}
+	if (lnum >= top->lnum
+		&& lnume <= bot->lnum
+		&& (VIsual_mode != 'v'
+		    || ((lnum > top->lnum
+			    || (lnum == top->lnum
+				&& top->col == 0))
+			&& (lnume < bot->lnum
+			    || (lnume == bot->lnum
+				&& (bot->col - (*p_sel == 'e'))
+		>= (colnr_T)STRLEN(ml_get_buf(wp->w_buffer, lnume, FALSE)))))))
+	{
+	    if (VIsual_mode == Ctrl_V)
+	    {
+		// Visual block mode: highlight the chars part of the block
+		if (wp->w_old_cursor_fcol + txtcol < (colnr_T)wp->w_width)
+		{
+		    if (wp->w_old_cursor_lcol != MAXCOL
+			     && wp->w_old_cursor_lcol + txtcol
+						       < (colnr_T)wp->w_width)
+			len = wp->w_old_cursor_lcol;
+		    else
+			len = wp->w_width - txtcol;
+		    RL_MEMSET(wp->w_old_cursor_fcol + txtcol, HL_ATTR(HLF_V),
+					    len - (int)wp->w_old_cursor_fcol);
+		}
+	    }
+	    else
+	    {
+		// Set all attributes of the text
+		RL_MEMSET(txtcol, HL_ATTR(HLF_V), wp->w_width - txtcol);
+	    }
+	}
+    }
+
+#ifdef FEAT_SYN_HL
+    // Show colorcolumn in the fold line, but let cursorcolumn override it.
+    if (wp->w_p_cc_cols)
+    {
+	int i = 0;
+	int j = wp->w_p_cc_cols[i];
+	int old_txtcol = txtcol;
+
+	while (j > -1)
+	{
+	    txtcol += j;
+	    if (wp->w_p_wrap)
+		txtcol -= wp->w_skipcol;
+	    else
+		txtcol -= wp->w_leftcol;
+	    if (txtcol >= 0 && txtcol < wp->w_width)
+		ScreenAttrs[off + txtcol] = hl_combine_attr(
+				    ScreenAttrs[off + txtcol], HL_ATTR(HLF_MC));
+	    txtcol = old_txtcol;
+	    j = wp->w_p_cc_cols[++i];
+	}
+    }
+
+    // Show 'cursorcolumn' in the fold line.
+    if (wp->w_p_cuc)
+    {
+	txtcol += wp->w_virtcol;
+	if (wp->w_p_wrap)
+	    txtcol -= wp->w_skipcol;
+	else
+	    txtcol -= wp->w_leftcol;
+	if (txtcol >= 0 && txtcol < wp->w_width)
+	    ScreenAttrs[off + txtcol] = hl_combine_attr(
+				 ScreenAttrs[off + txtcol], HL_ATTR(HLF_CUC));
+    }
+#endif
+
+    screen_line(wp, row + W_WINROW(wp), wp->w_wincol,
+						  wp->w_width, wp->w_width, 0);
+
+    // Update w_cline_height and w_cline_folded if the cursor line was
+    // updated (saves a call to plines() later).
+    if (wp == curwin
+	    && lnum <= curwin->w_cursor.lnum
+	    && lnume >= curwin->w_cursor.lnum)
+    {
+	curwin->w_cline_row = row;
+	curwin->w_cline_height = 1;
+	curwin->w_cline_folded = TRUE;
+	curwin->w_valid |= (VALID_CHEIGHT|VALID_CROW);
+    }
+
+# ifdef FEAT_CONCEAL
+    // When the line was not folded w_wrow may have been set, recompute it.
+    if (wp == curwin
+	    && wp->w_cursor.lnum >= lnum
+	    && wp->w_cursor.lnum <= lnume
+	    && conceal_cursor_line(wp))
+	curs_columns(TRUE);
+# endif
+}
+#endif
+
+/*
+ * Update a single window.
+ *
+ * This may cause the windows below it also to be redrawn (when clearing the
+ * screen or scrolling lines).
+ *
+ * How the window is redrawn depends on wp->w_redr_type.  Each type also
+ * implies the one below it.
+ * UPD_NOT_VALID	redraw the whole window
+ * UPD_SOME_VALID	redraw the whole window but do scroll when possible
+ * UPD_REDRAW_TOP	redraw the top w_upd_rows window lines, otherwise like
+ *			UPD_VALID
+ * UPD_INVERTED		redraw the changed part of the Visual area
+ * UPD_INVERTED_ALL	redraw the whole Visual area
+ * UPD_VALID	1. scroll up/down to adjust for a changed w_topline
+ *		2. update lines at the top when scrolled down
+ *		3. redraw changed text:
+ *		   - if wp->w_buffer->b_mod_set set, update lines between
+ *		     b_mod_top and b_mod_bot.
+ *		   - if wp->w_redraw_top non-zero, redraw lines between
+ *		     wp->w_redraw_top and wp->w_redr_bot.
+ *		   - continue redrawing when syntax status is invalid.
+ *		4. if scrolled up, update lines at the bottom.
+ * This results in three areas that may need updating:
+ * top:	from first row to top_end (when scrolled down)
+ * mid: from mid_start to mid_end (update inversion or changed text)
+ * bot: from bot_start to last row (when scrolled up)
+ */
+    static void
+win_update(win_T *wp)
+{
+    buf_T	*buf = wp->w_buffer;
+    int		type;
+    int		top_end = 0;	// Below last row of the top area that needs
+				// updating.  0 when no top area updating.
+    int		mid_start = 999;// first row of the mid area that needs
+				// updating.  999 when no mid area updating.
+    int		mid_end = 0;	// Below last row of the mid area that needs
+				// updating.  0 when no mid area updating.
+    int		bot_start = 999;// first row of the bot area that needs
+				// updating.  999 when no bot area updating
+    int		scrolled_down = FALSE;	// TRUE when scrolled down when
+					// w_topline got smaller a bit
+#ifdef FEAT_SEARCH_EXTRA
+    int		top_to_mod = FALSE;    // redraw above mod_top
+#endif
+
+    int		row;		// current window row to display
+    linenr_T	lnum;		// current buffer lnum to display
+    int		idx;		// current index in w_lines[]
+    int		srow;		// starting row of the current line
+
+    int		eof = FALSE;	// if TRUE, we hit the end of the file
+    int		didline = FALSE; // if TRUE, we finished the last line
+    int		i;
+    long	j;
+    static int	recursive = FALSE;	// being called recursively
+    linenr_T	old_botline = wp->w_botline;
+#ifdef FEAT_CONCEAL
+    int		old_wrow = wp->w_wrow;
+    int		old_wcol = wp->w_wcol;
+#endif
+#ifdef FEAT_FOLDING
+    long	fold_count;
+#endif
+#ifdef FEAT_SYN_HL
+    // remember what happened to the previous line, to know if
+    // check_visual_highlight() can be used
+# define DID_NONE 1	// didn't update a line
+# define DID_LINE 2	// updated a normal line
+# define DID_FOLD 3	// updated a folded line
+    int		did_update = DID_NONE;
+    linenr_T	syntax_last_parsed = 0;		// last parsed text line
+#endif
+    linenr_T	mod_top = 0;
+    linenr_T	mod_bot = 0;
+#if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA)
+    int		save_got_int;
+#endif
+
+#if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD)
+    // This needs to be done only for the first window when update_screen() is
+    // called.
+    if (!did_update_one_window)
+    {
+	did_update_one_window = TRUE;
+# ifdef FEAT_SEARCH_EXTRA
+	start_search_hl();
+# endif
+# ifdef FEAT_CLIPBOARD
+	// When Visual area changed, may have to update selection.
+	if (clip_star.available && clip_isautosel_star())
+	    clip_update_selection(&clip_star);
+	if (clip_plus.available && clip_isautosel_plus())
+	    clip_update_selection(&clip_plus);
+# endif
+    }
+#endif
+
+    type = wp->w_redr_type;
+
+    if (type == UPD_NOT_VALID)
+    {
+	wp->w_redr_status = TRUE;
+	wp->w_lines_valid = 0;
+    }
+
+    // Window frame is zero-height: nothing to draw.
+    if (wp->w_height + WINBAR_HEIGHT(wp) == 0
+	    || (wp->w_frame->fr_height == wp->w_status_height
+#if defined(FEAT_PROP_POPUP)
+		&& !popup_is_popup(wp)
+#endif
+	       ))
+    {
+	wp->w_redr_type = 0;
+	return;
+    }
+
+    // Window is zero-width: Only need to draw the separator.
+    if (wp->w_width == 0)
+    {
+	// draw the vertical separator right of this window
+	draw_vsep_win(wp, 0);
+	wp->w_redr_type = 0;
+	return;
+    }
+
+#ifdef FEAT_TERMINAL
+    // If this window contains a terminal, redraw works completely differently.
+    if (term_do_update_window(wp))
+    {
+	term_update_window(wp);
+# ifdef FEAT_MENU
+	// Draw the window toolbar, if there is one.
+	if (winbar_height(wp) > 0)
+	    redraw_win_toolbar(wp);
+# endif
+	wp->w_redr_type = 0;
+	return;
+    }
+#endif
+
+#ifdef FEAT_SEARCH_EXTRA
+    init_search_hl(wp, &screen_search_hl);
+#endif
+
+    // Make sure skipcol is valid, it depends on various options and the window
+    // width.
+    if (wp->w_skipcol > 0)
+    {
+	int w = 0;
+	int width1 = wp->w_width - win_col_off(wp);
+	int width2 = width1 + win_col_off2(wp);
+	int add = width1;
+
+	while (w < wp->w_skipcol)
+	{
+	    if (w > 0)
+		add = width2;
+	    w += add;
+	}
+	if (w != wp->w_skipcol)
+	    // always round down, the higher value may not be valid
+	    wp->w_skipcol = w - add;
+    }
+
+#ifdef FEAT_LINEBREAK
+    // Force redraw when width of 'number' or 'relativenumber' column
+    // changes.
+    i = (wp->w_p_nu || wp->w_p_rnu) ? number_width(wp) : 0;
+    if (wp->w_nrwidth != i)
+    {
+	type = UPD_NOT_VALID;
+	wp->w_nrwidth = i;
+    }
+    else
+#endif
+
+    if (buf->b_mod_set && buf->b_mod_xlines != 0 && wp->w_redraw_top != 0)
+    {
+	// When there are both inserted/deleted lines and specific lines to be
+	// redrawn, w_redraw_top and w_redraw_bot may be invalid, just redraw
+	// everything (only happens when redrawing is off for while).
+	type = UPD_NOT_VALID;
+    }
+    else
+    {
+	// Set mod_top to the first line that needs displaying because of
+	// changes.  Set mod_bot to the first line after the changes.
+	mod_top = wp->w_redraw_top;
+	if (wp->w_redraw_bot != 0)
+	    mod_bot = wp->w_redraw_bot + 1;
+	else
+	    mod_bot = 0;
+	if (buf->b_mod_set)
+	{
+	    if (mod_top == 0 || mod_top > buf->b_mod_top)
+	    {
+		mod_top = buf->b_mod_top;
+#ifdef FEAT_SYN_HL
+		// Need to redraw lines above the change that may be included
+		// in a pattern match.
+		if (syntax_present(wp))
+		{
+		    mod_top -= buf->b_s.b_syn_sync_linebreaks;
+		    if (mod_top < 1)
+			mod_top = 1;
+		}
+#endif
+	    }
+	    if (mod_bot == 0 || mod_bot < buf->b_mod_bot)
+		mod_bot = buf->b_mod_bot;
+
+#ifdef FEAT_SEARCH_EXTRA
+	    // When 'hlsearch' is on and using a multi-line search pattern, a
+	    // change in one line may make the Search highlighting in a
+	    // previous line invalid.  Simple solution: redraw all visible
+	    // lines above the change.
+	    // Same for a match pattern.
+	    if (screen_search_hl.rm.regprog != NULL
+		    && re_multiline(screen_search_hl.rm.regprog))
+		top_to_mod = TRUE;
+	    else
+	    {
+		matchitem_T *cur = wp->w_match_head;
+
+		while (cur != NULL)
+		{
+		    if (cur->mit_match.regprog != NULL
+				       && re_multiline(cur->mit_match.regprog))
+		    {
+			top_to_mod = TRUE;
+			break;
+		    }
+		    cur = cur->mit_next;
+		}
+	    }
+#endif
+	}
+
+#ifdef FEAT_SEARCH_EXTRA
+	if (search_hl_has_cursor_lnum > 0)
+	{
+	    // CurSearch was used last time, need to redraw the line with it to
+	    // avoid having two matches highlighted with CurSearch.
+	    if (mod_top == 0 || mod_top > search_hl_has_cursor_lnum)
+		mod_top = search_hl_has_cursor_lnum;
+	    if (mod_bot == 0 || mod_bot < search_hl_has_cursor_lnum + 1)
+		mod_bot = search_hl_has_cursor_lnum + 1;
+	}
+#endif
+
+#ifdef FEAT_FOLDING
+	if (mod_top != 0 && hasAnyFolding(wp))
+	{
+	    linenr_T	lnumt, lnumb;
+
+	    // A change in a line can cause lines above it to become folded or
+	    // unfolded.  Find the top most buffer line that may be affected.
+	    // If the line was previously folded and displayed, get the first
+	    // line of that fold.  If the line is folded now, get the first
+	    // folded line.  Use the minimum of these two.
+
+	    // Find last valid w_lines[] entry above mod_top.  Set lnumt to
+	    // the line below it.  If there is no valid entry, use w_topline.
+	    // Find the first valid w_lines[] entry below mod_bot.  Set lnumb
+	    // to this line.  If there is no valid entry, use MAXLNUM.
+	    lnumt = wp->w_topline;
+	    lnumb = MAXLNUM;
+	    for (i = 0; i < wp->w_lines_valid; ++i)
+		if (wp->w_lines[i].wl_valid)
+		{
+		    if (wp->w_lines[i].wl_lastlnum < mod_top)
+			lnumt = wp->w_lines[i].wl_lastlnum + 1;
+		    if (lnumb == MAXLNUM && wp->w_lines[i].wl_lnum >= mod_bot)
+		    {
+			lnumb = wp->w_lines[i].wl_lnum;
+			// When there is a fold column it might need updating
+			// in the next line ("J" just above an open fold).
+			if (compute_foldcolumn(wp, 0) > 0)
+			    ++lnumb;
+		    }
+		}
+
+	    (void)hasFoldingWin(wp, mod_top, &mod_top, NULL, TRUE, NULL);
+	    if (mod_top > lnumt)
+		mod_top = lnumt;
+
+	    // Now do the same for the bottom line (one above mod_bot).
+	    --mod_bot;
+	    (void)hasFoldingWin(wp, mod_bot, NULL, &mod_bot, TRUE, NULL);
+	    ++mod_bot;
+	    if (mod_bot < lnumb)
+		mod_bot = lnumb;
+	}
+#endif
+
+	// When a change starts above w_topline and the end is below
+	// w_topline, start redrawing at w_topline.
+	// If the end of the change is above w_topline: do like no change was
+	// made, but redraw the first line to find changes in syntax.
+	if (mod_top != 0 && mod_top < wp->w_topline)
+	{
+	    if (mod_bot > wp->w_topline)
+		mod_top = wp->w_topline;
+#ifdef FEAT_SYN_HL
+	    else if (syntax_present(wp))
+		top_end = 1;
+#endif
+	}
+
+	// When line numbers are displayed need to redraw all lines below
+	// inserted/deleted lines.
+	if (mod_top != 0 && buf->b_mod_xlines != 0 && wp->w_p_nu)
+	    mod_bot = MAXLNUM;
+    }
+    wp->w_redraw_top = 0;	// reset for next time
+    wp->w_redraw_bot = 0;
+#ifdef FEAT_SEARCH_EXTRA
+    search_hl_has_cursor_lnum = 0;
+#endif
+
+
+    // When only displaying the lines at the top, set top_end.  Used when
+    // window has scrolled down for msg_scrolled.
+    if (type == UPD_REDRAW_TOP)
+    {
+	j = 0;
+	for (i = 0; i < wp->w_lines_valid; ++i)
+	{
+	    j += wp->w_lines[i].wl_size;
+	    if (j >= wp->w_upd_rows)
+	    {
+		top_end = j;
+		break;
+	    }
+	}
+	if (top_end == 0)
+	    // not found (cannot happen?): redraw everything
+	    type = UPD_NOT_VALID;
+	else
+	    // top area defined, the rest is UPD_VALID
+	    type = UPD_VALID;
+    }
+
+    // Trick: we want to avoid clearing the screen twice.  screenclear() will
+    // set "screen_cleared" to TRUE.  The special value MAYBE (which is still
+    // non-zero and thus not FALSE) will indicate that screenclear() was not
+    // called.
+    if (screen_cleared)
+	screen_cleared = MAYBE;
+
+    // If there are no changes on the screen that require a complete redraw,
+    // handle three cases:
+    // 1: we are off the top of the screen by a few lines: scroll down
+    // 2: wp->w_topline is below wp->w_lines[0].wl_lnum: may scroll up
+    // 3: wp->w_topline is wp->w_lines[0].wl_lnum: find first entry in
+    //    w_lines[] that needs updating.
+    if ((type == UPD_VALID || type == UPD_SOME_VALID
+			   || type == UPD_INVERTED || type == UPD_INVERTED_ALL)
+#ifdef FEAT_DIFF
+	    && !wp->w_botfill && !wp->w_old_botfill
+#endif
+	    )
+    {
+	if (mod_top != 0
+		&& wp->w_topline == mod_top
+		&& (!wp->w_lines[0].wl_valid
+		    || wp->w_topline == wp->w_lines[0].wl_lnum))
+	{
+	    // w_topline is the first changed line and window is not scrolled,
+	    // the scrolling from changed lines will be done further down.
+	}
+	else if (wp->w_lines[0].wl_valid
+		&& (wp->w_topline < wp->w_lines[0].wl_lnum
+#ifdef FEAT_DIFF
+		    || (wp->w_topline == wp->w_lines[0].wl_lnum
+			&& wp->w_topfill > wp->w_old_topfill)
+#endif
+		   ))
+	{
+	    // New topline is above old topline: May scroll down.
+#ifdef FEAT_FOLDING
+	    if (hasAnyFolding(wp))
+	    {
+		linenr_T ln;
+
+		// count the number of lines we are off, counting a sequence
+		// of folded lines as one
+		j = 0;
+		for (ln = wp->w_topline; ln < wp->w_lines[0].wl_lnum; ++ln)
+		{
+		    ++j;
+		    if (j >= wp->w_height - 2)
+			break;
+		    (void)hasFoldingWin(wp, ln, NULL, &ln, TRUE, NULL);
+		}
+	    }
+	    else
+#endif
+		j = wp->w_lines[0].wl_lnum - wp->w_topline;
+	    if (j < wp->w_height - 2)		// not too far off
+	    {
+		i = plines_m_win(wp, wp->w_topline, wp->w_lines[0].wl_lnum - 1);
+#ifdef FEAT_DIFF
+		// insert extra lines for previously invisible filler lines
+		if (wp->w_lines[0].wl_lnum != wp->w_topline)
+		    i += diff_check_fill(wp, wp->w_lines[0].wl_lnum)
+							  - wp->w_old_topfill;
+#endif
+		if (i < wp->w_height - 2)	// less than a screen off
+		{
+		    // Try to insert the correct number of lines.
+		    // If not the last window, delete the lines at the bottom.
+		    // win_ins_lines may fail when the terminal can't do it.
+		    if (i > 0)
+			check_for_delay(FALSE);
+		    if (win_ins_lines(wp, 0, i, FALSE, wp == firstwin) == OK)
+		    {
+			if (wp->w_lines_valid != 0)
+			{
+			    // Need to update rows that are new, stop at the
+			    // first one that scrolled down.
+			    top_end = i;
+			    scrolled_down = TRUE;
+
+			    // Move the entries that were scrolled, disable
+			    // the entries for the lines to be redrawn.
+			    if ((wp->w_lines_valid += j) > wp->w_height)
+				wp->w_lines_valid = wp->w_height;
+			    for (idx = wp->w_lines_valid; idx - j >= 0; idx--)
+				wp->w_lines[idx] = wp->w_lines[idx - j];
+			    while (idx >= 0)
+				wp->w_lines[idx--].wl_valid = FALSE;
+			}
+		    }
+		    else
+			mid_start = 0;		// redraw all lines
+		}
+		else
+		    mid_start = 0;		// redraw all lines
+	    }
+	    else
+		mid_start = 0;		// redraw all lines
+	}
+	else
+	{
+	    // New topline is at or below old topline: May scroll up.
+	    // When topline didn't change, find first entry in w_lines[] that
+	    // needs updating.
+
+	    // Try to find wp->w_topline in wp->w_lines[].wl_lnum.  The check
+	    // for "Rows" is in case "wl_size" is incorrect somehow.
+	    j = -1;
+	    row = 0;
+	    for (i = 0; i < wp->w_lines_valid && i < Rows; i++)
+	    {
+		if (wp->w_lines[i].wl_valid
+			&& wp->w_lines[i].wl_lnum == wp->w_topline)
+		{
+		    j = i;
+		    break;
+		}
+		row += wp->w_lines[i].wl_size;
+	    }
+	    if (j == -1)
+	    {
+		// if wp->w_topline is not in wp->w_lines[].wl_lnum redraw all
+		// lines
+		mid_start = 0;
+	    }
+	    else
+	    {
+		// Try to delete the correct number of lines.
+		// wp->w_topline is at wp->w_lines[i].wl_lnum.
+#ifdef FEAT_DIFF
+		// If the topline didn't change, delete old filler lines,
+		// otherwise delete filler lines of the new topline...
+		if (wp->w_lines[0].wl_lnum == wp->w_topline)
+		    row += wp->w_old_topfill;
+		else
+		    row += diff_check_fill(wp, wp->w_topline);
+		// ... but don't delete new filler lines.
+		row -= wp->w_topfill;
+#endif
+		if (row > Rows)  // just in case
+		    row = Rows;
+		if (row > 0)
+		{
+		    check_for_delay(FALSE);
+		    if (win_del_lines(wp, 0, row, FALSE, wp == firstwin, 0)
+									 == OK)
+			bot_start = wp->w_height - row;
+		    else
+			mid_start = 0;		// redraw all lines
+		}
+		if ((row == 0 || bot_start < 999) && wp->w_lines_valid != 0)
+		{
+		    // Skip the lines (below the deleted lines) that are still
+		    // valid and don't need redrawing.	Copy their info
+		    // upwards, to compensate for the deleted lines.  Set
+		    // bot_start to the first row that needs redrawing.
+		    bot_start = 0;
+		    idx = 0;
+		    for (;;)
+		    {
+			wp->w_lines[idx] = wp->w_lines[j];
+			// stop at line that didn't fit, unless it is still
+			// valid (no lines deleted)
+			if (row > 0 && bot_start + row
+				 + (int)wp->w_lines[j].wl_size > wp->w_height)
+			{
+			    wp->w_lines_valid = idx + 1;
+			    break;
+			}
+			bot_start += wp->w_lines[idx++].wl_size;
+
+			// stop at the last valid entry in w_lines[].wl_size
+			if (++j >= wp->w_lines_valid)
+			{
+			    wp->w_lines_valid = idx;
+			    break;
+			}
+		    }
+#ifdef FEAT_DIFF
+		    // Correct the first entry for filler lines at the top
+		    // when it won't get updated below.
+		    if (wp->w_p_diff && bot_start > 0)
+			wp->w_lines[0].wl_size =
+			    plines_win_nofill(wp, wp->w_topline, TRUE)
+							      + wp->w_topfill;
+#endif
+		}
+	    }
+	}
+
+	// When starting redraw in the first line, redraw all lines.
+	if (mid_start == 0)
+	    mid_end = wp->w_height;
+
+	// When win_del_lines() or win_ins_lines() caused the screen to be
+	// cleared (only happens for the first window) or when screenclear()
+	// was called directly above, "must_redraw" will have been set to
+	// UPD_NOT_VALID, need to reset it here to avoid redrawing twice.
+	if (screen_cleared == TRUE)
+	    must_redraw = 0;
+    }
+    else
+    {
+	// Not UPD_VALID or UPD_INVERTED: redraw all lines.
+	mid_start = 0;
+	mid_end = wp->w_height;
+    }
+
+    if (type == UPD_SOME_VALID)
+    {
+	// UPD_SOME_VALID: redraw all lines.
+	mid_start = 0;
+	mid_end = wp->w_height;
+	type = UPD_NOT_VALID;
+    }
+
+    // check if we are updating or removing the inverted part
+    if ((VIsual_active && buf == curwin->w_buffer)
+	    || (wp->w_old_cursor_lnum != 0 && type != UPD_NOT_VALID))
+    {
+	linenr_T    from, to;
+
+	if (VIsual_active)
+	{
+	    if (VIsual_mode != wp->w_old_visual_mode
+		|| type == UPD_INVERTED_ALL)
+	    {
+		// If the type of Visual selection changed, redraw the whole
+		// selection.  Also when the ownership of the X selection is
+		// gained or lost.
+		if (curwin->w_cursor.lnum < VIsual.lnum)
+		{
+		    from = curwin->w_cursor.lnum;
+		    to = VIsual.lnum;
+		}
+		else
+		{
+		    from = VIsual.lnum;
+		    to = curwin->w_cursor.lnum;
+		}
+		// redraw more when the cursor moved as well
+		if (wp->w_old_cursor_lnum < from)
+		    from = wp->w_old_cursor_lnum;
+		if (wp->w_old_cursor_lnum > to)
+		    to = wp->w_old_cursor_lnum;
+		if (wp->w_old_visual_lnum < from)
+		    from = wp->w_old_visual_lnum;
+		if (wp->w_old_visual_lnum > to)
+		    to = wp->w_old_visual_lnum;
+	    }
+	    else
+	    {
+		// Find the line numbers that need to be updated: The lines
+		// between the old cursor position and the current cursor
+		// position.  Also check if the Visual position changed.
+		if (curwin->w_cursor.lnum < wp->w_old_cursor_lnum)
+		{
+		    from = curwin->w_cursor.lnum;
+		    to = wp->w_old_cursor_lnum;
+		}
+		else
+		{
+		    from = wp->w_old_cursor_lnum;
+		    to = curwin->w_cursor.lnum;
+		    if (from == 0)	// Visual mode just started
+			from = to;
+		}
+
+		if (VIsual.lnum != wp->w_old_visual_lnum
+					|| VIsual.col != wp->w_old_visual_col)
+		{
+		    if (wp->w_old_visual_lnum < from
+						&& wp->w_old_visual_lnum != 0)
+			from = wp->w_old_visual_lnum;
+		    if (wp->w_old_visual_lnum > to)
+			to = wp->w_old_visual_lnum;
+		    if (VIsual.lnum < from)
+			from = VIsual.lnum;
+		    if (VIsual.lnum > to)
+			to = VIsual.lnum;
+		}
+	    }
+
+	    // If in block mode and changed column or curwin->w_curswant:
+	    // update all lines.
+	    // First compute the actual start and end column.
+	    if (VIsual_mode == Ctrl_V)
+	    {
+		colnr_T	    fromc, toc;
+#if defined(FEAT_LINEBREAK)
+		int	    save_ve_flags = curwin->w_ve_flags;
+
+		if (curwin->w_p_lbr)
+		    curwin->w_ve_flags = VE_ALL;
+#endif
+		getvcols(wp, &VIsual, &curwin->w_cursor, &fromc, &toc);
+		++toc;
+#if defined(FEAT_LINEBREAK)
+		curwin->w_ve_flags = save_ve_flags;
+#endif
+		// Highlight to the end of the line, unless 'virtualedit' has
+		// "block".
+		if (curwin->w_curswant == MAXCOL)
+		{
+		    if (get_ve_flags() & VE_BLOCK)
+		    {
+			pos_T	    pos;
+			int	    cursor_above =
+					   curwin->w_cursor.lnum < VIsual.lnum;
+
+			// Need to find the longest line.
+			toc = 0;
+			pos.coladd = 0;
+			for (pos.lnum = curwin->w_cursor.lnum; cursor_above
+					? pos.lnum <= VIsual.lnum
+					: pos.lnum >= VIsual.lnum;
+					     pos.lnum += cursor_above ? 1 : -1)
+			{
+			    colnr_T t;
+
+			    pos.col = (int)STRLEN(ml_get_buf(wp->w_buffer,
+							     pos.lnum, FALSE));
+			    getvvcol(wp, &pos, NULL, NULL, &t);
+			    if (toc < t)
+				toc = t;
+			}
+			++toc;
+		    }
+		    else
+			toc = MAXCOL;
+		}
+
+		if (fromc != wp->w_old_cursor_fcol
+			|| toc != wp->w_old_cursor_lcol)
+		{
+		    if (from > VIsual.lnum)
+			from = VIsual.lnum;
+		    if (to < VIsual.lnum)
+			to = VIsual.lnum;
+		}
+		wp->w_old_cursor_fcol = fromc;
+		wp->w_old_cursor_lcol = toc;
+	    }
+	}
+	else
+	{
+	    // Use the line numbers of the old Visual area.
+	    if (wp->w_old_cursor_lnum < wp->w_old_visual_lnum)
+	    {
+		from = wp->w_old_cursor_lnum;
+		to = wp->w_old_visual_lnum;
+	    }
+	    else
+	    {
+		from = wp->w_old_visual_lnum;
+		to = wp->w_old_cursor_lnum;
+	    }
+	}
+
+	// There is no need to update lines above the top of the window.
+	if (from < wp->w_topline)
+	    from = wp->w_topline;
+
+	// If we know the value of w_botline, use it to restrict the update to
+	// the lines that are visible in the window.
+	if (wp->w_valid & VALID_BOTLINE)
+	{
+	    if (from >= wp->w_botline)
+		from = wp->w_botline - 1;
+	    if (to >= wp->w_botline)
+		to = wp->w_botline - 1;
+	}
+
+	// Find the minimal part to be updated.
+	// Watch out for scrolling that made entries in w_lines[] invalid.
+	// E.g., CTRL-U makes the first half of w_lines[] invalid and sets
+	// top_end; need to redraw from top_end to the "to" line.
+	// A middle mouse click with a Visual selection may change the text
+	// above the Visual area and reset wl_valid, do count these for
+	// mid_end (in srow).
+	if (mid_start > 0)
+	{
+	    lnum = wp->w_topline;
+	    idx = 0;
+	    srow = 0;
+	    if (scrolled_down)
+		mid_start = top_end;
+	    else
+		mid_start = 0;
+	    while (lnum < from && idx < wp->w_lines_valid)	// find start
+	    {
+		if (wp->w_lines[idx].wl_valid)
+		    mid_start += wp->w_lines[idx].wl_size;
+		else if (!scrolled_down)
+		    srow += wp->w_lines[idx].wl_size;
+		++idx;
+# ifdef FEAT_FOLDING
+		if (idx < wp->w_lines_valid && wp->w_lines[idx].wl_valid)
+		    lnum = wp->w_lines[idx].wl_lnum;
+		else
+# endif
+		    ++lnum;
+	    }
+	    srow += mid_start;
+	    mid_end = wp->w_height;
+	    for ( ; idx < wp->w_lines_valid; ++idx)		// find end
+	    {
+		if (wp->w_lines[idx].wl_valid
+			&& wp->w_lines[idx].wl_lnum >= to + 1)
+		{
+		    // Only update until first row of this line
+		    mid_end = srow;
+		    break;
+		}
+		srow += wp->w_lines[idx].wl_size;
+	    }
+	}
+    }
+
+    if (VIsual_active && buf == curwin->w_buffer)
+    {
+	wp->w_old_visual_mode = VIsual_mode;
+	wp->w_old_cursor_lnum = curwin->w_cursor.lnum;
+	wp->w_old_visual_lnum = VIsual.lnum;
+	wp->w_old_visual_col = VIsual.col;
+	wp->w_old_curswant = curwin->w_curswant;
+    }
+    else
+    {
+	wp->w_old_visual_mode = 0;
+	wp->w_old_cursor_lnum = 0;
+	wp->w_old_visual_lnum = 0;
+	wp->w_old_visual_col = 0;
+    }
+
+#if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA)
+    // reset got_int, otherwise regexp won't work
+    save_got_int = got_int;
+    got_int = 0;
+#endif
+#ifdef SYN_TIME_LIMIT
+    // Set the time limit to 'redrawtime'.
+    redrawtime_limit_set = TRUE;
+    init_regexp_timeout(p_rdt);
+#endif
+#ifdef FEAT_FOLDING
+    win_foldinfo.fi_level = 0;
+#endif
+
+#ifdef FEAT_MENU
+    // Draw the window toolbar, if there is one.
+    // TODO: only when needed.
+    if (winbar_height(wp) > 0)
+	redraw_win_toolbar(wp);
+#endif
+
+    // Update all the window rows.
+    idx = 0;		// first entry in w_lines[].wl_size
+    row = 0;
+    srow = 0;
+    lnum = wp->w_topline;	// first line shown in window
+    for (;;)
+    {
+	// stop updating when reached the end of the window (check for _past_
+	// the end of the window is at the end of the loop)
+	if (row == wp->w_height)
+	{
+	    didline = TRUE;
+	    break;
+	}
+
+	// stop updating when hit the end of the file
+	if (lnum > buf->b_ml.ml_line_count)
+	{
+	    eof = TRUE;
+	    break;
+	}
+
+	// Remember the starting row of the line that is going to be dealt
+	// with.  It is used further down when the line doesn't fit.
+	srow = row;
+
+	// Update a line when it is in an area that needs updating, when it
+	// has changes or w_lines[idx] is invalid.
+	// "bot_start" may be halfway a wrapped line after using
+	// win_del_lines(), check if the current line includes it.
+	// When syntax folding is being used, the saved syntax states will
+	// already have been updated, we can't see where the syntax state is
+	// the same again, just update until the end of the window.
+	if (row < top_end
+		|| (row >= mid_start && row < mid_end)
+#ifdef FEAT_SEARCH_EXTRA
+		|| top_to_mod
+#endif
+		|| idx >= wp->w_lines_valid
+		|| (row + wp->w_lines[idx].wl_size > bot_start)
+		|| (mod_top != 0
+		    && (lnum == mod_top
+			|| (lnum >= mod_top
+			    && (lnum < mod_bot
+#ifdef FEAT_SYN_HL
+				|| did_update == DID_FOLD
+				|| (did_update == DID_LINE
+				    && syntax_present(wp)
+				    && (
+# ifdef FEAT_FOLDING
+					(foldmethodIsSyntax(wp)
+						      && hasAnyFolding(wp)) ||
+# endif
+					syntax_check_changed(lnum)))
+#endif
+#ifdef FEAT_SEARCH_EXTRA
+				// match in fixed position might need redraw
+				// if lines were inserted or deleted
+				|| (wp->w_match_head != NULL
+						    && buf->b_mod_xlines != 0)
+#endif
+				))))
+#ifdef FEAT_SYN_HL
+		|| (wp->w_p_cul && lnum == wp->w_cursor.lnum)
+		|| lnum == wp->w_last_cursorline
+#endif
+				)
+	{
+#ifdef FEAT_SEARCH_EXTRA
+	    if (lnum == mod_top)
+		top_to_mod = FALSE;
+#endif
+
+	    // When at start of changed lines: May scroll following lines
+	    // up or down to minimize redrawing.
+	    // Don't do this when the change continues until the end.
+	    // Don't scroll when dollar_vcol >= 0, keep the "$".
+	    // Don't scroll when redrawing the top, scrolled already above.
+	    if (lnum == mod_top
+		    && mod_bot != MAXLNUM
+		    && !(dollar_vcol >= 0 && mod_bot == mod_top + 1)
+		    && row >= top_end)
+	    {
+		int		old_rows = 0;
+		int		new_rows = 0;
+		int		xtra_rows;
+		linenr_T	l;
+
+		// Count the old number of window rows, using w_lines[], which
+		// should still contain the sizes for the lines as they are
+		// currently displayed.
+		for (i = idx; i < wp->w_lines_valid; ++i)
+		{
+		    // Only valid lines have a meaningful wl_lnum.  Invalid
+		    // lines are part of the changed area.
+		    if (wp->w_lines[i].wl_valid
+			    && wp->w_lines[i].wl_lnum == mod_bot)
+			break;
+		    old_rows += wp->w_lines[i].wl_size;
+#ifdef FEAT_FOLDING
+		    if (wp->w_lines[i].wl_valid
+			    && wp->w_lines[i].wl_lastlnum + 1 == mod_bot)
+		    {
+			// Must have found the last valid entry above mod_bot.
+			// Add following invalid entries.
+			++i;
+			while (i < wp->w_lines_valid
+						  && !wp->w_lines[i].wl_valid)
+			    old_rows += wp->w_lines[i++].wl_size;
+			break;
+		    }
+#endif
+		}
+
+		if (i >= wp->w_lines_valid)
+		{
+		    // We can't find a valid line below the changed lines,
+		    // need to redraw until the end of the window.
+		    // Inserting/deleting lines has no use.
+		    bot_start = 0;
+		}
+		else
+		{
+		    // Able to count old number of rows: Count new window
+		    // rows, and may insert/delete lines
+		    j = idx;
+		    for (l = lnum; l < mod_bot; ++l)
+		    {
+#ifdef FEAT_FOLDING
+			if (hasFoldingWin(wp, l, NULL, &l, TRUE, NULL))
+			    ++new_rows;
+			else
+#endif
+			{
+#ifdef FEAT_DIFF
+			    if (l == wp->w_topline)
+				new_rows += plines_win_nofill(wp, l, TRUE)
+							      + wp->w_topfill;
+			    else
+#endif
+				new_rows += plines_win(wp, l, TRUE);
+			}
+			++j;
+			if (new_rows > wp->w_height - row - 2)
+			{
+			    // it's getting too much, must redraw the rest
+			    new_rows = 9999;
+			    break;
+			}
+		    }
+		    xtra_rows = new_rows - old_rows;
+		    if (xtra_rows < 0)
+		    {
+			// May scroll text up.  If there is not enough
+			// remaining text or scrolling fails, must redraw the
+			// rest.  If scrolling works, must redraw the text
+			// below the scrolled text.
+			if (row - xtra_rows >= wp->w_height - 2)
+			    mod_bot = MAXLNUM;
+			else
+			{
+			    check_for_delay(FALSE);
+			    if (win_del_lines(wp, row,
+					  -xtra_rows, FALSE, FALSE, 0) == FAIL)
+				mod_bot = MAXLNUM;
+			    else
+				bot_start = wp->w_height + xtra_rows;
+			}
+		    }
+		    else if (xtra_rows > 0)
+		    {
+			// May scroll text down.  If there is not enough
+			// remaining text of scrolling fails, must redraw the
+			// rest.
+			if (row + xtra_rows >= wp->w_height - 2)
+			    mod_bot = MAXLNUM;
+			else
+			{
+			    check_for_delay(FALSE);
+			    if (win_ins_lines(wp, row + old_rows,
+					     xtra_rows, FALSE, FALSE) == FAIL)
+				mod_bot = MAXLNUM;
+			    else if (top_end > row + old_rows)
+				// Scrolled the part at the top that requires
+				// updating down.
+				top_end += xtra_rows;
+			}
+		    }
+
+		    // When not updating the rest, may need to move w_lines[]
+		    // entries.
+		    if (mod_bot != MAXLNUM && i != j)
+		    {
+			if (j < i)
+			{
+			    int x = row + new_rows;
+
+			    // move entries in w_lines[] upwards
+			    for (;;)
+			    {
+				// stop at last valid entry in w_lines[]
+				if (i >= wp->w_lines_valid)
+				{
+				    wp->w_lines_valid = j;
+				    break;
+				}
+				wp->w_lines[j] = wp->w_lines[i];
+				// stop at a line that won't fit
+				if (x + (int)wp->w_lines[j].wl_size
+							   > wp->w_height)
+				{
+				    wp->w_lines_valid = j + 1;
+				    break;
+				}
+				x += wp->w_lines[j++].wl_size;
+				++i;
+			    }
+			    if (bot_start > x)
+				bot_start = x;
+			}
+			else // j > i
+			{
+			    // move entries in w_lines[] downwards
+			    j -= i;
+			    wp->w_lines_valid += j;
+			    if (wp->w_lines_valid > wp->w_height)
+				wp->w_lines_valid = wp->w_height;
+			    for (i = wp->w_lines_valid; i - j >= idx; --i)
+				wp->w_lines[i] = wp->w_lines[i - j];
+
+			    // The w_lines[] entries for inserted lines are
+			    // now invalid, but wl_size may be used above.
+			    // Reset to zero.
+			    while (i >= idx)
+			    {
+				wp->w_lines[i].wl_size = 0;
+				wp->w_lines[i--].wl_valid = FALSE;
+			    }
+			}
+		    }
+		}
+	    }
+
+#ifdef FEAT_FOLDING
+	    // When lines are folded, display one line for all of them.
+	    // Otherwise, display normally (can be several display lines when
+	    // 'wrap' is on).
+	    fold_count = foldedCount(wp, lnum, &win_foldinfo);
+	    if (fold_count != 0)
+	    {
+		fold_line(wp, fold_count, &win_foldinfo, lnum, row);
+		++row;
+		--fold_count;
+		wp->w_lines[idx].wl_folded = TRUE;
+		wp->w_lines[idx].wl_lastlnum = lnum + fold_count;
+# ifdef FEAT_SYN_HL
+		did_update = DID_FOLD;
+# endif
+	    }
+	    else
+#endif
+	    if (idx < wp->w_lines_valid
+		    && wp->w_lines[idx].wl_valid
+		    && wp->w_lines[idx].wl_lnum == lnum
+		    && lnum > wp->w_topline
+		    && !(dy_flags & (DY_LASTLINE | DY_TRUNCATE))
+		    && !WIN_IS_POPUP(wp)
+		    && srow + wp->w_lines[idx].wl_size > wp->w_height
+#ifdef FEAT_DIFF
+		    && diff_check_fill(wp, lnum) == 0
+#endif
+		    )
+	    {
+		// This line is not going to fit.  Don't draw anything here,
+		// will draw "@  " lines below.
+		row = wp->w_height + 1;
+	    }
+	    else
+	    {
+#ifdef FEAT_SEARCH_EXTRA
+		prepare_search_hl(wp, &screen_search_hl, lnum);
+#endif
+#ifdef FEAT_SYN_HL
+		// Let the syntax stuff know we skipped a few lines.
+		if (syntax_last_parsed != 0 && syntax_last_parsed + 1 < lnum
+						       && syntax_present(wp))
+		    syntax_end_parsing(wp, syntax_last_parsed + 1);
+#endif
+
+		// Display one line.
+		row = win_line(wp, lnum, srow, wp->w_height,
+							  mod_top == 0, FALSE);
+
+#ifdef FEAT_FOLDING
+		wp->w_lines[idx].wl_folded = FALSE;
+		wp->w_lines[idx].wl_lastlnum = lnum;
+#endif
+#ifdef FEAT_SYN_HL
+		did_update = DID_LINE;
+		syntax_last_parsed = lnum;
+#endif
+	    }
+
+	    wp->w_lines[idx].wl_lnum = lnum;
+	    wp->w_lines[idx].wl_valid = TRUE;
+
+	    // Past end of the window or end of the screen. Note that after
+	    // resizing wp->w_height may be end up too big. That's a problem
+	    // elsewhere, but prevent a crash here.
+	    if (row > wp->w_height || row + wp->w_winrow >= Rows)
+	    {
+		// we may need the size of that too long line later on
+		if (dollar_vcol == -1)
+		    wp->w_lines[idx].wl_size = plines_win(wp, lnum, TRUE);
+		++idx;
+		break;
+	    }
+	    if (dollar_vcol == -1)
+		wp->w_lines[idx].wl_size = row - srow;
+	    ++idx;
+#ifdef FEAT_FOLDING
+	    lnum += fold_count + 1;
+#else
+	    ++lnum;
+#endif
+	}
+	else
+	{
+	    if (wp->w_p_rnu && wp->w_last_cursor_lnum_rnu != wp->w_cursor.lnum)
+	    {
+#ifdef FEAT_FOLDING
+		// 'relativenumber' set and the cursor moved vertically: The
+		// text doesn't need to be drawn, but the number column does.
+		fold_count = foldedCount(wp, lnum, &win_foldinfo);
+		if (fold_count != 0)
+		    fold_line(wp, fold_count, &win_foldinfo, lnum, row);
+		else
+#endif
+		    (void)win_line(wp, lnum, srow, wp->w_height, TRUE, TRUE);
+	    }
+
+	    // This line does not need to be drawn, advance to the next one.
+	    row += wp->w_lines[idx++].wl_size;
+	    if (row > wp->w_height)	// past end of screen
+		break;
+#ifdef FEAT_FOLDING
+	    lnum = wp->w_lines[idx - 1].wl_lastlnum + 1;
+#else
+	    ++lnum;
+#endif
+#ifdef FEAT_SYN_HL
+	    did_update = DID_NONE;
+#endif
+	}
+
+	if (lnum > buf->b_ml.ml_line_count)
+	{
+	    eof = TRUE;
+	    break;
+	}
+
+	// Safety check: if any of the wl_size values is wrong we might go over
+	// the end of w_lines[].
+	if (idx >= Rows)
+	    break;
+    }
+
+    // End of loop over all window lines.
+
+#ifdef FEAT_SYN_HL
+    // Now that the window has been redrawn with the old and new cursor line,
+    // update w_last_cursorline.
+    wp->w_last_cursorline = wp->w_p_cul ? wp->w_cursor.lnum : 0;
+#endif
+    wp->w_last_cursor_lnum_rnu = wp->w_p_rnu ? wp->w_cursor.lnum : 0;
+
+#ifdef FEAT_VTP
+    // Rewrite the character at the end of the screen line.
+    // See the version that was fixed.
+    if (use_vtp() && get_conpty_fix_type() < 1)
+    {
+	int k;
+
+	for (k = 0; k < Rows; ++k)
+	    if (enc_utf8)
+		if ((*mb_off2cells)(LineOffset[k] + Columns - 2,
+					   LineOffset[k] + screen_Columns) > 1)
+		    screen_draw_rectangle(k, Columns - 2, 1, 2, FALSE);
+		else
+		    screen_draw_rectangle(k, Columns - 1, 1, 1, FALSE);
+	    else
+		screen_char(LineOffset[k] + Columns - 1, k, Columns - 1);
+    }
+#endif
+
+    if (idx > wp->w_lines_valid)
+	wp->w_lines_valid = idx;
+
+#ifdef FEAT_SYN_HL
+    // Let the syntax stuff know we stop parsing here.
+    if (syntax_last_parsed != 0 && syntax_present(wp))
+	syntax_end_parsing(wp, syntax_last_parsed + 1);
+#endif
+
+    // If we didn't hit the end of the file, and we didn't finish the last
+    // line we were working on, then the line didn't fit.
+    wp->w_empty_rows = 0;
+#ifdef FEAT_DIFF
+    wp->w_filler_rows = 0;
+#endif
+    if (!eof && !didline)
+    {
+	if (lnum == wp->w_topline)
+	{
+	    // Single line that does not fit!
+	    // Don't overwrite it, it can be edited.
+	    wp->w_botline = lnum + 1;
+	}
+#ifdef FEAT_DIFF
+	else if (diff_check_fill(wp, lnum) >= wp->w_height - srow)
+	{
+	    // Window ends in filler lines.
+	    wp->w_botline = lnum;
+	    wp->w_filler_rows = wp->w_height - srow;
+	}
+#endif
+#ifdef FEAT_PROP_POPUP
+	else if (WIN_IS_POPUP(wp))
+	{
+	    // popup line that doesn't fit is left as-is
+	    wp->w_botline = lnum;
+	}
+#endif
+	else if (dy_flags & DY_TRUNCATE)	// 'display' has "truncate"
+	{
+	    int		scr_row = W_WINROW(wp) + wp->w_height - 1;
+	    int		symbol  = wp->w_fill_chars.lastline;
+	    int		charlen;
+	    char_u	fillbuf[12];  // 2 characters of 6 bytes
+
+	    charlen = mb_char2bytes(symbol, &fillbuf[0]);
+	    mb_char2bytes(symbol, &fillbuf[charlen]);
+
+	    // Last line isn't finished: Display "@@@" in the last screen line.
+	    screen_puts_len(fillbuf,
+			    (wp->w_width > 2 ? 2 : wp->w_width) * charlen,
+			    scr_row, wp->w_wincol, HL_ATTR(HLF_AT));
+	    screen_fill(scr_row, scr_row + 1,
+		    (int)wp->w_wincol + 2, (int)W_ENDCOL(wp),
+		    symbol, ' ', HL_ATTR(HLF_AT));
+	    set_empty_rows(wp, srow);
+	    wp->w_botline = lnum;
+	}
+	else if (dy_flags & DY_LASTLINE)	// 'display' has "lastline"
+	{
+	    int start_col = (int)W_ENDCOL(wp) - 3;
+	    int symbol    = wp->w_fill_chars.lastline;
+
+	    // Last line isn't finished: Display "@@@" at the end.
+	    screen_fill(W_WINROW(wp) + wp->w_height - 1,
+		    W_WINROW(wp) + wp->w_height,
+		    start_col < wp->w_wincol ? wp->w_wincol : start_col,
+		    (int)W_ENDCOL(wp),
+		    symbol, symbol, HL_ATTR(HLF_AT));
+	    set_empty_rows(wp, srow);
+	    wp->w_botline = lnum;
+	}
+	else
+	{
+	    win_draw_end(wp, wp->w_fill_chars.lastline, ' ', TRUE,
+						   srow, wp->w_height, HLF_AT);
+	    wp->w_botline = lnum;
+	}
+    }
+    else
+    {
+	draw_vsep_win(wp, row);
+	if (eof)		// we hit the end of the file
+	{
+	    wp->w_botline = buf->b_ml.ml_line_count + 1;
+#ifdef FEAT_DIFF
+	    j = diff_check_fill(wp, wp->w_botline);
+	    if (j > 0 && !wp->w_botfill)
+	    {
+		// Display filler lines at the end of the file.
+		if (char2cells(wp->w_fill_chars.diff) > 1)
+		    i = '-';
+		else
+		    i = wp->w_fill_chars.diff;
+		if (row + j > wp->w_height)
+		    j = wp->w_height - row;
+		win_draw_end(wp, i, i, TRUE, row, row + (int)j, HLF_DED);
+		row += j;
+	    }
+#endif
+	}
+	else if (dollar_vcol == -1)
+	    wp->w_botline = lnum;
+
+	// Make sure the rest of the screen is blank.
+	// write the "eob" character from 'fillchars' to rows that aren't part
+	// of the file.
+	if (WIN_IS_POPUP(wp))
+	    win_draw_end(wp, ' ', ' ', FALSE, row, wp->w_height, HLF_AT);
+	else
+	    win_draw_end(wp, wp->w_fill_chars.eob, ' ', FALSE,
+						   row, wp->w_height, HLF_EOB);
+    }
+
+#ifdef SYN_TIME_LIMIT
+    disable_regexp_timeout();
+    redrawtime_limit_set = FALSE;
+#endif
+
+    // Reset the type of redrawing required, the window has been updated.
+    wp->w_redr_type = 0;
+#ifdef FEAT_DIFF
+    wp->w_old_topfill = wp->w_topfill;
+    wp->w_old_botfill = wp->w_botfill;
+#endif
+
+    if (dollar_vcol == -1)
+    {
+	// There is a trick with w_botline.  If we invalidate it on each
+	// change that might modify it, this will cause a lot of expensive
+	// calls to plines() in update_topline() each time.  Therefore the
+	// value of w_botline is often approximated, and this value is used to
+	// compute the value of w_topline.  If the value of w_botline was
+	// wrong, check that the value of w_topline is correct (cursor is on
+	// the visible part of the text).  If it's not, we need to redraw
+	// again.  Mostly this just means scrolling up a few lines, so it
+	// doesn't look too bad.  Only do this for the current window (where
+	// changes are relevant).
+	wp->w_valid |= VALID_BOTLINE;
+	if (wp == curwin && wp->w_botline != old_botline && !recursive)
+	{
+	    win_T	*wwp;
+#if defined(FEAT_CONCEAL)
+	    linenr_T	old_topline = wp->w_topline;
+	    int		new_wcol = wp->w_wcol;
+#endif
+	    recursive = TRUE;
+	    curwin->w_valid &= ~VALID_TOPLINE;
+	    update_topline();	// may invalidate w_botline again
+
+#if defined(FEAT_CONCEAL)
+	    if (old_wcol != new_wcol && (wp->w_valid & (VALID_WCOL|VALID_WROW))
+						    != (VALID_WCOL|VALID_WROW))
+	    {
+		// A win_line() call applied a fix to screen cursor column to
+		// accommodate concealment of cursor line, but in this call to
+		// update_topline() the cursor's row or column got invalidated.
+		// If they are left invalid, setcursor() will recompute them
+		// but there won't be any further win_line() call to re-fix the
+		// column and the cursor will end up misplaced.  So we call
+		// cursor validation now and reapply the fix again (or call
+		// win_line() to do it for us).
+		validate_cursor();
+		if (wp->w_wcol == old_wcol && wp->w_wrow == old_wrow
+					       && old_topline == wp->w_topline)
+		    wp->w_wcol = new_wcol;
+		else
+		    redrawWinline(wp, wp->w_cursor.lnum);
+	    }
+#endif
+	    // New redraw either due to updated topline or due to wcol fix.
+	    if (wp->w_redr_type != 0)
+	    {
+		// Don't update for changes in buffer again.
+		i = curbuf->b_mod_set;
+		curbuf->b_mod_set = FALSE;
+		j = curbuf->b_mod_xlines;
+		curbuf->b_mod_xlines = 0;
+		win_update(curwin);
+		curbuf->b_mod_set = i;
+		curbuf->b_mod_xlines = j;
+	    }
+	    // Other windows might have w_redr_type raised in update_topline().
+	    must_redraw = 0;
+	    FOR_ALL_WINDOWS(wwp)
+		if (wwp->w_redr_type > must_redraw)
+		    must_redraw = wwp->w_redr_type;
+	    recursive = FALSE;
+	}
+    }
+
+#if defined(FEAT_SYN_HL) || defined(FEAT_SEARCH_EXTRA)
+    // restore got_int, unless CTRL-C was hit while redrawing
+    if (!got_int)
+	got_int = save_got_int;
+#endif
+}
+
+#if defined(FEAT_NETBEANS_INTG) || defined(FEAT_GUI)
+/*
+ * Prepare for updating one or more windows.
+ * Caller must check for "updating_screen" already set to avoid recursiveness.
+ */
+    static void
+update_prepare(void)
+{
+    cursor_off();
+    updating_screen = TRUE;
+#ifdef FEAT_GUI
+    // Remove the cursor before starting to do anything, because scrolling may
+    // make it difficult to redraw the text under it.
+    if (gui.in_use)
+	gui_undraw_cursor();
+#endif
+#ifdef FEAT_SEARCH_EXTRA
+    start_search_hl();
+#endif
+#ifdef FEAT_PROP_POPUP
+    // Update popup_mask if needed.
+    may_update_popup_mask(must_redraw);
+#endif
+}
+
+/*
+ * Finish updating one or more windows.
+ */
+    static void
+update_finish(void)
+{
+    if (redraw_cmdline || redraw_mode)
+	showmode();
+
+# ifdef FEAT_SEARCH_EXTRA
+    end_search_hl();
+# endif
+
+    after_updating_screen(TRUE);
+
+# ifdef FEAT_GUI
+    // Redraw the cursor and update the scrollbars when all screen updating is
+    // done.
+    if (gui.in_use)
+    {
+	out_flush_cursor(FALSE, FALSE);
+	gui_update_scrollbars(FALSE);
+    }
+# endif
+}
+#endif
+
+#if defined(FEAT_NETBEANS_INTG) || defined(PROTO)
+    void
+update_debug_sign(buf_T *buf, linenr_T lnum)
+{
+    win_T	*wp;
+    int		doit = FALSE;
+
+# ifdef FEAT_FOLDING
+    win_foldinfo.fi_level = 0;
+# endif
+
+    // update/delete a specific sign
+    redraw_buf_line_later(buf, lnum);
+
+    // check if it resulted in the need to redraw a window
+    FOR_ALL_WINDOWS(wp)
+	if (wp->w_redr_type != 0)
+	    doit = TRUE;
+
+    // Return when there is nothing to do, screen updating is already
+    // happening (recursive call), messages on the screen or still starting up.
+    if (!doit || updating_screen
+	    || State == MODE_ASKMORE || State == MODE_HITRETURN
+	    || msg_scrolled
+#ifdef FEAT_GUI
+	    || gui.starting
+#endif
+	    || starting)
+	return;
+
+    // update all windows that need updating
+    update_prepare();
+
+    FOR_ALL_WINDOWS(wp)
+    {
+	if (wp->w_redr_type != 0)
+	    win_update(wp);
+	if (wp->w_redr_status)
+	    win_redr_status(wp, FALSE);
+    }
+
+    update_finish();
+}
+#endif
+
+#if defined(FEAT_GUI) || defined(PROTO)
+/*
+ * Update a single window, its status line and maybe the command line msg.
+ * Used for the GUI scrollbar.
+ */
+    void
+updateWindow(win_T *wp)
+{
+    // return if already busy updating
+    if (updating_screen)
+	return;
+
+    update_prepare();
+
+#ifdef FEAT_CLIPBOARD
+    // When Visual area changed, may have to update selection.
+    if (clip_star.available && clip_isautosel_star())
+	clip_update_selection(&clip_star);
+    if (clip_plus.available && clip_isautosel_plus())
+	clip_update_selection(&clip_plus);
+#endif
+
+    win_update(wp);
+
+    // When the screen was cleared redraw the tab pages line.
+    if (redraw_tabline)
+	draw_tabline();
+
+    if (wp->w_redr_status || p_ru
+# ifdef FEAT_STL_OPT
+	    || *p_stl != NUL || *wp->w_p_stl != NUL
+# endif
+	    )
+	win_redr_status(wp, FALSE);
+
+#ifdef FEAT_PROP_POPUP
+    // Display popup windows on top of everything.
+    update_popups(win_update);
+#endif
+
+    update_finish();
+}
+#endif
+
+/*
+ * Redraw as soon as possible.  When the command line is not scrolled redraw
+ * right away and restore what was on the command line.
+ * Return a code indicating what happened.
+ */
+    int
+redraw_asap(int type)
+{
+    int		rows;
+    int		cols = screen_Columns;
+    int		r;
+    int		ret = 0;
+    schar_T	*screenline;	// copy from ScreenLines[]
+    sattr_T	*screenattr;	// copy from ScreenAttrs[]
+    int		i;
+    u8char_T	*screenlineUC = NULL;	// copy from ScreenLinesUC[]
+    u8char_T	*screenlineC[MAX_MCO];	// copy from ScreenLinesC[][]
+    schar_T	*screenline2 = NULL;	// copy from ScreenLines2[]
+
+    redraw_later(type);
+    if (msg_scrolled
+	    || (State != MODE_NORMAL && State != MODE_NORMAL_BUSY)
+	    || exiting)
+	return ret;
+
+    // Allocate space to save the text displayed in the command line area.
+    rows = screen_Rows - cmdline_row;
+    screenline = LALLOC_MULT(schar_T, rows * cols);
+    screenattr = LALLOC_MULT(sattr_T, rows * cols);
+    if (screenline == NULL || screenattr == NULL)
+	ret = 2;
+    if (enc_utf8)
+    {
+	screenlineUC = LALLOC_MULT(u8char_T, rows * cols);
+	if (screenlineUC == NULL)
+	    ret = 2;
+	for (i = 0; i < p_mco; ++i)
+	{
+	    screenlineC[i] = LALLOC_MULT(u8char_T, rows * cols);
+	    if (screenlineC[i] == NULL)
+		ret = 2;
+	}
+    }
+    if (enc_dbcs == DBCS_JPNU)
+    {
+	screenline2 = LALLOC_MULT(schar_T, rows * cols);
+	if (screenline2 == NULL)
+	    ret = 2;
+    }
+
+    if (ret != 2)
+    {
+	// Save the text displayed in the command line area.
+	for (r = 0; r < rows; ++r)
+	{
+	    mch_memmove(screenline + r * cols,
+			ScreenLines + LineOffset[cmdline_row + r],
+			(size_t)cols * sizeof(schar_T));
+	    mch_memmove(screenattr + r * cols,
+			ScreenAttrs + LineOffset[cmdline_row + r],
+			(size_t)cols * sizeof(sattr_T));
+	    if (enc_utf8)
+	    {
+		mch_memmove(screenlineUC + r * cols,
+			    ScreenLinesUC + LineOffset[cmdline_row + r],
+			    (size_t)cols * sizeof(u8char_T));
+		for (i = 0; i < p_mco; ++i)
+		    mch_memmove(screenlineC[i] + r * cols,
+				ScreenLinesC[i] + LineOffset[cmdline_row + r],
+				(size_t)cols * sizeof(u8char_T));
+	    }
+	    if (enc_dbcs == DBCS_JPNU)
+		mch_memmove(screenline2 + r * cols,
+			    ScreenLines2 + LineOffset[cmdline_row + r],
+			    (size_t)cols * sizeof(schar_T));
+	}
+
+	update_screen(0);
+	ret = 3;
+
+	if (must_redraw == 0)
+	{
+	    int	off = (int)(current_ScreenLine - ScreenLines);
+
+	    // Restore the text displayed in the command line area.
+	    for (r = 0; r < rows; ++r)
+	    {
+		mch_memmove(current_ScreenLine,
+			    screenline + r * cols,
+			    (size_t)cols * sizeof(schar_T));
+		mch_memmove(ScreenAttrs + off,
+			    screenattr + r * cols,
+			    (size_t)cols * sizeof(sattr_T));
+		if (enc_utf8)
+		{
+		    mch_memmove(ScreenLinesUC + off,
+				screenlineUC + r * cols,
+				(size_t)cols * sizeof(u8char_T));
+		    for (i = 0; i < p_mco; ++i)
+			mch_memmove(ScreenLinesC[i] + off,
+				    screenlineC[i] + r * cols,
+				    (size_t)cols * sizeof(u8char_T));
+		}
+		if (enc_dbcs == DBCS_JPNU)
+		    mch_memmove(ScreenLines2 + off,
+				screenline2 + r * cols,
+				(size_t)cols * sizeof(schar_T));
+		screen_line(curwin, cmdline_row + r, 0, cols, cols, 0);
+	    }
+	    ret = 4;
+	}
+    }
+
+    vim_free(screenline);
+    vim_free(screenattr);
+    if (enc_utf8)
+    {
+	vim_free(screenlineUC);
+	for (i = 0; i < p_mco; ++i)
+	    vim_free(screenlineC[i]);
+    }
+    if (enc_dbcs == DBCS_JPNU)
+	vim_free(screenline2);
+
+    // Show the intro message when appropriate.
+    maybe_intro_message();
+
+    setcursor();
+
+    return ret;
+}
+
+/*
+ * Invoked after an asynchronous callback is called.
+ * If an echo command was used the cursor needs to be put back where
+ * it belongs. If highlighting was changed a redraw is needed.
+ * If "call_update_screen" is FALSE don't call update_screen() when at the
+ * command line.
+ * If "redraw_message" is TRUE.
+ */
+    void
+redraw_after_callback(int call_update_screen, int do_message)
+{
+    ++redrawing_for_callback;
+
+    if (State == MODE_HITRETURN || State == MODE_ASKMORE
+	    || State == MODE_SETWSIZE || State == MODE_EXTERNCMD
+	    || State == MODE_CONFIRM || exmode_active)
+    {
+	if (do_message)
+	    repeat_message();
+    }
+    else if (State & MODE_CMDLINE)
+    {
+	if (pum_visible())
+	    cmdline_pum_display();
+
+	// Don't redraw when in prompt_for_number().
+	if (cmdline_row > 0)
+	{
+	    // Redrawing only works when the screen didn't scroll. Don't clear
+	    // wildmenu entries.
+	    if (msg_scrolled == 0
+		    && wild_menu_showing == 0
+		    && call_update_screen)
+		update_screen(0);
+
+	    // Redraw in the same position, so that the user can continue
+	    // editing the command.
+	    redrawcmdline_ex(FALSE);
+	}
+    }
+    else if (State & (MODE_NORMAL | MODE_INSERT | MODE_TERMINAL))
+    {
+	update_topline();
+	validate_cursor();
+
+	// keep the command line if possible
+	update_screen(UPD_VALID_NO_UPDATE);
+	setcursor();
+
+	if (msg_scrolled == 0)
+	{
+	    // don't want a hit-enter prompt when something else is displayed
+	    msg_didany = FALSE;
+	    need_wait_return = FALSE;
+	}
+    }
+    cursor_on();
+#ifdef FEAT_GUI
+    if (gui.in_use && !gui_mch_is_blink_off())
+	// Don't update the cursor when it is blinking and off to avoid
+	// flicker.
+	out_flush_cursor(FALSE, FALSE);
+    else
+#endif
+	out_flush();
+
+    --redrawing_for_callback;
+}
+
+/*
+ * Redraw the current window later, with update_screen(type).
+ * Set must_redraw only if not already set to a higher value.
+ * E.g. if must_redraw is UPD_CLEAR, type UPD_NOT_VALID will do nothing.
+ */
+    void
+redraw_later(int type)
+{
+    redraw_win_later(curwin, type);
+}
+
+    void
+redraw_win_later(
+    win_T	*wp,
+    int		type)
+{
+    if (!exiting && !redraw_not_allowed && wp->w_redr_type < type)
+    {
+	wp->w_redr_type = type;
+	if (type >= UPD_NOT_VALID)
+	    wp->w_lines_valid = 0;
+	if (must_redraw < type)	// must_redraw is the maximum of all windows
+	    must_redraw = type;
+    }
+}
+
+/*
+ * Force a complete redraw later.  Also resets the highlighting.  To be used
+ * after executing a shell command that messes up the screen.
+ */
+    void
+redraw_later_clear(void)
+{
+    redraw_all_later(UPD_CLEAR);
+    reset_screen_attr();
+}
+
+/*
+ * Mark all windows to be redrawn later.  Except popup windows.
+ */
+    void
+redraw_all_later(int type)
+{
+    win_T	*wp;
+
+    FOR_ALL_WINDOWS(wp)
+	redraw_win_later(wp, type);
+    // This may be needed when switching tabs.
+    set_must_redraw(type);
+}
+
+#if 0  // not actually used yet, it probably should
+/*
+ * Mark all windows, including popup windows, to be redrawn.
+ */
+    void
+redraw_all_windows_later(int type)
+{
+    redraw_all_later(type);
+#ifdef FEAT_PROP_POPUP
+    popup_redraw_all();		// redraw all popup windows
+#endif
+}
+#endif
+
+/*
+ * Set "must_redraw" to "type" unless it already has a higher value
+ * or it is currently not allowed.
+ */
+    void
+set_must_redraw(int type)
+{
+    if (!redraw_not_allowed && must_redraw < type)
+	must_redraw = type;
+}
+
+/*
+ * Mark all windows that are editing the current buffer to be updated later.
+ */
+    void
+redraw_curbuf_later(int type)
+{
+    redraw_buf_later(curbuf, type);
+}
+
+    void
+redraw_buf_later(buf_T *buf, int type)
+{
+    win_T	*wp;
+
+    FOR_ALL_WINDOWS(wp)
+    {
+	if (wp->w_buffer == buf)
+	    redraw_win_later(wp, type);
+    }
+#if defined(FEAT_TERMINAL) && defined(FEAT_PROP_POPUP)
+    // terminal in popup window is not in list of windows
+    if (curwin->w_buffer == buf)
+	redraw_win_later(curwin, type);
+#endif
+}
+
+#if defined(FEAT_SIGNS) || defined(PROTO)
+    void
+redraw_buf_line_later(buf_T *buf, linenr_T lnum)
+{
+    win_T	*wp;
+
+    FOR_ALL_WINDOWS(wp)
+	if (wp->w_buffer == buf && lnum >= wp->w_topline
+						  && lnum < wp->w_botline)
+	    redrawWinline(wp, lnum);
+}
+#endif
+
+#if defined(FEAT_JOB_CHANNEL) || defined(PROTO)
+    void
+redraw_buf_and_status_later(buf_T *buf, int type)
+{
+    win_T	*wp;
+
+    if (wild_menu_showing != 0)
+	// Don't redraw while the command line completion is displayed, it
+	// would disappear.
+	return;
+    FOR_ALL_WINDOWS(wp)
+    {
+	if (wp->w_buffer == buf)
+	{
+	    redraw_win_later(wp, type);
+	    wp->w_redr_status = TRUE;
+	}
+    }
+}
+#endif
+
+/*
+ * mark all status lines for redraw; used after first :cd
+ */
+    void
+status_redraw_all(void)
+{
+    win_T	*wp;
+
+    FOR_ALL_WINDOWS(wp)
+	if (wp->w_status_height)
+	{
+	    wp->w_redr_status = TRUE;
+	    redraw_later(UPD_VALID);
+	}
+}
+
+/*
+ * mark all status lines of the current buffer for redraw
+ */
+    void
+status_redraw_curbuf(void)
+{
+    win_T	*wp;
+
+    FOR_ALL_WINDOWS(wp)
+	if (wp->w_status_height != 0 && wp->w_buffer == curbuf)
+	{
+	    wp->w_redr_status = TRUE;
+	    redraw_later(UPD_VALID);
+	}
+}
+
+/*
+ * Redraw all status lines that need to be redrawn.
+ */
+    void
+redraw_statuslines(void)
+{
+    win_T	*wp;
+
+    FOR_ALL_WINDOWS(wp)
+	if (wp->w_redr_status)
+	    win_redr_status(wp, FALSE);
+    if (redraw_tabline)
+	draw_tabline();
+}
+
+/*
+ * Redraw all status lines at the bottom of frame "frp".
+ */
+    void
+win_redraw_last_status(frame_T *frp)
+{
+    if (frp->fr_layout == FR_LEAF)
+	frp->fr_win->w_redr_status = TRUE;
+    else if (frp->fr_layout == FR_ROW)
+    {
+	FOR_ALL_FRAMES(frp, frp->fr_child)
+	    win_redraw_last_status(frp);
+    }
+    else // frp->fr_layout == FR_COL
+    {
+	frp = frp->fr_child;
+	while (frp->fr_next != NULL)
+	    frp = frp->fr_next;
+	win_redraw_last_status(frp);
+    }
+}
+
+/*
+ * Changed something in the current window, at buffer line "lnum", that
+ * requires that line and possibly other lines to be redrawn.
+ * Used when entering/leaving Insert mode with the cursor on a folded line.
+ * Used to remove the "$" from a change command.
+ * Note that when also inserting/deleting lines w_redraw_top and w_redraw_bot
+ * may become invalid and the whole window will have to be redrawn.
+ */
+    void
+redrawWinline(
+    win_T	*wp,
+    linenr_T	lnum)
+{
+    if (wp->w_redraw_top == 0 || wp->w_redraw_top > lnum)
+	wp->w_redraw_top = lnum;
+    if (wp->w_redraw_bot == 0 || wp->w_redraw_bot < lnum)
+	wp->w_redraw_bot = lnum;
+    redraw_win_later(wp, UPD_VALID);
+}