mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-09 04:48:18 +00:00
Code Issues Packages Projects Releases Wiki Activity

multigrid: Allow UIs to set grid size different from window size

Browse Source
This commit is contained in:
Utkarsh Maheshwari
2018-06-06 02:59:11 +05:30
committed by Björn Linse
parent f102f50ebe
commit 01555de2da
17 changed files with 270 additions and 195 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/nvim/api/ui.c
View File

@@ -126,7 +126,7 @@ void nvim_ui_attach(uint64_t channel_id, Integer width, Integer height,
} }
} }
if (ui->ui_ext[kUIHlState]) { if (ui->ui_ext[kUIHlState] || ui->ui_ext[kUIMultigrid]) {
ui->ui_ext[kUILinegrid] = true; ui->ui_ext[kUILinegrid] = true;
} }
@@ -245,6 +245,23 @@ static void ui_set_option(UI *ui, bool init, String name, Object value,
name.data); name.data);
} }
/// Sets the inner "width" and "height" of the window grid identified by
/// "grid" handle. If the grid does not exist, set error.
void nvim_ui_try_resize_grid(uint64_t channel_id, Integer grid, Integer width,
Integer height, Error *error)
FUNC_API_SINCE(4) FUNC_API_REMOTE_ONLY
{
if (!pmap_has(uint64_t)(connected_uis, channel_id)) {
api_set_error(error, kErrorTypeException,
"UI not attached to channel: %" PRId64, channel_id);
return;
}
// TODO(utkarshme): Check if grid exists
ui_grid_resize((GridHandle)grid, (int)width, (int)height);
}
/// Pushes data into UI.UIData, to be consumed later by remote_ui_flush(). /// Pushes data into UI.UIData, to be consumed later by remote_ui_flush().
static void push_call(UI *ui, const char *name, Array args) static void push_call(UI *ui, const char *name, Array args)
{ {

24
src/nvim/charset.c
View File

@@ -1022,12 +1022,12 @@ int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *he
&& vim_isbreak(c) && vim_isbreak(c)
&& !vim_isbreak((int)s[1]) && !vim_isbreak((int)s[1])
&& wp->w_p_wrap && wp->w_p_wrap
&& (wp->w_width != 0)) { && (wp->w_grid.Columns != 0)) {
// Count all characters from first non-blank after a blank up to next // Count all characters from first non-blank after a blank up to next
// non-blank after a blank. // non-blank after a blank.
numberextra = win_col_off(wp); numberextra = win_col_off(wp);
col2 = col; col2 = col;
colmax = (colnr_T)(wp->w_width - numberextra - col_adj); colmax = (colnr_T)(wp->w_grid.Columns - numberextra - col_adj);
if (col >= colmax) { if (col >= colmax) {
colmax += col_adj; colmax += col_adj;
@@ -1076,9 +1076,9 @@ int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *he
numberextra = numberwidth; numberextra = numberwidth;
col += numberextra + mb_added; col += numberextra + mb_added;
if (col >= (colnr_T)wp->w_width) { if (col >= (colnr_T)wp->w_grid.Columns) {
col -= wp->w_width; col -= wp->w_grid.Columns;
numberextra = wp->w_width - (numberextra - win_col_off2(wp)); numberextra = wp->w_grid.Columns - (numberextra - win_col_off2(wp));
if (col >= numberextra && numberextra > 0) { if (col >= numberextra && numberextra > 0) {
col %= numberextra; col %= numberextra;
} }
@@ -1097,16 +1097,16 @@ int win_lbr_chartabsize(win_T *wp, char_u *line, char_u *s, colnr_T col, int *he
numberwidth -= win_col_off2(wp); numberwidth -= win_col_off2(wp);
} }
if (col == 0 || (col + size + sbrlen > (colnr_T)wp->w_width)) { if (col == 0 || (col + size + sbrlen > (colnr_T)wp->w_grid.Columns)) {
added = 0; added = 0;
if (*p_sbr != NUL) { if (*p_sbr != NUL) {
if (size + sbrlen + numberwidth > (colnr_T)wp->w_width) { if (size + sbrlen + numberwidth > (colnr_T)wp->w_grid.Columns) {
// Calculate effective window width. // Calculate effective window width.
int width = (colnr_T)wp->w_width - sbrlen - numberwidth; int width = (colnr_T)wp->w_grid.Columns - sbrlen - numberwidth;
int prev_width = col ? ((colnr_T)wp->w_width - (sbrlen + col)) : 0; int prev_width = col ? ((colnr_T)wp->w_grid.Columns - (sbrlen + col)) : 0;
if (width == 0) { if (width == 0) {
width = (colnr_T)wp->w_width; width = (colnr_T)wp->w_grid.Columns;
} }
added += ((size - prev_width) / width) * vim_strsize(p_sbr); added += ((size - prev_width) / width) * vim_strsize(p_sbr);
if ((size - prev_width) % width) { if ((size - prev_width) % width) {
@@ -1175,11 +1175,11 @@ bool in_win_border(win_T *wp, colnr_T vcol)
int width1; // width of first line (after line number) int width1; // width of first line (after line number)
int width2; // width of further lines int width2; // width of further lines
if (wp->w_width == 0) { if (wp->w_grid.Columns == 0) {
// there is no border // there is no border
return false; return false;
} }
width1 = wp->w_width - win_col_off(wp); width1 = wp->w_grid.Columns - win_col_off(wp);
if ((int)vcol < width1 - 1) { if ((int)vcol < width1 - 1) {
return false; return false;

8
src/nvim/cursor.c
View File

@@ -120,11 +120,11 @@ static int coladvance2(
--curwin->w_curswant; --curwin->w_curswant;
} }
} else { } else {
int width = curwin->w_width - win_col_off(curwin); int width = curwin->w_grid.Columns - win_col_off(curwin);
if (finetune if (finetune
&& curwin->w_p_wrap && curwin->w_p_wrap
&& curwin->w_width != 0 && curwin->w_grid.Columns != 0
&& wcol >= (colnr_T)width) { && wcol >= (colnr_T)width) {
csize = linetabsize(line); csize = linetabsize(line);
if (csize > 0) if (csize > 0)
@@ -224,7 +224,7 @@ static int coladvance2(
int b = (int)wcol - (int)col; int b = (int)wcol - (int)col;
/* The difference between wcol and col is used to set coladd. */ /* The difference between wcol and col is used to set coladd. */
if (b > 0 && b < (MAXCOL - 2 * curwin->w_width)) if (b > 0 && b < (MAXCOL - 2 * curwin->w_grid.Columns))
pos->coladd = b; pos->coladd = b;
col += b; col += b;
@@ -436,7 +436,7 @@ bool leftcol_changed(void)
bool retval = false; bool retval = false;
changed_cline_bef_curs(); changed_cline_bef_curs();
lastcol = curwin->w_leftcol + curwin->w_width - curwin_col_off() - 1; lastcol = curwin->w_leftcol + curwin->w_grid.Columns - curwin_col_off() - 1;
validate_virtcol(); validate_virtcol();
/* /*

4
src/nvim/eval.c
View File

@@ -16774,10 +16774,10 @@ static void f_termopen(typval_T *argvars, typval_T *rettv, FunPtr fptr)
} }
} }
uint16_t term_width = MAX(0, curwin->w_width - win_col_off(curwin)); uint16_t term_width = MAX(0, curwin->w_grid.Columns - win_col_off(curwin));
Channel *chan = channel_job_start(argv, on_stdout, on_stderr, on_exit, Channel *chan = channel_job_start(argv, on_stdout, on_stderr, on_exit,
true, false, false, cwd, true, false, false, cwd,
term_width, curwin->w_height, term_width, curwin->w_grid.Rows,
xstrdup("xterm-256color"), xstrdup("xterm-256color"),
&rettv->vval.v_number); &rettv->vval.v_number);
if (rettv->vval.v_number <= 0) { if (rettv->vval.v_number <= 0) {

6
src/nvim/ex_cmds.c
View File

@@ -257,7 +257,7 @@ void ex_align(exarg_T *eap)
if (width <= 0) if (width <= 0)
width = curbuf->b_p_tw; width = curbuf->b_p_tw;
if (width == 0 && curbuf->b_p_wm > 0) if (width == 0 && curbuf->b_p_wm > 0)
width = curwin->w_width - curbuf->b_p_wm; width = curwin->w_grid.Columns - curbuf->b_p_wm;
if (width <= 0) if (width <= 0)
width = 80; width = 80;
} }
@@ -2870,11 +2870,11 @@ void ex_z(exarg_T *eap)
// Vi compatible: ":z!" uses display height, without a count uses // Vi compatible: ":z!" uses display height, without a count uses
// 'scroll' // 'scroll'
if (eap->forceit) { if (eap->forceit) {
bigness = curwin->w_height; bigness = curwin->w_grid.Rows;
} else if (ONE_WINDOW) { } else if (ONE_WINDOW) {
bigness = curwin->w_p_scr * 2; bigness = curwin->w_p_scr * 2;
} else { } else {
bigness = curwin->w_height - 3; bigness = curwin->w_grid.Rows - 3;
} }
if (bigness < 1) { if (bigness < 1) {
bigness = 1; bigness = 1;

6
src/nvim/ex_docmd.c
View File

@@ -9196,7 +9196,7 @@ static int ses_winsizes(FILE *fd, int restore_size, win_T *tab_firstwin)
&& (fprintf(fd, && (fprintf(fd,
"exe '%dresize ' . ((&lines * %" PRId64 "exe '%dresize ' . ((&lines * %" PRId64
" + %" PRId64 ") / %" PRId64 ")", " + %" PRId64 ") / %" PRId64 ")",
n, (int64_t)wp->w_height, n, (int64_t)wp->w_grid.Rows,
(int64_t)(Rows / 2), (int64_t)Rows) < 0 (int64_t)(Rows / 2), (int64_t)Rows) < 0
|| put_eol(fd) == FAIL)) || put_eol(fd) == FAIL))
return FAIL; return FAIL;
@@ -9459,8 +9459,8 @@ put_view(
" * winheight(0) + %" PRId64 ") / %" PRId64 ")", " * winheight(0) + %" PRId64 ") / %" PRId64 ")",
(int64_t)wp->w_cursor.lnum, (int64_t)wp->w_cursor.lnum,
(int64_t)(wp->w_cursor.lnum - wp->w_topline), (int64_t)(wp->w_cursor.lnum - wp->w_topline),
(int64_t)(wp->w_height / 2), (int64_t)(wp->w_grid.Rows / 2),
(int64_t)wp->w_height) < 0 (int64_t)wp->w_grid.Rows) < 0
|| put_eol(fd) == FAIL || put_eol(fd) == FAIL
|| put_line(fd, "if s:l < 1 | let s:l = 1 | endif") == FAIL || put_line(fd, "if s:l < 1 | let s:l = 1 | endif") == FAIL
|| put_line(fd, "exe s:l") == FAIL || put_line(fd, "exe s:l") == FAIL

6
src/nvim/getchar.c
View File

@@ -2120,8 +2120,8 @@ static int vgetorpeek(int advance)
++col; ++col;
} }
curwin->w_wrow = curwin->w_cline_row curwin->w_wrow = curwin->w_cline_row
+ curwin->w_wcol / curwin->w_width; + curwin->w_wcol / curwin->w_grid.Columns;
curwin->w_wcol %= curwin->w_width; curwin->w_wcol %= curwin->w_grid.Columns;
curwin->w_wcol += curwin_col_off(); curwin->w_wcol += curwin_col_off();
col = 0; /* no correction needed */ col = 0; /* no correction needed */
} else { } else {
@@ -2130,7 +2130,7 @@ static int vgetorpeek(int advance)
} }
} else if (curwin->w_p_wrap && curwin->w_wrow) { } else if (curwin->w_p_wrap && curwin->w_wrow) {
--curwin->w_wrow; --curwin->w_wrow;
curwin->w_wcol = curwin->w_width - 1; curwin->w_wcol = curwin->w_grid.Columns - 1;
col = curwin->w_cursor.col - 1; col = curwin->w_cursor.col - 1;
} }
if (col > 0 && curwin->w_wcol > 0) { if (col > 0 && curwin->w_wcol > 0) {

2
src/nvim/globals.h
View File

@@ -162,7 +162,7 @@ EXTERN int screen_Rows INIT(= 0); /* actual size of ScreenLines[] */
EXTERN int screen_Columns INIT(= 0); /* actual size of ScreenLines[] */ EXTERN int screen_Columns INIT(= 0); /* actual size of ScreenLines[] */
EXTERN ScreenGrid default_grid INIT(= { 0, NULL, NULL, NULL, NULL, 0, 0, 0, 0, EXTERN ScreenGrid default_grid INIT(= { 0, NULL, NULL, NULL, NULL, 0, 0, 0, 0,
0, 0, 0 }); 0, 0 });
/* /*
* When vgetc() is called, it sets mod_mask to the set of modifiers that are * When vgetc() is called, it sets mod_mask to the set of modifiers that are

2
src/nvim/indent.c
View File

@@ -464,7 +464,7 @@ int get_breakindent_win(win_T *wp, char_u *line)
static varnumber_T prev_tick = 0; // Changedtick of cached value. static varnumber_T prev_tick = 0; // Changedtick of cached value.
int bri = 0; int bri = 0;
/* window width minus window margin space, i.e. what rests for text */ /* window width minus window margin space, i.e. what rests for text */
const int eff_wwidth = wp->w_width const int eff_wwidth = wp->w_grid.Columns
- ((wp->w_p_nu || wp->w_p_rnu) - ((wp->w_p_nu || wp->w_p_rnu)
&& (vim_strchr(p_cpo, CPO_NUMCOL) == NULL) && (vim_strchr(p_cpo, CPO_NUMCOL) == NULL)
? number_width(wp) + 1 : 0); ? number_width(wp) + 1 : 0);

12
src/nvim/misc1.c
View File

@@ -1251,7 +1251,7 @@ int plines_win_nofill(
return 1; return 1;
} }
if (wp->w_width == 0) { if (wp->w_grid.Columns == 0) {
return 1; return 1;
} }
@@ -1261,8 +1261,8 @@ int plines_win_nofill(
} }
const int lines = plines_win_nofold(wp, lnum); const int lines = plines_win_nofold(wp, lnum);
if (winheight && lines > wp->w_height) { if (winheight && lines > wp->w_grid.Rows) {
return wp->w_height; return wp->w_grid.Rows;
} }
return lines; return lines;
} }
@@ -1292,7 +1292,7 @@ int plines_win_nofold(win_T *wp, linenr_T lnum)
/* /*
* Add column offset for 'number', 'relativenumber' and 'foldcolumn'. * Add column offset for 'number', 'relativenumber' and 'foldcolumn'.
*/ */
width = wp->w_width - win_col_off(wp); width = wp->w_grid.Columns - win_col_off(wp);
if (width <= 0 || col > 32000) { if (width <= 0 || col > 32000) {
return 32000; // bigger than the number of screen columns return 32000; // bigger than the number of screen columns
} }
@@ -1318,7 +1318,7 @@ int plines_win_col(win_T *wp, linenr_T lnum, long column)
if (!wp->w_p_wrap) if (!wp->w_p_wrap)
return lines + 1; return lines + 1;
if (wp->w_width == 0) if (wp->w_grid.Columns == 0)
return lines + 1; return lines + 1;
char_u *line = ml_get_buf(wp->w_buffer, lnum, false); char_u *line = ml_get_buf(wp->w_buffer, lnum, false);
@@ -1340,7 +1340,7 @@ int plines_win_col(win_T *wp, linenr_T lnum, long column)
} }
// Add column offset for 'number', 'relativenumber', 'foldcolumn', etc. // Add column offset for 'number', 'relativenumber', 'foldcolumn', etc.
int width = wp->w_width - win_col_off(wp); int width = wp->w_grid.Columns - win_col_off(wp);
if (width <= 0) { if (width <= 0) {
return 9999; return 9999;
} }

123
src/nvim/move.c
View File

@@ -83,7 +83,7 @@ static void comp_botline(win_T *wp)
redraw_for_cursorline(wp); redraw_for_cursorline(wp);
wp->w_valid |= (VALID_CROW|VALID_CHEIGHT); wp->w_valid |= (VALID_CROW|VALID_CHEIGHT);
} }
if (done + n > wp->w_height) if (done + n > wp->w_grid.Rows)
break; break;
done += n; done += n;
lnum = last; lnum = last;
@@ -203,7 +203,7 @@ void update_topline(void)
check_topline = true; check_topline = true;
if (check_topline) { if (check_topline) {
int halfheight = curwin->w_height / 2 - 1; int halfheight = curwin->w_grid.Rows / 2 - 1;
if (halfheight < 2) if (halfheight < 2)
halfheight = 2; halfheight = 2;
long n; long n;
@@ -295,14 +295,14 @@ void update_topline(void)
lnum >= curwin->w_botline - p_so; --lnum) { lnum >= curwin->w_botline - p_so; --lnum) {
++line_count; ++line_count;
/* stop at end of file or when we know we are far off */ /* stop at end of file or when we know we are far off */
if (lnum <= 0 || line_count > curwin->w_height + 1) if (lnum <= 0 || line_count > curwin->w_grid.Rows + 1)
break; break;
(void)hasFolding(lnum, &lnum, NULL); (void)hasFolding(lnum, &lnum, NULL);
} }
} else } else
line_count = curwin->w_cursor.lnum - curwin->w_botline line_count = curwin->w_cursor.lnum - curwin->w_botline
+ 1 + p_so; + 1 + p_so;
if (line_count <= curwin->w_height + 1) if (line_count <= curwin->w_grid.Rows + 1)
scroll_cursor_bot(scrolljump_value(), false); scroll_cursor_bot(scrolljump_value(), false);
else else
scroll_cursor_halfway(false); scroll_cursor_halfway(false);
@@ -349,7 +349,7 @@ void update_topline_win(win_T* win)
*/ */
static int scrolljump_value(void) static int scrolljump_value(void)
{ {
long result = p_sj >= 0 ? p_sj : (curwin->w_height * -p_sj) / 100; long result = p_sj >= 0 ? p_sj : (curwin->w_grid.Rows * -p_sj) / 100;
assert(result <= INT_MAX); assert(result <= INT_MAX);
return (int)result; return (int)result;
} }
@@ -525,6 +525,7 @@ int cursor_valid(void)
*/ */
void validate_cursor(void) void validate_cursor(void)
{ {
win_grid_alloc(curwin, true); // we need to have w_grid.Rows/Columns updated
check_cursor_moved(curwin); check_cursor_moved(curwin);
if ((curwin->w_valid & (VALID_WCOL|VALID_WROW)) != (VALID_WCOL|VALID_WROW)) if ((curwin->w_valid & (VALID_WCOL|VALID_WROW)) != (VALID_WCOL|VALID_WROW))
curs_columns(true); curs_columns(true);
@@ -663,14 +664,14 @@ void validate_cursor_col(void)
colnr_T col = curwin->w_virtcol; colnr_T col = curwin->w_virtcol;
colnr_T off = curwin_col_off(); colnr_T off = curwin_col_off();
col += off; col += off;
int width = curwin->w_width - off + curwin_col_off2(); int width = curwin->w_grid.Columns - off + curwin_col_off2();
/* long line wrapping, adjust curwin->w_wrow */ /* long line wrapping, adjust curwin->w_wrow */
if (curwin->w_p_wrap if (curwin->w_p_wrap
&& col >= (colnr_T)curwin->w_width && col >= (colnr_T)curwin->w_grid.Columns
&& width > 0) && width > 0)
/* use same formula as what is used in curs_columns() */ /* use same formula as what is used in curs_columns() */
col -= ((col - curwin->w_width) / width + 1) * width; col -= ((col - curwin->w_grid.Columns) / width + 1) * width;
if (col > (int)curwin->w_leftcol) if (col > (int)curwin->w_leftcol)
col -= curwin->w_leftcol; col -= curwin->w_leftcol;
else else
@@ -763,20 +764,20 @@ void curs_columns(
*/ */
curwin->w_wrow = curwin->w_cline_row; curwin->w_wrow = curwin->w_cline_row;
int textwidth = curwin->w_width - extra; int textwidth = curwin->w_grid.Columns - extra;
if (textwidth <= 0) { if (textwidth <= 0) {
/* No room for text, put cursor in last char of window. */ /* No room for text, put cursor in last char of window. */
curwin->w_wcol = curwin->w_width - 1; curwin->w_wcol = curwin->w_grid.Columns - 1;
curwin->w_wrow = curwin->w_height - 1; curwin->w_wrow = curwin->w_grid.Rows - 1;
} else if (curwin->w_p_wrap } else if (curwin->w_p_wrap
&& curwin->w_width != 0 && curwin->w_grid.Columns != 0
) { ) {
width = textwidth + curwin_col_off2(); width = textwidth + curwin_col_off2();
/* long line wrapping, adjust curwin->w_wrow */ /* long line wrapping, adjust curwin->w_wrow */
if (curwin->w_wcol >= curwin->w_width) { if (curwin->w_wcol >= curwin->w_grid.Columns) {
/* this same formula is used in validate_cursor_col() */ /* this same formula is used in validate_cursor_col() */
n = (curwin->w_wcol - curwin->w_width) / width + 1; n = (curwin->w_wcol - curwin->w_grid.Columns) / width + 1;
curwin->w_wcol -= n * width; curwin->w_wcol -= n * width;
curwin->w_wrow += n; curwin->w_wrow += n;
@@ -803,7 +804,7 @@ void curs_columns(
assert(p_siso <= INT_MAX); assert(p_siso <= INT_MAX);
int off_left = startcol - curwin->w_leftcol - (int)p_siso; int off_left = startcol - curwin->w_leftcol - (int)p_siso;
int off_right = int off_right =
endcol - curwin->w_leftcol - curwin->w_width + (int)p_siso + 1; endcol - curwin->w_leftcol - curwin->w_grid.Columns + (int)p_siso + 1;
if (off_left < 0 || off_right > 0) { if (off_left < 0 || off_right > 0) {
int diff = (off_left < 0) ? -off_left: off_right; int diff = (off_left < 0) ? -off_left: off_right;
@@ -846,17 +847,17 @@ void curs_columns(
prev_skipcol = curwin->w_skipcol; prev_skipcol = curwin->w_skipcol;
int p_lines = 0; int p_lines = 0;
if ((curwin->w_wrow >= curwin->w_height if ((curwin->w_wrow >= curwin->w_grid.Rows
|| ((prev_skipcol > 0 || ((prev_skipcol > 0
|| curwin->w_wrow + p_so >= curwin->w_height) || curwin->w_wrow + p_so >= curwin->w_grid.Rows)
&& (p_lines = && (p_lines =
plines_win_nofill plines_win_nofill
(curwin, curwin->w_cursor.lnum, false)) (curwin, curwin->w_cursor.lnum, false))
- 1 >= curwin->w_height)) - 1 >= curwin->w_grid.Rows))
&& curwin->w_height != 0 && curwin->w_grid.Rows != 0
&& curwin->w_cursor.lnum == curwin->w_topline && curwin->w_cursor.lnum == curwin->w_topline
&& width > 0 && width > 0
&& curwin->w_width != 0 && curwin->w_grid.Columns != 0
) { ) {
/* Cursor past end of screen. Happens with a single line that does /* Cursor past end of screen. Happens with a single line that does
* not fit on screen. Find a skipcol to show the text around the * not fit on screen. Find a skipcol to show the text around the
@@ -878,19 +879,19 @@ void curs_columns(
} }
else else
n = p_lines; n = p_lines;
if ((colnr_T)n >= curwin->w_height + curwin->w_skipcol / width) if ((colnr_T)n >= curwin->w_grid.Rows + curwin->w_skipcol / width)
extra += 2; extra += 2;
if (extra == 3 || p_lines < p_so * 2) { if (extra == 3 || p_lines < p_so * 2) {
/* not enough room for 'scrolloff', put cursor in the middle */ /* not enough room for 'scrolloff', put cursor in the middle */
n = curwin->w_virtcol / width; n = curwin->w_virtcol / width;
if (n > curwin->w_height / 2) if (n > curwin->w_grid.Rows / 2)
n -= curwin->w_height / 2; n -= curwin->w_grid.Rows / 2;
else else
n = 0; n = 0;
/* don't skip more than necessary */ /* don't skip more than necessary */
if (n > p_lines - curwin->w_height + 1) if (n > p_lines - curwin->w_grid.Rows + 1)
n = p_lines - curwin->w_height + 1; n = p_lines - curwin->w_grid.Rows + 1;
curwin->w_skipcol = n * width; curwin->w_skipcol = n * width;
} else if (extra == 1) { } else if (extra == 1) {
/* less then 'scrolloff' lines above, decrease skipcol */ /* less then 'scrolloff' lines above, decrease skipcol */
@@ -904,7 +905,7 @@ void curs_columns(
} }
} else if (extra == 2) { } else if (extra == 2) {
/* less then 'scrolloff' lines below, increase skipcol */ /* less then 'scrolloff' lines below, increase skipcol */
endcol = (n - curwin->w_height + 1) * width; endcol = (n - curwin->w_grid.Rows + 1) * width;
while (endcol > curwin->w_virtcol) while (endcol > curwin->w_virtcol)
endcol -= width; endcol -= width;
if (endcol > curwin->w_skipcol) if (endcol > curwin->w_skipcol)
@@ -912,9 +913,9 @@ void curs_columns(
} }
curwin->w_wrow -= curwin->w_skipcol / width; curwin->w_wrow -= curwin->w_skipcol / width;
if (curwin->w_wrow >= curwin->w_height) { if (curwin->w_wrow >= curwin->w_grid.Rows) {
/* small window, make sure cursor is in it */ /* small window, make sure cursor is in it */
extra = curwin->w_wrow - curwin->w_height + 1; extra = curwin->w_wrow - curwin->w_grid.Rows + 1;
curwin->w_skipcol += extra * width; curwin->w_skipcol += extra * width;
curwin->w_wrow -= extra; curwin->w_wrow -= extra;
} }
@@ -956,7 +957,7 @@ scrolldown (
validate_cursor(); /* w_wrow needs to be valid */ validate_cursor(); /* w_wrow needs to be valid */
while (line_count-- > 0) { while (line_count-- > 0) {
if (curwin->w_topfill < diff_check(curwin, curwin->w_topline) if (curwin->w_topfill < diff_check(curwin, curwin->w_topline)
&& curwin->w_topfill < curwin->w_height - 1) { && curwin->w_topfill < curwin->w_grid.Rows - 1) {
++curwin->w_topfill; ++curwin->w_topfill;
++done; ++done;
} else { } else {
@@ -991,15 +992,15 @@ scrolldown (
*/ */
int wrow = curwin->w_wrow; int wrow = curwin->w_wrow;
if (curwin->w_p_wrap if (curwin->w_p_wrap
&& curwin->w_width != 0 && curwin->w_grid.Columns != 0
) { ) {
validate_virtcol(); validate_virtcol();
validate_cheight(); validate_cheight();
wrow += curwin->w_cline_height - 1 - wrow += curwin->w_cline_height - 1 -
curwin->w_virtcol / curwin->w_width; curwin->w_virtcol / curwin->w_grid.Columns;
} }
bool moved = false; bool moved = false;
while (wrow >= curwin->w_height && curwin->w_cursor.lnum > 1) { while (wrow >= curwin->w_grid.Rows && curwin->w_cursor.lnum > 1) {
linenr_T first; linenr_T first;
if (hasFolding(curwin->w_cursor.lnum, &first, NULL)) { if (hasFolding(curwin->w_cursor.lnum, &first, NULL)) {
--wrow; --wrow;
@@ -1084,12 +1085,12 @@ check_topfill (
{ {
if (wp->w_topfill > 0) { if (wp->w_topfill > 0) {
int n = plines_win_nofill(wp, wp->w_topline, true); int n = plines_win_nofill(wp, wp->w_topline, true);
if (wp->w_topfill + n > wp->w_height) { if (wp->w_topfill + n > wp->w_grid.Rows) {
if (down && wp->w_topline > 1) { if (down && wp->w_topline > 1) {
--wp->w_topline; --wp->w_topline;
wp->w_topfill = 0; wp->w_topfill = 0;
} else { } else {
wp->w_topfill = wp->w_height - n; wp->w_topfill = wp->w_grid.Rows - n;
if (wp->w_topfill < 0) if (wp->w_topfill < 0)
wp->w_topfill = 0; wp->w_topfill = 0;
} }
@@ -1104,12 +1105,12 @@ check_topfill (
static void max_topfill(void) static void max_topfill(void)
{ {
int n = plines_nofill(curwin->w_topline); int n = plines_nofill(curwin->w_topline);
if (n >= curwin->w_height) if (n >= curwin->w_grid.Rows)
curwin->w_topfill = 0; curwin->w_topfill = 0;
else { else {
curwin->w_topfill = diff_check_fill(curwin, curwin->w_topline); curwin->w_topfill = diff_check_fill(curwin, curwin->w_topline);
if (curwin->w_topfill + n > curwin->w_height) if (curwin->w_topfill + n > curwin->w_grid.Rows)
curwin->w_topfill = curwin->w_height - n; curwin->w_topfill = curwin->w_grid.Rows - n;
} }
} }
@@ -1140,14 +1141,14 @@ void scrolldown_clamp(void)
else else
end_row += plines_nofill(curwin->w_topline - 1); end_row += plines_nofill(curwin->w_topline - 1);
if (curwin->w_p_wrap if (curwin->w_p_wrap
&& curwin->w_width != 0 && curwin->w_grid.Columns != 0
) { ) {
validate_cheight(); validate_cheight();
validate_virtcol(); validate_virtcol();
end_row += curwin->w_cline_height - 1 - end_row += curwin->w_cline_height - 1 -
curwin->w_virtcol / curwin->w_width; curwin->w_virtcol / curwin->w_grid.Columns;
} }
if (end_row < curwin->w_height - p_so) { if (end_row < curwin->w_grid.Rows - p_so) {
if (can_fill) { if (can_fill) {
++curwin->w_topfill; ++curwin->w_topfill;
check_topfill(curwin, true); check_topfill(curwin, true);
@@ -1182,10 +1183,10 @@ void scrollup_clamp(void)
int start_row = curwin->w_wrow - plines_nofill(curwin->w_topline) int start_row = curwin->w_wrow - plines_nofill(curwin->w_topline)
- curwin->w_topfill; - curwin->w_topfill;
if (curwin->w_p_wrap if (curwin->w_p_wrap
&& curwin->w_width != 0 && curwin->w_grid.Columns != 0
) { ) {
validate_virtcol(); validate_virtcol();
start_row -= curwin->w_virtcol / curwin->w_width; start_row -= curwin->w_virtcol / curwin->w_grid.Columns;
} }
if (start_row >= p_so) { if (start_row >= p_so) {
if (curwin->w_topfill > 0) if (curwin->w_topfill > 0)
@@ -1339,7 +1340,7 @@ void scroll_cursor_top(int min_scroll, int always)
else else
used += plines(bot); used += plines(bot);
} }
if (used > curwin->w_height) if (used > curwin->w_grid.Rows)
break; break;
if (top < curwin->w_topline) if (top < curwin->w_topline)
scrolled += i; scrolled += i;
@@ -1362,7 +1363,7 @@ void scroll_cursor_top(int min_scroll, int always)
* This makes sure we get the same position when using "k" and "j" * This makes sure we get the same position when using "k" and "j"
* in a small window. * in a small window.
*/ */
if (used > curwin->w_height) { if (used > curwin->w_grid.Rows) {
scroll_cursor_halfway(false); scroll_cursor_halfway(false);
} else { } else {
/* /*
@@ -1399,7 +1400,7 @@ void set_empty_rows(win_T *wp, int used)
if (used == 0) if (used == 0)
wp->w_empty_rows = 0; /* single line that doesn't fit */ wp->w_empty_rows = 0; /* single line that doesn't fit */
else { else {
wp->w_empty_rows = wp->w_height - used; wp->w_empty_rows = wp->w_grid.Rows - used;
if (wp->w_botline <= wp->w_buffer->b_ml.ml_line_count) { if (wp->w_botline <= wp->w_buffer->b_ml.ml_line_count) {
wp->w_filler_rows = diff_check_fill(wp, wp->w_botline); wp->w_filler_rows = diff_check_fill(wp, wp->w_botline);
if (wp->w_empty_rows > wp->w_filler_rows) if (wp->w_empty_rows > wp->w_filler_rows)
@@ -1442,7 +1443,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
curwin->w_topline = loff.lnum) { curwin->w_topline = loff.lnum) {
loff.lnum = curwin->w_topline; loff.lnum = curwin->w_topline;
topline_back(&loff); topline_back(&loff);
if (loff.height == MAXCOL || used + loff.height > curwin->w_height) if (loff.height == MAXCOL || used + loff.height > curwin->w_grid.Rows)
break; break;
used += loff.height; used += loff.height;
curwin->w_topfill = loff.fill; curwin->w_topfill = loff.fill;
@@ -1504,7 +1505,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
used = MAXCOL; used = MAXCOL;
else else
used += loff.height; used += loff.height;
if (used > curwin->w_height) if (used > curwin->w_grid.Rows)
break; break;
if (loff.lnum >= curwin->w_botline if (loff.lnum >= curwin->w_botline
&& (loff.lnum > curwin->w_botline && (loff.lnum > curwin->w_botline
@@ -1522,7 +1523,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
/* Add one line below */ /* Add one line below */
botline_forw(&boff); botline_forw(&boff);
used += boff.height; used += boff.height;
if (used > curwin->w_height) if (used > curwin->w_grid.Rows)
break; break;
if (extra < ( if (extra < (
mouse_dragging > 0 ? mouse_dragging - 1 : mouse_dragging > 0 ? mouse_dragging - 1 :
@@ -1548,7 +1549,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
if (scrolled <= 0) if (scrolled <= 0)
line_count = 0; line_count = 0;
/* more than a screenfull, don't scroll but redraw */ /* more than a screenfull, don't scroll but redraw */
else if (used > curwin->w_height) else if (used > curwin->w_grid.Rows)
line_count = used; line_count = used;
/* scroll minimal number of lines */ /* scroll minimal number of lines */
else { else {
@@ -1569,7 +1570,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
* Scroll up if the cursor is off the bottom of the screen a bit. * Scroll up if the cursor is off the bottom of the screen a bit.
* Otherwise put it at 1/2 of the screen. * Otherwise put it at 1/2 of the screen.
*/ */
if (line_count >= curwin->w_height && line_count > min_scroll) if (line_count >= curwin->w_grid.Rows && line_count > min_scroll)
scroll_cursor_halfway(false); scroll_cursor_halfway(false);
else else
scrollup(line_count, true); scrollup(line_count, true);
@@ -1611,7 +1612,7 @@ void scroll_cursor_halfway(int atend)
if (boff.lnum < curbuf->b_ml.ml_line_count) { if (boff.lnum < curbuf->b_ml.ml_line_count) {
botline_forw(&boff); botline_forw(&boff);
used += boff.height; used += boff.height;
if (used > curwin->w_height) if (used > curwin->w_grid.Rows)
break; break;
below += boff.height; below += boff.height;
} else { } else {
@@ -1627,7 +1628,7 @@ void scroll_cursor_halfway(int atend)
used = MAXCOL; used = MAXCOL;
else else
used += loff.height; used += loff.height;
if (used > curwin->w_height) if (used > curwin->w_grid.Rows)
break; break;
above += loff.height; above += loff.height;
topline = loff.lnum; topline = loff.lnum;
@@ -1637,7 +1638,7 @@ void scroll_cursor_halfway(int atend)
if (!hasFolding(topline, &curwin->w_topline, NULL)) if (!hasFolding(topline, &curwin->w_topline, NULL))
curwin->w_topline = topline; curwin->w_topline = topline;
curwin->w_topfill = topfill; curwin->w_topfill = topfill;
if (old_topline > curwin->w_topline + curwin->w_height) if (old_topline > curwin->w_topline + curwin->w_grid.Rows)
curwin->w_botfill = false; curwin->w_botfill = false;
check_topfill(curwin, false); check_topfill(curwin, false);
curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP); curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
@@ -1665,7 +1666,7 @@ void cursor_correct(void)
} }
if (curwin->w_topline == 1) { if (curwin->w_topline == 1) {
above_wanted = 0; above_wanted = 0;
int max_off = curwin->w_height / 2; int max_off = curwin->w_grid.Rows / 2;
if (below_wanted > max_off) if (below_wanted > max_off)
below_wanted = max_off; below_wanted = max_off;
} }
@@ -1674,7 +1675,7 @@ void cursor_correct(void)
&& mouse_dragging == 0 && mouse_dragging == 0
) { ) {
below_wanted = 0; below_wanted = 0;
int max_off = (curwin->w_height - 1) / 2; int max_off = (curwin->w_grid.Rows - 1) / 2;
if (above_wanted > max_off) if (above_wanted > max_off)
above_wanted = max_off; above_wanted = max_off;
} }
@@ -1847,7 +1848,7 @@ int onepage(Direction dir, long count)
/* Find the line just above the new topline to get the right line /* Find the line just above the new topline to get the right line
* at the bottom of the window. */ * at the bottom of the window. */
n = 0; n = 0;
while (n <= curwin->w_height && loff.lnum >= 1) { while (n <= curwin->w_grid.Rows && loff.lnum >= 1) {
topline_back(&loff); topline_back(&loff);
if (loff.height == MAXCOL) if (loff.height == MAXCOL)
n = MAXCOL; n = MAXCOL;
@@ -1938,7 +1939,7 @@ int onepage(Direction dir, long count)
*/ */
static void get_scroll_overlap(lineoff_T *lp, int dir) static void get_scroll_overlap(lineoff_T *lp, int dir)
{ {
int min_height = curwin->w_height - 2; int min_height = curwin->w_grid.Rows - 2;
if (lp->fill > 0) if (lp->fill > 0)
lp->height = 1; lp->height = 1;
@@ -1993,11 +1994,11 @@ void halfpage(bool flag, linenr_T Prenum)
int i; int i;
if (Prenum) if (Prenum)
curwin->w_p_scr = (Prenum > curwin->w_height) ? curwin->w_p_scr = (Prenum > curwin->w_grid.Rows) ?
curwin->w_height : Prenum; curwin->w_grid.Rows : Prenum;
assert(curwin->w_p_scr <= INT_MAX); assert(curwin->w_p_scr <= INT_MAX);
int n = curwin->w_p_scr <= curwin->w_height ? (int)curwin->w_p_scr int n = curwin->w_p_scr <= curwin->w_grid.Rows ? (int)curwin->w_p_scr
: curwin->w_height; : curwin->w_grid.Rows;
update_topline(); update_topline();
validate_botline(); validate_botline();

30
src/nvim/normal.c
View File

@@ -3906,14 +3906,14 @@ static bool nv_screengo(oparg_T *oap, int dir, long dist)
col_off1 = curwin_col_off(); col_off1 = curwin_col_off();
col_off2 = col_off1 - curwin_col_off2(); col_off2 = col_off1 - curwin_col_off2();
width1 = curwin->w_width - col_off1; width1 = curwin->w_grid.Columns - col_off1;
width2 = curwin->w_width - col_off2; width2 = curwin->w_grid.Columns - col_off2;
if (width2 == 0) { if (width2 == 0) {
width2 = 1; // Avoid divide by zero. width2 = 1; // Avoid divide by zero.
} }
if (curwin->w_width != 0) { if (curwin->w_grid.Columns != 0) {
/* /*
* Instead of sticking at the last character of the buffer line we * Instead of sticking at the last character of the buffer line we
* try to stick in the last column of the screen. * try to stick in the last column of the screen.
@@ -4256,7 +4256,7 @@ dozet:
/* "zH" - scroll screen right half-page */ /* "zH" - scroll screen right half-page */
case 'H': case 'H':
cap->count1 *= curwin->w_width / 2; cap->count1 *= curwin->w_grid.Columns / 2;
FALLTHROUGH; FALLTHROUGH;
/* "zh" - scroll screen to the right */ /* "zh" - scroll screen to the right */
@@ -4272,7 +4272,7 @@ dozet:
break; break;
/* "zL" - scroll screen left half-page */ /* "zL" - scroll screen left half-page */
case 'L': cap->count1 *= curwin->w_width / 2; case 'L': cap->count1 *= curwin->w_grid.Columns / 2;
FALLTHROUGH; FALLTHROUGH;
/* "zl" - scroll screen to the left */ /* "zl" - scroll screen to the left */
@@ -4308,7 +4308,7 @@ dozet:
col = 0; /* like the cursor is in col 0 */ col = 0; /* like the cursor is in col 0 */
else else
getvcol(curwin, &curwin->w_cursor, NULL, NULL, &col); getvcol(curwin, &curwin->w_cursor, NULL, NULL, &col);
n = curwin->w_width - curwin_col_off(); n = curwin->w_grid.Columns - curwin_col_off();
if (col + l_p_siso < n) if (col + l_p_siso < n)
col = 0; col = 0;
else else
@@ -5018,7 +5018,7 @@ static void nv_scroll(cmdarg_T *cap)
used -= diff_check_fill(curwin, curwin->w_topline) used -= diff_check_fill(curwin, curwin->w_topline)
- curwin->w_topfill; - curwin->w_topfill;
validate_botline(); /* make sure w_empty_rows is valid */ validate_botline(); /* make sure w_empty_rows is valid */
half = (curwin->w_height - curwin->w_empty_rows + 1) / 2; half = (curwin->w_grid.Rows - curwin->w_empty_rows + 1) / 2;
for (n = 0; curwin->w_topline + n < curbuf->b_ml.ml_line_count; ++n) { for (n = 0; curwin->w_topline + n < curbuf->b_ml.ml_line_count; ++n) {
/* Count half he number of filler lines to be "below this /* Count half he number of filler lines to be "below this
* line" and half to be "above the next line". */ * line" and half to be "above the next line". */
@@ -5033,7 +5033,7 @@ static void nv_scroll(cmdarg_T *cap)
if (hasFolding(curwin->w_topline + n, NULL, &lnum)) if (hasFolding(curwin->w_topline + n, NULL, &lnum))
n = lnum - curwin->w_topline; n = lnum - curwin->w_topline;
} }
if (n > 0 && used > curwin->w_height) if (n > 0 && used > curwin->w_grid.Rows)
--n; --n;
} else { /* (cap->cmdchar == 'H') */ } else { /* (cap->cmdchar == 'H') */
n = cap->count1 - 1; n = cap->count1 - 1;
@@ -6748,9 +6748,9 @@ static void nv_g_cmd(cmdarg_T *cap)
oap->motion_type = kMTCharWise; oap->motion_type = kMTCharWise;
oap->inclusive = false; oap->inclusive = false;
if (curwin->w_p_wrap if (curwin->w_p_wrap
&& curwin->w_width != 0 && curwin->w_grid.Columns != 0
) { ) {
int width1 = curwin->w_width - curwin_col_off(); int width1 = curwin->w_grid.Columns - curwin_col_off();
int width2 = width1 + curwin_col_off2(); int width2 = width1 + curwin_col_off2();
validate_virtcol(); validate_virtcol();
@@ -6763,7 +6763,7 @@ static void nv_g_cmd(cmdarg_T *cap)
* 'relativenumber' is on and lines are wrapping the middle can be more * 'relativenumber' is on and lines are wrapping the middle can be more
* to the left. */ * to the left. */
if (cap->nchar == 'm') if (cap->nchar == 'm')
i += (curwin->w_width - curwin_col_off() i += (curwin->w_grid.Columns - curwin_col_off()
+ ((curwin->w_p_wrap && i > 0) + ((curwin->w_p_wrap && i > 0)
? curwin_col_off2() : 0)) / 2; ? curwin_col_off2() : 0)) / 2;
coladvance((colnr_T)i); coladvance((colnr_T)i);
@@ -6809,11 +6809,11 @@ static void nv_g_cmd(cmdarg_T *cap)
oap->motion_type = kMTCharWise; oap->motion_type = kMTCharWise;
oap->inclusive = true; oap->inclusive = true;
if (curwin->w_p_wrap if (curwin->w_p_wrap
&& curwin->w_width != 0 && curwin->w_grid.Columns != 0
) { ) {
curwin->w_curswant = MAXCOL; /* so we stay at the end */ curwin->w_curswant = MAXCOL; /* so we stay at the end */
if (cap->count1 == 1) { if (cap->count1 == 1) {
int width1 = curwin->w_width - col_off; int width1 = curwin->w_grid.Columns - col_off;
int width2 = width1 + curwin_col_off2(); int width2 = width1 + curwin_col_off2();
validate_virtcol(); validate_virtcol();
@@ -6839,7 +6839,7 @@ static void nv_g_cmd(cmdarg_T *cap)
} else if (nv_screengo(oap, FORWARD, cap->count1 - 1) == false) } else if (nv_screengo(oap, FORWARD, cap->count1 - 1) == false)
clearopbeep(oap); clearopbeep(oap);
} else { } else {
i = curwin->w_leftcol + curwin->w_width - col_off - 1; i = curwin->w_leftcol + curwin->w_grid.Columns - col_off - 1;
coladvance((colnr_T)i); coladvance((colnr_T)i);
/* Make sure we stick in this column. */ /* Make sure we stick in this column. */
@@ -7954,7 +7954,7 @@ static void get_op_vcol(
colnr_T end; colnr_T end;
if (VIsual_mode != Ctrl_V if (VIsual_mode != Ctrl_V
|| (!initial && oap->end.col < curwin->w_width)) { || (!initial && oap->end.col < curwin->w_grid.Columns)) {
return; return;
} }

181
src/nvim/screen.c
View File

@@ -118,7 +118,11 @@
#define MB_FILLER_CHAR '<' /* character used when a double-width character #define MB_FILLER_CHAR '<' /* character used when a double-width character
* doesn't fit. */ * doesn't fit. */
#define W_ENDCOL(wp) (wp->w_width + wp->w_wincol) #define W_ENDCOL(wp) (wp->w_width + wp->w_wincol)
#define W_ENDROW(wp) (wp->w_height + wp->w_winrow)
#define DEFAULT_GRID_HANDLE 1
static match_T search_hl; /* used for 'hlsearch' highlight matching */ static match_T search_hl; /* used for 'hlsearch' highlight matching */
@@ -137,10 +141,6 @@ typedef struct {
} LineState; } LineState;
#define LINE_STATE(p) { p, 0, 0 } #define LINE_STATE(p) { p, 0, 0 }
/// The last handle that was assigned to a ScreenGrid. 1 is reserved for
/// the default_grid.
static int last_handle = 1;
/// Whether to call "ui_call_grid_resize" in win_grid_alloc /// Whether to call "ui_call_grid_resize" in win_grid_alloc
static int send_grid_resize; static int send_grid_resize;
@@ -295,11 +295,11 @@ void update_screen(int type)
redraw_tabline = true; redraw_tabline = true;
} }
FOR_ALL_WINDOWS_IN_TAB(wp, curtab) { FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
if (wp->w_winrow + wp->w_height > valid) { if (W_ENDROW(wp) > valid) {
wp->w_redr_type = NOT_VALID; wp->w_redr_type = NOT_VALID;
wp->w_lines_valid = 0; wp->w_lines_valid = 0;
} }
if (wp->w_winrow + wp->w_height + wp->w_status_height > valid) { if (W_ENDROW(wp) + wp->w_status_height > valid) {
wp->w_redr_status = true; wp->w_redr_status = true;
} }
} }
@@ -313,7 +313,7 @@ void update_screen(int type)
} }
FOR_ALL_WINDOWS_IN_TAB(wp, curtab) { FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
if (wp->w_winrow < msg_scrolled) { if (wp->w_winrow < msg_scrolled) {
if (wp->w_winrow + wp->w_height > msg_scrolled if (W_ENDROW(wp) > msg_scrolled
&& wp->w_redr_type < REDRAW_TOP && wp->w_redr_type < REDRAW_TOP
&& wp->w_lines_valid > 0 && wp->w_lines_valid > 0
&& wp->w_topline == wp->w_lines[0].wl_lnum) { && wp->w_topline == wp->w_lines[0].wl_lnum) {
@@ -321,7 +321,7 @@ void update_screen(int type)
wp->w_redr_type = REDRAW_TOP; wp->w_redr_type = REDRAW_TOP;
} else { } else {
wp->w_redr_type = NOT_VALID; wp->w_redr_type = NOT_VALID;
if (wp->w_winrow + wp->w_height + wp->w_status_height if (W_ENDROW(wp) + wp->w_status_height
<= msg_scrolled) { <= msg_scrolled) {
wp->w_redr_status = TRUE; wp->w_redr_status = TRUE;
} }
@@ -705,8 +705,8 @@ static void win_update(win_T *wp)
if (buf->terminal) { if (buf->terminal) {
terminal_resize(buf->terminal, terminal_resize(buf->terminal,
(uint16_t)(MAX(0, wp->w_width - win_col_off(wp))), (uint16_t)(MAX(0, wp->w_grid.Columns - win_col_off(wp))),
(uint16_t)wp->w_height); (uint16_t)wp->w_grid.Rows);
} }
} else if (buf->b_mod_set } else if (buf->b_mod_set
&& buf->b_mod_xlines != 0 && buf->b_mod_xlines != 0
@@ -1440,7 +1440,7 @@ static void win_update(win_T *wp)
if (wp->w_p_rnu) { if (wp->w_p_rnu) {
// 'relativenumber' set: The text doesn't need to be drawn, but // 'relativenumber' set: The text doesn't need to be drawn, but
// the number column nearly always does. // the number column nearly always does.
(void)win_line(wp, lnum, srow, wp->w_height, true, true); (void)win_line(wp, lnum, srow, wp->w_grid.Rows, true, true);
} }
// 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.
@@ -1501,7 +1501,7 @@ static void win_update(win_T *wp)
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"
// 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_height - 1, wp->w_height, grid_fill(&wp->w_grid, wp->w_grid.Rows - 1, wp->w_grid.Rows,
wp->w_grid.Columns - 3, wp->w_grid.Columns, '@', '@', at_attr); wp->w_grid.Columns - 3, wp->w_grid.Columns, '@', '@', at_attr);
set_empty_rows(wp, srow); set_empty_rows(wp, srow);
wp->w_botline = lnum; wp->w_botline = lnum;
@@ -1531,7 +1531,7 @@ static void win_update(win_T *wp)
// make sure the rest of the screen is blank // make sure the rest of the screen is blank
// write the 'fill_eob' character to rows that aren't part of the file. // write the 'fill_eob' character to rows that aren't part of the file.
win_draw_end(wp, fill_eob, ' ', row, wp->w_height, HLF_EOB); win_draw_end(wp, fill_eob, ' ', row, wp->w_grid.Rows, HLF_EOB);
} }
if (wp->w_redr_type >= REDRAW_TOP) { if (wp->w_redr_type >= REDRAW_TOP) {
@@ -1611,8 +1611,8 @@ static void win_draw_end(win_T *wp, int c1, int c2, int row, int endrow, hlf_T h
if (n > 0) { if (n > 0) {
/* draw the fold column at the right */ /* draw the fold column at the right */
if (n > wp->w_width) if (n > wp->w_grid.Columns)
n = wp->w_width; n = wp->w_grid.Columns;
grid_fill(&wp->w_grid, row, endrow, wp->w_grid.Columns - n, grid_fill(&wp->w_grid, row, endrow, wp->w_grid.Columns - n,
wp->w_grid.Columns, ' ', ' ', win_hl_attr(wp, HLF_FC)); wp->w_grid.Columns, ' ', ' ', win_hl_attr(wp, HLF_FC));
} }
@@ -1621,8 +1621,8 @@ static void win_draw_end(win_T *wp, int c1, int c2, int row, int endrow, hlf_T h
int nn = n + win_signcol_width(wp); int nn = n + win_signcol_width(wp);
/* draw the sign column left of the fold column */ /* draw the sign column left of the fold column */
if (nn > wp->w_width) { if (nn > wp->w_grid.Columns) {
nn = wp->w_width; nn = wp->w_grid.Columns;
} }
grid_fill(&wp->w_grid, row, endrow, wp->w_grid.Columns - nn, grid_fill(&wp->w_grid, row, endrow, wp->w_grid.Columns - nn,
wp->w_grid.Columns - n, ' ', ' ', win_hl_attr(wp, HLF_SC)); wp->w_grid.Columns - n, ' ', ' ', win_hl_attr(wp, HLF_SC));
@@ -1638,8 +1638,8 @@ static void win_draw_end(win_T *wp, int c1, int c2, int row, int endrow, hlf_T h
if (cmdwin_type != 0 && wp == curwin) { if (cmdwin_type != 0 && wp == curwin) {
/* draw the cmdline character in the leftmost column */ /* draw the cmdline character in the leftmost column */
n = 1; n = 1;
if (n > wp->w_width) if (n > wp->w_grid.Columns)
n = wp->w_width; n = wp->w_grid.Columns;
grid_fill(&wp->w_grid, row, endrow, 0, n, cmdwin_type, ' ', grid_fill(&wp->w_grid, row, endrow, 0, n, cmdwin_type, ' ',
win_hl_attr(wp, HLF_AT)); win_hl_attr(wp, HLF_AT));
} }
@@ -1647,8 +1647,8 @@ static void win_draw_end(win_T *wp, int c1, int c2, int row, int endrow, hlf_T h
int nn = n + fdc; int nn = n + fdc;
/* draw the fold column at the left */ /* draw the fold column at the left */
if (nn > wp->w_width) if (nn > wp->w_grid.Columns)
nn = wp->w_width; nn = wp->w_grid.Columns;
grid_fill(&wp->w_grid, row, endrow, n, nn, ' ', ' ', grid_fill(&wp->w_grid, row, endrow, n, nn, ' ', ' ',
win_hl_attr(wp, HLF_FC)); win_hl_attr(wp, HLF_FC));
n = nn; n = nn;
@@ -1658,8 +1658,8 @@ static void win_draw_end(win_T *wp, int c1, int c2, int row, int endrow, hlf_T h
int nn = n + win_signcol_width(wp); int nn = n + win_signcol_width(wp);
/* draw the sign column after the fold column */ /* draw the sign column after the fold column */
if (nn > wp->w_width) { if (nn > wp->w_grid.Columns) {
nn = wp->w_width; nn = wp->w_grid.Columns;
} }
grid_fill(&wp->w_grid, row, endrow, n, nn, ' ', ' ', grid_fill(&wp->w_grid, row, endrow, n, nn, ' ', ' ',
win_hl_attr(wp, HLF_SC)); win_hl_attr(wp, HLF_SC));
@@ -1688,7 +1688,7 @@ static int compute_foldcolumn(win_T *wp, int col)
{ {
int fdc = wp->w_p_fdc; int fdc = wp->w_p_fdc;
int wmw = wp == curwin && p_wmw == 0 ? 1 : p_wmw; int wmw = wp == curwin && p_wmw == 0 ? 1 : p_wmw;
int wwidth = wp->w_width; int wwidth = wp->w_grid.Columns;
if (fdc > wwidth - (col + wmw)) { if (fdc > wwidth - (col + wmw)) {
fdc = wwidth - (col + wmw); fdc = wwidth - (col + wmw);
@@ -2680,7 +2680,7 @@ win_line (
// Rightleft window: process the text in the normal direction, but put // Rightleft window: process the text in the normal direction, but put
// it in grid->ScreenLines[off] from right to left. Start at the // it in grid->ScreenLines[off] from right to left. Start at the
// rightmost column of the window. // rightmost column of the window.
col = wp->w_width - 1; col = grid->Columns - 1;
off += col; off += col;
} }
@@ -2858,7 +2858,7 @@ win_line (
if (wp->w_p_rl) if (wp->w_p_rl)
n_extra = col + 1; n_extra = col + 1;
else else
n_extra = wp->w_width - col; n_extra = grid->Columns - col;
char_attr = win_hl_attr(wp, HLF_DED); char_attr = win_hl_attr(wp, HLF_DED);
} }
if (*p_sbr != NUL && need_showbreak) { if (*p_sbr != NUL && need_showbreak) {
@@ -3129,7 +3129,7 @@ win_line (
* last column. */ * last column. */
if (( if ((
wp->w_p_rl ? (col <= 0) : wp->w_p_rl ? (col <= 0) :
(col >= wp->w_width - 1)) (col >= grid->Columns - 1))
&& (*mb_char2cells)(mb_c) == 2) { && (*mb_char2cells)(mb_c) == 2) {
c = '>'; c = '>';
mb_c = c; mb_c = c;
@@ -3271,7 +3271,7 @@ win_line (
* next line. */ * next line. */
if (( if ((
wp->w_p_rl ? (col <= 0) : wp->w_p_rl ? (col <= 0) :
(col >= wp->w_width - 1)) (col >= grid->Columns - 1))
&& (*mb_char2cells)(mb_c) == 2) { && (*mb_char2cells)(mb_c) == 2) {
c = '>'; c = '>';
mb_c = c; mb_c = c;
@@ -3445,7 +3445,7 @@ win_line (
char_u *p = ptr - (mb_off + 1); char_u *p = ptr - (mb_off + 1);
// TODO: is passing p for start of the line OK? // TODO: is passing p for start of the line OK?
n_extra = win_lbr_chartabsize(wp, line, p, (colnr_T)vcol, NULL) - 1; n_extra = win_lbr_chartabsize(wp, line, p, (colnr_T)vcol, NULL) - 1;
if (c == TAB && n_extra + col > wp->w_width) { if (c == TAB && n_extra + col > grid->Columns) {
n_extra = (int)wp->w_buffer->b_p_ts n_extra = (int)wp->w_buffer->b_p_ts
- vcol % (int)wp->w_buffer->b_p_ts - 1; - vcol % (int)wp->w_buffer->b_p_ts - 1;
} }
@@ -3604,7 +3604,7 @@ win_line (
&& VIsual_mode != Ctrl_V && VIsual_mode != Ctrl_V
&& ( && (
wp->w_p_rl ? (col >= 0) : wp->w_p_rl ? (col >= 0) :
(col < wp->w_width)) (col < grid->Columns))
&& !(noinvcur && !(noinvcur
&& lnum == wp->w_cursor.lnum && lnum == wp->w_cursor.lnum
&& (colnr_T)vcol == wp->w_virtcol))) && (colnr_T)vcol == wp->w_virtcol)))
@@ -3676,7 +3676,7 @@ win_line (
&& vcol < tocol && vcol < tocol
&& ( && (
wp->w_p_rl ? (col >= 0) : wp->w_p_rl ? (col >= 0) :
(col < wp->w_width))) { (col < grid->Columns))) {
c = ' '; c = ' ';
ptr--; // put it back at the NUL ptr--; // put it back at the NUL
} }
@@ -3746,7 +3746,7 @@ win_line (
&& 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 = wp->w_width - col + boguscols - 1; wp->w_wcol = grid->Columns - col + boguscols - 1;
} else { } else {
wp->w_wcol = col - boguscols; wp->w_wcol = col - boguscols;
} }
@@ -3834,7 +3834,7 @@ win_line (
if (col < 0) if (col < 0)
n = 1; n = 1;
} else { } else {
if (col >= wp->w_width) if (col >= grid->Columns)
n = -1; n = -1;
} }
if (n != 0) { if (n != 0) {
@@ -3907,7 +3907,7 @@ win_line (
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 <
wp->w_width * (row - startrow + 1) + v grid->Columns * (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 || do_virttext)) { || diff_hlf != (hlf_T)0 || do_virttext)) {
@@ -3955,7 +3955,7 @@ win_line (
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 < wp->w_width) { while (wp->w_p_rl ? col >= 0 : col < grid->Columns) {
int cells = -1; int cells = -1;
if (do_virttext && !delay_virttext) { if (do_virttext && !delay_virttext) {
if (*s.p == NUL) { if (*s.p == NUL) {
@@ -3969,7 +3969,7 @@ win_line (
} }
} }
if (*s.p != NUL) { if (*s.p != NUL) {
cells = line_putchar(&s, &grid->ScreenLines[off], wp->w_width - col, cells = line_putchar(&s, &grid->ScreenLines[off], grid->Columns - col,
false); false);
} }
} }
@@ -3998,9 +3998,9 @@ win_line (
attr = hl_combine_attr(attr, line_attr); attr = hl_combine_attr(attr, line_attr);
ScreenAttrs[off] = attr; grid->ScreenAttrs[off] = attr;
if (cells == 2) { if (cells == 2) {
ScreenAttrs[off+1] = attr; grid->ScreenAttrs[off+1] = attr;
} }
off += cells * col_stride; off += cells * col_stride;
@@ -4017,7 +4017,7 @@ win_line (
if (wp->w_buffer->terminal) { if (wp->w_buffer->terminal) {
// 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
while (col < wp->w_width) { while (col < grid->Columns) {
schar_from_ascii(grid->ScreenLines[off], ' '); schar_from_ascii(grid->ScreenLines[off], ' ');
grid->ScreenAttrs[off++] = term_attrs[vcol++]; grid->ScreenAttrs[off++] = term_attrs[vcol++];
col++; col++;
@@ -4047,7 +4047,7 @@ win_line (
&& filler_todo <= 0 && filler_todo <= 0
&& ( && (
wp->w_p_rl ? col == 0 : wp->w_p_rl ? col == 0 :
col == wp->w_width - 1) col == grid->Columns - 1)
&& (*ptr != NUL && (*ptr != NUL
|| (wp->w_p_list && lcs_eol_one > 0) || (wp->w_p_list && lcs_eol_one > 0)
|| (n_extra && (c_extra != NUL || *p_extra != NUL)))) { || (n_extra && (c_extra != NUL || *p_extra != NUL)))) {
@@ -4227,7 +4227,7 @@ win_line (
*/ */
if (( if ((
wp->w_p_rl ? (col < 0) : wp->w_p_rl ? (col < 0) :
(col >= wp->w_width)) (col >= grid->Columns))
&& (*ptr != NUL && (*ptr != NUL
|| filler_todo > 0 || filler_todo > 0
|| (wp->w_p_list && lcs_eol != NUL && p_extra != at_end_str) || (wp->w_p_list && lcs_eol != NUL && p_extra != at_end_str)
@@ -4276,7 +4276,7 @@ win_line (
col = 0; col = 0;
off = (unsigned)(grid->Rows * grid->Columns); off = (unsigned)(grid->Rows * grid->Columns);
if (wp->w_p_rl) { if (wp->w_p_rl) {
col = wp->w_width - 1; /* col is not used if breaking! */ col = grid->Columns - 1; /* col is not used if breaking! */
off += col; off += col;
} }
@@ -4586,7 +4586,7 @@ static void draw_vsep_win(win_T *wp, int row)
if (wp->w_vsep_width) { if (wp->w_vsep_width) {
// draw the vertical separator right of this window // draw the vertical separator right of this window
c = fillchar_vsep(wp, &hl); c = fillchar_vsep(wp, &hl);
grid_fill(&default_grid, wp->w_winrow + row, wp->w_winrow + wp->w_height, grid_fill(&default_grid, wp->w_winrow + row, W_ENDROW(wp),
W_ENDCOL(wp), W_ENDCOL(wp) + 1, c, ' ', hl); W_ENDCOL(wp), W_ENDCOL(wp) + 1, c, ' ', hl);
} }
} }
@@ -4905,7 +4905,7 @@ static void win_redr_status(win_T *wp, int ignore_pum)
} }
} }
row = wp->w_winrow + wp->w_height; row = W_ENDROW(wp);
grid_puts(&default_grid, p, row, wp->w_wincol, attr); grid_puts(&default_grid, p, row, wp->w_wincol, attr);
grid_fill(&default_grid, row, row + 1, len + wp->w_wincol, grid_fill(&default_grid, row, row + 1, len + wp->w_wincol,
this_ru_col + wp->w_wincol, fillchar, fillchar, attr); this_ru_col + wp->w_wincol, fillchar, fillchar, attr);
@@ -4927,8 +4927,7 @@ static void win_redr_status(win_T *wp, int ignore_pum)
} else { } else {
fillchar = fillchar_vsep(wp, &attr); fillchar = fillchar_vsep(wp, &attr);
} }
grid_putchar(&default_grid, fillchar, wp->w_winrow + wp->w_height, grid_putchar(&default_grid, fillchar, W_ENDROW(wp), W_ENDCOL(wp), attr);
W_ENDCOL(wp), attr);
} }
busy = FALSE; busy = FALSE;
} }
@@ -5075,7 +5074,7 @@ win_redr_custom (
maxwidth = default_grid.Columns; maxwidth = default_grid.Columns;
use_sandbox = was_set_insecurely((char_u *)"tabline", 0); use_sandbox = was_set_insecurely((char_u *)"tabline", 0);
} else { } else {
row = wp->w_winrow + wp->w_height; row = W_ENDROW(wp);
fillchar = fillchar_status(&attr, wp); fillchar = fillchar_status(&attr, wp);
maxwidth = wp->w_width; maxwidth = wp->w_width;
@@ -5834,7 +5833,7 @@ void grid_fill(ScreenGrid *grid, int start_row, int end_row, int start_col,
} }
} }
if (end_col == Columns) { if (end_col == grid->Columns) {
grid->LineWraps[row] = false; grid->LineWraps[row] = false;
} }
@@ -5886,25 +5885,51 @@ int screen_valid(int doclear)
// TODO(utkarshme): Think of a better name, place // TODO(utkarshme): Think of a better name, place
void win_grid_alloc(win_T *wp, int doclear) void win_grid_alloc(win_T *wp, int doclear)
{ {
if (wp->w_grid.ScreenLines == NULL ScreenGrid *grid = &wp->w_grid;
|| wp->w_grid.Rows != wp->w_height int rows = grid->internal_rows;
|| wp->w_grid.Columns != wp->w_width) { int columns = grid->internal_columns;
grid_alloc(&wp->w_grid, wp->w_height, wp->w_width, doclear); int was_resized = 0;
if (rows == 0) {
rows = wp->w_height;
}
if (columns == 0) {
columns = wp->w_width;
}
if (grid->ScreenLines == NULL
|| grid->Rows != rows
|| grid->Columns != columns) {
grid_alloc(grid, rows, columns, doclear);
win_free_lsize(wp);
win_alloc_lines(wp);
was_resized = true;
}
grid->OffsetRow = wp->w_winrow;
grid->OffsetColumn = wp->w_wincol;
grid_assign_handle(grid);
// send grid resize event if:
// - a grid was just resized
// - screen_resize was called and all grid sizes must be sent
// - the UI wants multigrid event (necessary)
if ((send_grid_resize || was_resized)
&& ui_is_external(kUIMultigrid)) {
ui_call_grid_resize(grid->handle, grid->Columns, grid->Rows);
was_resized = false;
}
}
/// 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 // only assign a grid handle if not already
if (wp->w_grid.handle == 0) { if (grid->handle == 0) {
wp->w_grid.handle = ++last_handle; grid->handle = ++last_grid_handle;
}
wp->w_grid.OffsetRow = wp->w_winrow;
wp->w_grid.OffsetColumn = wp->w_wincol;
wp->w_grid.was_resized = true;
}
if (send_grid_resize || wp->w_grid.was_resized) {
ui_call_grid_resize(wp->w_grid.handle, wp->w_grid.Columns, wp->w_grid.Rows);
wp->w_grid.was_resized = false;
} }
} }
@@ -5999,7 +6024,7 @@ retry:
default_grid.OffsetRow = 0; default_grid.OffsetRow = 0;
default_grid.OffsetColumn = 0; default_grid.OffsetColumn = 0;
default_grid.handle = 1; default_grid.handle = DEFAULT_GRID_HANDLE;
must_redraw = CLEAR; /* need to clear the screen later */ must_redraw = CLEAR; /* need to clear the screen later */
if (doclear) if (doclear)
@@ -6170,7 +6195,7 @@ void setcursor(void)
if (curwin->w_p_rl) { if (curwin->w_p_rl) {
// With 'rightleft' set and the cursor on a double-wide character, // With 'rightleft' set and the cursor on a double-wide character,
// position it on the leftmost column. // position it on the leftmost column.
left_offset = curwin->w_width - curwin->w_wcol left_offset = curwin->w_grid.Columns - curwin->w_wcol
- ((utf_ptr2cells(get_cursor_pos_ptr()) == 2 - ((utf_ptr2cells(get_cursor_pos_ptr()) == 2
&& vim_isprintc(gchar_cursor())) ? 2 : 1); && vim_isprintc(gchar_cursor())) ? 2 : 1);
} }
@@ -6212,10 +6237,10 @@ static int win_do_lines(win_T *wp, int row, int line_count, int del)
int retval; int retval;
if (del) { if (del) {
retval = grid_del_lines(&wp->w_grid, row, line_count, retval = grid_del_lines(&wp->w_grid, row, line_count,
wp->w_height, 0, wp->w_width); wp->w_grid.Rows, 0, wp->w_grid.Columns);
} else { } else {
retval = grid_ins_lines(&wp->w_grid, row, line_count, retval = grid_ins_lines(&wp->w_grid, row, line_count,
wp->w_height, 0, wp->w_width); wp->w_grid.Rows, 0, wp->w_grid.Columns);
} }
return retval; return retval;
} }
@@ -6232,9 +6257,11 @@ static int win_do_lines(win_T *wp, int row, int line_count, int del)
/// insert lines on the screen and update ScreenLines[] /// insert lines on the screen and update ScreenLines[]
/// 'line_count' is the number of lines to be inserted.
/// 'end' is the line after the scrolled part. Normally it is Rows. /// 'end' is the line after the scrolled part. Normally it is Rows.
/// When scrolling region used 'off' is the offset from the top for the region. /// 'col' is the column from with we start inserting.
/// 'row' and 'end' are relative to the start of the region. //
/// 'row', 'col' and 'end' are relative to the start of the region.
/// ///
/// @return FAIL for failure, OK for success. /// @return FAIL for failure, OK for success.
int grid_ins_lines(ScreenGrid *grid, int row, int line_count, int end, int grid_ins_lines(ScreenGrid *grid, int row, int line_count, int end,
@@ -6915,7 +6942,7 @@ static void win_redr_ruler(win_T *wp, int always)
int off; int off;
if (wp->w_status_height) { if (wp->w_status_height) {
row = wp->w_winrow + wp->w_height; row = W_ENDROW(wp);
fillchar = fillchar_status(&attr, wp); fillchar = fillchar_status(&attr, wp);
off = wp->w_wincol; off = wp->w_wincol;
width = wp->w_width; width = wp->w_width;
@@ -7168,3 +7195,13 @@ void win_new_shellsize(void)
shell_new_columns(); // update window sizes shell_new_columns(); // update window sizes
} }
} }
win_T * get_win_by_grid_handle(GridHandle handle)
{
FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
if (wp->w_grid.handle == handle) {
return wp;
}
}
return NULL;
}

2
src/nvim/search.c
View File

@@ -2167,7 +2167,7 @@ showmatch(
getvcol(curwin, lpos, NULL, &vcol, NULL); getvcol(curwin, lpos, NULL, &vcol, NULL);
} }
if (curwin->w_p_wrap || (vcol >= curwin->w_leftcol if (curwin->w_p_wrap || (vcol >= curwin->w_leftcol
&& vcol < curwin->w_leftcol + curwin->w_width)) { && vcol < curwin->w_leftcol + curwin->w_grid.Columns)) {
mpos = *lpos; /* save the pos, update_screen() may change it */ mpos = *lpos; /* save the pos, update_screen() may change it */
save_cursor = curwin->w_cursor; save_cursor = curwin->w_cursor;
save_so = p_so; save_so = p_so;

4
src/nvim/types.h
View File

@@ -40,7 +40,9 @@ typedef struct {
int OffsetRow; int OffsetRow;
int OffsetColumn; int OffsetColumn;
int was_resized; // the size expected to be allocated to the internal grid
int internal_rows;
int internal_columns;
} ScreenGrid; } ScreenGrid;
#endif // NVIM_TYPES_H #endif // NVIM_TYPES_H

32
src/nvim/ui.c
View File

@@ -57,7 +57,7 @@ static int busy = 0;
static int mode_idx = SHAPE_IDX_N; static int mode_idx = SHAPE_IDX_N;
static bool pending_mode_info_update = false; static bool pending_mode_info_update = false;
static bool pending_mode_update = false; static bool pending_mode_update = false;
static GridHandle cursor_grid_handle = 1; static GridHandle cursor_grid_handle = DEFAULT_GRID_HANDLE;
#if MIN_LOG_LEVEL > DEBUG_LOG_LEVEL #if MIN_LOG_LEVEL > DEBUG_LOG_LEVEL
# define UI_LOG(funname, ...) # define UI_LOG(funname, ...)
@@ -197,13 +197,6 @@ void ui_refresh(void)
row = col = 0; row = col = 0;
pending_cursor_update = true; pending_cursor_update = true;
ui_default_colors_set();
int save_p_lz = p_lz;
p_lz = false; // convince redrawing() to return true ...
screen_resize(width, height);
p_lz = save_p_lz;
for (UIExtension i = 0; (int)i < kUIExtCount; i++) { for (UIExtension i = 0; (int)i < kUIExtCount; i++) {
ui_ext[i] = ext_widgets[i]; ui_ext[i] = ext_widgets[i];
if (i < kUIGlobalCount) { if (i < kUIGlobalCount) {
@@ -211,6 +204,14 @@ void ui_refresh(void)
BOOLEAN_OBJ(ext_widgets[i])); BOOLEAN_OBJ(ext_widgets[i]));
} }
} }
ui_default_colors_set();
int save_p_lz = p_lz;
p_lz = false; // convince redrawing() to return true ...
screen_resize(width, height);
p_lz = save_p_lz;
ui_mode_info_set(); ui_mode_info_set();
pending_mode_update = true; pending_mode_update = true;
ui_cursor_shape(); ui_cursor_shape();
@@ -437,3 +438,18 @@ Array ui_array(void)
} }
return all_uis; return all_uis;
} }
void ui_grid_resize(GridHandle grid_handle, int width, int height)
{
win_T *wp = get_win_by_grid_handle(grid_handle);
if (wp == NULL) {
//TODO(utkarshme): error out
abort();
return;
}
wp->w_grid.internal_rows = (int)height;
wp->w_grid.internal_columns = (int)width;
redraw_win_later(wp, SOME_VALID);
}

6
src/nvim/window.c
View File

@@ -3860,6 +3860,8 @@ static win_T *win_alloc(win_T *after, int hidden)
new_wp->handle = ++last_win_id; new_wp->handle = ++last_win_id;
handle_register_window(new_wp); handle_register_window(new_wp);
grid_assign_handle(&new_wp->w_grid);
// Init w: variables. // Init w: variables.
new_wp->w_vars = tv_dict_alloc(); new_wp->w_vars = tv_dict_alloc();
init_var_dict(new_wp->w_vars, &new_wp->w_winvar, VAR_SCOPE); init_var_dict(new_wp->w_vars, &new_wp->w_winvar, VAR_SCOPE);
@@ -4087,8 +4089,8 @@ static void frame_remove(frame_T *frp)
void win_alloc_lines(win_T *wp) void win_alloc_lines(win_T *wp)
{ {
wp->w_lines_valid = 0; wp->w_lines_valid = 0;
assert(Rows >= 0); assert(wp->w_grid.Rows >= 0);
wp->w_lines = xcalloc(Rows, sizeof(wline_T)); wp->w_lines = xcalloc(wp->w_grid.Rows + 1, sizeof(wline_T));
} }
/* /*