Merge pull request #22666 from bfredl/unscreen

refactor(screen): screen.c delenda est
2025-10-08 10:56:31 +00:00 · 2023-03-14 14:00:56 +01:00
parent 4f7879dff0 d6ecead364
commit d1e0f7454b
37 changed files with 1069 additions and 1176 deletions
--- a/src/nvim/autocmd.c
+++ b/src/nvim/autocmd.c
@@ -48,7 +48,6 @@
 #include "nvim/profile.h"
 #include "nvim/regexp.h"
 #include "nvim/runtime.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/state.h"
 #include "nvim/strings.h"
--- a/src/nvim/buffer.c
+++ b/src/nvim/buffer.c
@@ -87,7 +87,6 @@
 #include "nvim/quickfix.h"
 #include "nvim/regexp.h"
 #include "nvim/runtime.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/sign.h"
 #include "nvim/spell.h"
--- a/src/nvim/change.c
+++ b/src/nvim/change.c
@@ -42,7 +42,6 @@
 #include "nvim/os/time.h"
 #include "nvim/plines.h"
 #include "nvim/pos.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/state.h"
 #include "nvim/strings.h"
--- a/src/nvim/charset.c
+++ b/src/nvim/charset.c
@@ -660,6 +660,17 @@ size_t transchar_hex(char *const buf, const int c)
  return i;
 }

+/// Mirror text "str" for right-left displaying.
+/// Only works for single-byte characters (e.g., numbers).
+void rl_mirror_ascii(char *str)
+{
+  for (char *p1 = str, *p2 = str + strlen(str) - 1; p1 < p2; p1++, p2--) {
+    char t = *p1;
+    *p1 = *p2;
+    *p2 = t;
+  }
+}
+
 /// Convert the lower 4 bits of byte "c" to its hex character
 ///
 /// Lower case letters are used to avoid the confusion of <F1> being 0xf1 or
--- a/src/nvim/digraph.c
+++ b/src/nvim/digraph.c
@@ -15,6 +15,7 @@
 #include "nvim/charset.h"
 #include "nvim/digraph.h"
 #include "nvim/drawscreen.h"
+#include "nvim/eval.h"
 #include "nvim/eval/typval.h"
 #include "nvim/eval/typval_defs.h"
 #include "nvim/ex_cmds_defs.h"
@@ -2180,3 +2181,42 @@ static void keymap_unload(void)
  curbuf->b_kmap_state &= ~KEYMAP_LOADED;
  status_redraw_curbuf();
 }
+
+/// Get the value to show for the language mappings, active 'keymap'.
+///
+/// @param fmt  format string containing one %s item
+/// @param buf  buffer for the result
+/// @param len  length of buffer
+bool get_keymap_str(win_T *wp, char *fmt, char *buf, int len)
+{
+  char *p;
+
+  if (wp->w_buffer->b_p_iminsert != B_IMODE_LMAP) {
+    return false;
+  }
+
+  buf_T *old_curbuf = curbuf;
+  win_T *old_curwin = curwin;
+  char *s;
+
+  curbuf = wp->w_buffer;
+  curwin = wp;
+  STRCPY(buf, "b:keymap_name");       // must be writable
+  emsg_skip++;
+  s = p = eval_to_string(buf, NULL, false);
+  emsg_skip--;
+  curbuf = old_curbuf;
+  curwin = old_curwin;
+  if (p == NULL || *p == NUL) {
+    if (wp->w_buffer->b_kmap_state & KEYMAP_LOADED) {
+      p = wp->w_buffer->b_p_keymap;
+    } else {
+      p = "lang";
+    }
+  }
+  if (vim_snprintf(buf, (size_t)len, fmt, p) > len - 1) {
+    buf[0] = NUL;
+  }
+  xfree(s);
+  return buf[0] != NUL;
+}
--- a/src/nvim/drawline.c
+++ b/src/nvim/drawline.c
@@ -21,6 +21,7 @@
 #include "nvim/decoration_provider.h"
 #include "nvim/diff.h"
 #include "nvim/drawline.h"
+#include "nvim/drawscreen.h"
 #include "nvim/eval.h"
 #include "nvim/extmark_defs.h"
 #include "nvim/fold.h"
@@ -40,7 +41,6 @@
 #include "nvim/plines.h"
 #include "nvim/pos.h"
 #include "nvim/quickfix.h"
-#include "nvim/screen.h"
 #include "nvim/sign.h"
 #include "nvim/spell.h"
 #include "nvim/state.h"
@@ -384,6 +384,70 @@ static void handle_foldcolumn(win_T *wp, winlinevars_T *wlv)
  }
 }

+/// Fills the foldcolumn at "p" for window "wp".
+/// Only to be called when 'foldcolumn' > 0.
+///
+/// @param[out] p  Char array to write into
+/// @param lnum    Absolute current line number
+/// @param closed  Whether it is in 'foldcolumn' mode
+///
+/// Assume monocell characters
+/// @return number of chars added to \param p
+size_t fill_foldcolumn(char *p, win_T *wp, foldinfo_T foldinfo, linenr_T lnum)
+{
+  int i = 0;
+  int level;
+  int first_level;
+  int fdc = compute_foldcolumn(wp, 0);    // available cell width
+  size_t char_counter = 0;
+  int symbol = 0;
+  int len = 0;
+  bool closed = foldinfo.fi_lines > 0;
+  // Init to all spaces.
+  memset(p, ' ', MAX_MCO * (size_t)fdc + 1);
+
+  level = foldinfo.fi_level;
+
+  // If the column is too narrow, we start at the lowest level that
+  // fits and use numbers to indicate the depth.
+  first_level = level - fdc - closed + 1;
+  if (first_level < 1) {
+    first_level = 1;
+  }
+
+  for (i = 0; i < MIN(fdc, level); i++) {
+    if (foldinfo.fi_lnum == lnum
+        && first_level + i >= foldinfo.fi_low_level) {
+      symbol = wp->w_p_fcs_chars.foldopen;
+    } else if (first_level == 1) {
+      symbol = wp->w_p_fcs_chars.foldsep;
+    } else if (first_level + i <= 9) {
+      symbol = '0' + first_level + i;
+    } else {
+      symbol = '>';
+    }
+
+    len = utf_char2bytes(symbol, &p[char_counter]);
+    char_counter += (size_t)len;
+    if (first_level + i >= level) {
+      i++;
+      break;
+    }
+  }
+
+  if (closed) {
+    if (symbol != 0) {
+      // rollback previous write
+      char_counter -= (size_t)len;
+      memset(&p[char_counter], ' ', (size_t)len);
+    }
+    len = utf_char2bytes(wp->w_p_fcs_chars.foldclosed, &p[char_counter]);
+    char_counter += (size_t)len;
+  }
+
+  return MAX(char_counter + (size_t)(fdc - i), (size_t)fdc);
+}
+
 /// Get information needed to display the sign in line "wlv->lnum" in window "wp".
 /// If "nrcol" is true, the sign is going to be displayed in the number column.
 /// Otherwise the sign is going to be displayed in the sign column.
@@ -469,6 +533,21 @@ static int get_sign_attrs(buf_T *buf, winlinevars_T *wlv, int *sign_num_attrp, i
  return num_signs;
 }

