new file mode 100644
--- /dev/null
+++ b/src/screen.c
@@ -0,0 +1,8437 @@
+/* vi:set ts=8 sts=4 sw=4:
+ *
+ * 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.
+ */
+
+/*
+ * screen.c: code for displaying on the screen
+ *
+ * Output to the screen (console, terminal emulator or GUI window) is minimized
+ * by remembering what is already on the screen, and only updating the parts
+ * that changed.
+ *
+ * ScreenLines[off]  Contains a copy of the whole screen, as it is currently
+ *		     displayed (excluding text written by external commands).
+ * ScreenAttrs[off]  Contains the associated attributes.
+ * LineOffset[row]   Contains the offset into ScreenLines*[] and ScreenAttrs[]
+ *		     for each line.
+ * LineWraps[row]    Flag for each line whether it wraps to the next line.
+ *
+ * For double-byte characters, two consecutive bytes in ScreenLines[] can form
+ * one character which occupies two display cells.
+ * For UTF-8 a multi-byte character is converted to Unicode and stored in
+ * ScreenLinesUC[].  ScreenLines[] contains the first byte only.  For an ASCII
+ * character without composing chars ScreenLinesUC[] will be 0.  When the
+ * character occupies two display cells the next byte in ScreenLines[] is 0.
+ * ScreenLinesC1[] and ScreenLinesC2[] contain up to two composing characters
+ * (drawn on top of the first character).  They are 0 when not used.
+ * ScreenLines2[] is only used for euc-jp to store the second byte if the
+ * first byte is 0x8e (single-width character).
+ *
+ * The screen_*() functions write to the screen and handle updating
+ * ScreenLines[].
+ *
+ * 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 immediated 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 line 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(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(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(NOT_VALID) to have all the windows for the
+ * buffer redisplayed by update_screen() later.
+ *
+ * Commands that move the window position must call redraw_later(NOT_VALID).
+ * TODO: should minimize redrawing by scrolling when possible.
+ *
+ * Commands that change everything (e.g., resizing the screen) must call
+ * redraw_all_later(NOT_VALID) or redraw_all_later(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"
+
+/*
+ * The attributes that are actually active for writing to the screen.
+ */
+static int	screen_attr = 0;
+
+/*
+ * Positioning the cursor is reduced by remembering the last position.
+ * Mostly used by windgoto() and screen_char().
+ */
+static int	screen_cur_row, screen_cur_col;	/* last known cursor position */
+
+#ifdef FEAT_SEARCH_EXTRA
+/*
+ * Struct used for highlighting 'hlsearch' matches for the last use search
+ * pattern or a ":match" item.
+ * For 'hlsearch' there is one pattern for all windows.  For ":match" there is
+ * a different pattern for each window.
+ */
+typedef struct
+{
+    regmmatch_T	rm;	/* points to the regexp program; contains last found
+			   match (may continue in next line) */
+    buf_T	*buf;	/* the buffer to search for a match */
+    linenr_T	lnum;	/* the line to search for a match */
+    int		attr;	/* attributes to be used for a match */
+    int		attr_cur; /* attributes currently active in win_line() */
+    linenr_T	first_lnum;	/* first lnum to search for multi-line pat */
+    char_u	*startp; /* in win_line() points to char where HL starts */
+    char_u	*endp;	 /* in win_line() points to char where HL ends */
+} match_T;
+
+static match_T search_hl;	/* used for 'hlsearch' highlight matching */
+static match_T match_hl;	/* used for ":match" highlight matching */
+#endif
+
+#ifdef FEAT_FOLDING
+static foldinfo_T win_foldinfo;	/* info for 'foldcolumn' */
+#endif
+
+/*
+ * Buffer for one screen line (characters and attributes).
+ */
+static schar_T	*current_ScreenLine;
+
+static void win_update __ARGS((win_T *wp));
+static void win_draw_end __ARGS((win_T *wp, int c1, int c2, int row, int endrow, enum hlf_value hl));
+#ifdef FEAT_FOLDING
+static void fold_line __ARGS((win_T *wp, long fold_count, foldinfo_T *foldinfo, linenr_T lnum, int row));
+static void fill_foldcolumn __ARGS((char_u *p, win_T *wp, int closed, linenr_T lnum));
+static void copy_text_attr __ARGS((int off, char_u *buf, int len, int attr));
+#endif
+static int win_line __ARGS((win_T *, linenr_T, int, int));
+static int char_needs_redraw __ARGS((int off_from, int off_to, int cols));
+#ifdef FEAT_RIGHTLEFT
+static void screen_line __ARGS((int row, int coloff, int endcol, int clear_width, int rlflag));
+# define SCREEN_LINE(r, o, e, c, rl)    screen_line((r), (o), (e), (c), (rl))
+#else
+static void screen_line __ARGS((int row, int coloff, int endcol, int clear_width));
+# define SCREEN_LINE(r, o, e, c, rl)    screen_line((r), (o), (e), (c))
+#endif
+#ifdef FEAT_RIGHTLEFT
+static void rl_mirror __ARGS((char_u *str));
+#endif
+#ifdef FEAT_VERTSPLIT
+static void draw_vsep_win __ARGS((win_T *wp, int row));
+#endif
+#ifdef FEAT_SEARCH_EXTRA
+static void start_search_hl __ARGS((void));
+static void end_search_hl __ARGS((void));
+static void prepare_search_hl __ARGS((win_T *wp, linenr_T lnum));
+static void next_search_hl __ARGS((win_T *win, match_T *shl, linenr_T lnum, colnr_T mincol));
+#endif
+static void screen_start_highlight __ARGS((int attr));
+static void screen_char __ARGS((unsigned off, int row, int col));
+#ifdef FEAT_MBYTE
+static void screen_char_2 __ARGS((unsigned off, int row, int col));
+#endif
+static void screenclear2 __ARGS((void));
+static void lineclear __ARGS((unsigned off, int width));
+static void lineinvalid __ARGS((unsigned off, int width));
+#ifdef FEAT_VERTSPLIT
+static void linecopy __ARGS((int to, int from, win_T *wp));
+static void redraw_block __ARGS((int row, int end, win_T *wp));
+#endif
+static int win_do_lines __ARGS((win_T *wp, int row, int line_count, int mayclear, int del));
+static void win_rest_invalid __ARGS((win_T *wp));
+static int screen_ins_lines __ARGS((int, int, int, int, win_T *wp));
+static void msg_pos_mode __ARGS((void));
+#if defined(FEAT_WINDOWS) || defined(FEAT_WILDMENU) || defined(FEAT_STL_OPT)
+static int fillchar_status __ARGS((int *attr, int is_curwin));
+#endif
+#ifdef FEAT_VERTSPLIT
+static int fillchar_vsep __ARGS((int *attr));
+#endif
+#ifdef FEAT_STL_OPT
+static void win_redr_custom __ARGS((win_T *wp, int Ruler));
+#endif
+#ifdef FEAT_CMDL_INFO
+static void win_redr_ruler __ARGS((win_T *wp, int always));
+#endif
+
+#if defined(FEAT_CLIPBOARD) || defined(FEAT_VERTSPLIT)
+/* Ugly global: overrule attribute used by screen_char() */
+static int screen_char_attr = 0;
+#endif
+
+/*
+ * 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 CLEAR, type NOT_VALID will do nothing.
+ */
+    void
+redraw_later(type)
+    int		type;
+{
+    redraw_win_later(curwin, type);
+}
+
+    void
+redraw_win_later(wp, type)
+    win_T	*wp;
+    int		type;
+{
+    if (wp->w_redr_type < type)
+    {
+	wp->w_redr_type = type;
+	if (type >= 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()
+{
+    redraw_all_later(CLEAR);
+    screen_attr = HL_BOLD | HL_UNDERLINE;
+}
+
+/*
+ * Mark all windows to be redrawn later.
+ */
+    void
+redraw_all_later(type)
+    int		type;
+{
+    win_T	*wp;
+
+    FOR_ALL_WINDOWS(wp)
+    {
+	redraw_win_later(wp, type);
+    }
+}
+
+/*
+ * Mark all windows that are editing the current buffer to be udpated later.
+ */
+    void
+redraw_curbuf_later(type)
+    int		type;
+{
+    redraw_buf_later(curbuf, type);
+}
+
+    void
+redraw_buf_later(buf, type)
+    buf_T	*buf;
+    int		type;
+{
+    win_T	*wp;
+
+    FOR_ALL_WINDOWS(wp)
+    {
+	if (wp->w_buffer == buf)
+	    redraw_win_later(wp, type);
+    }
+}
+
+/*
+ * 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.
+ */
+/*ARGSUSED*/
+    void
+redrawWinline(lnum, invalid)
+    linenr_T	lnum;
+    int		invalid;	/* window line height is invalid now */
+{
+#ifdef FEAT_FOLDING
+    int		i;
+#endif
+
+    if (curwin->w_redraw_top == 0 || curwin->w_redraw_top > lnum)
+	curwin->w_redraw_top = lnum;
+    if (curwin->w_redraw_bot == 0 || curwin->w_redraw_bot < lnum)
+	curwin->w_redraw_bot = lnum;
+    redraw_later(VALID);
+
+#ifdef FEAT_FOLDING
+    if (invalid)
+    {
+	/* A w_lines[] entry for this lnum has become invalid. */
+	i = find_wl_entry(curwin, lnum);
+	if (i >= 0)
+	    curwin->w_lines[i].wl_valid = FALSE;
+    }
+#endif
+}
+
+/*
+ * update all windows that are editing the current buffer
+ */
+    void
+update_curbuf(type)
+    int		type;
+{
+    redraw_curbuf_later(type);
+    update_screen(type);
+}
+
+/*
+ * update_screen()
+ *
+ * Based on the current value of curwin->w_topline, transfer a screenfull
+ * of stuff from Filemem to ScreenLines[], and update curwin->w_botline.
+ */
+    void
+update_screen(type)
+    int		type;
+{
+    win_T	*wp;
+    static int	did_intro = FALSE;
+#if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD)
+    int		did_one;
+#endif
+
+    if (!screen_valid(TRUE))
+	return;
+
+    if (must_redraw)
+    {
+	if (type < must_redraw)	    /* use maximal type */
+	    type = must_redraw;
+	must_redraw = 0;
+    }
+
+    /* Need to update w_lines[]. */
+    if (curwin->w_lines_valid == 0 && type < NOT_VALID)
+	type = NOT_VALID;
+
+    if (!redrawing())
+    {
+	redraw_later(type);		/* remember type for next time */
+	must_redraw = type;
+	if (type > INVERTED_ALL)
+	    curwin->w_lines_valid = 0;	/* don't use w_lines[].wl_size now */
+	return;
+    }
+
+    updating_screen = TRUE;
+#ifdef FEAT_SYN_HL
+    ++display_tick;	    /* let syntax code know we're in a next round of
+			     * display updating */
+#endif
+
+    /*
+     * if the screen was scrolled up when displaying a message, scroll it down
+     */
+    if (msg_scrolled)
+    {
+	clear_cmdline = TRUE;
+	if (msg_scrolled > Rows - 5)	    /* clearing is faster */
+	    type = CLEAR;
+	else if (type != CLEAR)
+	{
+	    check_for_delay(FALSE);
+	    if (screen_ins_lines(0, 0, msg_scrolled, (int)Rows, NULL) == FAIL)
+		type = CLEAR;
+	    FOR_ALL_WINDOWS(wp)
+	    {
+		if (W_WINROW(wp) < msg_scrolled)
+		{
+		    if (W_WINROW(wp) + wp->w_height > msg_scrolled
+			    && wp->w_redr_type < 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 = REDRAW_TOP;
+		    }
+		    else
+		    {
+			wp->w_redr_type = NOT_VALID;
+#ifdef FEAT_WINDOWS
+			if (W_WINROW(wp) + wp->w_height + W_STATUS_HEIGHT(wp)
+				<= msg_scrolled)
+			    wp->w_redr_status = TRUE;
+#endif
+		    }
+		}
+	    }
+	    redraw_cmdline = 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 == CLEAR)		/* first clear screen */
+    {
+	screenclear();		/* will reset clear_cmdline */
+	type = NOT_VALID;
+    }
+
+    if (clear_cmdline)		/* going to clear cmdline (done below) */
+	check_for_delay(FALSE);
+
+    /*
+     * Only start redrawing if there is really something to do.
+     */
+    if (type == INVERTED)
+	update_curswant();
+    if (curwin->w_redr_type < type
+	    && !((type == 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)
+#ifdef FEAT_VISUAL
+		|| (type == INVERTED
+		    && 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)
+#endif
+		))
+	curwin->w_redr_type = type;
+
+#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)
+	{
+# ifdef FEAT_WINDOWS
+	    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;
+# endif
+	    if (
+# ifdef FEAT_WINDOWS
+		    wwp == wp &&
+# endif
+		    syntax_present(wp->w_buffer))
+		syn_stack_apply_changes(wp->w_buffer);
+	}
+    }
+#endif
+
+    /*
+     * Go from top to bottom through the windows, redrawing the ones that need
+     * it.
+     */
+#if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD)
+    did_one = FALSE;
+#endif
+#ifdef FEAT_SEARCH_EXTRA
+    search_hl.rm.regprog = NULL;
+#endif
+    FOR_ALL_WINDOWS(wp)
+    {
+	if (wp->w_redr_type != 0)
+	{
+	    cursor_off();
+#if defined(FEAT_SEARCH_EXTRA) || defined(FEAT_CLIPBOARD)
+	    if (!did_one)
+	    {
+		did_one = 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())
+		    clip_update_selection();
+# endif
+#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
+	    }
+#endif
+	    win_update(wp);
+	}
+
+#ifdef FEAT_WINDOWS
+	/* redraw status line after the window to minimize cursor movement */
+	if (wp->w_redr_status)
+	{
+	    cursor_off();
+	    win_redr_status(wp);
+	}
+#endif
+    }
+#if defined(FEAT_SEARCH_EXTRA)
+    end_search_hl();
+#endif
+
+#ifdef FEAT_WINDOWS
+    /* Reset b_mod_set flags.  Going through all windows is probably faster
+     * than going through all buffers (there could be many buffers). */
+    for (wp = firstwin; wp != NULL; wp = wp->w_next)
+	wp->w_buffer->b_mod_set = FALSE;
+#else
+	curbuf->b_mod_set = FALSE;
+#endif
+
+    updating_screen = FALSE;
+#ifdef FEAT_GUI
+    gui_may_resize_shell();
+#endif
+
+    /* Clear or redraw the command line.  Done last, because scrolling may
+     * mess up the command line. */
+    if (clear_cmdline || redraw_cmdline)
+	showmode();
+
+    /* May put up an introductory message when not editing a file */
+    if (!did_intro && bufempty()
+	    && curbuf->b_fname == NULL
+#ifdef FEAT_WINDOWS
+	    && firstwin->w_next == NULL
+#endif
+	    && vim_strchr(p_shm, SHM_INTRO) == NULL)
+	intro_message(FALSE);
+    did_intro = TRUE;
+
+#ifdef FEAT_GUI
+    /* Redraw the cursor and update the scrollbars when all screen updating is
+     * done. */
+    if (gui.in_use)
+    {
+	out_flush();	/* required before updating the cursor */
+	if (did_one)
+	    gui_update_cursor(FALSE, FALSE);
+	gui_update_scrollbars(FALSE);
+    }
+#endif
+}
+
+#if defined(FEAT_SIGNS) || defined(FEAT_GUI)
+static void update_prepare __ARGS((void));
+static void update_finish __ARGS((void));
+
+/*
+ * Prepare for updating one or more windows.
+ */
+    static void
+update_prepare()
+{
+    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
+}
+
+/*
+ * Finish updating one or more windows.
+ */
+    static void
+update_finish()
+{
+    if (redraw_cmdline)
+	showmode();
+
+# ifdef FEAT_SEARCH_EXTRA
+    end_search_hl();
+# endif
+
+    updating_screen = FALSE;
+
+# ifdef FEAT_GUI
+    gui_may_resize_shell();
+
+    /* Redraw the cursor and update the scrollbars when all screen updating is
+     * done. */
+    if (gui.in_use)
+    {
+	out_flush();	/* required before updating the cursor */
+	gui_update_cursor(FALSE, FALSE);
+	gui_update_scrollbars(FALSE);
+    }
+# endif
+}
+#endif
+
+#if defined(FEAT_SIGNS) || defined(PROTO)
+    void
+update_debug_sign(buf, lnum)
+    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 mark */
+    FOR_ALL_WINDOWS(wp)
+    {
+	if (buf != NULL && lnum > 0)
+	{
+	    if (wp->w_buffer == buf && lnum >= wp->w_topline
+						      && lnum < wp->w_botline)
+	    {
+		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, VALID);
+	    }
+	}
+	else
+	    redraw_win_later(wp, VALID);
+	if (wp->w_redr_type != 0)
+	    doit = TRUE;
+    }
+
+    if (!doit)
+	return;
+
+    /* update all windows that need updating */
+    update_prepare();
+
+# ifdef FEAT_WINDOWS
+    for (wp = firstwin; wp; wp = wp->w_next)
+    {
+	if (wp->w_redr_type != 0)
+	    win_update(wp);
+	if (wp->w_redr_status)
+	    win_redr_status(wp);
+    }
+# else
+    if (curwin->w_redr_type != 0)
+	win_update(curwin);
+# endif
+
+    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(wp)
+    win_T	*wp;
+{
+    update_prepare();
+
+#ifdef FEAT_CLIPBOARD
+    /* When Visual area changed, may have to update selection. */
+    if (clip_star.available && clip_isautosel())
+	clip_update_selection();
+#endif
+    win_update(wp);
+#ifdef FEAT_WINDOWS
+    if (wp->w_redr_status
+# ifdef FEAT_CMDL_INFO
+	    || p_ru
+# endif
+# ifdef FEAT_STL_OPT
+	    || *p_stl
+# endif
+	    )
+	win_redr_status(wp);
+#endif
+
+    update_finish();
+}
+#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.
+ * NOT_VALID	redraw the whole window
+ * REDRAW_TOP	redraw the top w_upd_rows window lines, otherwise like VALID
+ * INVERTED	redraw the changed part of the Visual area
+ * INVERTED_ALL	redraw the whole Visual area
+ * 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, udpate 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(wp)
+    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 */
+#ifdef FEAT_VISUAL
+    int		scrolled_down = FALSE;	/* TRUE when scrolled down when
+					   w_topline got smaller a bit */
+#endif
+#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 */
+    int		old_botline = wp->w_botline;
+#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
+
+    type = wp->w_redr_type;
+
+    if (type == NOT_VALID)
+    {
+#ifdef FEAT_WINDOWS
+	wp->w_redr_status = TRUE;
+#endif
+	wp->w_lines_valid = 0;
+    }
+
+    /* Window is zero-height: nothing to draw. */
+    if (wp->w_height == 0)
+    {
+	wp->w_redr_type = 0;
+	return;
+    }
+
+#ifdef FEAT_VERTSPLIT
+    /* 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;
+    }
+#endif
+
+#ifdef FEAT_SEARCH_EXTRA
+    /* Setup for ":match" highlighting.  Disable any previous match */
+    match_hl.rm = wp->w_match;
+    if (wp->w_match_id == 0)
+	match_hl.attr = 0;
+    else
+	match_hl.attr = syn_id2attr(wp->w_match_id);
+    match_hl.buf = buf;
+    match_hl.lnum = 0;
+    search_hl.buf = buf;
+    search_hl.lnum = 0;
+    search_hl.first_lnum = 0;
+#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 = 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;
+	wp->w_redraw_top = 0;	/* reset for next time */
+	wp->w_redraw_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(buf))
+		{
+		    mod_top -= buf->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 ((search_hl.rm.regprog != NULL
+			&& re_multiline(search_hl.rm.regprog))
+		    || (match_hl.rm.regprog != NULL
+			&& re_multiline(match_hl.rm.regprog)))
+		top_to_mod = TRUE;
+#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 (wp->w_p_fdc > 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 changes was
+	 * maded, 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(buf))
+		top_end = 1;
+#endif
+	}
+    }
+
+    /*
+     * When only displaying the lines at the top, set top_end.  Used when
+     * window has scrolled down for msg_scrolled.
+     */
+    if (type == 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 = NOT_VALID;
+	else
+	    /* top area defined, the rest is VALID */
+	    type = VALID;
+    }
+
+    /*
+     * 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 == VALID || type == INVERTED || type == INVERTED_ALL)
+#ifdef FEAT_DIFF
+	    && !wp->w_botfill && !wp->w_old_botfill
+#endif
+	    )
+    {
+	if (mod_top != 0 && wp->w_topline == mod_top)
+	{
+	    /*
+	     * w_topline is the first changed line, the scrolling 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;
+#ifdef FEAT_VISUAL
+			    scrolled_down = TRUE;
+#endif
+
+			    /* 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 */
+	    j = -1;
+	    row = 0;
+	    for (i = 0; i < wp->w_lines_valid; 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 > 0)
+		{
+		    check_for_delay(FALSE);
+		    if (win_del_lines(wp, 0, row, FALSE, wp == firstwin) == 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.  When
+	 * there is only one window it's probably faster to clear the screen
+	 * first. */
+	if (mid_start == 0)
+	{
+	    mid_end = wp->w_height;
+	    if (lastwin == firstwin)
+		screenclear();
+	}
+    }
+    else
+    {
+	/* Not VALID or INVERTED: redraw all lines. */
+	mid_start = 0;
+	mid_end = wp->w_height;
+    }
+
+#ifdef FEAT_VISUAL
+    /* check if we are updating or removing the inverted part */
+    if ((VIsual_active && buf == curwin->w_buffer)
+	    || (wp->w_old_cursor_lnum != 0 && type != NOT_VALID))
+    {
+	linenr_T    from, to;
+
+	if (VIsual_active)
+	{
+	    if (VIsual_active
+		    && (VIsual_mode != wp->w_old_visual_mode
+			|| type == 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)
+		{
+		    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;
+
+		getvcols(wp, &VIsual, &curwin->w_cursor, &fromc, &toc);
+		++toc;
+		if (curwin->w_curswant == MAXCOL)
+		    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_curswant = curwin->w_curswant;
+    }
+    else
+    {
+	wp->w_old_visual_mode = 0;
+	wp->w_old_cursor_lnum = 0;
+	wp->w_old_visual_lnum = 0;
+    }
+#endif /* FEAT_VISUAL */
+
+#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 FEAT_FOLDING
+    win_foldinfo.fi_level = 0;
+#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(buf)
+				    && (
+# ifdef FEAT_FOLDING
+					(foldmethodIsSyntax(wp)
+						      && hasAnyFolding(wp)) ||
+# endif
+					syntax_check_changed(lnum)))
+#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 is non-zero, keep the "$".
+	     */
+	    if (lnum == mod_top
+		    && mod_bot != MAXLNUM
+		    && !(dollar_vcol != 0 && mod_bot == mod_top + 1))
+	    {
+		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) == 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;
+			    }
+			}
+		    }
+		}
+
+		/* When inserting or deleting lines and 'number' is set:
+		 * Redraw all lines below the change to update the line
+		 * numbers. */
+		if (buf->b_mod_xlines != 0 && wp->w_p_nu)
+		    bot_start = 0;
+	    }
+
+#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)
+		    && 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, 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(buf))
+		    syntax_end_parsing(syntax_last_parsed + 1);
+#endif
+
+		/*
+		 * Display one line.
+		 */
+		row = win_line(wp, lnum, srow, wp->w_height);
+
+#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;
+	    if (row > wp->w_height)	/* past end of screen */
+	    {
+		/* we may need the size of that too long line later on */
+		if (dollar_vcol == 0)
+		    wp->w_lines[idx].wl_size = plines_win(wp, lnum, TRUE);
+		++idx;
+		break;
+	    }
+	    if (dollar_vcol == 0)
+		wp->w_lines[idx].wl_size = row - srow;
+	    ++idx;
+#ifdef FEAT_FOLDING
+	    lnum += fold_count + 1;
+#else
+	    ++lnum;
+#endif
+	}
+	else
+	{
+	    /* This line does not need updating, 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;
+	}
+    }
+    /*
+     * End of loop over all window lines.
+     */
+
+
+    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(buf))
+	syntax_end_parsing(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
+	else if (dy_flags & DY_LASTLINE)	/* 'display' has "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,
+		    (int)W_ENDCOL(wp) - 3, (int)W_ENDCOL(wp),
+		    '@', '@', hl_attr(HLF_AT));
+	    set_empty_rows(wp, srow);
+	    wp->w_botline = lnum;
+	}
+	else
+	{
+	    win_draw_end(wp, '@', ' ', srow, wp->w_height, HLF_AT);
+	    wp->w_botline = lnum;
+	}
+    }
+    else
+    {
+#ifdef FEAT_VERTSPLIT
+	draw_vsep_win(wp, row);
+#endif
+	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(fill_diff) > 1)
+		    i = '-';
+		else
+		    i = fill_diff;
+		if (row + j > wp->w_height)
+		    j = wp->w_height - row;
+		win_draw_end(wp, i, i, row, row + (int)j, HLF_DED);
+		row += j;
+	    }
+#endif
+	}
+	else if (dollar_vcol == 0)
+	    wp->w_botline = lnum;
+
+	/* make sure the rest of the screen is blank */
+	/* put '~'s on rows that aren't part of the file. */
+	win_draw_end(wp, '~', ' ', row, wp->w_height, HLF_AT);
+    }
+
+    /* 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 == 0)
+    {
+	/*
+	 * 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)
+	{
+	    recursive = TRUE;
+	    curwin->w_valid &= ~VALID_TOPLINE;
+	    update_topline();	/* may invalidate w_botline again */
+	    if (must_redraw != 0)
+	    {
+		/* Don't update for changes in buffer again. */
+		i = curbuf->b_mod_set;
+		curbuf->b_mod_set = FALSE;
+		win_update(curwin);
+		must_redraw = 0;
+		curbuf->b_mod_set = i;
+	    }
+	    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
+}
+
+#ifdef FEAT_SIGNS
+static int draw_signcolumn __ARGS((win_T *wp));
+
+/*
+ * Return TRUE when window "wp" has a column to draw signs in.
+ */
+    static int
+draw_signcolumn(wp)
+    win_T *wp;
+{
+    return (wp->w_buffer->b_signlist != NULL
+# ifdef FEAT_NETBEANS_INTG
+			    || usingNetbeans
+# endif
+		    );
+}
+#endif
+
+/*
+ * Clear the rest of the window and mark the unused lines with "c1".  use "c2"
+ * as the filler character.
+ */
+    static void
+win_draw_end(wp, c1, c2, row, endrow, hl)
+    win_T	*wp;
+    int		c1;
+    int		c2;
+    int		row;
+    int		endrow;
+    enum hlf_value hl;
+{
+#if defined(FEAT_FOLDING) || defined(FEAT_SIGNS) || defined(FEAT_CMDWIN)
+    int		n = 0;
+# define FDC_OFF n
+#else
+# define FDC_OFF 0
+#endif
+
+#ifdef FEAT_RIGHTLEFT
+    if (wp->w_p_rl)
+    {
+	/* No check for cmdline window: should never be right-left. */
+# ifdef FEAT_FOLDING
+	n = wp->w_p_fdc;
+
+	if (n > 0)
+	{
+	    /* draw the fold column at the right */
+	    if (n > wp->w_width)
+		n = wp->w_width;
+	    screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
+		    W_ENDCOL(wp) - n, (int)W_ENDCOL(wp),
+		    ' ', ' ', hl_attr(HLF_FC));
+	}
+# endif
+# ifdef FEAT_SIGNS
+	if (draw_signcolumn(wp))
+	{
+	    int nn = n + 2;
+
+	    /* draw the sign column left of the fold column */
+	    if (nn > wp->w_width)
+		nn = wp->w_width;
+	    screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
+		    W_ENDCOL(wp) - nn, (int)W_ENDCOL(wp) - n,
+		    ' ', ' ', hl_attr(HLF_SC));
+	    n = nn;
+	}
+# endif
+	screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
+		W_WINCOL(wp), W_ENDCOL(wp) - 1 - FDC_OFF,
+		c2, c2, hl_attr(hl));
+	screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
+		W_ENDCOL(wp) - 1 - FDC_OFF, W_ENDCOL(wp) - FDC_OFF,
+		c1, c2, hl_attr(hl));
+    }
+    else
+#endif
+    {
+#ifdef FEAT_CMDWIN
+	if (cmdwin_type != 0 && wp == curwin)
+	{
+	    /* draw the cmdline character in the leftmost column */
+	    n = 1;
+	    if (n > wp->w_width)
+		n = wp->w_width;
+	    screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
+		    W_WINCOL(wp), (int)W_WINCOL(wp) + n,
+		    cmdwin_type, ' ', hl_attr(HLF_AT));
+	}
+#endif
+#ifdef FEAT_FOLDING
+	if (wp->w_p_fdc > 0)
+	{
+	    int	    nn = n + wp->w_p_fdc;
+
+	    /* draw the fold column at the left */
+	    if (nn > W_WIDTH(wp))
+		nn = W_WIDTH(wp);
+	    screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
+		    W_WINCOL(wp) + n, (int)W_WINCOL(wp) + nn,
+		    ' ', ' ', hl_attr(HLF_FC));
+	    n = nn;
+	}
+#endif
+#ifdef FEAT_SIGNS
+	if (draw_signcolumn(wp))
+	{
+	    int	    nn = n + 2;
+
+	    /* draw the sign column after the fold column */
+	    if (nn > W_WIDTH(wp))
+		nn = W_WIDTH(wp);
+	    screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
+		    W_WINCOL(wp) + n, (int)W_WINCOL(wp) + nn,
+		    ' ', ' ', hl_attr(HLF_SC));
+	    n = nn;
+	}
+#endif
+	screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + endrow,
+		W_WINCOL(wp) + FDC_OFF, (int)W_ENDCOL(wp),
+		c1, c2, hl_attr(hl));
+    }
+    set_empty_rows(wp, row);
+}
+
+#ifdef FEAT_FOLDING
+/*
+ * Display one folded line.
+ */
+    static void
+fold_line(wp, fold_count, foldinfo, lnum, row)
+    win_T	*wp;
+    long	fold_count;
+    foldinfo_T	*foldinfo;
+    linenr_T	lnum;
+    int		row;
+{
+    char_u	buf[51];
+    pos_T	*top, *bot;
+    linenr_T	lnume = lnum + fold_count - 1;
+    int		len;
+    char_u	*p;
+    char_u	*text = NULL;
+    int		fdc;
+    int		level;
+    int		col;
+    int		txtcol;
+    int		off = (int)(current_ScreenLine - ScreenLines);
+
+    /* Build the fold line:
+     * 1. Add the cmdwin_type for the command-line window
+     * 2. Add the 'foldcolumn'
+     * 3. Add the 'number' 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.
+     */
+#ifdef FEAT_CMDWIN
+    if (cmdwin_type != 0 && wp == curwin)
+    {
+	ScreenLines[off] = cmdwin_type;
+	ScreenAttrs[off] = hl_attr(HLF_AT);
+#ifdef FEAT_MBYTE
+	if (enc_utf8)
+	    ScreenLinesUC[off] = 0;
+#endif
+	++col;
+    }
+#endif
+
+    /*
+     * 2. Add the 'foldcolumn'
+     */
+    fdc = wp->w_p_fdc;
+    if (fdc > W_WIDTH(wp) - col)
+	fdc = W_WIDTH(wp) - col;
+    if (fdc > 0)
+    {
+	fill_foldcolumn(buf, wp, TRUE, lnum);
+#ifdef FEAT_RIGHTLEFT
+	if (wp->w_p_rl)
+	{
+	    int		i;
+
+	    copy_text_attr(off + W_WIDTH(wp) - fdc - col, buf, fdc,
+							     hl_attr(HLF_FC));
+	    /* reverse the fold column */
+	    for (i = 0; i < fdc; ++i)
+		ScreenLines[off + W_WIDTH(wp) - i - 1 - col] = buf[i];
+	}
+	else
+#endif
+	    copy_text_attr(off + col, buf, fdc, hl_attr(HLF_FC));
+	col += fdc;
+    }
+
+#ifdef FEAT_RIGHTLEFT
+# define RL_MEMSET(p, v, l) vim_memset(ScreenAttrs + off + (wp->w_p_rl ? (W_WIDTH(wp) - (p) - (l)) : (p)), v, l)
+#else
+# define RL_MEMSET(p, v, l) vim_memset(ScreenAttrs + off + p, v, l)
+#endif
+
+    /* Set all attributes of the 'number' column and the text */
+    RL_MEMSET(col, hl_attr(HLF_FL), (size_t)(W_WIDTH(wp) - col));
+
+#ifdef FEAT_SIGNS
+    /* If signs are being displayed, add two spaces. */
+    if (draw_signcolumn(wp))
+    {
+	len = W_WIDTH(wp) - 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 + W_WIDTH(wp) - 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' column
+     */
+    if (wp->w_p_nu)
+    {
+	len = W_WIDTH(wp) - col;
+	if (len > 0)
+	{
+	    if (len > 8)
+		len = 8;
+	    sprintf((char *)buf, "%7ld ", (long)lnum);
+#ifdef FEAT_RIGHTLEFT
+	    if (wp->w_p_rl)
+		/* the line number isn't reversed */
+		copy_text_attr(off + W_WIDTH(wp) - 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.
+     */
+#ifdef FEAT_EVAL
+    if (*wp->w_p_fdt != NUL)
+    {
+	char_u	dashes[51];
+	win_T	*save_curwin;
+
+	/* Set "v:foldstart" and "v:foldend". */
+	set_vim_var_nr(VV_FOLDSTART, lnum);
+	set_vim_var_nr(VV_FOLDEND, lnume);
+
+	/* Set "v:folddashes" to a string of "level" dashes. */
+	/* Set "v:foldlevel" to "level". */
+	level = foldinfo->fi_level;
+	if (level > 50)
+	    level = 50;
+	vim_memset(dashes, '-', (size_t)level);
+	dashes[level] = NUL;
+	set_vim_var_string(VV_FOLDDASHES, dashes, -1);
+	set_vim_var_nr(VV_FOLDLEVEL, (long)level);
+	save_curwin = curwin;
+	curwin = wp;
+	curbuf = wp->w_buffer;
+
+	++emsg_off;
+	text = eval_to_string_safe(wp->w_p_fdt, NULL);
+	--emsg_off;
+
+	curwin = save_curwin;
+	curbuf = curwin->w_buffer;
+	set_vim_var_string(VV_FOLDDASHES, NULL, -1);
+
+	if (text != NULL)
+	{
+	    /* Replace unprintable characters, if there are any.  But
+	     * replace a TAB with a space. */
+	    for (p = text; *p != NUL; ++p)
+	    {
+#ifdef FEAT_MBYTE
+		if (has_mbyte && (len = (*mb_ptr2len_check)(p)) > 1)
+		{
+		    if (!vim_isprintc((*mb_ptr2char)(p)))
+			break;
+		    p += len - 1;
+		}
+		else
+#endif
+		    if (*p == TAB)
+			*p = ' ';
+		    else if (ptr2cells(p) > 1)
+			break;
+	    }
+	    if (*p != NUL)
+	    {
+		p = transstr(text);
+		vim_free(text);
+		text = p;
+	    }
+	}
+    }
+    if (text == NULL)
+#endif
+    {
+	sprintf((char *)buf, _("+--%3ld lines folded "), fold_count);
+	text = buf;
+    }
+
+    txtcol = col;	/* remember where text starts */
+
+    /*
+     * 5. move the text to current_ScreenLine.  Fill up with "fill_fold".
+     *    Right-left text is put in columns 0 - number-col, normal text is put
+     *    in columns number-col - window-width.
+     */
+#ifdef FEAT_MBYTE
+    if (has_mbyte)
+    {
+	int	cells;
+	int	u8c, u8c_c1, u8c_c2;
+	int	idx;
+	int	c_len;
+# 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_check)(p);
+	    if (col + cells > W_WIDTH(wp)
+# ifdef FEAT_RIGHTLEFT
+		    - (wp->w_p_rl ? col : 0)
+# endif
+		    )
+		break;
+	    ScreenLines[idx] = *p;
+	    if (enc_utf8)
+	    {
+		u8c = utfc_ptr2char(p, &u8c_c1, &u8c_c2);
+		if (*p < 0x80 && u8c_c1 == 0 && u8c_c2 == 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, dummy;
+			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 = u8c_c1;
+			}
+			else
+			{
+			    pc = utfc_ptr2char(p + c_len, &pc1, &dummy);
+			    nc = prev_c;
+			}
+			prev_c = u8c;
+
+			u8c = arabic_shape(u8c, &firstbyte, &u8c_c1,
+								 pc, pc1, nc);
+			ScreenLines[idx] = firstbyte;
+		    }
+		    else
+			prev_c = u8c;
+#endif
+		    /* Non-BMP character: display as ? or fullwidth ?. */
+		    if (u8c >= 0x10000)
+			ScreenLinesUC[idx] = (cells == 2) ? 0xff1f : (int)'?';
+		    else
+			ScreenLinesUC[idx] = u8c;
+		    ScreenLinesC1[idx] = u8c_c1;
+		    ScreenLinesC2[idx] = u8c_c2;
+		}
+		if (cells > 1)
+		    ScreenLines[idx + 1] = 0;
+	    }
+	    else if (cells > 1)	    /* double-byte character */
+	    {
+		if (enc_dbcs == DBCS_JPNU && *p == 0x8e)
+		    ScreenLines2[idx] = p[1];
+		else
+		    ScreenLines[idx + 1] = p[1];
+	    }
+	    col += cells;
+	    idx += cells;
+	    p += c_len;
+	}
+    }
+    else
+#endif
+    {
+	len = (int)STRLEN(text);
+	if (len > W_WIDTH(wp) - col)
+	    len = W_WIDTH(wp) - col;
+	if (len > 0)
+	{
+#ifdef FEAT_RIGHTLEFT
+	    if (wp->w_p_rl)
+		STRNCPY(current_ScreenLine, text, len);
+	    else
+#endif
+		STRNCPY(current_ScreenLine + col, text, len);
+	    col += len;
+	}
+    }
+
+    /* Fill the rest of the line with the fold filler */
+#ifdef FEAT_RIGHTLEFT
+    if (wp->w_p_rl)
+	col -= txtcol;
+#endif
+    while (col < W_WIDTH(wp)
+#ifdef FEAT_RIGHTLEFT
+		    - (wp->w_p_rl ? txtcol : 0)
+#endif
+	    )
+    {
+#ifdef FEAT_MBYTE
+	if (enc_utf8)
+	{
+	    if (fill_fold >= 0x80)
+	    {
+		ScreenLinesUC[off + col] = fill_fold;
+		ScreenLinesC1[off + col] = 0;
+		ScreenLinesC2[off + col] = 0;
+	    }
+	    else
+		ScreenLinesUC[off + col] = 0;
+	}
+#endif
+	ScreenLines[off + col++] = fill_fold;
+    }
+
+    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.
+     */
+#ifdef FEAT_VISUAL
+    if (VIsual_active && wp->w_buffer == curwin->w_buffer)
+    {
+	if (ltoreq(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'))
+		>= 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)W_WIDTH(wp))
+		{
+		    if (wp->w_old_cursor_lcol + txtcol < (colnr_T)W_WIDTH(wp))
+			len = wp->w_old_cursor_lcol;
+		    else
+			len = W_WIDTH(wp) - txtcol;
+		    RL_MEMSET(wp->w_old_cursor_fcol + txtcol, hl_attr(HLF_V),
+				       (size_t)(len - wp->w_old_cursor_fcol));
+		}
+	    }
+	    else
+		/* Set all attributes of the text */
+		RL_MEMSET(txtcol, hl_attr(HLF_V),
+					      (size_t)(W_WIDTH(wp) - txtcol));
+	}
+    }
+#endif
+
+
+    SCREEN_LINE(row + W_WINROW(wp), W_WINCOL(wp), (int)W_WIDTH(wp),
+						     (int)W_WIDTH(wp), FALSE);
+
+    /*
+     * 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);
+    }
+}
+
+/*
+ * Copy "buf[len]" to ScreenLines["off"] and set attributes to "attr".
+ */
+    static void
+copy_text_attr(off, buf, len, attr)
+    int		off;
+    char_u	*buf;
+    int		len;
+    int		attr;
+{
+    mch_memmove(ScreenLines + off, buf, (size_t)len);
+# ifdef FEAT_MBYTE
+    if (enc_utf8)
+	vim_memset(ScreenLinesUC + off, 0, sizeof(u8char_T) * (size_t)len);
+# endif
+    vim_memset(ScreenAttrs + off, attr, (size_t)len);
+}
+
+/*
+ * Fill the foldcolumn at "p" for window "wp".
+ */
+    static void
+fill_foldcolumn(p, wp, closed, lnum)
+    char_u	*p;
+    win_T	*wp;
+    int		closed;		/* TRUE of FALSE */
+    linenr_T	lnum;		/* current line number */
+{
+    int		i = 0;
+    int		level;
+    int		first_level;
+
+    /* Init to all spaces. */
+    copy_spaces(p, (size_t)wp->w_p_fdc);
+
+    level = win_foldinfo.fi_level;
+    if (level > 0)
+    {
+	/* If the column is too narrow, we start at the lowest level that
+	 * fits and use numbers to indicated the depth. */
+	first_level = level - wp->w_p_fdc - closed + 2;
+	if (first_level < 1)
+	    first_level = 1;
+
+	for (i = 0; i + 1 < wp->w_p_fdc; ++i)
+	{
+	    if (win_foldinfo.fi_lnum == lnum
+			      && first_level + i >= win_foldinfo.fi_low_level)
+		p[i] = '-';
+	    else if (first_level == 1)
+		p[i] = '|';
+	    else if (first_level + i <= 9)
+		p[i] = '0' + first_level + i;
+	    else
+		p[i] = '>';
+	    if (first_level + i == level)
+		break;
+	}
+    }
+    if (closed)
+	p[i] = '+';
+}
+#endif /* FEAT_FOLDING */
+
+/*
+ * Display line "lnum" of window 'wp' on the screen.
+ * Start at row "startrow", stop when "endrow" is reached.
+ * wp->w_virtcol needs to be valid.
+ *
+ * Return the number of last row the line occupies.
+ */
+    static int
+win_line(wp, lnum, startrow, endrow)
+    win_T	*wp;
+    linenr_T	lnum;
+    int		startrow;
+    int		endrow;
+{
+    int		col;			/* visual column on screen */
+    unsigned	off;			/* offset in ScreenLines/ScreenAttrs */
+    int		c = 0;			/* init for GCC */
+    long	vcol = 0;		/* virtual column (for tabs) */
+    long	vcol_prev = -1;		/* "vcol" of previous character */
+    char_u	*line;			/* current line */
+    char_u	*ptr;			/* current position in "line" */
+    int		row;			/* row in the window, excl w_winrow */
+    int		screen_row;		/* row on the screen, incl w_winrow */
+
+    char_u	extra[18];		/* "%ld" and 'fdc' must fit in here */
+    int		n_extra = 0;		/* number of extra chars */
+    char_u	*p_extra = NULL;	/* string of extra chars */
+    int		c_extra = NUL;		/* extra chars, all the same */
+    int		extra_attr = 0;		/* attributes when n_extra != 0 */
+    static char_u *at_end_str = (char_u *)""; /* used for p_extra when
+					   displaying lcs_eol at end-of-line */
+    int		lcs_eol_one = lcs_eol;	/* lcs_eol until it's been used */
+    int		lcs_prec_todo = lcs_prec;   /* lcs_prec until it's been used */
+
+    /* saved "extra" items for when draw_state becomes WL_LINE (again) */
+    int		saved_n_extra = 0;
+    char_u	*saved_p_extra = NULL;
+    int		saved_c_extra = 0;
+    int		saved_char_attr = 0;
+
+    int		n_attr = 0;		/* chars with special attr */
+    int		saved_attr2 = 0;	/* char_attr saved for n_attr */
+    int		n_attr3 = 0;		/* chars with overruling special attr */
+    int		saved_attr3 = 0;	/* char_attr saved for n_attr3 */
+
+    int		n_skip = 0;		/* nr of chars to skip for 'nowrap' */
+
+    int		fromcol, tocol;		/* start/end of inverting */
+    int		fromcol_prev = -2;	/* start of inverting after cursor */
+    int		noinvcur = FALSE;	/* don't invert the cursor */
+#ifdef FEAT_VISUAL
+    pos_T	*top, *bot;
+#endif
+    pos_T	pos;
+    long	v;
+
+    int		char_attr = 0;		/* attributes for next character */
+    int		area_highlighting = FALSE; /* Visual or incsearch highlighting
+					      in this line */
+    int		attr = 0;		/* attributes for area highlighting */
+    int		area_attr = 0;		/* attributes desired by highlighting */
+    int		search_attr = 0;	/* attributes desired by 'hlsearch' */
+#ifdef FEAT_SYN_HL
+    int		syntax_attr = 0;	/* attributes desired by syntax */
+    int		has_syntax = FALSE;	/* this buffer has syntax highl. */
+    int		save_did_emsg;
+#endif
+    int		extra_check;		/* has syntax or linebreak */
+#ifdef FEAT_MBYTE
+    int		multi_attr = 0;		/* attributes desired by multibyte */
+    int		mb_l = 1;		/* multi-byte byte length */
+    int		mb_c = 0;		/* decoded multi-byte character */
+    int		mb_utf8 = FALSE;	/* screen char is UTF-8 char */
+    int		u8c_c1 = 0;		/* first composing UTF-8 char */
+    int		u8c_c2 = 0;		/* second composing UTF-8 char */
+#endif
+#ifdef FEAT_DIFF
+    int		filler_lines;		/* nr of filler lines to be drawn */
+    int		filler_todo;		/* nr of filler lines still to do + 1 */
+    enum hlf_value diff_hlf = (enum hlf_value)0; /* type of diff highlighting */
+    int		change_start = MAXCOL;	/* first col of changed area */
+    int		change_end = -1;	/* last col of changed area */
+#endif
+    colnr_T	trailcol = MAXCOL;	/* start of trailing spaces */
+#ifdef FEAT_LINEBREAK
+    int		need_showbreak = FALSE;
+#endif
+#if defined(FEAT_SIGNS) || (defined(FEAT_QUICKFIX) && defined(FEAT_WINDOWS))
+# define LINE_ATTR
+    int		line_attr = 0;		/* atrribute for the whole line */
+#endif
+#ifdef FEAT_SEARCH_EXTRA
+    match_T	*shl;			/* points to search_hl or match_hl */
+#endif
+#ifdef FEAT_ARABIC
+    int		prev_c = 0;		/* previous Arabic character */
+    int		prev_c1 = 0;		/* first composing char for prev_c */
+#endif
+
+    /* draw_state: items that are drawn in sequence: */
+#define WL_START	0		/* nothing done yet */
+#ifdef FEAT_CMDWIN
+# define WL_CMDLINE	WL_START + 1	/* cmdline window column */
+#else
+# define WL_CMDLINE	WL_START
+#endif
+#ifdef FEAT_FOLDING
+# define WL_FOLD	WL_CMDLINE + 1	/* 'foldcolumn' */
+#else
+# define WL_FOLD	WL_CMDLINE
+#endif
+#ifdef FEAT_SIGNS
+# define WL_SIGN	WL_FOLD + 1	/* column for signs */
+#else
+# define WL_SIGN	WL_FOLD		/* column for signs */
+#endif
+#define WL_NR		WL_SIGN + 1	/* line number */
+#if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF)
+# define WL_SBR		WL_NR + 1	/* 'showbreak' or 'diff' */
+#else
+# define WL_SBR		WL_NR
+#endif
+#define WL_LINE		WL_SBR + 1	/* text in the line */
+    int		draw_state = WL_START;	/* what to draw next */
+#if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
+    int		feedback_col = 0;
+    int		feedback_old_attr = -1;
+#endif
+
+
+    if (startrow > endrow)		/* past the end already! */
+	return startrow;
+
+    row = startrow;
+    screen_row = row + W_WINROW(wp);
+
+    /*
+     * To speed up the loop below, set extra_check when there is linebreak,
+     * trailing white space and/or syntax processing to be done.
+     */
+#ifdef FEAT_LINEBREAK
+    extra_check = wp->w_p_lbr;
+#else
+    extra_check = 0;
+#endif
+#ifdef FEAT_SYN_HL
+    if (syntax_present(wp->w_buffer))
+    {
+	/* Prepare for syntax highlighting in this line.  When there is an
+	 * error, stop syntax highlighting. */
+	save_did_emsg = did_emsg;
+	did_emsg = FALSE;
+	syntax_start(wp, lnum);
+	if (did_emsg)
+	    syntax_clear(wp->w_buffer);
+	else
+	{
+	    did_emsg = save_did_emsg;
+	    has_syntax = TRUE;
+	    extra_check = TRUE;
+	}
+    }
+#endif
+
+    /*
+     * handle visual active in this window
+     */
+    fromcol = -10;
+    tocol = MAXCOL;
+#ifdef FEAT_VISUAL
+    if (VIsual_active && wp->w_buffer == curwin->w_buffer)
+    {
+					/* Visual is after curwin->w_cursor */
+	if (ltoreq(curwin->w_cursor, VIsual))
+	{
+	    top = &curwin->w_cursor;
+	    bot = &VIsual;
+	}
+	else				/* Visual is before curwin->w_cursor */
+	{
+	    top = &VIsual;
+	    bot = &curwin->w_cursor;
+	}
+	if (VIsual_mode == Ctrl_V)	/* block mode */
+	{
+	    if (lnum >= top->lnum && lnum <= bot->lnum)
+	    {
+		fromcol = wp->w_old_cursor_fcol;
+		tocol = wp->w_old_cursor_lcol;
+	    }
+	}
+	else				/* non-block mode */
+	{
+	    if (lnum > top->lnum && lnum <= bot->lnum)
+		fromcol = 0;
+	    else if (lnum == top->lnum)
+	    {
+		if (VIsual_mode == 'V')	/* linewise */
+		    fromcol = 0;
+		else
+		{
+		    getvvcol(wp, top, (colnr_T *)&fromcol, NULL, NULL);
+		    if (gchar_pos(top) == NUL)
+			tocol = fromcol + 1;
+		}
+	    }
+	    if (VIsual_mode != 'V' && lnum == bot->lnum)
+	    {
+		if (*p_sel == 'e' && bot->col == 0
+#ifdef FEAT_VIRTUALEDIT
+			&& bot->coladd == 0
+#endif
+		   )
+		{
+		    fromcol = -10;
+		    tocol = MAXCOL;
+		}
+		else
+		{
+		    pos = *bot;
+		    if (*p_sel == 'e')
+			getvvcol(wp, &pos, (colnr_T *)&tocol, NULL, NULL);
+		    else
+		    {
+			getvvcol(wp, &pos, NULL, NULL, (colnr_T *)&tocol);
+			++tocol;
+		    }
+		}
+	    }
+	}
+
+#ifndef MSDOS
+	/* Check if the character under the cursor should not be inverted */
+	if (!highlight_match && lnum == curwin->w_cursor.lnum && wp == curwin
+# ifdef FEAT_GUI
+		&& !gui.in_use
+# endif
+		)
+	    noinvcur = TRUE;
+#endif
+
+	/* if inverting in this line set area_highlighting */
+	if (fromcol >= 0)
+	{
+	    area_highlighting = TRUE;
+	    attr = hl_attr(HLF_V);
+#if defined(FEAT_CLIPBOARD) && defined(FEAT_X11)
+	    if (clip_star.available && !clip_star.owned && clip_isautosel())
+		attr = hl_attr(HLF_VNC);
+#endif
+	}
+    }
+
+    /*
+     * handle 'insearch' and ":s///c" highlighting
+     */
+    else
+#endif /* FEAT_VISUAL */
+	if (highlight_match
+	    && wp == curwin
+	    && lnum >= curwin->w_cursor.lnum
+	    && lnum <= curwin->w_cursor.lnum + search_match_lines)
+    {
+	if (lnum == curwin->w_cursor.lnum)
+	    getvcol(curwin, &(curwin->w_cursor),
+					     (colnr_T *)&fromcol, NULL, NULL);
+	else
+	    fromcol = 0;
+	if (lnum == curwin->w_cursor.lnum + search_match_lines)
+	{
+	    pos.lnum = lnum;
+	    pos.col = search_match_endcol;
+	    getvcol(curwin, &pos, (colnr_T *)&tocol, NULL, NULL);
+	}
+	else
+	    tocol = MAXCOL;
+	if (fromcol == tocol)		/* do at least one character */
+	    tocol = fromcol + 1;	/* happens when past end of line */
+	area_highlighting = TRUE;
+	attr = hl_attr(HLF_I);
+    }
+
+#ifdef FEAT_DIFF
+    filler_lines = diff_check(wp, lnum);
+    if (filler_lines < 0)
+    {
+	if (filler_lines == -1)
+	{
+	    if (diff_find_change(wp, lnum, &change_start, &change_end))
+		diff_hlf = HLF_ADD;	/* added line */
+	    else if (change_start == 0)
+		diff_hlf = HLF_TXD;	/* changed text */
+	    else
+		diff_hlf = HLF_CHD;	/* changed line */
+	}
+	else
+	    diff_hlf = HLF_ADD;		/* added line */
+	filler_lines = 0;
+	area_highlighting = TRUE;
+    }
+    if (lnum == wp->w_topline)
+	filler_lines = wp->w_topfill;
+    filler_todo = filler_lines;
+#endif
+
+#ifdef LINE_ATTR
+# ifdef FEAT_SIGNS
+    /* If this line has a sign with line highlighting set line_attr. */
+    v = buf_getsigntype(wp->w_buffer, lnum, SIGN_LINEHL);
+    if (v != 0)
+	line_attr = sign_get_attr((int)v, TRUE);
+# endif
+# if defined(FEAT_QUICKFIX) && defined(FEAT_WINDOWS)
+    /* Highlight the current line in the quickfix window. */
+    if (bt_quickfix(wp->w_buffer) && qf_current_entry() == lnum)
+	line_attr = hl_attr(HLF_L);
+# endif
+    if (line_attr != 0)
+	area_highlighting = TRUE;
+#endif
+
+    line = ml_get_buf(wp->w_buffer, lnum, FALSE);
+    ptr = line;
+
+    /* find start of trailing whitespace */
+    if (wp->w_p_list && lcs_trail)
+    {
+	trailcol = (colnr_T)STRLEN(ptr);
+	while (trailcol > (colnr_T)0 && vim_iswhite(ptr[trailcol - 1]))
+	    --trailcol;
+	trailcol += (colnr_T) (ptr - line);
+	extra_check = TRUE;
+    }
+
+    /*
+     * 'nowrap' or 'wrap' and a single line that doesn't fit: Advance to the
+     * first character to be displayed.
+     */
+    if (wp->w_p_wrap)
+	v = wp->w_skipcol;
+    else
+	v = wp->w_leftcol;
+    if (v > 0)
+    {
+#ifdef FEAT_MBYTE
+	char_u	*prev_ptr = ptr;
+#endif
+	while (vcol < v && *ptr != NUL)
+	{
+	    c = win_lbr_chartabsize(wp, ptr, (colnr_T)vcol, NULL);
+	    vcol += c;
+#ifdef FEAT_MBYTE
+	    prev_ptr = ptr;
+	    if (has_mbyte)
+		ptr += (*mb_ptr2len_check)(ptr);
+	    else
+#endif
+		++ptr;
+	}
+
+#ifdef FEAT_VIRTUALEDIT
+	/* When 'virtualedit' is set the end of the line may be before the
+	 * start of the displayed part. */
+	if (vcol < v && *ptr == NUL && virtual_active())
+	    vcol = v;
+#endif
+
+	/* Handle a character that's not completely on the screen: Put ptr at
+	 * that character but skip the first few screen characters. */
+	if (vcol > v)
+	{
+	    vcol -= c;
+#ifdef FEAT_MBYTE
+	    ptr = prev_ptr;
+#else
+	    --ptr;
+#endif
+	    n_skip = v - vcol;
+	}
+
+	/*
+	 * Adjust for when the inverted text is before the screen,
+	 * and when the start of the inverted text is before the screen.
+	 */
+	if (tocol <= vcol)
+	    fromcol = 0;
+	else if (fromcol >= 0 && fromcol < vcol)
+	    fromcol = vcol;
+
+#ifdef FEAT_LINEBREAK
+	/* When w_skipcol is non-zero, first line needs 'showbreak' */
+	if (wp->w_p_wrap)
+	    need_showbreak = TRUE;
+#endif
+    }
+
+    /*
+     * Correct highlighting for cursor that can't be disabled.
+     * Avoids having to check this for each character.
+     */
+    if (fromcol >= 0)
+    {
+	if (noinvcur)
+	{
+	    if ((colnr_T)fromcol == wp->w_virtcol)
+	    {
+		/* highlighting starts at cursor, let it start just after the
+		 * cursor */
+		fromcol_prev = fromcol;
+		fromcol = -1;
+	    }
+	    else if ((colnr_T)fromcol < wp->w_virtcol)
+		/* restart highlighting after the cursor */
+		fromcol_prev = wp->w_virtcol;
+	}
+	if (fromcol >= tocol)
+	    fromcol = -1;
+    }
+
+#ifdef FEAT_SEARCH_EXTRA
+    /*
+     * Handle highlighting the last used search pattern.
+     * Do this for both search_hl and match_hl.
+     */
+    shl = &search_hl;
+    for (;;)
+    {
+	shl->startp = NULL;
+	shl->endp = NULL;
+	shl->attr_cur = 0;
+	if (shl->rm.regprog != NULL)
+	{
+	    v = (long)(ptr - line);
+	    next_search_hl(wp, shl, lnum, (colnr_T)v);
+
+	    /* Need to get the line again, a multi-line regexp may have made it
+	     * invalid. */
+	    line = ml_get_buf(wp->w_buffer, lnum, FALSE);
+	    ptr = line + v;
+
+	    if (shl->lnum != 0 && shl->lnum <= lnum)
+	    {
+		if (shl->lnum == lnum)
+		    shl->startp = line + shl->rm.startpos[0].col;
+		else
+		    shl->startp = line;
+		if (lnum == shl->lnum + shl->rm.endpos[0].lnum
+						  - shl->rm.startpos[0].lnum)
+		    shl->endp = line + shl->rm.endpos[0].col;
+		else
+		    shl->endp = line + MAXCOL;
+		/* Highlight one character for an empty match. */
+		if (shl->startp == shl->endp)
+		{
+#ifdef FEAT_MBYTE
+		    if (has_mbyte && *shl->endp != NUL)
+			shl->endp += (*mb_ptr2len_check)(shl->endp);
+		    else
+#endif
+			++shl->endp;
+		}
+		if (shl->startp < ptr)  /* match at leftcol */
+		{
+		    shl->attr_cur = shl->attr;
+		    search_attr = shl->attr;
+		}
+		area_highlighting = TRUE;
+	    }
+	}
+	if (shl == &match_hl)
+	    break;
+	shl = &match_hl;
+    }
+#endif
+
+    off = (unsigned) (current_ScreenLine - ScreenLines);
+    col = 0;
+#ifdef FEAT_RIGHTLEFT
+    if (wp->w_p_rl)
+    {
+	/* Rightleft window: process the text in the normal direction, but put
+	 * it in current_ScreenLine[] from right to left.  Start at the
+	 * rightmost column of the window. */
+	col = W_WIDTH(wp) - 1;
+	off += col;
+    }
+#endif
+
+    /*
+     * Repeat for the whole displayed line.
+     */
+    for (;;)
+    {
+	/* Skip this quickly when working on the text. */
+	if (draw_state != WL_LINE)
+	{
+#ifdef FEAT_CMDWIN
+	    if (draw_state == WL_CMDLINE - 1 && n_extra == 0)
+	    {
+		draw_state = WL_CMDLINE;
+		if (cmdwin_type != 0 && wp == curwin)
+		{
+		    /* Draw the cmdline character. */
+		    *extra = cmdwin_type;
+		    n_extra = 1;
+		    p_extra = extra;
+		    c_extra = NUL;
+		    char_attr = hl_attr(HLF_AT);
+		}
+	    }
+#endif
+
+#ifdef FEAT_FOLDING
+	    if (draw_state == WL_FOLD - 1 && n_extra == 0)
+	    {
+		draw_state = WL_FOLD;
+		if (wp->w_p_fdc > 0)
+		{
+		    /* Draw the 'foldcolumn'. */
+		    fill_foldcolumn(extra, wp, FALSE, lnum);
+		    n_extra = wp->w_p_fdc;
+		    p_extra = extra;
+		    c_extra = NUL;
+		    char_attr = hl_attr(HLF_FC);
+		}
+	    }
+#endif
+
+#ifdef FEAT_SIGNS
+	    if (draw_state == WL_SIGN - 1 && n_extra == 0)
+	    {
+		draw_state = WL_SIGN;
+		/* Show the sign column when there are any signs in this
+		 * buffer or when using Netbeans. */
+		if (draw_signcolumn(wp)
+# ifdef FEAT_DIFF
+			&& filler_todo <= 0
+# endif
+		   )
+		{
+		    int_u	text_sign;
+# ifdef FEAT_SIGN_ICONS
+		    int_u	icon_sign;
+# endif
+
+		    /* Draw two cells with the sign value or blank. */
+		    c_extra = ' ';
+		    char_attr = hl_attr(HLF_SC);
+		    n_extra = 2;
+
+		    if (row == startrow)
+		    {
+			text_sign = buf_getsigntype(wp->w_buffer, lnum,
+								   SIGN_TEXT);
+# ifdef FEAT_SIGN_ICONS
+			icon_sign = buf_getsigntype(wp->w_buffer, lnum,
+								   SIGN_ICON);
+			if (gui.in_use && icon_sign != 0)
+			{
+			    /* Use the image in this position. */
+			    c_extra = SIGN_BYTE;
+#  ifdef FEAT_NETBEANS_INTG
+			    if (buf_signcount(wp->w_buffer, lnum) > 1)
+				c_extra = MULTISIGN_BYTE;
+#  endif
+			    char_attr = icon_sign;
+			}
+			else
+# endif
+			    if (text_sign != 0)
+			{
+			    p_extra = sign_get_text(text_sign);
+			    if (p_extra != NULL)
+			    {
+				c_extra = NUL;
+				n_extra = STRLEN(p_extra);
+			    }
+			    char_attr = sign_get_attr(text_sign, FALSE);
+			}
+		    }
+		}
+	    }
+#endif
+
+	    if (draw_state == WL_NR - 1 && n_extra == 0)
+	    {
+		draw_state = WL_NR;
+		/* Display the line number.  After the first fill with blanks
+		 * when the 'n' flag isn't in 'cpo' */
+		if (wp->w_p_nu
+			&& (row == startrow
+#ifdef FEAT_DIFF
+			    + filler_lines
+#endif
+			    || vim_strchr(p_cpo, CPO_NUMCOL) == NULL))
+		{
+		    /* Draw the line number (empty space after wrapping). */
+		    if (row == startrow
+#ifdef FEAT_DIFF
+			    + filler_lines
+#endif
+			    )
+		    {
+			sprintf((char *)extra, "%7ld ", (long)lnum);
+			if (wp->w_skipcol > 0)
+			    for (p_extra = extra; *p_extra == ' '; ++p_extra)
+				*p_extra = '-';
+#ifdef FEAT_RIGHTLEFT
+			if (wp->w_p_rl)		    /* reverse line numbers */
+			    rl_mirror(extra);
+#endif
+			p_extra = extra;
+			c_extra = NUL;
+		    }
+		    else
+			c_extra = ' ';
+		    n_extra = 8;
+		    char_attr = hl_attr(HLF_N);
+		}
+	    }
+
+#if defined(FEAT_LINEBREAK) || defined(FEAT_DIFF)
+	    if (draw_state == WL_SBR - 1 && n_extra == 0)
+	    {
+		draw_state = WL_SBR;
+# ifdef FEAT_DIFF
+		if (filler_todo > 0)
+		{
+		    /* Draw "deleted" diff line(s). */
+		    if (char2cells(fill_diff) > 1)
+			c_extra = '-';
+		    else
+			c_extra = fill_diff;
+#  ifdef FEAT_RIGHTLEFT
+		    if (wp->w_p_rl)
+			n_extra = col + 1;
+		    else
+#  endif
+			n_extra = W_WIDTH(wp) - col;
+		    char_attr = hl_attr(HLF_DED);
+		}
+# endif
+# ifdef FEAT_LINEBREAK
+		if (*p_sbr != NUL && need_showbreak)
+		{
+		    /* Draw 'showbreak' at the start of each broken line. */
+		    p_extra = p_sbr;
+		    c_extra = NUL;
+		    n_extra = (int)STRLEN(p_sbr);
+		    char_attr = hl_attr(HLF_AT);
+		    need_showbreak = FALSE;
+		    /* Correct end of highlighted area for 'showbreak',
+		     * required when 'linebreak' is also set. */
+		    if (tocol == vcol)
+			tocol += n_extra;
+		}
+# endif
+	    }
+#endif
+
+	    if (draw_state == WL_LINE - 1 && n_extra == 0)
+	    {
+		draw_state = WL_LINE;
+		if (saved_n_extra)
+		{
+		    /* Continue item from end of wrapped line. */
+		    n_extra = saved_n_extra;
+		    c_extra = saved_c_extra;
+		    p_extra = saved_p_extra;
+		    char_attr = saved_char_attr;
+		}
+		else
+		    char_attr = 0;
+	    }
+	}
+
+	/* When still displaying '$' of change command, stop at cursor */
+	if (dollar_vcol != 0 && wp == curwin && vcol >= (long)wp->w_virtcol
+#ifdef FEAT_DIFF
+				   && filler_todo <= 0
+#endif
+		)
+	{
+	    SCREEN_LINE(screen_row, W_WINCOL(wp), col, -(int)W_WIDTH(wp),
+								  wp->w_p_rl);
+	    /* Pretend we have finished updating the window. */
+	    row = wp->w_height;
+	    break;
+	}
+
+	if (draw_state == WL_LINE && area_highlighting)
+	{
+	    /* handle Visual or match highlighting in this line */
+	    if (vcol == fromcol
+#ifdef FEAT_MBYTE
+		    || (has_mbyte && vcol + 1 == fromcol && n_extra == 0
+			&& (*mb_ptr2cells)(ptr) > 1)
+#endif
+		    || ((int)vcol_prev == fromcol_prev
+			&& vcol < tocol))
+		area_attr = attr;		/* start highlighting */
+	    else if (area_attr != 0
+		    && (vcol == tocol
+			|| (noinvcur && (colnr_T)vcol == wp->w_virtcol)))
+#ifdef LINE_ATTR
+		area_attr = line_attr;		/* stop highlighting */
+	    else if (line_attr && ((fromcol == -10 && tocol == MAXCOL)
+					 || (vcol < fromcol || vcol > tocol)))
+		area_attr = line_attr;
+#else
+		area_attr = 0;			/* stop highlighting */
+#endif
+
+#ifdef FEAT_SEARCH_EXTRA
+	    if (!n_extra)
+	    {
+		/*
+		 * Check for start/end of search pattern match.
+		 * After end, check for start/end of next match.
+		 * When another match, have to check for start again.
+		 * Watch out for matching an empty string!
+		 * Do this first for search_hl, then for match_hl, so that
+		 * ":match" overrules 'hlsearch'.
+		 */
+		shl = &search_hl;
+		for (;;)
+		{
+		    while (shl->rm.regprog != NULL)
+		    {
+			if (shl->startp != NULL
+				&& ptr >= shl->startp
+				&& ptr < shl->endp)
+			{
+			    shl->attr_cur = shl->attr;
+			}
+			else if (ptr == shl->endp)
+			{
+			    shl->attr_cur = 0;
+
+			    v = (long)(ptr - line);
+			    next_search_hl(wp, shl, lnum, (colnr_T)v);
+
+			    /* Need to get the line again, a multi-line regexp
+			     * may have made it invalid. */
+			    line = ml_get_buf(wp->w_buffer, lnum, FALSE);
+			    ptr = line + v;
+
+			    if (shl->lnum == lnum)
+			    {
+				shl->startp = line + shl->rm.startpos[0].col;
+				if (shl->rm.endpos[0].lnum == 0)
+				    shl->endp = line + shl->rm.endpos[0].col;
+				else
+				    shl->endp = line + MAXCOL;
+
+				if (shl->startp == shl->endp)
+				{
+				    /* highlight empty match, try again after
+				     * it */
+#ifdef FEAT_MBYTE
+				    if (has_mbyte)
+					shl->endp +=
+					       (*mb_ptr2len_check)(shl->endp);
+				    else
+#endif
+					++shl->endp;
+				}
+
+				/* Loop to check if the match starts at the
+				 * current position */
+				continue;
+			    }
+			}
+			break;
+		    }
+		    if (shl == &match_hl)
+			break;
+		    shl = &match_hl;
+		}
+		/* ":match" highlighting overrules 'hlsearch' */
+		if (match_hl.attr_cur != 0)
+		    search_attr = match_hl.attr_cur;
+		else
+		    search_attr = search_hl.attr_cur;
+	    }
+#endif
+
+	    if (area_attr != 0)
+		char_attr = area_attr;
+#ifdef FEAT_SYN_HL
+	    else if (search_attr == 0 && has_syntax)
+		char_attr = syntax_attr;
+#endif
+	    else
+		char_attr = search_attr;
+
+#ifdef FEAT_DIFF
+	    if (diff_hlf != (enum hlf_value)0 && n_extra == 0)
+	    {
+		if (diff_hlf == HLF_CHD && ptr - line >= change_start)
+		    diff_hlf = HLF_TXD;		/* changed text */
+		if (diff_hlf == HLF_TXD && ptr - line > change_end)
+		    diff_hlf = HLF_CHD;		/* changed line */
+		if (attr == 0 || area_attr != attr)
+		    area_attr = hl_attr(diff_hlf);
+		if (attr == 0 || char_attr != attr)
+		{
+		    if (search_attr != 0)
+			char_attr = search_attr;
+		    else
+			char_attr = hl_attr(diff_hlf);
+		}
+	    }
+#endif
+	}
+
+	/*
+	 * Get the next character to put on the screen.
+	 */
+	/*
+	 * The 'extra' array contains the extra stuff that is inserted to
+	 * represent special characters (non-printable stuff).  When all
+	 * characters are the same, c_extra is used.
+	 * For the '$' of the 'list' option, n_extra == 1, p_extra == "".
+	 */
+	if (n_extra > 0)
+	{
+	    if (c_extra != NUL)
+	    {
+		c = c_extra;
+#ifdef FEAT_MBYTE
+		mb_c = c;	/* doesn't handle non-utf-8 multi-byte! */
+		if (enc_utf8 && (*mb_char2len)(c) > 1)
+		{
+		    mb_utf8 = TRUE;
+		    u8c_c1 = u8c_c2 = 0;
+		}
+		else
+		    mb_utf8 = FALSE;
+#endif
+	    }
+	    else
+	    {
+		c = *p_extra;
+#ifdef FEAT_MBYTE
+		if (has_mbyte)
+		{
+		    mb_c = c;
+		    if (enc_utf8)
+		    {
+			/* If the UTF-8 character is more than one byte:
+			 * Decode it into "mb_c". */
+			mb_l = (*mb_ptr2len_check)(p_extra);
+			mb_utf8 = FALSE;
+			if (mb_l > n_extra)
+			    mb_l = 1;
+			else if (mb_l > 1)
+			{
+			    mb_c = utfc_ptr2char(p_extra, &u8c_c1, &u8c_c2);
+			    mb_utf8 = TRUE;
+			}
+		    }
+		    else
+		    {
+			/* if this is a DBCS character, put it in "mb_c" */
+			mb_l = MB_BYTE2LEN(c);
+			if (mb_l >= n_extra)
+			    mb_l = 1;
+			else if (mb_l > 1)
+			    mb_c = (c << 8) + p_extra[1];
+		    }
+		    /* If a double-width char doesn't fit display a '>' in the
+		     * last column. */
+		    if (
+# ifdef FEAT_RIGHTLEFT
+			    wp->w_p_rl ? (col <= 0) :
+# endif
+				    (col >= W_WIDTH(wp) - 1)
+			    && (*mb_char2cells)(mb_c) == 2)
+		    {
+			c = '>';
+			mb_c = c;
+			mb_l = 1;
+			mb_utf8 = FALSE;
+			multi_attr = hl_attr(HLF_AT);
+			/* put the pointer back to output the double-width
+			 * character at the start of the next line. */
+			++n_extra;
+			--p_extra;
+		    }
+		    else
+		    {
+			n_extra -= mb_l - 1;
+			p_extra += mb_l - 1;
+		    }
+		}
+#endif
+		++p_extra;
+	    }
+	    --n_extra;
+	}
+	else
+	{
+	    /*
+	     * Get a character from the line itself.
+	     */
+	    c = *ptr;
+#ifdef FEAT_MBYTE
+	    if (has_mbyte)
+	    {
+		mb_c = c;
+		if (enc_utf8)
+		{
+		    /* If the UTF-8 character is more than one byte: Decode it
+		     * into "mb_c". */
+		    mb_l = (*mb_ptr2len_check)(ptr);
+		    mb_utf8 = FALSE;
+		    if (mb_l > 1)
+		    {
+			mb_c = utfc_ptr2char(ptr, &u8c_c1, &u8c_c2);
+			/* Overlong encoded ASCII or ASCII with composing char
+			 * is displayed normally, except a NUL. */
+			if (mb_c < 0x80)
+			    c = mb_c;
+			mb_utf8 = TRUE;
+		    }
+
+		    if ((mb_l == 1 && c >= 0x80)
+			    || (mb_l >= 1 && mb_c == 0)
+			    || (mb_l > 1 && (!vim_isprintc(mb_c)
+							 || mb_c >= 0x10000)))
+		    {
+			/*
+			 * Illegal UTF-8 byte: display as <xx>.
+			 * Non-BMP character : display as ? or fullwidth ?.
+			 */
+			if (mb_c < 0x10000)
+			{
+			    transchar_hex(extra, mb_c);
+#ifdef FEAT_RIGHTLEFT
+			    if (wp->w_p_rl)		/* reverse */
+				rl_mirror(extra);
+#endif
+			}
+			else if (utf_char2cells(mb_c) != 2)
+			    STRCPY(extra, "?");
+			else
+			    /* 0xff1f in UTF-8: full-width '?' */
+			    STRCPY(extra, "\357\274\237");
+
+			p_extra = extra;
+			c = *p_extra;
+			mb_c = mb_ptr2char_adv(&p_extra);
+			mb_utf8 = (c >= 0x80);
+			n_extra = (int)STRLEN(p_extra);
+			c_extra = NUL;
+			if (area_attr == 0 && search_attr == 0)
+			{
+			    n_attr = n_extra + 1;
+			    extra_attr = hl_attr(HLF_8);
+			    saved_attr2 = char_attr; /* save current attr */
+			}
+		    }
+		    else if (mb_l == 0)  /* at the NUL at end-of-line */
+			mb_l = 1;
+#ifdef FEAT_ARABIC
+		    else if (p_arshape && !p_tbidi && ARABIC_CHAR(mb_c))
+		    {
+			/* Do Arabic shaping. */
+			int	pc, pc1, nc, dummy;
+
+			/* 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(ptr + mb_l);
+			    prev_c1 = u8c_c1;
+			}
+			else
+			{
+			    pc = utfc_ptr2char(ptr + mb_l, &pc1, &dummy);
+			    nc = prev_c;
+			}
+			prev_c = mb_c;
+
+			mb_c = arabic_shape(mb_c, &c, &u8c_c1, pc, pc1, nc);
+		    }
+		    else
+			prev_c = mb_c;
+#endif
+		}
+		else	/* enc_dbcs */
+		{
+		    mb_l = MB_BYTE2LEN(c);
+		    if (mb_l == 0)  /* at the NUL at end-of-line */
+			mb_l = 1;
+		    else if (mb_l > 1)
+		    {
+			/* We assume a second byte below 32 is illegal.
+			 * Hopefully this is OK for all double-byte encodings!
+			 */
+			if (ptr[1] >= 32)
+			    mb_c = (c << 8) + ptr[1];
+			else
+			{
+			    if (ptr[1] == NUL)
+			    {
+				/* head byte at end of line */
+				mb_l = 1;
+				transchar_nonprint(extra, c);
+			    }
+			    else
+			    {
+				/* illegal tail byte */
+				mb_l = 2;
+				STRCPY(extra, "XX");
+			    }
+			    p_extra = extra;
+			    n_extra = (int)STRLEN(extra) - 1;
+			    c_extra = NUL;
+			    c = *p_extra++;
+			    if (area_attr == 0 && search_attr == 0)
+			    {
+				n_attr = n_extra + 1;
+				extra_attr = hl_attr(HLF_8);
+				saved_attr2 = char_attr; /* save current attr */
+			    }
+			    mb_c = c;
+			}
+		    }
+		}
+		/* If a double-width char doesn't fit display a '>' in the
+		 * last column; the character is displayed at the start of the
+		 * next line. */
+		if ((
+# ifdef FEAT_RIGHTLEFT
+			    wp->w_p_rl ? (col <= 0) :
+# endif
+				(col >= W_WIDTH(wp) - 1))
+			&& (*mb_char2cells)(mb_c) == 2)
+		{
+		    c = '>';
+		    mb_c = c;
+		    mb_utf8 = FALSE;
+		    mb_l = 1;
+		    multi_attr = hl_attr(HLF_AT);
+		    /* Put pointer back so that the character will be
+		     * displayed at the start of the next line. */
+		    --ptr;
+		}
+		else if (*ptr != NUL)
+		    ptr += mb_l - 1;
+
+		/* If a double-width char doesn't fit at the left side display
+		 * a '<' in the first column. */
+		if (n_skip > 0 && mb_l > 1)
+		{
+		    extra[0] = '<';
+		    p_extra = extra;
+		    n_extra = 1;
+		    c_extra = NUL;
+		    c = ' ';
+		    if (area_attr == 0 && search_attr == 0)
+		    {
+			n_attr = n_extra + 1;
+			extra_attr = hl_attr(HLF_AT);
+			saved_attr2 = char_attr; /* save current attr */
+		    }
+		    mb_c = c;
+		    mb_utf8 = FALSE;
+		    mb_l = 1;
+		}
+
+	    }
+#endif
+	    ++ptr;
+
+	    if (extra_check)
+	    {
+#ifdef FEAT_SYN_HL
+		/* Get syntax attribute, unless still at the start of the line
+		 * (double-wide char that doesn't fit). */
+		if (has_syntax && (v = (long)(ptr - line)) > 0)
+		{
+		    /* Get the syntax attribute for the character.  If there
+		     * is an error, disable syntax highlighting. */
+		    save_did_emsg = did_emsg;
+		    did_emsg = FALSE;
+
+		    syntax_attr = get_syntax_attr((colnr_T)v - 1);
+
+		    if (did_emsg)
+			syntax_clear(wp->w_buffer);
+		    else
+			did_emsg = save_did_emsg;
+
+		    /* Need to get the line again, a multi-line regexp may
+		     * have made it invalid. */
+		    line = ml_get_buf(wp->w_buffer, lnum, FALSE);
+		    ptr = line + v;
+
+		    if (area_attr == 0 && search_attr == 0)
+			char_attr = syntax_attr;
+		}
+#endif
+#ifdef FEAT_LINEBREAK
+		/*
+		 * Found last space before word: check for line break
+		 */
+		if (wp->w_p_lbr && vim_isbreak(c) && !vim_isbreak(*ptr)
+						      && !wp->w_p_list)
+		{
+		    n_extra = win_lbr_chartabsize(wp, ptr - (
+# ifdef FEAT_MBYTE
+				has_mbyte ? mb_l :
+# endif
+				1), (colnr_T)vcol, NULL) - 1;
+		    c_extra = ' ';
+		    if (vim_iswhite(c))
+			c = ' ';
+		}
+#endif
+
+		if (trailcol != MAXCOL && ptr > line + trailcol && c == ' ')
+		{
+		    c = lcs_trail;
+		    if (area_attr == 0 && search_attr == 0)
+		    {
+			n_attr = 1;
+			extra_attr = hl_attr(HLF_8);
+			saved_attr2 = char_attr; /* save current attr */
+		    }
+#ifdef FEAT_MBYTE
+		    mb_c = c;
+		    if (enc_utf8 && (*mb_char2len)(c) > 1)
+		    {
+			mb_utf8 = TRUE;
+			u8c_c1 = u8c_c2 = 0;
+		    }
+		    else
+			mb_utf8 = FALSE;
+#endif
+		}
+	    }
+
+	    /*
+	     * Handling of non-printable characters.
+	     */
+	    if (!(chartab[c] & CT_PRINT_CHAR))
+	    {
+		/*
+		 * when getting a character from the file, we may have to
+		 * turn it into something else on the way to putting it
+		 * into "ScreenLines".
+		 */
+		if (c == TAB && (!wp->w_p_list || lcs_tab1))
+		{
+		    /* tab amount depends on current column */
+		    n_extra = (int)wp->w_buffer->b_p_ts
+				   - vcol % (int)wp->w_buffer->b_p_ts - 1;
+#ifdef FEAT_MBYTE
+		    mb_utf8 = FALSE;	/* don't draw as UTF-8 */
+#endif
+		    if (wp->w_p_list)
+		    {
+			c = lcs_tab1;
+			c_extra = lcs_tab2;
+			n_attr = n_extra + 1;
+			extra_attr = hl_attr(HLF_8);
+			saved_attr2 = char_attr; /* save current attr */
+#ifdef FEAT_MBYTE
+			mb_c = c;
+			if (enc_utf8 && (*mb_char2len)(c) > 1)
+			{
+			    mb_utf8 = TRUE;
+			    u8c_c1 = u8c_c2 = 0;
+			}
+#endif
+		    }
+		    else
+		    {
+			c_extra = ' ';
+			c = ' ';
+		    }
+		}
+		else if (c == NUL && wp->w_p_list && lcs_eol_one > 0)
+		{
+#if defined(FEAT_DIFF) || defined(LINE_ATTR)
+		    /* For a diff line the highlighting continues after the
+		     * "$". */
+		    if (
+# ifdef FEAT_DIFF
+			    diff_hlf == (enum hlf_value)0
+#  ifdef LINE_ATTR
+			    &&
+#  endif
+# endif
+# ifdef LINE_ATTR
+			    line_attr == 0
+# endif
+		       )
+#endif
+		    {
+#ifdef FEAT_VIRTUALEDIT
+			/* In virtualedit, visual selections may extend
+			 * beyond end of line. */
+			if (area_highlighting && virtual_active()
+				&& tocol != MAXCOL && vcol < tocol)
+			    n_extra = 0;
+			else
+#endif
+			{
+			    p_extra = at_end_str;
+			    n_extra = 1;
+			    c_extra = NUL;
+			}
+		    }
+		    c = lcs_eol;
+		    lcs_eol_one = -1;
+		    --ptr;	    /* put it back at the NUL */
+		    if (area_attr == 0 && search_attr == 0)
+		    {
+			extra_attr = hl_attr(HLF_AT);
+			n_attr = 1;
+		    }
+#ifdef FEAT_MBYTE
+		    mb_c = c;
+		    if (enc_utf8 && (*mb_char2len)(c) > 1)
+		    {
+			mb_utf8 = TRUE;
+			u8c_c1 = u8c_c2 = 0;
+		    }
+		    else
+			mb_utf8 = FALSE;	/* don't draw as UTF-8 */
+#endif
+		}
+		else if (c != NUL)
+		{
+		    p_extra = transchar(c);
+#ifdef FEAT_RIGHTLEFT
+		    if ((dy_flags & DY_UHEX) && wp->w_p_rl)
+			rl_mirror(p_extra);	/* reverse "<12>" */
+#endif
+		    n_extra = byte2cells(c) - 1;
+		    c_extra = NUL;
+		    c = *p_extra++;
+		    if (area_attr == 0 && search_attr == 0)
+		    {
+			n_attr = n_extra + 1;
+			extra_attr = hl_attr(HLF_8);
+			saved_attr2 = char_attr; /* save current attr */
+		    }
+#ifdef FEAT_MBYTE
+		    mb_utf8 = FALSE;	/* don't draw as UTF-8 */
+#endif
+		}
+#ifdef FEAT_VIRTUALEDIT
+		else if (VIsual_active
+			 && (VIsual_mode == Ctrl_V
+			     || VIsual_mode == 'v')
+			 && virtual_active()
+			 && tocol != MAXCOL
+			 && vcol < tocol
+			 && (
+# ifdef FEAT_RIGHTLEFT
+			    wp->w_p_rl ? (col >= 0) :
+# endif
+			    (col < W_WIDTH(wp))))
+		{
+		    c = ' ';
+		    --ptr;	    /* put it back at the NUL */
+		}
+#endif
+#if defined(FEAT_DIFF) || defined(LINE_ATTR)
+		else if ((
+# ifdef FEAT_DIFF
+			    diff_hlf != (enum hlf_value)0
+#  ifdef LINE_ATTR
+			    ||
+#  endif
+# endif
+# ifdef LINE_ATTR
+			    line_attr != 0
+# endif
+			) && (
+# ifdef FEAT_RIGHTLEFT
+			    wp->w_p_rl ? (col >= 0) :
+# endif
+			    (col < W_WIDTH(wp))))
+		{
+		    /* Highlight until the right side of the window */
+		    c = ' ';
+		    --ptr;	    /* put it back at the NUL */
+# ifdef FEAT_DIFF
+		    if (diff_hlf == HLF_TXD)
+		    {
+			diff_hlf = HLF_CHD;
+			if (attr == 0 || char_attr != attr)
+			    char_attr = hl_attr(diff_hlf);
+		    }
+# endif
+		}
+#endif
+	    }
+	}
+
+	/* Don't override visual selection highlighting. */
+	if (n_attr > 0
+		&& draw_state == WL_LINE
+		&& (area_attr == 0 || char_attr != area_attr)
+		&& (search_attr == 0 || char_attr != search_attr))
+	    char_attr = extra_attr;
+
+#if defined(FEAT_XIM) && defined(FEAT_GUI_GTK)
+	/* XIM don't send preedit_start and preedit_end, but they send
+	 * preedit_changed and commit.  Thus Vim can't set "im_is_active", use
+	 * im_is_preediting() here. */
+	if (xic != NULL
+		&& lnum == curwin->w_cursor.lnum
+		&& (State & INSERT)
+		&& !p_imdisable
+		&& im_is_preediting()
+		&& draw_state == WL_LINE)
+	{
+	    colnr_T tcol;
+
+	    if (preedit_end_col == MAXCOL)
+		getvcol(curwin, &(curwin->w_cursor), &tcol, NULL, NULL);
+	    else
+		tcol = preedit_end_col;
+	    if ((long)preedit_start_col <= vcol && vcol < (long)tcol)
+	    {
+		if (feedback_old_attr < 0)
+		{
+		    feedback_col = 0;
+		    feedback_old_attr = char_attr;
+		}
+		char_attr = im_get_feedback_attr(feedback_col);
+		if (char_attr < 0)
+		    char_attr = feedback_old_attr;
+		feedback_col++;
+	    }
+	    else if (feedback_old_attr >= 0)
+	    {
+		char_attr = feedback_old_attr;
+		feedback_old_attr = -1;
+		feedback_col = 0;
+	    }
+	}
+#endif
+	/*
+	 * Handle the case where we are in column 0 but not on the first
+	 * character of the line and the user wants us to show us a
+	 * special character (via 'listchars' option "precedes:<char>".
+	 */
+	if (lcs_prec_todo != NUL
+		&& (wp->w_p_wrap ? wp->w_skipcol > 0 : wp->w_leftcol > 0)
+#ifdef FEAT_DIFF
+		&& filler_todo <= 0
+#endif
+		&& draw_state > WL_NR
+		&& c != NUL)
+	{
+	    c = lcs_prec;
+	    lcs_prec_todo = NUL;
+#ifdef FEAT_MBYTE
+	    mb_c = c;
+	    if (enc_utf8 && (*mb_char2len)(c) > 1)
+	    {
+		mb_utf8 = TRUE;
+		u8c_c1 = u8c_c2 = 0;
+	    }
+	    else
+		mb_utf8 = FALSE;	/* don't draw as UTF-8 */
+#endif
+	    if ((area_attr == 0 || char_attr != area_attr)
+		    && (search_attr == 0 || char_attr != search_attr))
+	    {
+		saved_attr3 = char_attr; /* save current attr */
+		char_attr = hl_attr(HLF_AT); /* later copied to char_attr */
+		n_attr3 = 1;
+	    }
+	}
+
+	/*
+	 * At end of the text line.
+	 */
+	if (c == NUL)
+	{
+	    /* invert at least one char, used for Visual and empty line or
+	     * highlight match at end of line. If it's beyond the last
+	     * char on the screen, just overwrite that one (tricky!)  Not
+	     * needed when a '$' was displayed for 'list'. */
+	    if (lcs_eol == lcs_eol_one
+		    && ((area_attr != 0 && vcol == fromcol)
+#ifdef FEAT_SEARCH_EXTRA
+			/* highlight 'hlsearch' match at end of line */
+			|| ptr - 1 == search_hl.startp
+			|| ptr - 1 == match_hl.startp
+#endif
+		       ))
+	    {
+		int n = 0;
+
+#ifdef FEAT_RIGHTLEFT
+		if (wp->w_p_rl)
+		{
+		    if (col < 0)
+			n = 1;
+		}
+		else
+#endif
+		{
+		    if (col >= W_WIDTH(wp))
+			n = -1;
+		}
+		if (n != 0)
+		{
+		    /* At the window boundary, highlight the last character
+		     * instead (better than nothing). */
+		    off += n;
+		    col += n;
+		}
+		else
+		{
+		    /* Add a blank character to highlight. */
+		    ScreenLines[off] = ' ';
+#ifdef FEAT_MBYTE
+		    if (enc_utf8)
+			ScreenLinesUC[off] = 0;
+#endif
+		}
+#ifdef FEAT_SEARCH_EXTRA
+		if (area_attr == 0)
+		{
+		    if (ptr - 1 == match_hl.startp)
+			char_attr = match_hl.attr;
+		    else
+			char_attr = search_hl.attr;
+		}
+#endif
+		ScreenAttrs[off] = char_attr;
+#ifdef FEAT_RIGHTLEFT
+		if (wp->w_p_rl)
+		    --col;
+		else
+#endif
+		    ++col;
+	    }
+
+	    SCREEN_LINE(screen_row, W_WINCOL(wp), col, (int)W_WIDTH(wp),
+								  wp->w_p_rl);
+	    row++;
+
+	    /*
+	     * 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)
+	    {
+		curwin->w_cline_row = startrow;
+		curwin->w_cline_height = row - startrow;
+#ifdef FEAT_FOLDING
+		curwin->w_cline_folded = FALSE;
+#endif
+		curwin->w_valid |= (VALID_CHEIGHT|VALID_CROW);
+	    }
+
+	    break;
+	}
+
+	/* line continues beyond line end */
+	if (lcs_ext
+		&& !wp->w_p_wrap
+#ifdef FEAT_DIFF
+		&& filler_todo <= 0
+#endif
+		&& (
+#ifdef FEAT_RIGHTLEFT
+		    wp->w_p_rl ? col == 0 :
+#endif
+		    col == W_WIDTH(wp) - 1)
+		&& (*ptr != NUL
+		    || (wp->w_p_list && lcs_eol != NUL && p_extra != at_end_str)
+		    || (n_extra && (c_extra != NUL || *p_extra != NUL))))
+	{
+	    c = lcs_ext;
+	    char_attr = hl_attr(HLF_AT);
+#ifdef FEAT_MBYTE
+	    mb_c = c;
+	    if (enc_utf8 && (*mb_char2len)(c) > 1)
+	    {
+		mb_utf8 = TRUE;
+		u8c_c1 = u8c_c2 = 0;
+	    }
+	    else
+		mb_utf8 = FALSE;
+#endif
+	}
+
+	/*
+	 * Store character to be displayed.
+	 * Skip characters that are left of the screen for 'nowrap'.
+	 */
+	vcol_prev = vcol;
+	if (draw_state < WL_LINE || n_skip <= 0)
+	{
+	    /*
+	     * Store the character.
+	     */
+#if defined(FEAT_RIGHTLEFT) && defined(FEAT_MBYTE)
+	    if (has_mbyte && wp->w_p_rl && (*mb_char2cells)(mb_c) > 1)
+	    {
+		/* A double-wide character is: put first halve in left cell. */
+		--off;
+		--col;
+	    }
+#endif
+	    ScreenLines[off] = c;
+#ifdef FEAT_MBYTE
+	    if (enc_dbcs == DBCS_JPNU)
+		ScreenLines2[off] = mb_c & 0xff;
+	    else if (enc_utf8)
+	    {
+		if (mb_utf8)
+		{
+		    ScreenLinesUC[off] = mb_c;
+		    ScreenLinesC1[off] = u8c_c1;
+		    ScreenLinesC2[off] = u8c_c2;
+		}
+		else
+		    ScreenLinesUC[off] = 0;
+	    }
+	    if (multi_attr)
+	    {
+		ScreenAttrs[off] = multi_attr;
+		multi_attr = 0;
+	    }
+	    else
+#endif
+		ScreenAttrs[off] = char_attr;
+
+#ifdef FEAT_MBYTE
+	    if (has_mbyte && (*mb_char2cells)(mb_c) > 1)
+	    {
+		/* Need to fill two screen columns. */
+		++off;
+		++col;
+		if (enc_utf8)
+		    /* UTF-8: Put a 0 in the second screen char. */
+		    ScreenLines[off] = 0;
+		else
+		    /* DBCS: Put second byte in the second screen char. */
+		    ScreenLines[off] = mb_c & 0xff;
+		++vcol;
+		/* When "tocol" is halfway a character, set it to the end of
+		 * the character, otherwise highlighting won't stop. */
+		if (tocol == vcol)
+		    ++tocol;
+#ifdef FEAT_RIGHTLEFT
+		if (wp->w_p_rl)
+		{
+		    /* now it's time to backup one cell */
+		    --off;
+		    --col;
+		}
+#endif
+	    }
+#endif
+#ifdef FEAT_RIGHTLEFT
+	    if (wp->w_p_rl)
+	    {
+		--off;
+		--col;
+	    }
+	    else
+#endif
+	    {
+		++off;
+		++col;
+	    }
+	}
+	else
+	    --n_skip;
+
+	/* Only advance the "vcol" when after the 'number' column. */
+	if (draw_state >= WL_SBR
+#ifdef FEAT_DIFF
+		&& filler_todo <= 0
+#endif
+		)
+	    ++vcol;
+
+	/* restore attributes after "predeces" in 'listchars' */
+	if (draw_state > WL_NR && n_attr3 > 0 && --n_attr3 == 0)
+	    char_attr = saved_attr3;
+
+	/* restore attributes after last 'listchars' or 'number' char */
+	if (n_attr > 0 && draw_state == WL_LINE && --n_attr == 0)
+	    char_attr = saved_attr2;
+
+	/*
+	 * At end of screen line and there is more to come: Display the line
+	 * so far.  If there is no more to display it is catched above.
+	 */
+	if ((
+#ifdef FEAT_RIGHTLEFT
+	    wp->w_p_rl ? (col < 0) :
+#endif
+				    (col >= W_WIDTH(wp)))
+		&& (*ptr != NUL
+#ifdef FEAT_DIFF
+		    || filler_todo > 0
+#endif
+		    || (wp->w_p_list && lcs_eol != NUL && p_extra != at_end_str)
+		    || (n_extra != 0 && (c_extra != NUL || *p_extra != NUL)))
+		)
+	{
+	    SCREEN_LINE(screen_row, W_WINCOL(wp), col, (int)W_WIDTH(wp),
+								  wp->w_p_rl);
+	    ++row;
+	    ++screen_row;
+
+	    /* When not wrapping and finished diff lines, or when displayed
+	     * '$' and highlighting until last column, break here. */
+	    if ((!wp->w_p_wrap
+#ifdef FEAT_DIFF
+		    && filler_todo <= 0
+#endif
+		    ) || lcs_eol_one == -1)
+		break;
+
+	    /* When the window is too narrow draw all "@" lines. */
+	    if (draw_state != WL_LINE
+#ifdef FEAT_DIFF
+		    && filler_todo <= 0
+#endif
+		    )
+	    {
+		win_draw_end(wp, '@', ' ', row, wp->w_height, HLF_AT);
+#ifdef FEAT_VERTSPLIT
+		draw_vsep_win(wp, row);
+#endif
+		row = endrow;
+	    }
+
+	    /* When line got too long for screen break here. */
+	    if (row == endrow)
+	    {
+		++row;
+		break;
+	    }
+
+	    if (screen_cur_row == screen_row - 1
+#ifdef FEAT_DIFF
+		     && filler_todo <= 0
+#endif
+		     && W_WIDTH(wp) == Columns)
+	    {
+		/* Remember that the line wraps, used for modeless copy. */
+		LineWraps[screen_row - 1] = TRUE;
+
+		/*
+		 * Special trick to make copy/paste of wrapped lines work with
+		 * xterm/screen: write an extra character beyond the end of
+		 * the line. This will work with all terminal types
+		 * (regardless of the xn,am settings).
+		 * Only do this on a fast tty.
+		 * Only do this if the cursor is on the current line
+		 * (something has been written in it).
+		 * Don't do this for the GUI.
+		 * Don't do this for double-width characters.
+		 * Don't do this for a window not at the right screen border.
+		 */
+		if (p_tf
+#ifdef FEAT_GUI
+			 && !gui.in_use
+#endif
+#ifdef FEAT_MBYTE
+			 && !(has_mbyte
+			     && ((*mb_off2cells)(LineOffset[screen_row]) == 2
+				 || (*mb_off2cells)(LineOffset[screen_row - 1]
+							+ (int)Columns - 2) == 2))
+#endif
+		   )
+		{
+		    /* First make sure we are at the end of the screen line,
+		     * then output the same character again to let the
+		     * terminal know about the wrap.  If the terminal doesn't
+		     * auto-wrap, we overwrite the character. */
+		    if (screen_cur_col != W_WIDTH(wp))
+			screen_char(LineOffset[screen_row - 1]
+						      + (unsigned)Columns - 1,
+					  screen_row - 1, (int)(Columns - 1));
+
+#ifdef FEAT_MBYTE
+		    /* When there is a multi-byte character, just output a
+		     * space to keep it simple. */
+		    if (has_mbyte && mb_off2cells(LineOffset[screen_row - 1]
+						+ (unsigned)Columns - 1) != 1)
+			out_char(' ');
+		    else
+#endif
+			out_char(ScreenLines[LineOffset[screen_row - 1]
+							    + (Columns - 1)]);
+		    /* force a redraw of the first char on the next line */
+		    ScreenAttrs[LineOffset[screen_row]] = (sattr_T)-1;
+		    screen_start();	/* don't know where cursor is now */
+		}
+	    }
+
+	    col = 0;
+	    off = (unsigned)(current_ScreenLine - ScreenLines);
+#ifdef FEAT_RIGHTLEFT
+	    if (wp->w_p_rl)
+	    {
+		col = W_WIDTH(wp) - 1;	/* col is not used if breaking! */
+		off += col;
+	    }
+#endif
+
+	    /* reset the drawing state for the start of a wrapped line */
+	    draw_state = WL_START;
+	    saved_n_extra = n_extra;
+	    saved_p_extra = p_extra;
+	    saved_c_extra = c_extra;
+	    saved_char_attr = char_attr;
+	    n_extra = 0;
+	    lcs_prec_todo = lcs_prec;
+#ifdef FEAT_LINEBREAK
+# ifdef FEAT_DIFF
+	    if (filler_todo <= 0)
+# endif
+		need_showbreak = TRUE;
+#endif
+#ifdef FEAT_DIFF
+	    --filler_todo;
+	    /* When the filler lines are actually below the last line of the
+	     * file, don't draw the line itself, break here. */
+	    if (filler_todo == 0 && wp->w_botfill)
+		break;
+#endif
+	}
+
+    }	/* for every character in the line */
+
+    return row;
+}
+
+/*
+ * Check whether the given character needs redrawing:
+ * - the (first byte of the) character is different
+ * - the attributes are different
+ * - the character is multi-byte and the next byte is different
+ */
+    static int
+char_needs_redraw(off_from, off_to, cols)
+    int		off_from;
+    int		off_to;
+    int		cols;
+{
+    if (cols > 0
+	    && ((ScreenLines[off_from] != ScreenLines[off_to]
+		    || ScreenAttrs[off_from] != ScreenAttrs[off_to])
+
+#ifdef FEAT_MBYTE
+		|| (enc_dbcs != 0
+		    && MB_BYTE2LEN(ScreenLines[off_from]) > 1
+		    && (enc_dbcs == DBCS_JPNU && ScreenLines[off_from] == 0x8e
+			? ScreenLines2[off_from] != ScreenLines2[off_to]
+			: (cols > 1 && ScreenLines[off_from + 1]
+						 != ScreenLines[off_to + 1])))
+		|| (enc_utf8
+		    && (ScreenLinesUC[off_from] != ScreenLinesUC[off_to]
+			|| (ScreenLinesUC[off_from] != 0
+			    && (ScreenLinesC1[off_from]
+						      != ScreenLinesC1[off_to]
+				|| ScreenLinesC2[off_from]
+						  != ScreenLinesC2[off_to]))))
+#endif
+	       ))
+	return TRUE;
+    return FALSE;
+}
+
+/*
+ * Move one "cooked" screen line to the screen, but only the characters that
+ * have actually changed.  Handle insert/delete character.
+ * "coloff" gives the first column on the screen for this line.
+ * "endcol" gives the columns where valid characters are.
+ * "clear_width" is the width of the window.  It's > 0 if the rest of the line
+ * needs to be cleared, negative otherwise.
+ * "rlflag" is TRUE in a rightleft window:
+ *    When TRUE and "clear_width" > 0, clear columns 0 to "endcol"
+ *    When FALSE and "clear_width" > 0, clear columns "endcol" to "clear_width"
+ */
+    static void
+screen_line(row, coloff, endcol, clear_width
+#ifdef FEAT_RIGHTLEFT
+				    , rlflag
+#endif
+						)
+    int	    row;
+    int	    coloff;
+    int	    endcol;
+    int	    clear_width;
+#ifdef FEAT_RIGHTLEFT
+    int	    rlflag;
+#endif
+{
+    unsigned	    off_from;
+    unsigned	    off_to;
+    int		    col = 0;
+#if defined(FEAT_GUI) || defined(UNIX) || defined(FEAT_VERTSPLIT)
+    int		    hl;
+#endif
+    int		    force = FALSE;	/* force update rest of the line */
+    int		    redraw_this		/* bool: does character need redraw? */
+#ifdef FEAT_GUI
+				= TRUE	/* For GUI when while-loop empty */
+#endif
+				;
+    int		    redraw_next;	/* redraw_this for next character */
+#ifdef FEAT_MBYTE
+    int		    clear_next = FALSE;
+    int		    char_cells;		/* 1: normal char */
+					/* 2: occupies two display cells */
+# define CHAR_CELLS char_cells
+#else
+# define CHAR_CELLS 1
+#endif
+
+# ifdef FEAT_CLIPBOARD
+    clip_may_clear_selection(row, row);
+# endif
+
+    off_from = (unsigned)(current_ScreenLine - ScreenLines);
+    off_to = LineOffset[row] + coloff;
+
+#ifdef FEAT_RIGHTLEFT
+    if (rlflag)
+    {
+	/* Clear rest first, because it's left of the text. */
+	if (clear_width > 0)
+	{
+	    while (col <= endcol && ScreenLines[off_to] == ' '
+		    && ScreenAttrs[off_to] == 0
+# ifdef FEAT_MBYTE
+				  && (!enc_utf8 || ScreenLinesUC[off_to] == 0)
+# endif
+						  )
+	    {
+		++off_to;
+		++col;
+	    }
+	    if (col <= endcol)
+		screen_fill(row, row + 1, col + coloff,
+					    endcol + coloff + 1, ' ', ' ', 0);
+	}
+	col = endcol + 1;
+	off_to = LineOffset[row] + col + coloff;
+	off_from += col;
+	endcol = (clear_width > 0 ? clear_width : -clear_width);
+    }
+#endif /* FEAT_RIGHTLEFT */
+
+    redraw_next = char_needs_redraw(off_from, off_to, endcol - col);
+
+    while (col < endcol)
+    {
+#ifdef FEAT_MBYTE
+	if (has_mbyte && (col + 1 < endcol))
+	    char_cells = (*mb_off2cells)(off_from);
+	else
+	    char_cells = 1;
+#endif
+
+	redraw_this = redraw_next;
+	redraw_next = force || char_needs_redraw(off_from + CHAR_CELLS,
+			      off_to + CHAR_CELLS, endcol - col - CHAR_CELLS);
+
+#ifdef FEAT_GUI
+	/* If the next character was bold, then redraw the current character to
+	 * remove any pixels that might have spilt over into us.  This only
+	 * happens in the GUI.
+	 */
+	if (redraw_next && gui.in_use)
+	{
+	    hl = ScreenAttrs[off_to + CHAR_CELLS];
+	    if (hl > HL_ALL || (hl & HL_BOLD))
+		redraw_this = TRUE;
+	}
+#endif
+
+	if (redraw_this)
+	{
+	    /*
+	     * Special handling when 'xs' termcap flag set (hpterm):
+	     * Attributes for characters are stored at the position where the
+	     * cursor is when writing the highlighting code.  The
+	     * start-highlighting code must be written with the cursor on the
+	     * first highlighted character.  The stop-highlighting code must
+	     * be written with the cursor just after the last highlighted
+	     * character.
+	     * Overwriting a character doesn't remove it's highlighting.  Need
+	     * to clear the rest of the line, and force redrawing it
+	     * completely.
+	     */
+	    if (       p_wiv
+		    && !force
+#ifdef FEAT_GUI
+		    && !gui.in_use
+#endif
+		    && ScreenAttrs[off_to] != 0
+		    && ScreenAttrs[off_from] != ScreenAttrs[off_to])
+	    {
+		/*
+		 * Need to remove highlighting attributes here.
+		 */
+		windgoto(row, col + coloff);
+		out_str(T_CE);		/* clear rest of this screen line */
+		screen_start();		/* don't know where cursor is now */
+		force = TRUE;		/* force redraw of rest of the line */
+		redraw_next = TRUE;	/* or else next char would miss out */
+
+		/*
+		 * If the previous character was highlighted, need to stop
+		 * highlighting at this character.
+		 */
+		if (col + coloff > 0 && ScreenAttrs[off_to - 1] != 0)
+		{
+		    screen_attr = ScreenAttrs[off_to - 1];
+		    term_windgoto(row, col + coloff);
+		    screen_stop_highlight();
+		}
+		else
+		    screen_attr = 0;	    /* highlighting has stopped */
+	    }
+#ifdef FEAT_MBYTE
+	    if (enc_dbcs != 0)
+	    {
+		/* Check if overwriting a double-byte with a single-byte or
+		 * the other way around requires another character to be
+		 * redrawn.  For UTF-8 this isn't needed, because comparing
+		 * ScreenLinesUC[] is sufficient. */
+		if (char_cells == 1
+			&& col + 1 < endcol
+			&& (*mb_off2cells)(off_to) > 1)
+		{
+		    /* Writing a single-cell character over a double-cell
+		     * character: need to redraw the next cell. */
+		    ScreenLines[off_to + 1] = 0;
+		    redraw_next = TRUE;
+		}
+		else if (char_cells == 2
+			&& col + 2 < endcol
+			&& (*mb_off2cells)(off_to) == 1
+			&& (*mb_off2cells)(off_to + 1) > 1)
+		{
+		    /* Writing the second half of a double-cell character over
+		     * a double-cell character: need to redraw the second
+		     * cell. */
+		    ScreenLines[off_to + 2] = 0;
+		    redraw_next = TRUE;
+		}
+
+		if (enc_dbcs == DBCS_JPNU)
+		    ScreenLines2[off_to] = ScreenLines2[off_from];
+	    }
+	    /* When writing a single-width character over a double-width
+	     * character and at the end of the redrawn text, need to clear out
+	     * the right halve of the old character.
+	     * Also required when writing the right halve of a double-width
+	     * char over the left halve of an existing one. */
+	    if (has_mbyte && col + char_cells == endcol
+		    && ((char_cells == 1
+			    && (*mb_off2cells)(off_to) > 1)
+			|| (char_cells == 2
+			    && (*mb_off2cells)(off_to) == 1
+			    && (*mb_off2cells)(off_to + 1) > 1)))
+		clear_next = TRUE;
+#endif
+
+	    ScreenLines[off_to] = ScreenLines[off_from];
+#ifdef FEAT_MBYTE
+	    if (enc_utf8)
+	    {
+		ScreenLinesUC[off_to] = ScreenLinesUC[off_from];
+		if (ScreenLinesUC[off_from] != 0)
+		{
+		    ScreenLinesC1[off_to] = ScreenLinesC1[off_from];
+		    ScreenLinesC2[off_to] = ScreenLinesC2[off_from];
+		}
+	    }
+	    if (char_cells == 2)
+		ScreenLines[off_to + 1] = ScreenLines[off_from + 1];
+#endif
+
+#if defined(FEAT_GUI) || defined(UNIX)
+	    /* The bold trick makes a single row of pixels appear in the next
+	     * character.  When a bold character is removed, the next
+	     * character should be redrawn too.  This happens for our own GUI
+	     * and for some xterms. */
+	    if (
+# ifdef FEAT_GUI
+		    gui.in_use
+# endif
+# if defined(FEAT_GUI) && defined(UNIX)
+		    ||
+# endif
+# ifdef UNIX
+		    term_is_xterm
+# endif
+		    )
+	    {
+		hl = ScreenAttrs[off_to];
+		if (hl > HL_ALL || (hl & HL_BOLD))
+		    redraw_next = TRUE;
+	    }
+#endif
+	    ScreenAttrs[off_to] = ScreenAttrs[off_from];
+#ifdef FEAT_MBYTE
+	    if (enc_dbcs != 0 && char_cells == 2)
+	    {
+		/* just a hack: It makes two bytes of DBCS have same attr */
+		ScreenAttrs[off_to + 1] = ScreenAttrs[off_from];
+		screen_char_2(off_to, row, col + coloff);
+	    }
+	    else
+#endif
+		screen_char(off_to, row, col + coloff);
+	}
+	else if (  p_wiv
+#ifdef FEAT_GUI
+		&& !gui.in_use
+#endif
+		&& col + coloff > 0)
+	{
+	    if (ScreenAttrs[off_to] == ScreenAttrs[off_to - 1])
+	    {
+		/*
+		 * Don't output stop-highlight when moving the cursor, it will
+		 * stop the highlighting when it should continue.
+		 */
+		screen_attr = 0;
+	    }
+	    else if (screen_attr != 0)
+		screen_stop_highlight();
+	}
+
+	off_to += CHAR_CELLS;
+	off_from += CHAR_CELLS;
+	col += CHAR_CELLS;
+    }
+
+#ifdef FEAT_MBYTE
+    if (clear_next)
+    {
+	/* Clear the second half of a double-wide character of which the left
+	 * half was overwritten with a single-wide character. */
+	ScreenLines[off_to] = ' ';
+	if (enc_utf8)
+	    ScreenLinesUC[off_to] = 0;
+	screen_char(off_to, row, col + coloff);
+    }
+#endif
+
+    if (clear_width > 0
+#ifdef FEAT_RIGHTLEFT
+		    && !rlflag
+#endif
+				   )
+    {
+#ifdef FEAT_GUI
+	int startCol = col;
+#endif
+
+	/* blank out the rest of the line */
+	while (col < clear_width && ScreenLines[off_to] == ' '
+						  && ScreenAttrs[off_to] == 0
+#ifdef FEAT_MBYTE
+				  && (!enc_utf8 || ScreenLinesUC[off_to] == 0)
+#endif
+						  )
+	{
+	    ++off_to;
+	    ++col;
+	}
+	if (col < clear_width)
+	{
+#ifdef FEAT_GUI
+	    /*
+	     * In the GUI, clearing the rest of the line may leave pixels
+	     * behind if the first character cleared was bold.  Some bold
+	     * fonts spill over the left.  In this case we redraw the previous
+	     * character too.  If we didn't skip any blanks above, then we
+	     * only redraw if the character wasn't already redrawn anyway.
+	     */
+	    if (gui.in_use && (col > startCol || !redraw_this)
+# ifdef FEAT_MBYTE
+		    && enc_dbcs == 0
+# endif
+	       )
+	    {
+		hl = ScreenAttrs[off_to];
+		if (hl > HL_ALL || (hl & HL_BOLD))
+		    screen_char(off_to - 1, row, col + coloff - 1);
+	    }
+#endif
+	    screen_fill(row, row + 1, col + coloff, clear_width + coloff,
+								 ' ', ' ', 0);
+#ifdef FEAT_VERTSPLIT
+	    off_to += clear_width - col;
+	    col = clear_width;
+#endif
+	}
+    }
+
+    if (clear_width > 0)
+    {
+#ifdef FEAT_VERTSPLIT
+	/* For a window that's left of another, draw the separator char. */
+	if (col + coloff < Columns)
+	{
+	    int c;
+
+	    c = fillchar_vsep(&hl);
+	    if (ScreenLines[off_to] != c
+# ifdef FEAT_MBYTE
+		    || (enc_utf8
+			      && ScreenLinesUC[off_to] != (c >= 0x80 ? c : 0))
+# endif
+		    || ScreenAttrs[off_to] != hl)
+	    {
+		ScreenLines[off_to] = c;
+		ScreenAttrs[off_to] = hl;
+# ifdef FEAT_MBYTE
+		if (enc_utf8)
+		{
+		    if (c >= 0x80)
+		    {
+			ScreenLinesUC[off_to] = c;
+			ScreenLinesC1[off_to] = 0;
+			ScreenLinesC2[off_to] = 0;
+		    }
+		    else
+			ScreenLinesUC[off_to] = 0;
+		}
+# endif
+		screen_char(off_to, row, col + coloff);
+	    }
+	}
+	else
+#endif
+	    LineWraps[row] = FALSE;
+    }
+}
+
+#ifdef FEAT_RIGHTLEFT
+/*
+ * Mirror text "str" for right-lieft displaying.
+ */
+    static void
+rl_mirror(str)
+    char_u	*str;
+{
+    char_u	*p1, *p2;
+    int		t;
+
+    for (p1 = str, p2 = str + STRLEN(str) - 1; p1 < p2; ++p1, --p2)
+    {
+	t = *p1;
+	*p1 = *p2;
+	*p2 = t;
+    }
+}
+#endif
+
+#if defined(FEAT_WINDOWS) || defined(PROTO)
+/*
+ * mark all status lines for redraw; used after first :cd
+ */
+    void
+status_redraw_all()
+{
+    win_T	*wp;
+
+    for (wp = firstwin; wp; wp = wp->w_next)
+	if (wp->w_status_height)
+	{
+	    wp->w_redr_status = TRUE;
+	    redraw_later(VALID);
+	}
+}
+
+/*
+ * mark all status lines of the current buffer for redraw
+ */
+    void
+status_redraw_curbuf()
+{
+    win_T	*wp;
+
+    for (wp = firstwin; wp; wp = wp->w_next)
+	if (wp->w_status_height != 0 && wp->w_buffer == curbuf)
+	{
+	    wp->w_redr_status = TRUE;
+	    redraw_later(VALID);
+	}
+}
+
+/*
+ * Redraw all status lines that need to be redrawn.
+ */
+    void
+redraw_statuslines()
+{
+    win_T	*wp;
+
+    for (wp = firstwin; wp; wp = wp->w_next)
+	if (wp->w_redr_status)
+	    win_redr_status(wp);
+}
+#endif
+
+#if (defined(FEAT_WILDMENU) && defined(FEAT_VERTSPLIT)) || defined(PROTO)
+/*
+ * Redraw all status lines at the bottom of frame "frp".
+ */
+    void
+win_redraw_last_status(frp)
+    frame_T	*frp;
+{
+    if (frp->fr_layout == FR_LEAF)
+	frp->fr_win->w_redr_status = TRUE;
+    else if (frp->fr_layout == FR_ROW)
+    {
+	for (frp = frp->fr_child; frp != NULL; frp = frp->fr_next)
+	    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);
+    }
+}
+#endif
+
+#ifdef FEAT_VERTSPLIT
+/*
+ * Draw the verticap separator right of window "wp" starting with line "row".
+ */
+    static void
+draw_vsep_win(wp, row)
+    win_T	*wp;
+    int		row;
+{
+    int		hl;
+    int		c;
+
+    if (wp->w_vsep_width)
+    {
+	/* draw the vertical separator right of this window */
+	c = fillchar_vsep(&hl);
+	screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + wp->w_height,
+		W_ENDCOL(wp), W_ENDCOL(wp) + 1,
+		c, ' ', hl);
+    }
+}
+#endif
+
+#ifdef FEAT_WILDMENU
+static int status_match_len __ARGS((expand_T *xp, char_u *s));
+
+/*
+ * Get the lenght of an item as it will be shown in the status line.
+ */
+    static int
+status_match_len(xp, s)
+    expand_T	*xp;
+    char_u	*s;
+{
+    int	len = 0;
+
+#ifdef FEAT_MENU
+    int emenu = (xp->xp_context == EXPAND_MENUS
+	    || xp->xp_context == EXPAND_MENUNAMES);
+
+    /* Check for menu separators - replace with '|'. */
+    if (emenu && menu_is_separator(s))
+	return 1;
+#endif
+
+    while (*s != NUL)
+    {
+	/* Don't display backslashes used for escaping, they look ugly. */
+	if (rem_backslash(s)
+#ifdef FEAT_MENU
+		|| (emenu && (s[0] == '\\' && s[1] != NUL))
+#endif
+		)
+	    ++s;
+#ifdef FEAT_MBYTE
+	if (has_mbyte)
+	{
+	    len += ptr2cells(s);
+	    s += (*mb_ptr2len_check)(s);
+	}
+	else
+#endif
+	    len += ptr2cells(s++);
+
+    }
+
+    return len;
+}
+
+/*
+ * Show wildchar matches in the status line.
+ * Show at least the "match" item.
+ * We start at item 'first_match' in the list and show all matches that fit.
+ *
+ * If inversion is possible we use it. Else '=' characters are used.
+ */
+    void
+win_redr_status_matches(xp, num_matches, matches, match, showtail)
+    expand_T	*xp;
+    int		num_matches;
+    char_u	**matches;	/* list of matches */
+    int		match;
+    int		showtail;
+{
+#define L_MATCH(m) (showtail ? sm_gettail(matches[m]) : matches[m])
+    int		row;
+    char_u	*buf;
+    int		len;
+    int		clen;		/* lenght in screen cells */
+    int		fillchar;
+    int		attr;
+    int		i;
+    int		highlight = TRUE;
+    char_u	*selstart = NULL;
+    int		selstart_col = 0;
+    char_u	*selend = NULL;
+    static int	first_match = 0;
+    int		add_left = FALSE;
+    char_u	*s;
+#ifdef FEAT_MENU
+    int		emenu;
+#endif
+#if defined(FEAT_MBYTE) || defined(FEAT_MENU)
+    int		l;
+#endif
+
+    if (matches == NULL)	/* interrupted completion? */
+	return;
+
+    buf = alloc((unsigned)Columns + 1);
+    if (buf == NULL)
+	return;
+
+    if (match == -1)	/* don't show match but original text */
+    {
+	match = 0;
+	highlight = FALSE;
+    }
+    /* count 1 for the ending ">" */
+    clen = status_match_len(xp, L_MATCH(match)) + 3;
+    if (match == 0)
+	first_match = 0;
+    else if (match < first_match)
+    {
+	/* jumping left, as far as we can go */
+	first_match = match;
+	add_left = TRUE;
+    }
+    else
+    {
+	/* check if match fits on the screen */
+	for (i = first_match; i < match; ++i)
+	    clen += status_match_len(xp, L_MATCH(i)) + 2;
+	if (first_match > 0)
+	    clen += 2;
+	/* jumping right, put match at the left */
+	if ((long)clen > Columns)
+	{
+	    first_match = match;
+	    /* if showing the last match, we can add some on the left */
+	    clen = 2;
+	    for (i = match; i < num_matches; ++i)
+	    {
+		clen += status_match_len(xp, L_MATCH(i)) + 2;
+		if ((long)clen >= Columns)
+		    break;
+	    }
+	    if (i == num_matches)
+		add_left = TRUE;
+	}
+    }
+    if (add_left)
+	while (first_match > 0)
+	{
+	    clen += status_match_len(xp, L_MATCH(first_match - 1)) + 2;
+	    if ((long)clen >= Columns)
+		break;
+	    --first_match;
+	}
+
+    fillchar = fillchar_status(&attr, TRUE);
+
+    if (first_match == 0)
+    {
+	*buf = NUL;
+	len = 0;
+    }
+    else
+    {
+	STRCPY(buf, "< ");
+	len = 2;
+    }
+    clen = len;
+
+    i = first_match;
+    while ((long)(clen + status_match_len(xp, L_MATCH(i)) + 2) < Columns)
+    {
+	if (i == match)
+	{
+	    selstart = buf + len;
+	    selstart_col = clen;
+	}
+
+	s = L_MATCH(i);
+	/* Check for menu separators - replace with '|' */
+#ifdef FEAT_MENU
+	emenu = (xp->xp_context == EXPAND_MENUS
+		|| xp->xp_context == EXPAND_MENUNAMES);
+	if (emenu && menu_is_separator(s))
+	{
+	    STRCPY(buf + len, transchar('|'));
+	    l = (int)STRLEN(buf + len);
+	    len += l;
+	    clen += l;
+	}
+	else
+#endif
+	    for ( ; *s != NUL; ++s)
+	{
+	    /* Don't display backslashes used for escaping, they look ugly. */
+	    if (rem_backslash(s)
+#ifdef FEAT_MENU
+		    || (emenu
+			  && (s[0] == '\t' || (s[0] == '\\' && s[1] != NUL)))
+#endif
+		    )
+		++s;
+	    clen += ptr2cells(s);
+#ifdef FEAT_MBYTE
+	    if (has_mbyte && (l = (*mb_ptr2len_check)(s)) > 1)
+	    {
+		STRNCPY(buf + len, s, l);
+		s += l - 1;
+		len += l;
+	    }
+	    else
+#endif
+	    {
+		STRCPY(buf + len, transchar_byte(*s));
+		len += (int)STRLEN(buf + len);
+	    }
+	}
+	if (i == match)
+	    selend = buf + len;
+
+	*(buf + len++) = ' ';
+	*(buf + len++) = ' ';
+	clen += 2;
+	if (++i == num_matches)
+		break;
+    }
+
+    if (i != num_matches)
+    {
+	*(buf + len++) = '>';
+	++clen;
+    }
+
+    buf[len] = NUL;
+
+    row = cmdline_row - 1;
+    if (row >= 0)
+    {
+	if (wild_menu_showing == 0)
+	{
+	    if (msg_scrolled > 0)
+	    {
+		/* Put the wildmenu just above the command line.  If there is
+		 * no room, scroll the screen one line up. */
+		if (cmdline_row == Rows - 1)
+		{
+		    screen_del_lines(0, 0, 1, (int)Rows, TRUE, NULL);
+		    ++msg_scrolled;
+		}
+		else
+		{
+		    ++cmdline_row;
+		    ++row;
+		}
+		wild_menu_showing = WM_SCROLLED;
+	    }
+	    else
+	    {
+		/* Create status line if needed by setting 'laststatus' to 2.
+		 * Set 'winminheight' to zero to avoid that the window is
+		 * resized. */
+		if (lastwin->w_status_height == 0)
+		{
+		    save_p_ls = p_ls;
+		    save_p_wmh = p_wmh;
+		    p_ls = 2;
+		    p_wmh = 0;
+		    last_status(FALSE);
+		}
+		wild_menu_showing = WM_SHOWN;
+	    }
+	}
+
+	screen_puts(buf, row, 0, attr);
+	if (selstart != NULL && highlight)
+	{
+	    *selend = NUL;
+	    screen_puts(selstart, row, selstart_col, hl_attr(HLF_WM));
+	}
+
+	screen_fill(row, row + 1, clen, (int)Columns, fillchar, fillchar, attr);
+    }
+
+#ifdef FEAT_VERTSPLIT
+    win_redraw_last_status(topframe);
+#else
+    lastwin->w_redr_status = TRUE;
+#endif
+    vim_free(buf);
+}
+#endif
+
+#if defined(FEAT_WINDOWS) || defined(PROTO)
+/*
+ * Redraw the status line of window wp.
+ *
+ * If inversion is possible we use it. Else '=' characters are used.
+ */
+    void
+win_redr_status(wp)
+    win_T	*wp;
+{
+    int		row;
+    char_u	*p;
+    int		len;
+    int		fillchar;
+    int		attr;
+    int		this_ru_col;
+
+    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 redraw right now, do it later. */
+	wp->w_redr_status = TRUE;
+    }
+#ifdef FEAT_STL_OPT
+    else if (*p_stl)
+    {
+	/* redraw custom status line */
+	win_redr_custom(wp, FALSE);
+    }
+#endif
+    else
+    {
+	fillchar = fillchar_status(&attr, wp == curwin);
+
+	if (buf_spname(wp->w_buffer) != NULL)
+	    STRCPY(NameBuff, buf_spname(wp->w_buffer));
+	else
+	    home_replace(wp->w_buffer, wp->w_buffer->b_fname, NameBuff,
+							      MAXPATHL, TRUE);
+	trans_characters(NameBuff, MAXPATHL);
+	p = NameBuff;
+	len = (int)STRLEN(p);
+
+	if (wp->w_buffer->b_help
+#ifdef FEAT_QUICKFIX
+		|| wp->w_p_pvw
+#endif
+		|| bufIsChanged(wp->w_buffer)
+		|| wp->w_buffer->b_p_ro)
+	    *(p + len++) = ' ';
+	if (wp->w_buffer->b_help)
+	{
+	    STRCPY(p + len, _("[help]"));
+	    len += (int)STRLEN(p + len);
+	}
+#ifdef FEAT_QUICKFIX
+	if (wp->w_p_pvw)
+	{
+	    STRCPY(p + len, _("[Preview]"));
+	    len += (int)STRLEN(p + len);
+	}
+#endif
+	if (bufIsChanged(wp->w_buffer))
+	{
+	    STRCPY(p + len, "[+]");
+	    len += 3;
+	}
+	if (wp->w_buffer->b_p_ro)
+	{
+	    STRCPY(p + len, "[RO]");
+	    len += 4;
+	}
+
+#ifndef FEAT_VERTSPLIT
+	this_ru_col = ru_col;
+	if (this_ru_col < (Columns + 1) / 2)
+	    this_ru_col = (Columns + 1) / 2;
+#else
+	this_ru_col = ru_col - (Columns - W_WIDTH(wp));
+	if (this_ru_col < (W_WIDTH(wp) + 1) / 2)
+	    this_ru_col = (W_WIDTH(wp) + 1) / 2;
+	if (this_ru_col <= 1)
+	{
+	    p = (char_u *)"<";		/* No room for file name! */
+	    len = 1;
+	}
+	else
+#endif
+#ifdef FEAT_MBYTE
+	    if (has_mbyte)
+	    {
+		int	clen = 0, i;
+
+		/* Count total number of display cells. */
+		for (i = 0; p[i] != NUL; i += (*mb_ptr2len_check)(p + i))
+		    clen += (*mb_ptr2cells)(p + i);
+		/* 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_check)(p + i))
+		    clen -= (*mb_ptr2cells)(p + i);
+		len = clen;
+		if (i > 0)
+		{
+		    p = p + i - 1;
+		    *p = '<';
+		    ++len;
+		}
+
+	    }
+	    else
+#endif
+	    if (len > this_ru_col - 1)
+	    {
+		p += len - (this_ru_col - 1);
+		*p = '<';
+		len = this_ru_col - 1;
+	    }
+
+	row = W_WINROW(wp) + wp->w_height;
+	screen_puts(p, row, W_WINCOL(wp), attr);
+	screen_fill(row, row + 1, len + W_WINCOL(wp),
+			this_ru_col + W_WINCOL(wp), fillchar, fillchar, attr);
+
+	if (get_keymap_str(wp, NameBuff, MAXPATHL)
+		&& (int)(this_ru_col - len) > (int)(STRLEN(NameBuff) + 1))
+	    screen_puts(NameBuff, row, (int)(this_ru_col - STRLEN(NameBuff)
+						   - 1 + W_WINCOL(wp)), attr);
+
+#ifdef FEAT_CMDL_INFO
+	win_redr_ruler(wp, TRUE);
+#endif
+    }
+
+#ifdef FEAT_VERTSPLIT
+    /*
+     * 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 == curwin);
+	else
+	    fillchar = fillchar_vsep(&attr);
+	screen_putchar(fillchar, W_WINROW(wp) + wp->w_height, W_ENDCOL(wp),
+									attr);
+    }
+#endif
+}
+
+# ifdef FEAT_VERTSPLIT
+/*
+ * Return TRUE if the status line of window "wp" is connected to the status
+ * line of the window right of it.  If not, then it's a vertical separator.
+ * Only call if (wp->w_vsep_width != 0).
+ */
+    int
+stl_connected(wp)
+    win_T	*wp;
+{
+    frame_T	*fr;
+
+    fr = wp->w_frame;
+    while (fr->fr_parent != NULL)
+    {
+	if (fr->fr_parent->fr_layout == FR_COL)
+	{
+	    if (fr->fr_next != NULL)
+		break;
+	}
+	else
+	{
+	    if (fr->fr_next != NULL)
+		return TRUE;
+	}
+	fr = fr->fr_parent;
+    }
+    return FALSE;
+}
+# endif
+
+#endif /* FEAT_WINDOWS */
+
+#if defined(FEAT_WINDOWS) || defined(FEAT_STL_OPT) || defined(PROTO)
+/*
+ * Get the value to show for the language mappings, active 'keymap'.
+ */
+    int
+get_keymap_str(wp, buf, len)
+    win_T	*wp;
+    char_u	*buf;	    /* buffer for the result */
+    int		len;	    /* length of buffer */
+{
+    char_u	*p;
+
+    if (wp->w_buffer->b_p_iminsert != B_IMODE_LMAP)
+	return FALSE;
+
+    {
+#ifdef FEAT_EVAL
+	buf_T	*old_curbuf = curbuf;
+	win_T	*old_curwin = curwin;
+	char_u	*s;
+
+	curbuf = wp->w_buffer;
+	curwin = wp;
+	STRCPY(buf, "b:keymap_name");	/* must be writable */
+	++emsg_skip;
+	s = p = eval_to_string(buf, NULL);
+	--emsg_skip;
+	curbuf = old_curbuf;
+	curwin = old_curwin;
+	if (p == NULL || *p == NUL)
+#endif
+	{
+#ifdef FEAT_KEYMAP
+	    if (wp->w_buffer->b_kmap_state & KEYMAP_LOADED)
+		p = wp->w_buffer->b_p_keymap;
+	    else
+#endif
+		p = (char_u *)"lang";
+	}
+	if ((int)(STRLEN(p) + 3) < len)
+	    sprintf((char *)buf, "<%s>", p);
+	else
+	    buf[0] = NUL;
+#ifdef FEAT_EVAL
+	vim_free(s);
+#endif
+    }
+    return buf[0] != NUL;
+}
+#endif
+
+#if defined(FEAT_STL_OPT) || defined(PROTO)
+/*
+ * Redraw the status line or ruler of window wp.
+ */
+    static void
+win_redr_custom(wp, Ruler)
+    win_T	*wp;
+    int		Ruler;
+{
+    int		attr;
+    int		curattr;
+    int		row;
+    int		col = 0;
+    int		maxwidth;
+    int		width;
+    int		n;
+    int		len;
+    int		fillchar;
+    char_u	buf[MAXPATHL];
+    char_u	*p;
+    struct	stl_hlrec hl[STL_MAX_ITEM];
+
+    /* setup environment for the task at hand */
+    row = W_WINROW(wp) + wp->w_height;
+    fillchar = fillchar_status(&attr, wp == curwin);
+    maxwidth = W_WIDTH(wp);
+    p = p_stl;
+    if (Ruler)
+    {
+	p = p_ruf;
+	/* advance past any leading group spec - implicit in ru_col */
+	if (*p == '%')
+	{
+	    if (*++p == '-')
+		p++;
+	    if (atoi((char *) p))
+		while (VIM_ISDIGIT(*p))
+		    p++;
+	    if (*p++ != '(')
+		p = p_ruf;
+	}
+#ifdef FEAT_VERTSPLIT
+	col = ru_col - (Columns - W_WIDTH(wp));
+	if (col < (W_WIDTH(wp) + 1) / 2)
+	    col = (W_WIDTH(wp) + 1) / 2;
+#else
+	col = ru_col;
+	if (col > (Columns + 1) / 2)
+	    col = (Columns + 1) / 2;
+#endif
+	maxwidth = W_WIDTH(wp) - col;
+#ifdef FEAT_WINDOWS
+	if (!wp->w_status_height)
+#endif
+	{
+	    row = Rows - 1;
+	    --maxwidth;	/* writing in last column may cause scrolling */
+	    fillchar = ' ';
+	    attr = 0;
+	}
+    }
+    if (maxwidth <= 0)
+	return;
+#ifdef FEAT_VERTSPLIT
+    col += W_WINCOL(wp);
+#endif
+
+    width = build_stl_str_hl(wp, buf, sizeof(buf), p, fillchar, maxwidth, hl);
+    len = STRLEN(buf);
+
+    while (width < maxwidth && len < sizeof(buf) - 1)
+    {
+#ifdef FEAT_MBYTE
+	len += (*mb_char2bytes)(fillchar, buf + len);
+#else
+	buf[len++] = fillchar;
+#endif
+	++width;
+    }
+    buf[len] = NUL;
+
+    curattr = attr;
+    p = buf;
+    for (n = 0; hl[n].start != NULL; n++)
+    {
+	len = (int)(hl[n].start - p);
+	screen_puts_len(p, len, row, col, curattr);
+	col += vim_strnsize(p, len);
+	p = hl[n].start;
+
+	if (hl[n].userhl == 0)
+	    curattr = attr;
+#ifdef FEAT_WINDOWS
+	else if (wp != curwin && wp->w_status_height != 0)
+	    curattr = highlight_stlnc[hl[n].userhl - 1];
+#endif
+	else
+	    curattr = highlight_user[hl[n].userhl - 1];
+    }
+    screen_puts(p, row, col, curattr);
+}
+
+#endif /* FEAT_STL_OPT */
+
+/*
+ * Output a single character directly to the screen and update ScreenLines.
+ */
+    void
+screen_putchar(c, row, col, attr)
+    int	    c;
+    int	    row, col;
+    int	    attr;
+{
+#ifdef FEAT_MBYTE
+    char_u	buf[MB_MAXBYTES + 1];
+
+    buf[(*mb_char2bytes)(c, buf)] = NUL;
+#else
+    char_u	buf[2];
+
+    buf[0] = c;
+    buf[1] = NUL;
+#endif
+    screen_puts(buf, row, col, attr);
+}
+
+/*
+ * Get a single character directly from ScreenLines into "bytes[]".
+ * Also return its attribute in *attrp;
+ */
+    void
+screen_getbytes(row, col, bytes, attrp)
+    int	    row, col;
+    char_u  *bytes;
+    int	    *attrp;
+{
+    unsigned off;
+
+    /* safety check */
+    if (ScreenLines != NULL && row < screen_Rows && col < screen_Columns)
+    {
+	off = LineOffset[row] + col;
+	*attrp = ScreenAttrs[off];
+	bytes[0] = ScreenLines[off];
+	bytes[1] = NUL;
+
+#ifdef FEAT_MBYTE
+	if (enc_utf8 && ScreenLinesUC[off] != 0)
+	    bytes[utfc_char2bytes(off, bytes)] = NUL;
+	else if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e)
+	{
+	    bytes[0] = ScreenLines[off];
+	    bytes[1] = ScreenLines2[off];
+	    bytes[2] = NUL;
+	}
+	else if (enc_dbcs && MB_BYTE2LEN(bytes[0]) > 1)
+	{
+	    bytes[1] = ScreenLines[off + 1];
+	    bytes[2] = NUL;
+	}
+#endif
+    }
+}
+
+/*
+ * Put string '*text' on the screen at position 'row' and 'col', with
+ * attributes 'attr', and update ScreenLines[] and ScreenAttrs[].
+ * Note: only outputs within one row, message is truncated at screen boundary!
+ * Note: if ScreenLines[], row and/or col is invalid, nothing is done.
+ */
+    void
+screen_puts(text, row, col, attr)
+    char_u	*text;
+    int		row;
+    int		col;
+    int		attr;
+{
+    screen_puts_len(text, -1, row, col, attr);
+}
+
+/*
+ * Like screen_puts(), but output "text[len]".  When "len" is -1 output up to
+ * a NUL.
+ */
+    void
+screen_puts_len(text, len, row, col, attr)
+    char_u	*text;
+    int		len;
+    int		row;
+    int		col;
+    int		attr;
+{
+    unsigned	off;
+    char_u	*ptr = text;
+    int		c;
+#ifdef FEAT_MBYTE
+    int		mbyte_blen = 1;
+    int		mbyte_cells = 1;
+    int		u8c = 0;
+    int		u8c_c1 = 0;
+    int		u8c_c2 = 0;
+    int		clear_next_cell = FALSE;
+# ifdef FEAT_ARABIC
+    int		prev_c = 0;		/* previous Arabic character */
+    int		pc, nc, nc1, dummy;
+# endif
+#endif
+
+    if (ScreenLines == NULL || row >= screen_Rows)	/* safety check */
+	return;
+
+    off = LineOffset[row] + col;
+    while (*ptr != NUL && col < screen_Columns
+				      && (len < 0 || (int)(ptr - text) < len))
+    {
+	c = *ptr;
+#ifdef FEAT_MBYTE
+	/* check if this is the first byte of a multibyte */
+	if (has_mbyte)
+	{
+	    if (enc_utf8 && len > 0)
+		mbyte_blen = utfc_ptr2len_check_len(ptr,
+						   (int)((text + len) - ptr));
+	    else
+		mbyte_blen = (*mb_ptr2len_check)(ptr);
+	    if (enc_dbcs == DBCS_JPNU && c == 0x8e)
+		mbyte_cells = 1;
+	    else if (enc_dbcs != 0)
+		mbyte_cells = mbyte_blen;
+	    else	/* enc_utf8 */
+	    {
+		if (len >= 0)
+		    u8c = utfc_ptr2char_len(ptr, &u8c_c1, &u8c_c2,
+						   (int)((text + len) - ptr));
+		else
+		    u8c = utfc_ptr2char(ptr, &u8c_c1, &u8c_c2);
+		mbyte_cells = utf_char2cells(u8c);
+		/* Non-BMP character: display as ? or fullwidth ?. */
+		if (u8c >= 0x10000)
+		{
+		    u8c = (mbyte_cells == 2) ? 0xff1f : (int)'?';
+		    if (attr == 0)
+			attr = hl_attr(HLF_8);
+		}
+# ifdef FEAT_ARABIC
+		if (p_arshape && !p_tbidi && ARABIC_CHAR(u8c))
+		{
+		    /* Do Arabic shaping. */
+		    if (len >= 0 && (int)(ptr - text) + mbyte_blen >= len)
+		    {
+			/* Past end of string to be displayed. */
+			nc = NUL;
+			nc1 = NUL;
+		    }
+		    else
+			nc = utfc_ptr2char(ptr + mbyte_blen, &nc1, &dummy);
+		    pc = prev_c;
+		    prev_c = u8c;
+		    u8c = arabic_shape(u8c, &c, &u8c_c1, nc, nc1, pc);
+		}
+		else
+		    prev_c = u8c;
+# endif
+	    }
+	}
+#endif
+
+	if (ScreenLines[off] != c
+#ifdef FEAT_MBYTE
+		|| (mbyte_cells == 2
+		    && ScreenLines[off + 1] != (enc_dbcs ? ptr[1] : 0))
+		|| (enc_dbcs == DBCS_JPNU
+		    && c == 0x8e
+		    && ScreenLines2[off] != ptr[1])
+		|| (enc_utf8
+		    && mbyte_blen > 1
+		    && (ScreenLinesUC[off] != u8c
+			|| ScreenLinesC1[off] != u8c_c1
+			|| ScreenLinesC2[off] != u8c_c2))
+#endif
+		|| ScreenAttrs[off] != attr
+		|| exmode_active
+		)
+	{
+#if defined(FEAT_GUI) || defined(UNIX)
+	    /* The bold trick makes a single row of pixels appear in the next
+	     * character.  When a bold character is removed, the next
+	     * character should be redrawn too.  This happens for our own GUI
+	     * and for some xterms.
+	     * Force the redraw by setting the attribute to a different value
+	     * than "attr", the contents of ScreenLines[] may be needed by
+	     * mb_off2cells() further on.
+	     * Don't do this for the last drawn character, because the next
+	     * character may not be redrawn. */
+	    if (
+# ifdef FEAT_GUI
+		    gui.in_use
+# endif
+# if defined(FEAT_GUI) && defined(UNIX)
+		    ||
+# endif
+# ifdef UNIX
+		    term_is_xterm
+# endif
+	       )
+	    {
+		int		n;
+
+		n = ScreenAttrs[off];
+# ifdef FEAT_MBYTE
+		if (col + mbyte_cells < screen_Columns
+			&& (n > HL_ALL || (n & HL_BOLD))
+			&& (len < 0 ? ptr[mbyte_blen] != NUL
+					     : ptr + mbyte_blen < text + len))
+		    ScreenAttrs[off + mbyte_cells] = attr + 1;
+# else
+		if (col + 1 < screen_Columns
+			&& (n > HL_ALL || (n & HL_BOLD))
+			&& (len < 0 ? ptr[1] != NUL : ptr + 1 < text + len))
+		    ScreenLines[off + 1] = 0;
+# endif
+	    }
+#endif
+#ifdef FEAT_MBYTE
+	    /* When at the end of the text and overwriting a two-cell
+	     * character with a one-cell character, need to clear the next
+	     * cell.  Also when overwriting the left halve of a two-cell char
+	     * with the right halve of a two-cell char.  Do this only once
+	     * (mb_off2cells() may return 2 on the right halve). */
+	    if (clear_next_cell)
+		clear_next_cell = FALSE;
+	    else if (has_mbyte
+		    && (len < 0 ? ptr[mbyte_blen] == NUL
+					     : ptr + mbyte_blen >= text + len)
+		    && ((mbyte_cells == 1 && (*mb_off2cells)(off) > 1)
+			|| (mbyte_cells == 2
+			    && (*mb_off2cells)(off) == 1
+			    && (*mb_off2cells)(off + 1) > 1)))
+		clear_next_cell = TRUE;
+
+	    /* Make sure we never leave a second byte of a double-byte behind,
+	     * it confuses mb_off2cells(). */
+	    if (enc_dbcs
+		    && ((mbyte_cells == 1 && (*mb_off2cells)(off) > 1)
+			|| (mbyte_cells == 2
+			    && (*mb_off2cells)(off) == 1
+			    && (*mb_off2cells)(off + 1) > 1)))
+		ScreenLines[off + mbyte_blen] = 0;
+#endif
+	    ScreenLines[off] = c;
+	    ScreenAttrs[off] = attr;
+#ifdef FEAT_MBYTE
+	    if (enc_utf8)
+	    {
+		if (c < 0x80 && u8c_c1 == 0 && u8c_c2 == 0)
+		    ScreenLinesUC[off] = 0;
+		else
+		{
+		    ScreenLinesUC[off] = u8c;
+		    ScreenLinesC1[off] = u8c_c1;
+		    ScreenLinesC2[off] = u8c_c2;
+		}
+		if (mbyte_cells == 2)
+		{
+		    ScreenLines[off + 1] = 0;
+		    ScreenAttrs[off + 1] = attr;
+		}
+		screen_char(off, row, col);
+	    }
+	    else if (mbyte_cells == 2)
+	    {
+		ScreenLines[off + 1] = ptr[1];
+		ScreenAttrs[off + 1] = attr;
+		screen_char_2(off, row, col);
+	    }
+	    else if (enc_dbcs == DBCS_JPNU && c == 0x8e)
+	    {
+		ScreenLines2[off] = ptr[1];
+		screen_char(off, row, col);
+	    }
+	    else
+#endif
+		screen_char(off, row, col);
+	}
+#ifdef FEAT_MBYTE
+	if (has_mbyte)
+	{
+	    off += mbyte_cells;
+	    col += mbyte_cells;
+	    ptr += mbyte_blen;
+	    if (clear_next_cell)
+		ptr = (char_u *)" ";
+	}
+	else
+#endif
+	{
+	    ++off;
+	    ++col;
+	    ++ptr;
+	}
+    }
+}
+
+#ifdef FEAT_SEARCH_EXTRA
+/*
+ * Prepare for 'searchhl' highlighting.
+ */
+    static void
+start_search_hl()
+{
+    if (p_hls && !no_hlsearch)
+    {
+	last_pat_prog(&search_hl.rm);
+	search_hl.attr = hl_attr(HLF_L);
+    }
+}
+
+/*
+ * Clean up for 'searchhl' highlighting.
+ */
+    static void
+end_search_hl()
+{
+    if (search_hl.rm.regprog != NULL)
+    {
+	vim_free(search_hl.rm.regprog);
+	search_hl.rm.regprog = NULL;
+    }
+}
+
+/*
+ * Advance to the match in window "wp" line "lnum" or past it.
+ */
+    static void
+prepare_search_hl(wp, lnum)
+    win_T	*wp;
+    linenr_T	lnum;
+{
+    match_T	*shl;		/* points to search_hl or match_hl */
+    int		n;
+
+    /*
+     * When using a multi-line pattern, start searching at the top
+     * of the window or just after a closed fold.
+     * Do this both for search_hl and match_hl.
+     */
+    shl = &search_hl;
+    for (;;)
+    {
+	if (shl->rm.regprog != NULL
+		&& shl->lnum == 0
+		&& re_multiline(shl->rm.regprog))
+	{
+	    if (shl->first_lnum == 0)
+	    {
+# ifdef FEAT_FOLDING
+		for (shl->first_lnum = lnum;
+			   shl->first_lnum > wp->w_topline; --shl->first_lnum)
+		    if (hasFoldingWin(wp, shl->first_lnum - 1,
+						      NULL, NULL, TRUE, NULL))
+			break;
+# else
+		shl->first_lnum = wp->w_topline;
+# endif
+	    }
+	    n = 0;
+	    while (shl->first_lnum < lnum && shl->rm.regprog != NULL)
+	    {
+		next_search_hl(wp, shl, shl->first_lnum, (colnr_T)n);
+		if (shl->lnum != 0)
+		{
+		    shl->first_lnum = shl->lnum
+				    + shl->rm.endpos[0].lnum
+				    - shl->rm.startpos[0].lnum;
+		    n = shl->rm.endpos[0].col;
+		}
+		else
+		{
+		    ++shl->first_lnum;
+		    n = 0;
+		}
+	    }
+	}
+	if (shl == &match_hl)
+	    break;
+	shl = &match_hl;
+    }
+}
+
+/*
+ * Search for a next 'searchl' or ":match" match.
+ * Uses shl->buf.
+ * Sets shl->lnum and shl->rm contents.
+ * Note: Assumes a previous match is always before "lnum", unless
+ * shl->lnum is zero.
+ * Careful: Any pointers for buffer lines will become invalid.
+ */
+    static void
+next_search_hl(win, shl, lnum, mincol)
+    win_T	*win;
+    match_T	*shl;		/* points to search_hl or match_hl */
+    linenr_T	lnum;
+    colnr_T	mincol;		/* minimal column for a match */
+{
+    linenr_T	l;
+    colnr_T	matchcol;
+    long	nmatched;
+
+    if (shl->lnum != 0)
+    {
+	/* Check for three situations:
+	 * 1. If the "lnum" is below a previous match, start a new search.
+	 * 2. If the previous match includes "mincol", use it.
+	 * 3. Continue after the previous match.
+	 */
+	l = shl->lnum + shl->rm.endpos[0].lnum - shl->rm.startpos[0].lnum;
+	if (lnum > l)
+	    shl->lnum = 0;
+	else if (lnum < l || shl->rm.endpos[0].col > mincol)
+	    return;
+    }
+
+    /*
+     * Repeat searching for a match until one is found that includes "mincol"
+     * or none is found in this line.
+     */
+    called_emsg = FALSE;
+    for (;;)
+    {
+	/* Three situations:
+	 * 1. No useful previous match: search from start of line.
+	 * 2. Not Vi compatible or empty match: continue at next character.
+	 *    Break the loop if this is beyond the end of the line.
+	 * 3. Vi compatible searching: continue at end of previous match.
+	 */
+	if (shl->lnum == 0)
+	    matchcol = 0;
+	else if (vim_strchr(p_cpo, CPO_SEARCH) == NULL
+		|| (shl->rm.endpos[0].lnum == 0
+		    && shl->rm.endpos[0].col == shl->rm.startpos[0].col))
+	{
+	    matchcol = shl->rm.startpos[0].col + 1;
+	    if (ml_get_buf(shl->buf, lnum, FALSE)[matchcol - 1] == NUL)
+	    {
+		shl->lnum = 0;
+		break;
+	    }
+	}
+	else
+	    matchcol = shl->rm.endpos[0].col;
+
+	shl->lnum = lnum;
+	nmatched = vim_regexec_multi(&shl->rm, win, shl->buf, lnum, matchcol);
+	if (called_emsg)
+	{
+	    /* Error while handling regexp: stop using this regexp. */
+	    vim_free(shl->rm.regprog);
+	    shl->rm.regprog = NULL;
+	    no_hlsearch = TRUE;
+	    break;
+	}
+	if (nmatched == 0)
+	{
+	    shl->lnum = 0;		/* no match found */
+	    break;
+	}
+	if (shl->rm.startpos[0].lnum > 0
+		|| shl->rm.startpos[0].col >= mincol
+		|| nmatched > 1
+		|| shl->rm.endpos[0].col > mincol)
+	{
+	    shl->lnum += shl->rm.startpos[0].lnum;
+	    break;			/* useful match found */
+	}
+    }
+}
+#endif
+
+      static void
+screen_start_highlight(attr)
+      int	attr;
+{
+    attrentry_T *aep = NULL;
+
+    screen_attr = attr;
+    if (full_screen
+#ifdef WIN3264
+		    && termcap_active
+#endif
+				       )
+    {
+#ifdef FEAT_GUI
+	if (gui.in_use)
+	{
+	    char	buf[20];
+
+	    sprintf(buf, IF_EB("\033|%dh", ESC_STR "|%dh"), attr);		/* internal GUI code */
+	    OUT_STR(buf);
+	}
+	else
+#endif
+	{
+	    if (attr > HL_ALL)				/* special HL attr. */
+	    {
+		if (t_colors > 1)
+		    aep = syn_cterm_attr2entry(attr);
+		else
+		    aep = syn_term_attr2entry(attr);
+		if (aep == NULL)	    /* did ":syntax clear" */
+		    attr = 0;
+		else
+		    attr = aep->ae_attr;
+	    }
+	    if ((attr & HL_BOLD) && T_MD != NULL)	/* bold */
+		out_str(T_MD);
+	    if ((attr & HL_STANDOUT) && T_SO != NULL)	/* standout */
+		out_str(T_SO);
+	    if ((attr & HL_UNDERLINE) && T_US != NULL)	/* underline */
+		out_str(T_US);
+	    if ((attr & HL_ITALIC) && T_CZH != NULL)	/* italic */
+		out_str(T_CZH);
+	    if ((attr & HL_INVERSE) && T_MR != NULL)	/* inverse (reverse) */
+		out_str(T_MR);
+
+	    /*
+	     * Output the color or start string after bold etc., in case the
+	     * bold etc. override the color setting.
+	     */
+	    if (aep != NULL)
+	    {
+		if (t_colors > 1)
+		{
+		    if (aep->ae_u.cterm.fg_color)
+			term_fg_color(aep->ae_u.cterm.fg_color - 1);
+		    if (aep->ae_u.cterm.bg_color)
+			term_bg_color(aep->ae_u.cterm.bg_color - 1);
+		}
+		else
+		{
+		    if (aep->ae_u.term.start != NULL)
+			out_str(aep->ae_u.term.start);
+		}
+	    }
+	}
+    }
+}
+
+      void
+screen_stop_highlight()
+{
+    int	    do_ME = FALSE;	    /* output T_ME code */
+
+    if (screen_attr != 0
+#ifdef WIN3264
+			&& termcap_active
+#endif
+					   )
+    {
+#ifdef FEAT_GUI
+	if (gui.in_use)
+	{
+	    char	buf[20];
+
+	    /* use internal GUI code */
+	    sprintf(buf, IF_EB("\033|%dH", ESC_STR "|%dH"), screen_attr);
+	    OUT_STR(buf);
+	}
+	else
+#endif
+	{
+	    if (screen_attr > HL_ALL)			/* special HL attr. */
+	    {
+		attrentry_T *aep;
+
+		if (t_colors > 1)
+		{
+		    /*
+		     * Assume that t_me restores the original colors!
+		     */
+		    aep = syn_cterm_attr2entry(screen_attr);
+		    if (aep != NULL && (aep->ae_u.cterm.fg_color
+						 || aep->ae_u.cterm.bg_color))
+			do_ME = TRUE;
+		}
+		else
+		{
+		    aep = syn_term_attr2entry(screen_attr);
+		    if (aep != NULL && aep->ae_u.term.stop != NULL)
+		    {
+			if (STRCMP(aep->ae_u.term.stop, T_ME) == 0)
+			    do_ME = TRUE;
+			else
+			    out_str(aep->ae_u.term.stop);
+		    }
+		}
+		if (aep == NULL)	    /* did ":syntax clear" */
+		    screen_attr = 0;
+		else
+		    screen_attr = aep->ae_attr;
+	    }
+
+	    /*
+	     * Often all ending-codes are equal to T_ME.  Avoid outputting the
+	     * same sequence several times.
+	     */
+	    if (screen_attr & HL_STANDOUT)
+	    {
+		if (STRCMP(T_SE, T_ME) == 0)
+		    do_ME = TRUE;
+		else
+		    out_str(T_SE);
+	    }
+	    if (screen_attr & HL_UNDERLINE)
+	    {
+		if (STRCMP(T_UE, T_ME) == 0)
+		    do_ME = TRUE;
+		else
+		    out_str(T_UE);
+	    }
+	    if (screen_attr & HL_ITALIC)
+	    {
+		if (STRCMP(T_CZR, T_ME) == 0)
+		    do_ME = TRUE;
+		else
+		    out_str(T_CZR);
+	    }
+	    if (do_ME || (screen_attr & (HL_BOLD | HL_INVERSE)))
+		out_str(T_ME);
+
+	    if (t_colors > 1)
+	    {
+		/* set Normal cterm colors */
+		if (cterm_normal_fg_color != 0)
+		    term_fg_color(cterm_normal_fg_color - 1);
+		if (cterm_normal_bg_color != 0)
+		    term_bg_color(cterm_normal_bg_color - 1);
+		if (cterm_normal_fg_bold)
+		    out_str(T_MD);
+	    }
+	}
+    }
+    screen_attr = 0;
+}
+
+/*
+ * Reset the colors for a cterm.  Used when leaving Vim.
+ * The machine specific code may override this again.
+ */
+    void
+reset_cterm_colors()
+{
+    if (t_colors > 1)
+    {
+	/* set Normal cterm colors */
+	if (cterm_normal_fg_color > 0 || cterm_normal_bg_color > 0)
+	{
+	    out_str(T_OP);
+	    screen_attr = -1;
+	}
+	if (cterm_normal_fg_bold)
+	{
+	    out_str(T_ME);
+	    screen_attr = -1;
+	}
+    }
+}
+
+/*
+ * Put character ScreenLines["off"] on the screen at position "row" and "col",
+ * using the attributes from ScreenAttrs["off"].
+ */
+    static void
+screen_char(off, row, col)
+    unsigned	off;
+    int		row;
+    int		col;
+{
+    int		attr;
+
+    /* Check for illegal values, just in case (could happen just after
+     * resizing). */
+    if (row >= screen_Rows || col >= screen_Columns)
+	return;
+
+    /* Outputting the last character on the screen may scrollup the screen.
+     * Don't to it!  Mark the character invalid (update it when scrolled up) */
+    if (row == screen_Rows - 1 && col == screen_Columns - 1
+#ifdef FEAT_RIGHTLEFT
+	    /* account for first command-line character in rightleft mode */
+	    && !cmdmsg_rl
+#endif
+       )
+    {
+	ScreenAttrs[off] = (sattr_T)-1;
+	return;
+    }
+
+    /*
+     * Stop highlighting first, so it's easier to move the cursor.
+     */
+#if defined(FEAT_CLIPBOARD) || defined(FEAT_VERTSPLIT)
+    if (screen_char_attr != 0)
+	attr = screen_char_attr;
+    else
+#endif
+	attr = ScreenAttrs[off];
+    if (screen_attr != attr)
+	screen_stop_highlight();
+
+    windgoto(row, col);
+
+    if (screen_attr != attr)
+	screen_start_highlight(attr);
+
+#ifdef FEAT_MBYTE
+    if (enc_utf8 && ScreenLinesUC[off] != 0)
+    {
+	char_u	    buf[MB_MAXBYTES + 1];
+
+	/* Convert UTF-8 character to bytes and write it. */
+
+	buf[utfc_char2bytes(off, buf)] = NUL;
+
+	out_str(buf);
+	if (utf_char2cells(ScreenLinesUC[off]) > 1)
+	    ++screen_cur_col;
+    }
+    else
+#endif
+    {
+#ifdef FEAT_MBYTE
+	out_flush_check();
+#endif
+	out_char(ScreenLines[off]);
+#ifdef FEAT_MBYTE
+	/* double-byte character in single-width cell */
+	if (enc_dbcs == DBCS_JPNU && ScreenLines[off] == 0x8e)
+	    out_char(ScreenLines2[off]);
+#endif
+    }
+
+    screen_cur_col++;
+}
+
+#ifdef FEAT_MBYTE
+
+/*
+ * Used for enc_dbcs only: Put one double-wide character at ScreenLines["off"]
+ * on the screen at position 'row' and 'col'.
+ * The attributes of the first byte is used for all.  This is required to
+ * output the two bytes of a double-byte character with nothing in between.
+ */
+    static void
+screen_char_2(off, row, col)
+    unsigned	off;
+    int		row;
+    int		col;
+{
+    /* Check for illegal values (could be wrong when screen was resized). */
+    if (off + 1 >= (unsigned)(screen_Rows * screen_Columns))
+	return;
+
+    /* Outputting the last character on the screen may scrollup the screen.
+     * Don't to it!  Mark the character invalid (update it when scrolled up) */
+    if (row == screen_Rows - 1 && col >= screen_Columns - 2)
+    {
+	ScreenAttrs[off] = (sattr_T)-1;
+	return;
+    }
+
+    /* Output the first byte normally (positions the cursor), then write the
+     * second byte directly. */
+    screen_char(off, row, col);
+    out_char(ScreenLines[off + 1]);
+    ++screen_cur_col;
+}
+#endif
+
+#if defined(FEAT_CLIPBOARD) || defined(FEAT_VERTSPLIT) || defined(PROTO)
+/*
+ * Draw a rectangle of the screen, inverted when "invert" is TRUE.
+ * This uses the contents of ScreenLines[] and doesn't change it.
+ */
+    void
+screen_draw_rectangle(row, col, height, width, invert)
+    int		row;
+    int		col;
+    int		height;
+    int		width;
+    int		invert;
+{
+    int		r, c;
+    int		off;
+
+    if (invert)
+	screen_char_attr = HL_INVERSE;
+    for (r = row; r < row + height; ++r)
+    {
+	off = LineOffset[r];
+	for (c = col; c < col + width; ++c)
+	{
+#ifdef FEAT_MBYTE
+	    if (enc_dbcs != 0 && dbcs_off2cells(off + c) > 1)
+	    {
+		screen_char_2(off + c, r, c);
+		++c;
+	    }
+	    else
+#endif
+	    {
+		screen_char(off + c, r, c);
+#ifdef FEAT_MBYTE
+		if (utf_off2cells(off + c) > 1)
+		    ++c;
+#endif
+	    }
+	}
+    }
+    screen_char_attr = 0;
+}
+#endif
+
+#ifdef FEAT_VERTSPLIT
+/*
+ * Redraw the characters for a vertically split window.
+ */
+    static void
+redraw_block(row, end, wp)
+    int		row;
+    int		end;
+    win_T	*wp;
+{
+    int		col;
+    int		width;
+
+# ifdef FEAT_CLIPBOARD
+    clip_may_clear_selection(row, end - 1);
+# endif
+
+    if (wp == NULL)
+    {
+	col = 0;
+	width = Columns;
+    }
+    else
+    {
+	col = wp->w_wincol;
+	width = wp->w_width;
+    }
+    screen_draw_rectangle(row, col, end - row, width, FALSE);
+}
+#endif
+
+/*
+ * Fill the screen from 'start_row' to 'end_row', from 'start_col' to 'end_col'
+ * with character 'c1' in first column followed by 'c2' in the other columns.
+ * Use attributes 'attr'.
+ */
+    void
+screen_fill(start_row, end_row, start_col, end_col, c1, c2, attr)
+    int	    start_row, end_row;
+    int	    start_col, end_col;
+    int	    c1, c2;
+    int	    attr;
+{
+    int		    row;
+    int		    col;
+    int		    off;
+    int		    end_off;
+    int		    did_delete;
+    int		    c;
+    int		    norm_term;
+#if defined(FEAT_GUI) || defined(UNIX)
+    int		    force_next = FALSE;
+#endif
+
+    if (end_row > screen_Rows)		/* safety check */
+	end_row = screen_Rows;
+    if (end_col > screen_Columns)	/* safety check */
+	end_col = screen_Columns;
+    if (ScreenLines == NULL
+	    || start_row >= end_row
+	    || start_col >= end_col)	/* nothing to do */
+	return;
+
+    /* it's a "normal" terminal when not in a GUI or cterm */
+    norm_term = (
+#ifdef FEAT_GUI
+	    !gui.in_use &&
+#endif
+			    t_colors <= 1);
+    for (row = start_row; row < end_row; ++row)
+    {
+	/*
+	 * Try to use delete-line termcap code, when no attributes or in a
+	 * "normal" terminal, where a bold/italic space is just a
+	 * space.
+	 */
+	did_delete = FALSE;
+	if (c2 == ' '
+		&& end_col == Columns
+		&& can_clear(T_CE)
+		&& (attr == 0
+		    || (norm_term
+			&& attr <= HL_ALL
+			&& ((attr & ~(HL_BOLD | HL_ITALIC)) == 0))))
+	{
+	    /*
+	     * check if we really need to clear something
+	     */
+	    col = start_col;
+	    if (c1 != ' ')			/* don't clear first char */
+		++col;
+
+	    off = LineOffset[row] + col;
+	    end_off = LineOffset[row] + end_col;
+
+	    /* skip blanks (used often, keep it fast!) */
+#ifdef FEAT_MBYTE
+	    if (enc_utf8)
+		while (off < end_off && ScreenLines[off] == ' '
+			  && ScreenAttrs[off] == 0 && ScreenLinesUC[off] == 0)
+		    ++off;
+	    else
+#endif
+		while (off < end_off && ScreenLines[off] == ' '
+						     && ScreenAttrs[off] == 0)
+		    ++off;
+	    if (off < end_off)		/* something to be cleared */
+	    {
+		col = off - LineOffset[row];
+		screen_stop_highlight();
+		term_windgoto(row, col);/* clear rest of this screen line */
+		out_str(T_CE);
+		screen_start();		/* don't know where cursor is now */
+		col = end_col - col;
+		while (col--)		/* clear chars in ScreenLines */
+		{
+		    ScreenLines[off] = ' ';
+#ifdef FEAT_MBYTE
+		    if (enc_utf8)
+			ScreenLinesUC[off] = 0;
+#endif
+		    ScreenAttrs[off] = 0;
+		    ++off;
+		}
+	    }
+	    did_delete = TRUE;		/* the chars are cleared now */
+	}
+
+	off = LineOffset[row] + start_col;
+	c = c1;
+	for (col = start_col; col < end_col; ++col)
+	{
+	    if (ScreenLines[off] != c
+#ifdef FEAT_MBYTE
+		    || (enc_utf8 && ScreenLinesUC[off] != (c >= 0x80 ? c : 0))
+#endif
+		    || ScreenAttrs[off] != attr
+#if defined(FEAT_GUI) || defined(UNIX)
+		    || force_next
+#endif
+		    )
+	    {
+#if defined(FEAT_GUI) || defined(UNIX)
+		/* The bold trick may make a single row of pixels appear in
+		 * the next character.  When a bold character is removed, the
+		 * next character should be redrawn too.  This happens for our
+		 * own GUI and for some xterms.  */
+		if (
+# ifdef FEAT_GUI
+			gui.in_use
+# endif
+# if defined(FEAT_GUI) && defined(UNIX)
+			||
+# endif
+# ifdef UNIX
+			term_is_xterm
+# endif
+		   )
+		{
+		    if (ScreenLines[off] != ' '
+			    && (ScreenAttrs[off] > HL_ALL
+				|| ScreenAttrs[off] & HL_BOLD))
+			force_next = TRUE;
+		    else
+			force_next = FALSE;
+		}
+#endif
+		ScreenLines[off] = c;
+#ifdef FEAT_MBYTE
+		if (enc_utf8)
+		{
+		    if (c >= 0x80)
+		    {
+			ScreenLinesUC[off] = c;
+			ScreenLinesC1[off] = 0;
+			ScreenLinesC2[off] = 0;
+		    }
+		    else
+			ScreenLinesUC[off] = 0;
+		}
+#endif
+		ScreenAttrs[off] = attr;
+		if (!did_delete || c != ' ')
+		    screen_char(off, row, col);
+	    }
+	    ++off;
+	    if (col == start_col)
+	    {
+		if (did_delete)
+		    break;
+		c = c2;
+	    }
+	}
+	if (end_col == Columns)
+	    LineWraps[row] = FALSE;
+	if (row == Rows - 1)		/* overwritten the command line */
+	{
+	    redraw_cmdline = TRUE;
+	    if (c1 == ' ' && c2 == ' ')
+		clear_cmdline = FALSE;	/* command line has been cleared */
+	}
+    }
+}
+
+/*
+ * Check if there should be a delay.  Used before clearing or redrawing the
+ * screen or the command line.
+ */
+    void
+check_for_delay(check_msg_scroll)
+    int	    check_msg_scroll;
+{
+    if ((emsg_on_display || (check_msg_scroll && msg_scroll))
+	    && !did_wait_return
+	    && emsg_silent == 0)
+    {
+	out_flush();
+	ui_delay(1000L, TRUE);
+	emsg_on_display = FALSE;
+	if (check_msg_scroll)
+	    msg_scroll = FALSE;
+    }
+}
+
+/*
+ * screen_valid -  allocate screen buffers if size changed
+ *   If "clear" is TRUE: clear screen if it has been resized.
+ *	Returns TRUE if there is a valid screen to write to.
+ *	Returns FALSE when starting up and screen not initialized yet.
+ */
+    int
+screen_valid(clear)
+    int	    clear;
+{
+    screenalloc(clear);	    /* allocate screen buffers if size changed */
+    return (ScreenLines != NULL);
+}
+
+/*
+ * Resize the shell to Rows and Columns.
+ * Allocate ScreenLines[] and associated items.
+ *
+ * There may be some time between setting Rows and Columns and (re)allocating
+ * ScreenLines[].  This happens when starting up and when (manually) changing
+ * the shell size.  Always use screen_Rows and screen_Columns to access items
+ * in ScreenLines[].  Use Rows and Columns for positioning text etc. where the
+ * final size of the shell is needed.
+ */
+    void
+screenalloc(clear)
+    int	    clear;
+{
+    int		    new_row, old_row;
+#ifdef FEAT_GUI
+    int		    old_Rows;
+#endif
+    win_T	    *wp;
+    int		    outofmem = FALSE;
+    int		    len;
+    schar_T	    *new_ScreenLines;
+#ifdef FEAT_MBYTE
+    u8char_T	    *new_ScreenLinesUC = NULL;
+    u8char_T	    *new_ScreenLinesC1 = NULL;
+    u8char_T	    *new_ScreenLinesC2 = NULL;
+    schar_T	    *new_ScreenLines2 = NULL;
+#endif
+    sattr_T	    *new_ScreenAttrs;
+    unsigned	    *new_LineOffset;
+    char_u	    *new_LineWraps;
+    static int	    entered = FALSE;		/* avoid recursiveness */
+
+    /*
+     * Allocation of the screen buffers is done only when the size changes and
+     * when Rows and Columns have been set and we have started doing full
+     * screen stuff.
+     */
+    if ((ScreenLines != NULL
+		&& Rows == screen_Rows
+		&& Columns == screen_Columns
+#ifdef FEAT_MBYTE
+		&& enc_utf8 == (ScreenLinesUC != NULL)
+		&& (enc_dbcs == DBCS_JPNU) == (ScreenLines2 != NULL)
+#endif
+		)
+	    || Rows == 0
+	    || Columns == 0
+	    || (!full_screen && ScreenLines == NULL))
+	return;
+
+    /*
+     * It's possible that we produce an out-of-memory message below, which
+     * will cause this function to be called again.  To break the loop, just
+     * return here.
+     */
+    if (entered)
+	return;
+    entered = TRUE;
+
+    win_new_shellsize();    /* fit the windows in the new sized shell */
+
+#ifdef FEAT_GUI_BEOS
+    vim_lock_screen();  /* be safe, put it here */
+#endif
+
+    comp_col();		/* recompute columns for shown command and ruler */
+
+    /*
+     * We're changing the size of the screen.
+     * - Allocate new arrays for ScreenLines and ScreenAttrs.
+     * - Move lines from the old arrays into the new arrays, clear extra
+     *	 lines (unless the screen is going to be cleared).
+     * - Free the old arrays.
+     *
+     * If anything fails, make ScreenLines NULL, so we don't do anything!
+     * Continuing with the old ScreenLines may result in a crash, because the
+     * size is wrong.
+     */
+#ifdef FEAT_WINDOWS
+    for (wp = firstwin; wp; wp = wp->w_next)
+	win_free_lsize(wp);
+#else
+	win_free_lsize(curwin);
+#endif
+
+    new_ScreenLines = (schar_T *)lalloc((long_u)(
+			      (Rows + 1) * Columns * sizeof(schar_T)), FALSE);
+#ifdef FEAT_MBYTE
+    if (enc_utf8)
+    {
+	new_ScreenLinesUC = (u8char_T *)lalloc((long_u)(
+			     (Rows + 1) * Columns * sizeof(u8char_T)), FALSE);
+	new_ScreenLinesC1 = (u8char_T *)lalloc((long_u)(
+			     (Rows + 1) * Columns * sizeof(u8char_T)), FALSE);
+	new_ScreenLinesC2 = (u8char_T *)lalloc((long_u)(
+			     (Rows + 1) * Columns * sizeof(u8char_T)), FALSE);
+    }
+    if (enc_dbcs == DBCS_JPNU)
+	new_ScreenLines2 = (schar_T *)lalloc((long_u)(
+			     (Rows + 1) * Columns * sizeof(schar_T)), FALSE);
+#endif
+    new_ScreenAttrs = (sattr_T *)lalloc((long_u)(
+			      (Rows + 1) * Columns * sizeof(sattr_T)), FALSE);
+    new_LineOffset = (unsigned *)lalloc((long_u)(
+					 Rows * sizeof(unsigned)), FALSE);
+    new_LineWraps = (char_u *)lalloc((long_u)(Rows * sizeof(char_u)), FALSE);
+
+    FOR_ALL_WINDOWS(wp)
+    {
+	if (win_alloc_lines(wp) == FAIL)
+	{
+	    outofmem = TRUE;
+#ifdef FEAT_WINDOWS
+	    break;
+#endif
+	}
+    }
+
+    if (new_ScreenLines == NULL
+#ifdef FEAT_MBYTE
+	    || (enc_utf8 && (new_ScreenLinesUC == NULL
+		   || new_ScreenLinesC1 == NULL || new_ScreenLinesC2 == NULL))
+	    || (enc_dbcs == DBCS_JPNU && new_ScreenLines2 == NULL)
+#endif
+	    || new_ScreenAttrs == NULL
+	    || new_LineOffset == NULL
+	    || new_LineWraps == NULL
+	    || outofmem)
+    {
+	do_outofmem_msg((long_u)((Rows + 1) * Columns));    /* guess the size */
+	vim_free(new_ScreenLines);
+	new_ScreenLines = NULL;
+#ifdef FEAT_MBYTE
+	vim_free(new_ScreenLinesUC);
+	new_ScreenLinesUC = NULL;
+	vim_free(new_ScreenLinesC1);
+	new_ScreenLinesC1 = NULL;
+	vim_free(new_ScreenLinesC2);
+	new_ScreenLinesC2 = NULL;
+	vim_free(new_ScreenLines2);
+	new_ScreenLines2 = NULL;
+#endif
+	vim_free(new_ScreenAttrs);
+	new_ScreenAttrs = NULL;
+	vim_free(new_LineOffset);
+	new_LineOffset = NULL;
+	vim_free(new_LineWraps);
+	new_LineWraps = NULL;
+    }
+    else
+    {
+	for (new_row = 0; new_row < Rows; ++new_row)
+	{
+	    new_LineOffset[new_row] = new_row * Columns;
+	    new_LineWraps[new_row] = FALSE;
+
+	    /*
+	     * If the screen is not going to be cleared, copy as much as
+	     * possible from the old screen to the new one and clear the rest
+	     * (used when resizing the window at the "--more--" prompt or when
+	     * executing an external command, for the GUI).
+	     */
+	    if (!clear)
+	    {
+		(void)vim_memset(new_ScreenLines + new_row * Columns,
+				      ' ', (size_t)Columns * sizeof(schar_T));
+#ifdef FEAT_MBYTE
+		if (enc_utf8)
+		{
+		    (void)vim_memset(new_ScreenLinesUC + new_row * Columns,
+				       0, (size_t)Columns * sizeof(u8char_T));
+		    (void)vim_memset(new_ScreenLinesC1 + new_row * Columns,
+				       0, (size_t)Columns * sizeof(u8char_T));
+		    (void)vim_memset(new_ScreenLinesC2 + new_row * Columns,
+				       0, (size_t)Columns * sizeof(u8char_T));
+		}
+		if (enc_dbcs == DBCS_JPNU)
+		    (void)vim_memset(new_ScreenLines2 + new_row * Columns,
+				       0, (size_t)Columns * sizeof(schar_T));
+#endif
+		(void)vim_memset(new_ScreenAttrs + new_row * Columns,
+					0, (size_t)Columns * sizeof(sattr_T));
+		old_row = new_row + (screen_Rows - Rows);
+		if (old_row >= 0)
+		{
+		    if (screen_Columns < Columns)
+			len = screen_Columns;
+		    else
+			len = Columns;
+		    mch_memmove(new_ScreenLines + new_LineOffset[new_row],
+			    ScreenLines + LineOffset[old_row],
+			    (size_t)len * sizeof(schar_T));
+#ifdef FEAT_MBYTE
+		    if (enc_utf8 && ScreenLinesUC != NULL)
+		    {
+			mch_memmove(new_ScreenLinesUC + new_LineOffset[new_row],
+				ScreenLinesUC + LineOffset[old_row],
+				(size_t)len * sizeof(u8char_T));
+			mch_memmove(new_ScreenLinesC1 + new_LineOffset[new_row],
+				ScreenLinesC1 + LineOffset[old_row],
+				(size_t)len * sizeof(u8char_T));
+			mch_memmove(new_ScreenLinesC2 + new_LineOffset[new_row],
+				ScreenLinesC2 + LineOffset[old_row],
+				(size_t)len * sizeof(u8char_T));
+		    }
+		    if (enc_dbcs == DBCS_JPNU && ScreenLines2 != NULL)
+			mch_memmove(new_ScreenLines2 + new_LineOffset[new_row],
+				ScreenLines2 + LineOffset[old_row],
+				(size_t)len * sizeof(schar_T));
+#endif
+		    mch_memmove(new_ScreenAttrs + new_LineOffset[new_row],
+			    ScreenAttrs + LineOffset[old_row],
+			    (size_t)len * sizeof(sattr_T));
+		}
+	    }
+	}
+	/* Use the last line of the screen for the current line. */
+	current_ScreenLine = new_ScreenLines + Rows * Columns;
+    }
+
+    vim_free(ScreenLines);
+#ifdef FEAT_MBYTE
+    vim_free(ScreenLinesUC);
+    vim_free(ScreenLinesC1);
+    vim_free(ScreenLinesC2);
+    vim_free(ScreenLines2);
+#endif
+    vim_free(ScreenAttrs);
+    vim_free(LineOffset);
+    vim_free(LineWraps);
+    ScreenLines = new_ScreenLines;
+#ifdef FEAT_MBYTE
+    ScreenLinesUC = new_ScreenLinesUC;
+    ScreenLinesC1 = new_ScreenLinesC1;
+    ScreenLinesC2 = new_ScreenLinesC2;
+    ScreenLines2 = new_ScreenLines2;
+#endif
+    ScreenAttrs = new_ScreenAttrs;
+    LineOffset = new_LineOffset;
+    LineWraps = new_LineWraps;
+
+    /* It's important that screen_Rows and screen_Columns reflect the actual
+     * size of ScreenLines[].  Set them before calling anything. */
+#ifdef FEAT_GUI
+    old_Rows = screen_Rows;
+#endif
+    screen_Rows = Rows;
+    screen_Columns = Columns;
+
+    must_redraw = CLEAR;	/* need to clear the screen later */
+    if (clear)
+	screenclear2();
+
+#ifdef FEAT_GUI
+    else if (gui.in_use
+	    && !gui.starting
+	    && ScreenLines != NULL
+	    && old_Rows != Rows)
+    {
+	(void)gui_redraw_block(0, 0, (int)Rows - 1, (int)Columns - 1, 0);
+	/*
+	 * Adjust the position of the cursor, for when executing an external
+	 * command.
+	 */
+	if (msg_row >= Rows)		/* Rows got smaller */
+	    msg_row = Rows - 1;		/* put cursor at last row */
+	else if (Rows > old_Rows)	/* Rows got bigger */
+	    msg_row += Rows - old_Rows; /* put cursor in same place */
+	if (msg_col >= Columns)		/* Columns got smaller */
+	    msg_col = Columns - 1;	/* put cursor at last column */
+    }
+#endif
+
+#ifdef FEAT_GUI_BEOS
+    vim_unlock_screen();
+#endif
+    entered = FALSE;
+}
+
+    void
+screenclear()
+{
+    check_for_delay(FALSE);
+    screenalloc(FALSE);	    /* allocate screen buffers if size changed */
+    screenclear2();	    /* clear the screen */
+}
+
+    static void
+screenclear2()
+{
+    int	    i;
+
+    if (starting == NO_SCREEN || ScreenLines == NULL
+#ifdef FEAT_GUI
+	    || (gui.in_use && gui.starting)
+#endif
+	    )
+	return;
+
+#ifdef FEAT_GUI
+    if (!gui.in_use)
+#endif
+	screen_attr = -1;	/* force setting the Normal colors */
+    screen_stop_highlight();	/* don't want highlighting here */
+
+#ifdef FEAT_CLIPBOARD
+    /* disable selection without redrawing it */
+    clip_scroll_selection(9999);
+#endif
+
+    /* blank out ScreenLines */
+    for (i = 0; i < Rows; ++i)
+    {
+	lineclear(LineOffset[i], (int)Columns);
+	LineWraps[i] = FALSE;
+    }
+
+    if (can_clear(T_CL))
+    {
+	out_str(T_CL);		/* clear the display */
+	clear_cmdline = FALSE;
+    }
+    else
+    {
+	/* can't clear the screen, mark all chars with invalid attributes */
+	for (i = 0; i < Rows; ++i)
+	    lineinvalid(LineOffset[i], (int)Columns);
+	clear_cmdline = TRUE;
+    }
+
+    screen_cleared = TRUE;	/* can use contents of ScreenLines now */
+
+    win_rest_invalid(firstwin);
+    redraw_cmdline = TRUE;
+    if (must_redraw == CLEAR)	/* no need to clear again */
+	must_redraw = NOT_VALID;
+    compute_cmdrow();
+    msg_row = cmdline_row;	/* put cursor on last line for messages */
+    msg_col = 0;
+    screen_start();		/* don't know where cursor is now */
+    msg_scrolled = 0;		/* can't scroll back */
+    msg_didany = FALSE;
+    msg_didout = FALSE;
+}
+
+/*
+ * Clear one line in ScreenLines.
+ */
+    static void
+lineclear(off, width)
+    unsigned	off;
+    int		width;
+{
+    (void)vim_memset(ScreenLines + off, ' ', (size_t)width * sizeof(schar_T));
+#ifdef FEAT_MBYTE
+    if (enc_utf8)
+	(void)vim_memset(ScreenLinesUC + off, 0,
+					  (size_t)width * sizeof(u8char_T));
+#endif
+    (void)vim_memset(ScreenAttrs + off, 0, (size_t)width * sizeof(sattr_T));
+}
+
+/*
+ * Mark one line in ScreenLines invalid by setting the attributes to an
+ * invalid value.
+ */
+    static void
+lineinvalid(off, width)
+    unsigned	off;
+    int		width;
+{
+    (void)vim_memset(ScreenAttrs + off, -1, (size_t)width * sizeof(sattr_T));
+}
+
+#ifdef FEAT_VERTSPLIT
+/*
+ * Copy part of a Screenline for vertically split window "wp".
+ */
+    static void
+linecopy(to, from, wp)
+    int		to;
+    int		from;
+    win_T	*wp;
+{
+    unsigned	off_to = LineOffset[to] + wp->w_wincol;
+    unsigned	off_from = LineOffset[from] + wp->w_wincol;
+
+    mch_memmove(ScreenLines + off_to, ScreenLines + off_from,
+	    wp->w_width * sizeof(schar_T));
+# ifdef FEAT_MBYTE
+    if (enc_utf8)
+    {
+	mch_memmove(ScreenLinesUC + off_to, ScreenLinesUC + off_from,
+		wp->w_width * sizeof(u8char_T));
+	mch_memmove(ScreenLinesC1 + off_to, ScreenLinesC1 + off_from,
+		wp->w_width * sizeof(u8char_T));
+	mch_memmove(ScreenLinesC2 + off_to, ScreenLinesC2 + off_from,
+		wp->w_width * sizeof(u8char_T));
+    }
+    if (enc_dbcs == DBCS_JPNU)
+	mch_memmove(ScreenLines2 + off_to, ScreenLines2 + off_from,
+		wp->w_width * sizeof(schar_T));
+# endif
+    mch_memmove(ScreenAttrs + off_to, ScreenAttrs + off_from,
+	    wp->w_width * sizeof(sattr_T));
+}
+#endif
+
+/*
+ * Return TRUE if clearing with term string "p" would work.
+ * It can't work when the string is empty or it won't set the right background.
+ */
+    int
+can_clear(p)
+    char_u	*p;
+{
+    return (*p != NUL && (t_colors <= 1
+#ifdef FEAT_GUI
+		|| gui.in_use
+#endif
+		|| cterm_normal_bg_color == 0 || *T_UT != NUL));
+}
+
+/*
+ * Reset cursor position. Use whenever cursor was moved because of outputting
+ * something directly to the screen (shell commands) or a terminal control
+ * code.
+ */
+    void
+screen_start()
+{
+    screen_cur_row = screen_cur_col = 9999;
+}
+
+/*
+ * Note that the cursor has gone down to the next line, column 0.
+ * Used for Ex mode.
+ */
+    void
+screen_down()
+{
+    screen_cur_col = 0;
+    if (screen_cur_row < Rows - 1)
+	++screen_cur_row;
+}
+
+/*
+ * Move the cursor to position "row","col" in the screen.
+ * This tries to find the most efficient way to move, minimizing the number of
+ * characters sent to the terminal.
+ */
+    void
+windgoto(row, col)
+    int	    row;
+    int	    col;
+{
+    char_u	    *p;
+    int		    i;
+    int		    plan;
+    int		    cost;
+    int		    wouldbe_col;
+    int		    noinvcurs;
+    char_u	    *bs;
+    int		    goto_cost;
+    int		    attr;
+
+#define GOTO_COST   7	/* asssume a term_windgoto() takes about 7 chars */
+#define HIGHL_COST  5	/* assume unhighlight takes 5 chars */
+
+#define PLAN_LE	    1
+#define PLAN_CR	    2
+#define PLAN_NL	    3
+#define PLAN_WRITE  4
+    /* Can't use ScreenLines unless initialized */
+    if (ScreenLines == NULL)
+	return;
+
+    if (col != screen_cur_col || row != screen_cur_row)
+    {
+	/* Check for valid position. */
+	if (row < 0)	/* window without text lines? */
+	    row = 0;
+	if (row >= screen_Rows)
+	    row = screen_Rows - 1;
+	if (col >= screen_Columns)
+	    col = screen_Columns - 1;
+
+	/* check if no cursor movement is allowed in highlight mode */
+	if (screen_attr && *T_MS == NUL)
+	    noinvcurs = HIGHL_COST;
+	else
+	    noinvcurs = 0;
+	goto_cost = GOTO_COST + noinvcurs;
+
+	/*
+	 * Plan how to do the positioning:
+	 * 1. Use CR to move it to column 0, same row.
+	 * 2. Use T_LE to move it a few columns to the left.
+	 * 3. Use NL to move a few lines down, column 0.
+	 * 4. Move a few columns to the right with T_ND or by writing chars.
+	 *
+	 * Don't do this if the cursor went beyond the last column, the cursor
+	 * position is unknown then (some terminals wrap, some don't )
+	 *
+	 * First check if the highlighting attibutes allow us to write
+	 * characters to move the cursor to the right.
+	 */
+	if (row >= screen_cur_row && screen_cur_col < Columns)
+	{
+	    /*
+	     * If the cursor is in the same row, bigger col, we can use CR
+	     * or T_LE.
+	     */
+	    bs = NULL;			    /* init for GCC */
+	    attr = screen_attr;
+	    if (row == screen_cur_row && col < screen_cur_col)
+	    {
+		/* "le" is preferred over "bc", because "bc" is obsolete */
+		if (*T_LE)
+		    bs = T_LE;		    /* "cursor left" */
+		else
+		    bs = T_BC;		    /* "backspace character (old) */
+		if (*bs)
+		    cost = (screen_cur_col - col) * (int)STRLEN(bs);
+		else
+		    cost = 999;
+		if (col + 1 < cost)	    /* using CR is less characters */
+		{
+		    plan = PLAN_CR;
+		    wouldbe_col = 0;
+		    cost = 1;		    /* CR is just one character */
+		}
+		else
+		{
+		    plan = PLAN_LE;
+		    wouldbe_col = col;
+		}
+		if (noinvcurs)		    /* will stop highlighting */
+		{
+		    cost += noinvcurs;
+		    attr = 0;
+		}
+	    }
+
+	    /*
+	     * If the cursor is above where we want to be, we can use CR LF.
+	     */
+	    else if (row > screen_cur_row)
+	    {
+		plan = PLAN_NL;
+		wouldbe_col = 0;
+		cost = (row - screen_cur_row) * 2;  /* CR LF */
+		if (noinvcurs)		    /* will stop highlighting */
+		{
+		    cost += noinvcurs;
+		    attr = 0;
+		}
+	    }
+
+	    /*
+	     * If the cursor is in the same row, smaller col, just use write.
+	     */
+	    else
+	    {
+		plan = PLAN_WRITE;
+		wouldbe_col = screen_cur_col;
+		cost = 0;
+	    }
+
+	    /*
+	     * Check if any characters that need to be written have the
+	     * correct attributes.  Also avoid UTF-8 characters.
+	     */
+	    i = col - wouldbe_col;
+	    if (i > 0)
+		cost += i;
+	    if (cost < goto_cost && i > 0)
+	    {
+		/*
+		 * Check if the attributes are correct without additionally
+		 * stopping highlighting.
+		 */
+		p = ScreenAttrs + LineOffset[row] + wouldbe_col;
+		while (i && *p++ == attr)
+		    --i;
+		if (i != 0)
+		{
+		    /*
+		     * Try if it works when highlighting is stopped here.
+		     */
+		    if (*--p == 0)
+		    {
+			cost += noinvcurs;
+			while (i && *p++ == 0)
+			    --i;
+		    }
+		    if (i != 0)
+			cost = 999;	/* different attributes, don't do it */
+		}
+#ifdef FEAT_MBYTE
+		if (enc_utf8)
+		{
+		    /* Don't use an UTF-8 char for positioning, it's slow. */
+		    for (i = wouldbe_col; i < col; ++i)
+			if (ScreenLinesUC[LineOffset[row] + i] != 0)
+			{
+			    cost = 999;
+			    break;
+			}
+		}
+#endif
+	    }
+
+	    /*
+	     * We can do it without term_windgoto()!
+	     */
+	    if (cost < goto_cost)
+	    {
+		if (plan == PLAN_LE)
+		{
+		    if (noinvcurs)
+			screen_stop_highlight();
+		    while (screen_cur_col > col)
+		    {
+			out_str(bs);
+			--screen_cur_col;
+		    }
+		}
+		else if (plan == PLAN_CR)
+		{
+		    if (noinvcurs)
+			screen_stop_highlight();
+		    out_char('\r');
+		    screen_cur_col = 0;
+		}
+		else if (plan == PLAN_NL)
+		{
+		    if (noinvcurs)
+			screen_stop_highlight();
+		    while (screen_cur_row < row)
+		    {
+			out_char('\n');
+			++screen_cur_row;
+		    }
+		    screen_cur_col = 0;
+		}
+
+		i = col - screen_cur_col;
+		if (i > 0)
+		{
+		    /*
+		     * Use cursor-right if it's one character only.  Avoids
+		     * removing a line of pixels from the last bold char, when
+		     * using the bold trick in the GUI.
+		     */
+		    if (T_ND[0] != NUL && T_ND[1] == NUL)
+		    {
+			while (i-- > 0)
+			    out_char(*T_ND);
+		    }
+		    else
+		    {
+			int	off;
+
+			off = LineOffset[row] + screen_cur_col;
+			while (i-- > 0)
+			{
+			    if (ScreenAttrs[off] != screen_attr)
+				screen_stop_highlight();
+#ifdef FEAT_MBYTE
+			    out_flush_check();
+#endif
+			    out_char(ScreenLines[off]);
+#ifdef FEAT_MBYTE
+			    if (enc_dbcs == DBCS_JPNU
+						  && ScreenLines[off] == 0x8e)
+				out_char(ScreenLines2[off]);
+#endif
+			    ++off;
+			}
+		    }
+		}
+	    }
+	}
+	else
+	    cost = 999;
+
+	if (cost >= goto_cost)
+	{
+	    if (noinvcurs)
+		screen_stop_highlight();
+	    if (row == screen_cur_row && (col > screen_cur_col) &&
+								*T_CRI != NUL)
+		term_cursor_right(col - screen_cur_col);
+	    else
+		term_windgoto(row, col);
+	}
+	screen_cur_row = row;
+	screen_cur_col = col;
+    }
+}
+
+/*
+ * Set cursor to its position in the current window.
+ */
+    void
+setcursor()
+{
+    if (redrawing())
+    {
+	validate_cursor();
+	windgoto(W_WINROW(curwin) + curwin->w_wrow,
+		W_WINCOL(curwin) + (
+#ifdef FEAT_RIGHTLEFT
+		curwin->w_p_rl ? ((int)W_WIDTH(curwin) - curwin->w_wcol - (
+# ifdef FEAT_MBYTE
+			has_mbyte ? (*mb_ptr2cells)(ml_get_cursor()) :
+# endif
+			1)) :
+#endif
+							    curwin->w_wcol));
+    }
+}
+
+
+/*
+ * insert 'line_count' lines at 'row' in window 'wp'
+ * if 'invalid' is TRUE the wp->w_lines[].wl_lnum is invalidated.
+ * if 'mayclear' is TRUE the screen will be cleared if it is faster than
+ * scrolling.
+ * Returns FAIL if the lines are not inserted, OK for success.
+ */
+    int
+win_ins_lines(wp, row, line_count, invalid, mayclear)
+    win_T	*wp;
+    int		row;
+    int		line_count;
+    int		invalid;
+    int		mayclear;
+{
+    int		did_delete;
+    int		nextrow;
+    int		lastrow;
+    int		retval;
+
+    if (invalid)
+	wp->w_lines_valid = 0;
+
+    if (wp->w_height < 5)
+	return FAIL;
+
+    if (line_count > wp->w_height - row)
+	line_count = wp->w_height - row;
+
+    retval = win_do_lines(wp, row, line_count, mayclear, FALSE);
+    if (retval != MAYBE)
+	return retval;
+
+    /*
+     * If there is a next window or a status line, we first try to delete the
+     * lines at the bottom to avoid messing what is after the window.
+     * If this fails and there are following windows, don't do anything to avoid
+     * messing up those windows, better just redraw.
+     */
+    did_delete = FALSE;
+#ifdef FEAT_WINDOWS
+    if (wp->w_next != NULL || wp->w_status_height)
+    {
+	if (screen_del_lines(0, W_WINROW(wp) + wp->w_height - line_count,
+				    line_count, (int)Rows, FALSE, NULL) == OK)
+	    did_delete = TRUE;
+	else if (wp->w_next)
+	    return FAIL;
+    }
+#endif
+    /*
+     * if no lines deleted, blank the lines that will end up below the window
+     */
+    if (!did_delete)
+    {
+#ifdef FEAT_WINDOWS
+	wp->w_redr_status = TRUE;
+#endif
+	redraw_cmdline = TRUE;
+	nextrow = W_WINROW(wp) + wp->w_height + W_STATUS_HEIGHT(wp);
+	lastrow = nextrow + line_count;
+	if (lastrow > Rows)
+	    lastrow = Rows;
+	screen_fill(nextrow - line_count, lastrow - line_count,
+		  W_WINCOL(wp), (int)W_ENDCOL(wp),
+		  ' ', ' ', 0);
+    }
+
+    if (screen_ins_lines(0, W_WINROW(wp) + row, line_count, (int)Rows, NULL)
+								      == FAIL)
+    {
+	    /* deletion will have messed up other windows */
+	if (did_delete)
+	{
+#ifdef FEAT_WINDOWS
+	    wp->w_redr_status = TRUE;
+#endif
+	    win_rest_invalid(W_NEXT(wp));
+	}
+	return FAIL;
+    }
+
+    return OK;
+}
+
+/*
+ * delete "line_count" window lines at "row" in window "wp"
+ * If "invalid" is TRUE curwin->w_lines[] is invalidated.
+ * If "mayclear" is TRUE the screen will be cleared if it is faster than
+ * scrolling
+ * Return OK for success, FAIL if the lines are not deleted.
+ */
+    int
+win_del_lines(wp, row, line_count, invalid, mayclear)
+    win_T	*wp;
+    int		row;
+    int		line_count;
+    int		invalid;
+    int		mayclear;
+{
+    int		retval;
+
+    if (invalid)
+	wp->w_lines_valid = 0;
+
+    if (line_count > wp->w_height - row)
+	line_count = wp->w_height - row;
+
+    retval = win_do_lines(wp, row, line_count, mayclear, TRUE);
+    if (retval != MAYBE)
+	return retval;
+
+    if (screen_del_lines(0, W_WINROW(wp) + row, line_count,
+					      (int)Rows, FALSE, NULL) == FAIL)
+	return FAIL;
+
+#ifdef FEAT_WINDOWS
+    /*
+     * If there are windows or status lines below, try to put them at the
+     * correct place. If we can't do that, they have to be redrawn.
+     */
+    if (wp->w_next || wp->w_status_height || cmdline_row < Rows - 1)
+    {
+	if (screen_ins_lines(0, W_WINROW(wp) + wp->w_height - line_count,
+					 line_count, (int)Rows, NULL) == FAIL)
+	{
+	    wp->w_redr_status = TRUE;
+	    win_rest_invalid(wp->w_next);
+	}
+    }
+    /*
+     * If this is the last window and there is no status line, redraw the
+     * command line later.
+     */
+    else
+#endif
+	redraw_cmdline = TRUE;
+    return OK;
+}
+
+/*
+ * Common code for win_ins_lines() and win_del_lines().
+ * Returns OK or FAIL when the work has been done.
+ * Returns MAYBE when not finished yet.
+ */
+    static int
+win_do_lines(wp, row, line_count, mayclear, del)
+    win_T	*wp;
+    int		row;
+    int		line_count;
+    int		mayclear;
+    int		del;
+{
+    int		retval;
+
+    if (!redrawing() || line_count <= 0)
+	return FAIL;
+
+    /* only a few lines left: redraw is faster */
+    if (mayclear && Rows - line_count < 5
+#ifdef FEAT_VERTSPLIT
+	    && wp->w_width == Columns
+#endif
+	    )
+    {
+	screenclear();	    /* will set wp->w_lines_valid to 0 */
+	return FAIL;
+    }
+
+    /*
+     * Delete all remaining lines
+     */
+    if (row + line_count >= wp->w_height)
+    {
+	screen_fill(W_WINROW(wp) + row, W_WINROW(wp) + wp->w_height,
+		W_WINCOL(wp), (int)W_ENDCOL(wp),
+		' ', ' ', 0);
+	return OK;
+    }
+
+    /*
+     * when scrolling, the message on the command line should be cleared,
+     * otherwise it will stay there forever.
+     */
+    clear_cmdline = TRUE;
+
+    /*
+     * If the terminal can set a scroll region, use that.
+     * Always do this in a vertically split window.  This will redraw from
+     * ScreenLines[] when t_CV isn't defined.  That's faster than using
+     * win_line().
+     * Don't use a scroll region when we are going to redraw the text, writing
+     * a character in the lower right corner of the scroll region causes a
+     * scroll-up in the DJGPP version.
+     */
+    if (scroll_region
+#ifdef FEAT_VERTSPLIT
+	    || W_WIDTH(wp) != Columns
+#endif
+	    )
+    {
+#ifdef FEAT_VERTSPLIT
+	if (scroll_region && (wp->w_width == Columns || *T_CSV != NUL))
+#endif
+	    scroll_region_set(wp, row);
+	if (del)
+	    retval = screen_del_lines(W_WINROW(wp) + row, 0, line_count,
+					       wp->w_height - row, FALSE, wp);
+	else
+	    retval = screen_ins_lines(W_WINROW(wp) + row, 0, line_count,
+						      wp->w_height - row, wp);
+#ifdef FEAT_VERTSPLIT
+	if (scroll_region && (wp->w_width == Columns || *T_CSV != NUL))
+#endif
+	    scroll_region_reset();
+	return retval;
+    }
+
+#ifdef FEAT_WINDOWS
+    if (wp->w_next != NULL && p_tf) /* don't delete/insert on fast terminal */
+	return FAIL;
+#endif
+
+    return MAYBE;
+}
+
+/*
+ * window 'wp' and everything after it is messed up, mark it for redraw
+ */
+    static void
+win_rest_invalid(wp)
+    win_T	*wp;
+{
+#ifdef FEAT_WINDOWS
+    while (wp != NULL)
+#else
+    if (wp != NULL)
+#endif
+    {
+	redraw_win_later(wp, NOT_VALID);
+#ifdef FEAT_WINDOWS
+	wp->w_redr_status = TRUE;
+	wp = wp->w_next;
+#endif
+    }
+    redraw_cmdline = TRUE;
+}
+
+/*
+ * The rest of the routines in this file perform screen manipulations. The
+ * given operation is performed physically on the screen. The corresponding
+ * change is also made to the internal screen image. In this way, the editor
+ * anticipates the effect of editing changes on the appearance of the screen.
+ * That way, when we call screenupdate a complete redraw isn't usually
+ * necessary. Another advantage is that we can keep adding code to anticipate
+ * screen changes, and in the meantime, everything still works.
+ */
+
+/*
+ * types for inserting or deleting lines
+ */
+#define USE_T_CAL   1
+#define USE_T_CDL   2
+#define USE_T_AL    3
+#define USE_T_CE    4
+#define USE_T_DL    5
+#define USE_T_SR    6
+#define USE_NL	    7
+#define USE_T_CD    8
+#define USE_REDRAW  9
+
+/*
+ * insert lines on the screen and update ScreenLines[]
+ * 'end' is the line after the scrolled part. Normally it is Rows.
+ * When scrolling region used 'off' is the offset from the top for the region.
+ * 'row' and 'end' are relative to the start of the region.
+ *
+ * return FAIL for failure, OK for success.
+ */
+    static int
+screen_ins_lines(off, row, line_count, end, wp)
+    int		off;
+    int		row;
+    int		line_count;
+    int		end;
+    win_T	*wp;	    /* NULL or window to use width from */
+{
+    int		i;
+    int		j;
+    unsigned	temp;
+    int		cursor_row;
+    int		type;
+    int		result_empty;
+    int		can_ce = can_clear(T_CE);
+
+    /*
+     * FAIL if
+     * - there is no valid screen
+     * - the screen has to be redrawn completely
+     * - the line count is less than one
+     * - the line count is more than 'ttyscroll'
+     */
+    if (!screen_valid(TRUE) || line_count <= 0 || line_count > p_ttyscroll)
+	return FAIL;
+
+    /*
+     * There are seven ways to insert lines:
+     * 0. When in a vertically split window and t_CV isn't set, redraw the
+     *    characters from ScreenLines[].
+     * 1. Use T_CD (clear to end of display) if it exists and the result of
+     *	  the insert is just empty lines
+     * 2. Use T_CAL (insert multiple lines) if it exists and T_AL is not
+     *	  present or line_count > 1. It looks better if we do all the inserts
+     *	  at once.
+     * 3. Use T_CDL (delete multiple lines) if it exists and the result of the
+     *	  insert is just empty lines and T_CE is not present or line_count >
+     *	  1.
+     * 4. Use T_AL (insert line) if it exists.
+     * 5. Use T_CE (erase line) if it exists and the result of the insert is
+     *	  just empty lines.
+     * 6. Use T_DL (delete line) if it exists and the result of the insert is
+     *	  just empty lines.
+     * 7. Use T_SR (scroll reverse) if it exists and inserting at row 0 and
+     *	  the 'da' flag is not set or we have clear line capability.
+     * 8. redraw the characters from ScreenLines[].
+     *
+     * Careful: In a hpterm scroll reverse doesn't work as expected, it moves
+     * the scrollbar for the window. It does have insert line, use that if it
+     * exists.
+     */
+    result_empty = (row + line_count >= end);
+#ifdef FEAT_VERTSPLIT
+    if (wp != NULL && wp->w_width != Columns && *T_CSV == NUL)
+	type = USE_REDRAW;
+    else
+#endif
+    if (can_clear(T_CD) && result_empty)
+	type = USE_T_CD;
+    else if (*T_CAL != NUL && (line_count > 1 || *T_AL == NUL))
+	type = USE_T_CAL;
+    else if (*T_CDL != NUL && result_empty && (line_count > 1 || !can_ce))
+	type = USE_T_CDL;
+    else if (*T_AL != NUL)
+	type = USE_T_AL;
+    else if (can_ce && result_empty)
+	type = USE_T_CE;
+    else if (*T_DL != NUL && result_empty)
+	type = USE_T_DL;
+    else if (*T_SR != NUL && row == 0 && (*T_DA == NUL || can_ce))
+	type = USE_T_SR;
+    else
+	return FAIL;
+
+    /*
+     * For clearing the lines screen_del_lines() is used. This will also take
+     * care of t_db if necessary.
+     */
+    if (type == USE_T_CD || type == USE_T_CDL ||
+					 type == USE_T_CE || type == USE_T_DL)
+	return screen_del_lines(off, row, line_count, end, FALSE, wp);
+
+    /*
+     * If text is retained below the screen, first clear or delete as many
+     * lines at the bottom of the window as are about to be inserted so that
+     * the deleted lines won't later surface during a screen_del_lines.
+     */
+    if (*T_DB)
+	screen_del_lines(off, end - line_count, line_count, end, FALSE, wp);
+
+#ifdef FEAT_CLIPBOARD
+    /* Remove a modeless selection when inserting lines halfway the screen
+     * or not the full width of the screen. */
+    if (off + row > 0
+# ifdef FEAT_VERTSPLIT
+	    || (wp != NULL && wp->w_width != Columns)
+# endif
+       )
+	clip_clear_selection();
+    else
+	clip_scroll_selection(-line_count);
+#endif
+
+#ifdef FEAT_GUI_BEOS
+    vim_lock_screen();
+#endif
+#ifdef FEAT_GUI
+    /* Don't update the GUI cursor here, ScreenLines[] is invalid until the
+     * scrolling is actually carried out. */
+    gui_dont_update_cursor();
+#endif
+
+    if (*T_CCS != NUL)	   /* cursor relative to region */
+	cursor_row = row;
+    else
+	cursor_row = row + off;
+
+    /*
+     * Shift LineOffset[] line_count down to reflect the inserted lines.
+     * Clear the inserted lines in ScreenLines[].
+     */
+    row += off;
+    end += off;
+    for (i = 0; i < line_count; ++i)
+    {
+#ifdef FEAT_VERTSPLIT
+	if (wp != NULL && wp->w_width != Columns)
+	{
+	    /* need to copy part of a line */
+	    j = end - 1 - i;
+	    while ((j -= line_count) >= row)
+		linecopy(j + line_count, j, wp);
+	    j += line_count;
+	    if (can_clear((char_u *)" "))
+		lineclear(LineOffset[j] + wp->w_wincol, wp->w_width);
+	    else
+		lineinvalid(LineOffset[j] + wp->w_wincol, wp->w_width);
+	    LineWraps[j] = FALSE;
+	}
+	else
+#endif
+	{
+	    j = end - 1 - i;
+	    temp = LineOffset[j];
+	    while ((j -= line_count) >= row)
+	    {
+		LineOffset[j + line_count] = LineOffset[j];
+		LineWraps[j + line_count] = LineWraps[j];
+	    }
+	    LineOffset[j + line_count] = temp;
+	    LineWraps[j + line_count] = FALSE;
+	    if (can_clear((char_u *)" "))
+		lineclear(temp, (int)Columns);
+	    else
+		lineinvalid(temp, (int)Columns);
+	}
+    }
+#ifdef FEAT_GUI_BEOS
+    vim_unlock_screen();
+#endif
+
+    screen_stop_highlight();
+    windgoto(cursor_row, 0);
+
+#ifdef FEAT_VERTSPLIT
+    /* redraw the characters */
+    if (type == USE_REDRAW)
+	redraw_block(row, end, wp);
+    else
+#endif
+	if (type == USE_T_CAL)
+    {
+	term_append_lines(line_count);
+	screen_start();		/* don't know where cursor is now */
+    }
+    else
+    {
+	for (i = 0; i < line_count; i++)
+	{
+	    if (type == USE_T_AL)
+	    {
+		if (i && cursor_row != 0)
+		    windgoto(cursor_row, 0);
+		out_str(T_AL);
+	    }
+	    else  /* type == USE_T_SR */
+		out_str(T_SR);
+	    screen_start();	    /* don't know where cursor is now */
+	}
+    }
+
+    /*
+     * With scroll-reverse and 'da' flag set we need to clear the lines that
+     * have been scrolled down into the region.
+     */
+    if (type == USE_T_SR && *T_DA)
+    {
+	for (i = 0; i < line_count; ++i)
+	{
+	    windgoto(off + i, 0);
+	    out_str(T_CE);
+	    screen_start();	    /* don't know where cursor is now */
+	}
+    }
+
+#ifdef FEAT_GUI
+    gui_can_update_cursor();
+    if (gui.in_use)
+	out_flush();	/* always flush after a scroll */
+#endif
+    return OK;
+}
+
+/*
+ * delete lines on the screen and update ScreenLines[]
+ * 'end' is the line after the scrolled part. Normally it is Rows.
+ * When scrolling region used 'off' is the offset from the top for the region.
+ * 'row' and 'end' are relative to the start of the region.
+ *
+ * Return OK for success, FAIL if the lines are not deleted.
+ */
+/*ARGSUSED*/
+    int
+screen_del_lines(off, row, line_count, end, force, wp)
+    int		off;
+    int		row;
+    int		line_count;
+    int		end;
+    int		force;		/* even when line_count > p_ttyscroll */
+    win_T	*wp;		/* NULL or window to use width from */
+{
+    int		j;
+    int		i;
+    unsigned	temp;
+    int		cursor_row;
+    int		cursor_end;
+    int		result_empty;	/* result is empty until end of region */
+    int		can_delete;	/* deleting line codes can be used */
+    int		type;
+
+    /*
+     * FAIL if
+     * - there is no valid screen
+     * - the screen has to be redrawn completely
+     * - the line count is less than one
+     * - the line count is more than 'ttyscroll'
+     */
+    if (!screen_valid(TRUE) || line_count <= 0 ||
+					 (!force && line_count > p_ttyscroll))
+	return FAIL;
+
+    /*
+     * Check if the rest of the current region will become empty.
+     */
+    result_empty = row + line_count >= end;
+
+    /*
+     * We can delete lines only when 'db' flag not set or when 'ce' option
+     * available.
+     */
+    can_delete = (*T_DB == NUL || can_clear(T_CE));
+
+    /*
+     * There are six ways to delete lines:
+     * 0. When in a vertically split window and t_CV isn't set, redraw the
+     *    characters from ScreenLines[].
+     * 1. Use T_CD if it exists and the result is empty.
+     * 2. Use newlines if row == 0 and count == 1 or T_CDL does not exist.
+     * 3. Use T_CDL (delete multiple lines) if it exists and line_count > 1 or
+     *	  none of the other ways work.
+     * 4. Use T_CE (erase line) if the result is empty.
+     * 5. Use T_DL (delete line) if it exists.
+     * 6. redraw the characters from ScreenLines[].
+     */
+#ifdef FEAT_VERTSPLIT
+    if (wp != NULL && wp->w_width != Columns && *T_CSV == NUL)
+	type = USE_REDRAW;
+    else
+#endif
+    if (can_clear(T_CD) && result_empty)
+	type = USE_T_CD;
+#if defined(__BEOS__) && defined(BEOS_DR8)
+    /*
+     * USE_NL does not seem to work in Terminal of DR8 so we set T_DB="" in
+     * its internal termcap... this works okay for tests which test *T_DB !=
+     * NUL.  It has the disadvantage that the user cannot use any :set t_*
+     * command to get T_DB (back) to empty_option, only :set term=... will do
+     * the trick...
+     * Anyway, this hack will hopefully go away with the next OS release.
+     * (Olaf Seibert)
+     */
+    else if (row == 0 && T_DB == empty_option
+					&& (line_count == 1 || *T_CDL == NUL))
+#else
+    else if (row == 0 && (
+#ifndef AMIGA
+	/* On the Amiga, somehow '\n' on the last line doesn't always scroll
+	 * up, so use delete-line command */
+			    line_count == 1 ||
+#endif
+						*T_CDL == NUL))
+#endif
+	type = USE_NL;
+    else if (*T_CDL != NUL && line_count > 1 && can_delete)
+	type = USE_T_CDL;
+    else if (can_clear(T_CE) && result_empty
+#ifdef FEAT_VERTSPLIT
+	    && (wp == NULL || wp->w_width == Columns)
+#endif
+	    )
+	type = USE_T_CE;
+    else if (*T_DL != NUL && can_delete)
+	type = USE_T_DL;
+    else if (*T_CDL != NUL && can_delete)
+	type = USE_T_CDL;
+    else
+	return FAIL;
+
+#ifdef FEAT_CLIPBOARD
+    /* Remove a modeless selection when deleting lines halfway the screen or
+     * not the full width of the screen. */
+    if (off + row > 0
+# ifdef FEAT_VERTSPLIT
+	    || (wp != NULL && wp->w_width != Columns)
+# endif
+       )
+	clip_clear_selection();
+    else
+	clip_scroll_selection(line_count);
+#endif
+
+#ifdef FEAT_GUI_BEOS
+    vim_lock_screen();
+#endif
+#ifdef FEAT_GUI
+    /* Don't update the GUI cursor here, ScreenLines[] is invalid until the
+     * scrolling is actually carried out. */
+    gui_dont_update_cursor();
+#endif
+
+    if (*T_CCS != NUL)	    /* cursor relative to region */
+    {
+	cursor_row = row;
+	cursor_end = end;
+    }
+    else
+    {
+	cursor_row = row + off;
+	cursor_end = end + off;
+    }
+
+    /*
+     * Now shift LineOffset[] line_count up to reflect the deleted lines.
+     * Clear the inserted lines in ScreenLines[].
+     */
+    row += off;
+    end += off;
+    for (i = 0; i < line_count; ++i)
+    {
+#ifdef FEAT_VERTSPLIT
+	if (wp != NULL && wp->w_width != Columns)
+	{
+	    /* need to copy part of a line */
+	    j = row + i;
+	    while ((j += line_count) <= end - 1)
+		linecopy(j - line_count, j, wp);
+	    j -= line_count;
+	    if (can_clear((char_u *)" "))
+		lineclear(LineOffset[j] + wp->w_wincol, wp->w_width);
+	    else
+		lineinvalid(LineOffset[j] + wp->w_wincol, wp->w_width);
+	    LineWraps[j] = FALSE;
+	}
+	else
+#endif
+	{
+	    /* whole width, moving the line pointers is faster */
+	    j = row + i;
+	    temp = LineOffset[j];
+	    while ((j += line_count) <= end - 1)
+	    {
+		LineOffset[j - line_count] = LineOffset[j];
+		LineWraps[j - line_count] = LineWraps[j];
+	    }
+	    LineOffset[j - line_count] = temp;
+	    LineWraps[j - line_count] = FALSE;
+	    if (can_clear((char_u *)" "))
+		lineclear(temp, (int)Columns);
+	    else
+		lineinvalid(temp, (int)Columns);
+	}
+    }
+#ifdef FEAT_GUI_BEOS
+    vim_unlock_screen();
+#endif
+
+    screen_stop_highlight();
+
+#ifdef FEAT_VERTSPLIT
+    /* redraw the characters */
+    if (type == USE_REDRAW)
+	redraw_block(row, end, wp);
+    else
+#endif
+	if (type == USE_T_CD)	/* delete the lines */
+    {
+	windgoto(cursor_row, 0);
+	out_str(T_CD);
+	screen_start();			/* don't know where cursor is now */
+    }
+    else if (type == USE_T_CDL)
+    {
+	windgoto(cursor_row, 0);
+	term_delete_lines(line_count);
+	screen_start();			/* don't know where cursor is now */
+    }
+    /*
+     * Deleting lines at top of the screen or scroll region: Just scroll
+     * the whole screen (scroll region) up by outputting newlines on the
+     * last line.
+     */
+    else if (type == USE_NL)
+    {
+	windgoto(cursor_end - 1, 0);
+	for (i = line_count; --i >= 0; )
+	    out_char('\n');		/* cursor will remain on same line */
+    }
+    else
+    {
+	for (i = line_count; --i >= 0; )
+	{
+	    if (type == USE_T_DL)
+	    {
+		windgoto(cursor_row, 0);
+		out_str(T_DL);		/* delete a line */
+	    }
+	    else /* type == USE_T_CE */
+	    {
+		windgoto(cursor_row + i, 0);
+		out_str(T_CE);		/* erase a line */
+	    }
+	    screen_start();		/* don't know where cursor is now */
+	}
+    }
+
+    /*
+     * If the 'db' flag is set, we need to clear the lines that have been
+     * scrolled up at the bottom of the region.
+     */
+    if (*T_DB && (type == USE_T_DL || type == USE_T_CDL))
+    {
+	for (i = line_count; i > 0; --i)
+	{
+	    windgoto(cursor_end - i, 0);
+	    out_str(T_CE);		/* erase a line */
+	    screen_start();		/* don't know where cursor is now */
+	}
+    }
+
+#ifdef FEAT_GUI
+    gui_can_update_cursor();
+    if (gui.in_use)
+	out_flush();	/* always flush after a scroll */
+#endif
+
+    return OK;
+}
+
+/*
+ * show the current mode and ruler
+ *
+ * If clear_cmdline is TRUE, clear the rest of the cmdline.
+ * If clear_cmdline is FALSE there may be a message there that needs to be
+ * cleared only if a mode is shown.
+ * Return the length of the message (0 if no message).
+ */
+    int
+showmode()
+{
+    int		need_clear;
+    int		length = 0;
+    int		do_mode;
+    int		attr;
+    int		nwr_save;
+#ifdef FEAT_INS_EXPAND
+    int		sub_attr;
+#endif
+
+    do_mode = (p_smd && ((State & INSERT) || restart_edit
+#ifdef FEAT_VISUAL
+		|| VIsual_active
+#endif
+		));
+    if (do_mode || Recording)
+    {
+	/*
+	 * Don't show mode right now, when not redrawing or inside a mapping.
+	 * Call char_avail() only when we are going to show something, because
+	 * it takes a bit of time.
+	 */
+	if (!redrawing() || (char_avail() && !KeyTyped) || msg_silent != 0)
+	{
+	    redraw_cmdline = TRUE;		/* show mode later */
+	    return 0;
+	}
+
+	nwr_save = need_wait_return;
+
+	/* wait a bit before overwriting an important message */
+	check_for_delay(FALSE);
+
+	/* if the cmdline is more than one line high, erase top lines */
+	need_clear = clear_cmdline;
+	if (clear_cmdline && cmdline_row < Rows - 1)
+	    msg_clr_cmdline();			/* will reset clear_cmdline */
+
+	/* Position on the last line in the window, column 0 */
+	msg_pos_mode();
+	cursor_off();
+	attr = hl_attr(HLF_CM);			/* Highlight mode */
+	if (do_mode)
+	{
+	    MSG_PUTS_ATTR("--", attr);
+#if defined(FEAT_XIM)
+	    if (xic != NULL && im_get_status() && !p_imdisable
+					&& curbuf->b_p_iminsert == B_IMODE_IM)
+# ifdef HAVE_GTK2 /* most of the time, it's not XIM being used */
+		MSG_PUTS_ATTR(" IM", attr);
+# else
+		MSG_PUTS_ATTR(" XIM", attr);
+# endif
+#endif
+#if defined(FEAT_HANGULIN) && defined(FEAT_GUI)
+	    if (gui.in_use)
+	    {
+		if (hangul_input_state_get())
+		    MSG_PUTS_ATTR(" ÇѱÛ", attr);   /* HANGUL */
+	    }
+#endif
+#ifdef FEAT_INS_EXPAND
+	    if (edit_submode != NULL)		/* CTRL-X in Insert mode */
+	    {
+		/* These messages can get long, avoid a wrap in a narrow
+		 * window.  Prefer showing edit_submode_extra. */
+		length = (Rows - msg_row) * Columns - 3;
+		if (edit_submode_extra != NULL)
+		    length -= vim_strsize(edit_submode_extra);
+		if (length > 0)
+		{
+		    if (edit_submode_pre != NULL)
+			length -= vim_strsize(edit_submode_pre);
+		    if (length - vim_strsize(edit_submode) > 0)
+		    {
+			if (edit_submode_pre != NULL)
+			    msg_puts_attr(edit_submode_pre, attr);
+			msg_puts_attr(edit_submode, attr);
+		    }
+		    if (edit_submode_extra != NULL)
+		    {
+			MSG_PUTS_ATTR(" ", attr);  /* add a space in between */
+			if ((int)edit_submode_highl < (int)HLF_COUNT)
+			    sub_attr = hl_attr(edit_submode_highl);
+			else
+			    sub_attr = attr;
+			msg_puts_attr(edit_submode_extra, sub_attr);
+		    }
+		}
+		length = 0;
+	    }
+	    else
+#endif
+	    {
+#ifdef FEAT_VREPLACE
+		if (State & VREPLACE_FLAG)
+		    MSG_PUTS_ATTR(_(" VREPLACE"), attr);
+		else
+#endif
+		    if (State & REPLACE_FLAG)
+		    MSG_PUTS_ATTR(_(" REPLACE"), attr);
+		else if (State & INSERT)
+		{
+#ifdef FEAT_RIGHTLEFT
+		    if (p_ri)
+			MSG_PUTS_ATTR(_(" REVERSE"), attr);
+#endif
+		    MSG_PUTS_ATTR(_(" INSERT"), attr);
+		}
+		else if (restart_edit == 'I')
+		    MSG_PUTS_ATTR(_(" (insert)"), attr);
+		else if (restart_edit == 'R')
+		    MSG_PUTS_ATTR(_(" (replace)"), attr);
+		else if (restart_edit == 'V')
+		    MSG_PUTS_ATTR(_(" (vreplace)"), attr);
+#ifdef FEAT_RIGHTLEFT
+		if (p_hkmap)
+		    MSG_PUTS_ATTR(_(" Hebrew"), attr);
+# ifdef FEAT_FKMAP
+		if (p_fkmap)
+		    MSG_PUTS_ATTR(farsi_text_5, attr);
+# endif
+#endif
+#ifdef FEAT_KEYMAP
+		if (State & LANGMAP)
+		{
+# ifdef FEAT_ARABIC
+		    if (curwin->w_p_arab)
+			MSG_PUTS_ATTR(_(" Arabic"), attr);
+		    else
+# endif
+			MSG_PUTS_ATTR(_(" (lang)"), attr);
+		}
+#endif
+		if ((State & INSERT) && p_paste)
+		    MSG_PUTS_ATTR(_(" (paste)"), attr);
+
+#ifdef FEAT_VISUAL
+		if (VIsual_active)
+		{
+		    char *p;
+
+		    /* Don't concatenate separate words to avoid translation
+		     * problems. */
+		    switch ((VIsual_select ? 4 : 0)
+			    + (VIsual_mode == Ctrl_V) * 2
+			    + (VIsual_mode == 'V'))
+		    {
+			case 0:	p = N_(" VISUAL"); break;
+			case 1: p = N_(" VISUAL LINE"); break;
+			case 2: p = N_(" VISUAL BLOCK"); break;
+			case 4: p = N_(" SELECT"); break;
+			case 5: p = N_(" SELECT LINE"); break;
+			default: p = N_(" SELECT BLOCK"); break;
+		    }
+		    MSG_PUTS_ATTR(_(p), attr);
+		}
+#endif
+		MSG_PUTS_ATTR(" --", attr);
+	    }
+	    need_clear = TRUE;
+	}
+	if (Recording
+#ifdef FEAT_INS_EXPAND
+		&& edit_submode == NULL	    /* otherwise it gets too long */
+#endif
+		)
+	{
+	    MSG_PUTS_ATTR(_("recording"), attr);
+	    need_clear = TRUE;
+	}
+	if (need_clear || clear_cmdline)
+	    msg_clr_eos();
+	msg_didout = FALSE;		/* overwrite this message */
+	length = msg_col;
+	msg_col = 0;
+	need_wait_return = nwr_save;	/* never ask for hit-return for this */
+    }
+    else if (clear_cmdline && msg_silent == 0)
+	/* Clear the whole command line.  Will reset "clear_cmdline". */
+	msg_clr_cmdline();
+
+#ifdef FEAT_CMDL_INFO
+# ifdef FEAT_VISUAL
+    /* In Visual mode the size of the selected area must be redrawn. */
+    if (VIsual_active)
+	clear_showcmd();
+# endif
+
+    /* If the last window has no status line, the ruler is after the mode
+     * message and must be redrawn */
+    if (redrawing()
+# ifdef FEAT_WINDOWS
+	    && lastwin->w_status_height == 0
+# endif
+       )
+	win_redr_ruler(lastwin, TRUE);
+#endif
+    redraw_cmdline = FALSE;
+    clear_cmdline = FALSE;
+
+    return length;
+}
+
+/*
+ * Position for a mode message.
+ */
+    static void
+msg_pos_mode()
+{
+    msg_col = 0;
+    msg_row = Rows - 1;
+}
+
+/*
+ * Delete mode message.  Used when ESC is typed which is expected to end
+ * Insert mode (but Insert mode didn't end yet!).
+ */
+    void
+unshowmode(force)
+    int	    force;
+{
+    /*
+     * Don't delete it right now, when not redrawing or insided a mapping.
+     */
+    if (!redrawing() || (!force && char_avail() && !KeyTyped))
+	redraw_cmdline = TRUE;		/* delete mode later */
+    else
+    {
+	msg_pos_mode();
+	if (Recording)
+	    MSG_PUTS_ATTR(_("recording"), hl_attr(HLF_CM));
+	msg_clr_eos();
+    }
+}
+
+#if defined(FEAT_WINDOWS) || defined(FEAT_WILDMENU) || defined(FEAT_STL_OPT)
+/*
+ * Get the character to use in a status line.  Get its attributes in "*attr".
+ */
+    static int
+fillchar_status(attr, is_curwin)
+    int		*attr;
+    int		is_curwin;
+{
+    int fill;
+    if (is_curwin)
+    {
+	*attr = hl_attr(HLF_S);
+	fill = fill_stl;
+    }
+    else
+    {
+	*attr = hl_attr(HLF_SNC);
+	fill = fill_stlnc;
+    }
+    /* Use fill when there is highlighting, and highlighting of current
+     * window differs, or the fillchars differ, or this is not the
+     * current window */
+    if (*attr != 0 && ((hl_attr(HLF_S) != hl_attr(HLF_SNC)
+			|| !is_curwin || firstwin == lastwin)
+		    || (fill_stl != fill_stlnc)))
+	return fill;
+    if (is_curwin)
+	return '^';
+    return '=';
+}
+#endif
+
+#ifdef FEAT_VERTSPLIT
+/*
+ * Get the character to use in a separator between vertically split windows.
+ * Get its attributes in "*attr".
+ */
+    static int
+fillchar_vsep(attr)
+    int	    *attr;
+{
+    *attr = hl_attr(HLF_C);
+    if (*attr == 0 && fill_vert == ' ')
+	return '|';
+    else
+	return fill_vert;
+}
+#endif
+
+/*
+ * Return TRUE if redrawing should currently be done.
+ */
+    int
+redrawing()
+{
+    return (!RedrawingDisabled
+		       && !(p_lz && char_avail() && !KeyTyped && !do_redraw));
+}
+
+/*
+ * Return TRUE if printing messages should currently be done.
+ */
+    int
+messaging()
+{
+    return (!(p_lz && char_avail() && !KeyTyped));
+}
+
+/*
+ * Show current status info in ruler and various other places
+ * If always is FALSE, only show ruler if position has changed.
+ */
+    void
+showruler(always)
+    int	    always;
+{
+    if (!always && !redrawing())
+	return;
+#if defined(FEAT_STL_OPT) && defined(FEAT_WINDOWS)
+    if (*p_stl && curwin->w_status_height)
+	win_redr_custom(curwin, FALSE);
+    else
+#endif
+#ifdef FEAT_CMDL_INFO
+	win_redr_ruler(curwin, always);
+#endif
+
+#ifdef FEAT_TITLE
+    if (need_maketitle
+# ifdef FEAT_STL_OPT
+	    || (p_icon && (stl_syntax & STL_IN_ICON))
+	    || (p_title && (stl_syntax & STL_IN_TITLE))
+# endif
+       )
+	maketitle();
+#endif
+}
+
+#ifdef FEAT_CMDL_INFO
+    static void
+win_redr_ruler(wp, always)
+    win_T	*wp;
+    int		always;
+{
+    char_u	buffer[70];
+    int		row;
+    int		fillchar;
+    int		attr;
+    int		empty_line = FALSE;
+    colnr_T	virtcol;
+    int		i;
+    int		o;
+#ifdef FEAT_VERTSPLIT
+    int		this_ru_col;
+    int		off = 0;
+    int		width = Columns;
+# define WITH_OFF(x) x
+# define WITH_WIDTH(x) x
+#else
+# define WITH_OFF(x) 0
+# define WITH_WIDTH(x) Columns
+# define this_ru_col ru_col
+#endif
+
+    /* If 'ruler' off or redrawing disabled, 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;
+
+#ifdef FEAT_INS_EXPAND
+    /* Don't draw the ruler while doing insert-completion, it might overwrite
+     * the (long) mode message. */
+# ifdef FEAT_WINDOWS
+    if (wp == lastwin && lastwin->w_status_height == 0)
+# endif
+	if (edit_submode != NULL)
+	    return;
+#endif
+
+#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 & INSERT)
+		&& *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
+#ifdef FEAT_VIRTUALEDIT
+	    || wp->w_cursor.coladd != wp->w_ru_cursor.coladd
+#endif
+	    || 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();
+#ifdef FEAT_WINDOWS
+	if (wp->w_status_height)
+	{
+	    row = W_WINROW(wp) + wp->w_height;
+	    fillchar = fillchar_status(&attr, wp == curwin);
+# ifdef FEAT_VERTSPLIT
+	    off = W_WINCOL(wp);
+	    width = W_WIDTH(wp);
+# endif
+	}
+	else
+#endif
+	{
+	    row = Rows - 1;
+	    fillchar = ' ';
+	    attr = 0;
+#ifdef FEAT_VERTSPLIT
+	    width = Columns;
+	    off = 0;
+#endif
+	}
+
+	/* In list mode virtcol needs to be recomputed */
+	virtcol = wp->w_virtcol;
+	if (wp->w_p_list && lcs_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.
+	 */
+	sprintf((char *)buffer, "%ld,",
+		(wp->w_buffer->b_ml.ml_flags & ML_EMPTY)
+		    ? 0L
+		    : (long)(wp->w_cursor.lnum));
+	col_print(buffer + STRLEN(buffer),
+			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);
+	o = i + vim_strsize(buffer + i + 1);
+#ifdef FEAT_WINDOWS
+	if (wp->w_status_height == 0)	/* can't use last char of screen */
+#endif
+	    ++o;
+#ifdef FEAT_VERTSPLIT
+	this_ru_col = ru_col - (Columns - width);
+	if (this_ru_col < 0)
+	    this_ru_col = 0;
+#endif
+	/* Never use more than half the window/screen width, leave the other
+	 * half for the filename. */
+	if (this_ru_col < (WITH_WIDTH(width) + 1) / 2)
+	    this_ru_col = (WITH_WIDTH(width) + 1) / 2;
+	if (this_ru_col + o < WITH_WIDTH(width))
+	{
+	    while (this_ru_col + o < WITH_WIDTH(width))
+	    {
+#ifdef FEAT_MBYTE
+		if (has_mbyte)
+		    i += (*mb_char2bytes)(fillchar, buffer + i);
+		else
+#endif
+		    buffer[i++] = fillchar;
+		++o;
+	    }
+	    get_rel_pos(wp, buffer + i);
+	}
+	/* Truncate at window boundary. */
+#ifdef FEAT_MBYTE
+	if (has_mbyte)
+	{
+	    o = 0;
+	    for (i = 0; buffer[i] != NUL; i += (*mb_ptr2len_check)(buffer + i))
+	    {
+		o += (*mb_ptr2cells)(buffer + i);
+		if (this_ru_col + o > WITH_WIDTH(width))
+		{
+		    buffer[i] = NUL;
+		    break;
+		}
+	    }
+	}
+	else
+#endif
+	if (this_ru_col + (int)STRLEN(buffer) > WITH_WIDTH(width))
+	    buffer[WITH_WIDTH(width) - this_ru_col] = NUL;
+
+	screen_puts(buffer, row, this_ru_col + WITH_OFF(off), attr);
+	i = redraw_cmdline;
+	screen_fill(row, row + 1,
+		this_ru_col + WITH_OFF(off) + (int)STRLEN(buffer),
+		(int)(WITH_OFF(off) + WITH_WIDTH(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
+    }
+}
+#endif