mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-28 05:58:33 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #33481 from bfredl/gridview

Browse Source 
refactor(ui): separate types for allocated grids and viewports
This commit is contained in:
bfredl
2025-04-28 12:07:54 +02:00
committed by GitHub
parent 317a897c46 bd413a2f55
commit 43f3c4a48f
34 changed files with 427 additions and 438 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1034,8 +1034,8 @@ Integer nvim_open_term(Buffer buffer, Dict(open_term) *opts, Error *err)
.data = chan, .data = chan,
// NB: overridden in terminal_check_size if a window is already // NB: overridden in terminal_check_size if a window is already
// displaying the buffer // displaying the buffer
.width = (uint16_t)MAX(curwin->w_width_inner - win_col_off(curwin), 0), .width = (uint16_t)MAX(curwin->w_view_width - win_col_off(curwin), 0),
.height = (uint16_t)curwin->w_height_inner, .height = (uint16_t)curwin->w_view_height,
.write_cb = term_write, .write_cb = term_write,
.resize_cb = term_resize, .resize_cb = term_resize,
.close_cb = term_close, .close_cb = term_close,
@@ -2197,11 +2197,13 @@ static void redraw_status(win_T *wp, Dict(redraw) *opts, bool *flush)
wp->w_nrwidth_line_count = 0; wp->w_nrwidth_line_count = 0;
changed_window_setting(wp); changed_window_setting(wp);
} }
int old_row_offset = wp->w_grid.row_offset;
win_grid_alloc(wp); win_grid_alloc(wp);
// Flush later in case winbar was just hidden or shown for the first time, or // Flush later in case winbar was just hidden or shown for the first time, or
// statuscolumn is being drawn. // statuscolumn is being drawn.
if (wp->w_lines_valid == 0) { if (wp->w_lines_valid == 0 || wp->w_grid.row_offset != old_row_offset) {
*flush = true; *flush = true;
} }

9
src/nvim/buffer_defs.h
View File