+/// Returns width of the signcolumn that should be used for the whole window
+///
+/// @param wp window we want signcolumn width from
+/// @return max width of signcolumn (cell unit)
+///
+/// @note Returns a constant for now but hopefully we can improve neovim so that
+///       the returned value width adapts to the maximum number of marks to draw
+///       for the window
+/// TODO(teto)
+int win_signcol_width(win_T *wp)
+{
+  // 2 is vim default value
+  return 2;
+}
+
 static inline void get_line_number_str(win_T *wp, linenr_T lnum, char *buf, size_t buf_len)
 {
  long num;
@@ -553,7 +632,7 @@ static void handle_lnum_col(win_T *wp, winlinevars_T *wlv, int num_signs, int si
          }
        }
        if (wp->w_p_rl) {                       // reverse line numbers
-          // like rl_mirror(), but keep the space at the end
+          // like rl_mirror_ascii(), but keep the space at the end
          char *p2 = skipwhite(wlv->extra);
          p2 = skiptowhite(p2) - 1;
          for (char *p1 = skipwhite(wlv->extra); p1 < p2; p1++, p2--) {
@@ -1799,7 +1878,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
        // Non-BMP character : display as ? or fullwidth ?.
        transchar_hex(wlv.extra, mb_c);
        if (wp->w_p_rl) {  // reverse
-          rl_mirror(wlv.extra);
+          rl_mirror_ascii(wlv.extra);
        }

        wlv.p_extra = wlv.extra;
@@ -2297,7 +2376,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool nochange,
            wlv.n_extra = byte2cells(c) - 1;
          }
          if ((dy_flags & DY_UHEX) && wp->w_p_rl) {
-            rl_mirror(wlv.p_extra);                 // reverse "<12>"
+            rl_mirror_ascii(wlv.p_extra);                 // reverse "<12>"
          }
          wlv.c_extra = NUL;
          wlv.c_final = NUL;
--- a/src/nvim/drawline.h
+++ b/src/nvim/drawline.h
@@ -8,7 +8,6 @@
 #include "nvim/decoration_provider.h"
 #include "nvim/fold.h"
 #include "nvim/macros.h"
-#include "nvim/screen.h"
 #include "nvim/types.h"

 // Maximum columns for terminal highlight attributes
--- a/src/nvim/drawscreen.c
+++ b/src/nvim/drawscreen.c
@@ -66,11 +66,14 @@
 #include "nvim/buffer.h"
 #include "nvim/charset.h"
 #include "nvim/cmdexpand.h"
+#include "nvim/cursor.h"
 #include "nvim/decoration.h"
 #include "nvim/decoration_provider.h"
 #include "nvim/diff.h"
+#include "nvim/digraph.h"
 #include "nvim/drawline.h"
 #include "nvim/drawscreen.h"
+#include "nvim/eval.h"
 #include "nvim/ex_getln.h"
 #include "nvim/extmark_defs.h"
 #include "nvim/fold.h"
@@ -91,7 +94,7 @@
 #include "nvim/pos.h"
 #include "nvim/profile.h"
 #include "nvim/regexp.h"
-#include "nvim/screen.h"
+#include "nvim/search.h"
 #include "nvim/state.h"
 #include "nvim/statusline.h"
 #include "nvim/syntax.h"
@@ -203,7 +206,7 @@ bool default_grid_alloc(void)

 void screenclear(void)
 {
-  check_for_delay(false);
+  msg_check_for_delay(false);

  if (starting == NO_SCREEN || default_grid.chars == NULL) {
    return;
@@ -375,6 +378,32 @@ void screen_resize(int width, int height)
  resizing_screen = false;
 }

+/// Check if the new Nvim application "screen" dimensions are valid.
+/// Correct it if it's too small or way too big.
+void check_screensize(void)
+{
+  // Limit Rows and Columns to avoid an overflow in Rows * Columns.
+  if (Rows < min_rows()) {
+    // need room for one window and command line
+    Rows = min_rows();
+  } else if (Rows > 1000) {
+    Rows = 1000;
+  }
+
+  if (Columns < MIN_COLUMNS) {
+    Columns = MIN_COLUMNS;
+  } else if (Columns > 10000) {
+    Columns = 10000;
+  }
+}
+
+/// Return true if redrawing should currently be done.
+bool redrawing(void)
+{
+  return !RedrawingDisabled
+         && !(p_lz && char_avail() && !KeyTyped && !do_redraw);
+}
+
 /// Redraw the parts of the screen that is marked for redraw.
 ///
 /// Most code shouldn't call this directly, rather use redraw_later() and
@@ -521,7 +550,7 @@ int update_screen(void)
  }

  if (clear_cmdline) {          // going to clear cmdline (done below)
-    check_for_delay(false);
+    msg_check_for_delay(false);
  }

  // Force redraw when width of 'number' or 'relativenumber' column
@@ -637,6 +666,30 @@ int update_screen(void)
  return OK;
 }

+/// Prepare for 'hlsearch' highlighting.
+void start_search_hl(void)
+{
+  if (!p_hls || no_hlsearch) {
+    return;
+  }
+
+  end_search_hl();  // just in case it wasn't called before
+  last_pat_prog(&screen_search_hl.rm);
+  // Set the time limit to 'redrawtime'.
+  screen_search_hl.tm = profile_setlimit(p_rdt);
+}
+
+/// Clean up for 'hlsearch' highlighting.
+void end_search_hl(void)
+{
+  if (screen_search_hl.rm.regprog == NULL) {
+    return;
+  }
+
+  vim_regfree(screen_search_hl.rm.regprog);
+  screen_search_hl.rm.regprog = NULL;
+}
+
 static void win_border_redr_title(win_T *wp, ScreenGrid *grid, int col)
 {
  VirtText title_chunks = wp->w_float_config.title_chunks;
@@ -725,6 +778,35 @@ static void win_redr_border(win_T *wp)
  }
 }

+/// Set cursor to its position in the current window.
+void setcursor(void)
+{
+  setcursor_mayforce(false);
+}
+
+/// Set cursor to its position in the current window.
+/// @param force  when true, also when not redrawing.
+void setcursor_mayforce(bool force)
+{
+  if (force || redrawing()) {
+    validate_cursor();
+
+    ScreenGrid *grid = &curwin->w_grid;
+    int row = curwin->w_wrow;
+    int col = curwin->w_wcol;
+    if (curwin->w_p_rl) {
+      // With 'rightleft' set and the cursor on a double-wide character,
+      // position it on the leftmost column.
+      col = curwin->w_width_inner - curwin->w_wcol
+            - ((utf_ptr2cells(get_cursor_pos_ptr()) == 2
+                && vim_isprintc(gchar_cursor())) ? 2 : 1);
+    }
+
+    grid_adjust(&grid, &row, &col);
+    ui_grid_cursor_goto(grid->handle, row, col);
+  }
+}
+
 /// Show current cursor info in ruler and various other places
 ///
 /// @param always  if false, only show ruler if position has changed.
@@ -771,6 +853,306 @@ void show_cursor_info_later(bool force)
  curwin->w_stl_state = state;
 }

