1 files changed, 148 insertions, 49 deletions

diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index aa3a7ae7ed..5bf5a471c1 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -232,7 +232,7 @@ void screen_invalidate_highlights(void)
 {
   FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
     redraw_later(wp, NOT_VALID);
-    wp->w_grid.valid = false;
+    wp->w_grid_alloc.valid = false;
   }
 }
 
@@ -582,11 +582,18 @@ int update_screen(int type)
 
 
   FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
-    if (wp->w_redr_type == CLEAR && wp->w_floating && wp->w_grid.chars) {
-      grid_invalidate(&wp->w_grid);
+    if (wp->w_redr_type == CLEAR && wp->w_floating && wp->w_grid_alloc.chars) {
+      grid_invalidate(&wp->w_grid_alloc);
       wp->w_redr_type = NOT_VALID;
     }
 
+    // reallocate grid if needed.
+    win_grid_alloc(wp);
+
+    if (wp->w_redr_border || wp->w_redr_type >= NOT_VALID) {
+      win_redr_border(wp);
+    }
+
     if (wp->w_redr_type != 0) {
       if (!did_one) {
         did_one = TRUE;
@@ -774,8 +781,6 @@ static void win_update(win_T *wp, Providers *providers)
 
   type = wp->w_redr_type;
 
-  win_grid_alloc(wp);
-
   if (type >= NOT_VALID) {
     wp->w_redr_status = true;
     wp->w_lines_valid = 0;
@@ -2077,6 +2082,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
   int change_start = MAXCOL;            // first col of changed area
   int change_end = -1;                  // last col of changed area
   colnr_T trailcol = MAXCOL;            // start of trailing spaces
+  colnr_T leadcol = 0;                  // start of leading spaces
   bool need_showbreak = false;          // overlong line, skip first x chars
   int line_attr = 0;                    // attribute for the whole line
   int line_attr_lowprio = 0;            // low-priority attribute for the line
@@ -2317,7 +2323,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
         getvcol(curwin, &pos, (colnr_T *)&tocol, NULL, NULL);
       }
       // do at least one character; happens when past end of line
-      if (fromcol == tocol) {
+      if (fromcol == tocol && search_match_endcol) {
         tocol = fromcol + 1;
       }
       area_highlighting = true;
@@ -2422,6 +2428,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
   if (wp->w_p_list && !has_fold) {
     if (wp->w_p_lcs_chars.space
         || wp->w_p_lcs_chars.trail
+        || wp->w_p_lcs_chars.lead
         || wp->w_p_lcs_chars.nbsp) {
       extra_check = true;
     }
@@ -2433,6 +2440,20 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
       }
       trailcol += (colnr_T) (ptr - line);
     }
+    // find end of leading whitespace
+    if (wp->w_p_lcs_chars.lead) {
+      leadcol = 0;
+      while (ascii_iswhite(ptr[leadcol])) {
+        leadcol++;
+      }
+      if (ptr[leadcol] == NUL) {
+        // in a line full of spaces all of them are treated as trailing
+        leadcol = (colnr_T)0;
+      } else {
+        // keep track of the first column not filled with spaces
+        leadcol += (colnr_T)(ptr - line) + 1;
+      }
+    }
   }
 
   /*
@@ -2753,7 +2774,8 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
               // :sign defined with "numhl" highlight.
               char_attr = sign_get_attr(num_sign, SIGN_NUMHL);
             } else if ((wp->w_p_cul || wp->w_p_rnu)
-                       && lnum == wp->w_cursor.lnum) {
+                       && lnum == wp->w_cursor.lnum
+                       && filler_todo == 0) {
               // When 'cursorline' is set highlight the line number of
               // the current line differently.
               // TODO(vim): Can we use CursorLine instead of CursorLineNr
@@ -3132,6 +3154,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
           mb_utf8 = false;
         }
       } else {
+        assert(p_extra != NULL);
         c = *p_extra;
         mb_c = c;
         // If the UTF-8 character is more than one byte:
@@ -3435,8 +3458,8 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
           // TODO: is passing p for start of the line OK?
           n_extra = win_lbr_chartabsize(wp, line, p, (colnr_T)vcol, NULL) - 1;
           if (c == TAB && n_extra + col > grid->Columns) {
-            n_extra = (int)wp->w_buffer->b_p_ts
-                      - vcol % (int)wp->w_buffer->b_p_ts - 1;
+            n_extra = tabstop_padding(vcol, wp->w_buffer->b_p_ts,
+                                      wp->w_buffer->b_p_vts_array) - 1;
           }
           c_extra = mb_off > 0 ? MB_FILLER_CHAR : ' ';
           c_final = NUL;
@@ -3456,6 +3479,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
                   || (mb_utf8 && (mb_c == 160 || mb_c == 0x202f)))
                  && curwin->w_p_lcs_chars.nbsp)
                 || (c == ' ' && curwin->w_p_lcs_chars.space
+                    && ptr - line >= leadcol
                     && ptr - line <= trailcol))) {
           c = (c == ' ') ? wp->w_p_lcs_chars.space : wp->w_p_lcs_chars.nbsp;
           n_attr = 1;
@@ -3471,8 +3495,10 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
           }
         }
 
-        if (trailcol != MAXCOL && ptr > line + trailcol && c == ' ') {
-          c = wp->w_p_lcs_chars.trail;
+        if ((trailcol != MAXCOL && ptr > line + trailcol && c == ' ')
+            || (leadcol != 0 && ptr < line + leadcol && c == ' ')) {
+          c = (ptr > line + trailcol) ? wp->w_p_lcs_chars.trail
+                                      : wp->w_p_lcs_chars.lead;
           n_attr = 1;
           extra_attr = win_hl_attr(wp, HLF_0);
           saved_attr2 = char_attr;  // save current attr
@@ -3502,8 +3528,9 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
             vcol_adjusted = vcol - MB_CHARLEN(p_sbr);
           }
           // tab amount depends on current column
-          tab_len = (int)wp->w_buffer->b_p_ts
-                    - vcol_adjusted % (int)wp->w_buffer->b_p_ts - 1;
+          tab_len = tabstop_padding(vcol_adjusted,
+                                    wp->w_buffer->b_p_ts,
+                                    wp->w_buffer->b_p_vts_array) - 1;
 
           if (!wp->w_p_lbr || !wp->w_p_list) {
             n_extra = tab_len;
@@ -3536,6 +3563,10 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
             xfree(p_extra_free);
             p_extra_free = p;
             for (i = 0; i < tab_len; i++) {
+              if (*p == NUL) {
+                tab_len = i;
+                break;
+              }
               int lcs = wp->w_p_lcs_chars.tab2;
 
               // if tab3 is given, need to change the char
@@ -3916,9 +3947,8 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow,
                                              .hl_id = hl_err }));
         do_virttext = true;
       } else if (has_decor) {
-        VirtText *vp = decor_redraw_virt_text(wp->w_buffer, &decor_state);
-        if (vp) {
-          virt_text = *vp;
+        virt_text = decor_redraw_virt_text(wp->w_buffer, &decor_state);
+        if (kv_size(virt_text)) {
           do_virttext = true;
         }
       }
@@ -4348,10 +4378,10 @@ void draw_virt_text(buf_T *buf, int *end_col, int max_col)
   DecorState *state = &decor_state;
   for (size_t i = 0; i < kv_size(state->active); i++) {
     HlRange *item = &kv_A(state->active, i);
-    if (item->start_row == state->row && item->virt_text
+    if (item->start_row == state->row && kv_size(item->virt_text)
         && item->virt_text_pos == kVTOverlay
         && item->virt_col >= 0) {
-        VirtText vt = *item->virt_text;
+        VirtText vt = item->virt_text;
         LineState s = LINE_STATE("");
         int virt_attr = 0;
         int col = item->virt_col;
@@ -4404,14 +4434,10 @@ void draw_virt_text(buf_T *buf, int *end_col, int max_col)
 /// screen positions.
 void screen_adjust_grid(ScreenGrid **grid, int *row_off, int *col_off)
 {
-  if (!(*grid)->chars && *grid != &default_grid) {
-      *row_off += (*grid)->row_offset;
-      *col_off += (*grid)->col_offset;
-    if (*grid == &msg_grid_adj && msg_grid.chars) {
-      *grid = &msg_grid;
-    } else {
-      *grid = &default_grid;
-    }
+  if ((*grid)->target) {
+    *row_off += (*grid)->row_offset;
+    *col_off += (*grid)->col_offset;
+    *grid = (*grid)->target;
   }
 }
 
@@ -5415,6 +5441,46 @@ theend:
   entered = FALSE;
 }
 
+static void win_redr_border(win_T *wp)
+{
+  wp->w_redr_border = false;
+  if (!(wp->w_floating && wp->w_float_config.border)) {
+    return;
+  }
+
+  ScreenGrid *grid = &wp->w_grid_alloc;
+
+  schar_T *chars = wp->w_float_config.border_chars;
+  int *attrs = wp->w_float_config.border_attr;
+
+  int endrow = grid->Rows-1, endcol = grid->Columns-1;
+
+  grid_puts_line_start(grid, 0);
+  grid_put_schar(grid, 0, 0, chars[0], attrs[0]);
+  for (int i = 1; i < endcol; i++) {
+    grid_put_schar(grid, 0, i, chars[1], attrs[1]);
+  }
+  grid_put_schar(grid, 0, endcol, chars[2], attrs[2]);
+  grid_puts_line_flush(false);
+
+  for (int i = 1; i < endrow; i++) {
+    grid_puts_line_start(grid, i);
+    grid_put_schar(grid, i, 0, chars[7], attrs[7]);
+    grid_puts_line_flush(false);
+    grid_puts_line_start(grid, i);
+    grid_put_schar(grid, i, endcol, chars[3], attrs[3]);
+    grid_puts_line_flush(false);
+  }
+
+  grid_puts_line_start(grid, endrow);
+  grid_put_schar(grid, endrow, 0, chars[6], attrs[6]);
+  for (int i = 1; i < endcol; i++) {
+    grid_put_schar(grid, endrow, i, chars[5], attrs[5]);
+  }
+  grid_put_schar(grid, endrow, endcol, chars[4], attrs[4]);
+  grid_puts_line_flush(false);
+}
+
 // Low-level functions to manipulate invidual character cells on the
 // screen grid.
 
@@ -5552,6 +5618,20 @@ void grid_puts_line_start(ScreenGrid *grid, int row)
   put_dirty_grid = grid;
 }
 
+void grid_put_schar(ScreenGrid *grid, int row, int col, char_u *schar, int attr)
+{
+  assert(put_dirty_row == row);
+  unsigned int off = grid->line_offset[row] + col;
+  if (grid->attrs[off] != attr || schar_cmp(grid->chars[off], schar)) {
+      schar_copy(grid->chars[off], schar);
+      grid->attrs[off] = attr;
+
+      put_dirty_first = MIN(put_dirty_first, col);
+      // TODO(bfredl): Y U NO DOUBLEWIDTH?
+      put_dirty_last = MAX(put_dirty_last, col+1);
+  }
+}
+
 /// like grid_puts(), but output "text[len]".  When "len" is -1 output up to
 /// a NUL.
 void grid_puts_len(ScreenGrid *grid, char_u *text, int textlen, int row,
@@ -6143,12 +6223,15 @@ void check_for_delay(int check_msg_scroll)
 void win_grid_alloc(win_T *wp)
 {
   ScreenGrid *grid = &wp->w_grid;
+  ScreenGrid *grid_allocated = &wp->w_grid_alloc;
 
   int rows = wp->w_height_inner;
   int cols = wp->w_width_inner;
+  int total_rows = wp->w_height_outer;
+  int total_cols = wp->w_width_outer;
 
   bool want_allocation = ui_has(kUIMultigrid) || wp->w_floating;
-  bool has_allocation = (grid->chars != NULL);
+  bool has_allocation = (grid_allocated->chars != NULL);
 
   if (grid->Rows != rows) {
     wp->w_lines_valid = 0;
@@ -6157,35 +6240,47 @@ void win_grid_alloc(win_T *wp)
   }
 
   int was_resized = false;
-  if ((has_allocation != want_allocation)
-      || grid->Rows != rows
-      || grid->Columns != cols) {
-    if (want_allocation) {
-      grid_alloc(grid, rows, cols, wp->w_grid.valid, false);
-      grid->valid = true;
-    } else {
-      // Single grid mode, all rendering will be redirected to default_grid.
-      // Only keep track of the size and offset of the window.
-      grid_free(grid);
-      grid->Rows = rows;
-      grid->Columns = cols;
-      grid->valid = false;
+  if (want_allocation && (!has_allocation
+                          || grid_allocated->Rows != total_rows
+                          || grid_allocated->Columns != total_cols)) {
+    grid_alloc(grid_allocated, total_rows, total_cols,
+               wp->w_grid_alloc.valid, false);
+    grid_allocated->valid = true;
+    if (wp->w_border_adj) {
+      wp->w_redr_border = true;
     }
     was_resized = true;
-  } else if (want_allocation && has_allocation && !wp->w_grid.valid) {
-    grid_invalidate(grid);
-    grid->valid = true;
+  } else if (!want_allocation && has_allocation) {
+    // Single grid mode, all rendering will be redirected to default_grid.
+    // Only keep track of the size and offset of the window.
+    grid_free(grid_allocated);
+    grid_allocated->valid = false;
+    was_resized = true;
+  } else if (want_allocation && has_allocation && !wp->w_grid_alloc.valid) {
+    grid_invalidate(grid_allocated);
+    grid_allocated->valid = true;
   }
 
-  grid->row_offset = wp->w_winrow;
-  grid->col_offset = wp->w_wincol;
+  grid->Rows = rows;
+  grid->Columns = cols;
+
+  if (want_allocation) {
+    grid->target = grid_allocated;
+    grid->row_offset = wp->w_border_adj;
+    grid->col_offset = wp->w_border_adj;
+  } else {
+    grid->target = &default_grid;
+    grid->row_offset = wp->w_winrow;
+    grid->col_offset = wp->w_wincol;
+  }
 
   // send grid resize event if:
   // - a grid was just resized
   // - screen_resize was called and all grid sizes must be sent
   // - the UI wants multigrid event (necessary)
   if ((send_grid_resize || was_resized) && want_allocation) {
-    ui_call_grid_resize(grid->handle, grid->Columns, grid->Rows);
+    ui_call_grid_resize(grid_allocated->handle,
+                        grid_allocated->Columns, grid_allocated->Rows);
   }
 }
 
@@ -6274,6 +6369,9 @@ retry:
   tab_page_click_defs = new_tab_page_click_defs;
   tab_page_click_defs_size = Columns;
 
+  default_grid.comp_height = Rows;
+  default_grid.comp_width = Columns;
+
   default_grid.row_offset = 0;
   default_grid.col_offset = 0;
   default_grid.handle = DEFAULT_GRID_HANDLE;
@@ -7512,8 +7610,9 @@ void win_new_shellsize(void)
   static long old_Columns = 0;
 
   if (old_Rows != Rows) {
-    // if 'window' uses the whole screen, keep it using that */
-    if (p_window == old_Rows - 1 || old_Rows == 0) {
+    // If 'window' uses the whole screen, keep it using that.
+    // Don't change it when set with "-w size" on the command line.
+    if (p_window == old_Rows - 1 || (old_Rows == 0 && p_window == 0)) {
       p_window = Rows - 1;
     }
     old_Rows = Rows;
@@ -7528,7 +7627,7 @@ void win_new_shellsize(void)
 win_T *get_win_by_grid_handle(handle_T handle)
 {
   FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
-    if (wp->w_grid.handle == handle) {
+    if (wp->w_grid_alloc.handle == handle) {
       return wp;
     }
   }