mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-12 22:38:16 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor: de-curwin-ify update_topline/curs_columns

Browse Source
This commit is contained in:
Matthieu Coudron
2020-12-23 16:53:35 +01:00
parent 4d9520ec86
commit 45166313cc
13 changed files with 221 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
src/nvim/edit.c
View File

@@ -381,7 +381,7 @@ static void insert_enter(InsertState *s)
// Need to recompute the cursor position, it might move when the cursor is
// on a TAB or special character.
curs_columns(true);
curs_columns(curwin, true);
// Enable langmap or IME, indicated by 'iminsert'.
// Note that IME may enabled/disabled without us noticing here, thus the
@@ -608,7 +608,7 @@ static int insert_check(VimState *state)
}
// May need to adjust w_topline to show the cursor.
update_topline();
update_topline(curwin);
s->did_backspace = false;
@@ -1561,7 +1561,7 @@ void edit_putchar(int c, bool highlight)
int attr;
if (curwin->w_grid.chars != NULL || default_grid.chars != NULL) {
update_topline(); // just in case w_topline isn't valid
update_topline(curwin); // just in case w_topline isn't valid
validate_cursor();
if (highlight) {
attr = HL_ATTR(HLF_8);
@@ -1677,7 +1677,7 @@ void display_dollar(colnr_T col)
// If on the last byte of a multi-byte move to the first byte.
char_u *p = get_cursor_line_ptr();
curwin->w_cursor.col -= utf_head_off(p, p + col);
curs_columns(false); // Recompute w_wrow and w_wcol
curs_columns(curwin, false); // Recompute w_wrow and w_wcol
if (curwin->w_wcol < curwin->w_grid.Columns) {
edit_putchar('$', false);
dollar_vcol = curwin->w_virtcol;
@@ -5328,7 +5328,7 @@ static int ins_complete(int c, bool enable_pum)
edit_submode_extra = match_ref;
edit_submode_highl = HLF_R;
if (dollar_vcol >= 0)
curs_columns(FALSE);
curs_columns(curwin, false);
}
}
}
@@ -6158,7 +6158,7 @@ internal_format (
curwin->w_p_lbr = has_lbr;
if (!format_only && haveto_redraw) {
update_topline();
update_topline(curwin);
redraw_curbuf_later(VALID);
}
}
@@ -6807,7 +6807,7 @@ cursor_up (
coladvance(curwin->w_curswant);
if (upd_topline) {
update_topline(); // make sure curwin->w_topline is valid
update_topline(curwin); // make sure curwin->w_topline is valid
}
return OK;
@@ -6858,7 +6858,7 @@ cursor_down (
coladvance(curwin->w_curswant);
if (upd_topline) {
update_topline(); // make sure curwin->w_topline is valid
update_topline(curwin); // make sure curwin->w_topline is valid
}
return OK;

6
src/nvim/eval.c
View File

@@ -7070,7 +7070,7 @@ void set_buffer_lines(buf_T *buf, linenr_T lnum_arg, bool append,
}
}
check_cursor_col();
update_topline();
update_topline(curwin);
}
if (!is_curbuf) {
@@ -7782,13 +7782,13 @@ pos_T *var2fpos(const typval_T *const tv, const int dollar_lnum,
if (name[0] == 'w' && dollar_lnum) {
pos.col = 0;
if (name[1] == '0') { // "w0": first visible line
update_topline();
update_topline(curwin);
// In silent Ex mode topline is zero, but that's not a valid line
// number; use one instead.
pos.lnum = curwin->w_topline > 0 ? curwin->w_topline : 1;
return &pos;
} else if (name[1] == '$') { // "w$": last visible line
validate_botline();
validate_botline(curwin);
// In silent Ex mode botline is zero, return zero then.
pos.lnum = curwin->w_botline > 0 ? curwin->w_botline - 1 : 0;
return &pos;

6
src/nvim/ex_cmds.c
View File

@@ -2705,7 +2705,7 @@ int do_ecmd(
if (topline == 0 && command == NULL) {
*so_ptr = 999; // force cursor to be vertically centered in the window
}
update_topline();
update_topline(curwin);
curwin->w_scbind_pos = curwin->w_topline;
*so_ptr = n;
redraw_curbuf_later(NOT_VALID); // redraw this buffer later
@@ -3704,7 +3704,7 @@ static buf_T *do_sub(exarg_T *eap, proftime_T timeout,
+ len_change;
highlight_match = TRUE;
update_topline();
update_topline(curwin);
validate_cursor();
update_screen(SOME_VALID);
highlight_match = false;
@@ -5733,7 +5733,7 @@ static buf_T *show_sub(exarg_T *eap, pos_T old_cusr,
redraw_later(curwin, SOME_VALID);
win_enter(save_curwin, false); // Return to original window
update_topline();
update_topline(curwin);
// Update screen now.
int save_rd = RedrawingDisabled;

4
src/nvim/ex_docmd.c
View File

@@ -8050,7 +8050,7 @@ static void ex_redraw(exarg_T *eap)
RedrawingDisabled = 0;
p_lz = FALSE;
validate_cursor();
update_topline();
update_topline(curwin);
if (eap->forceit) {
redraw_all_later(NOT_VALID);
}
@@ -8200,7 +8200,7 @@ static void ex_mark(exarg_T *eap)
void update_topline_cursor(void)
{
check_cursor(); /* put cursor on valid line */
update_topline();
update_topline(curwin);
if (!curwin->w_p_wrap)
validate_cursor();
update_curswant();

6
src/nvim/ex_getln.c
View File

@@ -523,7 +523,7 @@ static void may_do_incsearch_highlighting(int firstc, long count,
// positioned in the same way as the actual search command
restore_viewstate(&s->old_viewstate);
changed_cline_bef_curs();
update_topline();
update_topline(curwin);
if (found != 0) {
pos_T save_pos = curwin->w_cursor;
@@ -1546,7 +1546,7 @@ static int may_do_command_line_next_incsearch(int firstc, long count,
set_search_match(&s->match_end);
curwin->w_cursor = s->match_start;
changed_cline_bef_curs();
update_topline();
update_topline(curwin);
validate_cursor();
highlight_match = true;
save_viewstate(&s->old_viewstate);
@@ -2242,7 +2242,7 @@ static int command_line_changed(CommandLineState *s)
// Restore the window "view".
curwin->w_cursor = s->is_state.save_cursor;
restore_viewstate(&s->is_state.old_viewstate);
update_topline();
update_topline(curwin);
redrawcmdline();

2
src/nvim/fileio.c
View File

@@ -5103,7 +5103,7 @@ void buf_reload(buf_T *buf, int orig_mode)
curwin->w_topline = old_topline;
curwin->w_cursor = old_cursor;
check_cursor();
update_topline();
update_topline(curwin);
keep_filetype = FALSE;
/* Update folds unless they are defined manually. */

2
src/nvim/main.c
View File

@@ -539,7 +539,7 @@ int main(int argc, char **argv)
// When a startup script or session file setup for diff'ing and
// scrollbind, sync the scrollbind now.
if (curwin->w_p_diff && curwin->w_p_scb) {
update_topline();
update_topline(curwin);
check_scrollbind((linenr_T)0, 0L);
TIME_MSG("diff scrollbinding");
}

360
src/nvim/move.c
View File

@@ -129,7 +129,7 @@ void redraw_for_cursorline(win_T *wp)
*/
void update_topline_redraw(void)
{
update_topline();
update_topline(curwin);
if (must_redraw)
update_screen(0);
}
@@ -137,28 +137,28 @@ void update_topline_redraw(void)
/*
* Update curwin->w_topline to move the cursor onto the screen.
*/
void update_topline(void)
void update_topline(win_T *wp)
{
linenr_T old_topline;
int old_topfill;
bool check_topline = false;
bool check_botline = false;
long *so_ptr = curwin->w_p_so >= 0 ? &curwin->w_p_so : &p_so;
long *so_ptr = wp->w_p_so >= 0 ? &wp->w_p_so : &p_so;
long save_so = *so_ptr;
// If there is no valid screen and when the window height is zero just use
// the cursor line.
if (!default_grid.chars || curwin->w_height_inner == 0) {
curwin->w_topline = curwin->w_cursor.lnum;
curwin->w_botline = curwin->w_topline;
curwin->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
curwin->w_viewport_invalid = true;
curwin->w_scbind_pos = 1;
if (!default_grid.chars || wp->w_height_inner == 0) {
wp->w_topline = wp->w_cursor.lnum;
wp->w_botline = wp->w_topline;
wp->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
wp->w_viewport_invalid = true;
wp->w_scbind_pos = 1;
return;
}
check_cursor_moved(curwin);
if (curwin->w_valid & VALID_TOPLINE)
check_cursor_moved(wp);
if (wp->w_valid & VALID_TOPLINE)
return;
// When dragging with the mouse, don't scroll that quickly
@@ -166,52 +166,52 @@ void update_topline(void)
*so_ptr = mouse_dragging - 1;
}
old_topline = curwin->w_topline;
old_topfill = curwin->w_topfill;
old_topline = wp->w_topline;
old_topfill = wp->w_topfill;
// If the buffer is empty, always set topline to 1.
if (BUFEMPTY()) { // special case - file is empty
if (curwin->w_topline != 1) {
redraw_later(curwin, NOT_VALID);
if (wp->w_topline != 1) {
redraw_later(wp, NOT_VALID);
}
curwin->w_topline = 1;
curwin->w_botline = 2;
curwin->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
curwin->w_viewport_invalid = true;
curwin->w_scbind_pos = 1;
wp->w_topline = 1;
wp->w_botline = 2;
wp->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
wp->w_viewport_invalid = true;
wp->w_scbind_pos = 1;
}
/*
* If the cursor is above or near the top of the window, scroll the window
* to show the line the cursor is in, with 'scrolloff' context.
*/
else {
if (curwin->w_topline > 1) {
if (wp->w_topline > 1) {
/* If the cursor is above topline, scrolling is always needed.
* If the cursor is far below topline and there is no folding,
* scrolling down is never needed. */
if (curwin->w_cursor.lnum < curwin->w_topline)
if (wp->w_cursor.lnum < wp->w_topline)
check_topline = true;
else if (check_top_offset())
check_topline = true;
}
/* Check if there are more filler lines than allowed. */
if (!check_topline && curwin->w_topfill > diff_check_fill(curwin,
curwin->w_topline))
if (!check_topline && wp->w_topfill > diff_check_fill(wp,
wp->w_topline))
check_topline = true;
if (check_topline) {
int halfheight = curwin->w_height_inner / 2 - 1;
int halfheight = wp->w_height_inner / 2 - 1;
if (halfheight < 2) {
halfheight = 2;
}
long n;
if (hasAnyFolding(curwin)) {
if (hasAnyFolding(wp)) {
/* Count the number of logical lines between the cursor and
* topline + p_so (approximation of how much will be
* scrolled). */
n = 0;
for (linenr_T lnum = curwin->w_cursor.lnum;
lnum < curwin->w_topline + *so_ptr; lnum++) {
for (linenr_T lnum = wp->w_cursor.lnum;
lnum < wp->w_topline + *so_ptr; lnum++) {
n++;
// stop at end of file or when we know we are far off
if (lnum >= curbuf->b_ml.ml_line_count || n >= halfheight) {
@@ -220,7 +220,7 @@ void update_topline(void)
(void)hasFolding(lnum, NULL, &lnum);
}
} else {
n = curwin->w_topline + *so_ptr - curwin->w_cursor.lnum;
n = wp->w_topline + *so_ptr - wp->w_cursor.lnum;
}
/* If we weren't very close to begin with, we scroll to put the
@@ -234,7 +234,7 @@ void update_topline(void)
}
} else {
/* Make sure topline is the first line of a fold. */
(void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
(void)hasFolding(wp->w_topline, &wp->w_topline, NULL);
check_botline = true;
}
}
@@ -248,35 +248,37 @@ void update_topline(void)
* for every small change.
*/
if (check_botline) {
if (!(curwin->w_valid & VALID_BOTLINE_AP))
validate_botline();
if (!(wp->w_valid & VALID_BOTLINE_AP)) {
validate_botline(wp);
}
if (curwin->w_botline <= curbuf->b_ml.ml_line_count) {
if (curwin->w_cursor.lnum < curwin->w_botline) {
if (((long)curwin->w_cursor.lnum
>= (long)curwin->w_botline - *so_ptr
|| hasAnyFolding(curwin)
assert(wp->w_buffer != 0);
if (wp->w_botline <= wp->w_buffer->b_ml.ml_line_count) {
if (wp->w_cursor.lnum < wp->w_botline) {
if (((long)wp->w_cursor.lnum
>= (long)wp->w_botline - *so_ptr
|| hasAnyFolding(wp)
)) {
lineoff_T loff;
/* Cursor is (a few lines) above botline, check if there are
* 'scrolloff' window lines below the cursor. If not, need to
* scroll. */
int n = curwin->w_empty_rows;
loff.lnum = curwin->w_cursor.lnum;
int n = wp->w_empty_rows;
loff.lnum = wp->w_cursor.lnum;
/* In a fold go to its last line. */
(void)hasFolding(loff.lnum, NULL, &loff.lnum);
(void)hasFoldingWin(wp, loff.lnum, NULL, &loff.lnum, true, NULL);
loff.fill = 0;
n += curwin->w_filler_rows;
n += wp->w_filler_rows;
loff.height = 0;
while (loff.lnum < curwin->w_botline
&& (loff.lnum + 1 < curwin->w_botline || loff.fill == 0)
while (loff.lnum < wp->w_botline
&& (loff.lnum + 1 < wp->w_botline || loff.fill == 0)
) {
n += loff.height;
if (n >= *so_ptr) {
break;
}
botline_forw(&loff);
botline_forw(wp, &loff);
}
if (n >= *so_ptr) {
// sufficient context, no need to scroll
@@ -289,23 +291,23 @@ void update_topline(void)
}
if (check_botline) {
long line_count = 0;
if (hasAnyFolding(curwin)) {
if (hasAnyFolding(wp)) {
/* Count the number of logical lines between the cursor and
* botline - p_so (approximation of how much will be
* scrolled). */
for (linenr_T lnum = curwin->w_cursor.lnum;
lnum >= curwin->w_botline - *so_ptr; lnum--) {
for (linenr_T lnum = wp->w_cursor.lnum;
lnum >= wp->w_botline - *so_ptr; lnum--) {
line_count++;
// stop at end of file or when we know we are far off
if (lnum <= 0 || line_count > curwin->w_height_inner + 1) {
if (lnum <= 0 || line_count > wp->w_height_inner + 1) {
break;
}
(void)hasFolding(lnum, &lnum, NULL);
}
} else
line_count = curwin->w_cursor.lnum - curwin->w_botline
line_count = wp->w_cursor.lnum - wp->w_botline
+ 1 + *so_ptr;
if (line_count <= curwin->w_height_inner + 1) {
if (line_count <= wp->w_height_inner + 1) {
scroll_cursor_bot(scrolljump_value(), false);
} else {
scroll_cursor_halfway(false);
@@ -313,25 +315,25 @@ void update_topline(void)
}
}
}
curwin->w_valid |= VALID_TOPLINE;
curwin->w_viewport_invalid = true;
win_check_anchored_floats(curwin);
wp->w_valid |= VALID_TOPLINE;
wp->w_viewport_invalid = true;
win_check_anchored_floats(wp);
/*
* Need to redraw when topline changed.
*/
if (curwin->w_topline != old_topline
|| curwin->w_topfill != old_topfill
if (wp->w_topline != old_topline
|| wp->w_topfill != old_topfill
) {
dollar_vcol = -1;
if (curwin->w_skipcol != 0) {
curwin->w_skipcol = 0;
redraw_later(curwin, NOT_VALID);
if (wp->w_skipcol != 0) {
wp->w_skipcol = 0;
redraw_later(wp, NOT_VALID);
} else {
redraw_later(curwin, VALID);
redraw_later(wp, VALID);
}
// May need to set w_skipcol when cursor in w_topline.
if (curwin->w_cursor.lnum == curwin->w_topline) {
if (wp->w_cursor.lnum == wp->w_topline) {
validate_cursor();
}
}
@@ -346,7 +348,7 @@ void update_topline_win(win_T* win)
{
win_T *save_curwin;
switch_win(&save_curwin, NULL, win, NULL, true);
update_topline();
update_topline(curwin);
restore_win(save_curwin, NULL, true);
}
@@ -498,10 +500,11 @@ void changed_line_abv_curs_win(win_T *wp)
/*
* Make sure the value of curwin->w_botline is valid.
*/
void validate_botline(void)
void validate_botline(win_T *wp)
{
if (!(curwin->w_valid & VALID_BOTLINE))
comp_botline(curwin);
if (!(wp->w_valid & VALID_BOTLINE)) {
comp_botline(wp);
}
}
/*
@@ -540,7 +543,7 @@ void validate_cursor(void)
{
check_cursor_moved(curwin);
if ((curwin->w_valid & (VALID_WCOL|VALID_WROW)) != (VALID_WCOL|VALID_WROW))
curs_columns(true);
curs_columns(curwin, true);
}
/*
@@ -720,8 +723,10 @@ int curwin_col_off2(void)
// Compute curwin->w_wcol and curwin->w_virtcol.
// Also updates curwin->w_wrow and curwin->w_cline_row.
// Also updates curwin->w_leftcol.
// @param may_scroll when true, may scroll horizontally
void curs_columns(
int may_scroll /* when true, may scroll horizontally */
win_T *wp,
int may_scroll
)
{
int n;
@@ -729,72 +734,71 @@ void curs_columns(
colnr_T startcol;
colnr_T endcol;
colnr_T prev_skipcol;
long so = get_scrolloff_value(curwin);
long siso = get_sidescrolloff_value(curwin);
long so = get_scrolloff_value(wp);
long siso = get_sidescrolloff_value(wp);
/*
* First make sure that w_topline is valid (after moving the cursor).
*/
update_topline();
update_topline(wp);
// Next make sure that w_cline_row is valid.
if (!(curwin->w_valid & VALID_CROW)) {
curs_rows(curwin);
if (!(wp->w_valid & VALID_CROW)) {
curs_rows(wp);
}
/*
* Compute the number of virtual columns.
*/
if (curwin->w_cline_folded)
if (wp->w_cline_folded) {
/* In a folded line the cursor is always in the first column */
startcol = curwin->w_virtcol = endcol = curwin->w_leftcol;
else
getvvcol(curwin, &curwin->w_cursor,
&startcol, &(curwin->w_virtcol), &endcol);
startcol = wp->w_virtcol = endcol = wp->w_leftcol;
} else {
getvvcol(wp, &wp->w_cursor,
&startcol, &(wp->w_virtcol), &endcol);
}
/* remove '$' from change command when cursor moves onto it */
if (startcol > dollar_vcol)
dollar_vcol = -1;
int extra = curwin_col_off();
curwin->w_wcol = curwin->w_virtcol + extra;
int extra = win_col_off(wp);
wp->w_wcol = wp->w_virtcol + extra;
endcol += extra;
/*
* Now compute w_wrow, counting screen lines from w_cline_row.
*/
curwin->w_wrow = curwin->w_cline_row;
// Now compute w_wrow, counting screen lines from w_cline_row.
wp->w_wrow = wp->w_cline_row;
int textwidth = curwin->w_width_inner - extra;
int textwidth = wp->w_width_inner - extra;
if (textwidth <= 0) {
// No room for text, put cursor in last char of window.
curwin->w_wcol = curwin->w_width_inner - 1;
curwin->w_wrow = curwin->w_height_inner - 1;
} else if (curwin->w_p_wrap
&& curwin->w_width_inner != 0
wp->w_wcol = wp->w_width_inner - 1;
wp->w_wrow = wp->w_height_inner - 1;
} else if (wp->w_p_wrap
&& wp->w_width_inner != 0
) {
width = textwidth + curwin_col_off2();
width = textwidth + win_col_off2(wp);
// long line wrapping, adjust curwin->w_wrow
if (curwin->w_wcol >= curwin->w_width_inner) {
// long line wrapping, adjust wp->w_wrow
if (wp->w_wcol >= wp->w_width_inner) {
// this same formula is used in validate_cursor_col()
n = (curwin->w_wcol - curwin->w_width_inner) / width + 1;
curwin->w_wcol -= n * width;
curwin->w_wrow += n;
n = (wp->w_wcol - wp->w_width_inner) / width + 1;
wp->w_wcol -= n * width;
wp->w_wrow += n;
/* When cursor wraps to first char of next line in Insert
* mode, the 'showbreak' string isn't shown, backup to first
* column */
if (*p_sbr && *get_cursor_pos_ptr() == NUL
&& curwin->w_wcol == (int)vim_strsize(p_sbr))
curwin->w_wcol = 0;
&& wp->w_wcol == (int)vim_strsize(p_sbr))
wp->w_wcol = 0;
}
}
/* No line wrapping: compute curwin->w_leftcol if scrolling is on and line
/* No line wrapping: compute wp->w_leftcol if scrolling is on and line
* is not folded.
* If scrolling is off, curwin->w_leftcol is assumed to be 0 */
* If scrolling is off, wp->w_leftcol is assumed to be 0 */
else if (may_scroll
&& !curwin->w_cline_folded
&& !wp->w_cline_folded
) {
/*
* If Cursor is left of the screen, scroll rightwards.
@@ -803,9 +807,9 @@ void curs_columns(
* extra
*/
assert(siso <= INT_MAX);
int off_left = startcol - curwin->w_leftcol - (int)siso;
int off_left = startcol - wp->w_leftcol - (int)siso;
int off_right =
endcol - curwin->w_leftcol - curwin->w_width_inner + (int)siso + 1;
endcol - wp->w_leftcol - wp->w_width_inner + (int)siso + 1;
if (off_left < 0 || off_right > 0) {
int diff = (off_left < 0) ? -off_left: off_right;
@@ -813,52 +817,52 @@ void curs_columns(
* middle of window. */
int new_leftcol;
if (p_ss == 0 || diff >= textwidth / 2 || off_right >= off_left)
new_leftcol = curwin->w_wcol - extra - textwidth / 2;
new_leftcol = wp->w_wcol - extra - textwidth / 2;
else {
if (diff < p_ss) {
assert(p_ss <= INT_MAX);
diff = (int)p_ss;
}
if (off_left < 0)
new_leftcol = curwin->w_leftcol - diff;
new_leftcol = wp->w_leftcol - diff;
else
new_leftcol = curwin->w_leftcol + diff;
new_leftcol = wp->w_leftcol + diff;
}
if (new_leftcol < 0)
new_leftcol = 0;
if (new_leftcol != (int)curwin->w_leftcol) {
curwin->w_leftcol = new_leftcol;
win_check_anchored_floats(curwin);
// screen has to be redrawn with new curwin->w_leftcol
redraw_later(curwin, NOT_VALID);
if (new_leftcol != (int)wp->w_leftcol) {
wp->w_leftcol = new_leftcol;
win_check_anchored_floats(wp);
// screen has to be redrawn with new wp->w_leftcol
redraw_later(wp, NOT_VALID);
}
}
curwin->w_wcol -= curwin->w_leftcol;
} else if (curwin->w_wcol > (int)curwin->w_leftcol)
curwin->w_wcol -= curwin->w_leftcol;
wp->w_wcol -= wp->w_leftcol;
} else if (wp->w_wcol > (int)wp->w_leftcol)
wp->w_wcol -= wp->w_leftcol;
else
curwin->w_wcol = 0;
wp->w_wcol = 0;
/* Skip over filler lines. At the top use w_topfill, there
* may be some filler lines above the window. */
if (curwin->w_cursor.lnum == curwin->w_topline)
curwin->w_wrow += curwin->w_topfill;
if (wp->w_cursor.lnum == wp->w_topline)
wp->w_wrow += wp->w_topfill;
else
curwin->w_wrow += diff_check_fill(curwin, curwin->w_cursor.lnum);
wp->w_wrow += diff_check_fill(wp, wp->w_cursor.lnum);
prev_skipcol = curwin->w_skipcol;
prev_skipcol = wp->w_skipcol;
int plines = 0;
if ((curwin->w_wrow >= curwin->w_height_inner
if ((wp->w_wrow >= wp->w_height_inner
|| ((prev_skipcol > 0
|| curwin->w_wrow + so >= curwin->w_height_inner)
|| wp->w_wrow + so >= wp->w_height_inner)
&& (plines =
plines_win_nofill(curwin, curwin->w_cursor.lnum, false)) - 1
>= curwin->w_height_inner))
&& curwin->w_height_inner != 0
&& curwin->w_cursor.lnum == curwin->w_topline
plines_win_nofill(wp, wp->w_cursor.lnum, false)) - 1
>= wp->w_height_inner))
&& wp->w_height_inner != 0
&& wp->w_cursor.lnum == wp->w_topline
&& width > 0
&& curwin->w_width_inner != 0
&& wp->w_width_inner != 0
) {
/* Cursor past end of screen. Happens with a single line that does
* not fit on screen. Find a skipcol to show the text around the
@@ -867,87 +871,87 @@ void curs_columns(
* 2: Less than "p_so" lines below
* 3: both of them */
extra = 0;
if (curwin->w_skipcol + so * width > curwin->w_virtcol) {
if (wp->w_skipcol + so * width > wp->w_virtcol) {
extra = 1;
}
// Compute last display line of the buffer line that we want at the
// bottom of the window.
if (plines == 0) {
plines = plines_win(curwin, curwin->w_cursor.lnum, false);
plines = plines_win(wp, wp->w_cursor.lnum, false);
}
plines--;
if (plines > curwin->w_wrow + so) {
if (plines > wp->w_wrow + so) {
assert(so <= INT_MAX);
n = curwin->w_wrow + (int)so;
n = wp->w_wrow + (int)so;
} else {
n = plines;
}
if ((colnr_T)n >= curwin->w_height_inner + curwin->w_skipcol / width) {
if ((colnr_T)n >= wp->w_height_inner + wp->w_skipcol / width) {
extra += 2;
}
if (extra == 3 || plines < so * 2) {
// not enough room for 'scrolloff', put cursor in the middle
n = curwin->w_virtcol / width;
if (n > curwin->w_height_inner / 2) {
n -= curwin->w_height_inner / 2;
n = wp->w_virtcol / width;
if (n > wp->w_height_inner / 2) {
n -= wp->w_height_inner / 2;
} else {
n = 0;
}
// don't skip more than necessary
if (n > plines - curwin->w_height_inner + 1) {
n = plines - curwin->w_height_inner + 1;
if (n > plines - wp->w_height_inner + 1) {
n = plines - wp->w_height_inner + 1;
}
curwin->w_skipcol = n * width;
wp->w_skipcol = n * width;
} else if (extra == 1) {
// less then 'scrolloff' lines above, decrease skipcol
assert(so <= INT_MAX);
extra = (curwin->w_skipcol + (int)so * width - curwin->w_virtcol
extra = (wp->w_skipcol + (int)so * width - wp->w_virtcol
+ width - 1) / width;
if (extra > 0) {
if ((colnr_T)(extra * width) > curwin->w_skipcol)
extra = curwin->w_skipcol / width;
curwin->w_skipcol -= extra * width;
if ((colnr_T)(extra * width) > wp->w_skipcol)
extra = wp->w_skipcol / width;
wp->w_skipcol -= extra * width;
}
} else if (extra == 2) {
// less then 'scrolloff' lines below, increase skipcol
endcol = (n - curwin->w_height_inner + 1) * width;
while (endcol > curwin->w_virtcol) {
endcol = (n - wp->w_height_inner + 1) * width;
while (endcol > wp->w_virtcol) {
endcol -= width;
}
if (endcol > curwin->w_skipcol) {
curwin->w_skipcol = endcol;
if (endcol > wp->w_skipcol) {
wp->w_skipcol = endcol;
}
}
curwin->w_wrow -= curwin->w_skipcol / width;
if (curwin->w_wrow >= curwin->w_height_inner) {
wp->w_wrow -= wp->w_skipcol / width;
if (wp->w_wrow >= wp->w_height_inner) {
// small window, make sure cursor is in it
extra = curwin->w_wrow - curwin->w_height_inner + 1;
curwin->w_skipcol += extra * width;
curwin->w_wrow -= extra;
extra = wp->w_wrow - wp->w_height_inner + 1;
wp->w_skipcol += extra * width;
wp->w_wrow -= extra;
}
// extra could be either positive or negative
extra = ((int)prev_skipcol - (int)curwin->w_skipcol) / width;
win_scroll_lines(curwin, 0, extra);
extra = ((int)prev_skipcol - (int)wp->w_skipcol) / width;
win_scroll_lines(wp, 0, extra);
} else {
curwin->w_skipcol = 0;
wp->w_skipcol = 0;
}
if (prev_skipcol != curwin->w_skipcol) {
redraw_later(curwin, NOT_VALID);
if (prev_skipcol != wp->w_skipcol) {
redraw_later(wp, NOT_VALID);
}
/* Redraw when w_virtcol changes and 'cursorcolumn' is set */
if (curwin->w_p_cuc && (curwin->w_valid & VALID_VIRTCOL) == 0
if (wp->w_p_cuc && (wp->w_valid & VALID_VIRTCOL) == 0
&& !pum_visible()) {
redraw_later(curwin, SOME_VALID);
redraw_later(wp, SOME_VALID);
}
// now w_leftcol is valid, avoid check_cursor_moved() thinking otherwise
curwin->w_valid_leftcol = curwin->w_leftcol;
wp->w_valid_leftcol = wp->w_leftcol;
curwin->w_valid |= VALID_WCOL|VALID_WROW|VALID_VIRTCOL;
wp->w_valid |= VALID_WCOL|VALID_WROW|VALID_VIRTCOL;
}
/// Compute the screen position of text character at "pos" in window "wp"
@@ -1315,22 +1319,23 @@ static void topline_back(lineoff_T *lp)
* Returns the height of the added line in "lp->height".
* Lines below the last one are incredibly high.
*/
static void botline_forw(lineoff_T *lp)
static void botline_forw(win_T *wp, lineoff_T *lp)
{
if (lp->fill < diff_check_fill(curwin, lp->lnum + 1)) {
if (lp->fill < diff_check_fill(wp, lp->lnum + 1)) {
/* Add a filler line. */
++lp->fill;
lp->height = 1;
} else {
++lp->lnum;
lp->fill = 0;
if (lp->lnum > curbuf->b_ml.ml_line_count) {
assert(wp->w_buffer != 0);
if (lp->lnum > wp->w_buffer->b_ml.ml_line_count) {
lp->height = MAXCOL;
} else if (hasFolding(lp->lnum, NULL, &lp->lnum)) {
} else if (hasFoldingWin(wp, lp->lnum, NULL, &lp->lnum, true, NULL)) {
// Add a closed fold
lp->height = 1;
} else {
lp->height = plines_nofill(lp->lnum);
lp->height = plines_win_nofill(wp, lp->lnum, true);
}
}
}
@@ -1542,8 +1547,9 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
|| curwin->w_topfill != old_topfill
)
curwin->w_valid &= ~(VALID_WROW|VALID_CROW);
} else
validate_botline();
} else {
validate_botline(curwin);
}
/* The lines of the cursor line itself are always used. */
used = plines_nofill(cln);
@@ -1610,7 +1616,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
if (boff.lnum < curbuf->b_ml.ml_line_count) {
/* Add one line below */
botline_forw(&boff);
botline_forw(curwin, &boff);
used += boff.height;
if (used > curwin->w_height_inner) {
break;
@@ -1647,7 +1653,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
boff.lnum = curwin->w_topline - 1;
int i;
for (i = 0; i < scrolled && boff.lnum < curwin->w_botline; ) {
botline_forw(&boff);
botline_forw(curwin, &boff);
i += boff.height;
++line_count;
}
@@ -1701,7 +1707,7 @@ void scroll_cursor_halfway(int atend)
while (topline > 1) {
if (below <= above) { /* add a line below the cursor first */
if (boff.lnum < curbuf->b_ml.ml_line_count) {
botline_forw(&boff);
botline_forw(curwin, &boff);
used += boff.height;
if (used > curwin->w_height_inner) {
break;
@@ -1764,7 +1770,7 @@ void cursor_correct(void)
below_wanted = max_off;
}
}
validate_botline();
validate_botline(curwin);
if (curwin->w_botline == curbuf->b_ml.ml_line_count + 1
&& mouse_dragging == 0) {
below_wanted = 0;
@@ -1856,7 +1862,7 @@ int onepage(Direction dir, long count)
}
for (; count > 0; --count) {
validate_botline();
validate_botline(curwin);
/*
* It's an error to move a page up when the first line is already on
* the screen. It's an error to move a page down when the last line
@@ -1958,11 +1964,11 @@ int onepage(Direction dir, long count)
} else {
/* Go two lines forward again. */
topline_botline(&loff);
botline_forw(&loff);
botline_forw(&loff);
botline_forw(curwin, &loff);
botline_forw(curwin, &loff);
botline_topline(&loff);
/* We're at the wrong end of a fold now. */
(void)hasFolding(loff.lnum, &loff.lnum, NULL);
(void)hasFoldingWin(curwin, loff.lnum, &loff.lnum, NULL, true, NULL);
/* Always scroll at least one line. Avoid getting stuck on
* very long lines. */
@@ -2047,7 +2053,7 @@ static void get_scroll_overlap(lineoff_T *lp, int dir)
lineoff_T loff0 = *lp;
if (dir > 0)
botline_forw(lp);
botline_forw(curwin, lp);
else
topline_back(lp);
int h2 = lp->height;
@@ -2058,7 +2064,7 @@ static void get_scroll_overlap(lineoff_T *lp, int dir)
lineoff_T loff1 = *lp;
if (dir > 0)
botline_forw(lp);
botline_forw(curwin, lp);
else
topline_back(lp);
int h3 = lp->height;
@@ -2069,7 +2075,7 @@ static void get_scroll_overlap(lineoff_T *lp, int dir)
lineoff_T loff2 = *lp;
if (dir > 0)
botline_forw(lp);
botline_forw(curwin, lp);
else
topline_back(lp);
int h4 = lp->height;
@@ -2094,8 +2100,8 @@ void halfpage(bool flag, linenr_T Prenum)
int n = curwin->w_p_scr <= curwin->w_height_inner ? (int)curwin->w_p_scr
: curwin->w_height_inner;
update_topline();
validate_botline();
update_topline(curwin);
validate_botline(curwin);
int room = curwin->w_empty_rows + curwin->w_filler_rows;
if (flag) {
/*
@@ -2255,7 +2261,7 @@ void do_check_cursorbind(void)
// Only scroll when 'scrollbind' hasn't done this.
if (!curwin->w_p_scb) {
update_topline();
update_topline(curwin);
}
curwin->w_redr_status = true;
}

12
src/nvim/normal.c
View File

@@ -1261,7 +1261,7 @@ static void normal_redraw(NormalState *s)
{
// Before redrawing, make sure w_topline is correct, and w_leftcol
// if lines don't wrap, and w_skipcol if lines wrap.
update_topline();
update_topline(curwin);
validate_cursor();
// If the cursor moves horizontally when 'concealcursor' is active, then the
@@ -1341,7 +1341,7 @@ static int normal_check(VimState *state)
} else if (do_redraw || stuff_empty()) {
// Need to make sure w_topline and w_leftcol are correct before
// normal_check_window_scrolled() is called.
update_topline();
update_topline(curwin);
normal_check_cursor_moved(s);
normal_check_text_changed(s);
@@ -4254,7 +4254,7 @@ dozet:
case '+':
if (cap->count0 == 0) {
/* No count given: put cursor at the line below screen */
validate_botline(); /* make sure w_botline is valid */
validate_botline(curwin); /* make sure w_botline is valid */
if (curwin->w_botline > curbuf->b_ml.ml_line_count)
curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
else
@@ -5053,7 +5053,7 @@ static void nv_scroll(cmdarg_T *cap)
setpcmark();
if (cap->cmdchar == 'L') {
validate_botline(); /* make sure curwin->w_botline is valid */
validate_botline(curwin); /* make sure curwin->w_botline is valid */
curwin->w_cursor.lnum = curwin->w_botline - 1;
if (cap->count1 - 1 >= curwin->w_cursor.lnum)
curwin->w_cursor.lnum = 1;
@@ -5074,7 +5074,7 @@ static void nv_scroll(cmdarg_T *cap)
/* Don't count filler lines above the window. */
used -= diff_check_fill(curwin, curwin->w_topline)
- curwin->w_topfill;
validate_botline(); // make sure w_empty_rows is valid
validate_botline(curwin); // make sure w_empty_rows is valid
half = (curwin->w_height_inner - curwin->w_empty_rows + 1) / 2;
for (n = 0; curwin->w_topline + n < curbuf->b_ml.ml_line_count; n++) {
// Count half he number of filler lines to be "below this
@@ -6653,7 +6653,7 @@ static void nv_g_cmd(cmdarg_T *cap)
VIsual = curwin->w_cursor;
curwin->w_cursor = tpos;
check_cursor();
update_topline();
update_topline(curwin);
/*
* When called from normal "g" command: start Select mode when
* 'selectmode' contains "cmd". When called for K_SELECT, always

2
src/nvim/popupmnu.c
View File

@@ -809,7 +809,7 @@ static int pum_set_selected(int n, int repeat)
no_u_sync++;
win_enter(curwin_save, true);
no_u_sync--;
update_topline();
update_topline(curwin);
}
// Update the screen before drawing the popup menu.

4
src/nvim/quickfix.c
View File

@@ -3696,7 +3696,7 @@ void ex_copen(exarg_T *eap)
curwin->w_cursor.lnum = lnum;
curwin->w_cursor.col = 0;
check_cursor();
update_topline(); // scroll to show the line
update_topline(curwin); // scroll to show the line
}
// Move the cursor in the quickfix window to "lnum".
@@ -3710,7 +3710,7 @@ static void qf_win_goto(win_T *win, linenr_T lnum)
curwin->w_cursor.col = 0;
curwin->w_cursor.coladd = 0;
curwin->w_curswant = 0;
update_topline(); // scroll to show the line
update_topline(curwin); // scroll to show the line
redraw_later(curwin, VALID);
curwin->w_redr_status = true; // update ruler
curwin = old_curwin;

6
src/nvim/screen.c
View File

@@ -683,7 +683,7 @@ void conceal_check_cursor_line(void)
redrawWinline(curwin, curwin->w_cursor.lnum);
// Need to recompute cursor column, e.g., when starting Visual mode
// without concealing. */
curs_columns(true);
curs_columns(curwin, true);
}
}
@@ -1698,7 +1698,7 @@ static void win_update(win_T *wp, Providers *providers)
const int new_wcol = wp->w_wcol;
recursive = true;
curwin->w_valid &= ~VALID_TOPLINE;
update_topline(); // may invalidate w_botline again
update_topline(curwin); // may invalidate w_botline again
if (old_wcol != new_wcol
&& (wp->w_valid & (VALID_WCOL|VALID_WROW))
@@ -7382,7 +7382,7 @@ void screen_resize(int width, int height)
cmdline_pum_display(false);
}
} else {
update_topline();
update_topline(curwin);
if (pum_drawn()) {
// TODO(bfredl): ins_compl_show_pum wants to redraw the screen first.
// For now make sure the nested update_screen(0) won't redraw the

10
src/nvim/window.c
View File

@@ -4526,7 +4526,7 @@ static void win_enter_ext(win_T *wp, bool undo_sync, int curwin_invalid,
// Might need to scroll the old window before switching, e.g., when the
// cursor was moved.
update_topline();
update_topline(curwin);
// may have to copy the buffer options when 'cpo' contains 'S'
if (wp->w_buffer != curbuf) {
@@ -5860,9 +5860,9 @@ void scroll_to_fraction(win_T *wp, int prev_height)
if (wp == curwin) {
if (get_scrolloff_value(wp)) {
update_topline();
update_topline(wp);
}
curs_columns(false); // validate w_wrow
curs_columns(wp, false); // validate w_wrow
}
if (prev_height > 0) {
wp->w_prev_fraction_row = wp->w_wrow;
@@ -5918,8 +5918,8 @@ void win_set_inner_size(win_T *wp)
changed_line_abv_curs_win(wp);
invalidate_botline_win(wp);
if (wp == curwin) {
update_topline();
curs_columns(true); // validate w_wrow
update_topline(wp);
curs_columns(wp, true); // validate w_wrow
}
redraw_later(wp, NOT_VALID);
}