+/// @return true when postponing displaying the mode message: when not redrawing
+/// or inside a mapping.
+bool skip_showmode(void)
+{
+  // Call char_avail() only when we are going to show something, because it
+  // takes a bit of time.  redrawing() may also call char_avail().
+  if (global_busy || msg_silent != 0 || !redrawing() || (char_avail() && !KeyTyped)) {
+    redraw_mode = true;  // show mode later
+    return true;
+  }
+  return false;
+}
+
+/// 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.
+/// If redraw_mode is true show or clear the mode.
+/// @return the length of the message (0 if no message).
+int showmode(void)
+{
+  int length = 0;
+
+  if (ui_has(kUIMessages) && clear_cmdline) {
+    msg_ext_clear(true);
+  }
+
+  // don't make non-flushed message part of the showmode
+  msg_ext_ui_flush();
+
+  msg_grid_validate();
+
+  int do_mode = ((p_smd && msg_silent == 0)
+                 && ((State & MODE_TERMINAL)
+                     || (State & MODE_INSERT)
+                     || restart_edit != NUL
+                     || VIsual_active));
+  if (do_mode || reg_recording != 0) {
+    int sub_attr;
+    if (skip_showmode()) {
+      return 0;  // show mode later
+    }
+
+    bool nwr_save = need_wait_return;
+
+    // wait a bit before overwriting an important message
+    msg_check_for_delay(false);
+
+    // if the cmdline is more than one line high, erase top lines
+    bool 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();
+    int attr = HL_ATTR(HLF_CM);                     // Highlight mode
+
+    // When the screen is too narrow to show the entire mode message,
+    // avoid scrolling and truncate instead.
+    msg_no_more = true;
+    int save_lines_left = lines_left;
+    lines_left = 0;
+
+    if (do_mode) {
+      msg_puts_attr("--", attr);
+      // CTRL-X in Insert mode
+      if (edit_submode != NULL && !shortmess(SHM_COMPLETIONMENU)) {
+        // These messages can get long, avoid a wrap in a narrow window.
+        // Prefer showing edit_submode_extra. With external messages there
+        // is no imposed limit.
+        if (ui_has(kUIMessages)) {
+          length = INT_MAX;
+        } else {
+          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((const char *)edit_submode_pre, attr);
+            }
+            msg_puts_attr((const char *)edit_submode, attr);
+          }
+          if (edit_submode_extra != NULL) {
+            msg_puts_attr(" ", attr);  // Add a space in between.
+            if ((int)edit_submode_highl < HLF_COUNT) {
+              sub_attr = win_hl_attr(curwin, (int)edit_submode_highl);
+            } else {
+              sub_attr = attr;
+            }
+            msg_puts_attr((const char *)edit_submode_extra, sub_attr);
+          }
+        }
+      } else {
+        if (State & MODE_TERMINAL) {
+          msg_puts_attr(_(" TERMINAL"), attr);
+        } else if (State & VREPLACE_FLAG) {
+          msg_puts_attr(_(" VREPLACE"), attr);
+        } else if (State & REPLACE_FLAG) {
+          msg_puts_attr(_(" REPLACE"), attr);
+        } else if (State & MODE_INSERT) {
+          if (p_ri) {
+            msg_puts_attr(_(" REVERSE"), attr);
+          }
+          msg_puts_attr(_(" INSERT"), attr);
+        } else if (restart_edit == 'I' || restart_edit == 'i'
+                   || restart_edit == 'a' || restart_edit == 'A') {
+          if (curbuf->terminal) {
+            msg_puts_attr(_(" (terminal)"), attr);
+          } else {
+            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);
+        }
+        if (State & MODE_LANGMAP) {
+          if (curwin->w_p_arab) {
+            msg_puts_attr(_(" Arabic"), attr);
+          } else if (get_keymap_str(curwin, " (%s)",
+                                    NameBuff, MAXPATHL)) {
+            msg_puts_attr(NameBuff, attr);
+          }
+        }
+        if ((State & MODE_INSERT) && p_paste) {
+          msg_puts_attr(_(" (paste)"), attr);
+        }
+
+        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);
+        }
+        msg_puts_attr(" --", attr);
+      }
+
+      need_clear = true;
+    }
+    if (reg_recording != 0
+        && edit_submode == NULL             // otherwise it gets too long
+        ) {
+      recording_mode(attr);
+      need_clear = true;
+    }
+
+    mode_displayed = true;
+    if (need_clear || clear_cmdline || redraw_mode) {
+      msg_clr_eos();
+    }
+    msg_didout = false;                 // overwrite this message
+    length = msg_col;
+    msg_col = 0;
+    msg_no_more = false;
+    lines_left = save_lines_left;
+    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();
+  } else if (redraw_mode) {
+    msg_pos_mode();
+    msg_clr_eos();
+  }
+
+  // NB: also handles clearing the showmode if it was empty or disabled
+  msg_ext_flush_showmode();
+
+  // In Visual mode the size of the selected area must be redrawn.
+  if (VIsual_active) {
+    clear_showcmd();
+  }
+
+  // If the last window has no status line and global statusline is disabled,
+  // the ruler is after the mode message and must be redrawn
+  win_T *last = curwin->w_floating ? curwin : lastwin_nofloating();
+  if (redrawing() && last->w_status_height == 0 && global_stl_height() == 0) {
+    win_redr_ruler(last);
+  }
+
+  redraw_cmdline = false;
+  redraw_mode = false;
+  clear_cmdline = false;
+
+  return length;
+}
+
+/// Position for a mode message.
+static void msg_pos_mode(void)
+{
+  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!).
+/// Caller should check "mode_displayed".
+void unshowmode(bool force)
+{
+  // Don't delete it right now, when not redrawing or inside a mapping.
+  if (!redrawing() || (!force && char_avail() && !KeyTyped)) {
+    redraw_cmdline = true;  // delete mode later
+  } else {
+    clearmode();
+  }
+}
+
+// Clear the mode message.
+void clearmode(void)
+{
+  const int save_msg_row = msg_row;
+  const int save_msg_col = msg_col;
+
+  msg_ext_ui_flush();
+  msg_pos_mode();
+  if (reg_recording != 0) {
+    recording_mode(HL_ATTR(HLF_CM));
+  }
+  msg_clr_eos();
+  msg_ext_flush_showmode();
+
+  msg_col = save_msg_col;
+  msg_row = save_msg_row;
+}
+
+static void recording_mode(int attr)
+{
+  msg_puts_attr(_("recording"), attr);
+  if (shortmess(SHM_RECORDING)) {
+    return;
+  }
+
+  char s[4];
+  snprintf(s, ARRAY_SIZE(s), " @%c", reg_recording);
+  msg_puts_attr(s, attr);
+}
+
+#define COL_RULER 17        // columns needed by standard ruler
+
+/// Compute columns for ruler and shown command. 'sc_col' is also used to
+/// decide what the maximum length of a message on the status line can be.
+/// If there is a status line for the last window, 'sc_col' is independent
+/// of 'ru_col'.
+void comp_col(void)
+{
+  int last_has_status = (p_ls > 1 || (p_ls == 1 && !ONE_WINDOW));
+
+  sc_col = 0;
+  ru_col = 0;
+  if (p_ru) {
+    ru_col = (ru_wid ? ru_wid : COL_RULER) + 1;
+    // no last status line, adjust sc_col
+    if (!last_has_status) {
+      sc_col = ru_col;
+    }
+  }
+  if (p_sc) {
+    sc_col += SHOWCMD_COLS;
+    if (!p_ru || last_has_status) {         // no need for separating space
+      sc_col++;
+    }
+  }
+  assert(sc_col >= 0
+         && INT_MIN + sc_col <= Columns);
+  sc_col = Columns - sc_col;
+  assert(ru_col >= 0
+         && INT_MIN + ru_col <= Columns);
+  ru_col = Columns - ru_col;
+  if (sc_col <= 0) {            // screen too narrow, will become a mess
+    sc_col = 1;
+  }
+  if (ru_col <= 0) {
+    ru_col = 1;
+  }
+  set_vim_var_nr(VV_ECHOSPACE, sc_col - 1);
+}
 static void redraw_win_signcol(win_T *wp)
 {
  // If we can compute a change in the automatic sizing of the sign column
@@ -862,8 +1244,8 @@ static void draw_vsep_win(win_T *wp)
  }

  // draw the vertical separator right of this window
