Merge pull request #18620 from bfredl/multibar

fix(ui): make winbar work with floats and multigrid

17 files changed, 290 insertions, 295 deletions

diff --git a/src/nvim/api/ui.c b/src/nvim/api/ui.c
index b4d20ed975..52f76f4650 100644
--- a/src/nvim/api/ui.c
+++ b/src/nvim/api/ui.c
@@ -349,7 +349,11 @@ void nvim_ui_try_resize_grid(uint64_t channel_id, Integer grid, Integer width, I
     return;
   }
 
-  ui_grid_resize((handle_T)grid, (int)width, (int)height, err);
+  if (grid == DEFAULT_GRID_HANDLE) {
+    nvim_ui_try_resize(channel_id, width, height, err);
+  } else {
+    ui_grid_resize((handle_T)grid, (int)width, (int)height, err);
+  }
 }
 
 /// Tells Nvim the number of elements displaying in the popumenu, to decide
diff --git a/src/nvim/api/vim.c b/src/nvim/api/vim.c
index 3c378e73e1..15992a98be 100644
--- a/src/nvim/api/vim.c
+++ b/src/nvim/api/vim.c
@@ -2140,8 +2140,8 @@ Array nvim__inspect_cell(Integer grid, Integer row, Integer col, Error *err)
     }
   }
 
