kevin/neovim
1
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2024-12-20 11:15:14 -07:00
Code Issues Packages Projects Releases Wiki Activity

refactor: grid->rows and grid->cols

Browse Source
This commit is contained in:
bfredl 2022-05-18 13:06:02 +02:00
parent d7dd600716
commit 028329850e
13 changed files with 186 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/nvim/api/vim.c
View File

@ -2140,8 +2140,8 @@ Array nvim__inspect_cell(Integer grid, Integer row, Integer col, Error *err)
} }
} }
if (row < 0 || row >= g->Rows if (row < 0 || row >= g->rows
|| col < 0 || col >= g->Columns) { || col < 0 || col >= g->cols) {
return ret; return ret;
} }
size_t off = g->line_offset[(size_t)row] + (size_t)col; size_t off = g->line_offset[(size_t)row] + (size_t)col;

4
src/nvim/edit.c
View File

@ -1632,7 +1632,7 @@ void edit_putchar(int c, bool highlight)
pc_col = 0; pc_col = 0;
pc_status = PC_STATUS_UNSET; pc_status = PC_STATUS_UNSET;
if (curwin->w_p_rl) { 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); const int fix_col = grid_fix_col(&curwin->w_grid, pc_col, pc_row);
if (fix_col != pc_col) { if (fix_col != pc_col) {
@ -1759,7 +1759,7 @@ void display_dollar(colnr_T col)
char_u *p = get_cursor_line_ptr(); char_u *p = get_cursor_line_ptr();
curwin->w_cursor.col -= utf_head_off(p, p + col); curwin->w_cursor.col -= utf_head_off(p, p + col);
curs_columns(curwin, false); // Recompute w_wrow and w_wcol 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); edit_putchar('$', false);
dollar_vcol = curwin->w_virtcol; dollar_vcol = curwin->w_virtcol;
} }

4
src/nvim/eval.c
View File

@ -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. // have its own buffer, this should just read from it instead.
msg_scroll_flush(); msg_scroll_flush();
if (msg_grid.chars && msg_grid.comp_index > 0 && *row >= msg_grid.comp_row if (msg_grid.chars && msg_grid.comp_index > 0 && *row >= msg_grid.comp_row
&& *row < (msg_grid.Rows + msg_grid.comp_row) && *row < (msg_grid.rows + msg_grid.comp_row)
&& *col < msg_grid.Columns) { && *col < msg_grid.cols) {
*grid = &msg_grid; *grid = &msg_grid;
*row -= msg_grid.comp_row; *row -= msg_grid.comp_row;
} }

16
src/nvim/eval/funcs.c
View File