-  int hl;
-  int c = fillchar_vsep(wp, &hl);
+  int hl = win_hl_attr(wp, HLF_C);
+  int c = wp->w_p_fcs_chars.vert;
  grid_fill(&default_grid, wp->w_winrow, W_ENDROW(wp),
            W_ENDCOL(wp), W_ENDCOL(wp) + 1, c, ' ', hl);
 }
@@ -876,8 +1258,8 @@ static void draw_hsep_win(win_T *wp)
  }

  // draw the horizontal separator below this window
-  int hl;
-  int c = fillchar_hsep(wp, &hl);
+  int hl = win_hl_attr(wp, HLF_C);
+  int c = wp->w_p_fcs_chars.horiz;
  grid_fill(&default_grid, W_ENDROW(wp), W_ENDROW(wp) + 1,
            wp->w_wincol, W_ENDCOL(wp), c, c, hl);
 }
@@ -2021,6 +2403,152 @@ static void win_update(win_T *wp, DecorProviders *providers)
  }
 }

+/// Scroll `line_count` lines at 'row' in window 'wp'.
+///
+/// Positive `line_count` means scrolling down, so that more space is available
+/// at 'row'. Negative `line_count` implies deleting lines at `row`.
+void win_scroll_lines(win_T *wp, int row, int line_count)
+{
+  if (!redrawing() || line_count == 0) {
+    return;
+  }
+
+  // No lines are being moved, just draw over the entire area
+  if (row + abs(line_count) >= wp->w_grid.rows) {
+    return;
+  }
+
+  if (line_count < 0) {
+    grid_del_lines(&wp->w_grid, row, -line_count,
+                   wp->w_grid.rows, 0, wp->w_grid.cols);
+  } else {
+    grid_ins_lines(&wp->w_grid, row, line_count,
+                   wp->w_grid.rows, 0, wp->w_grid.cols);
+  }
+}
+
+/// Call grid_fill() with columns adjusted for 'rightleft' if needed.
+/// Return the new offset.
+static int win_fill_end(win_T *wp, int c1, int c2, int off, int width, int row, int endrow,
+                        int attr)
+{
+  int nn = off + width;
+  const int endcol = wp->w_grid.cols;
+
+  if (nn > endcol) {
+    nn = endcol;
+  }
+
+  if (wp->w_p_rl) {
+    grid_fill(&wp->w_grid, row, endrow, endcol - nn, endcol - off, c1, c2, attr);
+  } else {
+    grid_fill(&wp->w_grid, row, endrow, off, nn, c1, c2, attr);
+  }
+
+  return nn;
+}
+
+/// Clear lines near the end of the window and mark the unused lines with "c1".
+/// Use "c2" as filler character.
+/// When "draw_margin" is true, then draw the sign/fold/number columns.
+void win_draw_end(win_T *wp, int c1, int c2, bool draw_margin, int row, int endrow, hlf_T hl)
+{
+  assert(hl >= 0 && hl < HLF_COUNT);
+  int n = 0;
+
+  if (draw_margin) {
+    // draw the fold column
+    int fdc = compute_foldcolumn(wp, 0);
+    if (fdc > 0) {
+      n = win_fill_end(wp, ' ', ' ', n, fdc, row, endrow,
+                       win_hl_attr(wp, HLF_FC));
+    }
+    // draw the sign column
+    int count = wp->w_scwidth;
+    if (count > 0) {
+      n = win_fill_end(wp, ' ', ' ', n, win_signcol_width(wp) * count, row,
+                       endrow, win_hl_attr(wp, HLF_SC));
+    }
+    // draw the number column
+    if ((wp->w_p_nu || wp->w_p_rnu) && vim_strchr(p_cpo, CPO_NUMCOL) == NULL) {
+      n = win_fill_end(wp, ' ', ' ', n, number_width(wp) + 1, row, endrow,
+                       win_hl_attr(wp, HLF_N));
+    }
+  }
+
+  int attr = hl_combine_attr(win_bg_attr(wp), win_hl_attr(wp, (int)hl));
+
+  const int endcol = wp->w_grid.cols;
+  if (wp->w_p_rl) {
+    grid_fill(&wp->w_grid, row, endrow, 0, endcol - 1 - n, c2, c2, attr);
+    grid_fill(&wp->w_grid, row, endrow, endcol - 1 - n, endcol - n, c1, c2, attr);
+  } else {
+    grid_fill(&wp->w_grid, row, endrow, n, endcol, c1, c2, attr);
+  }
+}
+
+/// Compute the width of the foldcolumn.  Based on 'foldcolumn' and how much
+/// space is available for window "wp", minus "col".
+int compute_foldcolumn(win_T *wp, int col)
+{
+  int fdc = win_fdccol_count(wp);
+  int wmw = wp == curwin && p_wmw == 0 ? 1 : (int)p_wmw;
+  int wwidth = wp->w_grid.cols;
+
+  if (fdc > wwidth - (col + wmw)) {
+    fdc = wwidth - (col + wmw);
+  }
+  return fdc;
+}
+
+/// Return the width of the 'number' and 'relativenumber' column.
+/// Caller may need to check if 'number' or 'relativenumber' is set.
+/// Otherwise it depends on 'numberwidth' and the line count.
+int number_width(win_T *wp)
+{
+  linenr_T lnum;
+
+  if (wp->w_p_rnu && !wp->w_p_nu) {
+    // cursor line shows "0"
+    lnum = wp->w_height_inner;
+  } else {
+    // cursor line shows absolute line number
+    lnum = wp->w_buffer->b_ml.ml_line_count;
+  }
+
+  if (lnum == wp->w_nrwidth_line_count) {
+    return wp->w_nrwidth_width;
+  }
+  wp->w_nrwidth_line_count = lnum;
+
+  // reset for 'statuscolumn'
+  if (*wp->w_p_stc != NUL) {
+    wp->w_nrwidth_width = (wp->w_p_nu || wp->w_p_rnu) * (int)wp->w_p_nuw;
+    return wp->w_nrwidth_width;
+  }
+
+  int n = 0;
+  do {
+    lnum /= 10;
+    n++;
+  } while (lnum > 0);
+
+  // 'numberwidth' gives the minimal width plus one
+  if (n < wp->w_p_nuw - 1) {
+    n = (int)wp->w_p_nuw - 1;
+  }
+
+  // If 'signcolumn' is set to 'number' and there is a sign to display, then
+  // the minimal width for the number column is 2.
+  if (n < 2 && (wp->w_buffer->b_signlist != NULL)
+      && (*wp->w_p_scl == 'n' && *(wp->w_p_scl + 1) == 'u')) {
+    n = 2;
+  }
+
+  wp->w_nrwidth_width = n;
+  return n;
+}
+
 /// Redraw a window later, with wp->w_redr_type >= type.
 ///
 /// Set must_redraw only if not already set to a higher value.