-  if (row < 0 || row >= g->Rows
-      || col < 0 || col >= g->Columns) {
+  if (row < 0 || row >= g->rows
+      || col < 0 || col >= g->cols) {
     return ret;
   }
   size_t off = g->line_offset[(size_t)row] + (size_t)col;
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index aa77c03b48..d7e82729a9 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -1632,7 +1632,7 @@ void edit_putchar(int c, bool highlight)
     pc_col = 0;
     pc_status = PC_STATUS_UNSET;
     if (curwin->w_p_rl) {
-      pc_col += curwin->w_grid.Columns - 1 - curwin->w_wcol;
+      pc_col += curwin->w_grid.cols - 1 - curwin->w_wcol;
       const int fix_col = grid_fix_col(&curwin->w_grid, pc_col, pc_row);
 
       if (fix_col != pc_col) {
@@ -1759,7 +1759,7 @@ void display_dollar(colnr_T col)
   char_u *p = get_cursor_line_ptr();
   curwin->w_cursor.col -= utf_head_off(p, p + col);
   curs_columns(curwin, false);              // Recompute w_wrow and w_wcol
-  if (curwin->w_wcol < curwin->w_grid.Columns) {
+  if (curwin->w_wcol < curwin->w_grid.cols) {
     edit_putchar('$', false);
     dollar_vcol = curwin->w_virtcol;
   }
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index f9c6b6fbb2..641dcae55e 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -6865,8 +6865,8 @@ void screenchar_adjust_grid(ScreenGrid **grid, int *row, int *col)
   // have its own buffer, this should just read from it instead.
   msg_scroll_flush();
   if (msg_grid.chars && msg_grid.comp_index > 0 && *row >= msg_grid.comp_row
-      && *row < (msg_grid.Rows + msg_grid.comp_row)
-      && *col < msg_grid.Columns) {
+      && *row < (msg_grid.rows + msg_grid.comp_row)
+      && *col < msg_grid.cols) {
     *grid = &msg_grid;
     *row -= msg_grid.comp_row;
   }
diff --git a/src/nvim/eval/funcs.c b/src/nvim/eval/funcs.c
index ad133b5b5f..683b035f5b 100644
--- a/src/nvim/eval/funcs.c
+++ b/src/nvim/eval/funcs.c
@@ -8047,8 +8047,8 @@ static void f_screenattr(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   int row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
   int col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
-  if (row < 0 || row >= default_grid.Rows
-      || col < 0 || col >= default_grid.Columns) {
+  if (row < 0 || row >= default_grid.rows
+      || col < 0 || col >= default_grid.cols) {
     c = -1;
   } else {
     ScreenGrid *grid = &default_grid;
@@ -8065,8 +8065,8 @@ static void f_screenchar(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 
   int row = tv_get_number_chk(&argvars[0], NULL) - 1;
   int col = tv_get_number_chk(&argvars[1], NULL) - 1;
-  if (row < 0 || row >= default_grid.Rows
-      || col < 0 || col >= default_grid.Columns) {
+  if (row < 0 || row >= default_grid.rows
+      || col < 0 || col >= default_grid.cols) {
     c = -1;
   } else {
     ScreenGrid *grid = &default_grid;
@@ -8081,8 +8081,8 @@ static void f_screenchars(typval_T *argvars, typval_T *rettv, FunPtr fptr)
 {
   int row = tv_get_number_chk(&argvars[0], NULL) - 1;
   int col = tv_get_number_chk(&argvars[1], NULL) - 1;
-  if (row < 0 || row >= default_grid.Rows
-      || col < 0 || col >= default_grid.Columns) {
+  if (row < 0 || row >= default_grid.rows
+      || col < 0 || col >= default_grid.cols) {
     tv_list_alloc_ret(rettv, 0);
     return;
   }
@@ -8148,8 +8148,8 @@ static void f_screenstring(typval_T *argvars, typval_T *rettv, FunPtr fptr)
   rettv->v_type = VAR_STRING;
   int row = tv_get_number_chk(&argvars[0], NULL) - 1;
   int col = tv_get_number_chk(&argvars[1], NULL) - 1;
-  if (row < 0 || row >= default_grid.Rows
-      || col < 0 || col >= default_grid.Columns) {
+  if (row < 0 || row >= default_grid.rows
+      || col < 0 || col >= default_grid.cols) {
     return;
   }
   ScreenGrid *grid = &default_grid;
diff --git a/src/nvim/globals.h b/src/nvim/globals.h
index 3231ac011a..1819af7ee4 100644
--- a/src/nvim/globals.h
+++ b/src/nvim/globals.h
@@ -84,7 +84,7 @@ EXTERN struct nvim_stats_s {
 //                      0          not starting anymore
 
 // Number of Rows and Columns in the screen.
-// Note: Use default_grid.Rows and default_grid.Columns to access items in
+// Note: Use default_grid.rows and default_grid.cols to access items in
 // default_grid.chars[]. They may have different values when the screen
 // wasn't (re)allocated yet after setting Rows or Columns (e.g., when starting
 // up).
@@ -421,10 +421,6 @@ EXTERN vimmenu_T *root_menu INIT(= NULL);
 // overruling of menus that the user already defined.
 EXTERN int sys_menu INIT(= false);
 
-// While redrawing the screen this flag is set.  It means the screen size
-// ('lines' and 'rows') must not be changed.
-EXTERN int updating_screen INIT(= 0);
-
 // All windows are linked in a list. firstwin points to the first entry,
 // lastwin to the last entry (can be the same as firstwin) and curwin to the
 // currently active window.
diff --git a/src/nvim/grid.c b/src/nvim/grid.c
index 13429994de..fa5c193fe0 100644
--- a/src/nvim/grid.c
+++ b/src/nvim/grid.c
@@ -6,6 +6,7 @@
 #include "nvim/highlight.h"
 #include "nvim/ui.h"
 #include "nvim/vim.h"
+#include "nvim/screen.h"
 
 #ifdef INCLUDE_GENERATED_DECLARATIONS
 # include "grid.c.generated.h"
@@ -63,7 +64,7 @@ void grid_clear_line(ScreenGrid *grid, size_t off, int width, bool valid)
 
 void grid_invalidate(ScreenGrid *grid)
 {
-  (void)memset(grid->attrs, -1, sizeof(sattr_T) * (size_t)grid->Rows * (size_t)grid->Columns);
+  (void)memset(grid->attrs, -1, sizeof(sattr_T) * (size_t)grid->rows * (size_t)grid->cols);
 }
 
 bool grid_invalid_row(ScreenGrid *grid, int row)
@@ -92,7 +93,7 @@ bool grid_lefthalve(ScreenGrid *grid, int row, int col)
   grid_adjust(&grid, &row, &col);
 
   return grid_off2cells(grid, grid->line_offset[row] + (size_t)col,
-                        grid->line_offset[row] + (size_t)grid->Columns) > 1;
+                        grid->line_offset[row] + (size_t)grid->cols) > 1;
 }
 
 /// Correct a position on the screen, if it's the right half of a double-wide
@@ -128,7 +129,7 @@ void grid_getbytes(ScreenGrid *grid, int row, int col, char_u *bytes, int *attrp
   grid_adjust(&grid, &row, &col);
 
   // safety check
-  if (grid->chars != NULL && row < grid->Rows && col < grid->Columns) {
+  if (grid->chars != NULL && row < grid->rows && col < grid->cols) {
     off = grid->line_offset[row] + (size_t)col;
     *attrp = grid->attrs[off];
     schar_copy(bytes, grid->chars[off]);
@@ -202,8 +203,8 @@ void grid_puts_len(ScreenGrid *grid, char_u *text, int textlen, int row, int col
   // Safety check. The check for negative row and column is to fix issue
   // vim/vim#4102. TODO(neovim): find out why row/col could be negative.
   if (grid->chars == NULL
-      || row >= grid->Rows || row < 0
-      || col >= grid->Columns || col < 0) {
+      || row >= grid->rows || row < 0
+      || col >= grid->cols || col < 0) {
     return;
   }
 
@@ -225,8 +226,8 @@ void grid_puts_len(ScreenGrid *grid, char_u *text, int textlen, int row, int col
     put_dirty_last = MAX(put_dirty_last, 1);
   }
 
-  max_off = grid->line_offset[row] + (size_t)grid->Columns;
-  while (col < grid->Columns
+  max_off = grid->line_offset[row] + (size_t)grid->cols;
+  while (col < grid->cols
          && (len < 0 || (int)(ptr - text) < len)
          && *ptr != NUL) {
     c = *ptr;
@@ -259,7 +260,7 @@ void grid_puts_len(ScreenGrid *grid, char_u *text, int textlen, int row, int col
     } else {
       prev_c = u8c;
     }
-    if (col + mbyte_cells > grid->Columns) {
+    if (col + mbyte_cells > grid->cols) {
       // Only 1 cell left, but character requires 2 cells:
       // display a '>' in the last column to avoid wrapping. */
       c = '>';
@@ -338,7 +339,7 @@ void grid_puts_line_flush(bool set_cursor)
   if (put_dirty_first < put_dirty_last) {
     if (set_cursor) {
       ui_grid_cursor_goto(put_dirty_grid->handle, put_dirty_row,
-                          MIN(put_dirty_last, put_dirty_grid->Columns - 1));
+                          MIN(put_dirty_last, put_dirty_grid->cols - 1));
     }
     if (!put_dirty_grid->throttled) {
       ui_line(put_dirty_grid, put_dirty_row, put_dirty_first, put_dirty_last,
@@ -371,11 +372,11 @@ void grid_fill(ScreenGrid *grid, int start_row, int end_row, int start_col, int
   end_col += col_off;
 
   // safety check
-  if (end_row > grid->Rows) {
-    end_row = grid->Rows;
+  if (end_row > grid->rows) {
+    end_row = grid->rows;
   }
-  if (end_col > grid->Columns) {
-    end_col = grid->Columns;
+  if (end_col > grid->cols) {
+    end_col = grid->cols;
   }
 
   // nothing to do
@@ -391,7 +392,7 @@ void grid_fill(ScreenGrid *grid, int start_row, int end_row, int start_col, int
     if (start_col > 0 && grid_fix_col(grid, start_col, row) != start_col) {
       grid_puts_len(grid, (char_u *)" ", 1, row, start_col - 1, 0);
     }
-    if (end_col < grid->Columns
+    if (end_col < grid->cols
         && grid_fix_col(grid, end_col, row) != end_col) {
       grid_puts_len(grid, (char_u *)" ", 1, row, end_col, 0);
     }
@@ -443,7 +444,7 @@ void grid_fill(ScreenGrid *grid, int start_row, int end_row, int start_col, int
       }
     }
 
-    if (end_col == grid->Columns) {
+    if (end_col == grid->cols) {
       grid->line_wraps[row] = false;
     }
   }
@@ -491,17 +492,17 @@ void grid_put_linebuf(ScreenGrid *grid, int row, int coloff, int endcol, int cle
 
   // TODO(bfredl): check all callsites and eliminate
   // Check for illegal row and col, just in case
-  if (row >= grid->Rows) {
-    row = grid->Rows - 1;
+  if (row >= grid->rows) {
+    row = grid->rows - 1;
   }
-  if (endcol > grid->Columns) {
-    endcol = grid->Columns;
+  if (endcol > grid->cols) {
+    endcol = grid->cols;
   }
 
   grid_adjust(&grid, &row, &coloff);
 
   // Safety check. Avoids clang warnings down the call stack.
-  if (grid->chars == NULL || row >= grid->Rows || coloff >= grid->Columns) {
+  if (grid->chars == NULL || row >= grid->rows || coloff >= grid->cols) {
     DLOG("invalid state, skipped");
     return;
   }
@@ -509,7 +510,7 @@ void grid_put_linebuf(ScreenGrid *grid, int row, int coloff, int endcol, int cle
   size_t off_from = 0;
   size_t off_to = grid->line_offset[row] + (size_t)coloff;
   max_off_from = linebuf_size;
-  max_off_to = grid->line_offset[row] + (size_t)grid->Columns;
+  max_off_to = grid->line_offset[row] + (size_t)grid->cols;
 
   if (rlflag) {
     // Clear rest first, because it's left of the text.
@@ -617,7 +618,7 @@ void grid_put_linebuf(ScreenGrid *grid, int row, int coloff, int endcol, int cle
     }
   }
 
-  if (clear_width > 0 || wp->w_width != grid->Columns) {
+  if (clear_width > 0 || wp->w_width != grid->cols) {
     // If we cleared after the end of the line, it did not wrap.
     // For vsplit, line wrapping is not possible.
     grid->line_wraps[row] = false;
@@ -646,11 +647,11 @@ void grid_alloc(ScreenGrid *grid, int rows, int columns, bool copy, bool valid)
   new.line_offset = xmalloc((size_t)rows * sizeof(*new.line_offset));
   new.line_wraps = xmalloc((size_t)rows * sizeof(*new.line_wraps));
 
-  new.Rows = rows;
-  new.Columns = columns;
+  new.rows = rows;
+  new.cols = columns;
 
-  for (new_row = 0; new_row < new.Rows; new_row++) {
-    new.line_offset[new_row] = (size_t)new_row * (size_t)new.Columns;
+  for (new_row = 0; new_row < new.rows; new_row++) {
+    new.line_offset[new_row] = (size_t)new_row * (size_t)new.cols;
     new.line_wraps[new_row] = false;
 
     grid_clear_line(&new, new.line_offset[new_row], columns, valid);
@@ -660,8 +661,8 @@ void grid_alloc(ScreenGrid *grid, int rows, int columns, bool copy, bool valid)
       // 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 (new_row < grid->Rows && grid->chars != NULL) {
-        int len = MIN(grid->Columns, new.Columns);
+      if (new_row < grid->rows && grid->chars != NULL) {
+        int len = MIN(grid->cols, new.cols);
         memmove(new.chars + new.line_offset[new_row],
                 grid->chars + grid->line_offset[new_row],
                 (size_t)len * sizeof(schar_T));
@@ -705,3 +706,83 @@ void grid_free_all_mem(void)
   xfree(linebuf_char);
   xfree(linebuf_attr);
 }
+
+/// (Re)allocates a window grid if size changed while in ext_multigrid mode.
+/// Updates size, offsets and handle for the grid regardless.
+///
+/// If "doclear" is true, don't try to copy from the old grid rather clear the
+/// resized grid.
+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_allocated->chars != NULL);
+
+  if (grid->rows != rows) {
+    wp->w_lines_valid = 0;
+    xfree(wp->w_lines);
+    wp->w_lines = xcalloc((size_t)rows + 1, sizeof(wline_T));
+  }
+
+  int was_resized = false;
+  if (want_allocation && (!has_allocation
+                          || grid_allocated->rows != total_rows
+                          || grid_allocated->cols != total_cols)) {
+    grid_alloc(grid_allocated, total_rows, total_cols,
+               wp->w_grid_alloc.valid, false);
+    grid_allocated->valid = true;
+    if (wp->w_floating && wp->w_float_config.border) {
+      wp->w_redr_border = true;
+    }
+    was_resized = 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->rows = rows;
+  grid->cols = cols;
+
+  if (want_allocation) {
+    grid->target = grid_allocated;
+    grid->row_offset = wp->w_winrow_off;
+    grid->col_offset = wp->w_wincol_off;
+  } else {
+    grid->target = &default_grid;
+    grid->row_offset = wp->w_winrow + wp->w_winrow_off;
+    grid->col_offset = wp->w_wincol + wp->w_wincol_off;
+  }
+
+  // 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 ((resizing_screen || was_resized) && want_allocation) {
+    ui_call_grid_resize(grid_allocated->handle,
+                        grid_allocated->cols, grid_allocated->rows);
+  }
+}
+
+/// assign a handle to the grid. The grid need not be allocated.
+void grid_assign_handle(ScreenGrid *grid)
+{
+  static int last_grid_handle = DEFAULT_GRID_HANDLE;
+
+  // only assign a grid handle if not already
+  if (grid->handle == 0) {
+    grid->handle = ++last_grid_handle;
+  }
+}
diff --git a/src/nvim/grid_defs.h b/src/nvim/grid_defs.h
index 2516ea52a7..a97a1c2c39 100644
--- a/src/nvim/grid_defs.h
+++ b/src/nvim/grid_defs.h
@@ -58,8 +58,8 @@ struct ScreenGrid {
   int *dirty_col;
 
   // the size of the allocated grid.
-  int Rows;
-  int Columns;
+  int rows;
+  int cols;
 
   // The state of the grid is valid. Otherwise it needs to be redrawn.
   bool valid;
diff --git a/src/nvim/message.c b/src/nvim/message.c
index 9ab086f1ea..49549bcc26 100644
--- a/src/nvim/message.c
+++ b/src/nvim/message.c
@@ -162,7 +162,7 @@ void msg_grid_validate(void)
 {
   grid_assign_handle(&msg_grid);
   bool should_alloc = msg_use_grid();
-  if (should_alloc && (msg_grid.Rows != Rows || msg_grid.Columns != Columns
+  if (should_alloc && (msg_grid.rows != Rows || msg_grid.cols != Columns
                        || !msg_grid.chars)) {
     // TODO(bfredl): eventually should be set to "invalid". I e all callers
     // will use the grid including clear to EOS if necessary.
@@ -174,9 +174,9 @@ void msg_grid_validate(void)
 
     // Tricky: allow resize while pager is active
     int pos = msg_scrolled ? msg_grid_pos : Rows - p_ch;
-    ui_comp_put_grid(&msg_grid, pos, 0, msg_grid.Rows, msg_grid.Columns,
+    ui_comp_put_grid(&msg_grid, pos, 0, msg_grid.rows, msg_grid.cols,
                      false, true);
-    ui_call_grid_resize(msg_grid.handle, msg_grid.Columns, msg_grid.Rows);
+    ui_call_grid_resize(msg_grid.handle, msg_grid.cols, msg_grid.rows);
 
     msg_grid.throttled = false;  // don't throttle in 'cmdheight' area
     msg_scrolled_at_flush = msg_scrolled;
@@ -2320,10 +2320,10 @@ void msg_scroll_up(bool may_throttle)
     if (msg_grid_pos > 0) {
       msg_grid_set_pos(msg_grid_pos - 1, true);
     } else {
-      grid_del_lines(&msg_grid, 0, 1, msg_grid.Rows, 0, msg_grid.Columns);
+      grid_del_lines(&msg_grid, 0, 1, msg_grid.rows, 0, msg_grid.cols);
       memmove(msg_grid.dirty_col, msg_grid.dirty_col + 1,
-              (msg_grid.Rows - 1) * sizeof(*msg_grid.dirty_col));
-      msg_grid.dirty_col[msg_grid.Rows - 1] = 0;
+              (msg_grid.rows - 1) * sizeof(*msg_grid.dirty_col));
+      msg_grid.dirty_col[msg_grid.rows - 1] = 0;
     }
   } else {
     grid_del_lines(&msg_grid_adj, 0, 1, Rows, 0, Columns);
@@ -2356,7 +2356,7 @@ void msg_scroll_flush(void)
     msg_grid.throttled = false;
     int pos_delta = msg_grid_pos_at_flush - msg_grid_pos;
     assert(pos_delta >= 0);
-    int delta = MIN(msg_scrolled - msg_scrolled_at_flush, msg_grid.Rows);
+    int delta = MIN(msg_scrolled - msg_scrolled_at_flush, msg_grid.rows);
 
     if (pos_delta > 0) {
       ui_ext_msg_set_pos(msg_grid_pos, true);
@@ -2374,7 +2374,7 @@ void msg_scroll_flush(void)
     for (int i = MAX(Rows - MAX(delta, 1), 0); i < Rows; i++) {
       int row = i - msg_grid_pos;
       assert(row >= 0);
-      ui_line(&msg_grid, row, 0, msg_grid.dirty_col[row], msg_grid.Columns,
+      ui_line(&msg_grid, row, 0, msg_grid.dirty_col[row], msg_grid.cols,
               HL_ATTR(HLF_MSG), false);
       msg_grid.dirty_col[row] = 0;
     }
@@ -2400,9 +2400,9 @@ void msg_reset_scroll(void)
     clear_cmdline = true;
     if (msg_grid.chars) {
       // non-displayed part of msg_grid is considered invalid.
-      for (int i = 0; i < MIN(msg_scrollsize(), msg_grid.Rows); i++) {
+      for (int i = 0; i < MIN(msg_scrollsize(), msg_grid.rows); i++) {
         grid_clear_line(&msg_grid, msg_grid.line_offset[i],
-                        msg_grid.Columns, false);
+                        msg_grid.cols, false);
       }
     }
   } else {
diff --git a/src/nvim/mouse.c b/src/nvim/mouse.c
index ad17bfc8a9..fe21279ef7 100644
--- a/src/nvim/mouse.c
+++ b/src/nvim/mouse.c
@@ -525,8 +525,8 @@ static win_T *mouse_find_grid_win(int *gridp, int *rowp, int *colp)
     win_T *wp = get_win_by_grid_handle(*gridp);
     if (wp && wp->w_grid_alloc.chars
         && !(wp->w_floating && !wp->w_float_config.focusable)) {
-      *rowp = MIN(*rowp - wp->w_grid.row_offset, wp->w_grid.Rows - 1);
-      *colp = MIN(*colp - wp->w_grid.col_offset, wp->w_grid.Columns - 1);
+      *rowp = MIN(*rowp - wp->w_grid.row_offset, wp->w_grid.rows - 1);
+      *colp = MIN(*colp - wp->w_grid.col_offset, wp->w_grid.cols - 1);
       return wp;
     }
   } else if (*gridp == 0) {
@@ -797,8 +797,8 @@ int mouse_check_fold(void)
 
   wp = mouse_find_win(&click_grid, &click_row, &click_col);
   if (wp && multigrid) {
-    max_row = wp->w_grid_alloc.Rows;
-    max_col = wp->w_grid_alloc.Columns;
+    max_row = wp->w_grid_alloc.rows;
+    max_col = wp->w_grid_alloc.cols;
   }
 
   if (wp && mouse_row >= 0 && mouse_row < max_row
diff --git a/src/nvim/os/input.c b/src/nvim/os/input.c
index c99d2869da..ac21b32a3e 100644
--- a/src/nvim/os/input.c
+++ b/src/nvim/os/input.c
@@ -19,6 +19,7 @@
 #include "nvim/memory.h"
 #include "nvim/msgpack_rpc/channel.h"
 #include "nvim/os/input.h"
+#include "nvim/screen.h"
 #include "nvim/state.h"
 #include "nvim/ui.h"
 #include "nvim/vim.h"
@@ -178,15 +179,7 @@ void os_breakcheck(void)
     return;
   }
 
-  int save_us = updating_screen;
-  // We do not want screen_resize() to redraw here.
-  // TODO(bfredl): we are already special casing redraw events, is this
-  // hack still needed?
-  updating_screen++;
-
   loop_poll_events(&main_loop, 0);
-
-  updating_screen = save_us;
 }
 
 #define BREAKCHECK_SKIP 1000
diff --git a/src/nvim/popupmnu.c b/src/nvim/popupmnu.c
index c5c1d87919..9525a84e62 100644
--- a/src/nvim/popupmnu.c
+++ b/src/nvim/popupmnu.c
@@ -429,9 +429,9 @@ void pum_redraw(void)
   must_redraw_pum = false;
 
   if (!pum_grid.chars
-      || pum_grid.Rows != pum_height || pum_grid.Columns != grid_width) {
+      || pum_grid.rows != pum_height || pum_grid.cols != grid_width) {
     grid_alloc(&pum_grid, pum_height, grid_width, !invalid_grid, false);
-    ui_call_grid_resize(pum_grid.handle, pum_grid.Columns, pum_grid.Rows);
+    ui_call_grid_resize(pum_grid.handle, pum_grid.cols, pum_grid.rows);
   } else if (invalid_grid) {
     grid_invalidate(&pum_grid);
   }
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index b2490fb9c5..86dbf532a7 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -132,10 +132,6 @@
 
 static match_T search_hl;       // used for 'hlsearch' highlight matching
 
-StlClickDefinition *tab_page_click_defs = NULL;
-
-long tab_page_click_defs_size = 0;
-
 // for line_putchar. Contains the state that needs to be remembered from
 // putting one character to the next.
 typedef struct {
@@ -382,9 +378,9 @@ int update_screen(int type)
     int valid = MAX(Rows - msg_scrollsize(), 0);
     if (msg_grid.chars) {
       // non-displayed part of msg_grid is considered invalid.
-      for (int i = 0; i < MIN(msg_scrollsize(), msg_grid.Rows); i++) {
+      for (int i = 0; i < MIN(msg_scrollsize(), msg_grid.rows); i++) {
         grid_clear_line(&msg_grid, msg_grid.line_offset[i],
-                        msg_grid.Columns, false);
+                        msg_grid.cols, false);
       }
     }
     if (msg_use_msgsep()) {
@@ -607,8 +603,6 @@ int update_screen(int type)
     pum_redraw();
   }
 
-  send_grid_resize = false;
-
   /* Reset b_mod_set flags.  Going through all windows is probably faster
    * than going through all buffers (there could be many buffers). */
   FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
@@ -757,7 +751,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
   }
 
   // Window is zero-height: Only need to draw the separator
-  if (wp->w_grid.Rows == 0) {
+  if (wp->w_grid.rows == 0) {
     // draw the horizontal separator below this window
     draw_hsep_win(wp);
     draw_sep_connectors_win(wp);
@@ -766,7 +760,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
   }
 
   // Window is zero-width: Only need to draw the separator.
-  if (wp->w_grid.Columns == 0) {
+  if (wp->w_grid.cols == 0) {
     // draw the vertical separator right of this window
     draw_vsep_win(wp);
     draw_sep_connectors_win(wp);
@@ -965,7 +959,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
         j = 0;
         for (ln = wp->w_topline; ln < wp->w_lines[0].wl_lnum; ln++) {
           j++;
-          if (j >= wp->w_grid.Rows - 2) {
+          if (j >= wp->w_grid.rows - 2) {
             break;
           }
           (void)hasFoldingWin(wp, ln, NULL, &ln, true, NULL);
@@ -973,13 +967,13 @@ static void win_update(win_T *wp, DecorProviders *providers)
       } else {
         j = wp->w_lines[0].wl_lnum - wp->w_topline;
       }
-      if (j < wp->w_grid.Rows - 2) {               // not too far off
+      if (j < wp->w_grid.rows - 2) {               // not too far off
         i = plines_m_win(wp, wp->w_topline, wp->w_lines[0].wl_lnum - 1);
         // insert extra lines for previously invisible filler lines
         if (wp->w_lines[0].wl_lnum != wp->w_topline) {
           i += win_get_fill(wp, wp->w_lines[0].wl_lnum) - wp->w_old_topfill;
         }
-        if (i != 0 && i < wp->w_grid.Rows - 2) {  // less than a screen off
+        if (i != 0 && i < wp->w_grid.rows - 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.
@@ -992,8 +986,8 @@ static void win_update(win_T *wp, DecorProviders *providers)
 
             // Move the entries that were scrolled, disable
             // the entries for the lines to be redrawn.
-            if ((wp->w_lines_valid += j) > wp->w_grid.Rows) {
-              wp->w_lines_valid = wp->w_grid.Rows;
+            if ((wp->w_lines_valid += j) > wp->w_grid.rows) {
+              wp->w_lines_valid = wp->w_grid.rows;
             }
             for (idx = wp->w_lines_valid; idx - j >= 0; idx--) {
               wp->w_lines[idx] = wp->w_lines[idx - j];
@@ -1046,7 +1040,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
         row -= wp->w_topfill;
         if (row > 0) {
           win_scroll_lines(wp, 0, -row);
-          bot_start = wp->w_grid.Rows - row;
+          bot_start = wp->w_grid.rows - row;
         }
         if ((row == 0 || bot_start < 999) && wp->w_lines_valid != 0) {
           /*
@@ -1062,7 +1056,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
             /* 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_grid.Rows) {
+                + (int)wp->w_lines[j].wl_size > wp->w_grid.rows) {
               wp->w_lines_valid = idx + 1;
               break;
             }
@@ -1087,18 +1081,18 @@ static void win_update(win_T *wp, DecorProviders *providers)
 
     // When starting redraw in the first line, redraw all lines.
     if (mid_start == 0) {
-      mid_end = wp->w_grid.Rows;
+      mid_end = wp->w_grid.rows;
     }
   } else {
     // Not VALID or INVERTED: redraw all lines.
     mid_start = 0;
-    mid_end = wp->w_grid.Rows;
+    mid_end = wp->w_grid.rows;
   }
 
   if (type == SOME_VALID) {
     // SOME_VALID: redraw all lines.
     mid_start = 0;
-    mid_end = wp->w_grid.Rows;
+    mid_end = wp->w_grid.rows;
     type = NOT_VALID;
   }
 
@@ -1285,7 +1279,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
         }
       }
       srow += mid_start;
-      mid_end = wp->w_grid.Rows;
+      mid_end = wp->w_grid.rows;
       for (; idx < wp->w_lines_valid; idx++) {                  // find end
         if (wp->w_lines[idx].wl_valid
             && wp->w_lines[idx].wl_lnum >= to + 1) {
@@ -1338,7 +1332,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
   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_grid.Rows) {
+    if (row == wp->w_grid.rows) {
       didline = true;
       break;
     }
@@ -1443,7 +1437,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
               new_rows += plines_win(wp, l, true);
             }
             j++;
-            if (new_rows > wp->w_grid.Rows - row - 2) {
+            if (new_rows > wp->w_grid.rows - row - 2) {
               // it's getting too much, must redraw the rest
               new_rows = 9999;
               break;
@@ -1455,17 +1449,17 @@ static void win_update(win_T *wp, DecorProviders *providers)
              * 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_grid.Rows - 2) {
+            if (row - xtra_rows >= wp->w_grid.rows - 2) {
               mod_bot = MAXLNUM;
             } else {
               win_scroll_lines(wp, row, xtra_rows);
-              bot_start = wp->w_grid.Rows + xtra_rows;
+              bot_start = wp->w_grid.rows + 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_grid.Rows - 2) {
+            if (row + xtra_rows >= wp->w_grid.rows - 2) {
               mod_bot = MAXLNUM;
             } else {
               win_scroll_lines(wp, row + old_rows, xtra_rows);
@@ -1493,7 +1487,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
                 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_grid.Rows) {
+                    > wp->w_grid.rows) {
                   wp->w_lines_valid = j + 1;
                   break;
                 }
@@ -1507,8 +1501,8 @@ static void win_update(win_T *wp, DecorProviders *providers)
                            // move entries in w_lines[] downwards
               j -= i;
               wp->w_lines_valid += j;
-              if (wp->w_lines_valid > wp->w_grid.Rows) {
-                wp->w_lines_valid = wp->w_grid.Rows;
+              if (wp->w_lines_valid > wp->w_grid.rows) {
+                wp->w_lines_valid = wp->w_grid.rows;
               }
               for (i = wp->w_lines_valid; i - j >= idx; i--) {
                 wp->w_lines[i] = wp->w_lines[i - j];
@@ -1539,11 +1533,11 @@ static void win_update(win_T *wp, DecorProviders *providers)
           && wp->w_lines[idx].wl_lnum == lnum
           && lnum > wp->w_topline
           && !(dy_flags & (DY_LASTLINE | DY_TRUNCATE))
-          && srow + wp->w_lines[idx].wl_size > wp->w_grid.Rows
+          && srow + wp->w_lines[idx].wl_size > wp->w_grid.rows
           && win_get_fill(wp, lnum) == 0) {
         // This line is not going to fit.  Don't draw anything here,
         // will draw "@  " lines below.
-        row = wp->w_grid.Rows + 1;
+        row = wp->w_grid.rows + 1;
       } else {
         prepare_search_hl(wp, &search_hl, lnum);
         // Let the