IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #9551 from bfredl/multiterm

Browse Source 
Fix :terminal resizing, and some multigrid size cleanup
This commit is contained in:
Björn Linse 2019-01-27 14:15:08 +01:00 committed by GitHub
commit 8171e96b96
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
25 changed files with 437 additions and 341 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
src/nvim/buffer.c
View File

@ -1472,6 +1472,10 @@ void set_curbuf(buf_T *buf, int action)
if (old_tw != curbuf->b_p_tw)
check_colorcolumn(curwin);
}
if (bufref_valid(&prevbufref) && prevbuf->terminal != NULL) {
terminal_check_size(prevbuf->terminal);
}
}
/*

7
src/nvim/buffer_defs.h
View File

@ -1034,6 +1034,13 @@ struct window_S {
int w_width; /* Width of window, excluding separation. */
int w_vsep_width; /* Number of separator columns (0 or 1). */
// inner size of window, which can be overriden by external UI
int w_height_inner;
int w_width_inner;
// external UI request. If non-zero, the inner size will use this.
int w_height_request;
int w_width_request;
/*
* === start of cached values ====
*/

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

8
src/nvim/cursor.c
View File

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

8
src/nvim/edit.c
View File

@ -566,7 +566,7 @@ static int insert_check(VimState *state)
if (curwin->w_wcol < s->mincol - curbuf->b_p_ts
&& curwin->w_wrow == curwin->w_winrow
+ curwin->w_grid.Rows - 1 - p_so
+ curwin->w_height_inner - 1 - p_so
&& (curwin->w_cursor.lnum != curwin->w_topline
|| curwin->w_topfill > 0)) {
if (curwin->w_topfill > 0) {
@ -5868,7 +5868,7 @@ static void check_auto_format(
/*
* Find out textwidth to be used for formatting:
* if 'textwidth' option is set, use it
* else if 'wrapmargin' option is set, use curwin->w_grid.Columns-'wrapmargin'
* else if 'wrapmargin' option is set, use curwin->w_width_inner-'wrapmargin'
* if invalid value, use 0.
* Set default to window width (maximum 79) for "gq" operator.
*/
@ -5883,7 +5883,7 @@ comp_textwidth (
if (textwidth == 0 && curbuf->b_p_wm) {
/* The width is the window width minus 'wrapmargin' minus all the
* things that add to the margin. */
textwidth = curwin->w_grid.Columns - curbuf->b_p_wm;
textwidth = curwin->w_width_inner - curbuf->b_p_wm;
if (cmdwin_type != 0) {
textwidth -= 1;
}
@ -5899,7 +5899,7 @@ comp_textwidth (
if (textwidth < 0)
textwidth = 0;
if (ff && textwidth == 0) {
textwidth = curwin->w_grid.Columns - 1;
textwidth = curwin->w_width_inner - 1;
if (textwidth > 79) {
textwidth = 79;
}

4
src/nvim/eval.c
View File

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

10
src/nvim/ex_cmds.c
View File

@ -257,7 +257,7 @@ void ex_align(exarg_T *eap)
if (width <= 0)
width = curbuf->b_p_tw;
if (width == 0 && curbuf->b_p_wm > 0) {
width = curwin->w_grid.Columns - curbuf->b_p_wm;
width = curwin->w_width_inner - curbuf->b_p_wm;
}
if (width <= 0) {
width = 80;
@ -2678,6 +2678,10 @@ int do_ecmd(
theend:
if (bufref_valid(&old_curbuf) && old_curbuf.br_buf->terminal != NULL) {
terminal_check_size(old_curbuf.br_buf->terminal);
}
if (did_inc_redrawing_disabled) {
RedrawingDisabled--;
}
@ -2872,11 +2876,11 @@ void ex_z(exarg_T *eap)
// Vi compatible: ":z!" uses display height, without a count uses
// 'scroll'
if (eap->forceit) {
bigness = curwin->w_grid.Rows;
bigness = curwin->w_height_inner;
} else if (ONE_WINDOW) {
bigness = curwin->w_p_scr * 2;
} else {
bigness = curwin->w_grid.Rows - 3;
bigness = curwin->w_height_inner - 3;
}
if (bigness < 1) {
bigness = 1;

6
src/nvim/ex_docmd.c
View File

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

6
src/nvim/getchar.c
View File

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

8
src/nvim/grid_defs.h
View File

@ -48,12 +48,8 @@ typedef struct {
// offsets for the grid relative to the global screen
int row_offset;
int col_offset;
// grid size requested by the UI. Used for window grids only.
int requested_rows;
int requested_cols;
int was_resized;
} ScreenGrid;
#define SCREEN_GRID_INIT { 0, NULL, NULL, NULL, NULL, 0, 0, 0, 0 }
#endif // NVIM_GRID_DEFS_H

2
src/nvim/indent.c
View File

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

12
src/nvim/misc1.c
View File

@ -1251,7 +1251,7 @@ int plines_win_nofill(
return 1;
}
if (wp->w_grid.Columns == 0) {
if (wp->w_width_inner == 0) {
return 1;
}
@ -1261,8 +1261,8 @@ int plines_win_nofill(
}
const int lines = plines_win_nofold(wp, lnum);
if (winheight && lines > wp->w_grid.Rows) {
return wp->w_grid.Rows;
if (winheight && lines > wp->w_height_inner) {
return wp->w_height_inner;
}
return lines;
}
@ -1292,7 +1292,7 @@ int plines_win_nofold(win_T *wp, linenr_T lnum)
/*
* Add column offset for 'number', 'relativenumber' and 'foldcolumn'.
*/
width = wp->w_grid.Columns - win_col_off(wp);
width = wp->w_width_inner - win_col_off(wp);
if (width <= 0 || col > 32000) {
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)
return lines + 1;
if (wp->w_grid.Columns == 0) {
if (wp->w_width_inner == 0) {
return lines + 1;
}
@ -1341,7 +1341,7 @@ int plines_win_col(win_T *wp, linenr_T lnum, long column)
}
// Add column offset for 'number', 'relativenumber', 'foldcolumn', etc.
int width = wp->w_grid.Columns - win_col_off(wp);
int width = wp->w_width_inner - win_col_off(wp);
if (width <= 0) {
return 9999;
}

18
src/nvim/mouse.c
View File

@ -164,7 +164,7 @@ retnomove:
|| (!on_status_line
&& !on_sep_line
&& (wp->w_p_rl
? col < wp->w_grid.Columns - wp->w_p_fdc
? col < wp->w_width_inner - wp->w_p_fdc
: col >= wp->w_p_fdc + (cmdwin_type == 0 && wp == curwin
? 0 : 1))
&& (flags & MOUSE_MAY_STOP_VIS)))) {
@ -258,7 +258,7 @@ retnomove:
~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
redraw_later(VALID);
row = 0;
} else if (row >= curwin->w_grid.Rows) {
} else if (row >= curwin->w_height_inner) {
count = 0;
for (first = true; curwin->w_topline < curbuf->b_ml.ml_line_count; ) {
if (curwin->w_topfill > 0) {
@ -267,7 +267,7 @@ retnomove:
count += plines(curwin->w_topline);
}
if (!first && count > row - curwin->w_grid.Rows + 1) {
if (!first && count > row - curwin->w_height_inner + 1) {
break;
}
first = false;
@ -289,7 +289,7 @@ retnomove:
redraw_later(VALID);
curwin->w_valid &=
~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
row = curwin->w_grid.Rows - 1;
row = curwin->w_height_inner - 1;
} else if (row == 0) {
// When dragging the mouse, while the text has been scrolled up as
// far as it goes, moving the mouse in the top line should scroll
@ -304,7 +304,7 @@ retnomove:
}
// Check for position outside of the fold column.
if (curwin->w_p_rl ? col < curwin->w_grid.Columns - curwin->w_p_fdc :
if (curwin->w_p_rl ? col < curwin->w_width_inner - curwin->w_p_fdc :
col >= curwin->w_p_fdc + (cmdwin_type == 0 ? 0 : 1)) {
mouse_char = ' ';
}
@ -371,7 +371,7 @@ bool mouse_comp_pos(win_T *win, int *rowp, int *colp, linenr_T *lnump)
int count;
if (win->w_p_rl) {
col = win->w_grid.Columns - 1 - col;
col = win->w_width_inner - 1 - col;
}
lnum = win->w_topline;
@ -409,7 +409,7 @@ bool mouse_comp_pos(win_T *win, int *rowp, int *colp, linenr_T *lnump)
off = win_col_off(win) - win_col_off2(win);
if (col < off)
col = off;
col += row * (win->w_grid.Columns - off);
col += row * (win->w_width_inner - off);
// add skip column (for long wrapping line)
col += win->w_skipcol;
}
@ -622,7 +622,7 @@ bool mouse_scroll_horiz(int dir)
int step = 6;
if (mod_mask & (MOD_MASK_SHIFT | MOD_MASK_CTRL)) {
step = curwin->w_grid.Columns;
step = curwin->w_width_inner;
}
int leftcol = curwin->w_leftcol + (dir == MSCR_RIGHT ? -step : +step);
@ -674,7 +674,7 @@ static int mouse_adjust_click(win_T *wp, int row, int col)
// Find the offset where scanning should begin.
int offset = wp->w_leftcol;
if (row > 0) {
offset += row * (wp->w_grid.Columns - win_col_off(wp) - win_col_off2(wp) -
offset += row * (wp->w_width_inner - win_col_off(wp) - win_col_off2(wp) -
wp->w_leftcol + wp->w_skipcol);
}

127
src/nvim/move.c
View File

@ -83,7 +83,7 @@ static void comp_botline(win_T *wp)
redraw_for_cursorline(wp);
wp->w_valid |= (VALID_CROW|VALID_CHEIGHT);
}
if (done + n > wp->w_grid.Rows) {
if (done + n > wp->w_height_inner) {
break;
}
done += n;
@ -150,12 +150,9 @@ void update_topline(void)
bool check_botline = false;
long save_so = p_so;
// need to have w_grid.Rows/Columns updated
win_grid_alloc(curwin);
// If there is no valid screen and when the window height is zero just use
// the cursor line.
if (!screen_valid(true) || curwin->w_grid.Rows == 0) {
if (!screen_valid(true) || curwin->w_height_inner == 0) {
curwin->w_topline = curwin->w_cursor.lnum;
curwin->w_botline = curwin->w_topline;
curwin->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
@ -204,7 +201,7 @@ void update_topline(void)
check_topline = true;
if (check_topline) {
int halfheight = curwin->w_grid.Rows / 2 - 1;
int halfheight = curwin->w_height_inner / 2 - 1;
if (halfheight < 2) {
halfheight = 2;
}
@ -297,7 +294,7 @@ void update_topline(void)
lnum >= curwin->w_botline - p_so; lnum--) {
line_count++;
// stop at end of file or when we know we are far off
if (lnum <= 0 || line_count > curwin->w_grid.Rows + 1) {
if (lnum <= 0 || line_count > curwin->w_height_inner + 1) {
break;
}
(void)hasFolding(lnum, &lnum, NULL);
@ -305,7 +302,7 @@ void update_topline(void)
} else
line_count = curwin->w_cursor.lnum - curwin->w_botline
+ 1 + p_so;
if (line_count <= curwin->w_grid.Rows + 1) {
if (line_count <= curwin->w_height_inner + 1) {
scroll_cursor_bot(scrolljump_value(), false);
} else {
scroll_cursor_halfway(false);
@ -353,7 +350,7 @@ void update_topline_win(win_T* win)
*/
static int scrolljump_value(void)
{
long result = p_sj >= 0 ? p_sj : (curwin->w_grid.Rows * -p_sj) / 100;
long result = p_sj >= 0 ? p_sj : (curwin->w_height_inner * -p_sj) / 100;
assert(result <= INT_MAX);
return (int)result;
}
@ -529,7 +526,6 @@ int cursor_valid(void)
*/
void validate_cursor(void)
{
win_grid_alloc(curwin); // we need to have w_grid.Rows/Columns updated
check_cursor_moved(curwin);
if ((curwin->w_valid & (VALID_WCOL|VALID_WROW)) != (VALID_WCOL|VALID_WROW))
curs_columns(true);
@ -668,13 +664,13 @@ void validate_cursor_col(void)
colnr_T col = curwin->w_virtcol;
colnr_T off = curwin_col_off();
col += off;
int width = curwin->w_grid.Columns - off + curwin_col_off2();
int width = curwin->w_width_inner - off + curwin_col_off2();
// long line wrapping, adjust curwin->w_wrow
if (curwin->w_p_wrap && col >= (colnr_T)curwin->w_grid.Columns
if (curwin->w_p_wrap && col >= (colnr_T)curwin->w_width_inner
&& width > 0) {
// use same formula as what is used in curs_columns()
col -= ((col - curwin->w_grid.Columns) / width + 1) * width;
col -= ((col - curwin->w_width_inner) / width + 1) * width;
}
if (col > (int)curwin->w_leftcol) {
col -= curwin->w_leftcol;
@ -769,20 +765,20 @@ void curs_columns(
*/
curwin->w_wrow = curwin->w_cline_row;
int textwidth = curwin->w_grid.Columns - extra;
int textwidth = curwin->w_width_inner - extra;
if (textwidth <= 0) {
// No room for text, put cursor in last char of window.
curwin->w_wcol = curwin->w_grid.Columns - 1;
curwin->w_wrow = curwin->w_grid.Rows - 1;
curwin->w_wcol = curwin->w_width_inner - 1;
curwin->w_wrow = curwin->w_height_inner - 1;
} else if (curwin->w_p_wrap
&& curwin->w_grid.Columns != 0
&& curwin->w_width_inner != 0
) {
width = textwidth + curwin_col_off2();
// long line wrapping, adjust curwin->w_wrow
if (curwin->w_wcol >= curwin->w_grid.Columns) {
if (curwin->w_wcol >= curwin->w_width_inner) {
// this same formula is used in validate_cursor_col()
n = (curwin->w_wcol - curwin->w_grid.Columns) / width + 1;
n = (curwin->w_wcol - curwin->w_width_inner) / width + 1;
curwin->w_wcol -= n * width;
curwin->w_wrow += n;
@ -809,7 +805,7 @@ void curs_columns(
assert(p_siso <= INT_MAX);
int off_left = startcol - curwin->w_leftcol - (int)p_siso;
int off_right =
endcol - curwin->w_leftcol - curwin->w_grid.Columns + (int)p_siso + 1;
endcol - curwin->w_leftcol - curwin->w_width_inner + (int)p_siso + 1;
if (off_left < 0 || off_right > 0) {
int diff = (off_left < 0) ? -off_left: off_right;
@ -852,16 +848,16 @@ void curs_columns(
prev_skipcol = curwin->w_skipcol;
int p_lines = 0;
if ((curwin->w_wrow >= curwin->w_grid.Rows
if ((curwin->w_wrow >= curwin->w_height_inner
|| ((prev_skipcol > 0
|| curwin->w_wrow + p_so >= curwin->w_grid.Rows)
|| curwin->w_wrow + p_so >= curwin->w_height_inner)
&& (p_lines =
plines_win_nofill(curwin, curwin->w_cursor.lnum, false)) - 1
>= curwin->w_grid.Rows))
&& curwin->w_grid.Rows != 0
>= curwin->w_height_inner))
&& curwin->w_height_inner != 0
&& curwin->w_cursor.lnum == curwin->w_topline
&& width > 0
&& curwin->w_grid.Columns != 0
&& curwin->w_width_inner != 0
) {
/* 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
@ -883,21 +879,21 @@ void curs_columns(
}
else
n = p_lines;
if ((colnr_T)n >= curwin->w_grid.Rows + curwin->w_skipcol / width) {
if ((colnr_T)n >= curwin->w_height_inner + curwin->w_skipcol / width) {
extra += 2;
}
if (extra == 3 || p_lines < p_so * 2) {
// not enough room for 'scrolloff', put cursor in the middle
n = curwin->w_virtcol / width;
if (n > curwin->w_grid.Rows / 2) {
n -= curwin->w_grid.Rows / 2;
if (n > curwin->w_height_inner / 2) {
n -= curwin->w_height_inner / 2;
} else {
n = 0;
}
// don't skip more than necessary
if (n > p_lines - curwin->w_grid.Rows + 1) {
n = p_lines - curwin->w_grid.Rows + 1;
if (n > p_lines - curwin->w_height_inner + 1) {
n = p_lines - curwin->w_height_inner + 1;
}
curwin->w_skipcol = n * width;
} else if (extra == 1) {
@ -912,7 +908,7 @@ void curs_columns(
}
} else if (extra == 2) {
// less then 'scrolloff' lines below, increase skipcol
endcol = (n - curwin->w_grid.Rows + 1) * width;
endcol = (n - curwin->w_height_inner + 1) * width;
while (endcol > curwin->w_virtcol) {
endcol -= width;
}
@ -922,9 +918,9 @@ void curs_columns(
}
curwin->w_wrow -= curwin->w_skipcol / width;
if (curwin->w_wrow >= curwin->w_grid.Rows) {
if (curwin->w_wrow >= curwin->w_height_inner) {
// small window, make sure cursor is in it
extra = curwin->w_wrow - curwin->w_grid.Rows + 1;
extra = curwin->w_wrow - curwin->w_height_inner + 1;
curwin->w_skipcol += extra * width;
curwin->w_wrow -= extra;
}
@ -966,7 +962,7 @@ scrolldown (
validate_cursor(); /* w_wrow needs to be valid */
while (line_count-- > 0) {
if (curwin->w_topfill < diff_check(curwin, curwin->w_topline)
&& curwin->w_topfill < curwin->w_grid.Rows - 1) {
&& curwin->w_topfill < curwin->w_height_inner - 1) {
curwin->w_topfill++;
done++;
} else {
@ -1001,15 +997,15 @@ scrolldown (
*/
int wrow = curwin->w_wrow;
if (curwin->w_p_wrap
&& curwin->w_grid.Columns != 0
&& curwin->w_width_inner != 0
) {
validate_virtcol();
validate_cheight();
wrow += curwin->w_cline_height - 1 -
curwin->w_virtcol / curwin->w_grid.Columns;
curwin->w_virtcol / curwin->w_width_inner;
}
bool moved = false;
while (wrow >= curwin->w_grid.Rows && curwin->w_cursor.lnum > 1) {
while (wrow >= curwin->w_height_inner && curwin->w_cursor.lnum > 1) {
linenr_T first;
if (hasFolding(curwin->w_cursor.lnum, &first, NULL)) {
--wrow;
@ -1094,12 +1090,12 @@ check_topfill (
{
if (wp->w_topfill > 0) {
int n = plines_win_nofill(wp, wp->w_topline, true);
if (wp->w_topfill + n > wp->w_grid.Rows) {
if (wp->w_topfill + n > wp->w_height_inner) {
if (down && wp->w_topline > 1) {
--wp->w_topline;
wp->w_topfill = 0;
} else {
wp->w_topfill = wp->w_grid.Rows - n;
wp->w_topfill = wp->w_height_inner - n;
if (wp->w_topfill < 0) {
wp->w_topfill = 0;
}
@ -1115,12 +1111,12 @@ check_topfill (
static void max_topfill(void)
{
int n = plines_nofill(curwin->w_topline);
if (n >= curwin->w_grid.Rows) {
if (n >= curwin->w_height_inner) {
curwin->w_topfill = 0;
} else {
curwin->w_topfill = diff_check_fill(curwin, curwin->w_topline);
if (curwin->w_topfill + n > curwin->w_grid.Rows) {
curwin->w_topfill = curwin->w_grid.Rows - n;
if (curwin->w_topfill + n > curwin->w_height_inner) {
curwin->w_topfill = curwin->w_height_inner - n;
}
}
}
@ -1152,14 +1148,14 @@ void scrolldown_clamp(void)
else
end_row += plines_nofill(curwin->w_topline - 1);
if (curwin->w_p_wrap
&& curwin->w_grid.Columns != 0
&& curwin->w_width_inner != 0
) {
validate_cheight();
validate_virtcol();
end_row += curwin->w_cline_height - 1 -
curwin->w_virtcol / curwin->w_grid.Columns;
curwin->w_virtcol / curwin->w_width_inner;
}
if (end_row < curwin->w_grid.Rows - p_so) {
if (end_row < curwin->w_height_inner - p_so) {
if (can_fill) {
++curwin->w_topfill;
check_topfill(curwin, true);
@ -1194,10 +1190,10 @@ void scrollup_clamp(void)
int start_row = curwin->w_wrow - plines_nofill(curwin->w_topline)
- curwin->w_topfill;
if (curwin->w_p_wrap
&& curwin->w_grid.Columns != 0
&& curwin->w_width_inner != 0
) {
validate_virtcol();
start_row -= curwin->w_virtcol / curwin->w_grid.Columns;
start_row -= curwin->w_virtcol / curwin->w_width_inner;
}
if (start_row >= p_so) {
if (curwin->w_topfill > 0)
@ -1351,7 +1347,7 @@ void scroll_cursor_top(int min_scroll, int always)
else
used += plines(bot);
}
if (used > curwin->w_grid.Rows) {
if (used > curwin->w_height_inner) {
break;
}
if (top < curwin->w_topline) {
@ -1376,7 +1372,7 @@ void scroll_cursor_top(int min_scroll, int always)
* This makes sure we get the same position when using "k" and "j"
* in a small window.
*/
if (used > curwin->w_grid.Rows) {
if (used > curwin->w_height_inner) {
scroll_cursor_halfway(false);
} else {
/*
@ -1413,7 +1409,7 @@ void set_empty_rows(win_T *wp, int used)
if (used == 0) {
wp->w_empty_rows = 0; // single line that doesn't fit
} else {
wp->w_empty_rows = wp->w_grid.Rows - used;
wp->w_empty_rows = wp->w_height_inner - used;
if (wp->w_botline <= wp->w_buffer->b_ml.ml_line_count) {
wp->w_filler_rows = diff_check_fill(wp, wp->w_botline);
if (wp->w_empty_rows > wp->w_filler_rows)
@ -1456,7 +1452,8 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
curwin->w_topline = loff.lnum) {
loff.lnum = curwin->w_topline;
topline_back(&loff);
if (loff.height == MAXCOL || used + loff.height > curwin->w_grid.Rows) {
if (loff.height == MAXCOL
|| used + loff.height > curwin->w_height_inner) {
break;
}
used += loff.height;
@ -1520,7 +1517,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
} else {
used += loff.height;
}
if (used > curwin->w_grid.Rows) {
if (used > curwin->w_height_inner) {
break;
}
if (loff.lnum >= curwin->w_botline
@ -1539,7 +1536,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
/* Add one line below */
botline_forw(&boff);
used += boff.height;
if (used > curwin->w_grid.Rows) {
if (used > curwin->w_height_inner) {
break;
}
if (extra < (
@ -1566,7 +1563,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
if (scrolled <= 0) {
line_count = 0;
// more than a screenfull, don't scroll but redraw
} else if (used > curwin->w_grid.Rows) {
} else if (used > curwin->w_height_inner) {
line_count = used;
// scroll minimal number of lines
} else {
@ -1587,7 +1584,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.
* Otherwise put it at 1/2 of the screen.
*/
if (line_count >= curwin->w_grid.Rows && line_count > min_scroll) {
if (line_count >= curwin->w_height_inner && line_count > min_scroll) {
scroll_cursor_halfway(false);
} else {
scrollup(line_count, true);
@ -1630,7 +1627,7 @@ void scroll_cursor_halfway(int atend)
if (boff.lnum < curbuf->b_ml.ml_line_count) {
botline_forw(&boff);
used += boff.height;
if (used > curwin->w_grid.Rows) {
if (used > curwin->w_height_inner) {
break;
}
below += boff.height;
@ -1647,7 +1644,7 @@ void scroll_cursor_halfway(int atend)
used = MAXCOL;
else
used += loff.height;
if (used > curwin->w_grid.Rows) {
if (used > curwin->w_height_inner) {
break;
}
above += loff.height;
@ -1658,7 +1655,7 @@ void scroll_cursor_halfway(int atend)
if (!hasFolding(topline, &curwin->w_topline, NULL))
curwin->w_topline = topline;
curwin->w_topfill = topfill;
if (old_topline > curwin->w_topline + curwin->w_grid.Rows) {
if (old_topline > curwin->w_topline + curwin->w_height_inner) {
curwin->w_botfill = false;
}
check_topfill(curwin, false);
@ -1687,7 +1684,7 @@ void cursor_correct(void)
}
if (curwin->w_topline == 1) {
above_wanted = 0;
int max_off = curwin->w_grid.Rows / 2;
int max_off = curwin->w_height_inner / 2;
if (below_wanted > max_off) {
below_wanted = max_off;
}
@ -1697,7 +1694,7 @@ void cursor_correct(void)
&& mouse_dragging == 0
) {
below_wanted = 0;
int max_off = (curwin->w_grid.Rows - 1) / 2;
int max_off = (curwin->w_height_inner - 1) / 2;
if (above_wanted > max_off) {
above_wanted = max_off;
}
@ -1871,7 +1868,7 @@ int onepage(Direction dir, long count)
/* Find the line just above the new topline to get the right line
* at the bottom of the window. */
n = 0;
while (n <= curwin->w_grid.Rows && loff.lnum >= 1) {
while (n <= curwin->w_height_inner && loff.lnum >= 1) {
topline_back(&loff);
if (loff.height == MAXCOL)
n = MAXCOL;
@ -1962,7 +1959,7 @@ int onepage(Direction dir, long count)
*/
static void get_scroll_overlap(lineoff_T *lp, int dir)
{
int min_height = curwin->w_grid.Rows - 2;
int min_height = curwin->w_height_inner - 2;
if (lp->fill > 0)
lp->height = 1;
@ -2017,12 +2014,12 @@ void halfpage(bool flag, linenr_T Prenum)
int i;
if (Prenum) {
curwin->w_p_scr = (Prenum > curwin->w_grid.Rows) ? curwin->w_grid.Rows
curwin->w_p_scr = (Prenum > curwin->w_height_inner) ? curwin->w_height_inner
: Prenum;
}
assert(curwin->w_p_scr <= INT_MAX);
int n = curwin->w_p_scr <= curwin->w_grid.Rows ? (int)curwin->w_p_scr
: curwin->w_grid.Rows;
int n = curwin->w_p_scr <= curwin->w_height_inner ? (int)curwin->w_p_scr
: curwin->w_height_inner;
update_topline();
validate_botline();

30
src/nvim/normal.c
View File

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

2
src/nvim/option.c
View File

@ -4339,7 +4339,7 @@ static char *set_num_option(int opt_idx, char_u *varp, long value,
} else if (pp == &curbuf->b_p_scbk || pp == &p_scbk) {
if (curbuf->terminal) {
// Force the scrollback to take effect.
terminal_resize(curbuf->terminal, UINT16_MAX, UINT16_MAX);
terminal_check_size(curbuf->terminal);
}
} else if (pp == &curwin->w_p_nuw) {
curwin->w_nrwidth_line_count = 0;

105
src/nvim/screen.c
View File

@ -324,7 +324,7 @@ void update_screen(int type)
wp->w_redr_status = true;
}
}
} else if (msg_scrolled > default_grid.Rows - 5) { // clearing is faster
} else if (msg_scrolled > Rows - 5) { // clearing is faster
type = CLEAR;
} else if (type != CLEAR) {
check_for_delay(false);
@ -629,9 +629,7 @@ static void win_update(win_T *wp)
wp->w_nrwidth = i;
if (buf->terminal) {
terminal_resize(buf->terminal,
(uint16_t)(MAX(0, wp->w_grid.Columns - win_col_off(wp))),
(uint16_t)wp->w_grid.Rows);
terminal_check_size(buf->terminal);
}
} else if (buf->b_mod_set
&& buf->b_mod_xlines != 0
@ -4629,8 +4627,7 @@ win_redr_status_matches (
if (matches == NULL) /* interrupted completion? */
return;
buf = xmalloc(has_mbyte ? default_grid.Columns * MB_MAXBYTES + 1
: default_grid.Columns + 1);
buf = xmalloc(Columns * MB_MAXBYTES + 1);
if (match == -1) { /* don't show match but original text */
match = 0;
@ -4651,13 +4648,13 @@ win_redr_status_matches (
if (first_match > 0)
clen += 2;
// jumping right, put match at the left
if ((long)clen > default_grid.Columns) {
if ((long)clen > Columns) {
first_match = match;
/* if showing the last match, we can add some on the left */
clen = 2;
for (i = match; i < num_matches; ++i) {
clen += status_match_len(xp, L_MATCH(i)) + 2;
if ((long)clen >= default_grid.Columns) {
if ((long)clen >= Columns) {
break;
}
}
@ -4668,7 +4665,7 @@ win_redr_status_matches (
if (add_left)
while (first_match > 0) {
clen += status_match_len(xp, L_MATCH(first_match - 1)) + 2;
if ((long)clen >= default_grid.Columns) {
if ((long)clen >= Columns) {
break;
}
first_match--;
@ -4686,8 +4683,7 @@ win_redr_status_matches (
clen = len;
i = first_match;
while ((long)(clen + status_match_len(xp, L_MATCH(i)) + 2)
< default_grid.Columns) {
while ((long)(clen + status_match_len(xp, L_MATCH(i)) + 2) < Columns) {
if (i == match) {
selstart = buf + len;
selstart_col = clen;
@ -4738,7 +4734,7 @@ win_redr_status_matches (
if (msg_scrolled > 0) {
/* Put the wildmenu just above the command line. If there is
* no room, scroll the screen one line up. */
if (cmdline_row == default_grid.Rows - 1) {
if (cmdline_row == Rows - 1) {
grid_del_lines(&default_grid, 0, 1, (int)Rows, 0, (int)Columns);
msg_scrolled++;
} else {
@ -4767,7 +4763,7 @@ win_redr_status_matches (
grid_puts(&default_grid, selstart, row, selstart_col, HL_ATTR(HLF_WM));
}
grid_fill(&default_grid, row, row + 1, clen, (int)default_grid.Columns,
grid_fill(&default_grid, row, row + 1, clen, (int)Columns,
fillchar, fillchar, attr);
}
@ -5033,7 +5029,7 @@ win_redr_custom (
row = 0;
fillchar = ' ';
attr = HL_ATTR(HLF_TPF);
maxwidth = default_grid.Columns;
maxwidth = Columns;
use_sandbox = was_set_insecurely((char_u *)"tabline", 0);
} else {
row = W_ENDROW(wp);
@ -5052,13 +5048,13 @@ win_redr_custom (
if (*stl++ != '(')
stl = p_ruf;
}
col = ru_col - (default_grid.Columns - wp->w_width);
col = ru_col - (Columns - wp->w_width);
if (col < (wp->w_width + 1) / 2) {
col = (wp->w_width + 1) / 2;
}
maxwidth = wp->w_width - col;
if (!wp->w_status_height) {
row = default_grid.Rows - 1;
row = Rows - 1;
maxwidth--; // writing in last column may cause scrolling
fillchar = ' ';
attr = 0;
@ -5152,7 +5148,7 @@ win_redr_custom (
p = (char_u *) tabtab[n].start;
cur_click_def = tabtab[n].def;
}
while (col < default_grid.Columns) {
while (col < Columns) {
tab_page_click_defs[col++] = cur_click_def;
}
}
@ -5851,7 +5847,7 @@ void grid_fill(ScreenGrid *grid, int start_row, int end_row, int start_col,
}
// TODO(bfredl): The relevant caller should do this
if (row == default_grid.Rows - 1) { // overwritten the command line
if (row == Rows - 1) { // overwritten the command line
redraw_cmdline = true;
if (start_col == 0 && end_col == Columns
&& c1 == ' ' && c2 == ' ' && attr == 0) {
@ -5902,15 +5898,8 @@ void win_grid_alloc(win_T *wp)
{
ScreenGrid *grid = &wp->w_grid;
int rows = grid->requested_rows;
if (rows == 0) {
rows = wp->w_height;
}
int columns = grid->requested_cols;
if (columns == 0) {
columns = wp->w_width;
}
int rows = wp->w_height_inner;
int cols = wp->w_width_inner;
// TODO(bfredl): floating windows should force this to true
bool want_allocation = ui_is_external(kUIMultigrid);
@ -5920,20 +5909,24 @@ void win_grid_alloc(win_T *wp)
grid_invalidate(grid);
}
if (grid->Rows != rows) {
wp->w_lines_valid = 0;
xfree(wp->w_lines);
wp->w_lines = xcalloc(rows+1, sizeof(wline_T));
}
int was_resized = false;
if ((has_allocation != want_allocation)
|| grid->Rows != rows
|| grid->Columns != columns) {
|| grid->Columns != cols) {
if (want_allocation) {
grid_alloc(grid, rows, columns, true);
win_free_lsize(wp);
win_alloc_lines(wp);
grid_alloc(grid, rows, cols, true);
} else {
// Single grid mode, all rendering will be redirected to default_grid.
// Only keep track of the size and offset of the window.
grid_free(grid);
grid->Rows = rows;
grid->Columns = columns;
grid->Columns = cols;
}
was_resized = true;
}
@ -6018,28 +6011,16 @@ retry:
// If anything fails, make grid arrays NULL, so we don't do anything!
// Continuing with the old arrays may result in a crash, because the
// size is wrong.
FOR_ALL_TAB_WINDOWS(tp, wp) {
win_free_lsize(wp);
}
if (aucmd_win != NULL)
win_free_lsize(aucmd_win);
grid_alloc(&default_grid, Rows, Columns, !doclear);
StlClickDefinition *new_tab_page_click_defs = xcalloc(
(size_t)Columns, sizeof(*new_tab_page_click_defs));
FOR_ALL_TAB_WINDOWS(tp, wp) {
win_alloc_lines(wp);
}
if (aucmd_win != NULL && aucmd_win->w_lines == NULL) {
win_alloc_lines(aucmd_win);
}
clear_tab_page_click_defs(tab_page_click_defs, tab_page_click_defs_size);
xfree(tab_page_click_defs);
tab_page_click_defs = new_tab_page_click_defs;
tab_page_click_defs_size = default_grid.Columns;
tab_page_click_defs_size = Columns;
default_grid.row_offset = 0;
default_grid.col_offset = 0;
@ -6237,7 +6218,7 @@ void setcursor(void)
if (curwin->w_p_rl) {
// With 'rightleft' set and the cursor on a double-wide character,
// position it on the leftmost column.
col = curwin->w_grid.Columns - curwin->w_wcol
col = curwin->w_width_inner - curwin->w_wcol
- ((utf_ptr2cells(get_cursor_pos_ptr()) == 2
&& vim_isprintc(gchar_cursor())) ? 2 : 1);
}
@ -6445,7 +6426,7 @@ int showmode(void)
/* if the cmdline is more than one line high, erase top lines */
need_clear = clear_cmdline;
if (clear_cmdline && cmdline_row < default_grid.Rows - 1) {
if (clear_cmdline && cmdline_row < Rows - 1) {
msg_clr_cmdline(); // will reset clear_cmdline
}
@ -6465,7 +6446,7 @@ int showmode(void)
if (edit_submode != NULL && !shortmess(SHM_COMPLETIONMENU)) {
/* These messages can get long, avoid a wrap in a narrow
* window. Prefer showing edit_submode_extra. */
length = (default_grid.Rows - msg_row) * default_grid.Columns - 3;
length = (Rows - msg_row) * Columns - 3;
if (edit_submode_extra != NULL) {
length -= vim_strsize(edit_submode_extra);
}
@ -6589,7 +6570,7 @@ int showmode(void)
static void msg_pos_mode(void)
{
msg_col = 0;
msg_row = default_grid.Rows - 1;
msg_row = Rows - 1;
}
/// Delete mode message. Used when ESC is typed which is expected to end
@ -6663,7 +6644,7 @@ static void draw_tabline(void)
// Init TabPageIdxs[] to zero: Clicking outside of tabs has no effect.
assert(default_grid.Columns == tab_page_click_defs_size);
assert(Columns == tab_page_click_defs_size);
clear_tab_page_click_defs(tab_page_click_defs, tab_page_click_defs_size);
/* Use the 'tabline' option if it's set. */
@ -6685,7 +6666,7 @@ static void draw_tabline(void)
}
if (tabcount > 0) {
tabwidth = (default_grid.Columns - 1 + tabcount / 2) / tabcount;
tabwidth = (Columns - 1 + tabcount / 2) / tabcount;
}
if (tabwidth < 6) {
@ -6696,7 +6677,7 @@ static void draw_tabline(void)
tabcount = 0;
FOR_ALL_TABS(tp) {
if (col >= default_grid.Columns - 4) {
if (col >= Columns - 4) {
break;
}
@ -6737,7 +6718,7 @@ static void draw_tabline(void)
if (wincount > 1) {
vim_snprintf((char *)NameBuff, MAXPATHL, "%d", wincount);
len = (int)STRLEN(NameBuff);
if (col + len >= default_grid.Columns - 3) {
if (col + len >= Columns - 3) {
break;
}
grid_puts_len(&default_grid, NameBuff, len, 0, col,
@ -6766,8 +6747,8 @@ static void draw_tabline(void)
p += len - room;
len = room;
}
if (len > default_grid.Columns - col - 1) {
len = default_grid.Columns - col - 1;
if (len > Columns - col - 1) {
len = Columns - col - 1;
}
grid_puts_len(&default_grid, p, (int)STRLEN(p), 0, col, attr);
@ -6791,14 +6772,14 @@ static void draw_tabline(void)
c = '_';
else
c = ' ';
grid_fill(&default_grid, 0, 1, col, (int)default_grid.Columns, c, c,
grid_fill(&default_grid, 0, 1, col, (int)Columns, c, c,
attr_fill);
/* Put an "X" for closing the current tab if there are several. */
if (first_tabpage->tp_next != NULL) {
grid_putchar(&default_grid, 'X', 0, (int)default_grid.Columns - 1,
grid_putchar(&default_grid, 'X', 0, (int)Columns - 1,
attr_nosel);
tab_page_click_defs[default_grid.Columns - 1] = (StlClickDefinition) {
tab_page_click_defs[Columns - 1] = (StlClickDefinition) {
.type = kStlClickTabClose,
.tabnr = 999,
.func = NULL,
@ -6994,10 +6975,10 @@ static void win_redr_ruler(win_T *wp, int always)
off = wp->w_wincol;
width = wp->w_width;
} else {
row = default_grid.Rows - 1;
row = Rows - 1;
fillchar = ' ';
attr = 0;
width = default_grid.Columns;
width = Columns;
off = 0;
}
@ -7035,7 +7016,7 @@ static void win_redr_ruler(win_T *wp, int always)
if (wp->w_status_height == 0) { // can't use last char of screen
o++;
}
int this_ru_col = ru_col - (default_grid.Columns - width);
int this_ru_col = ru_col - (Columns - width);
if (this_ru_col < 0) {
this_ru_col = 0;
}
@ -7090,7 +7071,7 @@ int number_width(win_T *wp)
if (wp->w_p_rnu && !wp->w_p_nu) {
// cursor line shows "0"
lnum = wp->w_grid.Rows;
lnum = wp->w_height_inner;
} else {
// cursor line shows absolute line number
lnum = wp->w_buffer->b_ml.ml_line_count;

3
src/nvim/screen.h
View File

@ -28,8 +28,7 @@
///
/// Note: before the screen is initialized and when out of memory these can be
/// NULL.
EXTERN ScreenGrid default_grid INIT(= { 0, NULL, NULL, NULL, NULL, 0, 0, 0, 0,
0, 0, 0 });
EXTERN ScreenGrid default_grid INIT(= SCREEN_GRID_INIT);
#define DEFAULT_GRID_HANDLE 1 // handle for the default_grid

2
src/nvim/search.c
View File

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

37
src/nvim/terminal.c
View File

@ -334,41 +334,32 @@ void terminal_close(Terminal *term, char *msg)
}
}
void terminal_resize(Terminal *term, uint16_t width, uint16_t height)
void terminal_check_size(Terminal *term)
{
if (term->closed) {
// If two windows display the same terminal and one is closed by keypress.
return;
}
bool force = width == UINT16_MAX || height == UINT16_MAX;
int curwidth, curheight;
vterm_get_size(term->vt, &curheight, &curwidth);
uint16_t width = 0, height = 0;
if (force || !width) {
width = (uint16_t)curwidth;
}
if (force || !height) {
height = (uint16_t)curheight;
}
if (!force && curheight == height && curwidth == width) {
return;
}
if (height == 0 || width == 0) {
return;
}
FOR_ALL_TAB_WINDOWS(tp, wp) {
if (wp->w_buffer && wp->w_buffer->terminal == term) {
const uint16_t win_width =
(uint16_t)(MAX(0, wp->w_width - win_col_off(wp)));
(uint16_t)(MAX(0, wp->w_width_inner - win_col_off(wp)));
width = MAX(width, win_width);
height = (uint16_t)MAX(height, wp->w_height);
height = (uint16_t)MAX(height, wp->w_height_inner);
}
}
// if no window displays the terminal, or such all windows are zero-height,
// don't resize the terminal.
if ((curheight == height && curwidth == width) || height == 0 || width == 0) {
return;
}
vterm_set_size(term->vt, height, width);
vterm_screen_flush_damage(term->vts);
term->pending_resize = true;
@ -383,8 +374,10 @@ void terminal_enter(void)
memset(s, 0, sizeof(TerminalState));
s->term = buf->terminal;
// Ensure the terminal is properly sized.
terminal_resize(s->term, 0, 0);
// Ensure the terminal is properly sized. Ideally window size management
// code should always have resized the terminal already, but check here to
// be sure.
terminal_check_size(s->term);
int save_state = State;
s->save_rd = RedrawingDisabled;

8
src/nvim/ui.c
View File

@ -452,8 +452,8 @@ void ui_grid_resize(handle_T grid_handle, int width, int height, Error *error)
return;
}
wp->w_grid.requested_rows = (int)height;
wp->w_grid.requested_cols = (int)width;
win_inner_width_changed(wp);
redraw_win_later(wp, SOME_VALID);
// non-positive indicates no request
wp->w_height_request = (int)MAX(height, 0);
wp->w_width_request = (int)MAX(width, 0);
win_set_inner_size(wp);
}

164
src/nvim/window.c
View File

@ -3025,8 +3025,10 @@ static void new_frame(win_T *wp)
void win_init_size(void)
{
firstwin->w_height = ROWS_AVAIL;
firstwin->w_height_inner = firstwin->w_height;
topframe->fr_height = ROWS_AVAIL;
firstwin->w_width = Columns;
firstwin->w_width_inner = firstwin->w_width;
topframe->fr_width = Columns;
}
@ -3889,7 +3891,6 @@ static win_T *win_alloc(win_T *after, int hidden)
// allocate window structure and linesizes arrays
win_T *new_wp = xcalloc(1, sizeof(win_T));
win_alloc_lines(new_wp);
new_wp->handle = ++last_win_id;
handle_register_window(new_wp);
@ -3970,7 +3971,7 @@ win_free (
}
}
win_free_lsize(wp);
xfree(wp->w_lines);
for (i = 0; i < wp->w_tagstacklen; ++i)
xfree(wp->w_tagstack[i].tagname);
@ -4117,28 +4118,6 @@ static void frame_remove(frame_T *frp)
}
/*
* Allocate w_lines[] for window "wp".
*/
void win_alloc_lines(win_T *wp)
{
wp->w_lines_valid = 0;
assert(wp->w_grid.Rows >= 0);
wp->w_lines = xcalloc(MAX(wp->w_grid.Rows + 1, Rows), sizeof(wline_T));
}
/*
* free lsize arrays for a window
*/
void win_free_lsize(win_T *wp)
{
// TODO: why would wp be NULL here?
if (wp != NULL) {
xfree(wp->w_lines);
wp->w_lines = NULL;
}
}
/*
* Called from win_new_shellsize() after Rows changed.
* This only does the current tab page, others must be done when made active.
@ -4876,9 +4855,9 @@ void win_drag_vsep_line(win_T *dragwin, int offset)
// Has no effect when the window is less than two lines.
void set_fraction(win_T *wp)
{
if (wp->w_height > 1) {
wp->w_fraction = ((long)wp->w_wrow * FRACTION_MULT + wp->w_height / 2)
/ (long)wp->w_height;
if (wp->w_height_inner > 1) {
wp->w_fraction = ((long)wp->w_wrow * FRACTION_MULT + wp->w_height_inner / 2)
/ (long)wp->w_height_inner;
}
}
@ -4889,46 +4868,25 @@ void set_fraction(win_T *wp)
*/
void win_new_height(win_T *wp, int height)
{
int prev_height = wp->w_height;
/* Don't want a negative height. Happens when splitting a tiny window.
* Will equalize heights soon to fix it. */
if (height < 0)
// Don't want a negative height. Happens when splitting a tiny window.
// Will equalize heights soon to fix it.
if (height < 0) {
height = 0;
if (wp->w_height == height)
return; /* nothing to do */
if (wp->w_height > 0) {
if (wp == curwin) {
// w_wrow needs to be valid. When setting 'laststatus' this may
// call win_new_height() recursively.
validate_cursor();
}
if (wp->w_height != prev_height) { // -V547
return; // Recursive call already changed the size, bail out.
}
if (wp->w_wrow != wp->w_prev_fraction_row) {
set_fraction(wp);
}
}
if (wp->w_height == height) {
return; // nothing to do
}
wp->w_height = height;
wp->w_skipcol = 0;
// There is no point in adjusting the scroll position when exiting. Some
// values might be invalid.
if (!exiting) {
scroll_to_fraction(wp, prev_height);
}
wp->w_pos_changed = true;
win_set_inner_size(wp);
}
void scroll_to_fraction(win_T *wp, int prev_height)
{
linenr_T lnum;
int sline, line_size;
int height = wp->w_height;
int height = wp->w_height_inner;
/* Don't change w_topline when height is zero. Don't set w_topline when
* 'scrollbind' is set and this isn't the current window. */
@ -4951,8 +4909,8 @@ void scroll_to_fraction(win_T *wp, int prev_height)
// Make sure the whole cursor line is visible, if possible.
const int rows = plines_win(wp, lnum, false);
if (sline > wp->w_height - rows) {
sline = wp->w_height - rows;
if (sline > wp->w_height_inner - rows) {
sline = wp->w_height_inner - rows;
wp->w_wrow -= rows - line_size;
}
}
@ -4964,14 +4922,14 @@ void scroll_to_fraction(win_T *wp, int prev_height)
* room use w_skipcol;
*/
wp->w_wrow = line_size;
if (wp->w_wrow >= wp->w_height
&& (wp->w_width - win_col_off(wp)) > 0) {
wp->w_skipcol += wp->w_width - win_col_off(wp);
--wp->w_wrow;
while (wp->w_wrow >= wp->w_height) {
wp->w_skipcol += wp->w_width - win_col_off(wp)
if (wp->w_wrow >= wp->w_height_inner
&& (wp->w_width_inner - win_col_off(wp)) > 0) {
wp->w_skipcol += wp->w_width_inner - win_col_off(wp);
wp->w_wrow--;
while (wp->w_wrow >= wp->w_height_inner) {
wp->w_skipcol += wp->w_width_inner - win_col_off(wp)
+ win_col_off2(wp);
--wp->w_wrow;
wp->w_wrow--;
}
}
set_topline(wp, lnum);
@ -5024,21 +4982,58 @@ void scroll_to_fraction(win_T *wp, int prev_height)
redraw_win_later(wp, SOME_VALID);
wp->w_redr_status = TRUE;
invalidate_botline_win(wp);
if (wp->w_buffer->terminal) {
terminal_resize(wp->w_buffer->terminal, 0, wp->w_height);
redraw_win_later(wp, NOT_VALID);
}
}
void win_inner_width_changed(win_T *wp)
void win_set_inner_size(win_T *wp)
{
wp->w_lines_valid = 0;
changed_line_abv_curs_win(wp);
invalidate_botline_win(wp);
if (wp == curwin) {
update_topline();
curs_columns(TRUE); /* validate w_wrow */
int width = wp->w_width_request;
if (width == 0) {
width = wp->w_width;
}
int prev_height = wp->w_height_inner;
int height = wp->w_height_request;
if (height == 0) {
height = wp->w_height;
}
if (height != prev_height) {
if (height > 0) {
if (wp == curwin) {
// w_wrow needs to be valid. When setting 'laststatus' this may
// call win_new_height() recursively.
validate_cursor();
}
if (wp->w_height_inner != prev_height) { // -V547
return; // Recursive call already changed the size, bail out.
}
if (wp->w_wrow != wp->w_prev_fraction_row) {
set_fraction(wp);
}
}
wp->w_height_inner = height;
wp->w_skipcol = 0;
// There is no point in adjusting the scroll position when exiting. Some
// values might be invalid.
if (!exiting) {
scroll_to_fraction(wp, prev_height);
}
}
if (width != wp->w_width_inner) {
wp->w_width_inner = width;
wp->w_lines_valid = 0;
changed_line_abv_curs_win(wp);
invalidate_botline_win(wp);
if (wp == curwin) {
update_topline();
curs_columns(true); // validate w_wrow
}
}
if (wp->w_buffer->terminal) {
terminal_check_size(wp->w_buffer->terminal);
}
}
@ -5046,24 +5041,11 @@ void win_inner_width_changed(win_T *wp)
void win_new_width(win_T *wp, int width)
{
wp->w_width = width;
// TODO(bfredl): refactor this. There should be some variable
// wp->w_inner_width which always contains the final actual width.
// Alternatively use wp->w_width for this and introduce wp->w_outer_width
// Then use this to fix terminal_resize.
if (!ui_is_external(kUIMultigrid) || wp->w_grid.requested_cols == 0) {
win_inner_width_changed(wp);
}
win_set_inner_size(wp);
redraw_win_later(wp, NOT_VALID);
wp->w_redr_status = TRUE;
if (wp->w_buffer->terminal) {
if (wp->w_height != 0) {
terminal_resize(wp->w_buffer->terminal,
(uint16_t)(MAX(0, wp->w_width - win_col_off(wp))),
0);
}
}
wp->w_pos_changed = true;
}

6
test/functional/terminal/helpers.lua
View File

@ -33,7 +33,7 @@ local function disable_mouse() feed_termcode('[?1002l') end
local default_command = '["'..nvim_dir..'/tty-test'..'"]'
local function screen_setup(extra_rows, command, cols)
local function screen_setup(extra_rows, command, cols, opts)
extra_rows = extra_rows and extra_rows or 0
command = command and command or default_command
cols = cols and cols or 50
@ -55,7 +55,7 @@ local function screen_setup(extra_rows, command, cols)
[10] = {foreground = 121}, -- "Press ENTER" in embedded :terminal session.
})
screen:attach({rgb=false})
screen:attach(opts or {rgb=false})
feed_command('enew | call termopen('..command..')')
nvim('input', '<CR>')
@ -69,7 +69,7 @@ local function screen_setup(extra_rows, command, cols)
-- tty-test puts the terminal into raw mode and echoes input. Tests work by
-- feeding termcodes to control the display and asserting by screen:expect.
if command == default_command then
if command == default_command and opts == nil then
-- Wait for "tty ready" to be printed before each test or the terminal may
-- still be in canonical mode (will echo characters for example).
local empty_line = (' '):rep(cols)

79
test/functional/terminal/mouse_spec.lua
View File

@ -108,41 +108,42 @@ describe('terminal mouse', function()
]])
feed(':enew | set number<cr>')
screen:expect([[
{7: 1 }^ │line28 |
{4:~ }│line29 |
{7: 1 }^ │line29 |
{4:~ }│line30 |
{4:~ }│rows: 5, cols: 25 |
{4:~ }│rows: 5, cols: 24 |
{4:~ }│{2: } |
========== ========== |
:enew | set number |
]])
feed('30iline\n<esc>')
screen:expect([[
{7: 27 }line │line28 |
{7: 28 }line │line29 |
{7: 29 }line │line30 |
{7: 30 }line │rows: 5, cols: 25 |
{7: 27 }line │line29 |
{7: 28 }line │line30 |
{7: 29 }line │rows: 5, cols: 25 |
{7: 30 }line │rows: 5, cols: 24 |
{7: 31 }^ │{2: } |
========== ========== |
|
]])
feed('<c-w>li')
screen:expect([[
{7: 27 }line │line28 |
{7: 28 }line │line29 |
{7: 29 }line │line30 |
{7: 30 }line │rows: 5, cols: 25 |
{7: 27 }line │line29 |
{7: 28 }line │line30 |
{7: 29 }line │rows: 5, cols: 25 |
{7: 30 }line │rows: 5, cols: 24 |
{7: 31 } │{1: } |
========== ========== |
{3:-- TERMINAL --} |
]])
-- enabling mouse won't affect interaction with other windows
thelpers.enable_mouse()
thelpers.feed_data('mouse enabled\n')
screen:expect([[
{7: 27 }line │line29 |
{7: 28 }line │line30 |
{7: 29 }line │rows: 5, cols: 25 |
{7: 27 }line │line30 |
{7: 28 }line │rows: 5, cols: 25 |
{7: 29 }line │rows: 5, cols: 24 |
{7: 30 }line │mouse enabled |
{7: 31 } │{1: } |
========== ========== |
@ -153,9 +154,9 @@ describe('terminal mouse', function()
it('wont lose focus if another window is scrolled', function()
feed('<ScrollWheelUp><0,0><ScrollWheelUp><0,0>')
screen:expect([[
{7: 21 }line │line29 |
{7: 22 }line │line30 |
{7: 23 }line │rows: 5, cols: 25 |
{7: 21 }line │line30 |
{7: 22 }line │rows: 5, cols: 25 |
{7: 23 }line │rows: 5, cols: 24 |
{7: 24 }line │mouse enabled |
{7: 25 }line │{1: } |
========== ========== |
@ -163,9 +164,9 @@ describe('terminal mouse', function()
]])
feed('<S-ScrollWheelDown><0,0>')
screen:expect([[
{7: 26 }line │line29 |
{7: 27 }line │line30 |
{7: 28 }line │rows: 5, cols: 25 |
{7: 26 }line │line30 |
{7: 27 }line │rows: 5, cols: 25 |
{7: 28 }line │rows: 5, cols: 24 |
{7: 29 }line │mouse enabled |
{7: 30 }line │{1: } |
========== ========== |
@ -176,15 +177,49 @@ describe('terminal mouse', function()
it('will lose focus if another window is clicked', function()
feed('<LeftMouse><5,1>')
screen:expect([[
{7: 27 }line │line29 |
{7: 28 }l^ine │line30 |
{7: 29 }line │rows: 5, cols: 25 |
{7: 27 }line │line30 |
{7: 28 }l^ine │rows: 5, cols: 25 |
{7: 29 }line │rows: 5, cols: 24 |
{7: 30 }line │mouse enabled |
{7: 31 } │{2: } |
========== ========== |
|
]])
end)
it('handles terminal size when switching buffers', function()
nvim('set_option', 'hidden', true)
feed('<c-\\><c-n><c-w><c-w>')
screen:expect([[
{7: 27 }line │line30 |
{7: 28 }line │rows: 5, cols: 25 |
{7: 29 }line │rows: 5, cols: 24 |
{7: 30 }line │mouse enabled |
{7: 31 }^ │{2: } |
========== ========== |
|
]])
feed(':bn<cr>')
screen:expect([[
rows: 5, cols: 25 │rows: 5, cols: 25 |
rows: 5, cols: 24 │rows: 5, cols: 24 |
mouse enabled │mouse enabled |
rows: 5, cols: 25 │rows: 5, cols: 25 |
{2:^ } │{2: } |
========== ========== |
:bn |
]])
feed(':bn<cr>')
screen:expect([[
{7: 27 }line │rows: 5, cols: 24 |
{7: 28 }line │mouse enabled |
{7: 29 }line │rows: 5, cols: 25 |
{7: 30 }line │rows: 5, cols: 24 |
{7: 31 }^ │{2: } |
========== ========== |
:bn |
]])
end)
end)
end)
end)

98
test/functional/terminal/window_spec.lua
View File

@ -124,3 +124,101 @@ describe('terminal window', function()
end)
end)
describe('terminal window with multigrid', function()
local screen
before_each(function()
clear()
screen = thelpers.screen_setup(0,nil,50,{ext_multigrid=true})
end)
it('resizes to requested size', function()
screen:expect([[
## grid 1
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
{3:-- TERMINAL --} |
## grid 2
tty ready |
{1: } |
|
|
|
|
]])
screen:try_resize_grid(2, 20, 10)
if iswin() then
screen:expect{any="rows: 10, cols: 20"}
else
screen:expect([[
## grid 1
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
{3:-- TERMINAL --} |
## grid 2
tty ready |
rows: 10, cols: 20 |
{1: } |
|
|
|
|
|
|
|
]])
end
screen:try_resize_grid(2, 70, 3)
if iswin() then
screen:expect{any="rows: 3, cols: 70"}
else
screen:expect([[
## grid 1
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
{3:-- TERMINAL --} |
## grid 2
rows: 10, cols: 20 |
rows: 3, cols: 70 |
{1: } |
]])
end
screen:try_resize_grid(2, 0, 0)
if iswin() then
screen:expect{any="rows: 6, cols: 50"}
else
screen:expect([[
## grid 1
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
[2:--------------------------------------------------]|
{3:-- TERMINAL --} |
## grid 2
tty ready |
rows: 10, cols: 20 |
rows: 3, cols: 70 |
rows: 6, cols: 50 |
{1: } |
|
]])
end
end)
end)