@@ -2209,3 +2737,48 @@ void redrawWinline(win_T *wp, linenr_T lnum)
    redraw_later(wp, UPD_VALID);
  }
 }
+
+/// Return true if the cursor line in window "wp" may be concealed, according
+/// to the 'concealcursor' option.
+bool conceal_cursor_line(const win_T *wp)
+  FUNC_ATTR_NONNULL_ALL
+{
+  int c;
+
+  if (*wp->w_p_cocu == NUL) {
+    return false;
+  }
+  if (get_real_state() & MODE_VISUAL) {
+    c = 'v';
+  } else if (State & MODE_INSERT) {
+    c = 'i';
+  } else if (State & MODE_NORMAL) {
+    c = 'n';
+  } else if (State & MODE_CMDLINE) {
+    c = 'c';
+  } else {
+    return false;
+  }
+  return vim_strchr(wp->w_p_cocu, c) != NULL;
+}
+
+/// Whether cursorline is drawn in a special way
+///
+/// If true, both old and new cursorline will need to be redrawn when moving cursor within windows.
+bool win_cursorline_standout(const win_T *wp)
+  FUNC_ATTR_NONNULL_ALL
+{
+  return wp->w_p_cul || (wp->w_p_cole > 0 && !conceal_cursor_line(wp));
+}
+
+/// Redraw when w_cline_row changes and 'relativenumber' or 'cursorline' is set.
+/// Also when concealing is on and 'concealcursor' is not active.
+void redraw_for_cursorline(win_T *wp)
+  FUNC_ATTR_NONNULL_ALL
+{
+  if ((wp->w_valid & VALID_CROW) == 0 && !pum_visible()
+      && (wp->w_p_rnu || win_cursorline_standout(wp))) {
+    // win_line() will redraw the number column and cursorline only.
+    redraw_later(wp, UPD_VALID);
+  }
+}
--- a/src/nvim/drawscreen.h
+++ b/src/nvim/drawscreen.h
@@ -22,6 +22,11 @@ enum {
 /// ('lines' and 'rows') must not be changed.
 EXTERN bool updating_screen INIT(= 0);

+EXTERN match_T screen_search_hl INIT(= { 0 });       // used for 'hlsearch' highlight matching
+
+#define W_ENDCOL(wp)   ((wp)->w_wincol + (wp)->w_width)
+#define W_ENDROW(wp)   ((wp)->w_winrow + (wp)->w_height)
+
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "drawscreen.h.generated.h"
 #endif
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -52,7 +52,6 @@
 #include "nvim/plines.h"
 #include "nvim/popupmenu.h"
 #include "nvim/pos.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/state.h"
 #include "nvim/strings.h"
@@ -138,7 +137,7 @@ static void insert_enter(InsertState *s)
  did_restart_edit = restart_edit;
  // sleep before redrawing, needed for "CTRL-O :" that results in an
  // error message
-  check_for_delay(true);
+  msg_check_for_delay(true);
  // set Insstart_orig to Insstart
  update_Insstart_orig = true;

--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -77,7 +77,6 @@
 #include "nvim/profile.h"
 #include "nvim/quickfix.h"
 #include "nvim/regexp.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/spell.h"
 #include "nvim/strings.h"
@@ -2658,7 +2657,7 @@ int do_ecmd(int fnum, char *ffname, char *sfname, exarg_T *eap, linenr_T newlnum
      msg_scroll = false;
    }
    if (!msg_scroll) {          // wait a bit when overwriting an error msg
-      check_for_delay(false);
+      msg_check_for_delay(false);
    }
    msg_start();
    msg_scroll = msg_scroll_save;
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -72,7 +72,6 @@
 #include "nvim/quickfix.h"
 #include "nvim/regexp.h"
 #include "nvim/runtime.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/shada.h"
 #include "nvim/state.h"
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -63,7 +63,6 @@
 #include "nvim/pos.h"
 #include "nvim/profile.h"
 #include "nvim/regexp.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/state.h"
 #include "nvim/strings.h"
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -55,7 +55,6 @@
 #include "nvim/path.h"
 #include "nvim/pos.h"
 #include "nvim/regexp.h"
-#include "nvim/screen.h"
 #include "nvim/sha256.h"
 #include "nvim/shada.h"
 #include "nvim/strings.h"
@@ -157,7 +156,7 @@ void filemess(buf_T *buf, char *name, char *s, int attr)
    msg_scroll = false;
  }
  if (!msg_scroll) {    // wait a bit when overwriting an error msg
-    check_for_delay(false);
+    msg_check_for_delay(false);
  }
  msg_start();
  msg_scroll = msg_scroll_save;
--- a/src/nvim/getchar.c
+++ b/src/nvim/getchar.c
@@ -54,7 +54,6 @@
 #include "nvim/os/os.h"
 #include "nvim/plines.h"
 #include "nvim/pos.h"
-#include "nvim/screen.h"
 #include "nvim/state.h"
 #include "nvim/strings.h"
 #include "nvim/types.h"
--- a/src/nvim/indent.c
+++ b/src/nvim/indent.c
@@ -36,7 +36,6 @@
 #include "nvim/plines.h"
 #include "nvim/pos.h"
 #include "nvim/regexp.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/strings.h"
 #include "nvim/textformat.h"
--- a/src/nvim/insexpand.c
+++ b/src/nvim/insexpand.c
@@ -54,7 +54,6 @@
 #include "nvim/popupmenu.h"
 #include "nvim/pos.h"
 #include "nvim/regexp.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/spell.h"
 #include "nvim/state.h"
--- a/src/nvim/mbyte.c
+++ b/src/nvim/mbyte.c
@@ -60,10 +60,10 @@
 #include "nvim/memory.h"
 #include "nvim/message.h"
 #include "nvim/option_defs.h"
+#include "nvim/optionstr.h"
 #include "nvim/os/os.h"
 #include "nvim/os/os_defs.h"
 #include "nvim/pos.h"
-#include "nvim/screen.h"
 #include "nvim/strings.h"
 #include "nvim/types.h"
 #include "nvim/vim.h"
--- a/src/nvim/memline.c
+++ b/src/nvim/memline.c
@@ -79,8 +79,8 @@
 #include "nvim/os/time.h"
 #include "nvim/path.h"
 #include "nvim/pos.h"
-#include "nvim/screen.h"
 #include "nvim/spell.h"
+#include "nvim/statusline.h"
 #include "nvim/strings.h"
 #include "nvim/types.h"
 #include "nvim/ui.h"
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -49,7 +49,6 @@
 #include "nvim/pos.h"
 #include "nvim/regexp.h"
 #include "nvim/runtime.h"
-#include "nvim/screen.h"
 #include "nvim/strings.h"
 #include "nvim/ui.h"
 #include "nvim/ui_compositor.h"
@@ -1340,6 +1339,14 @@ void set_keep_msg(char *s, int attr)
  keep_msg_attr = attr;
 }