@ -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 row = (int)tv_get_number_chk(&argvars[0], NULL) - 1;
int col = (int)tv_get_number_chk(&argvars[1], NULL) - 1; int col = (int)tv_get_number_chk(&argvars[1], NULL) - 1;
if (row < 0 || row >= default_grid.Rows if (row < 0 || row >= default_grid.rows
|| col < 0 || col >= default_grid.Columns) { || col < 0 || col >= default_grid.cols) {
c = -1; c = -1;
} else { } else {
ScreenGrid *grid = &default_grid; 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 row = tv_get_number_chk(&argvars[0], NULL) - 1;
int col = tv_get_number_chk(&argvars[1], NULL) - 1; int col = tv_get_number_chk(&argvars[1], NULL) - 1;
if (row < 0 || row >= default_grid.Rows if (row < 0 || row >= default_grid.rows
|| col < 0 || col >= default_grid.Columns) { || col < 0 || col >= default_grid.cols) {
c = -1; c = -1;
} else { } else {
ScreenGrid *grid = &default_grid; 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 row = tv_get_number_chk(&argvars[0], NULL) - 1;
int col = tv_get_number_chk(&argvars[1], NULL) - 1; int col = tv_get_number_chk(&argvars[1], NULL) - 1;
if (row < 0 || row >= default_grid.Rows if (row < 0 || row >= default_grid.rows
|| col < 0 || col >= default_grid.Columns) { || col < 0 || col >= default_grid.cols) {
tv_list_alloc_ret(rettv, 0); tv_list_alloc_ret(rettv, 0);
return; return;
} }
@ -8148,8 +8148,8 @@ static void f_screenstring(typval_T *argvars, typval_T *rettv, FunPtr fptr)
rettv->v_type = VAR_STRING; rettv->v_type = VAR_STRING;
int row = tv_get_number_chk(&argvars[0], NULL) - 1; int row = tv_get_number_chk(&argvars[0], NULL) - 1;
int col = tv_get_number_chk(&argvars[1], NULL) - 1; int col = tv_get_number_chk(&argvars[1], NULL) - 1;
if (row < 0 || row >= default_grid.Rows if (row < 0 || row >= default_grid.rows
|| col < 0 || col >= default_grid.Columns) { || col < 0 || col >= default_grid.cols) {
return; return;
} }
ScreenGrid *grid = &default_grid; ScreenGrid *grid = &default_grid;

2
src/nvim/globals.h
View File

@ -84,7 +84,7 @@ EXTERN struct nvim_stats_s {
// 0 not starting anymore // 0 not starting anymore
// Number of Rows and Columns in the screen. // 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 // 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 // wasn't (re)allocated yet after setting Rows or Columns (e.g., when starting
// up). // up).

56
src/nvim/grid.c
View File

@ -63,7 +63,7 @@ void grid_clear_line(ScreenGrid *grid, size_t off, int width, bool valid)
void grid_invalidate(ScreenGrid *grid) 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) bool grid_invalid_row(ScreenGrid *grid, int row)
@ -92,7 +92,7 @@ bool grid_lefthalve(ScreenGrid *grid, int row, int col)
grid_adjust(&grid, &row, &col); grid_adjust(&grid, &row, &col);
return grid_off2cells(grid, grid->line_offset[row] + (size_t)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 /// Correct a position on the screen, if it's the right half of a double-wide
@ -128,7 +128,7 @@ void grid_getbytes(ScreenGrid *grid, int row, int col, char_u *bytes, int *attrp
grid_adjust(&grid, &row, &col); grid_adjust(&grid, &row, &col);
// safety check // 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; off = grid->line_offset[row] + (size_t)col;
*attrp = grid->attrs[off]; *attrp = grid->attrs[off];
schar_copy(bytes, grid->chars[off]); schar_copy(bytes, grid->chars[off]);
@ -202,8 +202,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 // 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. // vim/vim#4102. TODO(neovim): find out why row/col could be negative.
if (grid->chars == NULL if (grid->chars == NULL
|| row >= grid->Rows || row < 0 || row >= grid->rows || row < 0
|| col >= grid->Columns || col < 0) { || col >= grid->cols || col < 0) {
return; return;
} }
@ -225,8 +225,8 @@ void grid_puts_len(ScreenGrid *grid, char_u *text, int textlen, int row, int col
put_dirty_last = MAX(put_dirty_last, 1); put_dirty_last = MAX(put_dirty_last, 1);
} }
max_off = grid->line_offset[row] + (size_t)grid->Columns; max_off = grid->line_offset[row] + (size_t)grid->cols;
while (col < grid->Columns while (col < grid->cols
&& (len < 0 || (int)(ptr - text) < len) && (len < 0 || (int)(ptr - text) < len)
&& *ptr != NUL) { && *ptr != NUL) {
c = *ptr; c = *ptr;
@ -259,7 +259,7 @@ void grid_puts_len(ScreenGrid *grid, char_u *text, int textlen, int row, int col
} else { } else {
prev_c = u8c; prev_c = u8c;
} }
if (col + mbyte_cells > grid->Columns) { if (col + mbyte_cells > grid->cols) {
// Only 1 cell left, but character requires 2 cells: // Only 1 cell left, but character requires 2 cells:
// display a '>' in the last column to avoid wrapping. */ // display a '>' in the last column to avoid wrapping. */
c = '>'; c = '>';
@ -338,7 +338,7 @@ void grid_puts_line_flush(bool set_cursor)
if (put_dirty_first < put_dirty_last) { if (put_dirty_first < put_dirty_last) {
if (set_cursor) { if (set_cursor) {
ui_grid_cursor_goto(put_dirty_grid->handle, put_dirty_row, 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) { if (!put_dirty_grid->throttled) {
ui_line(put_dirty_grid, put_dirty_row, put_dirty_first, put_dirty_last, ui_line(put_dirty_grid, put_dirty_row, put_dirty_first, put_dirty_last,
@ -371,11 +371,11 @@ void grid_fill(ScreenGrid *grid, int start_row, int end_row, int start_col, int
end_col += col_off; end_col += col_off;
// safety check // safety check
if (end_row > grid->Rows) { if (end_row > grid->rows) {
end_row = grid->Rows; end_row = grid->rows;
} }
if (end_col > grid->Columns) { if (end_col > grid->cols) {
end_col = grid->Columns; end_col = grid->cols;
} }
// nothing to do // nothing to do
@ -391,7 +391,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) { 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); 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_fix_col(grid, end_col, row) != end_col) {
grid_puts_len(grid, (char_u *)" ", 1, row, end_col, 0); grid_puts_len(grid, (char_u *)" ", 1, row, end_col, 0);
} }
@ -443,7 +443,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; grid->line_wraps[row] = false;
} }
} }
@ -491,17 +491,17 @@ void grid_put_linebuf(ScreenGrid *grid, int row, int coloff, int endcol, int cle
// TODO(bfredl): check all callsites and eliminate // TODO(bfredl): check all callsites and eliminate
// Check for illegal row and col, just in case // Check for illegal row and col, just in case
if (row >= grid->Rows) { if (row >= grid->rows) {
row = grid->Rows - 1; row = grid->rows - 1;
} }
if (endcol > grid->Columns) { if (endcol > grid->cols) {
endcol = grid->Columns; endcol = grid->cols;
} }
grid_adjust(&grid, &row, &coloff); grid_adjust(&grid, &row, &coloff);
// Safety check. Avoids clang warnings down the call stack. // 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"); DLOG("invalid state, skipped");
return; return;
} }
@ -509,7 +509,7 @@ void grid_put_linebuf(ScreenGrid *grid, int row, int coloff, int endcol, int cle
size_t off_from = 0; size_t off_from = 0;
size_t off_to = grid->line_offset[row] + (size_t)coloff; size_t off_to = grid->line_offset[row] + (size_t)coloff;
max_off_from = linebuf_size; 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) { if (rlflag) {
// Clear rest first, because it's left of the text. // Clear rest first, because it's left of the text.
@ -617,7 +617,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. // If we cleared after the end of the line, it did not wrap.
// For vsplit, line wrapping is not possible. // For vsplit, line wrapping is not possible.
grid->line_wraps[row] = false; grid->line_wraps[row] = false;
@ -646,11 +646,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_offset = xmalloc((size_t)rows * sizeof(*new.line_offset));
new.line_wraps = xmalloc((size_t)rows * sizeof(*new.line_wraps)); new.line_wraps = xmalloc((size_t)rows * sizeof(*new.line_wraps));
new.Rows = rows; new.rows = rows;
new.Columns = columns; new.cols = columns;
for (new_row = 0; new_row < new.Rows; new_row++) { for (new_row = 0; new_row < new.rows; new_row++) {
new.line_offset[new_row] = (size_t)new_row * (size_t)new.Columns; new.line_offset[new_row] = (size_t)new_row * (size_t)new.cols;
new.line_wraps[new_row] = false; new.line_wraps[new_row] = false;
grid_clear_line(&new, new.line_offset[new_row], columns, valid); grid_clear_line(&new, new.line_offset[new_row], columns, valid);
@ -660,8 +660,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 // possible from the old screen to the new one and clear the rest
// (used when resizing the window at the "--more--" prompt or when // (used when resizing the window at the "--more--" prompt or when
// executing an external command, for the GUI). // executing an external command, for the GUI).
if (new_row < grid->Rows && grid->chars != NULL) { if (new_row < grid->rows && grid->chars != NULL) {
int len = MIN(grid->Columns, new.Columns); int len = MIN(grid->cols, new.cols);
memmove(new.chars + new.line_offset[new_row], memmove(new.chars + new.line_offset[new_row],
grid->chars + grid->line_offset[new_row], grid->chars + grid->line_offset[new_row],
(size_t)len * sizeof(schar_T)); (size_t)len * sizeof(schar_T));

4
src/nvim/grid_defs.h
View File

@ -58,8 +58,8 @@ struct ScreenGrid {
int *dirty_col; int *dirty_col;
// the size of the allocated grid. // the size of the allocated grid.
int Rows; int rows;
int Columns; int cols;
// The state of the grid is valid. Otherwise it needs to be redrawn. // The state of the grid is valid. Otherwise it needs to be redrawn.
bool valid; bool valid;

20
src/nvim/message.c
View File

@ -162,7 +162,7 @@ void msg_grid_validate(void)
{ {
grid_assign_handle(&msg_grid); grid_assign_handle(&msg_grid);
bool should_alloc = msg_use_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)) { || !msg_grid.chars)) {
// TODO(bfredl): eventually should be set to "invalid". I e all callers // TODO(bfredl): eventually should be set to "invalid". I e all callers
// will use the grid including clear to EOS if necessary. // 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 // Tricky: allow resize while pager is active
int pos = msg_scrolled ? msg_grid_pos : Rows - p_ch; 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); 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_grid.throttled = false; // don't throttle in 'cmdheight' area
msg_scrolled_at_flush = msg_scrolled; msg_scrolled_at_flush = msg_scrolled;
@ -2320,10 +2320,10 @@ void msg_scroll_up(bool may_throttle)
if (msg_grid_pos > 0) { if (msg_grid_pos > 0) {
msg_grid_set_pos(msg_grid_pos - 1, true); msg_grid_set_pos(msg_grid_pos - 1, true);
} else { } 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, memmove(msg_grid.dirty_col, msg_grid.dirty_col + 1,
(msg_grid.Rows - 1) * sizeof(*msg_grid.dirty_col)); (msg_grid.rows - 1) * sizeof(*msg_grid.dirty_col));
msg_grid.dirty_col[msg_grid.Rows - 1] = 0; msg_grid.dirty_col[msg_grid.rows - 1] = 0;
} }
} else { } else {
grid_del_lines(&msg_grid_adj, 0, 1, Rows, 0, Columns); grid_del_lines(&msg_grid_adj, 0, 1, Rows, 0, Columns);
@ -2356,7 +2356,7 @@ void msg_scroll_flush(void)
msg_grid.throttled = false; msg_grid.throttled = false;
int pos_delta = msg_grid_pos_at_flush - msg_grid_pos; int pos_delta = msg_grid_pos_at_flush - msg_grid_pos;
assert(pos_delta >= 0); 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) { if (pos_delta > 0) {
ui_ext_msg_set_pos(msg_grid_pos, true); 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++) { for (int i = MAX(Rows - MAX(delta, 1), 0); i < Rows; i++) {
int row = i - msg_grid_pos; int row = i - msg_grid_pos;
assert(row >= 0); 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); HL_ATTR(HLF_MSG), false);
msg_grid.dirty_col[row] = 0; msg_grid.dirty_col[row] = 0;
} }
@ -2400,9 +2400,9 @@ void msg_reset_scroll(void)
clear_cmdline = true; clear_cmdline = true;
if (msg_grid.chars) { if (msg_grid.chars) {
// non-displayed part of msg_grid is considered invalid. // 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], grid_clear_line(&msg_grid, msg_grid.line_offset[i],
msg_grid.Columns, false); msg_grid.cols, false);
} }
} }
} else { } else {

8
src/nvim/mouse.c
View File

@ -522,8 +522,8 @@ static win_T *mouse_find_grid_win(int *gridp, int *rowp, int *colp)
win_T *wp = get_win_by_grid_handle(*gridp); win_T *wp = get_win_by_grid_handle(*gridp);
if (wp && wp->w_grid_alloc.chars if (wp && wp->w_grid_alloc.chars
&& !(wp->w_floating && !wp->w_float_config.focusable)) { && !(wp->w_floating && !wp->w_float_config.focusable)) {
*rowp = MIN(*rowp - wp->w_grid.row_offset, wp->w_grid.Rows - 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.Columns - 1); *colp = MIN(*colp - wp->w_grid.col_offset, wp->w_grid.cols - 1);
return wp; return wp;
} }
} else if (*gridp == 0) { } else if (*gridp == 0) {
@ -794,8 +794,8 @@ int mouse_check_fold(void)
wp = mouse_find_win(&click_grid, &click_row, &click_col); wp = mouse_find_win(&click_grid, &click_row, &click_col);
if (wp && multigrid) { if (wp && multigrid) {
max_row = wp->w_grid_alloc.Rows; max_row = wp->w_grid_alloc.rows;
max_col = wp->w_grid_alloc.Columns; max_col = wp->w_grid_alloc.cols;
} }
if (wp && mouse_row >= 0 && mouse_row < max_row if (wp && mouse_row >= 0 && mouse_row < max_row

4
src/nvim/popupmnu.c
View File

@ -429,9 +429,9 @@ void pum_redraw(void)
must_redraw_pum = false; must_redraw_pum = false;
if (!pum_grid.chars 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); 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) { } else if (invalid_grid) {
grid_invalidate(&pum_grid); grid_invalidate(&pum_grid);
} }

184
src/nvim/screen.c
View File

@ -382,9 +382,9 @@ int update_screen(int type)
int valid = MAX(Rows - msg_scrollsize(), 0); int valid = MAX(Rows - msg_scrollsize(), 0);
if (msg_grid.chars) { if (msg_grid.chars) {
// non-displayed part of msg_grid is considered invalid. // 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], grid_clear_line(&msg_grid, msg_grid.line_offset[i],
msg_grid.Columns, false); msg_grid.cols, false);
} }
} }
if (msg_use_msgsep()) { if (msg_use_msgsep()) {
@ -757,7 +757,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
} }
// Window is zero-height: Only need to draw the separator // 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 the horizontal separator below this window
draw_hsep_win(wp); draw_hsep_win(wp);
draw_sep_connectors_win(wp); draw_sep_connectors_win(wp);
@ -766,7 +766,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
} }
// Window is zero-width: Only need to draw the separator. // 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 the vertical separator right of this window
draw_vsep_win(wp); draw_vsep_win(wp);
draw_sep_connectors_win(wp); draw_sep_connectors_win(wp);
@ -965,7 +965,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
j = 0; j = 0;
for (ln = wp->w_topline; ln < wp->w_lines[0].wl_lnum; ln++) { for (ln = wp->w_topline; ln < wp->w_lines[0].wl_lnum; ln++) {
j++; j++;
if (j >= wp->w_grid.Rows - 2) { if (j >= wp->w_grid.rows - 2) {
break; break;
} }
(void)hasFoldingWin(wp, ln, NULL, &ln, true, NULL); (void)hasFoldingWin(wp, ln, NULL, &ln, true, NULL);
@ -973,13 +973,13 @@ static void win_update(win_T *wp, DecorProviders *providers)
} else { } else {
j = wp->w_lines[0].wl_lnum - wp->w_topline; 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); i = plines_m_win(wp, wp->w_topline, wp->w_lines[0].wl_lnum - 1);
// insert extra lines for previously invisible filler lines // insert extra lines for previously invisible filler lines
if (wp->w_lines[0].wl_lnum != wp->w_topline) { 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; 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. // Try to insert the correct number of lines.
// If not the last window, delete the lines at the bottom. // If not the last window, delete the lines at the bottom.
// win_ins_lines may fail when the terminal can't do it. // win_ins_lines may fail when the terminal can't do it.
@ -992,8 +992,8 @@ static void win_update(win_T *wp, DecorProviders *providers)
// Move the entries that were scrolled, disable // Move the entries that were scrolled, disable
// the entries for the lines to be redrawn. // the entries for the lines to be redrawn.
if ((wp->w_lines_valid += j) > wp->w_grid.Rows) { if ((wp->w_lines_valid += j) > wp->w_grid.rows) {
wp->w_lines_valid = wp->w_grid.Rows; wp->w_lines_valid = wp->w_grid.rows;
} }
for (idx = wp->w_lines_valid; idx - j >= 0; idx--) { for (idx = wp->w_lines_valid; idx - j >= 0; idx--) {
wp->w_lines[idx] = wp->w_lines[idx - j]; wp->w_lines[idx] = wp->w_lines[idx - j];
@ -1046,7 +1046,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
row -= wp->w_topfill; row -= wp->w_topfill;
if (row > 0) { if (row > 0) {
win_scroll_lines(wp, 0, -row); 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) { if ((row == 0 || bot_start < 999) && wp->w_lines_valid != 0) {
/* /*
@ -1062,7 +1062,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
/* stop at line that didn't fit, unless it is still /* stop at line that didn't fit, unless it is still
* valid (no lines deleted) */ * valid (no lines deleted) */
if (row > 0 && bot_start + row 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; wp->w_lines_valid = idx + 1;
break; break;
} }
@ -1087,18 +1087,18 @@ static void win_update(win_T *wp, DecorProviders *providers)
// When starting redraw in the first line, redraw all lines. // When starting redraw in the first line, redraw all lines.
if (mid_start == 0) { if (mid_start == 0) {
mid_end = wp->w_grid.Rows; mid_end = wp->w_grid.rows;
} }
} else { } else {
// Not VALID or INVERTED: redraw all lines. // Not VALID or INVERTED: redraw all lines.
mid_start = 0; mid_start = 0;
mid_end = wp->w_grid.Rows; mid_end = wp->w_grid.rows;
} }
if (type == SOME_VALID) { if (type == SOME_VALID) {
// SOME_VALID: redraw all lines. // SOME_VALID: redraw all lines.
mid_start = 0; mid_start = 0;
mid_end = wp->w_grid.Rows; mid_end = wp->w_grid.rows;
type = NOT_VALID; type = NOT_VALID;
} }
@ -1285,7 +1285,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
} }
} }
srow += mid_start; srow += mid_start;
mid_end = wp->w_grid.Rows; mid_end = wp->w_grid.rows;
for (; idx < wp->w_lines_valid; idx++) { // find end for (; idx < wp->w_lines_valid; idx++) { // find end
if (wp->w_lines[idx].wl_valid if (wp->w_lines[idx].wl_valid
&& wp->w_lines[idx].wl_lnum >= to + 1) { && wp->w_lines[idx].wl_lnum >= to + 1) {
@ -1338,7 +1338,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
for (;;) { for (;;) {
/* stop updating when reached the end of the window (check for _past_ /* stop updating when reached the end of the window (check for _past_
* the end of the window is at the end of the loop) */ * 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; didline = true;
break; break;
} }
@ -1443,7 +1443,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
new_rows += plines_win(wp, l, true); new_rows += plines_win(wp, l, true);
} }
j++; 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 // it's getting too much, must redraw the rest
new_rows = 9999; new_rows = 9999;
break; break;
@ -1455,17 +1455,17 @@ static void win_update(win_T *wp, DecorProviders *providers)
* remaining text or scrolling fails, must redraw the * remaining text or scrolling fails, must redraw the
* rest. If scrolling works, must redraw the text * rest. If scrolling works, must redraw the text
* below the scrolled 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; mod_bot = MAXLNUM;
} else { } else {
win_scroll_lines(wp, row, xtra_rows); 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) { } else if (xtra_rows > 0) {
/* May scroll text down. If there is not enough /* May scroll text down. If there is not enough
* remaining text of scrolling fails, must redraw the * remaining text of scrolling fails, must redraw the
* rest. */ * rest. */
if (row + xtra_rows >= wp->w_grid.Rows - 2) { if (row + xtra_rows >= wp->w_grid.rows - 2) {
mod_bot = MAXLNUM; mod_bot = MAXLNUM;
} else { } else {
win_scroll_lines(wp, row + old_rows, xtra_rows); win_scroll_lines(wp, row + old_rows, xtra_rows);
@ -1493,7 +1493,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
wp->w_lines[j] = wp->w_lines[i]; wp->w_lines[j] = wp->w_lines[i];
// stop at a line that won't fit // stop at a line that won't fit
if (x + (int)wp->w_lines[j].wl_size if (x + (int)wp->w_lines[j].wl_size
> wp->w_grid.Rows) { > wp->w_grid.rows) {
wp->w_lines_valid = j + 1; wp->w_lines_valid = j + 1;
break; break;
} }
@ -1507,8 +1507,8 @@ static void win_update(win_T *wp, DecorProviders *providers)
// move entries in w_lines[] downwards // move entries in w_lines[] downwards
j -= i; j -= i;
wp->w_lines_valid += j; wp->w_lines_valid += j;
if (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; wp->w_lines_valid = wp->w_grid.rows;
} }
for (i = wp->w_lines_valid; i - j >= idx; i--) { for (i = wp->w_lines_valid; i - j >= idx; i--) {
wp->w_lines[i] = wp->w_lines[i - j]; wp->w_lines[i] = wp->w_lines[i - j];
@ -1539,11 +1539,11 @@ static void win_update(win_T *wp, DecorProviders *providers)
&& wp->w_lines[idx].wl_lnum == lnum && wp->w_lines[idx].wl_lnum == lnum
&& lnum > wp->w_topline && lnum > wp->w_topline
&& !(dy_flags & (DY_LASTLINE | DY_TRUNCATE)) && !(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) { && win_get_fill(wp, lnum) == 0) {
// This line is not going to fit. Don't draw anything here, // This line is not going to fit. Don't draw anything here,
// will draw "@ " lines below. // will draw "@ " lines below.
row = wp->w_grid.Rows + 1; row = wp->w_grid.rows + 1;
} else { } else {
prepare_search_hl(wp, &search_hl, lnum); prepare_search_hl(wp, &search_hl, lnum);
// Let the syntax stuff know we skipped a few lines. // Let the syntax stuff know we skipped a few lines.
@ -1554,7 +1554,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
// Display one line // Display one line
row = win_line(wp, lnum, srow, row = win_line(wp, lnum, srow,
foldinfo.fi_lines ? srow : wp->w_grid.Rows, foldinfo.fi_lines ? srow : wp->w_grid.rows,
mod_top == 0, false, foldinfo, &line_providers); mod_top == 0, false, foldinfo, &line_providers);
if (foldinfo.fi_lines == 0) { if (foldinfo.fi_lines == 0) {
@ -1573,7 +1573,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
wp->w_lines[idx].wl_lnum = lnum; wp->w_lines[idx].wl_lnum = lnum;
wp->w_lines[idx].wl_valid = true; wp->w_lines[idx].wl_valid = true;
if (row > wp->w_grid.Rows) { // past end of grid if (row > wp->w_grid.rows) { // past end of grid
// we may need the size of that too long line later on // we may need the size of that too long line later on
if (dollar_vcol == -1) { if (dollar_vcol == -1) {
wp->w_lines[idx].wl_size = plines_win(wp, lnum, true); wp->w_lines[idx].wl_size = plines_win(wp, lnum, true);
@ -1591,13 +1591,13 @@ static void win_update(win_T *wp, DecorProviders *providers)
// 'relativenumber' set and cursor moved vertically: The // 'relativenumber' set and cursor moved vertically: The
// text doesn't need to be drawn, but the number column does. // text doesn't need to be drawn, but the number column does.
foldinfo_T info = fold_info(wp, lnum); foldinfo_T info = fold_info(wp, lnum);
(void)win_line(wp, lnum, srow, wp->w_grid.Rows, true, true, (void)win_line(wp, lnum, srow, wp->w_grid.rows, true, true,
info, &line_providers); info, &line_providers);
} }
// This line does not need to be drawn, advance to the next one. // This line does not need to be drawn, advance to the next one.
row += wp->w_lines[idx++].wl_size; row += wp->w_lines[idx++].wl_size;
if (row > wp->w_grid.Rows) { // past end of screen if (row > wp->w_grid.rows) { // past end of screen
break; break;
} }
lnum = wp->w_lines[idx - 1].wl_lastlnum + 1; lnum = wp->w_lines[idx - 1].wl_lastlnum + 1;
@ -1645,41 +1645,41 @@ static void win_update(win_T *wp, DecorProviders *providers)
* Don't overwrite it, it can be edited. * Don't overwrite it, it can be edited.
*/ */
wp->w_botline = lnum + 1; wp->w_botline = lnum + 1;
} else if (win_get_fill(wp, lnum) >= wp->w_grid.Rows - srow) { } else if (win_get_fill(wp, lnum) >= wp->w_grid.rows - srow) {
// Window ends in filler lines. // Window ends in filler lines.
wp->w_botline = lnum; wp->w_botline = lnum;
wp->w_filler_rows = wp->w_grid.Rows - srow; wp->w_filler_rows = wp->w_grid.rows - srow;
} else if (dy_flags & DY_TRUNCATE) { // 'display' has "truncate" } else if (dy_flags & DY_TRUNCATE) { // 'display' has "truncate"
int scr_row = wp->w_grid.Rows - 1; int scr_row = wp->w_grid.rows - 1;
// Last line isn't finished: Display "@@@" in the last screen line. // Last line isn't finished: Display "@@@" in the last screen line.
grid_puts_len(&wp->w_grid, (char_u *)"@@", MIN(wp->w_grid.Columns, 2), scr_row, 0, at_attr); grid_puts_len(&wp->w_grid, (char_u *)"@@", MIN(wp->w_grid.cols, 2), scr_row, 0, at_attr);
grid_fill(&wp->w_grid, scr_row, scr_row + 1, 2, wp->w_grid.Columns, grid_fill(&wp->w_grid, scr_row, scr_row + 1, 2, wp->w_grid.cols,
'@', ' ', at_attr); '@', ' ', at_attr);
set_empty_rows(wp, srow); set_empty_rows(wp, srow);
wp->w_botline = lnum; wp->w_botline = lnum;
} else if (dy_flags & DY_LASTLINE) { // 'display' has "lastline" } else if (dy_flags & DY_LASTLINE) { // 'display' has "lastline"
int start_col = wp->w_grid.Columns - 3; int start_col = wp->w_grid.cols - 3;
// Last line isn't finished: Display "@@@" at the end. // Last line isn't finished: Display "@@@" at the end.
grid_fill(&wp->w_grid, wp->w_grid.Rows - 1, wp->w_grid.Rows, grid_fill(&wp->w_grid, wp->w_grid.rows - 1, wp->w_grid.rows,
MAX(start_col, 0), wp->w_grid.Columns, '@', '@', at_attr); MAX(start_col, 0), wp->w_grid.cols, '@', '@', at_attr);
set_empty_rows(wp, srow); set_empty_rows(wp, srow);
wp->w_botline = lnum; wp->w_botline = lnum;
} else { } else {
win_draw_end(wp, '@', ' ', true, srow, wp->w_grid.Rows, HLF_AT); win_draw_end(wp, '@', ' ', true, srow, wp->w_grid.rows, HLF_AT);
wp->w_botline = lnum; wp->w_botline = lnum;
} }
} else { } else {
if (eof) { // we hit the end of the file if (eof) { // we hit the end of the file
wp->w_botline = buf->b_ml.ml_line_count + 1; wp->w_botline = buf->b_ml.ml_line_count + 1;
j = win_get_fill(wp, wp->w_botline); j = win_get_fill(wp, wp->w_botline);
if (j > 0 && !wp->w_botfill && row < wp->w_grid.Rows) { if (j > 0 && !wp->w_botfill && row < wp->w_grid.rows) {
// Display filler text below last line. win_line() will check // Display filler text below last line. win_line() will check
// for ml_line_count+1 and only draw filler lines // for ml_line_count+1 and only draw filler lines
foldinfo_T info = FOLDINFO_INIT; foldinfo_T info = FOLDINFO_INIT;
row = win_line(wp, wp->w_botline, row, wp->w_grid.Rows, row = win_line(wp, wp->w_botline, row, wp->w_grid.rows,
false, false, info, &line_providers); false, false, info, &line_providers);
} }
} else if (dollar_vcol == -1) { } else if (dollar_vcol == -1) {
@ -1688,7 +1688,7 @@ static void win_update(win_T *wp, DecorProviders *providers)
// make sure the rest of the screen is blank // make sure the rest of the screen is blank
// write the 'eob' character to rows that aren't part of the file. // write the 'eob' character to rows that aren't part of the file.
win_draw_end(wp, wp->w_p_fcs_chars.eob, ' ', false, row, wp->w_grid.Rows, win_draw_end(wp, wp->w_p_fcs_chars.eob, ' ', false, row, wp->w_grid.rows,
HLF_EOB); HLF_EOB);
} }
@ -1773,8 +1773,8 @@ static int win_fill_end(win_T *wp, int c1, int c2, int off, int width, int row,
{ {
int nn = off + width; int nn = off + width;
if (nn > wp->w_grid.Columns) { if (nn > wp->w_grid.cols) {
nn = wp->w_grid.Columns; nn = wp->w_grid.cols;
} }
if (wp->w_p_rl) { if (wp->w_p_rl) {
@ -1823,7 +1823,7 @@ static void win_draw_end(win_T *wp, int c1, int c2, bool draw_margin, int row, i
grid_fill(&wp->w_grid, row, endrow, W_ENDCOL(wp) - 1 - n, W_ENDCOL(wp) - n, grid_fill(&wp->w_grid, row, endrow, W_ENDCOL(wp) - 1 - n, W_ENDCOL(wp) - n,
c1, c2, attr); c1, c2, attr);
} else { } else {
grid_fill(&wp->w_grid, row, endrow, n, wp->w_grid.Columns, c1, c2, attr); grid_fill(&wp->w_grid, row, endrow, n, wp->w_grid.cols, c1, c2, attr);
} }
set_empty_rows(wp, row); set_empty_rows(wp, row);
@ -1847,7 +1847,7 @@ static int compute_foldcolumn(win_T *wp, int col)
{ {
int fdc = win_fdccol_count(wp); int fdc = win_fdccol_count(wp);
int wmw = wp == curwin && p_wmw == 0 ? 1 : p_wmw; int wmw = wp == curwin && p_wmw == 0 ? 1 : p_wmw;
int wwidth = wp->w_grid.Columns; int wwidth = wp->w_grid.cols;
if (fdc > wwidth - (col + wmw)) { if (fdc > wwidth - (col + wmw)) {
fdc = wwidth - (col + wmw); fdc = wwidth - (col + wmw);
@ -2631,7 +2631,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
// Rightleft window: process the text in the normal direction, but put // Rightleft window: process the text in the normal direction, but put
// it in linebuf_char[off] from right to left. Start at the // it in linebuf_char[off] from right to left. Start at the
// rightmost column of the window. // rightmost column of the window.
col = grid->Columns - 1; col = grid->cols - 1;
off += col; off += col;
} }
@ -2813,7 +2813,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
if (wp->w_p_rl) { if (wp->w_p_rl) {
n_extra = col + 1; n_extra = col + 1;
} else { } else {
n_extra = grid->Columns - col; n_extra = grid->cols - col;
} }
char_attr = 0; char_attr = 0;
} else if (filler_todo > 0) { } else if (filler_todo > 0) {
@ -2828,7 +2828,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
if (wp->w_p_rl) { if (wp->w_p_rl) {
n_extra = col + 1; n_extra = col + 1;
} else { } else {
n_extra = grid->Columns - col; n_extra = grid->cols - col;
} }
char_attr = win_hl_attr(wp, HLF_DED); char_attr = win_hl_attr(wp, HLF_DED);
} }
@ -2902,15 +2902,15 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
&& vcol >= (long)wp->w_virtcol) && vcol >= (long)wp->w_virtcol)
|| (number_only && draw_state > WL_NR)) || (number_only && draw_state > WL_NR))
&& filler_todo <= 0) { && filler_todo <= 0) {
draw_virt_text(wp, buf, win_col_offset, &col, grid->Columns, row); draw_virt_text(wp, buf, win_col_offset, &col, grid->cols, row);
grid_put_linebuf(grid, row, 0, col, -grid->Columns, wp->w_p_rl, wp, grid_put_linebuf(grid, row, 0, col, -grid->cols, wp->w_p_rl, wp,
wp->w_hl_attr_normal, false); wp->w_hl_attr_normal, false);
// Pretend we have finished updating the window. Except when // Pretend we have finished updating the window. Except when
// 'cursorcolumn' is set. // 'cursorcolumn' is set.
if (wp->w_p_cuc) { if (wp->w_p_cuc) {
row = wp->w_cline_row + wp->w_cline_height; row = wp->w_cline_row + wp->w_cline_height;
} else { } else {
row = grid->Rows; row = grid->rows;
} }
break; break;
} }
@ -2938,19 +2938,19 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
if (draw_state == WL_LINE if (draw_state == WL_LINE
&& has_fold && has_fold
&& col < grid->Columns && col < grid->cols
&& n_extra == 0 && n_extra == 0
&& row == startrow) { && row == startrow) {
// fill rest of line with 'fold' // fill rest of line with 'fold'
c_extra = wp->w_p_fcs_chars.fold; c_extra = wp->w_p_fcs_chars.fold;
c_final = NUL; c_final = NUL;
n_extra = wp->w_p_rl ? (col + 1) : (grid->Columns - col); n_extra = wp->w_p_rl ? (col + 1) : (grid->cols - col);
} }
if (draw_state == WL_LINE if (draw_state == WL_LINE
&& has_fold && has_fold
&& col >= grid->Columns && col >= grid->cols
&& n_extra != 0 && n_extra != 0
&& row == startrow) { && row == startrow) {
// Truncate the folding. // Truncate the folding.
@ -3079,7 +3079,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
} }
// If a double-width char doesn't fit display a '>' in the last column. // If a double-width char doesn't fit display a '>' in the last column.
if ((wp->w_p_rl ? (col <= 0) : (col >= grid->Columns - 1)) if ((wp->w_p_rl ? (col <= 0) : (col >= grid->cols - 1))
&& utf_char2cells(mb_c) == 2) { && utf_char2cells(mb_c) == 2) {
c = '>'; c = '>';
mb_c = c; mb_c = c;
@ -3193,7 +3193,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
// last column; the character is displayed at the start of the // last column; the character is displayed at the start of the
// next line. // next line.
if ((wp->w_p_rl ? (col <= 0) : if ((wp->w_p_rl ? (col <= 0) :
(col >= grid->Columns - 1)) (col >= grid->cols - 1))
&& utf_char2cells(mb_c) == 2) { && utf_char2cells(mb_c) == 2) {
c = '>'; c = '>';
mb_c = c; mb_c = c;
@ -3398,7 +3398,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
} }
} }
if (c == TAB && n_extra + col > grid->Columns) { if (c == TAB && n_extra + col > grid->cols) {
n_extra = tabstop_padding(vcol, wp->w_buffer->b_p_ts, n_extra = tabstop_padding(vcol, wp->w_buffer->b_p_ts,
wp->w_buffer->b_p_vts_array) - 1; wp->w_buffer->b_p_vts_array) - 1;
} }
@ -3601,7 +3601,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
|| ((fromcol >= 0 || fromcol_prev >= 0) || ((fromcol >= 0 || fromcol_prev >= 0)
&& tocol > vcol && tocol > vcol
&& VIsual_mode != Ctrl_V && VIsual_mode != Ctrl_V
&& (wp->w_p_rl ? (col >= 0) : (col < grid->Columns)) && (wp->w_p_rl ? (col >= 0) : (col < grid->cols))
&& !(noinvcur && !(noinvcur
&& lnum == wp->w_cursor.lnum && lnum == wp->w_cursor.lnum
&& (colnr_T)vcol == wp->w_virtcol))) && (colnr_T)vcol == wp->w_virtcol)))
@ -3673,7 +3673,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
&& virtual_active() && virtual_active()
&& tocol != MAXCOL && tocol != MAXCOL
&& vcol < tocol && vcol < tocol
&& (wp->w_p_rl ? (col >= 0) : (col < grid->Columns))) { && (wp->w_p_rl ? (col >= 0) : (col < grid->cols))) {
c = ' '; c = ' ';
ptr--; // put it back at the NUL ptr--; // put it back at the NUL
} }
@ -3755,7 +3755,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
&& conceal_cursor_line(wp) && conceal_cursor_line(wp)
&& (int)wp->w_virtcol <= vcol + n_skip) { && (int)wp->w_virtcol <= vcol + n_skip) {
if (wp->w_p_rl) { if (wp->w_p_rl) {
wp->w_wcol = grid->Columns - col + boguscols - 1; wp->w_wcol = grid->cols - col + boguscols - 1;
} else { } else {
wp->w_wcol = col - boguscols; wp->w_wcol = col - boguscols;
} }
@ -3827,7 +3827,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
n = 1; n = 1;
} }
} else { } else {
if (col >= grid->Columns) { if (col >= grid->cols) {
n = -1; n = -1;
} }
} }
@ -3895,7 +3895,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
if (((wp->w_p_cuc if (((wp->w_p_cuc
&& (int)wp->w_virtcol >= VCOL_HLC - eol_hl_off && (int)wp->w_virtcol >= VCOL_HLC - eol_hl_off
&& (int)wp->w_virtcol < && (int)wp->w_virtcol <
(long)grid->Columns * (row - startrow + 1) + v (long)grid->cols * (row - startrow + 1) + v
&& lnum != wp->w_cursor.lnum) && lnum != wp->w_cursor.lnum)
|| draw_color_col || line_attr_lowprio || line_attr || draw_color_col || line_attr_lowprio || line_attr
|| diff_hlf != (hlf_T)0 || has_virttext)) { || diff_hlf != (hlf_T)0 || has_virttext)) {
@ -3933,7 +3933,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
int col_stride = wp->w_p_rl ? -1 : 1; int col_stride = wp->w_p_rl ? -1 : 1;
while (wp->w_p_rl ? col >= 0 : col < grid->Columns) { while (wp->w_p_rl ? col >= 0 : col < grid->cols) {
schar_from_ascii(linebuf_char[off], ' '); schar_from_ascii(linebuf_char[off], ' ');
col += col_stride; col += col_stride;
if (draw_color_col) { if (draw_color_col) {
@ -3966,7 +3966,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
// terminal buffers may need to highlight beyond the end of the // terminal buffers may need to highlight beyond the end of the
// logical line // logical line
int n = wp->w_p_rl ? -1 : 1; int n = wp->w_p_rl ? -1 : 1;
while (col >= 0 && col < grid->Columns) { while (col >= 0 && col < grid->cols) {
schar_from_ascii(linebuf_char[off], ' '); schar_from_ascii(linebuf_char[off], ' ');
linebuf_attr[off] = vcol >= TERM_ATTRS_MAX ? 0 : term_attrs[vcol]; linebuf_attr[off] = vcol >= TERM_ATTRS_MAX ? 0 : term_attrs[vcol];
off += n; off += n;
@ -3975,8 +3975,8 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
} }
} }
draw_virt_text(wp, buf, win_col_offset, &col, grid->Columns, row); draw_virt_text(wp, buf, win_col_offset, &col, grid->cols, row);
grid_put_linebuf(grid, row, 0, col, grid->Columns, wp->w_p_rl, wp, grid_put_linebuf(grid, row, 0, col, grid->cols, wp->w_p_rl, wp,
wp->w_hl_attr_normal, false); wp->w_hl_attr_normal, false);
row++; row++;
@ -4001,7 +4001,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
&& wp->w_p_list && wp->w_p_list
&& !wp->w_p_wrap && !wp->w_p_wrap
&& filler_todo <= 0 && filler_todo <= 0
&& (wp->w_p_rl ? col == 0 : col == grid->Columns - 1) && (wp->w_p_rl ? col == 0 : col == grid->cols - 1)
&& !has_fold && !has_fold
&& (*ptr != NUL && (*ptr != NUL
|| lcs_eol_one > 0 || lcs_eol_one > 0
@ -4191,7 +4191,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
* At end of screen line and there is more to come: Display the line * At end of screen line and there is more to come: Display the line
* so far. If there is no more to display it is caught above. * so far. If there is no more to display it is caught above.
*/ */
if ((wp->w_p_rl ? (col < 0) : (col >= grid->Columns)) if ((wp->w_p_rl ? (col < 0) : (col >= grid->cols))
&& foldinfo.fi_lines == 0 && foldinfo.fi_lines == 0
&& (draw_state != WL_LINE && (draw_state != WL_LINE
|| *ptr != NUL || *ptr != NUL
@ -4204,7 +4204,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
&& filler_todo <= 0 // Not drawing diff filler lines. && filler_todo <= 0 // Not drawing diff filler lines.
&& lcs_eol_one != -1 // Haven't printed the lcs_eol character. && lcs_eol_one != -1 // Haven't printed the lcs_eol character.
&& row != endrow - 1 // Not the last line being displayed. && row != endrow - 1 // Not the last line being displayed.
&& (grid->Columns == Columns // Window spans the width of the screen, && (grid->cols == Columns // Window spans the width of the screen,
|| ui_has(kUIMultigrid)) // or has dedicated grid. || ui_has(kUIMultigrid)) // or has dedicated grid.
&& !wp->w_p_rl; // Not right-to-left. && !wp->w_p_rl; // Not right-to-left.
@ -4216,13 +4216,13 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
assert(i >= 0); assert(i >= 0);
int offset = kv_A(virt_lines, i).left_col ? 0 : win_col_offset; int offset = kv_A(virt_lines, i).left_col ? 0 : win_col_offset;
draw_virt_text_item(buf, offset, kv_A(virt_lines, i).line, draw_virt_text_item(buf, offset, kv_A(virt_lines, i).line,
kHlModeReplace, grid->Columns, offset); kHlModeReplace, grid->cols, offset);
} }
} else { } else {
draw_virt_text(wp, buf, win_col_offset, &draw_col, grid->Columns, row); draw_virt_text(wp, buf, win_col_offset, &draw_col, grid->cols, row);
} }
grid_put_linebuf(grid, row, 0, draw_col, grid->Columns, wp->w_p_rl, grid_put_linebuf(grid, row, 0, draw_col, grid->cols, wp->w_p_rl,
wp, wp->w_hl_attr_normal, wrap); wp, wp->w_hl_attr_normal, wrap);
if (wrap) { if (wrap) {
ScreenGrid *current_grid = grid; ScreenGrid *current_grid = grid;
@ -4249,7 +4249,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
// When the window is too narrow draw all "@" lines. // When the window is too narrow draw all "@" lines.
if (draw_state != WL_LINE && filler_todo <= 0) { if (draw_state != WL_LINE && filler_todo <= 0) {
win_draw_end(wp, '@', ' ', true, row, wp->w_grid.Rows, HLF_AT); win_draw_end(wp, '@', ' ', true, row, wp->w_grid.rows, HLF_AT);
row = endrow; row = endrow;
} }
@ -4262,7 +4262,7 @@ static int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, bool noc
col = 0; col = 0;
off = 0; off = 0;
if (wp->w_p_rl) { if (wp->w_p_rl) {
col = grid->Columns - 1; // col is not used if breaking! col = grid->cols - 1; // col is not used if breaking!
off += col; off += col;
} }
@ -5589,7 +5589,7 @@ void win_grid_alloc(win_T *wp)
bool want_allocation = ui_has(kUIMultigrid) || wp->w_floating; bool want_allocation = ui_has(kUIMultigrid) || wp->w_floating;
bool has_allocation = (grid_allocated->chars != NULL); bool has_allocation = (grid_allocated->chars != NULL);
if (grid->Rows != rows) { if (grid->rows != rows) {
wp->w_lines_valid = 0; wp->w_lines_valid = 0;
xfree(wp->w_lines); xfree(wp->w_lines);
wp->w_lines = xcalloc(rows + 1, sizeof(wline_T)); wp->w_lines = xcalloc(rows + 1, sizeof(wline_T));
@ -5597,8 +5597,8 @@ void win_grid_alloc(win_T *wp)
int was_resized = false; int was_resized = false;
if (want_allocation && (!has_allocation if (want_allocation && (!has_allocation
|| grid_allocated->Rows != total_rows || grid_allocated->rows != total_rows
|| grid_allocated->Columns != total_cols)) { || grid_allocated->cols != total_cols)) {
grid_alloc(grid_allocated, total_rows, total_cols, grid_alloc(grid_allocated, total_rows, total_cols,
wp->w_grid_alloc.valid, false); wp->w_grid_alloc.valid, false);
grid_allocated->valid = true; grid_allocated->valid = true;
@ -5617,8 +5617,8 @@ void win_grid_alloc(win_T *wp)
grid_allocated->valid = true; grid_allocated->valid = true;
} }
grid->Rows = rows; grid->rows = rows;
grid->Columns = cols; grid->cols = cols;
wp->w_winrow_off = wp->w_border_adj[0] + wp->w_winbar_height; wp->w_winrow_off = wp->w_border_adj[0] + wp->w_winbar_height;
wp->w_wincol_off = wp->w_border_adj[3]; wp->w_wincol_off = wp->w_border_adj[3];
@ -5639,7 +5639,7 @@ void win_grid_alloc(win_T *wp)
// - the UI wants multigrid event (necessary) // - the UI wants multigrid event (necessary)
if ((send_grid_resize || was_resized) && want_allocation) { if ((send_grid_resize || was_resized) && want_allocation) {
ui_call_grid_resize(grid_allocated->handle, ui_call_grid_resize(grid_allocated->handle,
grid_allocated->Columns, grid_allocated->Rows); grid_allocated->cols, grid_allocated->rows);
} }
} }
@ -5660,7 +5660,7 @@ void grid_assign_handle(ScreenGrid *grid)
/// ///
/// There may be some time between setting Rows and Columns and (re)allocating /// There may be some time between setting Rows and Columns and (re)allocating
/// default_grid arrays. This happens when starting up and when /// default_grid arrays. This happens when starting up and when
/// (manually) changing the shell size. Always use default_grid.Rows and /// (manually) changing the shell size. Always use default_grid.rows and
/// default_grid.Columns to access items in default_grid.chars[]. Use Rows /// default_grid.Columns to access items in default_grid.chars[]. Use Rows
/// and Columns for positioning text etc. where the final size of the shell is /// and Columns for positioning text etc. where the final size of the shell is
/// needed. /// needed.
@ -5681,8 +5681,8 @@ retry:
// when Rows and Columns have been set and we have started doing full // when Rows and Columns have been set and we have started doing full
// screen stuff. // screen stuff.
if ((default_grid.chars != NULL if ((default_grid.chars != NULL
&& Rows == default_grid.Rows && Rows == default_grid.rows
&& Columns == default_grid.Columns && Columns == default_grid.cols
) )
|| Rows == 0 || Rows == 0
|| Columns == 0 || Columns == 0
@ -5781,9 +5781,9 @@ void screenclear(void)
} }
// blank out the default grid // blank out the default grid
for (i = 0; i < default_grid.Rows; i++) { for (i = 0; i < default_grid.rows; i++) {
grid_clear_line(&default_grid, default_grid.line_offset[i], grid_clear_line(&default_grid, default_grid.line_offset[i],
default_grid.Columns, true); default_grid.cols, true);
default_grid.line_wraps[i] = false; default_grid.line_wraps[i] = false;
} }
@ -5867,16 +5867,16 @@ void win_scroll_lines(win_T *wp, int row, int line_count)
} }
// No lines are being moved, just draw over the entire area // No lines are being moved, just draw over the entire area
if (row + abs(line_count) >= wp->w_grid.Rows) { if (row + abs(line_count) >= wp->w_grid.rows) {
return; return;
} }
if (line_count < 0) { if (line_count < 0) {
grid_del_lines(&wp->w_grid, row, -line_count, grid_del_lines(&wp->w_grid, row, -line_count,
wp->w_grid.Rows, 0, wp->w_grid.Columns); wp->w_grid.rows, 0, wp->w_grid.cols);
} else { } else {
grid_ins_lines(&wp->w_grid, row, line_count, grid_ins_lines(&wp->w_grid, row, line_count,
wp->w_grid.Rows, 0, wp->w_grid.Columns); wp->w_grid.rows, 0, wp->w_grid.cols);
} }
} }
@ -5915,7 +5915,7 @@ void grid_ins_lines(ScreenGrid *grid, int row, int line_count, int end, int col,
// Shift line_offset[] line_count down to reflect the inserted lines. // Shift line_offset[] line_count down to reflect the inserted lines.
// Clear the inserted lines. // Clear the inserted lines.
for (i = 0; i < line_count; i++) { for (i = 0; i < line_count; i++) {
if (width != grid->Columns) { if (width != grid->cols) {
// need to copy part of a line // need to copy part of a line
j = end - 1 - i; j = end - 1 - i;
while ((j -= line_count) >= row) { while ((j -= line_count) >= row) {
@ -5933,7 +5933,7 @@ void grid_ins_lines(ScreenGrid *grid, int row, int line_count, int end, int col,
} }
grid->line_offset[j + line_count] = temp; grid->line_offset[j + line_count] = temp;
grid->line_wraps[j + line_count] = false; grid->line_wraps[j + line_count] = false;
grid_clear_line(grid, temp, grid->Columns, false); grid_clear_line(grid, temp, grid->cols, false);
} }
} }
@ -5964,7 +5964,7 @@ void grid_del_lines(ScreenGrid *grid, int row, int line_count, int end, int col,
// Now shift line_offset[] line_count up to reflect the deleted lines. // Now shift line_offset[] line_count up to reflect the deleted lines.
// Clear the inserted lines. // Clear the inserted lines.
for (i = 0; i < line_count; i++) { for (i = 0; i < line_count; i++) {
if (width != grid->Columns) { if (width != grid->cols) {
// need to copy part of a line // need to copy part of a line
j = row + i; j = row + i;
while ((j += line_count) <= end - 1) { while ((j += line_count) <= end - 1) {
@ -5983,7 +5983,7 @@ void grid_del_lines(ScreenGrid *grid, int row, int line_count, int end, int col,
} }
grid->line_offset[j - line_count] = temp; grid->line_offset[j - line_count] = temp;
grid->line_wraps[j - line_count] = false; grid->line_wraps[j - line_count] = false;
grid_clear_line(grid, temp, grid->Columns, false); grid_clear_line(grid, temp, grid->cols, false);
} }
} }

4
src/nvim/ui.c
View File

@ -436,7 +436,7 @@ void ui_set_ext_option(UI *ui, UIExtension ext, bool active)
void ui_line(ScreenGrid *grid, int row, int startcol, int endcol, int clearcol, int clearattr, void ui_line(ScreenGrid *grid, int row, int startcol, int endcol, int clearcol, int clearattr,
bool wrap) bool wrap)
{ {
assert(0 <= row && row < grid->Rows); assert(0 <= row && row < grid->rows);
LineFlags flags = wrap ? kLineFlagWrap : 0; LineFlags flags = wrap ? kLineFlagWrap : 0;
if (startcol == -1) { if (startcol == -1) {
startcol = 0; startcol = 0;
@ -453,7 +453,7 @@ void ui_line(ScreenGrid *grid, int row, int startcol, int endcol, int clearcol,
if (p_wd && !(rdb_flags & RDB_COMPOSITOR)) { if (p_wd && !(rdb_flags & RDB_COMPOSITOR)) {
// If 'writedelay' is active, set the cursor to indicate what was drawn. // If 'writedelay' is active, set the cursor to indicate what was drawn.
ui_call_grid_cursor_goto(grid->handle, row, ui_call_grid_cursor_goto(grid->handle, row,
MIN(clearcol, (int)grid->Columns - 1)); MIN(clearcol, (int)grid->cols - 1));
ui_call_flush(); ui_call_flush();
uint64_t wd = (uint64_t)labs(p_wd); uint64_t wd = (uint64_t)labs(p_wd);
os_microdelay(wd * 1000u, true); os_microdelay(wd * 1000u, true);

62
src/nvim/ui_compositor.c
View File

@ -138,19 +138,19 @@ bool ui_comp_put_grid(ScreenGrid *grid, int row, int col, int height, int width,
// use it. // use it.
grid->comp_disabled = true; grid->comp_disabled = true;
compose_area(grid->comp_row, row, compose_area(grid->comp_row, row,
grid->comp_col, grid->comp_col + grid->Columns); grid->comp_col, grid->comp_col + grid->cols);
if (grid->comp_col < col) { if (grid->comp_col < col) {
compose_area(MAX(row, grid->comp_row), compose_area(MAX(row, grid->comp_row),
MIN(row + height, grid->comp_row + grid->Rows), MIN(row + height, grid->comp_row + grid->rows),
grid->comp_col, col); grid->comp_col, col);
} }
if (col + width < grid->comp_col + grid->Columns) { if (col + width < grid->comp_col + grid->cols) {
compose_area(MAX(row, grid->comp_row), compose_area(MAX(row, grid->comp_row),
MIN(row + height, grid->comp_row + grid->Rows), MIN(row + height, grid->comp_row + grid->rows),
col + width, grid->comp_col + grid->Columns); col + width, grid->comp_col + grid->cols);
} }
compose_area(row + height, grid->comp_row + grid->Rows, compose_area(row + height, grid->comp_row + grid->rows,
grid->comp_col, grid->comp_col + grid->Columns); grid->comp_col, grid->comp_col + grid->cols);
grid->comp_disabled = false; grid->comp_disabled = false;
} }
grid->comp_row = row; grid->comp_row = row;
@ -188,8 +188,8 @@ bool ui_comp_put_grid(ScreenGrid *grid, int row, int col, int height, int width,
grid->comp_index = insert_at; grid->comp_index = insert_at;
} }
if (moved && valid && ui_comp_should_draw()) { if (moved && valid && ui_comp_should_draw()) {
compose_area(grid->comp_row, grid->comp_row + grid->Rows, compose_area(grid->comp_row, grid->comp_row + grid->rows,
grid->comp_col, grid->comp_col + grid->Columns); grid->comp_col, grid->comp_col + grid->cols);
} }
return moved; return moved;
} }
@ -249,10 +249,10 @@ static void ui_comp_raise_grid(ScreenGrid *grid, size_t new_index)
for (size_t i = old_index; i < new_index; i++) { for (size_t i = old_index; i < new_index; i++) {
ScreenGrid *grid2 = kv_A(layers, i); ScreenGrid *grid2 = kv_A(layers, i);
int startcol = MAX(grid->comp_col, grid2->comp_col); int startcol = MAX(grid->comp_col, grid2->comp_col);
int endcol = MIN(grid->comp_col + grid->Columns, int endcol = MIN(grid->comp_col + grid->cols,
grid2->comp_col + grid2->Columns); grid2->comp_col + grid2->cols);
compose_area(MAX(grid->comp_row, grid2->comp_row), compose_area(MAX(grid->comp_row, grid2->comp_row),
MIN(grid->comp_row + grid->Rows, grid2->comp_row + grid2->Rows), MIN(grid->comp_row + grid->rows, grid2->comp_row + grid2->rows),
startcol, endcol); startcol, endcol);
} }
} }
@ -279,7 +279,7 @@ static void ui_comp_grid_cursor_goto(UI *ui, Integer grid_handle, Integer r, Int
} }
} }
if (cursor_col >= default_grid.Columns || cursor_row >= default_grid.Rows) { if (cursor_col >= default_grid.cols || cursor_row >= default_grid.rows) {
// TODO(bfredl): this happens with 'writedelay', refactor? // TODO(bfredl): this happens with 'writedelay', refactor?
// abort(); // abort();
return; return;
@ -292,8 +292,8 @@ ScreenGrid *ui_comp_mouse_focus(int row, int col)
for (ssize_t i = (ssize_t)kv_size(layers) - 1; i > 0; i--) { for (ssize_t i = (ssize_t)kv_size(layers) - 1; i > 0; i--) {
ScreenGrid *grid = kv_A(layers, i); ScreenGrid *grid = kv_A(layers, i);
if (grid->focusable if (grid->focusable
&& row >= grid->comp_row && row < grid->comp_row + grid->Rows && row >= grid->comp_row && row < grid->comp_row + grid->rows
&& col >= grid->comp_col && col < grid->comp_col + grid->Columns) { && col >= grid->comp_col && col < grid->comp_col + grid->cols) {
return grid; return grid;
} }
} }
@ -315,7 +315,7 @@ static void compose_line(Integer row, Integer startcol, Integer endcol, LineFlag
startcol--; startcol--;
skipstart = 1; skipstart = 1;
} }
if (endcol < default_grid.Columns && (flags & kLineFlagInvalid)) { if (endcol < default_grid.cols && (flags & kLineFlagInvalid)) {
endcol++; endcol++;
skipend = 1; skipend = 1;
} }
@ -337,8 +337,8 @@ static void compose_line(Integer row, Integer startcol, Integer endcol, LineFlag
// first check to see if any grids have pending updates to width/height, // first check to see if any grids have pending updates to width/height,
// to ensure that we don't accidentally put any characters into `linebuf` // to ensure that we don't accidentally put any characters into `linebuf`
// that have been invalidated. // that have been invalidated.
grid_width = MIN(g->Columns, g->comp_width); grid_width = MIN(g->cols, g->comp_width);
grid_height = MIN(g->Rows, g->comp_height); grid_height = MIN(g->rows, g->comp_height);
if (g->comp_row > row || row >= g->comp_row + grid_height if (g->comp_row > row || row >= g->comp_row + grid_height
|| g->comp_disabled) { || g->comp_disabled) {
continue; continue;
@ -354,7 +354,7 @@ static void compose_line(Integer row, Integer startcol, Integer endcol, LineFlag
assert(grid != NULL); assert(grid != NULL);
assert(until > col); assert(until > col);
assert(until <= default_grid.Columns); assert(until <= default_grid.cols);
size_t n = (size_t)(until - col); size_t n = (size_t)(until - col);
if (row == msg_sep_row && grid->comp_index <= msg_grid.comp_index) { if (row == msg_sep_row && grid->comp_index <= msg_grid.comp_index) {
@ -371,7 +371,7 @@ static void compose_line(Integer row, Integer startcol, Integer endcol, LineFlag
+ (size_t)(col - grid->comp_col); + (size_t)(col - grid->comp_col);
memcpy(linebuf + (col - startcol), grid->chars + off, n * sizeof(*linebuf)); memcpy(linebuf + (col - startcol), grid->chars + off, n * sizeof(*linebuf));
memcpy(attrbuf + (col - startcol), grid->attrs + off, n * sizeof(*attrbuf)); memcpy(attrbuf + (col - startcol), grid->attrs + off, n * sizeof(*attrbuf));
if (grid->comp_col + grid->Columns > until if (grid->comp_col + grid->cols > until
&& grid->chars[off + n][0] == NUL) { && grid->chars[off + n][0] == NUL) {
linebuf[until - 1 - startcol][0] = ' '; linebuf[until - 1 - startcol][0] = ' ';
linebuf[until - 1 - startcol][1] = '\0'; linebuf[until - 1 - startcol][1] = '\0';
@ -452,8 +452,8 @@ static void compose_debug(Integer startrow, Integer endrow, Integer startcol, In
return; return;
} }
endrow = MIN(endrow, default_grid.Rows); endrow = MIN(endrow, default_grid.rows);
endcol = MIN(endcol, default_grid.Columns); endcol = MIN(endcol, default_grid.cols);
int attr = syn_id2attr(syn_id); int attr = syn_id2attr(syn_id);
for (int row = (int)startrow; row < endrow; row++) { for (int row = (int)startrow; row < endrow; row++) {
@ -480,8 +480,8 @@ static void debug_delay(Integer lines)
static void compose_area(Integer startrow, Integer endrow, Integer startcol, Integer endcol) static void compose_area(Integer startrow, Integer endrow, Integer startcol, Integer endcol)
{ {
compose_debug(startrow, endrow, startcol, endcol, dbghl_recompose, true); compose_debug(startrow, endrow, startcol, endcol, dbghl_recompose, true);
endrow = MIN(endrow, default_grid.Rows); endrow = MIN(endrow, default_grid.rows);
endcol = MIN(endcol, default_grid.Columns); endcol = MIN(endcol, default_grid.cols);
if (endcol <= startcol) { if (endcol <= startcol) {
return; return;
} }
@ -497,8 +497,8 @@ static void compose_area(Integer startrow, Integer endrow, Integer startcol, Int
void ui_comp_compose_grid(ScreenGrid *grid) void ui_comp_compose_grid(ScreenGrid *grid)
{ {
if (ui_comp_should_draw()) { if (ui_comp_should_draw()) {
compose_area(grid->comp_row, grid->comp_row + grid->Rows, compose_area(grid->comp_row, grid->comp_row + grid->rows,
grid->comp_col, grid->comp_col + grid->Columns); grid->comp_col, grid->comp_col + grid->cols);
} }
} }
@ -523,17 +523,17 @@ static void ui_comp_raw_line(UI *ui, Integer grid, Integer row, Integer startcol
// TODO(bfredl): this should not really be necessary. But on some condition // TODO(bfredl): this should not really be necessary. But on some condition
// when resizing nvim, a window will be attempted to be drawn on the older // when resizing nvim, a window will be attempted to be drawn on the older
// and possibly larger global screen size. // and possibly larger global screen size.
if (row >= default_grid.Rows) { if (row >= default_grid.rows) {
DLOG("compositor: invalid row %" PRId64 " on grid %" PRId64, row, grid); DLOG("compositor: invalid row %" PRId64 " on grid %" PRId64, row, grid);
return; return;
} }
if (clearcol > default_grid.Columns) { if (clearcol > default_grid.cols) {
DLOG("compositor: invalid last column %" PRId64 " on grid %" PRId64, DLOG("compositor: invalid last column %" PRId64 " on grid %" PRId64,
clearcol, grid); clearcol, grid);
if (startcol >= default_grid.Columns) { if (startcol >= default_grid.cols) {
return; return;
} }
clearcol = default_grid.Columns; clearcol = default_grid.cols;
endcol = MIN(endcol, clearcol); endcol = MIN(endcol, clearcol);
} }
@ -581,7 +581,7 @@ static void ui_comp_msg_set_pos(UI *ui, Integer grid, Integer row, Boolean scrol
} }
if (row > msg_current_row && ui_comp_should_draw()) { if (row > msg_current_row && ui_comp_should_draw()) {
compose_area(MAX(msg_current_row - 1, 0), row, 0, default_grid.Columns); compose_area(MAX(msg_current_row - 1, 0), row, 0, default_grid.cols);
} else if (row < msg_current_row && ui_comp_should_draw() } else if (row < msg_current_row && ui_comp_should_draw()
&& msg_current_row < Rows) { && msg_current_row < Rows) {
int delta = msg_current_row - (int)row; int delta = msg_current_row - (int)row;