@@ -1171,9 +1171,9 @@ struct window_S {
///< this includes float border but excludes special columns ///< this includes float border but excludes special columns
///< implemented in win_line() (i.e. signs, folds, numbers) ///< implemented in win_line() (i.e. signs, folds, numbers)
// inner size of window, which can be overridden by external UI // Size of the window viewport. This is the area usable to draw columns and buffer contents
int w_height_inner; int w_view_height;
int w_width_inner; int w_view_width;
// external UI request. If non-zero, the inner size will use this. // external UI request. If non-zero, the inner size will use this.
int w_height_request; int w_height_request;
int w_width_request; int w_width_request;
@@ -1235,6 +1235,7 @@ struct window_S {
// This is used for efficient redrawing. // This is used for efficient redrawing.
int w_lines_valid; // number of valid entries int w_lines_valid; // number of valid entries
wline_T *w_lines; wline_T *w_lines;
int w_lines_size;
garray_T w_folds; // array of nested folds garray_T w_folds; // array of nested folds
bool w_fold_manual; // when true: some folds are opened/closed bool w_fold_manual; // when true: some folds are opened/closed
@@ -1331,7 +1332,7 @@ struct window_S {
int w_tagstackidx; // idx just below active entry int w_tagstackidx; // idx just below active entry
int w_tagstacklen; // number of tags on stack int w_tagstacklen; // number of tags on stack
ScreenGrid w_grid; // the grid specific to the window GridView w_grid; // area to draw on, excluding borders and winbar
ScreenGrid w_grid_alloc; // the grid specific to the window ScreenGrid w_grid_alloc; // the grid specific to the window
bool w_pos_changed; // true if window position changed bool w_pos_changed; // true if window position changed
bool w_floating; ///< whether the window is floating bool w_floating; ///< whether the window is floating

2
src/nvim/cmdexpand.c
View File

@@ -633,7 +633,7 @@ static void redraw_wildmenu(expand_T *xp, int num_matches, char **matches, int m
// Tricky: wildmenu can be drawn either over a status line, or at empty // Tricky: wildmenu can be drawn either over a status line, or at empty
// scrolled space in the message output // scrolled space in the message output
grid_line_start((wild_menu_showing == WM_SCROLLED) ? &msg_grid_adj : &default_grid, row); grid_line_start((wild_menu_showing == WM_SCROLLED) ? &msg_grid_adj : &default_gridview, row);
grid_line_puts(0, buf, -1, attr); grid_line_puts(0, buf, -1, attr);
if (selstart != NULL && highlight) { if (selstart != NULL && highlight) {

8
src/nvim/cursor.c
View File

@@ -122,12 +122,12 @@ static int coladvance2(win_T *wp, pos_T *pos, bool addspaces, bool finetune, col
} }
} }
} else { } else {
int width = wp->w_width_inner - win_col_off(wp); int width = wp->w_view_width - win_col_off(wp);
int csize = 0; int csize = 0;
if (finetune if (finetune
&& wp->w_p_wrap && wp->w_p_wrap
&& wp->w_width_inner != 0 && wp->w_view_width != 0
&& wcol >= (colnr_T)width && wcol >= (colnr_T)width
&& width > 0) { && width > 0) {
csize = linetabsize_eol(wp, pos->lnum); csize = linetabsize_eol(wp, pos->lnum);
@@ -233,7 +233,7 @@ static int coladvance2(win_T *wp, pos_T *pos, bool addspaces, bool finetune, col
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 * wp->w_width_inner)) { if (b > 0 && b < (MAXCOL - 2 * wp->w_view_width)) {
pos->coladd = b; pos->coladd = b;
} }
@@ -437,7 +437,7 @@ bool set_leftcol(colnr_T leftcol)
changed_cline_bef_curs(curwin); changed_cline_bef_curs(curwin);
// TODO(hinidu): I think it should be colnr_T or int, but p_siso is long. // TODO(hinidu): I think it should be colnr_T or int, but p_siso is long.
// Perhaps we can change p_siso to int. // Perhaps we can change p_siso to int.
int64_t lastcol = curwin->w_leftcol + curwin->w_width_inner - win_col_off(curwin) - 1; int64_t lastcol = curwin->w_leftcol + curwin->w_view_width - win_col_off(curwin) - 1;
validate_virtcol(curwin); validate_virtcol(curwin);
bool retval = false; bool retval = false;

91
src/nvim/drawline.c
View File

@@ -181,7 +181,7 @@ static void margin_columns_win(win_T *wp, int *left_col, int *right_col)
static int prev_right_col; static int prev_right_col;
int cur_col_off = win_col_off(wp); int cur_col_off = win_col_off(wp);
int width1 = wp->w_width_inner - cur_col_off; int width1 = wp->w_view_width - cur_col_off;
int width2 = width1 + win_col_off2(wp); int width2 = width1 + win_col_off2(wp);
if (saved_w_virtcol == wp->w_virtcol && prev_wp == wp if (saved_w_virtcol == wp->w_virtcol && prev_wp == wp
@@ -258,7 +258,7 @@ static int line_putchar(buf_T *buf, const char **pp, schar_T *dest, int maxcells
static void draw_virt_text(win_T *wp, buf_T *buf, int col_off, int *end_col, int win_row) static void draw_virt_text(win_T *wp, buf_T *buf, int col_off, int *end_col, int win_row)
{ {
DecorState *const state = &decor_state; DecorState *const state = &decor_state;
int const max_col = wp->w_grid.cols; int const max_col = wp->w_view_width;
int right_pos = max_col; int right_pos = max_col;
bool const do_eol = state->eol_col > -1; bool const do_eol = state->eol_col > -1;
@@ -330,7 +330,7 @@ static void draw_virt_text(win_T *wp, buf_T *buf, int col_off, int *end_col, int
} else { } else {
updated = false; updated = false;
} }
if (updated && (item->draw_col < 0 || item->draw_col >= wp->w_grid.cols)) { if (updated && (item->draw_col < 0 || item->draw_col >= wp->w_view_width)) {
// Out of window, don't draw at all. // Out of window, don't draw at all.
item->draw_col = INT_MIN; item->draw_col = INT_MIN;
} }
@@ -432,9 +432,9 @@ static void draw_col_buf(win_T *wp, winlinevars_T *wlv, const char *text, size_t
const colnr_T *fold_vcol, bool inc_vcol) const colnr_T *fold_vcol, bool inc_vcol)
{ {
const char *ptr = text; const char *ptr = text;
while (ptr < text + len && wlv->off < wp->w_grid.cols) { while (ptr < text + len && wlv->off < wp->w_view_width) {
int cells = line_putchar(wp->w_buffer, &ptr, &linebuf_char[wlv->off], int cells = line_putchar(wp->w_buffer, &ptr, &linebuf_char[wlv->off],
wp->w_grid.cols - wlv->off, wlv->off); wp->w_view_width - wlv->off, wlv->off);
int myattr = attr; int myattr = attr;
if (inc_vcol) { if (inc_vcol) {
advance_color_col(wlv, wlv->vcol); advance_color_col(wlv, wlv->vcol);
@@ -788,7 +788,7 @@ static void handle_breakindent(win_T *wp, winlinevars_T *wlv)
static void handle_showbreak_and_filler(win_T *wp, winlinevars_T *wlv) static void handle_showbreak_and_filler(win_T *wp, winlinevars_T *wlv)
{ {
int remaining = wp->w_grid.cols - wlv->off; int remaining = wp->w_view_width - wlv->off;
if (wlv->filler_todo > wlv->filler_lines - wlv->n_virt_lines) { if (wlv->filler_todo > wlv->filler_lines - wlv->n_virt_lines) {
// TODO(bfredl): check this doesn't inhibit TUI-style // TODO(bfredl): check this doesn't inhibit TUI-style
// clear-to-end-of-line. // clear-to-end-of-line.
@@ -986,7 +986,7 @@ static void win_line_start(win_T *wp, winlinevars_T *wlv)
wlv->col = 0; wlv->col = 0;
wlv->off = 0; wlv->off = 0;
wlv->need_lbr = false; wlv->need_lbr = false;
for (int i = 0; i < wp->w_grid.cols; i++) { for (int i = 0; i < wp->w_view_width; i++) {
linebuf_char[i] = schar_from_ascii(' '); linebuf_char[i] = schar_from_ascii(' ');
linebuf_attr[i] = 0; linebuf_attr[i] = 0;
linebuf_vcol[i] = -1; linebuf_vcol[i] = -1;
@@ -1041,7 +1041,9 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
spellvars_T *spv, foldinfo_T foldinfo) spellvars_T *spv, foldinfo_T foldinfo)
{ {
colnr_T vcol_prev = -1; // "wlv.vcol" of previous character colnr_T vcol_prev = -1; // "wlv.vcol" of previous character
ScreenGrid *grid = &wp->w_grid; // grid specific to the window GridView *grid = &wp->w_grid; // grid specific to the window
const int view_width = wp->w_view_width;
const int view_height = wp->w_view_height;
const bool in_curline = wp == curwin && lnum == curwin->w_cursor.lnum; const bool in_curline = wp == curwin && lnum == curwin->w_cursor.lnum;
const bool has_fold = foldinfo.fi_level != 0 && foldinfo.fi_lines > 0; const bool has_fold = foldinfo.fi_level != 0 && foldinfo.fi_lines > 0;
@@ -1695,7 +1697,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
// When only updating the columns and that's done, stop here. // When only updating the columns and that's done, stop here.
if (col_rows > 0) { if (col_rows > 0) {
wlv_put_linebuf(wp, &wlv, MIN(wlv.off, grid->cols), false, bg_attr, 0); wlv_put_linebuf(wp, &wlv, MIN(wlv.off, view_width), false, bg_attr, 0);
// Need to update more screen lines if: // Need to update more screen lines if:
// - 'statuscolumn' needs to be drawn, or // - 'statuscolumn' needs to be drawn, or
// - LineNrAbove or LineNrBelow is used, or // - LineNrAbove or LineNrBelow is used, or
@@ -1740,8 +1742,8 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
// hide virt_text on text hidden by 'nowrap' or 'smoothscroll' // hide virt_text on text hidden by 'nowrap' or 'smoothscroll'
decor_redraw_col(wp, (colnr_T)(ptr - line) - 1, wlv.off, true, &decor_state); decor_redraw_col(wp, (colnr_T)(ptr - line) - 1, wlv.off, true, &decor_state);
} }
if (wlv.col >= grid->cols) { if (wlv.col >= view_width) {
wlv.col = wlv.off = grid->cols; wlv.col = wlv.off = view_width;
goto end_check; goto end_check;
} }
} }
@@ -1761,7 +1763,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
if (wp->w_p_cuc) { if (wp->w_p_cuc) {
wlv.row = wp->w_cline_row + wp->w_cline_height; wlv.row = wp->w_cline_row + wp->w_cline_height;
} else { } else {
wlv.row = grid->rows; wlv.row = view_height;
} }
break; break;
} }
@@ -1944,14 +1946,14 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
ptr = line + v; ptr = line + v;
} }
if (draw_folded && wlv.n_extra == 0 && wlv.col < grid->cols && (has_foldtext || *ptr == NUL)) { if (draw_folded && wlv.n_extra == 0 && wlv.col < view_width && (has_foldtext || *ptr == NUL)) {
// Fill rest of line with 'fold'. // Fill rest of line with 'fold'.
wlv.sc_extra = wp->w_p_fcs_chars.fold; wlv.sc_extra = wp->w_p_fcs_chars.fold;
wlv.sc_final = NUL; wlv.sc_final = NUL;
wlv.n_extra = grid->cols - wlv.col; wlv.n_extra = view_width - wlv.col;
} }
if (draw_folded && wlv.n_extra != 0 && wlv.col >= grid->cols) { if (draw_folded && wlv.n_extra != 0 && wlv.col >= view_width) {
// Truncate the folding. // Truncate the folding.
wlv.n_extra = 0; wlv.n_extra = 0;
} }
@@ -1981,7 +1983,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
// If a double-width char doesn't fit display a '>' in the last column. // If a double-width char doesn't fit display a '>' in the last column.
// Don't advance the pointer but put the character at the start of the next line. // Don't advance the pointer but put the character at the start of the next line.
if (wlv.col >= grid->cols - 1 && schar_cells(mb_schar) == 2) { if (wlv.col >= view_width - 1 && schar_cells(mb_schar) == 2) {
mb_c = '>'; mb_c = '>';
mb_l = 1; mb_l = 1;
mb_schar = schar_from_ascii(mb_c); mb_schar = schar_from_ascii(mb_c);
@@ -2054,7 +2056,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
// initialize these. // initialize these.
mb_c = ' '; mb_c = ' ';
mb_schar = schar_from_ascii(' '); mb_schar = schar_from_ascii(' ');
} else if (has_foldtext || (has_fold && wlv.col >= grid->cols)) { } else if (has_foldtext || (has_fold && wlv.col >= view_width)) {
// skip writing the buffer line itself // skip writing the buffer line itself
mb_schar = NUL; mb_schar = NUL;
} else { } else {
@@ -2104,7 +2106,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
// If a double-width char doesn't fit display a '>' in the // If a double-width char doesn't fit display a '>' in the
// last column; the character is displayed at the start of the // last column; the character is displayed at the start of the
// next line. // next line.
if (wlv.col >= grid->cols - 1 && schar_cells(mb_schar) == 2) { if (wlv.col >= view_width - 1 && schar_cells(mb_schar) == 2) {
mb_schar = schar_from_ascii('>'); mb_schar = schar_from_ascii('>');
mb_c = '>'; mb_c = '>';
mb_l = 1; mb_l = 1;
@@ -2286,7 +2288,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
search_attr = 0; search_attr = 0;
} }
if (mb_c == TAB && wlv.n_extra + wlv.col > grid->cols) { if (mb_c == TAB && wlv.n_extra + wlv.col > view_width) {
wlv.n_extra = tabstop_padding(wlv.vcol, wp->w_buffer->b_p_ts, wlv.n_extra = tabstop_padding(wlv.vcol, wp->w_buffer->b_p_ts,
wp->w_buffer->b_p_vts_array) - 1; wp->w_buffer->b_p_vts_array) - 1;
} }
@@ -2478,7 +2480,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
|| ((wlv.fromcol >= 0 || fromcol_prev >= 0) || ((wlv.fromcol >= 0 || fromcol_prev >= 0)
&& wlv.tocol > wlv.vcol && wlv.tocol > wlv.vcol
&& VIsual_mode != Ctrl_V && VIsual_mode != Ctrl_V
&& wlv.col < grid->cols && wlv.col < view_width
&& !(noinvcur && !(noinvcur
&& lnum == wp->w_cursor.lnum && lnum == wp->w_cursor.lnum
&& wlv.vcol == wp->w_virtcol))) && wlv.vcol == wp->w_virtcol)))
@@ -2536,7 +2538,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
&& virtual_active(wp) && virtual_active(wp)
&& wlv.tocol != MAXCOL && wlv.tocol != MAXCOL
&& wlv.vcol < wlv.tocol && wlv.vcol < wlv.tocol
&& wlv.col < grid->cols) { && wlv.col < view_width) {
mb_c = ' '; mb_c = ' ';
mb_schar = schar_from_char(mb_c); mb_schar = schar_from_char(mb_c);
ptr--; // put it back at the NUL ptr--; // put it back at the NUL
@@ -2693,7 +2695,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
|| prevcol_hl_flag)) { || prevcol_hl_flag)) {
int n = 0; int n = 0;
if (wlv.col >= grid->cols) { if (wlv.col >= view_width) {
n = -1; n = -1;
} }
if (n != 0) { if (n != 0) {
@@ -2748,13 +2750,13 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
decor_redraw_eol(wp, &decor_state, &wlv.line_attr, wlv.col + eol_skip); decor_redraw_eol(wp, &decor_state, &wlv.line_attr, wlv.col + eol_skip);
} }
for (int i = wlv.col; i < grid->cols; i++) { for (int i = wlv.col; i < view_width; i++) {
linebuf_vcol[wlv.off + (i - wlv.col)] = wlv.vcol + (i - wlv.col); linebuf_vcol[wlv.off + (i - wlv.col)] = wlv.vcol + (i - wlv.col);
} }
if (((wp->w_p_cuc if (((wp->w_p_cuc
&& wp->w_virtcol >= vcol_hlc(wlv) - eol_hl_off && wp->w_virtcol >= vcol_hlc(wlv) - eol_hl_off
&& wp->w_virtcol < grid->cols * (ptrdiff_t)(wlv.row - startrow + 1) + start_col && wp->w_virtcol < view_width * (ptrdiff_t)(wlv.row - startrow + 1) + start_col
&& lnum != wp->w_cursor.lnum) && lnum != wp->w_cursor.lnum)
|| wlv.color_cols || wlv.line_attr_lowprio || wlv.line_attr || wlv.color_cols || wlv.line_attr_lowprio || wlv.line_attr
|| wlv.diff_hlf != 0 || wp->w_buffer->terminal)) { || wlv.diff_hlf != 0 || wp->w_buffer->terminal)) {
@@ -2776,7 +2778,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
rightmost_vcol = INT_MAX; rightmost_vcol = INT_MAX;
} }
while (wlv.col < grid->cols) { while (wlv.col < view_width) {
linebuf_char[wlv.off] = schar_from_ascii(' '); linebuf_char[wlv.off] = schar_from_ascii(' ');
advance_color_col(&wlv, vcol_hlc(wlv)); advance_color_col(&wlv, vcol_hlc(wlv));
@@ -2809,7 +2811,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
} }
if (kv_size(fold_vt) > 0) { if (kv_size(fold_vt) > 0) {
draw_virt_text_item(buf, win_col_offset, fold_vt, kHlModeCombine, grid->cols, 0, 0); draw_virt_text_item(buf, win_col_offset, fold_vt, kHlModeCombine, view_width, 0, 0);
} }
draw_virt_text(wp, buf, win_col_offset, &wlv.col, wlv.row); draw_virt_text(wp, buf, win_col_offset, &wlv.col, wlv.row);
// Set increasing virtual columns in grid->vcols[] to set correct curswant // Set increasing virtual columns in grid->vcols[] to set correct curswant
@@ -2837,7 +2839,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
&& wp->w_p_list && wp->w_p_list
&& !wp->w_p_wrap && !wp->w_p_wrap
&& wlv.filler_todo <= 0 && wlv.filler_todo <= 0
&& wlv.col == grid->cols - 1 && wlv.col == view_width - 1
&& !has_foldtext) { && !has_foldtext) {
if (has_decor && *ptr == NUL && lcs_eol == 0 && lcs_eol_todo) { if (has_decor && *ptr == NUL && lcs_eol == 0 && lcs_eol_todo) {
// Tricky: there might be a virtual text just _after_ the last char // Tricky: there might be a virtual text just _after_ the last char
@@ -2999,7 +3001,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
wlv.char_attr = saved_attr2; wlv.char_attr = saved_attr2;
} }
if (has_decor && wlv.filler_todo <= 0 && wlv.col >= grid->cols) { if (has_decor && wlv.filler_todo <= 0 && wlv.col >= view_width) {
// At the end of screen line: might need to peek for decorations just after // At the end of screen line: might need to peek for decorations just after
// this position. // this position.
if (is_wrapped && wlv.n_extra == 0) { if (is_wrapped && wlv.n_extra == 0) {
@@ -3017,7 +3019,7 @@ int win_line(win_T *wp, linenr_T lnum, int startrow, int endrow, int col_rows, b
end_check: end_check:
// At end of screen line and there is more to come: Display the line // At end of screen line and there is more to come: Display the line
// so far. If there is no more to display it is caught above. // so far. If there is no more to display it is caught above.
if (wlv.col >= grid->cols && (!has_foldtext || virt_line_index >= 0) if (wlv.col >= view_width && (!has_foldtext || virt_line_index >= 0)
&& (wlv.col <= leftcols_width && (wlv.col <= leftcols_width
|| *ptr != NUL || *ptr != NUL
|| wlv.filler_todo > 0 || wlv.filler_todo > 0
@@ -3028,20 +3030,20 @@ end_check:
&& wlv.filler_todo <= 0 // Not drawing diff filler lines. && wlv.filler_todo <= 0 // Not drawing diff filler lines.
&& lcs_eol_todo // Haven't printed the lcs_eol character. && lcs_eol_todo // Haven't printed the lcs_eol character.
&& wlv.row != endrow - 1 // Not the last line being displayed. && wlv.row != endrow - 1 // Not the last line being displayed.
&& (grid->cols == Columns // Window spans the width of the screen, && (view_width == Columns // Window spans the width of the screen,
|| ui_has(kUIMultigrid)) // or has dedicated grid. || wp->w_grid_alloc.chars) // or has dedicated grid.
&& !wp->w_p_rl; // Not right-to-left. && !wp->w_p_rl; // Not right-to-left.
int draw_col = wlv.col - wlv.boguscols; int draw_col = wlv.col - wlv.boguscols;
for (int i = draw_col; i < grid->cols; i++) { for (int i = draw_col; i < view_width; i++) {
linebuf_vcol[wlv.off + (i - draw_col)] = wlv.vcol - 1; linebuf_vcol[wlv.off + (i - draw_col)] = wlv.vcol - 1;
} }
// Apply 'cursorline' highlight. // Apply 'cursorline' highlight.
if (wlv.boguscols != 0 && (wlv.line_attr_lowprio != 0 || wlv.line_attr != 0)) { if (wlv.boguscols != 0 && (wlv.line_attr_lowprio != 0 || wlv.line_attr != 0)) {
int attr = hl_combine_attr(wlv.line_attr_lowprio, wlv.line_attr); int attr = hl_combine_attr(wlv.line_attr_lowprio, wlv.line_attr);
while (draw_col < grid->cols) { while (draw_col < view_width) {
linebuf_char[wlv.off] = schar_from_char(' '); linebuf_char[wlv.off] = schar_from_char(' ');
linebuf_attr[wlv.off] = attr; linebuf_attr[wlv.off] = attr;
// linebuf_vcol[] already filled by the for loop above // linebuf_vcol[] already filled by the for loop above
@@ -3055,7 +3057,7 @@ end_check:
virt_line_flags & kVLLeftcol ? 0 : win_col_offset, virt_line_flags & kVLLeftcol ? 0 : win_col_offset,
kv_A(virt_lines, virt_line_index).line, kv_A(virt_lines, virt_line_index).line,
kHlModeReplace, kHlModeReplace,
grid->cols, view_width,
0, 0,
virt_line_flags & kVLScroll ? wp->w_leftcol : 0); virt_line_flags & kVLScroll ? wp->w_leftcol : 0);
} else if (wlv.filler_todo <= 0) { } else if (wlv.filler_todo <= 0) {
@@ -3064,10 +3066,9 @@ end_check:
wlv_put_linebuf(wp, &wlv, draw_col, true, bg_attr, wrap ? SLF_WRAP : 0); wlv_put_linebuf(wp, &wlv, draw_col, true, bg_attr, wrap ? SLF_WRAP : 0);
if (wrap) { if (wrap) {
ScreenGrid *current_grid = grid;
int current_row = wlv.row; int current_row = wlv.row;
int dummy_col = 0; // unused int dummy_col = 0; // unused
grid_adjust(&current_grid, &current_row, &dummy_col); ScreenGrid *current_grid = grid_adjust(grid, &current_row, &dummy_col);
// Force a redraw of the first column of the next line. // Force a redraw of the first column of the next line.
current_grid->attrs[current_grid->line_offset[current_row + 1]] = -1; current_grid->attrs[current_grid->line_offset[current_row + 1]] = -1;
@@ -3084,7 +3085,7 @@ end_check:
// When the window is too narrow draw all "@" lines. // When the window is too narrow draw all "@" lines.
if (wlv.col <= leftcols_width) { if (wlv.col <= leftcols_width) {
win_draw_end(wp, schar_from_ascii('@'), true, wlv.row, wp->w_grid.rows, HLF_AT); win_draw_end(wp, schar_from_ascii('@'), true, wlv.row, wp->w_view_height, HLF_AT);
set_empty_rows(wp, wlv.row); set_empty_rows(wp, wlv.row);
wlv.row = endrow; wlv.row = endrow;
} }
@@ -3132,14 +3133,14 @@ end_check:
static void wlv_put_linebuf(win_T *wp, const winlinevars_T *wlv, int endcol, bool clear_end, static void wlv_put_linebuf(win_T *wp, const winlinevars_T *wlv, int endcol, bool clear_end,
int bg_attr, int flags) int bg_attr, int flags)
{ {
ScreenGrid *grid = &wp->w_grid; GridView *grid = &wp->w_grid;
int startcol = 0; int startcol = 0;
int clear_width = clear_end ? grid->cols : endcol; int clear_width = clear_end ? wp->w_view_width : endcol;
assert(!(flags & SLF_RIGHTLEFT)); assert(!(flags & SLF_RIGHTLEFT));
if (wp->w_p_rl) { if (wp->w_p_rl) {
linebuf_mirror(&startcol, &endcol, &clear_width, grid->cols); linebuf_mirror(&startcol, &endcol, &clear_width, wp->w_view_width);
flags |= SLF_RIGHTLEFT; flags |= SLF_RIGHTLEFT;
} }
@@ -3152,13 +3153,13 @@ static void wlv_put_linebuf(win_T *wp, const winlinevars_T *wlv, int endcol, boo
int off = 0; int off = 0;
if (wp->w_p_nu && wp->w_p_rnu) { if (wp->w_p_nu && wp->w_p_rnu) {
// do not overwrite the line number, change "123 text" to "123<<<xt". // do not overwrite the line number, change "123 text" to "123<<<xt".
while (off < grid->cols && ascii_isdigit(schar_get_ascii(linebuf_char[off]))) { while (off < wp->w_view_width && ascii_isdigit(schar_get_ascii(linebuf_char[off]))) {
off++; off++;
} }
} }
for (int i = 0; i < 3 && off < grid->cols; i++) { for (int i = 0; i < 3 && off < wp->w_view_width; i++) {
if (off + 1 < grid->cols && linebuf_char[off + 1] == NUL) { if (off + 1 < wp->w_view_width && linebuf_char[off + 1] == NUL) {
// When the first half of a double-width character is // When the first half of a double-width character is
// overwritten, change the second half to a space. // overwritten, change the second half to a space.
linebuf_char[off + 1] = schar_from_ascii(' '); linebuf_char[off + 1] = schar_from_ascii(' ');
@@ -3171,6 +3172,6 @@ static void wlv_put_linebuf(win_T *wp, const winlinevars_T *wlv, int endcol, boo
int row = wlv->row; int row = wlv->row;
int coloff = 0; int coloff = 0;
grid_adjust(&grid, &row, &coloff); ScreenGrid *g = grid_adjust(grid, &row, &coloff);
grid_put_linebuf(grid, row, coloff, startcol, endcol, clear_width, bg_attr, wlv->vcol - 1, flags); grid_put_linebuf(g, row, coloff, startcol, endcol, clear_width, bg_attr, wlv->vcol - 1, flags);
} }

148
src/nvim/drawscreen.c
View File

@@ -210,8 +210,6 @@ bool default_grid_alloc(void)
default_grid.comp_height = Rows; default_grid.comp_height = Rows;
default_grid.comp_width = Columns; default_grid.comp_width = Columns;
default_grid.row_offset = 0;
default_grid.col_offset = 0;
default_grid.handle = DEFAULT_GRID_HANDLE; default_grid.handle = DEFAULT_GRID_HANDLE;
resizing = false; resizing = false;
@@ -569,7 +567,7 @@ int update_screen(void)
// might need to clear space on default_grid for the message area. // might need to clear space on default_grid for the message area.
if (type == UPD_NOT_VALID && clear_cmdline && !ui_has(kUIMessages)) { if (type == UPD_NOT_VALID && clear_cmdline && !ui_has(kUIMessages)) {
grid_clear(&default_grid, Rows - (int)p_ch, Rows, 0, Columns, 0); grid_clear(&default_gridview, Rows - (int)p_ch, Rows, 0, Columns, 0);
} }
ui_comp_set_screen_valid(true); ui_comp_set_screen_valid(true);
@@ -773,11 +771,11 @@ static void win_redr_border(win_T *wp)
int *attrs = wp->w_config.border_attr; int *attrs = wp->w_config.border_attr;
int *adj = wp->w_border_adj; int *adj = wp->w_border_adj;
int irow = wp->w_height_inner + wp->w_winbar_height; int irow = wp->w_view_height + wp->w_winbar_height;
int icol = wp->w_width_inner; int icol = wp->w_view_width;
if (adj[0]) { if (adj[0]) {
grid_line_start(grid, 0); screengrid_line_start(grid, 0, 0);
if (adj[3]) { if (adj[3]) {
grid_line_put_schar(0, chars[0], attrs[0]); grid_line_put_schar(0, chars[0], attrs[0]);
} }
@@ -799,20 +797,20 @@ static void win_redr_border(win_T *wp)
for (int i = 0; i < irow; i++) { for (int i = 0; i < irow; i++) {
if (adj[3]) { if (adj[3]) {
grid_line_start(grid, i + adj[0]); screengrid_line_start(grid, i + adj[0], 0);
grid_line_put_schar(0, chars[7], attrs[7]); grid_line_put_schar(0, chars[7], attrs[7]);
grid_line_flush(); grid_line_flush();
} }
if (adj[1]) { if (adj[1]) {
int ic = (i == 0 && !adj[0] && chars[2]) ? 2 : 3; int ic = (i == 0 && !adj[0] && chars[2]) ? 2 : 3;
grid_line_start(grid, i + adj[0]); screengrid_line_start(grid, i + adj[0], 0);
grid_line_put_schar(icol + adj[3], chars[ic], attrs[ic]); grid_line_put_schar(icol + adj[3], chars[ic], attrs[ic]);
grid_line_flush(); grid_line_flush();
} }
} }
if (adj[2]) { if (adj[2]) {
grid_line_start(grid, irow + adj[0]); screengrid_line_start(grid, irow + adj[0], 0);
if (adj[3]) { if (adj[3]) {
grid_line_put_schar(0, chars[6], attrs[6]); grid_line_put_schar(0, chars[6], attrs[6]);
} }
@@ -847,21 +845,22 @@ void setcursor_mayforce(win_T *wp, bool force)
if (force || redrawing()) { if (force || redrawing()) {
validate_cursor(wp); validate_cursor(wp);
ScreenGrid *grid = &wp->w_grid;
int row = wp->w_wrow; int row = wp->w_wrow;
int col = wp->w_wcol; int col = wp->w_wcol;
if (wp->w_p_rl) { if (wp->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.
char *cursor = ml_get_buf(wp->w_buffer, wp->w_cursor.lnum) + wp->w_cursor.col; char *cursor = ml_get_buf(wp->w_buffer, wp->w_cursor.lnum) + wp->w_cursor.col;
col = wp->w_width_inner - wp->w_wcol - ((utf_ptr2cells(cursor) == 2 col = wp->w_view_width - wp->w_wcol - ((utf_ptr2cells(cursor) == 2
&& vim_isprintc(utf_ptr2char(cursor))) ? 2 : 1); && vim_isprintc(utf_ptr2char(cursor))) ? 2 : 1);
} }
grid_adjust(&grid, &row, &col); ScreenGrid *grid = grid_adjust(&wp->w_grid, &row, &col);
if (grid) {
ui_grid_cursor_goto(grid->handle, row, col); ui_grid_cursor_goto(grid->handle, row, col);
} }
} }
}
/// Mark the title and icon for redraw if either of them uses statusline format. /// Mark the title and icon for redraw if either of them uses statusline format.
/// ///
@@ -1338,7 +1337,7 @@ static void draw_vsep_win(win_T *wp)
// draw the vertical separator right of this window // draw the vertical separator right of this window
for (int row = wp->w_winrow; row < W_ENDROW(wp); row++) { for (int row = wp->w_winrow; row < W_ENDROW(wp); row++) {
grid_line_start(&default_grid, row); grid_line_start(&default_gridview, row);
grid_line_put_schar(W_ENDCOL(wp), wp->w_p_fcs_chars.vert, win_hl_attr(wp, HLF_C)); grid_line_put_schar(W_ENDCOL(wp), wp->w_p_fcs_chars.vert, win_hl_attr(wp, HLF_C));
grid_line_flush(); grid_line_flush();
} }
@@ -1352,7 +1351,7 @@ static void draw_hsep_win(win_T *wp)
} }
// draw the horizontal separator below this window // draw the horizontal separator below this window
grid_line_start(&default_grid, W_ENDROW(wp)); grid_line_start(&default_gridview, W_ENDROW(wp));
grid_line_fill(wp->w_wincol, W_ENDCOL(wp), wp->w_p_fcs_chars.horiz, win_hl_attr(wp, HLF_C)); grid_line_fill(wp->w_wincol, W_ENDCOL(wp), wp->w_p_fcs_chars.horiz, win_hl_attr(wp, HLF_C));
grid_line_flush(); grid_line_flush();
} }
@@ -1417,22 +1416,22 @@ static void draw_sep_connectors_win(win_T *wp)
bool bot_right = !(win_at_bottom || win_at_right); bool bot_right = !(win_at_bottom || win_at_right);
if (top_left) { if (top_left) {
grid_line_start(&default_grid, wp->w_winrow - 1); grid_line_start(&default_gridview, wp->w_winrow - 1);
grid_line_put_schar(wp->w_wincol - 1, get_corner_sep_connector(wp, WC_TOP_LEFT), hl); grid_line_put_schar(wp->w_wincol - 1, get_corner_sep_connector(wp, WC_TOP_LEFT), hl);
grid_line_flush(); grid_line_flush();
} }
if (top_right) { if (top_right) {
grid_line_start(&default_grid, wp->w_winrow - 1); grid_line_start(&default_gridview, wp->w_winrow - 1);
grid_line_put_schar(W_ENDCOL(wp), get_corner_sep_connector(wp, WC_TOP_RIGHT), hl); grid_line_put_schar(W_ENDCOL(wp), get_corner_sep_connector(wp, WC_TOP_RIGHT), hl);
grid_line_flush(); grid_line_flush();
} }
if (bot_left) { if (bot_left) {
grid_line_start(&default_grid, W_ENDROW(wp)); grid_line_start(&default_gridview, W_ENDROW(wp));
grid_line_put_schar(wp->w_wincol - 1, get_corner_sep_connector(wp, WC_BOTTOM_LEFT), hl); grid_line_put_schar(wp->w_wincol - 1, get_corner_sep_connector(wp, WC_BOTTOM_LEFT), hl);
grid_line_flush(); grid_line_flush();
} }
if (bot_right) { if (bot_right) {
grid_line_start(&default_grid, W_ENDROW(wp)); grid_line_start(&default_gridview, W_ENDROW(wp));
grid_line_put_schar(W_ENDCOL(wp), get_corner_sep_connector(wp, WC_BOTTOM_RIGHT), hl); grid_line_put_schar(W_ENDCOL(wp), get_corner_sep_connector(wp, WC_BOTTOM_RIGHT), hl);
grid_line_flush(); grid_line_flush();
} }
@@ -1500,7 +1499,7 @@ static void win_update(win_T *wp)
} }
// Window is zero-height: Only need to draw the separator // Window is zero-height: Only need to draw the separator
if (wp->w_grid.rows == 0) { if (wp->w_view_height == 0) {
// draw the horizontal separator below this window // draw the horizontal separator below this window
draw_hsep_win(wp); draw_hsep_win(wp);
draw_sep_connectors_win(wp); draw_sep_connectors_win(wp);
@@ -1509,7 +1508,7 @@ static void win_update(win_T *wp)
} }
// Window is zero-width: Only need to draw the separator. // Window is zero-width: Only need to draw the separator.
if (wp->w_grid.cols == 0) { if (wp->w_view_width == 0) {
// draw the vertical separator right of this window // draw the vertical separator right of this window
draw_vsep_win(wp); draw_vsep_win(wp);
draw_sep_connectors_win(wp); draw_sep_connectors_win(wp);
@@ -1544,9 +1543,9 @@ static void win_update(win_T *wp)
// Make sure skipcol is valid, it depends on various options and the window // Make sure skipcol is valid, it depends on various options and the window
// width. // width.
if (wp->w_skipcol > 0 && wp->w_width_inner > win_col_off(wp)) { if (wp->w_skipcol > 0 && wp->w_view_width > win_col_off(wp)) {
int w = 0; int w = 0;
int width1 = wp->w_width_inner - win_col_off(wp); int width1 = wp->w_view_width - win_col_off(wp);
int width2 = width1 + win_col_off2(wp); int width2 = width1 + win_col_off2(wp);
int add = width1; int add = width1;
@@ -1738,7 +1737,7 @@ static void win_update(win_T *wp)
j = 0; j = 0;
for (linenr_T ln = wp->w_topline; ln < wp->w_lines[0].wl_lnum; ln++) { for (linenr_T ln = wp->w_topline; ln < wp->w_lines[0].wl_lnum; ln++) {
j += !decor_conceal_line(wp, ln - 1, false); j += !decor_conceal_line(wp, ln - 1, false);
if (j >= wp->w_grid.rows - 2) { if (j >= wp->w_view_height - 2) {
break; break;
} }
hasFolding(wp, ln, NULL, &ln); hasFolding(wp, ln, NULL, &ln);
@@ -1746,13 +1745,13 @@ static void win_update(win_T *wp)
} else { } else {
j = wp->w_lines[0].wl_lnum - wp->w_topline; j = wp->w_lines[0].wl_lnum - wp->w_topline;
} }
if (j < wp->w_grid.rows - 2) { // not too far off if (j < wp->w_view_height - 2) { // not too far off
int i = plines_m_win(wp, wp->w_topline, wp->w_lines[0].wl_lnum - 1, wp->w_height_inner); int i = plines_m_win(wp, wp->w_topline, wp->w_lines[0].wl_lnum - 1, wp->w_view_height);
// insert extra lines for previously invisible filler lines // insert extra lines for previously invisible filler lines
if (wp->w_lines[0].wl_lnum != wp->w_topline) { if (wp->w_lines[0].wl_lnum != wp->w_topline) {
i += win_get_fill(wp, wp->w_lines[0].wl_lnum) - wp->w_old_topfill; i += win_get_fill(wp, wp->w_lines[0].wl_lnum) - wp->w_old_topfill;
} }
if (i != 0 && i < wp->w_grid.rows - 2) { // less than a screen off if (i != 0 && i < wp->w_view_height - 2) { // less than a screen off
// Try to insert the correct number of lines. // Try to insert the correct number of lines.
// If not the last window, delete the lines at the bottom. // If not the last window, delete the lines at the bottom.
// win_ins_lines may fail when the terminal can't do it. // win_ins_lines may fail when the terminal can't do it.
@@ -1766,8 +1765,8 @@ static void win_update(win_T *wp)
// Move the entries that were scrolled, disable // Move the entries that were scrolled, disable
// the entries for the lines to be redrawn. // the entries for the lines to be redrawn.
if ((wp->w_lines_valid += (linenr_T)j) > wp->w_grid.rows) { if ((wp->w_lines_valid += (linenr_T)j) > wp->w_view_height) {
wp->w_lines_valid = wp->w_grid.rows; wp->w_lines_valid = wp->w_view_height;
} }
int idx; int idx;
for (idx = wp->w_lines_valid; idx - j >= 0; idx--) { for (idx = wp->w_lines_valid; idx - j >= 0; idx--) {
@@ -1818,7 +1817,7 @@ static void win_update(win_T *wp)
row -= wp->w_topfill; row -= wp->w_topfill;
if (row > 0) { if (row > 0) {
win_scroll_lines(wp, 0, -row); win_scroll_lines(wp, 0, -row);
bot_start = wp->w_grid.rows - row; bot_start = wp->w_view_height - row;
bot_scroll_start = bot_start; bot_scroll_start = bot_start;
} }
if ((row == 0 || bot_start < 999) && wp->w_lines_valid != 0) { if ((row == 0 || bot_start < 999) && wp->w_lines_valid != 0) {
@@ -1833,7 +1832,7 @@ static void win_update(win_T *wp)
// stop at line that didn't fit, unless it is still // stop at line that didn't fit, unless it is still
// valid (no lines deleted) // valid (no lines deleted)
if (row > 0 && bot_start + row if (row > 0 && bot_start + row
+ (int)wp->w_lines[j].wl_size > wp->w_grid.rows) { + (int)wp->w_lines[j].wl_size > wp->w_view_height) {
wp->w_lines_valid = idx + 1; wp->w_lines_valid = idx + 1;
break; break;
} }
@@ -1851,7 +1850,7 @@ static void win_update(win_T *wp)
if (win_may_fill(wp) && bot_start > 0) { if (win_may_fill(wp) && bot_start > 0) {
int n = plines_win_nofill(wp, wp->w_topline, false) + wp->w_topfill int n = plines_win_nofill(wp, wp->w_topline, false) + wp->w_topfill
- adjust_plines_for_skipcol(wp); - adjust_plines_for_skipcol(wp);
n = MIN(n, wp->w_height_inner); n = MIN(n, wp->w_view_height);
wp->w_lines[0].wl_size = (uint16_t)n; wp->w_lines[0].wl_size = (uint16_t)n;
} }
} }
@@ -1860,18 +1859,18 @@ static void win_update(win_T *wp)
// When starting redraw in the first line, redraw all lines. // When starting redraw in the first line, redraw all lines.
if (mid_start == 0) { if (mid_start == 0) {
mid_end = wp->w_grid.rows; mid_end = wp->w_view_height;
} }
} else { } else {
// Not UPD_VALID or UPD_INVERTED: redraw all lines. // Not UPD_VALID or UPD_INVERTED: redraw all lines.
mid_start = 0; mid_start = 0;
mid_end = wp->w_grid.rows; mid_end = wp->w_view_height;
} }
if (type == UPD_SOME_VALID) { if (type == UPD_SOME_VALID) {
// UPD_SOME_VALID: redraw all lines. // UPD_SOME_VALID: redraw all lines.
mid_start = 0; mid_start = 0;
mid_end = wp->w_grid.rows; mid_end = wp->w_view_height;
type = UPD_NOT_VALID; type = UPD_NOT_VALID;
} }
@@ -2019,7 +2018,7 @@ static void win_update(win_T *wp)
} }
} }
srow += mid_start; srow += mid_start;
mid_end = wp->w_grid.rows; mid_end = wp->w_view_height;
for (; idx < wp->w_lines_valid; idx++) { // find end for (; idx < wp->w_lines_valid; idx++) { // find end
if (wp->w_lines[idx].wl_valid if (wp->w_lines[idx].wl_valid
&& wp->w_lines[idx].wl_lnum >= to + 1) { && wp->w_lines[idx].wl_lnum >= to + 1) {
@@ -2068,7 +2067,7 @@ static void win_update(win_T *wp)
while (true) { while (true) {
// stop updating when reached the end of the window (check for _past_ // stop updating when reached the end of the window (check for _past_
// the end of the window is at the end of the loop) // the end of the window is at the end of the loop)
if (row == wp->w_grid.rows) { if (row == wp->w_view_height) {
didline = true; didline = true;
break; break;
} }
@@ -2191,9 +2190,9 @@ static void win_update(win_T *wp)
for (l = lnum; l < mod_bot; l++) { for (l = lnum; l < mod_bot; l++) {
int n = plines_win_full(wp, l, &l, NULL, true, false); int n = plines_win_full(wp, l, &l, NULL, true, false);
n -= (l == wp->w_topline ? adjust_plines_for_skipcol(wp) : 0); n -= (l == wp->w_topline ? adjust_plines_for_skipcol(wp) : 0);
new_rows += MIN(n, wp->w_height_inner); new_rows += MIN(n, wp->w_view_height);
j += n > 0; // don't count concealed lines j += n > 0; // don't count concealed lines
if (new_rows > wp->w_grid.rows - row - 2) { if (new_rows > wp->w_view_height - row - 2) {
// it's getting too much, must redraw the rest // it's getting too much, must redraw the rest
new_rows = 9999; new_rows = 9999;
break; break;
@@ -2205,18 +2204,18 @@ static void win_update(win_T *wp)
// remaining text or scrolling fails, must redraw the // remaining text or scrolling fails, must redraw the
// rest. If scrolling works, must redraw the text // rest. If scrolling works, must redraw the text
// below the scrolled text. // below the scrolled text.
if (row - xtra_rows >= wp->w_grid.rows - 2) { if (row - xtra_rows >= wp->w_view_height - 2) {
mod_bot = MAXLNUM; mod_bot = MAXLNUM;
} else { } else {
win_scroll_lines(wp, row, xtra_rows); win_scroll_lines(wp, row, xtra_rows);
bot_start = wp->w_grid.rows + xtra_rows; bot_start = wp->w_view_height + xtra_rows;
bot_scroll_start = bot_start; bot_scroll_start = bot_start;
} }
} else if (xtra_rows > 0) { } else if (xtra_rows > 0) {
// May scroll text down. If there is not enough // May scroll text down. If there is not enough
// remaining text of scrolling fails, must redraw the // remaining text of scrolling fails, must redraw the
// rest. // rest.
if (row + xtra_rows >= wp->w_grid.rows - 2) { if (row + xtra_rows >= wp->w_view_height - 2) {
mod_bot = MAXLNUM; mod_bot = MAXLNUM;
} else { } else {
win_scroll_lines(wp, row + old_rows, xtra_rows); win_scroll_lines(wp, row + old_rows, xtra_rows);
@@ -2245,7 +2244,7 @@ static void win_update(win_T *wp)
wp->w_lines[j] = wp->w_lines[i]; wp->w_lines[j] = wp->w_lines[i];
// stop at a line that won't fit // stop at a line that won't fit
if (x + (int)wp->w_lines[j].wl_size if (x + (int)wp->w_lines[j].wl_size
> wp->w_grid.rows) { > wp->w_view_height) {
wp->w_lines_valid = j + 1; wp->w_lines_valid = j + 1;
break; break;
} }
@@ -2257,7 +2256,7 @@ static void win_update(win_T *wp)
// move entries in w_lines[] downwards // move entries in w_lines[] downwards
j -= i; j -= i;
wp->w_lines_valid += (linenr_T)j; wp->w_lines_valid += (linenr_T)j;
wp->w_lines_valid = MIN(wp->w_lines_valid, wp->w_grid.rows); wp->w_lines_valid = MIN(wp->w_lines_valid, wp->w_view_height);
for (i = wp->w_lines_valid; i - j >= idx; i--) { for (i = wp->w_lines_valid; i - j >= idx; i--) {
wp->w_lines[i] = wp->w_lines[i - j]; wp->w_lines[i] = wp->w_lines[i - j];
} }
@@ -2280,11 +2279,11 @@ static void win_update(win_T *wp)
&& wp->w_lines[idx].wl_lnum == lnum && wp->w_lines[idx].wl_lnum == lnum
&& lnum > wp->w_topline && lnum > wp->w_topline
&& !(dy_flags & (kOptDyFlagLastline | kOptDyFlagTruncate)) && !(dy_flags & (kOptDyFlagLastline | kOptDyFlagTruncate))
&& srow + wp->w_lines[idx].wl_size > wp->w_grid.rows && srow + wp->w_lines[idx].wl_size > wp->w_view_height
&& win_get_fill(wp, lnum) == 0) { && win_get_fill(wp, lnum) == 0) {
// This line is not going to fit. Don't draw anything here, // This line is not going to fit. Don't draw anything here,
// will draw "@ " lines below. // will draw "@ " lines below.
row = wp->w_grid.rows + 1; row = wp->w_view_height + 1;
} else { } else {
prepare_search_hl(wp, &screen_search_hl, lnum); prepare_search_hl(wp, &screen_search_hl, lnum);
// Let the syntax stuff know we skipped a few lines. // Let the syntax stuff know we skipped a few lines.
@@ -2297,7 +2296,7 @@ static void win_update(win_T *wp)
// Display one line // Display one line
spellvars_T zero_spv = { 0 }; spellvars_T zero_spv = { 0 };
row = win_line(wp, lnum, srow, wp->w_grid.rows, 0, concealed, row = win_line(wp, lnum, srow, wp->w_view_height, 0, concealed,
display_buf_line ? &spv : &zero_spv, foldinfo); display_buf_line ? &spv : &zero_spv, foldinfo);
if (display_buf_line) { if (display_buf_line) {
@@ -2320,7 +2319,7 @@ static void win_update(win_T *wp)
} }
// Adjust "wl_lastlnum" for concealed lines below the last line in the window. // Adjust "wl_lastlnum" for concealed lines below the last line in the window.
while (row == wp->w_grid.rows while (row == wp->w_view_height
&& wp->w_lines[idx].wl_lastlnum < buf->b_ml.ml_line_count && wp->w_lines[idx].wl_lastlnum < buf->b_ml.ml_line_count
&& decor_conceal_line(wp, wp->w_lines[idx].wl_lastlnum, false)) { && decor_conceal_line(wp, wp->w_lines[idx].wl_lastlnum, false)) {
wp->w_lines[idx].wl_lastlnum++; wp->w_lines[idx].wl_lastlnum++;
@@ -2331,7 +2330,7 @@ static void win_update(win_T *wp)
wp->w_lines[idx].wl_lnum = lnum; wp->w_lines[idx].wl_lnum = lnum;
wp->w_lines[idx].wl_valid = true; wp->w_lines[idx].wl_valid = true;
if (row > wp->w_grid.rows) { // past end of grid if (row > wp->w_view_height) { // past end of grid
// we may need the size of that too long line later on // we may need the size of that too long line later on
if (dollar_vcol == -1) { if (dollar_vcol == -1) {
wp->w_lines[idx].wl_size = (uint16_t)plines_win(wp, lnum, true); wp->w_lines[idx].wl_size = (uint16_t)plines_win(wp, lnum, true);
@@ -2355,12 +2354,12 @@ static void win_update(win_T *wp)
&& !decor_conceal_line(wp, lnum - 1, true)) { && !decor_conceal_line(wp, lnum - 1, true)) {
foldinfo_T info = wp->w_p_cul && lnum == wp->w_cursor.lnum foldinfo_T info = wp->w_p_cul && lnum == wp->w_cursor.lnum
? cursorline_fi : fold_info(wp, lnum); ? cursorline_fi : fold_info(wp, lnum);
win_line(wp, lnum, srow, wp->w_grid.rows, wp->w_lines[idx].wl_size, false, &spv, info); win_line(wp, lnum, srow, wp->w_view_height, wp->w_lines[idx].wl_size, false, &spv, info);
} }
// This line does not need to be drawn, advance to the next one. // This line does not need to be drawn, advance to the next one.
row += wp->w_lines[idx++].wl_size; row += wp->w_lines[idx++].wl_size;
if (row > wp->w_grid.rows) { // past end of screen if (row > wp->w_view_height) { // past end of screen
break; break;
} }
lnum = wp->w_lines[idx - 1].wl_lastlnum + 1; lnum = wp->w_lines[idx - 1].wl_lastlnum + 1;
@@ -2414,31 +2413,31 @@ redr_statuscol:
// Single line that does not fit! // Single line that does not fit!
// Don't overwrite it, it can be edited. // Don't overwrite it, it can be edited.
wp->w_botline = lnum + 1; wp->w_botline = lnum + 1;
} else if (win_get_fill(wp, lnum) >= wp->w_grid.rows - srow) { } else if (win_get_fill(wp, lnum) >= wp->w_view_height - srow) {
// Window ends in filler lines. // Window ends in filler lines.
wp->w_botline = lnum; wp->w_botline = lnum;
wp->w_filler_rows = wp->w_grid.rows - srow; wp->w_filler_rows = wp->w_view_height - srow;
} else if (dy_flags & kOptDyFlagTruncate) { // 'display' has "truncate" } else if (dy_flags & kOptDyFlagTruncate) { // 'display' has "truncate"
// Last line isn't finished: Display "@@@" in the last screen line. // Last line isn't finished: Display "@@@" in the last screen line.
grid_line_start(&wp->w_grid, wp->w_grid.rows - 1); grid_line_start(&wp->w_grid, wp->w_view_height - 1);
grid_line_fill(0, MIN(wp->w_grid.cols, 3), wp->w_p_fcs_chars.lastline, at_attr); grid_line_fill(0, MIN(wp->w_view_width, 3), wp->w_p_fcs_chars.lastline, at_attr);
grid_line_fill(3, wp->w_grid.cols, schar_from_ascii(' '), at_attr); grid_line_fill(3, wp->w_view_width, schar_from_ascii(' '), at_attr);
grid_line_flush(); grid_line_flush();
set_empty_rows(wp, srow); set_empty_rows(wp, srow);
wp->w_botline = lnum; wp->w_botline = lnum;
} else if (dy_flags & kOptDyFlagLastline) { // 'display' has "lastline" } else if (dy_flags & kOptDyFlagLastline) { // 'display' has "lastline"
// Last line isn't finished: Display "@@@" at the end. // Last line isn't finished: Display "@@@" at the end.
// If this would split a doublewidth char in two, we need to display "@@@@" instead // If this would split a doublewidth char in two, we need to display "@@@@" instead
grid_line_start(&wp->w_grid, wp->w_grid.rows - 1); grid_line_start(&wp->w_grid, wp->w_view_height - 1);
int width = grid_line_getchar(MAX(wp->w_grid.cols - 3, 0), NULL) == NUL ? 4 : 3; int width = grid_line_getchar(MAX(wp->w_view_width - 3, 0), NULL) == NUL ? 4 : 3;
grid_line_fill(MAX(wp->w_grid.cols - width, 0), wp->w_grid.cols, grid_line_fill(MAX(wp->w_view_width - width, 0), wp->w_view_width,
wp->w_p_fcs_chars.lastline, at_attr); wp->w_p_fcs_chars.lastline, at_attr);
grid_line_flush(); grid_line_flush();
set_empty_rows(wp, srow); set_empty_rows(wp, srow);
wp->w_botline = lnum; wp->w_botline = lnum;
} else { } else {
win_draw_end(wp, wp->w_p_fcs_chars.lastline, true, srow, win_draw_end(wp, wp->w_p_fcs_chars.lastline, true, srow,
wp->w_grid.rows, HLF_AT); wp->w_view_height, HLF_AT);
set_empty_rows(wp, srow); set_empty_rows(wp, srow);
wp->w_botline = lnum; wp->w_botline = lnum;
} }
@@ -2446,12 +2445,13 @@ redr_statuscol:
if (eof) { // we hit the end of the file if (eof) { // we hit the end of the file
wp->w_botline = buf->b_ml.ml_line_count + 1; wp->w_botline = buf->b_ml.ml_line_count + 1;
int j = win_get_fill(wp, wp->w_botline); int j = win_get_fill(wp, wp->w_botline);
if (j > 0 && !wp->w_botfill && row < wp->w_grid.rows) { if (j > 0 && !wp->w_botfill && row < wp->w_view_height) {
// Display filler text below last line. win_line() will check // Display filler text below last line. win_line() will check
// for ml_line_count+1 and only draw filler lines // for ml_line_count+1 and only draw filler lines
spellvars_T zero_spv = { 0 }; spellvars_T zero_spv = { 0 };
foldinfo_T zero_foldinfo = { 0 }; foldinfo_T zero_foldinfo = { 0 };
row = win_line(wp, wp->w_botline, row, wp->w_grid.rows, 0, false, &zero_spv, zero_foldinfo); row = win_line(wp, wp->w_botline, row, wp->w_view_height, 0, false, &zero_spv,
zero_foldinfo);
if (wp->w_redr_statuscol) { if (wp->w_redr_statuscol) {
eof = false; eof = false;
goto redr_statuscol; goto redr_statuscol;
@@ -2475,7 +2475,7 @@ redr_statuscol:
} }
win_draw_end(wp, wp->w_p_fcs_chars.eob, false, MAX(lastline, row), win_draw_end(wp, wp->w_p_fcs_chars.eob, false, MAX(lastline, row),
wp->w_grid.rows, wp->w_view_height,
HLF_EOB); HLF_EOB);
set_empty_rows(wp, row); set_empty_rows(wp, row);
} }
@@ -2551,16 +2551,20 @@ void win_scroll_lines(win_T *wp, int row, int line_count)
} }
// No lines are being moved, just draw over the entire area // No lines are being moved, just draw over the entire area
if (row + abs(line_count) >= wp->w_grid.rows) { if (row + abs(line_count) >= wp->w_view_height) {
return; return;
} }
int col = 0;
int row_off = 0;
ScreenGrid *grid = grid_adjust(&wp->w_grid, &row_off, &col);
if (line_count < 0) { if (line_count < 0) {
grid_del_lines(&wp->w_grid, row, -line_count, grid_del_lines(grid, row + row_off, -line_count,
wp->w_grid.rows, 0, wp->w_grid.cols); wp->w_view_height + row_off, col, wp->w_view_width);
} else { } else {
grid_ins_lines(&wp->w_grid, row, line_count, grid_ins_lines(grid, row + row_off, line_count,
wp->w_grid.rows, 0, wp->w_grid.cols); wp->w_view_height + row_off, col, wp->w_view_width);
} }
} }
@@ -2590,15 +2594,15 @@ void win_draw_end(win_T *wp, schar_T c1, bool draw_margin, int startrow, int end
int attr = hl_combine_attr(win_bg_attr(wp), win_hl_attr(wp, (int)hl)); int attr = hl_combine_attr(win_bg_attr(wp), win_hl_attr(wp, (int)hl));
if (n < wp->w_grid.cols) { if (n < wp->w_view_width) {
grid_line_put_schar(n, c1, 0); // base attr is inherited from clear grid_line_put_schar(n, c1, 0); // base attr is inherited from clear
n++; n++;
} }
grid_line_clear_end(n, wp->w_grid.cols, attr); grid_line_clear_end(n, wp->w_view_width, attr);
if (wp->w_p_rl) { if (wp->w_p_rl) {
grid_line_mirror(); grid_line_mirror(wp->w_view_width);
} }
grid_line_flush(); grid_line_flush();
} }
@@ -2610,7 +2614,7 @@ int compute_foldcolumn(win_T *wp, int col)
{ {
int fdc = win_fdccol_count(wp); int fdc = win_fdccol_count(wp);
int wmw = wp == curwin && p_wmw == 0 ? 1 : (int)p_wmw; int wmw = wp == curwin && p_wmw == 0 ? 1 : (int)p_wmw;
int n = wp->w_grid.cols - (col + wmw); int n = wp->w_view_width - (col + wmw);
return MIN(fdc, n); return MIN(fdc, n);
} }
@@ -2624,7 +2628,7 @@ int number_width(win_T *wp)
if (wp->w_p_rnu && !wp->w_p_nu) { if (wp->w_p_rnu && !wp->w_p_nu) {
// cursor line shows "0" // cursor line shows "0"
lnum = wp->w_height_inner; lnum = wp->w_view_height;
} else { } else {
// cursor line shows absolute line number // cursor line shows absolute line number
lnum = wp->w_buffer->b_ml.ml_line_count; lnum = wp->w_buffer->b_ml.ml_line_count;

6
src/nvim/edit.c
View File

@@ -479,7 +479,7 @@ static int insert_check(VimState *state)
curbuf->b_p_ts, curbuf->b_p_ts,
curbuf->b_p_vts_array, curbuf->b_p_vts_array,
false) false)
&& curwin->w_wrow == curwin->w_height_inner - 1 - get_scrolloff_value(curwin) && curwin->w_wrow == curwin->w_view_height - 1 - get_scrolloff_value(curwin)
&& (curwin->w_cursor.lnum != curwin->w_topline && (curwin->w_cursor.lnum != curwin->w_topline
|| curwin->w_topfill > 0)) { || curwin->w_topfill > 0)) {
if (curwin->w_topfill > 0) { if (curwin->w_topfill > 0) {
@@ -1478,7 +1478,7 @@ void edit_putchar(int c, bool highlight)
pc_status = PC_STATUS_UNSET; pc_status = PC_STATUS_UNSET;
grid_line_start(&curwin->w_grid, pc_row); grid_line_start(&curwin->w_grid, pc_row);
if (curwin->w_p_rl) { if (curwin->w_p_rl) {
pc_col = curwin->w_grid.cols - 1 - curwin->w_wcol; pc_col = curwin->w_view_width - 1 - curwin->w_wcol;
if (grid_line_getchar(pc_col, NULL) == NUL) { if (grid_line_getchar(pc_col, NULL) == NUL) {
grid_line_put_schar(pc_col - 1, schar_from_ascii(' '), attr); grid_line_put_schar(pc_col - 1, schar_from_ascii(' '), attr);
@@ -1603,7 +1603,7 @@ void display_dollar(colnr_T col_arg)
char *p = get_cursor_line_ptr(); char *p = get_cursor_line_ptr();
curwin->w_cursor.col -= utf_head_off(p, p + col); curwin->w_cursor.col -= utf_head_off(p, p + col);
curs_columns(curwin, false); // Recompute w_wrow and w_wcol curs_columns(curwin, false); // Recompute w_wrow and w_wcol
if (curwin->w_wcol < curwin->w_grid.cols) { if (curwin->w_wcol < curwin->w_view_width) {
edit_putchar('$', false); edit_putchar('$', false);
dollar_vcol = curwin->w_virtcol; dollar_vcol = curwin->w_virtcol;
} }

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

@@ -4019,8 +4019,8 @@ void f_jobstart(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
overlapped = false; overlapped = false;
detach = false; detach = false;
stdin_mode = kChannelStdinPipe; stdin_mode = kChannelStdinPipe;
width = (uint16_t)MAX(0, curwin->w_width_inner - win_col_off(curwin)); width = (uint16_t)MAX(0, curwin->w_view_width - win_col_off(curwin));
height = (uint16_t)curwin->w_height_inner; height = (uint16_t)curwin->w_view_height;
} }
if (pty) { if (pty) {

8
src/nvim/eval/window.c
View File

@@ -321,13 +321,13 @@ static dict_T *get_win_info(win_T *wp, int16_t tpnr, int16_t winnr)
tv_dict_add_nr(dict, S_LEN("tabnr"), tpnr); tv_dict_add_nr(dict, S_LEN("tabnr"), tpnr);
tv_dict_add_nr(dict, S_LEN("winnr"), winnr); tv_dict_add_nr(dict, S_LEN("winnr"), winnr);
tv_dict_add_nr(dict, S_LEN("winid"), wp->handle); tv_dict_add_nr(dict, S_LEN("winid"), wp->handle);
tv_dict_add_nr(dict, S_LEN("height"), wp->w_height_inner); tv_dict_add_nr(dict, S_LEN("height"), wp->w_view_height);
tv_dict_add_nr(dict, S_LEN("winrow"), wp->w_winrow + 1); tv_dict_add_nr(dict, S_LEN("winrow"), wp->w_winrow + 1);
tv_dict_add_nr(dict, S_LEN("topline"), wp->w_topline); tv_dict_add_nr(dict, S_LEN("topline"), wp->w_topline);
tv_dict_add_nr(dict, S_LEN("botline"), wp->w_botline - 1); tv_dict_add_nr(dict, S_LEN("botline"), wp->w_botline - 1);
tv_dict_add_nr(dict, S_LEN("leftcol"), wp->w_leftcol); tv_dict_add_nr(dict, S_LEN("leftcol"), wp->w_leftcol);
tv_dict_add_nr(dict, S_LEN("winbar"), wp->w_winbar_height); tv_dict_add_nr(dict, S_LEN("winbar"), wp->w_winbar_height);
tv_dict_add_nr(dict, S_LEN("width"), wp->w_width_inner); tv_dict_add_nr(dict, S_LEN("width"), wp->w_view_width);
tv_dict_add_nr(dict, S_LEN("bufnr"), wp->w_buffer->b_fnum); tv_dict_add_nr(dict, S_LEN("bufnr"), wp->w_buffer->b_fnum);
tv_dict_add_nr(dict, S_LEN("wincol"), wp->w_wincol + 1); tv_dict_add_nr(dict, S_LEN("wincol"), wp->w_wincol + 1);
tv_dict_add_nr(dict, S_LEN("textoff"), win_col_off(wp)); tv_dict_add_nr(dict, S_LEN("textoff"), win_col_off(wp));
@@ -786,7 +786,7 @@ void f_winheight(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
if (wp == NULL) { if (wp == NULL) {
rettv->vval.v_number = -1; rettv->vval.v_number = -1;
} else { } else {
rettv->vval.v_number = wp->w_height_inner; rettv->vval.v_number = wp->w_view_height;
} }
} }
@@ -923,7 +923,7 @@ void f_winwidth(typval_T *argvars, typval_T *rettv, EvalFuncData fptr)
if (wp == NULL) { if (wp == NULL) {
rettv->vval.v_number = -1; rettv->vval.v_number = -1;
} else { } else {
rettv->vval.v_number = wp->w_width_inner; rettv->vval.v_number = wp->w_view_width;
} }
} }

4
src/nvim/ex_cmds.c
View File

@@ -263,7 +263,7 @@ void ex_align(exarg_T *eap)
width = (int)curbuf->b_p_tw; width = (int)curbuf->b_p_tw;
} }
if (width == 0 && curbuf->b_p_wm > 0) { if (width == 0 && curbuf->b_p_wm > 0) {
width = curwin->w_width_inner - (int)curbuf->b_p_wm; width = curwin->w_view_width - (int)curbuf->b_p_wm;
} }
if (width <= 0) { if (width <= 0) {
width = 80; width = 80;
@@ -2949,7 +2949,7 @@ void ex_z(exarg_T *eap)
} 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_inner - 3; bigness = curwin->w_view_height - 3;
} }
bigness = MAX(bigness, 1); bigness = MAX(bigness, 1);

6
src/nvim/ex_session.c
View File

@@ -468,7 +468,7 @@ static int put_view(FILE *fd, win_T *wp, int add_edit, unsigned *flagp, int curr
if (do_cursor) { if (do_cursor) {
// Restore the cursor line in the file and relatively in the // Restore the cursor line in the file and relatively in the
// window. Don't use "G", it changes the jumplist. // window. Don't use "G", it changes the jumplist.
if (wp->w_height_inner <= 0) { if (wp->w_view_height <= 0) {
if (fprintf(fd, "let s:l = %" PRIdLINENR "\n", wp->w_cursor.lnum) < 0) { if (fprintf(fd, "let s:l = %" PRIdLINENR "\n", wp->w_cursor.lnum) < 0) {
return FAIL; return FAIL;
} }
@@ -477,8 +477,8 @@ static int put_view(FILE *fd, win_T *wp, int add_edit, unsigned *flagp, int curr
" * winheight(0) + %d) / %d)\n", " * winheight(0) + %d) / %d)\n",
wp->w_cursor.lnum, wp->w_cursor.lnum,
wp->w_cursor.lnum - wp->w_topline, wp->w_cursor.lnum - wp->w_topline,
(wp->w_height_inner / 2), (wp->w_view_height / 2),
wp->w_height_inner) < 0) { wp->w_view_height) < 0) {
return FAIL; return FAIL;
} }
if (fprintf(fd, if (fprintf(fd,

6
src/nvim/getchar.c
View File

@@ -2749,8 +2749,8 @@ static int vgetorpeek(bool advance)
} }
curwin->w_wrow = curwin->w_cline_row curwin->w_wrow = curwin->w_cline_row
+ curwin->w_wcol / curwin->w_width_inner; + curwin->w_wcol / curwin->w_view_width;
curwin->w_wcol %= curwin->w_width_inner; curwin->w_wcol %= curwin->w_view_width;
curwin->w_wcol += win_col_off(curwin); curwin->w_wcol += win_col_off(curwin);
col = 0; // no correction needed col = 0; // no correction needed
} else { } else {
@@ -2759,7 +2759,7 @@ static int vgetorpeek(bool 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_inner - 1; curwin->w_wcol = curwin->w_view_width - 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) {

59
src/nvim/grid.c
View File

@@ -64,13 +64,11 @@ static Set(glyph) glyph_cache = SET_INIT;
/// ///
/// If the default_grid is used, adjust window relative positions to global /// If the default_grid is used, adjust window relative positions to global
/// screen positions. /// screen positions.
void grid_adjust(ScreenGrid **grid, int *row_off, int *col_off) ScreenGrid *grid_adjust(GridView *grid, int *row_off, int *col_off)
{ {
if ((*grid)->target) { *row_off += grid->row_offset;
*row_off += (*grid)->row_offset; *col_off += grid->col_offset;
*col_off += (*grid)->col_offset; return grid->target;
*grid = (*grid)->target;
}
} }
schar_T schar_from_str(const char *str) schar_T schar_from_str(const char *str)
@@ -337,8 +335,6 @@ static bool grid_invalid_row(ScreenGrid *grid, int row)
/// @param[out] attrp set to the character's attribute (optional) /// @param[out] attrp set to the character's attribute (optional)
schar_T grid_getchar(ScreenGrid *grid, int row, int col, int *attrp) schar_T grid_getchar(ScreenGrid *grid, int row, int col, int *attrp)
{ {
grid_adjust(&grid, &row, &col);
// safety check // safety check
if (grid->chars == NULL || row >= grid->rows || col >= grid->cols) { if (grid->chars == NULL || row >= grid->rows || col >= grid->cols) {
return NUL; return NUL;
@@ -365,11 +361,16 @@ static int grid_line_flags = 0;
/// ///
/// Must be matched with a grid_line_flush call before moving to /// Must be matched with a grid_line_flush call before moving to
/// another line. /// another line.
void grid_line_start(ScreenGrid *grid, int row) void grid_line_start(GridView *view, int row)
{ {
int col = 0; int col = 0;
ScreenGrid *grid = grid_adjust(view, &row, &col);
screengrid_line_start(grid, row, col);
}
void screengrid_line_start(ScreenGrid *grid, int row, int col)
{
grid_line_maxcol = grid->cols; grid_line_maxcol = grid->cols;
grid_adjust(&grid, &row, &col);
assert(grid_line_grid == NULL); assert(grid_line_grid == NULL);
grid_line_row = row; grid_line_row = row;
grid_line_grid = grid; grid_line_grid = grid;
@@ -534,23 +535,23 @@ void grid_line_cursor_goto(int col)
ui_grid_cursor_goto(grid_line_grid->handle, grid_line_row, col); ui_grid_cursor_goto(grid_line_grid->handle, grid_line_row, col);
} }
void grid_line_mirror(void) void grid_line_mirror(int width)
{ {
grid_line_clear_to = MAX(grid_line_last, grid_line_clear_to); grid_line_clear_to = MAX(grid_line_last, grid_line_clear_to);
if (grid_line_first >= grid_line_clear_to) { if (grid_line_first >= grid_line_clear_to) {
return; return;
} }
linebuf_mirror(&grid_line_first, &grid_line_last, &grid_line_clear_to, grid_line_maxcol); linebuf_mirror(&grid_line_first, &grid_line_last, &grid_line_clear_to, width);
grid_line_flags |= SLF_RIGHTLEFT; grid_line_flags |= SLF_RIGHTLEFT;
} }
void linebuf_mirror(int *firstp, int *lastp, int *clearp, int maxcol) void linebuf_mirror(int *firstp, int *lastp, int *clearp, int width)
{ {
int first = *firstp; int first = *firstp;
int last = *lastp; int last = *lastp;
size_t n = (size_t)(last - first); size_t n = (size_t)(last - first);
int mirror = maxcol - 1; // Mirrors are more fun than television. int mirror = width - 1; // Mirrors are more fun than television.
schar_T *scratch_char = (schar_T *)linebuf_scratch; schar_T *scratch_char = (schar_T *)linebuf_scratch;
memcpy(scratch_char + first, linebuf_char + first, n * sizeof(schar_T)); memcpy(scratch_char + first, linebuf_char + first, n * sizeof(schar_T));
for (int col = first; col < last; col++) { for (int col = first; col < last; col++) {
@@ -577,9 +578,9 @@ void linebuf_mirror(int *firstp, int *lastp, int *clearp, int maxcol)
linebuf_vcol[mirror - col] = scratch_vcol[col]; linebuf_vcol[mirror - col] = scratch_vcol[col];
} }
*firstp = maxcol - *clearp; *firstp = width - *clearp;
*clearp = maxcol - first; *clearp = width - first;
*lastp = maxcol - last; *lastp = width - last;
} }
/// End a group of grid_line_puts calls and send the screen buffer to the UI layer. /// End a group of grid_line_puts calls and send the screen buffer to the UI layer.
@@ -613,7 +614,7 @@ void grid_line_flush_if_valid_row(void)
grid_line_flush(); grid_line_flush();
} }
void grid_clear(ScreenGrid *grid, int start_row, int end_row, int start_col, int end_col, int attr) void grid_clear(GridView *grid, int start_row, int end_row, int start_col, int end_col, int attr)
{ {
for (int row = start_row; row < end_row; row++) { for (int row = start_row; row < end_row; row++) {
grid_line_start(grid, row); grid_line_start(grid, row);
@@ -924,21 +925,20 @@ void grid_free_all_mem(void)
/// resized grid. /// resized grid.
void win_grid_alloc(win_T *wp) void win_grid_alloc(win_T *wp)
{ {
ScreenGrid *grid = &wp->w_grid; GridView *grid = &wp->w_grid;
ScreenGrid *grid_allocated = &wp->w_grid_alloc; ScreenGrid *grid_allocated = &wp->w_grid_alloc;
int rows = wp->w_height_inner;
int cols = wp->w_width_inner;
int total_rows = wp->w_height_outer; int total_rows = wp->w_height_outer;
int total_cols = wp->w_width_outer; int total_cols = wp->w_width_outer;
bool want_allocation = ui_has(kUIMultigrid) || wp->w_floating; bool want_allocation = ui_has(kUIMultigrid) || wp->w_floating;
bool has_allocation = (grid_allocated->chars != NULL); bool has_allocation = (grid_allocated->chars != NULL);
if (grid->rows != rows) { if (wp->w_view_height > wp->w_lines_size) {
wp->w_lines_valid = 0; wp->w_lines_valid = 0;
xfree(wp->w_lines); xfree(wp->w_lines);
wp->w_lines = xcalloc((size_t)rows + 1, sizeof(wline_T)); wp->w_lines = xcalloc((size_t)wp->w_view_height + 1, sizeof(wline_T));
wp->w_lines_size = wp->w_view_height;
} }
bool was_resized = false; bool was_resized = false;
@@ -963,9 +963,6 @@ void win_grid_alloc(win_T *wp)
grid_allocated->valid = true; grid_allocated->valid = true;
} }
grid->rows = rows;
grid->cols = cols;
if (want_allocation) { if (want_allocation) {
grid->target = grid_allocated; grid->target = grid_allocated;
grid->row_offset = wp->w_winrow_off; grid->row_offset = wp->w_winrow_off;
@@ -1009,11 +1006,6 @@ void grid_ins_lines(ScreenGrid *grid, int row, int line_count, int end, int col,
int j; int j;
unsigned temp; unsigned temp;
int row_off = 0;
grid_adjust(&grid, &row_off, &col);
row += row_off;
end += row_off;
if (line_count <= 0) { if (line_count <= 0) {
return; return;
} }
@@ -1054,11 +1046,6 @@ void grid_del_lines(ScreenGrid *grid, int row, int line_count, int end, int col,
int j; int j;
unsigned temp; unsigned temp;
int row_off = 0;
grid_adjust(&grid, &row_off, &col);
row += row_off;
end += row_off;
if (line_count <= 0) { if (line_count <= 0) {
return; return;
} }

1
src/nvim/grid.h
View File

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

20
src/nvim/grid_defs.h
View File

@@ -65,14 +65,6 @@ struct ScreenGrid {
// external UI. // external UI.
bool throttled; bool throttled;
// TODO(bfredl): maybe physical grids and "views" (i e drawing
// specifications) should be two separate types?
// offsets for the grid relative to another grid. Used for grids
// that are views into another, actually allocated grid 'target'
int row_offset;
int col_offset;
ScreenGrid *target;
// whether the compositor should blend the grid with the background grid // whether the compositor should blend the grid with the background grid
bool blending; bool blending;
@@ -103,13 +95,21 @@ struct ScreenGrid {
// moving around grids etc. // moving around grids etc.
bool comp_disabled; bool comp_disabled;
bool composition_updated; // need to resend win_float_pos or similar due to comp_index change
bool pending_comp_index_update;
}; };
#define SCREEN_GRID_INIT { 0, NULL, NULL, NULL, NULL, NULL, 0, 0, false, \ #define SCREEN_GRID_INIT { 0, NULL, NULL, NULL, NULL, NULL, 0, 0, false, \
false, 0, 0, NULL, false, true, 0, \ false, false, true, 0, \
0, 0, 0, 0, 0, false, true } 0, 0, 0, 0, 0, false, true }
/// Represents the position of a viewport within a ScreenGrid
typedef struct {
ScreenGrid *target;
int row_offset;
int col_offset;
} GridView;
typedef struct { typedef struct {
int args[3]; int args[3];
int icell; int icell;

2
src/nvim/indent.c
View File

@@ -851,7 +851,7 @@ int get_breakindent_win(win_T *wp, char *line)
static char *prev_flp = NULL; // cached formatlistpat value static char *prev_flp = NULL; // cached formatlistpat 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_inner - win_col_off(wp) + win_col_off2(wp); const int eff_wwidth = wp->w_view_width - win_col_off(wp) + win_col_off2(wp);
// In list mode, if 'listchars' "tab" isn't set, a TAB is displayed as ^I. // In list mode, if 'listchars' "tab" isn't set, a TAB is displayed as ^I.
const bool no_ts = wp->w_p_list && wp->w_p_lcs_chars.tab1 == NUL; const bool no_ts = wp->w_p_list && wp->w_p_lcs_chars.tab1 == NUL;

12
src/nvim/message.c
View File

@@ -173,7 +173,7 @@ static void ui_ext_msg_set_pos(int row, bool scrolled)
ui_call_msg_set_pos(msg_grid.handle, row, scrolled, ui_call_msg_set_pos(msg_grid.handle, row, scrolled,
(String){ .data = buf, .size = size }, msg_grid.zindex, (String){ .data = buf, .size = size }, msg_grid.zindex,
(int)msg_grid.comp_index); (int)msg_grid.comp_index);
msg_grid.composition_updated = false; msg_grid.pending_comp_index_update = false;
} }
void msg_grid_set_pos(int row, bool scrolled) void msg_grid_set_pos(int row, bool scrolled)
@@ -235,7 +235,6 @@ void msg_grid_validate(void)
grid_clear(&msg_grid_adj, Rows - diff, Rows, 0, Columns, HL_ATTR(HLF_MSG)); grid_clear(&msg_grid_adj, Rows - diff, Rows, 0, Columns, HL_ATTR(HLF_MSG));
} }
} }
msg_grid_adj.cols = Columns;
if (msg_grid.chars && !msg_scrolled && cmdline_row < msg_grid_pos) { if (msg_grid.chars && !msg_scrolled && cmdline_row < msg_grid_pos) {
// TODO(bfredl): this should already be the case, but fails in some // TODO(bfredl): this should already be the case, but fails in some
@@ -2384,18 +2383,17 @@ static void msg_puts_display(const char *str, int maxlen, int hl_id, int recurse
void msg_line_flush(void) void msg_line_flush(void)
{ {
if (cmdmsg_rl) { if (cmdmsg_rl) {
grid_line_mirror(); grid_line_mirror(msg_grid.cols);
} }
grid_line_flush_if_valid_row(); grid_line_flush_if_valid_row();
} }
void msg_cursor_goto(int row, int col) void msg_cursor_goto(int row, int col)
{ {
ScreenGrid *grid = &msg_grid_adj;
if (cmdmsg_rl) { if (cmdmsg_rl) {
col = Columns - 1 - col; col = Columns - 1 - col;
} }
grid_adjust(&grid, &row, &col); ScreenGrid *grid = grid_adjust(&msg_grid_adj, &row, &col);
ui_grid_cursor_goto(grid->handle, row, col); ui_grid_cursor_goto(grid->handle, row, col);
} }
@@ -2533,7 +2531,7 @@ void msg_ui_refresh(void)
void msg_ui_flush(void) void msg_ui_flush(void)
{ {
if (ui_has(kUIMultigrid) && msg_grid.chars && msg_grid.composition_updated) { if (ui_has(kUIMultigrid) && msg_grid.chars && msg_grid.pending_comp_index_update) {
ui_ext_msg_set_pos(msg_grid_pos, msg_scrolled); ui_ext_msg_set_pos(msg_grid_pos, msg_scrolled);
} }
} }
@@ -2978,7 +2976,7 @@ static bool do_more_prompt(int typed_char)
} }
if (toscroll == -1 && !to_redraw) { if (toscroll == -1 && !to_redraw) {
grid_ins_lines(&msg_grid_adj, 0, 1, Rows, 0, Columns); grid_ins_lines(&msg_grid, 0, 1, Rows, 0, Columns);
grid_clear(&msg_grid_adj, 0, 1, 0, Columns, HL_ATTR(HLF_MSG)); grid_clear(&msg_grid_adj, 0, 1, 0, Columns, HL_ATTR(HLF_MSG));
// display line at top // display line at top
disp_sb_line(0, mp); disp_sb_line(0, mp);

6
src/nvim/message.h
View File

@@ -34,8 +34,8 @@ EXTERN bool msg_ext_need_clear INIT( = false);
// Set to true to force grouping a set of message chunks into a single `cmdline_show` event. // Set to true to force grouping a set of message chunks into a single `cmdline_show` event.
EXTERN bool msg_ext_skip_flush INIT( = false); EXTERN bool msg_ext_skip_flush INIT( = false);
/// allocated grid for messages. Used when display+=msgsep is set, or /// allocated grid for messages. Used unless ext_messages is active.
/// ext_multigrid is active. See also the description at msg_scroll_flush() /// See also the description at msg_scroll_flush()
EXTERN ScreenGrid msg_grid INIT( = SCREEN_GRID_INIT); EXTERN ScreenGrid msg_grid INIT( = SCREEN_GRID_INIT);
EXTERN int msg_grid_pos INIT( = 0); EXTERN int msg_grid_pos INIT( = 0);
@@ -45,7 +45,7 @@ EXTERN int msg_grid_pos INIT( = 0);
/// for legacy (display-=msgsep) message scroll behavior. /// for legacy (display-=msgsep) message scroll behavior.
/// TODO(bfredl): refactor "internal" message logic, msg_row etc /// TODO(bfredl): refactor "internal" message logic, msg_row etc
/// to use the correct positions already. /// to use the correct positions already.
EXTERN ScreenGrid msg_grid_adj INIT( = SCREEN_GRID_INIT); EXTERN GridView msg_grid_adj INIT( = { 0 });
/// value of msg_scrolled at latest msg_scroll_flush. /// value of msg_scrolled at latest msg_scroll_flush.
EXTERN int msg_scrolled_at_flush INIT( = 0); EXTERN int msg_scrolled_at_flush INIT( = 0);

35
src/nvim/mouse.c
View File

@@ -249,19 +249,19 @@ static int get_fpos_of_mouse(pos_T *mpos)
if (!below_buffer && *wp->w_p_stc != NUL if (!below_buffer && *wp->w_p_stc != NUL
&& (wp->w_p_rl && (wp->w_p_rl
? wincol >= wp->w_width_inner - win_col_off(wp) ? wincol >= wp->w_view_width - win_col_off(wp)
: wincol < win_col_off(wp))) { : wincol < win_col_off(wp))) {
return MOUSE_STATUSCOL; return MOUSE_STATUSCOL;
} }
// winpos and height may change in win_enter()! // winpos and height may change in win_enter()!
if (winrow >= wp->w_height_inner + wp->w_status_height) { // Below window if (winrow >= wp->w_view_height + wp->w_status_height) { // Below window
if (mouse_grid <= 1 && mouse_row < Rows - p_ch if (mouse_grid <= 1 && mouse_row < Rows - p_ch
&& mouse_row >= Rows - p_ch - global_stl_height()) { // In global status line && mouse_row >= Rows - p_ch - global_stl_height()) { // In global status line
return IN_STATUS_LINE; return IN_STATUS_LINE;
} }
return IN_UNKNOWN; return IN_UNKNOWN;
} else if (winrow >= wp->w_height_inner) { // In window status line } else if (winrow >= wp->w_view_height) { // In window status line
return IN_STATUS_LINE; return IN_STATUS_LINE;
} }
@@ -269,7 +269,7 @@ static int get_fpos_of_mouse(pos_T *mpos)
return MOUSE_WINBAR; return MOUSE_WINBAR;
} }
if (wincol >= wp->w_width_inner) { // In vertical separator line if (wincol >= wp->w_view_width) { // In vertical separator line
return IN_SEP_LINE; return IN_SEP_LINE;
} }
@@ -682,7 +682,7 @@ bool do_mouse(oparg_T *oap, int c, int dir, int count, bool fixindent)
} }
if (in_statuscol && wp->w_p_rl) { if (in_statuscol && wp->w_p_rl) {
click_col = wp->w_width_inner - click_col - 1; click_col = wp->w_view_width - click_col - 1;
} }
if ((in_statuscol && click_col >= (int)wp->w_statuscol_click_defs_size) if ((in_statuscol && click_col >= (int)wp->w_statuscol_click_defs_size)
@@ -1053,7 +1053,7 @@ void do_mousescroll(cmdarg_T *cap)
} }
} else { } else {
// Horizontal scrolling // Horizontal scrolling
int step = shift_or_ctrl ? curwin->w_width_inner : (int)p_mousescroll_hor; int step = shift_or_ctrl ? curwin->w_view_width : (int)p_mousescroll_hor;
colnr_T leftcol = curwin->w_leftcol + (cap->arg == MSCR_RIGHT ? -step : +step); colnr_T leftcol = curwin->w_leftcol + (cap->arg == MSCR_RIGHT ? -step : +step);
leftcol = MAX(leftcol, 0); leftcol = MAX(leftcol, 0);
do_mousescroll_horiz(leftcol); do_mousescroll_horiz(leftcol);
@@ -1277,7 +1277,7 @@ retnomove:
on_statuscol = !below_window && !on_status_line && !on_sep_line && !on_winbar on_statuscol = !below_window && !on_status_line && !on_sep_line && !on_winbar
&& *wp->w_p_stc != NUL && *wp->w_p_stc != NUL
&& (wp->w_p_rl && (wp->w_p_rl
? col >= wp->w_width_inner - win_col_off(wp) ? col >= wp->w_view_width - win_col_off(wp)
: col < win_col_off(wp)); : col < win_col_off(wp));
// The rightmost character of the status line might be a vertical // The rightmost character of the status line might be a vertical
@@ -1346,7 +1346,7 @@ retnomove:
|| (!status_line_offset || (!status_line_offset
&& !sep_line_offset && !sep_line_offset
&& (wp->w_p_rl && (wp->w_p_rl
? col < wp->w_width_inner - fdc ? col < wp->w_view_width - fdc
: col >= fdc + (wp != cmdwin_win ? 0 : 1)) : col >= fdc + (wp != cmdwin_win ? 0 : 1))
&& (flags & MOUSE_MAY_STOP_VIS)))) { && (flags & MOUSE_MAY_STOP_VIS)))) {
end_visual_mode(); end_visual_mode();
@@ -1455,7 +1455,7 @@ retnomove:
~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP); ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
redraw_later(curwin, UPD_VALID); redraw_later(curwin, UPD_VALID);
row = 0; row = 0;
} else if (row >= curwin->w_height_inner) { } else if (row >= curwin->w_view_height) {
count = 0; count = 0;
for (first = true; curwin->w_topline < curbuf->b_ml.ml_line_count;) { for (first = true; curwin->w_topline < curbuf->b_ml.ml_line_count;) {
if (curwin->w_topfill > 0) { if (curwin->w_topfill > 0) {
@@ -1464,7 +1464,7 @@ retnomove:
count += plines_win(curwin, curwin->w_topline, true); count += plines_win(curwin, curwin->w_topline, true);
} }
if (!first && count > row - curwin->w_height_inner + 1) { if (!first && count > row - curwin->w_view_height + 1) {
break; break;
} }
first = false; first = false;
@@ -1484,7 +1484,7 @@ retnomove:
redraw_later(curwin, UPD_VALID); redraw_later(curwin, UPD_VALID);
curwin->w_valid &= curwin->w_valid &=
~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP); ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
row = curwin->w_height_inner - 1; row = curwin->w_view_height - 1;
} else if (row == 0) { } else if (row == 0) {
// When dragging the mouse, while the text has been scrolled up as // 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 // far as it goes, moving the mouse in the top line should scroll
@@ -1615,7 +1615,7 @@ bool mouse_comp_pos(win_T *win, int *rowp, int *colp, linenr_T *lnump)
int count; int count;
if (win->w_p_rl) { if (win->w_p_rl) {
col = win->w_width_inner - 1 - col; col = win->w_view_width - 1 - col;
} }
linenr_T lnum = win->w_topline; linenr_T lnum = win->w_topline;
@@ -1631,7 +1631,7 @@ bool mouse_comp_pos(win_T *win, int *rowp, int *colp, linenr_T *lnump)
} }
if (win->w_skipcol > 0 && lnum == win->w_topline) { if (win->w_skipcol > 0 && lnum == win->w_topline) {
int width1 = win->w_width_inner - win_col_off(win); int width1 = win->w_view_width - win_col_off(win);
if (width1 > 0) { if (width1 > 0) {
int skip_lines = 0; int skip_lines = 0;
@@ -1673,7 +1673,7 @@ bool mouse_comp_pos(win_T *win, int *rowp, int *colp, linenr_T *lnump)
// Compute the column without wrapping. // Compute the column without wrapping.
int off = win_col_off(win) - win_col_off2(win); int off = win_col_off(win) - win_col_off2(win);
col = MAX(col, off); col = MAX(col, off);
col += row * (win->w_width_inner - off); col += row * (win->w_view_width - off);
// Add skip column for the topline. // Add skip column for the topline.
if (lnum == win->w_topline) { if (lnum == win->w_topline) {
@@ -1750,8 +1750,8 @@ static win_T *mouse_find_grid_win(int *gridp, int *rowp, int *colp)
win_T *wp = get_win_by_grid_handle(*gridp); win_T *wp = get_win_by_grid_handle(*gridp);
if (wp && wp->w_grid_alloc.chars if (wp && wp->w_grid_alloc.chars
&& !(wp->w_floating && !wp->w_config.mouse)) { && !(wp->w_floating && !wp->w_config.mouse)) {
*rowp = MIN(*rowp - wp->w_grid.row_offset, wp->w_grid.rows - 1); *rowp = MIN(*rowp - wp->w_grid.row_offset, wp->w_view_height - 1);
*colp = MIN(*colp - wp->w_grid.col_offset, wp->w_grid.cols - 1); *colp = MIN(*colp - wp->w_grid.col_offset, wp->w_view_width - 1);
return wp; return wp;
} }
} else if (*gridp == 0) { } else if (*gridp == 0) {
@@ -1884,10 +1884,9 @@ static void mouse_check_grid(colnr_T *vcolp, int *flagsp)
|| curwin->w_redr_type != 0) { || curwin->w_redr_type != 0) {
return; return;
} }
ScreenGrid *gp = &curwin->w_grid;
int start_row = 0; int start_row = 0;
int start_col = 0; int start_col = 0;
grid_adjust(&gp, &start_row, &start_col); ScreenGrid *gp = grid_adjust(&curwin->w_grid, &start_row, &start_col);
if (gp->handle != click_grid || gp->chars == NULL) { if (gp->handle != click_grid || gp->chars == NULL) {
return; return;
} }

196
src/nvim/move.c
View File

@@ -67,7 +67,7 @@ int adjust_plines_for_skipcol(win_T *wp)
return 0; return 0;
} }
int width = wp->w_width_inner - win_col_off(wp); int width = wp->w_view_width - win_col_off(wp);
int w2 = width + win_col_off2(wp); int w2 = width + win_col_off2(wp);
if (wp->w_skipcol >= width && w2 > 0) { if (wp->w_skipcol >= width && w2 > 0) {
return (wp->w_skipcol - width) / w2 + 1; return (wp->w_skipcol - width) / w2 + 1;
@@ -86,8 +86,8 @@ static int plines_correct_topline(win_T *wp, linenr_T lnum, linenr_T *nextp, boo
if (lnum == wp->w_topline) { if (lnum == wp->w_topline) {
n -= adjust_plines_for_skipcol(wp); n -= adjust_plines_for_skipcol(wp);
} }
if (limit_winheight && n > wp->w_height_inner) { if (limit_winheight && n > wp->w_view_height) {
return wp->w_height_inner; return wp->w_view_height;
} }
return n; return n;
} }
@@ -121,7 +121,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_inner) { if (done + n > wp->w_view_height) {
break; break;
} }
done += n; done += n;
@@ -210,7 +210,7 @@ int sms_marker_overlap(win_T *wp, int extra2)
/// physical lines we want to scroll down. /// physical lines we want to scroll down.
static int skipcol_from_plines(win_T *wp, int plines_off) static int skipcol_from_plines(win_T *wp, int plines_off)
{ {
int width1 = wp->w_width_inner - win_col_off(wp); int width1 = wp->w_view_width - win_col_off(wp);
int skipcol = 0; int skipcol = 0;
if (plines_off > 0) { if (plines_off > 0) {
@@ -251,7 +251,7 @@ void update_topline(win_T *wp)
// If there is no valid screen and when the window height is zero just use // If there is no valid screen and when the window height is zero just use
// the cursor line. // the cursor line.
if (!default_grid.chars || wp->w_height_inner == 0) { if (!default_grid.chars || wp->w_view_height == 0) {
wp->w_topline = wp->w_cursor.lnum; wp->w_topline = wp->w_cursor.lnum;
wp->w_botline = wp->w_topline; wp->w_botline = wp->w_topline;
wp->w_viewport_invalid = true; wp->w_viewport_invalid = true;
@@ -313,7 +313,7 @@ void update_topline(win_T *wp)
} }
if (check_topline) { if (check_topline) {
int halfheight = wp->w_height_inner / 2 - 1; int halfheight = wp->w_view_height / 2 - 1;
if (halfheight < 2) { if (halfheight < 2) {
halfheight = 2; halfheight = 2;
} }
@@ -405,7 +405,7 @@ void update_topline(win_T *wp)
for (linenr_T lnum = wp->w_cursor.lnum; lnum >= wp->w_botline - *so_ptr; lnum--) { for (linenr_T lnum = wp->w_cursor.lnum; lnum >= wp->w_botline - *so_ptr; lnum--) {
line_count += !decor_conceal_line(wp, lnum - 1, false); line_count += !decor_conceal_line(wp, lnum - 1, false);
// 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 > wp->w_height_inner + 1) { if (lnum <= 0 || line_count > wp->w_view_height + 1) {
break; break;
} }
hasFolding(wp, lnum, &lnum, NULL); hasFolding(wp, lnum, &lnum, NULL);
@@ -413,7 +413,7 @@ void update_topline(win_T *wp)
} else { } else {
line_count = wp->w_cursor.lnum - wp->w_botline + 1 + (int)(*so_ptr); line_count = wp->w_cursor.lnum - wp->w_botline + 1 + (int)(*so_ptr);
} }
if (line_count <= wp->w_height_inner + 1) { if (line_count <= wp->w_view_height + 1) {
scroll_cursor_bot(wp, scrolljump_value(wp), false); scroll_cursor_bot(wp, scrolljump_value(wp), false);
} else { } else {
scroll_cursor_halfway(wp, false, false); scroll_cursor_halfway(wp, false, false);
@@ -452,7 +452,7 @@ void update_topline(win_T *wp)
/// When 'scrolljump' is negative use it as a percentage of the window height. /// When 'scrolljump' is negative use it as a percentage of the window height.
static int scrolljump_value(win_T *wp) static int scrolljump_value(win_T *wp)
{ {
int result = p_sj >= 0 ? (int)p_sj : (wp->w_height_inner * (int)(-p_sj)) / 100; int result = p_sj >= 0 ? (int)p_sj : (wp->w_view_height * (int)(-p_sj)) / 100;
return result; return result;
} }
@@ -748,12 +748,12 @@ void validate_cursor_col(win_T *wp)
colnr_T col = wp->w_virtcol; colnr_T col = wp->w_virtcol;
colnr_T off = win_col_off(wp); colnr_T off = win_col_off(wp);
col += off; col += off;
int width = wp->w_width_inner - off + win_col_off2(wp); int width = wp->w_view_width - off + win_col_off2(wp);
// long line wrapping, adjust wp->w_wrow // long line wrapping, adjust wp->w_wrow
if (wp->w_p_wrap && col >= (colnr_T)wp->w_width_inner && width > 0) { if (wp->w_p_wrap && col >= (colnr_T)wp->w_view_width && width > 0) {
// use same formula as what is used in curs_columns() // use same formula as what is used in curs_columns()
col -= ((col - wp->w_width_inner) / width + 1) * width; col -= ((col - wp->w_view_width) / width + 1) * width;
} }
if (col > (int)wp->w_leftcol) { if (col > (int)wp->w_leftcol) {
col -= wp->w_leftcol; col -= wp->w_leftcol;
@@ -825,19 +825,19 @@ void curs_columns(win_T *wp, int may_scroll)
wp->w_wrow = wp->w_cline_row; wp->w_wrow = wp->w_cline_row;
int n; int n;
int width1 = wp->w_width_inner - extra; // text width for first screen line int width1 = wp->w_view_width - extra; // text width for first screen line
int width2 = 0; // text width for second and later screen line int width2 = 0; // text width for second and later screen line
bool did_sub_skipcol = false; bool did_sub_skipcol = false;
if (width1 <= 0) { if (width1 <= 0) {
// No room for text, put cursor in last char of window. // No room for text, put cursor in last char of window.
// If not wrapping, the last non-empty line. // If not wrapping, the last non-empty line.
wp->w_wcol = wp->w_width_inner - 1; wp->w_wcol = wp->w_view_width - 1;
if (wp->w_p_wrap) { if (wp->w_p_wrap) {
wp->w_wrow = wp->w_height_inner - 1; wp->w_wrow = wp->w_view_height - 1;
} else { } else {
wp->w_wrow = wp->w_height_inner - 1 - wp->w_empty_rows; wp->w_wrow = wp->w_view_height - 1 - wp->w_empty_rows;
} }
} else if (wp->w_p_wrap && wp->w_width_inner != 0) { } else if (wp->w_p_wrap && wp->w_view_width != 0) {
width2 = width1 + win_col_off2(wp); width2 = width1 + win_col_off2(wp);
// skip columns that are not visible // skip columns that are not visible
@@ -856,9 +856,9 @@ void curs_columns(win_T *wp, int may_scroll)
} }
// long line wrapping, adjust wp->w_wrow // long line wrapping, adjust wp->w_wrow
if (wp->w_wcol >= wp->w_width_inner) { if (wp->w_wcol >= wp->w_view_width) {
// this same formula is used in validate_cursor_col() // this same formula is used in validate_cursor_col()
n = (wp->w_wcol - wp->w_width_inner) / width2 + 1; n = (wp->w_wcol - wp->w_view_width) / width2 + 1;
wp->w_wcol -= n * width2; wp->w_wcol -= n * width2;
wp->w_wrow += n; wp->w_wrow += n;
} }
@@ -874,7 +874,7 @@ void curs_columns(win_T *wp, int may_scroll)
// extra // extra
int siso = get_sidescrolloff_value(wp); int siso = get_sidescrolloff_value(wp);
int off_left = startcol - wp->w_leftcol - siso; int off_left = startcol - wp->w_leftcol - siso;
int off_right = endcol - wp->w_leftcol - wp->w_width_inner + siso + 1; int off_right = endcol - wp->w_leftcol - wp->w_view_width + 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;
@@ -920,15 +920,15 @@ void curs_columns(win_T *wp, int may_scroll)
int plines = 0; int plines = 0;
int so = get_scrolloff_value(wp); int so = get_scrolloff_value(wp);
colnr_T prev_skipcol = wp->w_skipcol; colnr_T prev_skipcol = wp->w_skipcol;
if ((wp->w_wrow >= wp->w_height_inner if ((wp->w_wrow >= wp->w_view_height
|| ((prev_skipcol > 0 || ((prev_skipcol > 0
|| wp->w_wrow + so >= wp->w_height_inner) || wp->w_wrow + so >= wp->w_view_height)
&& (plines = plines_win_nofill(wp, wp->w_cursor.lnum, false)) - 1 && (plines = plines_win_nofill(wp, wp->w_cursor.lnum, false)) - 1
>= wp->w_height_inner)) >= wp->w_view_height))
&& wp->w_height_inner != 0 && wp->w_view_height != 0
&& wp->w_cursor.lnum == wp->w_topline && wp->w_cursor.lnum == wp->w_topline
&& width2 > 0 && width2 > 0
&& wp->w_width_inner != 0) { && wp->w_view_width != 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
// cursor. Avoid scrolling all the time. compute value of "extra": // cursor. Avoid scrolling all the time. compute value of "extra":
@@ -951,21 +951,21 @@ void curs_columns(win_T *wp, int may_scroll)
} else { } else {
n = plines; n = plines;
} }
if ((colnr_T)n >= wp->w_height_inner + wp->w_skipcol / width2 - so) { if ((colnr_T)n >= wp->w_view_height + wp->w_skipcol / width2 - so) {
extra += 2; extra += 2;
} }
if (extra == 3 || wp->w_height_inner <= so * 2) { if (extra == 3 || wp->w_view_height <= so * 2) {
// not enough room for 'scrolloff', put cursor in the middle // not enough room for 'scrolloff', put cursor in the middle
n = wp->w_virtcol / width2; n = wp->w_virtcol / width2;
if (n > wp->w_height_inner / 2) { if (n > wp->w_view_height / 2) {
n -= wp->w_height_inner / 2; n -= wp->w_view_height / 2;
} else { } else {
n = 0; n = 0;
} }
// don't skip more than necessary // don't skip more than necessary
if (n > plines - wp->w_height_inner + 1) { if (n > plines - wp->w_view_height + 1) {
n = plines - wp->w_height_inner + 1; n = plines - wp->w_view_height + 1;
} }
wp->w_skipcol = n > 0 ? width1 + (n - 1) * width2 wp->w_skipcol = n > 0 ? width1 + (n - 1) * width2
: 0; : 0;
@@ -981,7 +981,7 @@ void curs_columns(win_T *wp, int may_scroll)
} }
} else if (extra == 2) { } else if (extra == 2) {
// less than 'scrolloff' lines below, increase skipcol // less than 'scrolloff' lines below, increase skipcol
endcol = (n - wp->w_height_inner + 1) * width2; endcol = (n - wp->w_view_height + 1) * width2;
while (endcol > wp->w_virtcol) { while (endcol > wp->w_virtcol) {
endcol -= width2; endcol -= width2;
} }
@@ -995,16 +995,20 @@ void curs_columns(win_T *wp, int may_scroll)
wp->w_wrow -= wp->w_skipcol / width2; wp->w_wrow -= wp->w_skipcol / width2;
} }
if (wp->w_wrow >= wp->w_height_inner) { if (wp->w_wrow >= wp->w_view_height) {
// small window, make sure cursor is in it // small window, make sure cursor is in it
extra = wp->w_wrow - wp->w_height_inner + 1; extra = wp->w_wrow - wp->w_view_height + 1;
wp->w_skipcol += extra * width2; wp->w_skipcol += extra * width2;
wp->w_wrow -= extra; wp->w_wrow -= extra;
} }
// extra could be either positive or negative // extra could be either positive or negative
extra = (prev_skipcol - wp->w_skipcol) / width2; extra = (prev_skipcol - wp->w_skipcol) / width2;
// TODO(bfredl): this is very suspicious when not called by win_update()
// We should not randomly alter screen state outside of update_screen() :(
if (wp->w_grid.target) {
win_scroll_lines(wp, 0, extra); win_scroll_lines(wp, 0, extra);
}
} else if (!wp->w_p_sms) { } else if (!wp->w_p_sms) {
wp->w_skipcol = 0; wp->w_skipcol = 0;
} }
@@ -1053,7 +1057,7 @@ void textpos2screenpos(win_T *wp, pos_T *pos, int *rowp, int *scolp, int *ccolp,
} else if (!local || lnum < wp->w_topline) { } else if (!local || lnum < wp->w_topline) {
row = 0; row = 0;
} else { } else {
row = wp->w_height_inner - 1; row = wp->w_view_height - 1;
} }
bool existing_row = (lnum > 0 && lnum <= wp->w_buffer->b_ml.ml_line_count); bool existing_row = (lnum > 0 && lnum <= wp->w_buffer->b_ml.ml_line_count);
@@ -1070,26 +1074,26 @@ void textpos2screenpos(win_T *wp, pos_T *pos, int *rowp, int *scolp, int *ccolp,
// similar to what is done in validate_cursor_col() // similar to what is done in validate_cursor_col()
colnr_T col = scol; colnr_T col = scol;
col += off; col += off;
int width = wp->w_width_inner - off + win_col_off2(wp); int width = wp->w_view_width - off + win_col_off2(wp);
// long line wrapping, adjust row // long line wrapping, adjust row
if (wp->w_p_wrap && col >= (colnr_T)wp->w_width_inner && width > 0) { if (wp->w_p_wrap && col >= (colnr_T)wp->w_view_width && width > 0) {
// use same formula as what is used in curs_columns() // use same formula as what is used in curs_columns()
int rowoff = visible_row ? ((col - wp->w_width_inner) / width + 1) : 0; int rowoff = visible_row ? ((col - wp->w_view_width) / width + 1) : 0;
col -= rowoff * width; col -= rowoff * width;
row += rowoff; row += rowoff;
} }
col -= wp->w_leftcol; col -= wp->w_leftcol;
if (col >= 0 && col < wp->w_width_inner && row >= 0 && row < wp->w_height_inner) { if (col >= 0 && col < wp->w_view_width && row >= 0 && row < wp->w_view_height) {
coloff = col - scol + (local ? 0 : wp->w_wincol + wp->w_wincol_off) + 1; coloff = col - scol + (local ? 0 : wp->w_wincol + wp->w_wincol_off) + 1;
row += (local ? 0 : wp->w_winrow + wp->w_winrow_off) + 1; row += (local ? 0 : wp->w_winrow + wp->w_winrow_off) + 1;
} else { } else {
// character is left, right or below of the window // character is left, right or below of the window
scol = ccol = ecol = 0; scol = ccol = ecol = 0;
if (local) { if (local) {
coloff = col < 0 ? -1 : wp->w_width_inner + 1; coloff = col < 0 ? -1 : wp->w_view_width + 1;
} else { } else {
row = 0; row = 0;
} }
@@ -1193,10 +1197,10 @@ static void cursor_correct_sms(win_T *wp)
} }
int so = get_scrolloff_value(wp); int so = get_scrolloff_value(wp);
int width1 = wp->w_width_inner - win_col_off(wp); int width1 = wp->w_view_width - win_col_off(wp);
int width2 = width1 + win_col_off2(wp); int width2 = width1 + win_col_off2(wp);
int so_cols = so == 0 ? 0 : width1 + (so - 1) * width2; int so_cols = so == 0 ? 0 : width1 + (so - 1) * width2;
int space_cols = (wp->w_height_inner - 1) * width2; int space_cols = (wp->w_view_height - 1) * width2;
int size = so == 0 ? 0 : linetabsize_eol(wp, wp->w_topline); int size = so == 0 ? 0 : linetabsize_eol(wp, wp->w_topline);
if (wp->w_topline == 1 && wp->w_skipcol == 0) { if (wp->w_topline == 1 && wp->w_skipcol == 0) {
@@ -1214,10 +1218,10 @@ static void cursor_correct_sms(win_T *wp)
} }
int overlap = wp->w_skipcol == 0 int overlap = wp->w_skipcol == 0
? 0 : sms_marker_overlap(wp, wp->w_width_inner - width2); ? 0 : sms_marker_overlap(wp, wp->w_view_width - width2);
// If we have non-zero scrolloff, ignore marker overlap. // If we have non-zero scrolloff, ignore marker overlap.
int top = wp->w_skipcol + (so_cols != 0 ? so_cols : overlap); int top = wp->w_skipcol + (so_cols != 0 ? so_cols : overlap);
int bot = wp->w_skipcol + width1 + (wp->w_height_inner - 1) * width2 - so_cols; int bot = wp->w_skipcol + width1 + (wp->w_view_height - 1) * width2 - so_cols;
validate_virtcol(wp); validate_virtcol(wp);
colnr_T col = wp->w_virtcol; colnr_T col = wp->w_virtcol;
@@ -1323,7 +1327,7 @@ bool scrolldown(win_T *wp, linenr_T line_count, int byfold)
bool do_sms = wp->w_p_wrap && wp->w_p_sms; bool do_sms = wp->w_p_wrap && wp->w_p_sms;
if (do_sms) { if (do_sms) {
width1 = wp->w_width_inner - win_col_off(wp); width1 = wp->w_view_width - win_col_off(wp);
width2 = width1 + win_col_off2(wp); width2 = width1 + win_col_off2(wp);
} }
@@ -1332,7 +1336,7 @@ bool scrolldown(win_T *wp, linenr_T line_count, int byfold)
validate_cursor(wp); // w_wrow needs to be valid validate_cursor(wp); // w_wrow needs to be valid
for (int todo = line_count; todo > 0; todo--) { for (int todo = line_count; todo > 0; todo--) {
if (wp->w_topfill < win_get_fill(wp, wp->w_topline) if (wp->w_topfill < win_get_fill(wp, wp->w_topline)
&& wp->w_topfill < wp->w_height_inner - 1) { && wp->w_topfill < wp->w_view_height - 1) {
wp->w_topfill++; wp->w_topfill++;
done++; done++;
} else { } else {
@@ -1405,14 +1409,14 @@ bool scrolldown(win_T *wp, linenr_T line_count, int byfold)
// Compute the row number of the last row of the cursor line // Compute the row number of the last row of the cursor line
// and move the cursor onto the displayed part of the window. // and move the cursor onto the displayed part of the window.
int wrow = wp->w_wrow; int wrow = wp->w_wrow;
if (wp->w_p_wrap && wp->w_width_inner != 0) { if (wp->w_p_wrap && wp->w_view_width != 0) {
validate_virtcol(wp); validate_virtcol(wp);
validate_cheight(wp); validate_cheight(wp);
wrow += wp->w_cline_height - 1 - wrow += wp->w_cline_height - 1 -
wp->w_virtcol / wp->w_width_inner; wp->w_virtcol / wp->w_view_width;
} }
bool moved = false; bool moved = false;
while (wrow >= wp->w_height_inner && wp->w_cursor.lnum > 1) { while (wrow >= wp->w_view_height && wp->w_cursor.lnum > 1) {
linenr_T first; linenr_T first;
if (hasFolding(wp, wp->w_cursor.lnum, &first, NULL)) { if (hasFolding(wp, wp->w_cursor.lnum, &first, NULL)) {
wrow -= !decor_conceal_line(wp, wp->w_cursor.lnum - 1, false); wrow -= !decor_conceal_line(wp, wp->w_cursor.lnum - 1, false);
@@ -1445,7 +1449,7 @@ bool scrollup(win_T *wp, linenr_T line_count, bool byfold)
bool do_sms = wp->w_p_wrap && wp->w_p_sms; bool do_sms = wp->w_p_wrap && wp->w_p_sms;
if (do_sms || (byfold && win_lines_concealed(wp)) || win_may_fill(wp)) { if (do_sms || (byfold && win_lines_concealed(wp)) || win_may_fill(wp)) {
int width1 = wp->w_width_inner - win_col_off(wp); int width1 = wp->w_view_width - win_col_off(wp);
int width2 = width1 + win_col_off2(wp); int width2 = width1 + win_col_off2(wp);
int size = 0; int size = 0;
const colnr_T prev_skipcol = wp->w_skipcol; const colnr_T prev_skipcol = wp->w_skipcol;
@@ -1540,7 +1544,7 @@ void adjust_skipcol(void)
return; return;
} }
int width1 = curwin->w_width_inner - win_col_off(curwin); int width1 = curwin->w_view_width - win_col_off(curwin);
if (width1 <= 0) { if (width1 <= 0) {
return; // no text will be displayed return; // no text will be displayed
} }
@@ -1550,17 +1554,17 @@ void adjust_skipcol(void)
bool scrolled = false; bool scrolled = false;
validate_cheight(curwin); validate_cheight(curwin);
if (curwin->w_cline_height == curwin->w_height_inner if (curwin->w_cline_height == curwin->w_view_height
// w_cline_height may be capped at w_height_inner, check there aren't // w_cline_height may be capped at w_view_height, check there aren't
// actually more lines. // actually more lines.
&& plines_win(curwin, curwin->w_cursor.lnum, false) <= curwin->w_height_inner) { && plines_win(curwin, curwin->w_cursor.lnum, false) <= curwin->w_view_height) {
// the line just fits in the window, don't scroll // the line just fits in the window, don't scroll
reset_skipcol(curwin); reset_skipcol(curwin);
return; return;
} }
validate_virtcol(curwin); validate_virtcol(curwin);
int overlap = sms_marker_overlap(curwin, curwin->w_width_inner - width2); int overlap = sms_marker_overlap(curwin, curwin->w_view_width - width2);
while (curwin->w_skipcol > 0 while (curwin->w_skipcol > 0
&& curwin->w_virtcol < curwin->w_skipcol + overlap + scrolloff_cols) { && curwin->w_virtcol < curwin->w_skipcol + overlap + scrolloff_cols) {
// scroll a screen line down // scroll a screen line down
@@ -1596,13 +1600,13 @@ void adjust_skipcol(void)
if (col > width2) { if (col > width2) {
row += (int)col / width2; row += (int)col / width2;
} }
if (row >= curwin->w_height_inner) { if (row >= curwin->w_view_height) {
if (curwin->w_skipcol == 0) { if (curwin->w_skipcol == 0) {
curwin->w_skipcol += width1; curwin->w_skipcol += width1;
row--; row--;
} }
if (row >= curwin->w_height_inner) { if (row >= curwin->w_view_height) {
curwin->w_skipcol += (row - curwin->w_height_inner) * width2; curwin->w_skipcol += (row - curwin->w_view_height) * width2;
} }
redraw_later(curwin, UPD_NOT_VALID); redraw_later(curwin, UPD_NOT_VALID);
} }
@@ -1615,12 +1619,12 @@ void check_topfill(win_T *wp, bool down)
{ {
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_inner) { if (wp->w_topfill + n > wp->w_view_height) {
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_inner - n; wp->w_topfill = wp->w_view_height - n;
wp->w_topfill = MAX(wp->w_topfill, 0); wp->w_topfill = MAX(wp->w_topfill, 0);
} }
} }
@@ -1650,13 +1654,13 @@ void scrolldown_clamp(void)
} else { } else {
end_row += plines_win_nofill(curwin, curwin->w_topline - 1, true); end_row += plines_win_nofill(curwin, curwin->w_topline - 1, true);
} }
if (curwin->w_p_wrap && curwin->w_width_inner != 0) { if (curwin->w_p_wrap && curwin->w_view_width != 0) {
validate_cheight(curwin); validate_cheight(curwin);
validate_virtcol(curwin); validate_virtcol(curwin);
end_row += curwin->w_cline_height - 1 - end_row += curwin->w_cline_height - 1 -
curwin->w_virtcol / curwin->w_width_inner; curwin->w_virtcol / curwin->w_view_width;
} }
if (end_row < curwin->w_height_inner - get_scrolloff_value(curwin)) { if (end_row < curwin->w_view_height - get_scrolloff_value(curwin)) {
if (can_fill) { if (can_fill) {
curwin->w_topfill++; curwin->w_topfill++;
check_topfill(curwin, true); check_topfill(curwin, true);
@@ -1687,9 +1691,9 @@ void scrollup_clamp(void)
int start_row = (curwin->w_wrow int start_row = (curwin->w_wrow
- plines_win_nofill(curwin, curwin->w_topline, true) - plines_win_nofill(curwin, curwin->w_topline, true)
- curwin->w_topfill); - curwin->w_topfill);
if (curwin->w_p_wrap && curwin->w_width_inner != 0) { if (curwin->w_p_wrap && curwin->w_view_width != 0) {
validate_virtcol(curwin); validate_virtcol(curwin);
start_row -= curwin->w_virtcol / curwin->w_width_inner; start_row -= curwin->w_virtcol / curwin->w_view_width;
} }
if (start_row >= get_scrolloff_value(curwin)) { if (start_row >= get_scrolloff_value(curwin)) {
if (curwin->w_topfill > 0) { if (curwin->w_topfill > 0) {
@@ -1818,7 +1822,7 @@ void scroll_cursor_top(win_T *wp, int min_scroll, int always)
if (extra + i <= off && bot < wp->w_buffer->b_ml.ml_line_count) { if (extra + i <= off && bot < wp->w_buffer->b_ml.ml_line_count) {
used += plines_win_full(wp, bot, &bot, NULL, true, true); used += plines_win_full(wp, bot, &bot, NULL, true, true);
} }
if (used > wp->w_height_inner) { if (used > wp->w_view_height) {
break; break;
} }
@@ -1831,7 +1835,7 @@ void scroll_cursor_top(win_T *wp, int min_scroll, int always)
// If we don't have enough space, put cursor in the middle. // If we don't have enough space, put cursor in the middle.
// 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 > wp->w_height_inner) { if (used > wp->w_view_height) {
scroll_cursor_halfway(wp, false, false); scroll_cursor_halfway(wp, false, false);
} else { } else {
// If "always" is false, only adjust topline to a lower value, higher // If "always" is false, only adjust topline to a lower value, higher
@@ -1875,7 +1879,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_inner - used; wp->w_empty_rows = wp->w_view_height - 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 = win_get_fill(wp, wp->w_botline); wp->w_filler_rows = win_get_fill(wp, wp->w_botline);
if (wp->w_empty_rows > wp->w_filler_rows) { if (wp->w_empty_rows > wp->w_filler_rows) {
@@ -1914,14 +1918,14 @@ void scroll_cursor_bot(win_T *wp, int min_scroll, bool set_topbot)
if (loff.height == MAXCOL) { if (loff.height == MAXCOL) {
break; break;
} }
if (used + loff.height > wp->w_height_inner) { if (used + loff.height > wp->w_view_height) {
if (do_sms) { if (do_sms) {
// 'smoothscroll' and 'wrap' are set. The above line is // 'smoothscroll' and 'wrap' are set. The above line is
// too long to show in its entirety, so we show just a part // too long to show in its entirety, so we show just a part
// of it. // of it.
if (used < wp->w_height_inner) { if (used < wp->w_view_height) {
int plines_offset = used + loff.height - wp->w_height_inner; int plines_offset = used + loff.height - wp->w_view_height;
used = wp->w_height_inner; used = wp->w_view_height;
wp->w_topfill = loff.fill; wp->w_topfill = loff.fill;
wp->w_topline = loff.lnum; wp->w_topline = loff.lnum;
wp->w_skipcol = skipcol_from_plines(wp, plines_offset); wp->w_skipcol = skipcol_from_plines(wp, plines_offset);
@@ -1970,7 +1974,7 @@ void scroll_cursor_bot(win_T *wp, int min_scroll, bool set_topbot)
// need to scroll the additional clipped lines to scroll past the // need to scroll the additional clipped lines to scroll past the
// top line before we can move on to the other lines. // top line before we can move on to the other lines.
int top_plines = plines_win_nofill(wp, wp->w_topline, false); int top_plines = plines_win_nofill(wp, wp->w_topline, false);
int width1 = wp->w_width_inner - win_col_off(wp); int width1 = wp->w_view_width - win_col_off(wp);
if (width1 > 0) { if (width1 > 0) {
int width2 = width1 + win_col_off2(wp); int width2 = width1 + win_col_off2(wp);
@@ -1984,8 +1988,8 @@ void scroll_cursor_bot(win_T *wp, int min_scroll, bool set_topbot)
} }
top_plines -= skip_lines; top_plines -= skip_lines;
if (top_plines > wp->w_height_inner) { if (top_plines > wp->w_view_height) {
scrolled += (top_plines - wp->w_height_inner); scrolled += (top_plines - wp->w_view_height);
} }
} }
} }
@@ -2026,7 +2030,7 @@ void scroll_cursor_bot(win_T *wp, int min_scroll, bool set_topbot)
} else { } else {
used += loff.height; used += loff.height;
} }
if (used > wp->w_height_inner) { if (used > wp->w_view_height) {
break; break;
} }
if (loff.lnum >= wp->w_botline if (loff.lnum >= wp->w_botline
@@ -2044,7 +2048,7 @@ void scroll_cursor_bot(win_T *wp, int min_scroll, bool set_topbot)
// Add one line below // Add one line below
botline_forw(wp, &boff); botline_forw(wp, &boff);
used += boff.height; used += boff.height;
if (used > wp->w_height_inner) { if (used > wp->w_view_height) {
break; break;
} }
if (extra < (mouse_dragging > 0 ? mouse_dragging - 1 : so) if (extra < (mouse_dragging > 0 ? mouse_dragging - 1 : so)
@@ -2069,7 +2073,7 @@ void scroll_cursor_bot(win_T *wp, int min_scroll, bool 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 > wp->w_height_inner) { } else if (used > wp->w_view_height) {
line_count = used; line_count = used;
// scroll minimal number of lines // scroll minimal number of lines
} else { } else {
@@ -2089,7 +2093,7 @@ void scroll_cursor_bot(win_T *wp, int min_scroll, bool 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 >= wp->w_height_inner && line_count > min_scroll) { if (line_count >= wp->w_view_height && line_count > min_scroll) {
scroll_cursor_halfway(wp, false, true); scroll_cursor_halfway(wp, false, true);
} else if (line_count > 0) { } else if (line_count > 0) {
if (do_sms) { if (do_sms) {
@@ -2137,10 +2141,10 @@ void scroll_cursor_halfway(win_T *wp, bool atend, bool prefer_above)
if (do_sms) { if (do_sms) {
// 'smoothscroll' and 'wrap' are set // 'smoothscroll' and 'wrap' are set
if (atend) { if (atend) {
want_height = (wp->w_height_inner - used) / 2; want_height = (wp->w_view_height - used) / 2;
used = 0; used = 0;
} else { } else {
want_height = wp->w_height_inner; want_height = wp->w_view_height;
} }
} }
@@ -2189,7 +2193,7 @@ void scroll_cursor_halfway(win_T *wp, bool atend, bool prefer_above)
if (boff.lnum < wp->w_buffer->b_ml.ml_line_count) { if (boff.lnum < wp->w_buffer->b_ml.ml_line_count) {
botline_forw(wp, &boff); botline_forw(wp, &boff);
used += boff.height; used += boff.height;
if (used > wp->w_height_inner) { if (used > wp->w_view_height) {
done = true; done = true;
break; break;
} }
@@ -2212,7 +2216,7 @@ void scroll_cursor_halfway(win_T *wp, bool atend, bool prefer_above)
} else { } else {
used += loff.height; used += loff.height;
} }
if (used > wp->w_height_inner) { if (used > wp->w_view_height) {
done = true; done = true;
break; break;
} }
@@ -2237,7 +2241,7 @@ void scroll_cursor_halfway(win_T *wp, bool atend, bool prefer_above)
} }
} }
wp->w_topfill = topfill; wp->w_topfill = topfill;
if (old_topline > wp->w_topline + wp->w_height_inner) { if (old_topline > wp->w_topline + wp->w_view_height) {
wp->w_botfill = false; wp->w_botfill = false;
} }
check_topfill(wp, false); check_topfill(wp, false);
@@ -2261,14 +2265,14 @@ void cursor_correct(win_T *wp)
} }
if (wp->w_topline == 1) { if (wp->w_topline == 1) {
above_wanted = 0; above_wanted = 0;
int max_off = wp->w_height_inner / 2; int max_off = wp->w_view_height / 2;
below_wanted = MIN(below_wanted, max_off); below_wanted = MIN(below_wanted, max_off);
} }
validate_botline(wp); validate_botline(wp);
if (wp->w_botline == wp->w_buffer->b_ml.ml_line_count + 1 if (wp->w_botline == wp->w_buffer->b_ml.ml_line_count + 1
&& mouse_dragging == 0) { && mouse_dragging == 0) {
below_wanted = 0; below_wanted = 0;
int max_off = (wp->w_height_inner - 1) / 2; int max_off = (wp->w_view_height - 1) / 2;
above_wanted = MIN(above_wanted, max_off); above_wanted = MIN(above_wanted, max_off);
} }
@@ -2283,7 +2287,7 @@ void cursor_correct(win_T *wp)
if (wp->w_p_sms && !wp->w_p_wrap) { if (wp->w_p_sms && !wp->w_p_wrap) {
// 'smoothscroll' is active // 'smoothscroll' is active
if (wp->w_cline_height == wp->w_height_inner) { if (wp->w_cline_height == wp->w_view_height) {
// The cursor line just fits in the window, don't scroll. // The cursor line just fits in the window, don't scroll.
reset_skipcol(wp); reset_skipcol(wp);
return; return;
@@ -2351,7 +2355,7 @@ void cursor_correct(win_T *wp)
static int get_scroll_overlap(Direction dir) static int get_scroll_overlap(Direction dir)
{ {
lineoff_T loff; lineoff_T loff;
int min_height = curwin->w_height_inner - 2; int min_height = curwin->w_view_height - 2;
validate_botline(curwin); validate_botline(curwin);
if ((dir == BACKWARD && curwin->w_topline == 1) if ((dir == BACKWARD && curwin->w_topline == 1)
@@ -2456,21 +2460,21 @@ int pagescroll(Direction dir, int count, bool half)
if (half) { if (half) {
// Scroll [count], 'scroll' or current window height lines. // Scroll [count], 'scroll' or current window height lines.
if (count) { if (count) {
curwin->w_p_scr = MIN(curwin->w_height_inner, count); curwin->w_p_scr = MIN(curwin->w_view_height, count);
} }
count = MIN(curwin->w_height_inner, (int)curwin->w_p_scr); count = MIN(curwin->w_view_height, (int)curwin->w_p_scr);
int curscount = count; int curscount = count;
// Adjust count so as to not reveal end of buffer lines. // Adjust count so as to not reveal end of buffer lines.
if (dir == FORWARD if (dir == FORWARD
&& (curwin->w_topline + curwin->w_height_inner + count > buflen && (curwin->w_topline + curwin->w_view_height + count > buflen
|| win_lines_concealed(curwin))) { || win_lines_concealed(curwin))) {
int n = plines_correct_topline(curwin, curwin->w_topline, NULL, false, NULL); int n = plines_correct_topline(curwin, curwin->w_topline, NULL, false, NULL);
if (n - count < curwin->w_height_inner && curwin->w_topline < buflen) { if (n - count < curwin->w_view_height && curwin->w_topline < buflen) {
n += plines_m_win(curwin, curwin->w_topline + 1, buflen, curwin->w_height_inner + count); n += plines_m_win(curwin, curwin->w_topline + 1, buflen, curwin->w_view_height + count);
} }
if (n < curwin->w_height_inner + count) { if (n < curwin->w_view_height + count) {
count = n - curwin->w_height_inner; count = n - curwin->w_view_height;
} }
} }

32
src/nvim/normal.c
View File

@@ -2503,14 +2503,14 @@ bool nv_screengo(oparg_T *oap, int dir, int dist, bool skip_conceal)
col_off1 = win_col_off(curwin); col_off1 = win_col_off(curwin);
col_off2 = col_off1 - win_col_off2(curwin); col_off2 = col_off1 - win_col_off2(curwin);
width1 = curwin->w_width_inner - col_off1; width1 = curwin->w_view_width - col_off1;
width2 = curwin->w_width_inner - col_off2; width2 = curwin->w_view_width - col_off2;
if (width2 == 0) { if (width2 == 0) {
width2 = 1; // Avoid divide by zero. width2 = 1; // Avoid divide by zero.
} }
if (curwin->w_width_inner != 0) { if (curwin->w_view_width != 0) {
int n; int n;
// 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.
@@ -2843,7 +2843,7 @@ static void nv_zet(cmdarg_T *cap)
// "zH" - scroll screen right half-page // "zH" - scroll screen right half-page
case 'H': case 'H':
cap->count1 *= curwin->w_width_inner / 2; cap->count1 *= curwin->w_view_width / 2;
FALLTHROUGH; FALLTHROUGH;
// "zh" - scroll screen to the right // "zh" - scroll screen to the right
@@ -2857,7 +2857,7 @@ static void nv_zet(cmdarg_T *cap)
// "zL" - scroll window left half-page // "zL" - scroll window left half-page
case 'L': case 'L':
cap->count1 *= curwin->w_width_inner / 2; cap->count1 *= curwin->w_view_width / 2;
FALLTHROUGH; FALLTHROUGH;
// "zl" - scroll window to the left if not wrapping // "zl" - scroll window to the left if not wrapping
@@ -2896,7 +2896,7 @@ static void nv_zet(cmdarg_T *cap)
} else { } else {
getvcol(curwin, &curwin->w_cursor, NULL, NULL, &col); getvcol(curwin, &curwin->w_cursor, NULL, NULL, &col);
} }
int n = curwin->w_width_inner - win_col_off(curwin); int n = curwin->w_view_width - win_col_off(curwin);
if (col + siso < n) { if (col + siso < n) {
col = 0; col = 0;
} else { } else {
@@ -3637,7 +3637,7 @@ static void nv_scroll(cmdarg_T *cap)
// Don't count filler lines above the window. // Don't count filler lines above the window.
used -= win_get_fill(curwin, curwin->w_topline) - curwin->w_topfill; used -= win_get_fill(curwin, curwin->w_topline) - curwin->w_topfill;
validate_botline(curwin); // make sure w_empty_rows is valid validate_botline(curwin); // make sure w_empty_rows is valid
int half = (curwin->w_height_inner - curwin->w_empty_rows + 1) / 2; int half = (curwin->w_view_height - 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 the number of filler lines to be "below this // Count half the 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".
@@ -3653,7 +3653,7 @@ static void nv_scroll(cmdarg_T *cap)
n = lnum - curwin->w_topline; n = lnum - curwin->w_topline;
} }
} }
if (n > 0 && used > curwin->w_height_inner) { if (n > 0 && used > curwin->w_view_height) {
n--; n--;
} }
} else { // (cap->cmdchar == 'H') } else { // (cap->cmdchar == 'H')
@@ -5222,8 +5222,8 @@ void nv_g_home_m_cmd(cmdarg_T *cap)
cap->oap->motion_type = kMTCharWise; cap->oap->motion_type = kMTCharWise;
cap->oap->inclusive = false; cap->oap->inclusive = false;
if (curwin->w_p_wrap && curwin->w_width_inner != 0) { if (curwin->w_p_wrap && curwin->w_view_width != 0) {
int width1 = curwin->w_width_inner - win_col_off(curwin); int width1 = curwin->w_view_width - win_col_off(curwin);
int width2 = width1 + win_col_off2(curwin); int width2 = width1 + win_col_off2(curwin);
validate_virtcol(curwin); validate_virtcol(curwin);
@@ -5235,7 +5235,7 @@ void nv_g_home_m_cmd(cmdarg_T *cap)
// When ending up below 'smoothscroll' marker, move just beyond it so // When ending up below 'smoothscroll' marker, move just beyond it so
// that skipcol is not adjusted later. // that skipcol is not adjusted later.
if (curwin->w_skipcol > 0 && curwin->w_cursor.lnum == curwin->w_topline) { if (curwin->w_skipcol > 0 && curwin->w_cursor.lnum == curwin->w_topline) {
int overlap = sms_marker_overlap(curwin, curwin->w_width_inner - width2); int overlap = sms_marker_overlap(curwin, curwin->w_view_width - width2);
if (overlap > 0 && i == curwin->w_skipcol) { if (overlap > 0 && i == curwin->w_skipcol) {
i += overlap; i += overlap;
} }
@@ -5247,7 +5247,7 @@ void nv_g_home_m_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_inner - win_col_off(curwin) i += (curwin->w_view_width - win_col_off(curwin)
+ ((curwin->w_p_wrap && i > 0) ? win_col_off2(curwin) : 0)) / 2; + ((curwin->w_p_wrap && i > 0) ? win_col_off2(curwin) : 0)) / 2;
} }
coladvance(curwin, (colnr_T)i); coladvance(curwin, (colnr_T)i);
@@ -5303,10 +5303,10 @@ static void nv_g_dollar_cmd(cmdarg_T *cap)
oap->motion_type = kMTCharWise; oap->motion_type = kMTCharWise;
oap->inclusive = true; oap->inclusive = true;
if (curwin->w_p_wrap && curwin->w_width_inner != 0) { if (curwin->w_p_wrap && curwin->w_view_width != 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_inner - col_off; int width1 = curwin->w_view_width - col_off;
int width2 = width1 + win_col_off2(curwin); int width2 = width1 + win_col_off2(curwin);
validate_virtcol(curwin); validate_virtcol(curwin);
@@ -5334,7 +5334,7 @@ static void nv_g_dollar_cmd(cmdarg_T *cap)
// if it fails, let the cursor still move to the last char // if it fails, let the cursor still move to the last char
cursor_down(cap->count1 - 1, false); cursor_down(cap->count1 - 1, false);
} }
i = curwin->w_leftcol + curwin->w_width_inner - col_off - 1; i = curwin->w_leftcol + curwin->w_view_width - col_off - 1;
coladvance(curwin, (colnr_T)i); coladvance(curwin, (colnr_T)i);
// if the character doesn't fit move one back // if the character doesn't fit move one back
@@ -5342,7 +5342,7 @@ static void nv_g_dollar_cmd(cmdarg_T *cap)
colnr_T vcol; colnr_T vcol;
getvvcol(curwin, &curwin->w_cursor, NULL, NULL, &vcol); getvvcol(curwin, &curwin->w_cursor, NULL, NULL, &vcol);
if (vcol >= curwin->w_leftcol + curwin->w_width_inner - col_off) { if (vcol >= curwin->w_leftcol + curwin->w_view_width - col_off) {
curwin->w_cursor.col--; curwin->w_cursor.col--;
} }
} }

2
src/nvim/ops.c
View File

@@ -5766,7 +5766,7 @@ static void get_op_vcol(oparg_T *oap, colnr_T redo_VIsual_vcol, bool initial)
colnr_T end; colnr_T end;
if (VIsual_mode != Ctrl_V if (VIsual_mode != Ctrl_V
|| (!initial && oap->end.col < curwin->w_width_inner)) { || (!initial && oap->end.col < curwin->w_view_width)) {
return; return;
} }

2
src/nvim/option.c
View File

@@ -2807,7 +2807,7 @@ static const char *check_num_option_bounds(OptIndex opt_idx, OptInt *newval, cha
} }
break; break;
case kOptScroll: case kOptScroll:
if ((*newval <= 0 || (*newval > curwin->w_height_inner && curwin->w_height_inner > 0)) if ((*newval <= 0 || (*newval > curwin->w_view_height && curwin->w_view_height > 0))
&& full_screen) { && full_screen) {
if (*newval != 0) { if (*newval != 0) {
errmsg = e_scroll; errmsg = e_scroll;

34
src/nvim/plines.c
View File

@@ -207,16 +207,16 @@ CharSize charsize_regular(CharsizeArg *csarg, char *const cur, colnr_T const vco
// When "size" is 0, no new screen line is started. // When "size" is 0, no new screen line is started.
if (size > 0 && wp->w_p_wrap && (*sbr != NUL || wp->w_p_bri)) { if (size > 0 && wp->w_p_wrap && (*sbr != NUL || wp->w_p_bri)) {
int col_off_prev = win_col_off(wp); int col_off_prev = win_col_off(wp);
int width2 = wp->w_width_inner - col_off_prev + win_col_off2(wp); int width2 = wp->w_view_width - col_off_prev + win_col_off2(wp);
colnr_T wcol = vcol + col_off_prev; colnr_T wcol = vcol + col_off_prev;
colnr_T max_head_vcol = csarg->max_head_vcol; colnr_T max_head_vcol = csarg->max_head_vcol;
int added = 0; int added = 0;
// cells taken by 'showbreak'/'breakindent' before current char // cells taken by 'showbreak'/'breakindent' before current char
int head_prev = 0; int head_prev = 0;
if (wcol >= wp->w_width_inner) { if (wcol >= wp->w_view_width) {
wcol -= wp->w_width_inner; wcol -= wp->w_view_width;
col_off_prev = wp->w_width_inner - width2; col_off_prev = wp->w_view_width - width2;
if (wcol >= width2 && width2 > 0) { if (wcol >= width2 && width2 > 0) {
wcol %= width2; wcol %= width2;
} }
@@ -244,7 +244,7 @@ CharSize charsize_regular(CharsizeArg *csarg, char *const cur, colnr_T const vco
wcol += col_off_prev; wcol += col_off_prev;
} }
if (wcol + size > wp->w_width_inner) { if (wcol + size > wp->w_view_width) {
// cells taken by 'showbreak'/'breakindent' halfway current char // cells taken by 'showbreak'/'breakindent' halfway current char
int head_mid = csarg->indent_width; int head_mid = csarg->indent_width;
if (head_mid == INT_MIN) { if (head_mid == INT_MIN) {
@@ -259,7 +259,7 @@ CharSize charsize_regular(CharsizeArg *csarg, char *const cur, colnr_T const vco
} }
if (head_mid > 0) { if (head_mid > 0) {
// Calculate effective window width. // Calculate effective window width.
int prev_rem = wp->w_width_inner - wcol; int prev_rem = wp->w_view_width - wcol;
int width = width2 - head_mid; int width = width2 - head_mid;
if (width <= 0) { if (width <= 0) {
@@ -293,7 +293,7 @@ CharSize charsize_regular(CharsizeArg *csarg, char *const cur, colnr_T const vco
bool need_lbr = false; bool need_lbr = false;
// If 'linebreak' set check at a blank before a non-blank if the line // If 'linebreak' set check at a blank before a non-blank if the line
// needs a break here. // needs a break here.
if (wp->w_p_lbr && wp->w_p_wrap && wp->w_width_inner != 0 if (wp->w_p_lbr && wp->w_p_wrap && wp->w_view_width != 0
&& vim_isbreak((uint8_t)cur[0]) && !vim_isbreak((uint8_t)cur[1])) { && vim_isbreak((uint8_t)cur[0]) && !vim_isbreak((uint8_t)cur[1])) {
char *t = csarg->line; char *t = csarg->line;
while (vim_isbreak((uint8_t)t[0])) { while (vim_isbreak((uint8_t)t[0])) {
@@ -308,7 +308,7 @@ CharSize charsize_regular(CharsizeArg *csarg, char *const cur, colnr_T const vco
// non-blank after a blank. // non-blank after a blank.
int numberextra = win_col_off(wp); int numberextra = win_col_off(wp);
colnr_T col_adj = size - 1; colnr_T col_adj = size - 1;
colnr_T colmax = (colnr_T)(wp->w_width_inner - numberextra - col_adj); colnr_T colmax = (colnr_T)(wp->w_view_width - numberextra - col_adj);
if (vcol >= colmax) { if (vcol >= colmax) {
colmax += col_adj; colmax += col_adj;
int n = colmax + win_col_off2(wp); int n = colmax + win_col_off2(wp);
@@ -410,11 +410,11 @@ int charsize_nowrap(buf_T *buf, const char *cur, bool use_tabstop, colnr_T vcol,
static bool in_win_border(win_T *wp, colnr_T vcol) static bool in_win_border(win_T *wp, colnr_T vcol)
FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ARG(1) FUNC_ATTR_PURE FUNC_ATTR_WARN_UNUSED_RESULT FUNC_ATTR_NONNULL_ARG(1)
{ {
if (wp->w_width_inner == 0) { if (wp->w_view_width == 0) {
// there is no border // there is no border
return false; return false;
} }
int width1 = wp->w_width_inner - win_col_off(wp); // width of first line (after line number) int width1 = wp->w_view_width - win_col_off(wp); // width of first line (after line number)
if ((int)vcol < width1 - 1) { if ((int)vcol < width1 - 1) {
return false; return false;
@@ -765,7 +765,7 @@ int plines_win_nofill(win_T *wp, linenr_T lnum, bool limit_winheight)
return 1; return 1;
} }
if (wp->w_width_inner == 0) { if (wp->w_view_width == 0) {
return 1; return 1;
} }
@@ -775,8 +775,8 @@ int plines_win_nofill(win_T *wp, linenr_T lnum, bool limit_winheight)
} }
const int lines = plines_win_nofold(wp, lnum); const int lines = plines_win_nofold(wp, lnum);
if (limit_winheight && lines > wp->w_height_inner) { if (limit_winheight && lines > wp->w_view_height) {
return wp->w_height_inner; return wp->w_view_height;
} }
return lines; return lines;
} }
@@ -806,7 +806,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'.
int width = wp->w_width_inner - win_col_off(wp); int width = wp->w_view_width - win_col_off(wp);
if (width <= 0) { if (width <= 0) {
return 32000; // bigger than the number of screen lines return 32000; // bigger than the number of screen lines
} }
@@ -830,7 +830,7 @@ int plines_win_col(win_T *wp, linenr_T lnum, long column)
return lines + 1; return lines + 1;
} }
if (wp->w_width_inner == 0) { if (wp->w_view_width == 0) {
return lines + 1; return lines + 1;
} }
@@ -865,7 +865,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_inner - win_col_off(wp); int width = wp->w_view_width - win_col_off(wp);
if (width <= 0) { if (width <= 0) {
return 9999; return 9999;
} }
@@ -970,7 +970,7 @@ int64_t win_text_height(win_T *const wp, const linenr_T start_lnum, const int64_
linenr_T *const end_lnum, int64_t *const end_vcol, int64_t *const fill, linenr_T *const end_lnum, int64_t *const end_vcol, int64_t *const fill,
int64_t const max) int64_t const max)
{ {
int width1 = wp->w_width_inner - win_col_off(wp); int width1 = wp->w_view_width - win_col_off(wp);
int width2 = width1 + win_col_off2(wp); int width2 = width1 + win_col_off2(wp);
width1 = MAX(width1, 0); width1 = MAX(width1, 0);
width2 = MAX(width2, 0); width2 = MAX(width2, 0);

22
src/nvim/popupmenu.c
View File

@@ -154,7 +154,7 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed, i
pum_is_drawn = true; pum_is_drawn = true;
validate_cursor_col(curwin); validate_cursor_col(curwin);
int above_row = 0; int above_row = 0;
int below_row = MAX(cmdline_row, curwin->w_winrow + curwin->w_grid.rows); int below_row = MAX(cmdline_row, curwin->w_winrow + curwin->w_view_height);
if (State & MODE_CMDLINE) { if (State & MODE_CMDLINE) {
below_row = cmdline_row; below_row = cmdline_row;
} }
@@ -170,7 +170,7 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed, i
// anchor position: the start of the completed word // anchor position: the start of the completed word
pum_win_row = curwin->w_wrow; pum_win_row = curwin->w_wrow;
if (pum_rl) { if (pum_rl) {
cursor_col = curwin->w_width_inner - curwin->w_wcol - 1; cursor_col = curwin->w_view_width - curwin->w_wcol - 1;
} else { } else {
cursor_col = curwin->w_wcol; cursor_col = curwin->w_wcol;
} }
@@ -236,7 +236,7 @@ void pum_display(pumitem_T *array, int size, int selected, bool array_changed, i
int min_row = 0; int min_row = 0;
int min_col = 0; int min_col = 0;
int max_col = MAX(Columns, curwin->w_wincol + curwin->w_grid.cols); int max_col = MAX(Columns, curwin->w_wincol + curwin->w_view_width);
if (State & MODE_CMDLINE) { if (State & MODE_CMDLINE) {
max_col = Columns; max_col = Columns;
} }
@@ -655,7 +655,7 @@ void pum_redraw(void)
int attr = win_hl_attr(curwin, (int)hlf); int attr = win_hl_attr(curwin, (int)hlf);
attr = hl_combine_attr(win_hl_attr(curwin, HLF_PNI), attr); attr = hl_combine_attr(win_hl_attr(curwin, HLF_PNI), attr);
grid_line_start(&pum_grid, row); screengrid_line_start(&pum_grid, row, 0);
// prepend a space if there is room // prepend a space if there is room
if (extra_space) { if (extra_space) {
@@ -924,7 +924,7 @@ static void pum_adjust_info_position(win_T *wp, int width)
// when pum_above is SW otherwise is NW // when pum_above is SW otherwise is NW
wp->w_config.anchor = pum_above ? kFloatAnchorSouth : 0; wp->w_config.anchor = pum_above ? kFloatAnchorSouth : 0;
linenr_T count = wp->w_buffer->b_ml.ml_line_count; linenr_T count = wp->w_buffer->b_ml.ml_line_count;
wp->w_width_inner = wp->w_config.width; wp->w_view_width = wp->w_config.width;
wp->w_config.height = plines_m_win(wp, wp->w_topline, count, Rows); wp->w_config.height = plines_m_win(wp, wp->w_topline, count, Rows);
wp->w_config.row = pum_above ? pum_row + wp->w_config.height : pum_row; wp->w_config.row = pum_above ? pum_row + wp->w_config.height : pum_row;
wp->w_config.hide = false; wp->w_config.hide = false;
@@ -1329,11 +1329,11 @@ static void pum_position_at_mouse(int min_width)
pum_win_row_offset = wp->w_winrow; pum_win_row_offset = wp->w_winrow;
pum_win_col_offset = wp->w_wincol; pum_win_col_offset = wp->w_wincol;
if (wp->w_height_inner > 0 || wp->w_width_inner > 0) { if (wp->w_view_height > 0 || wp->w_view_width > 0) {
// When the user has requested a different grid size, let the popupmenu extend to the size // When the user has requested a different grid size, let the popupmenu extend to the size
// of it. // of it.
max_row = MAX(Rows - wp->w_winrow, wp->w_winrow + wp->w_grid.rows); max_row = MAX(Rows - wp->w_winrow, wp->w_winrow + wp->w_view_height);
max_col = MAX(Columns - wp->w_wincol, wp->w_wincol + wp->w_grid.cols); max_col = MAX(Columns - wp->w_wincol, wp->w_wincol + wp->w_view_width);
} }
} }
} }
@@ -1547,7 +1547,7 @@ void pum_make_popup(const char *path_name, int use_mouse_pos)
// around there. // around there.
mouse_row = curwin->w_grid.row_offset + curwin->w_wrow; mouse_row = curwin->w_grid.row_offset + curwin->w_wrow;
mouse_col = curwin->w_grid.col_offset mouse_col = curwin->w_grid.col_offset
+ (curwin->w_p_rl ? curwin->w_width_inner - curwin->w_wcol - 1 + (curwin->w_p_rl ? curwin->w_view_width - curwin->w_wcol - 1
: curwin->w_wcol); : curwin->w_wcol);
if (ui_has(kUIMultigrid)) { if (ui_has(kUIMultigrid)) {
mouse_grid = curwin->w_grid.target->handle; mouse_grid = curwin->w_grid.target->handle;
@@ -1567,13 +1567,13 @@ void pum_make_popup(const char *path_name, int use_mouse_pos)
void pum_ui_flush(void) void pum_ui_flush(void)
{ {
if (ui_has(kUIMultigrid) && pum_is_drawn && !pum_external && pum_grid.handle != 0 if (ui_has(kUIMultigrid) && pum_is_drawn && !pum_external && pum_grid.handle != 0
&& pum_grid.composition_updated) { && pum_grid.pending_comp_index_update) {
const char *anchor = pum_above ? "SW" : "NW"; const char *anchor = pum_above ? "SW" : "NW";
int row_off = pum_above ? -pum_height : 0; int row_off = pum_above ? -pum_height : 0;
ui_call_win_float_pos(pum_grid.handle, -1, cstr_as_string(anchor), pum_anchor_grid, ui_call_win_float_pos(pum_grid.handle, -1, cstr_as_string(anchor), pum_anchor_grid,
pum_row - row_off - pum_win_row_offset, pum_left_col - pum_win_col_offset, pum_row - row_off - pum_win_row_offset, pum_left_col - pum_win_col_offset,
false, pum_grid.zindex, (int)pum_grid.comp_index, pum_grid.comp_row, false, pum_grid.zindex, (int)pum_grid.comp_index, pum_grid.comp_row,
pum_grid.comp_col); pum_grid.comp_col);
pum_grid.composition_updated = false; pum_grid.pending_comp_index_update = false;
} }
} }

2
src/nvim/search.c
View File

@@ -2363,7 +2363,7 @@ void showmatch(int c)
bool col_visible = curwin->w_p_wrap bool col_visible = curwin->w_p_wrap
|| (vcol >= curwin->w_leftcol || (vcol >= curwin->w_leftcol
&& vcol < curwin->w_leftcol + curwin->w_width_inner); && vcol < curwin->w_leftcol + curwin->w_view_width);
if (!col_visible) { if (!col_visible) {
return; return;
} }

13
src/nvim/statusline.c
View File

@@ -101,7 +101,7 @@ void win_redr_status(win_T *wp)
attr = win_hl_attr(wp, HLF_C); attr = win_hl_attr(wp, HLF_C);
fillchar = wp->w_p_fcs_chars.vert; fillchar = wp->w_p_fcs_chars.vert;
} }
grid_line_start(&default_grid, W_ENDROW(wp)); grid_line_start(&default_gridview, W_ENDROW(wp));
grid_line_put_schar(W_ENDCOL(wp), fillchar, attr); grid_line_put_schar(W_ENDCOL(wp), fillchar, attr);
grid_line_flush(); grid_line_flush();
} }
@@ -252,8 +252,7 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
opt_scope = ((*wp->w_p_wbr != NUL) ? OPT_LOCAL : 0); opt_scope = ((*wp->w_p_wbr != NUL) ? OPT_LOCAL : 0);
row = -1; // row zero is first row of text row = -1; // row zero is first row of text
col = 0; col = 0;
grid = &wp->w_grid; grid = grid_adjust(&wp->w_grid, &row, &col);
grid_adjust(&grid, &row, &col);
if (row < 0) { if (row < 0) {
goto theend; goto theend;
@@ -261,7 +260,7 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
fillchar = wp->w_p_fcs_chars.wbr; fillchar = wp->w_p_fcs_chars.wbr;
attr = (wp == curwin) ? win_hl_attr(wp, HLF_WBR) : win_hl_attr(wp, HLF_WBRNC); attr = (wp == curwin) ? win_hl_attr(wp, HLF_WBR) : win_hl_attr(wp, HLF_WBRNC);
maxwidth = wp->w_width_inner; maxwidth = wp->w_view_width;
stl_clear_click_defs(wp->w_winbar_click_defs, wp->w_winbar_click_defs_size); stl_clear_click_defs(wp->w_winbar_click_defs, wp->w_winbar_click_defs_size);
wp->w_winbar_click_defs = stl_alloc_click_defs(wp->w_winbar_click_defs, maxwidth, wp->w_winbar_click_defs = stl_alloc_click_defs(wp->w_winbar_click_defs, maxwidth,
&wp->w_winbar_click_defs_size); &wp->w_winbar_click_defs_size);
@@ -294,8 +293,8 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
col = MAX(ru_col - (Columns - maxwidth), (maxwidth + 1) / 2); col = MAX(ru_col - (Columns - maxwidth), (maxwidth + 1) / 2);
maxwidth -= col; maxwidth -= col;
if (!in_status_line) { if (!in_status_line) {
grid = &msg_grid_adj;
row = Rows - 1; row = Rows - 1;
grid = grid_adjust(&msg_grid_adj, &row, &col);
maxwidth--; // writing in last column may cause scrolling maxwidth--; // writing in last column may cause scrolling
fillchar = schar_from_ascii(' '); fillchar = schar_from_ascii(' ');
attr = HL_ATTR(HLF_MSG); attr = HL_ATTR(HLF_MSG);
@@ -335,7 +334,7 @@ static void win_redr_custom(win_T *wp, bool draw_winbar, bool draw_ruler)
// Draw each snippet with the specified highlighting. // Draw each snippet with the specified highlighting.
if (!draw_ruler) { if (!draw_ruler) {
grid_line_start(grid, row); screengrid_line_start(grid, row, 0);
} }
int curattr = attr; int curattr = attr;
@@ -643,7 +642,7 @@ void draw_tabline(void)
int col = 0; int col = 0;
win_T *cwp; win_T *cwp;
int wincount; int wincount;
grid_line_start(&default_grid, 0); grid_line_start(&default_gridview, 0);
FOR_ALL_TABS(tp) { FOR_ALL_TABS(tp) {
tabcount++; tabcount++;
} }

6
src/nvim/terminal.c
View File

@@ -659,9 +659,9 @@ void terminal_check_size(Terminal *term)
} }
if (wp->w_buffer && wp->w_buffer->terminal == term) { if (wp->w_buffer && wp->w_buffer->terminal == term) {
const uint16_t win_width = const uint16_t win_width =
(uint16_t)(MAX(0, wp->w_width_inner - win_col_off(wp))); (uint16_t)(MAX(0, wp->w_view_width - win_col_off(wp)));
width = MAX(width, win_width); width = MAX(width, win_width);
height = (uint16_t)MAX(height, wp->w_height_inner); height = (uint16_t)MAX(height, wp->w_view_height);
} }
} }
@@ -2260,7 +2260,7 @@ static void adjust_topline(Terminal *term, buf_T *buf, int added)
if (following || (wp == curwin && is_focused(term))) { if (following || (wp == curwin && is_focused(term))) {
// "Follow" the terminal output // "Follow" the terminal output
wp->w_cursor.lnum = ml_end; wp->w_cursor.lnum = ml_end;
set_topline(wp, MAX(wp->w_cursor.lnum - wp->w_height_inner + 1, 1)); set_topline(wp, MAX(wp->w_cursor.lnum - wp->w_view_height + 1, 1));
} else { } else {
// Ensure valid cursor for each window displaying this terminal. // Ensure valid cursor for each window displaying this terminal.
wp->w_cursor.lnum = MIN(wp->w_cursor.lnum, ml_end); wp->w_cursor.lnum = MIN(wp->w_cursor.lnum, ml_end);

6
src/nvim/textformat.c
View File

@@ -734,7 +734,7 @@ void check_auto_format(bool end_insert)
/// Find out textwidth to be used for formatting: /// Find out textwidth to be used for formatting:
/// if 'textwidth' option is set, use it /// if 'textwidth' option is set, use it
/// else if 'wrapmargin' option is set, use curwin->w_width_inner-'wrapmargin' /// else if 'wrapmargin' option is set, use curwin->w_view_width-'wrapmargin'
/// if invalid value, use 0. /// if invalid value, use 0.
/// Set default to window width (maximum 79) for "gq" operator. /// Set default to window width (maximum 79) for "gq" operator.
/// ///
@@ -745,7 +745,7 @@ int comp_textwidth(bool ff)
if (textwidth == 0 && curbuf->b_p_wm) { if (textwidth == 0 && curbuf->b_p_wm) {
// The width is the window width minus 'wrapmargin' minus all the // The width is the window width minus 'wrapmargin' minus all the
// things that add to the margin. // things that add to the margin.
textwidth = curwin->w_width_inner - (int)curbuf->b_p_wm; textwidth = curwin->w_view_width - (int)curbuf->b_p_wm;
if (curbuf == cmdwin_buf) { if (curbuf == cmdwin_buf) {
textwidth -= 1; textwidth -= 1;
} }
@@ -758,7 +758,7 @@ int comp_textwidth(bool ff)
} }
textwidth = MAX(textwidth, 0); textwidth = MAX(textwidth, 0);
if (ff && textwidth == 0) { if (ff && textwidth == 0) {
textwidth = MIN(curwin->w_width_inner - 1, 79); textwidth = MIN(curwin->w_view_width - 1, 79);
} }
return textwidth; return textwidth;
} }

7
src/nvim/ui.c
View File

@@ -561,8 +561,11 @@ void ui_flush(void)
if (pending_cursor_update) { if (pending_cursor_update) {
ui_call_grid_cursor_goto(cursor_grid_handle, cursor_row, cursor_col); ui_call_grid_cursor_goto(cursor_grid_handle, cursor_row, cursor_col);
pending_cursor_update = false; pending_cursor_update = false;
// The cursor move might change the composition order, so flush again to update the windows that // The cursor move might change the composition order,
// changed // so flush again to update the windows that changed
// TODO(bfredl): refactor the flow of information so that win_ui_flush()
// only is called once. (as order state is exposed, it should be owned
// by nvim core, not the compositor)
win_ui_flush(false); win_ui_flush(false);
} }
if (pending_mode_info_update) { if (pending_mode_info_update) {

22
src/nvim/ui_compositor.c
View File

@@ -117,20 +117,20 @@ void ui_comp_layers_adjust(size_t layer_idx, bool raise)
while (layer_idx < size - 1 && layer->zindex > layers.items[layer_idx + 1]->zindex) { while (layer_idx < size - 1 && layer->zindex > layers.items[layer_idx + 1]->zindex) {
layers.items[layer_idx] = layers.items[layer_idx + 1]; layers.items[layer_idx] = layers.items[layer_idx + 1];
layers.items[layer_idx]->comp_index = layer_idx; layers.items[layer_idx]->comp_index = layer_idx;
layers.items[layer_idx]->composition_updated = true; layers.items[layer_idx]->pending_comp_index_update = true;
layer_idx++; layer_idx++;
} }
} else { } else {
while (layer_idx > 0 && layer->zindex < layers.items[layer_idx - 1]->zindex) { while (layer_idx > 0 && layer->zindex < layers.items[layer_idx - 1]->zindex) {
layers.items[layer_idx] = layers.items[layer_idx - 1]; layers.items[layer_idx] = layers.items[layer_idx - 1];
layers.items[layer_idx]->comp_index = layer_idx; layers.items[layer_idx]->comp_index = layer_idx;
layers.items[layer_idx]->composition_updated = true; layers.items[layer_idx]->pending_comp_index_update = true;
layer_idx--; layer_idx--;
} }
} }
layers.items[layer_idx] = layer; layers.items[layer_idx] = layer;
layer->comp_index = layer_idx; layer->comp_index = layer_idx;
layer->composition_updated = true; layer->pending_comp_index_update = true;
} }
/// Places `grid` at (col,row) position with (width * height) size. /// Places `grid` at (col,row) position with (width * height) size.
@@ -143,7 +143,7 @@ bool ui_comp_put_grid(ScreenGrid *grid, int row, int col, int height, int width,
bool on_top) bool on_top)
{ {
bool moved; bool moved;
grid->composition_updated = true; grid->pending_comp_index_update = true;
grid->comp_height = height; grid->comp_height = height;
grid->comp_width = width; grid->comp_width = width;
@@ -197,14 +197,14 @@ bool ui_comp_put_grid(ScreenGrid *grid, int row, int col, int height, int width,
for (size_t i = kv_size(layers) - 1; i > insert_at; i--) { for (size_t i = kv_size(layers) - 1; i > insert_at; i--) {
kv_A(layers, i) = kv_A(layers, i - 1); kv_A(layers, i) = kv_A(layers, i - 1);
kv_A(layers, i)->comp_index = i; kv_A(layers, i)->comp_index = i;
kv_A(layers, i)->composition_updated = true; kv_A(layers, i)->pending_comp_index_update = true;
} }
kv_A(layers, insert_at) = grid; kv_A(layers, insert_at) = grid;
grid->comp_row = row; grid->comp_row = row;
grid->comp_col = col; grid->comp_col = col;
grid->comp_index = insert_at; grid->comp_index = insert_at;
grid->composition_updated = true; grid->pending_comp_index_update = true;
} }
if (moved && valid && ui_comp_should_draw()) { if (moved && valid && ui_comp_should_draw()) {
compose_area(grid->comp_row, grid->comp_row + grid->rows, compose_area(grid->comp_row, grid->comp_row + grid->rows,
@@ -228,11 +228,11 @@ void ui_comp_remove_grid(ScreenGrid *grid)
for (size_t i = grid->comp_index; i < kv_size(layers) - 1; i++) { for (size_t i = grid->comp_index; i < kv_size(layers) - 1; i++) {
kv_A(layers, i) = kv_A(layers, i + 1); kv_A(layers, i) = kv_A(layers, i + 1);
kv_A(layers, i)->comp_index = i; kv_A(layers, i)->comp_index = i;
kv_A(layers, i)->composition_updated = true; kv_A(layers, i)->pending_comp_index_update = true;
} }
(void)kv_pop(layers); (void)kv_pop(layers);
grid->comp_index = 0; grid->comp_index = 0;
grid->composition_updated = true; grid->pending_comp_index_update = true;
// recompose the area under the grid // recompose the area under the grid
// inefficient when being overlapped: only draw up to grid->comp_index // inefficient when being overlapped: only draw up to grid->comp_index
@@ -264,11 +264,11 @@ void ui_comp_raise_grid(ScreenGrid *grid, size_t new_index)
for (size_t i = old_index; i < new_index; i++) { for (size_t i = old_index; i < new_index; i++) {
kv_A(layers, i) = kv_A(layers, i + 1); kv_A(layers, i) = kv_A(layers, i + 1);
kv_A(layers, i)->comp_index = i; kv_A(layers, i)->comp_index = i;
kv_A(layers, i)->composition_updated = true; kv_A(layers, i)->pending_comp_index_update = true;
} }
kv_A(layers, new_index) = grid; kv_A(layers, new_index) = grid;
grid->comp_index = new_index; grid->comp_index = new_index;
grid->composition_updated = true; grid->pending_comp_index_update = true;
for (size_t i = old_index; i < new_index; i++) { for (size_t i = old_index; i < new_index; i++) {
ScreenGrid *grid2 = kv_A(layers, i); ScreenGrid *grid2 = kv_A(layers, i);
int startcol = MAX(grid->comp_col, grid2->comp_col); int startcol = MAX(grid->comp_col, grid2->comp_col);
@@ -616,7 +616,7 @@ bool ui_comp_set_screen_valid(bool valid)
void ui_comp_msg_set_pos(Integer grid, Integer row, Boolean scrolled, String sep_char, void ui_comp_msg_set_pos(Integer grid, Integer row, Boolean scrolled, String sep_char,
Integer zindex, Integer compindex) Integer zindex, Integer compindex)
{ {
msg_grid.composition_updated = true; msg_grid.pending_comp_index_update = true;
msg_grid.comp_row = (int)row; msg_grid.comp_row = (int)row;
if (scrolled && row > 0) { if (scrolled && row > 0) {
msg_sep_row = (int)row - 1; msg_sep_row = (int)row - 1;

6
src/nvim/version.c
View File

@@ -2815,12 +2815,8 @@ static void do_intro_line(int row, char *mesg, bool colon)
col = 0; col = 0;
} }
ScreenGrid *grid = &default_grid; grid_line_start((!colon && ui_has(kUIMultigrid)) ? &firstwin->w_grid : &default_gridview, row);
if (!colon && ui_has(kUIMultigrid)) {
grid = &firstwin->w_grid;
}
grid_line_start(grid, row);
// Split up in parts to highlight <> items differently. // Split up in parts to highlight <> items differently.
for (char *p = mesg; *p != NUL; p += l) { for (char *p = mesg; *p != NUL; p += l) {
for (l = 0; for (l = 0;

57
src/nvim/window.c
View File

@@ -831,10 +831,9 @@ void ui_ext_win_position(win_T *wp, bool validate)
if (win->w_pos_changed && win->w_grid_alloc.chars != NULL && win_valid(win)) { if (win->w_pos_changed && win->w_grid_alloc.chars != NULL && win_valid(win)) {
ui_ext_win_position(win, validate); ui_ext_win_position(win, validate);
} }
grid = &win->w_grid;
int row_off = 0; int row_off = 0;
int col_off = 0; int col_off = 0;
grid_adjust(&grid, &row_off, &col_off); grid = grid_adjust(&win->w_grid, &row_off, &col_off);
row += row_off; row += row_off;
col += col_off; col += col_off;
if (c.bufpos.lnum >= 0) { if (c.bufpos.lnum >= 0) {
@@ -4127,12 +4126,12 @@ void win_init_size(void)
{ {
firstwin->w_height = (int)ROWS_AVAIL; firstwin->w_height = (int)ROWS_AVAIL;
firstwin->w_prev_height = (int)ROWS_AVAIL; firstwin->w_prev_height = (int)ROWS_AVAIL;
firstwin->w_height_inner = firstwin->w_height - firstwin->w_winbar_height; firstwin->w_view_height = firstwin->w_height - firstwin->w_winbar_height;
firstwin->w_height_outer = firstwin->w_height; firstwin->w_height_outer = firstwin->w_height;
firstwin->w_winrow_off = firstwin->w_winbar_height; firstwin->w_winrow_off = firstwin->w_winbar_height;
topframe->fr_height = (int)ROWS_AVAIL; topframe->fr_height = (int)ROWS_AVAIL;
firstwin->w_width = Columns; firstwin->w_width = Columns;
firstwin->w_width_inner = firstwin->w_width; firstwin->w_view_width = firstwin->w_width;
firstwin->w_width_outer = firstwin->w_width; firstwin->w_width_outer = firstwin->w_width;
topframe->fr_width = Columns; topframe->fr_width = Columns;
} }
@@ -6409,11 +6408,11 @@ void win_drag_vsep_line(win_T *dragwin, int offset)
// Has no effect when the window is less than two lines. // Has no effect when the window is less than two lines.
void set_fraction(win_T *wp) void set_fraction(win_T *wp)
{ {
if (wp->w_height_inner > 1) { if (wp->w_view_height > 1) {
// When cursor is in the first line the percentage is computed as if // When cursor is in the first line the percentage is computed as if
// it's halfway that line. Thus with two lines it is 25%, with three // it's halfway that line. Thus with two lines it is 25%, with three
// lines 17%, etc. Similarly for the last line: 75%, 83%, etc. // lines 17%, etc. Similarly for the last line: 75%, 83%, etc.
wp->w_fraction = (wp->w_wrow * FRACTION_MULT + FRACTION_MULT / 2) / wp->w_height_inner; wp->w_fraction = (wp->w_wrow * FRACTION_MULT + FRACTION_MULT / 2) / wp->w_view_height;
} }
} }
@@ -6488,13 +6487,13 @@ static void win_fix_cursor(bool normal)
if (skip_win_fix_cursor if (skip_win_fix_cursor
|| !wp->w_do_win_fix_cursor || !wp->w_do_win_fix_cursor
|| wp->w_buffer->b_ml.ml_line_count < wp->w_height_inner) { || wp->w_buffer->b_ml.ml_line_count < wp->w_view_height) {
return; return;
} }
wp->w_do_win_fix_cursor = false; wp->w_do_win_fix_cursor = false;
// Determine valid cursor range. // Determine valid cursor range.
int so = MIN(wp->w_height_inner / 2, get_scrolloff_value(wp)); int so = MIN(wp->w_view_height / 2, get_scrolloff_value(wp));
linenr_T lnum = wp->w_cursor.lnum; linenr_T lnum = wp->w_cursor.lnum;
wp->w_cursor.lnum = wp->w_topline; wp->w_cursor.lnum = wp->w_topline;
@@ -6511,7 +6510,7 @@ static void win_fix_cursor(bool normal)
if (lnum > bot && (wp->w_botline - wp->w_buffer->b_ml.ml_line_count) != 1) { if (lnum > bot && (wp->w_botline - wp->w_buffer->b_ml.ml_line_count) != 1) {
nlnum = bot; nlnum = bot;
} else if (lnum < top && wp->w_topline != 1) { } else if (lnum < top && wp->w_topline != 1) {
nlnum = (so == wp->w_height_inner / 2) ? bot : top; nlnum = (so == wp->w_view_height / 2) ? bot : top;
} }
if (nlnum != 0) { // Cursor is invalid for current scroll position. if (nlnum != 0) { // Cursor is invalid for current scroll position.
@@ -6546,7 +6545,7 @@ void win_new_height(win_T *wp, int height)
void scroll_to_fraction(win_T *wp, int prev_height) void scroll_to_fraction(win_T *wp, int prev_height)
{ {
int height = wp->w_height_inner; int height = wp->w_view_height;
// Don't change w_topline in any of these cases: // Don't change w_topline in any of these cases:
// - window height is 0 // - window height is 0
@@ -6570,8 +6569,8 @@ void scroll_to_fraction(win_T *wp, int prev_height)
// Make sure the whole cursor line is visible, if possible. // Make sure the whole cursor line is visible, if possible.
const int rows = plines_win(wp, lnum, false); const int rows = plines_win(wp, lnum, false);
if (sline > wp->w_height_inner - rows) { if (sline > wp->w_view_height - rows) {
sline = wp->w_height_inner - rows; sline = wp->w_view_height - rows;
wp->w_wrow -= rows - line_size; wp->w_wrow -= rows - line_size;
} }
} }
@@ -6581,12 +6580,12 @@ void scroll_to_fraction(win_T *wp, int prev_height)
// Make cursor line the first line in the window. If not enough // Make cursor line the first line in the window. If not enough
// room use w_skipcol; // room use w_skipcol;
wp->w_wrow = line_size; wp->w_wrow = line_size;
if (wp->w_wrow >= wp->w_height_inner if (wp->w_wrow >= wp->w_view_height
&& (wp->w_width_inner - win_col_off(wp)) > 0) { && (wp->w_view_width - win_col_off(wp)) > 0) {
wp->w_skipcol += wp->w_width_inner - win_col_off(wp); wp->w_skipcol += wp->w_view_width - win_col_off(wp);
wp->w_wrow--; wp->w_wrow--;
while (wp->w_wrow >= wp->w_height_inner) { while (wp->w_wrow >= wp->w_view_height) {
wp->w_skipcol += wp->w_width_inner - win_col_off(wp) wp->w_skipcol += wp->w_view_width - win_col_off(wp)
+ win_col_off2(wp); + win_col_off2(wp);
wp->w_wrow--; wp->w_wrow--;
} }
@@ -6643,7 +6642,7 @@ void win_set_inner_size(win_T *wp, bool valid_cursor)
width = wp->w_width; width = wp->w_width;
} }
int prev_height = wp->w_height_inner; int prev_height = wp->w_view_height;
int height = wp->w_height_request; int height = wp->w_height_request;
if (height == 0) { if (height == 0) {
height = MAX(0, wp->w_height - wp->w_winbar_height); height = MAX(0, wp->w_height - wp->w_winbar_height);
@@ -6656,14 +6655,14 @@ void win_set_inner_size(win_T *wp, bool valid_cursor)
// call win_new_height() recursively. // call win_new_height() recursively.
validate_cursor(curwin); validate_cursor(curwin);
} }
if (wp->w_height_inner != prev_height) { if (wp->w_view_height != prev_height) {
return; // Recursive call already changed the size, bail out. return; // Recursive call already changed the size, bail out.
} }
if (wp->w_wrow != wp->w_prev_fraction_row) { if (wp->w_wrow != wp->w_prev_fraction_row) {
set_fraction(wp); set_fraction(wp);
} }
} }
wp->w_height_inner = height; wp->w_view_height = height;
win_comp_scroll(wp); win_comp_scroll(wp);
// There is no point in adjusting the scroll position when exiting. Some // There is no point in adjusting the scroll position when exiting. Some
@@ -6675,8 +6674,8 @@ void win_set_inner_size(win_T *wp, bool valid_cursor)
redraw_later(wp, UPD_SOME_VALID); redraw_later(wp, UPD_SOME_VALID);
} }
if (width != wp->w_width_inner) { if (width != wp->w_view_width) {
wp->w_width_inner = width; wp->w_view_width = width;
wp->w_lines_valid = 0; wp->w_lines_valid = 0;
if (valid_cursor) { if (valid_cursor) {
changed_line_abv_curs_win(wp); changed_line_abv_curs_win(wp);
@@ -6692,8 +6691,8 @@ void win_set_inner_size(win_T *wp, bool valid_cursor)
terminal_check_size(wp->w_buffer->terminal); terminal_check_size(wp->w_buffer->terminal);
} }
wp->w_height_outer = (wp->w_height_inner + win_border_height(wp) + wp->w_winbar_height); wp->w_height_outer = (wp->w_view_height + win_border_height(wp) + wp->w_winbar_height);
wp->w_width_outer = (wp->w_width_inner + win_border_width(wp)); wp->w_width_outer = (wp->w_view_width + win_border_width(wp));
wp->w_winrow_off = wp->w_border_adj[0] + wp->w_winbar_height; wp->w_winrow_off = wp->w_border_adj[0] + wp->w_winbar_height;
wp->w_wincol_off = wp->w_border_adj[3]; wp->w_wincol_off = wp->w_border_adj[3];
@@ -6717,7 +6716,7 @@ void win_new_width(win_T *wp, int width)
OptInt win_default_scroll(win_T *wp) OptInt win_default_scroll(win_T *wp)
{ {
return MAX(wp->w_height_inner / 2, 1); return MAX(wp->w_view_height / 2, 1);
} }
void win_comp_scroll(win_T *wp) void win_comp_scroll(win_T *wp)
@@ -6770,7 +6769,7 @@ void command_height(void)
// Clear the cmdheight area. // Clear the cmdheight area.
if (msg_scrolled == 0 && full_screen) { if (msg_scrolled == 0 && full_screen) {
ScreenGrid *grid = &default_grid; GridView *grid = &default_gridview;
if (!ui_has(kUIMessages)) { if (!ui_has(kUIMessages)) {
msg_grid_validate(); msg_grid_validate();
grid = &msg_grid_adj; grid = &msg_grid_adj;
@@ -6944,7 +6943,7 @@ int set_winbar_win(win_T *wp, bool make_room, bool valid_cursor)
: ((*p_wbr != NUL || *wp->w_p_wbr != NUL) ? 1 : 0); : ((*p_wbr != NUL || *wp->w_p_wbr != NUL) ? 1 : 0);
if (wp->w_winbar_height != winbar_height) { if (wp->w_winbar_height != winbar_height) {
if (winbar_height == 1 && wp->w_height_inner <= 1) { if (winbar_height == 1 && wp->w_view_height <= 1) {
if (wp->w_floating) { if (wp->w_floating) {
emsg(_(e_noroom)); emsg(_(e_noroom));
return NOTDONE; return NOTDONE;
@@ -7468,7 +7467,7 @@ void win_get_tabwin(handle_T id, int *tabnr, int *winnr)
void win_ui_flush(bool validate) void win_ui_flush(bool validate)
{ {
FOR_ALL_TAB_WINDOWS(tp, wp) { FOR_ALL_TAB_WINDOWS(tp, wp) {
if ((wp->w_pos_changed || wp->w_grid_alloc.composition_updated) if ((wp->w_pos_changed || wp->w_grid_alloc.pending_comp_index_update)
&& wp->w_grid_alloc.chars != NULL) { && wp->w_grid_alloc.chars != NULL) {
if (tp == curtab) { if (tp == curtab) {
ui_ext_win_position(wp, validate); ui_ext_win_position(wp, validate);
@@ -7476,7 +7475,7 @@ void win_ui_flush(bool validate)
ui_call_win_hide(wp->w_grid_alloc.handle); ui_call_win_hide(wp->w_grid_alloc.handle);
wp->w_pos_changed = false; wp->w_pos_changed = false;
} }
wp->w_grid_alloc.composition_updated = false; wp->w_grid_alloc.pending_comp_index_update = false;
} }
if (tp == curtab) { if (tp == curtab) {
ui_ext_win_viewport(wp); ui_ext_win_viewport(wp);

7
src/nvim/winfloat.c
View File

@@ -243,12 +243,7 @@ void win_config_float(win_T *wp, WinConfig fconfig)
if (parent) { if (parent) {
row += parent->w_winrow; row += parent->w_winrow;
col += parent->w_wincol; col += parent->w_wincol;
ScreenGrid *grid = &parent->w_grid; grid_adjust(&parent->w_grid, &row, &col);
int row_off = 0;
int col_off = 0;
grid_adjust(&grid, &row_off, &col_off);
row += row_off;
col += col_off;
if (wp->w_config.bufpos.lnum >= 0) { if (wp->w_config.bufpos.lnum >= 0) {
pos_T pos = { MIN(wp->w_config.bufpos.lnum + 1, parent->w_buffer->b_ml.ml_line_count), pos_T pos = { MIN(wp->w_config.bufpos.lnum + 1, parent->w_buffer->b_ml.ml_line_count),
wp->w_config.bufpos.col, 0 }; wp->w_config.bufpos.col, 0 };