+/// Return true if printing messages should currently be done.
+bool messaging(void)
+{
+  // TODO(bfredl): with general support for "async" messages with p_ch,
+  // this should be re-enabled.
+  return !(p_lz && char_avail() && !KeyTyped) && (p_ch > 0 || ui_has(kUIMessages));
+}
+
 void msgmore(long n)
 {
  long pn;
@@ -3807,3 +3814,21 @@ int vim_dialog_yesnoallcancel(int type, char *title, char *message, int dflt)
  }
  return VIM_CANCEL;
 }
+
+/// Check if there should be a delay to allow the user to see a message.
+///
+/// Used before clearing or redrawing the screen or the command line.
+void msg_check_for_delay(bool check_msg_scroll)
+{
+  if ((emsg_on_display || (check_msg_scroll && msg_scroll))
+      && !did_wait_return
+      && emsg_silent == 0
+      && !in_assert_fails) {
+    ui_flush();
+    os_delay(1006L, true);
+    emsg_on_display = false;
+    if (check_msg_scroll) {
+      msg_scroll = false;
+    }
+  }
+}
--- a/src/nvim/mouse.c
+++ b/src/nvim/mouse.c
@@ -35,7 +35,6 @@
 #include "nvim/option.h"
 #include "nvim/plines.h"
 #include "nvim/pos.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/state.h"
 #include "nvim/statusline.h"
--- a/src/nvim/move.c
+++ b/src/nvim/move.c
@@ -41,7 +41,6 @@
 #include "nvim/plines.h"
 #include "nvim/popupmenu.h"
 #include "nvim/pos.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/strings.h"
 #include "nvim/types.h"
@@ -104,18 +103,6 @@ static void comp_botline(win_T *wp)
  win_check_anchored_floats(wp);
 }

-/// Redraw when w_cline_row changes and 'relativenumber' or 'cursorline' is set.
-/// Also when concealing is on and 'concealcursor' is not active.
-void redraw_for_cursorline(win_T *wp)
-  FUNC_ATTR_NONNULL_ALL
-{
-  if ((wp->w_valid & VALID_CROW) == 0 && !pum_visible()
-      && (wp->w_p_rnu || win_cursorline_standout(wp))) {
-    // win_line() will redraw the number column and cursorline only.
-    redraw_later(wp, UPD_VALID);
-  }
-}
-
 /// Redraw when w_virtcol changes and 'cursorcolumn' is set or 'cursorlineopt'
 /// contains "screenline" or when the "CurSearch" highlight is in use.
 /// Also when concealing is on and 'concealcursor' is active.
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -62,7 +62,6 @@
 #include "nvim/plines.h"
 #include "nvim/profile.h"
 #include "nvim/quickfix.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/spell.h"
 #include "nvim/spellfile.h"
--- a/src/nvim/ops.c
+++ b/src/nvim/ops.c
@@ -52,7 +52,6 @@
 #include "nvim/os/input.h"
 #include "nvim/os/time.h"
 #include "nvim/plines.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/state.h"
 #include "nvim/strings.h"
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -86,7 +86,6 @@
 #include "nvim/pos.h"
 #include "nvim/regexp.h"
 #include "nvim/runtime.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/sign_defs.h"
 #include "nvim/spell.h"
--- a/src/nvim/optionstr.c
+++ b/src/nvim/optionstr.c
@@ -45,7 +45,6 @@
 #include "nvim/pos.h"
 #include "nvim/quickfix.h"
 #include "nvim/runtime.h"
-#include "nvim/screen.h"
 #include "nvim/spell.h"
 #include "nvim/spellfile.h"
 #include "nvim/spellsuggest.h"
@@ -1960,3 +1959,285 @@ int check_ff_value(char *p)
 {
  return check_opt_strings(p, p_ff_values, false);
 }
+
+static char e_conflicts_with_value_of_listchars[] = N_("E834: Conflicts with value of 'listchars'");
+static char e_conflicts_with_value_of_fillchars[] = N_("E835: Conflicts with value of 'fillchars'");
+
+/// Calls mb_cptr2char_adv(p) and returns the character.
+/// If "p" starts with "\x", "\u" or "\U" the hex or unicode value is used.
+/// Returns 0 for invalid hex or invalid UTF-8 byte.
+static int get_encoded_char_adv(const char **p)
+{
+  const char *s = *p;
+
+  if (s[0] == '\\' && (s[1] == 'x' || s[1] == 'u' || s[1] == 'U')) {
+    int64_t num = 0;
+    for (int bytes = s[1] == 'x' ? 1 : s[1] == 'u' ? 2 : 4; bytes > 0; bytes--) {
+      *p += 2;
+      int n = hexhex2nr(*p);
+      if (n < 0) {
+        return 0;
+      }
+      num = num * 256 + n;
+    }
+    *p += 2;
+    return (int)num;
+  }
+
+  // TODO(bfredl): use schar_T representation and utfc_ptr2len
+  int clen = utf_ptr2len(s);
+  int c = mb_cptr2char_adv(p);
+  if (clen == 1 && c > 127) {  // Invalid UTF-8 byte
+    return 0;
+  }
+  return c;
+}
+
+/// Handle setting 'listchars' or 'fillchars'.
+/// Assume monocell characters
+///
+/// @param varp   either the global or the window-local value.
+/// @param apply  if false, do not store the flags, only check for errors.
+/// @return error message, NULL if it's OK.
+char *set_chars_option(win_T *wp, char **varp, bool apply)
+{
+  const char *last_multispace = NULL;   // Last occurrence of "multispace:"
+  const char *last_lmultispace = NULL;  // Last occurrence of "leadmultispace:"
+  int multispace_len = 0;           // Length of lcs-multispace string
+  int lead_multispace_len = 0;      // Length of lcs-leadmultispace string
+  const bool is_listchars = (varp == &p_lcs || varp == &wp->w_p_lcs);
+
+  struct chars_tab {
+    int *cp;     ///< char value
+    char *name;  ///< char id
+    int def;     ///< default value
+  };
+
+  // XXX: Characters taking 2 columns is forbidden (TUI limitation?). Set old defaults in this case.
+  struct chars_tab fcs_tab[] = {
+    { &wp->w_p_fcs_chars.stl,        "stl",       ' ' },
+    { &wp->w_p_fcs_chars.stlnc,      "stlnc",     ' ' },
+    { &wp->w_p_fcs_chars.wbr,        "wbr",       ' ' },
+    { &wp->w_p_fcs_chars.horiz,      "horiz",     char2cells(0x2500) == 1 ? 0x2500 : '-' },  // ─
+    { &wp->w_p_fcs_chars.horizup,    "horizup",   char2cells(0x2534) == 1 ? 0x2534 : '-' },  // ┴
+    { &wp->w_p_fcs_chars.horizdown,  "horizdown", char2cells(0x252c) == 1 ? 0x252c : '-' },  // ┬
+    { &wp->w_p_fcs_chars.vert,       "vert",      char2cells(0x2502) == 1 ? 0x2502 : '|' },  // │
+    { &wp->w_p_fcs_chars.vertleft,   "vertleft",  char2cells(0x2524) == 1 ? 0x2524 : '|' },  // ┤
+    { &wp->w_p_fcs_chars.vertright,  "vertright", char2cells(0x251c) == 1 ? 0x251c : '|' },  // ├
+    { &wp->w_p_fcs_chars.verthoriz,  "verthoriz", char2cells(0x253c) == 1 ? 0x253c : '+' },  // ┼
+    { &wp->w_p_fcs_chars.fold,       "fold",      char2cells(0x00b7) == 1 ? 0x00b7 : '-' },  // ·
+    { &wp->w_p_fcs_chars.foldopen,   "foldopen",  '-' },
+    { &wp->w_p_fcs_chars.foldclosed, "foldclose", '+' },
+    { &wp->w_p_fcs_chars.foldsep,    "foldsep",   char2cells(0x2502) == 1 ? 0x2502 : '|' },  // │
+    { &wp->w_p_fcs_chars.diff,       "diff",      '-' },
+    { &wp->w_p_fcs_chars.msgsep,     "msgsep",    ' ' },
+    { &wp->w_p_fcs_chars.eob,        "eob",       '~' },
+    { &wp->w_p_fcs_chars.lastline,   "lastline",  '@' },
+  };
+
+  struct chars_tab lcs_tab[] = {
+    { &wp->w_p_lcs_chars.eol,     "eol",      NUL },
+    { &wp->w_p_lcs_chars.ext,     "extends",  NUL },
+    { &wp->w_p_lcs_chars.nbsp,    "nbsp",     NUL },
+    { &wp->w_p_lcs_chars.prec,    "precedes", NUL },
+    { &wp->w_p_lcs_chars.space,   "space",    NUL },
+    { &wp->w_p_lcs_chars.tab2,    "tab",      NUL },
+    { &wp->w_p_lcs_chars.lead,    "lead",     NUL },
+    { &wp->w_p_lcs_chars.trail,   "trail",    NUL },
+    { &wp->w_p_lcs_chars.conceal, "conceal",  NUL },
+  };
+
+  struct chars_tab *tab;
+  int entries;
+  const char *value = *varp;
+  if (is_listchars) {
+    tab = lcs_tab;
+    entries = ARRAY_SIZE(lcs_tab);
+    if (varp == &wp->w_p_lcs && wp->w_p_lcs[0] == NUL) {
+      value = p_lcs;  // local value is empty, use the global value
+    }
+  } else {
+    tab = fcs_tab;
+    entries = ARRAY_SIZE(fcs_tab);
+    if (varp == &wp->w_p_fcs && wp->w_p_fcs[0] == NUL) {
+      value = p_fcs;  // local value is empty, use the global value
+    }
+  }
+
+  // first round: check for valid value, second round: assign values
+  for (int round = 0; round <= (apply ? 1 : 0); round++) {
+    if (round > 0) {
+      // After checking that the value is valid: set defaults
+      for (int i = 0; i < entries; i++) {
+        if (tab[i].cp != NULL) {
+          *(tab[i].cp) = tab[i].def;
+        }
+      }
+      if (is_listchars) {
+        wp->w_p_lcs_chars.tab1 = NUL;
+        wp->w_p_lcs_chars.tab3 = NUL;
+
+        xfree(wp->w_p_lcs_chars.multispace);
+        if (multispace_len > 0) {
+          wp->w_p_lcs_chars.multispace = xmalloc(((size_t)multispace_len + 1) * sizeof(int));
+          wp->w_p_lcs_chars.multispace[multispace_len] = NUL;
+        } else {
+          wp->w_p_lcs_chars.multispace = NULL;
+        }
+
+        xfree(wp->w_p_lcs_chars.leadmultispace);
+        if (lead_multispace_len > 0) {
+          wp->w_p_lcs_chars.leadmultispace
+            = xmalloc(((size_t)lead_multispace_len + 1) * sizeof(int));
+          wp->w_p_lcs_chars.leadmultispace[lead_multispace_len] = NUL;
+        } else {
+          wp->w_p_lcs_chars.leadmultispace = NULL;
+        }
+      }
+    }
+    const char *p = value;
+    while (*p) {
+      int i;
+      for (i = 0; i < entries; i++) {
+        const size_t len = strlen(tab[i].name);
+        if (strncmp(p, tab[i].name, len) == 0
+            && p[len] == ':'
+            && p[len + 1] != NUL) {
+          const char *s = p + len + 1;
+          int c1 = get_encoded_char_adv(&s);
+          if (c1 == 0 || char2cells(c1) > 1) {
+            return e_invarg;
+          }
+          int c2 = 0, c3 = 0;
+          if (tab[i].cp == &wp->w_p_lcs_chars.tab2) {
+            if (*s == NUL) {
+              return e_invarg;
+            }
+            c2 = get_encoded_char_adv(&s);
+            if (c2 == 0 || char2cells(c2) > 1) {
+              return e_invarg;
+            }
+            if (!(*s == ',' || *s == NUL)) {
+              c3 = get_encoded_char_adv(&s);
+              if (c3 == 0 || char2cells(c3) > 1) {
+                return e_invarg;
+              }
+            }
+          }
+          if (*s == ',' || *s == NUL) {
+            if (round > 0) {
+              if (tab[i].cp == &wp->w_p_lcs_chars.tab2) {
+                wp->w_p_lcs_chars.tab1 = c1;
+                wp->w_p_lcs_chars.tab2 = c2;
+                wp->w_p_lcs_chars.tab3 = c3;
+              } else if (tab[i].cp != NULL) {
+                *(tab[i].cp) = c1;
+              }
+            }
+            p = s;
+            break;
+          }
+        }
+      }
+
+      if (i == entries) {
+        const size_t len = strlen("multispace");
+        const size_t len2 = strlen("leadmultispace");
+        if (is_listchars
+            && strncmp(p, "multispace", len) == 0
+            && p[len] == ':'
+            && p[len + 1] != NUL) {
+          const char *s = p + len + 1;
+          if (round == 0) {
+            // Get length of lcs-multispace string in the first round
+            last_multispace = p;
+            multispace_len = 0;
+            while (*s != NUL && *s != ',') {
+              int c1 = get_encoded_char_adv(&s);
+              if (c1 == 0 || char2cells(c1) > 1) {
+                return e_invarg;
+              }
+              multispace_len++;
+            }
+            if (multispace_len == 0) {
+              // lcs-multispace cannot be an empty string
+              return e_invarg;
+            }
+            p = s;
+          } else {
+            int multispace_pos = 0;
+            while (*s != NUL && *s != ',') {
+              int c1 = get_encoded_char_adv(&s);
+              if (p == last_multispace) {
+                wp->w_p_lcs_chars.multispace[multispace_pos++] = c1;
+              }
+            }
+            p = s;
+          }
+        } else if (is_listchars
+                   && strncmp(p, "leadmultispace", len2) == 0
+                   && p[len2] == ':'
+                   && p[len2 + 1] != NUL) {
+          const char *s = p + len2 + 1;
+          if (round == 0) {
+            // get length of lcs-leadmultispace string in first round
+            last_lmultispace = p;
+            lead_multispace_len = 0;
+            while (*s != NUL && *s != ',') {
+              int c1 = get_encoded_char_adv(&s);
+              if (c1 == 0 || char2cells(c1) > 1) {
+                return e_invarg;
+              }
+              lead_multispace_len++;
+            }
+            if (lead_multispace_len == 0) {
+              // lcs-leadmultispace cannot be an empty string
+              return e_invarg;
+            }
+            p = s;
+          } else {
+            int multispace_pos = 0;
+            while (*s != NUL && *s != ',') {
+              int c1 = get_encoded_char_adv(&s);
+              if (p == last_lmultispace) {
+                wp->w_p_lcs_chars.leadmultispace[multispace_pos++] = c1;
+              }
+            }
+            p = s;
+          }
+        } else {
+          return e_invarg;
+        }
+      }
+
+      if (*p == ',') {
+        p++;
+      }
+    }
+  }
+
+  return NULL;          // no error
+}
+
+/// Check all global and local values of 'listchars' and 'fillchars'.
+/// May set different defaults in case character widths change.
+///
+/// @return  an untranslated error message if any of them is invalid, NULL otherwise.
+char *check_chars_options(void)
+{
+  if (set_chars_option(curwin, &p_lcs, false) != NULL) {
+    return e_conflicts_with_value_of_listchars;
+  }
+  if (set_chars_option(curwin, &p_fcs, false) != NULL) {
+    return e_conflicts_with_value_of_fillchars;
+  }
+  FOR_ALL_TAB_WINDOWS(tp, wp) {
+    if (set_chars_option(wp, &wp->w_p_lcs, true) != NULL) {
+      return e_conflicts_with_value_of_listchars;
+    }
+    if (set_chars_option(wp, &wp->w_p_fcs, true) != NULL) {
+      return e_conflicts_with_value_of_fillchars;
+    }
+  }
+  return NULL;
+}
--- a/src/nvim/popupmenu.c
+++ b/src/nvim/popupmenu.c
@@ -34,7 +34,6 @@
 #include "nvim/option.h"
 #include "nvim/popupmenu.h"
 #include "nvim/pos.h"
-#include "nvim/screen.h"
 #include "nvim/strings.h"
 #include "nvim/ui.h"
 #include "nvim/ui_compositor.h"
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
--- a/src/nvim/screen.h
+++ b/src/nvim/screen.h
@@ -1,19 +0,0 @@
-#ifndef NVIM_SCREEN_H
-#define NVIM_SCREEN_H
-
-#include <stdbool.h>
-
-#include "nvim/buffer_defs.h"
-#include "nvim/fold.h"
-#include "nvim/grid_defs.h"
-#include "nvim/macros.h"
-
-EXTERN match_T screen_search_hl;       // used for 'hlsearch' highlight matching
-
-#define W_ENDCOL(wp)   ((wp)->w_wincol + (wp)->w_width)
-#define W_ENDROW(wp)   ((wp)->w_winrow + (wp)->w_height)
-
-#ifdef INCLUDE_GENERATED_DECLARATIONS
-# include "screen.h.generated.h"
-#endif
-#endif  // NVIM_SCREEN_H
--- a/src/nvim/search.c
+++ b/src/nvim/search.c
@@ -49,7 +49,6 @@
 #include "nvim/path.h"
 #include "nvim/profile.h"
 #include "nvim/regexp.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/strings.h"
 #include "nvim/ui.h"
--- a/src/nvim/spellsuggest.c
+++ b/src/nvim/spellsuggest.c
@@ -39,7 +39,6 @@
 #include "nvim/os/os_defs.h"
 #include "nvim/pos.h"
 #include "nvim/profile.h"
-#include "nvim/screen.h"
 #include "nvim/spell.h"
 #include "nvim/spellfile.h"
 #include "nvim/spellsuggest.h"
@@ -569,7 +568,7 @@ void spell_suggest(int count)
      }
      vim_snprintf(IObuff, IOSIZE, "%2d", i + 1);
      if (cmdmsg_rl) {
-        rl_mirror(IObuff);
+        rl_mirror_ascii(IObuff);
      }
      msg_puts((const char *)IObuff);

@@ -595,7 +594,7 @@ void spell_suggest(int count)
        }
        if (cmdmsg_rl) {
          // Mirror the numbers, but keep the leading space.
-          rl_mirror(IObuff + 1);
+          rl_mirror_ascii(IObuff + 1);
        }
        msg_advance(30);
        msg_puts((const char *)IObuff);
--- a/src/nvim/state.c
+++ b/src/nvim/state.c
@@ -24,7 +24,6 @@
 #include "nvim/main.h"
 #include "nvim/option.h"
 #include "nvim/os/input.h"
-#include "nvim/screen.h"
 #include "nvim/state.h"
 #include "nvim/strings.h"
 #include "nvim/types.h"
--- a/src/nvim/statusline.c
+++ b/src/nvim/statusline.c
@@ -15,6 +15,7 @@
 #include "nvim/buffer.h"
 #include "nvim/buffer_defs.h"
 #include "nvim/charset.h"
+#include "nvim/digraph.h"
 #include "nvim/drawscreen.h"
 #include "nvim/eval.h"
 #include "nvim/eval/typval_defs.h"
@@ -36,7 +37,6 @@
 #include "nvim/os/os.h"
 #include "nvim/path.h"
 #include "nvim/pos.h"
-#include "nvim/screen.h"
 #include "nvim/sign.h"
 #include "nvim/statusline.h"
 #include "nvim/strings.h"
@@ -180,13 +180,46 @@ void win_redr_status(win_T *wp)
    if (stl_connected(wp)) {
      fillchar = fillchar_status(&attr, wp);
    } else {
-      fillchar = fillchar_vsep(wp, &attr);
+      attr = win_hl_attr(wp, HLF_C);
+      fillchar = wp->w_p_fcs_chars.vert;
    }
    grid_putchar(&default_grid, fillchar, W_ENDROW(wp), W_ENDCOL(wp), attr);
  }
  busy = false;
 }

+void get_trans_bufname(buf_T *buf)
+{
+  if (buf_spname(buf) != NULL) {
+    xstrlcpy(NameBuff, buf_spname(buf), MAXPATHL);
+  } else {
+    home_replace(buf, buf->b_fname, NameBuff, MAXPATHL, true);
+  }
+  trans_characters(NameBuff, MAXPATHL);
+}
+
+/// Only call if (wp->w_vsep_width != 0).
+///
+/// @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.
+bool stl_connected(win_T *wp)
+{
+  frame_T *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;
+}
+
 /// Clear status line, window bar or tab page line click definition table
 ///
 /// @param[out]  tpcd  Table to clear.
--- a/src/nvim/terminal.c
+++ b/src/nvim/terminal.c
@@ -82,7 +82,6 @@
 #include "nvim/option.h"
 #include "nvim/optionstr.h"
 #include "nvim/pos.h"
-#include "nvim/screen.h"
 #include "nvim/state.h"
 #include "nvim/terminal.h"
 #include "nvim/types.h"
--- a/src/nvim/textobject.c
+++ b/src/nvim/textobject.c
@@ -25,7 +25,6 @@
 #include "nvim/normal.h"
 #include "nvim/option_defs.h"
 #include "nvim/pos.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/strings.h"
 #include "nvim/textobject.h"
--- a/src/nvim/undo.c
+++ b/src/nvim/undo.c
@@ -118,7 +118,6 @@
 #include "nvim/os/time.h"
 #include "nvim/path.h"
 #include "nvim/pos.h"
-#include "nvim/screen.h"
 #include "nvim/sha256.h"
 #include "nvim/state.h"
 #include "nvim/strings.h"
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -66,7 +66,6 @@
 #include "nvim/plines.h"
 #include "nvim/pos.h"
 #include "nvim/quickfix.h"
-#include "nvim/screen.h"
 #include "nvim/search.h"
 #include "nvim/state.h"
 #include "nvim/statusline.h"