mirrors/neovim
1
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-09-13 06:48:17 +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 // Need to recompute the cursor position, it might move when the cursor is
// on a TAB or special character. // on a TAB or special character.
curs_columns(true); curs_columns(curwin, true);
// Enable langmap or IME, indicated by 'iminsert'. // Enable langmap or IME, indicated by 'iminsert'.
// Note that IME may enabled/disabled without us noticing here, thus the // 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. // May need to adjust w_topline to show the cursor.
update_topline(); update_topline(curwin);
s->did_backspace = false; s->did_backspace = false;
@@ -1561,7 +1561,7 @@ void edit_putchar(int c, bool highlight)
int attr; int attr;
if (curwin->w_grid.chars != NULL || default_grid.chars != NULL) { 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(); validate_cursor();
if (highlight) { if (highlight) {
attr = HL_ATTR(HLF_8); 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. // If on the last byte of a multi-byte move to the first byte.
char_u *p = get_cursor_line_ptr(); char_u *p = get_cursor_line_ptr();
curwin->w_cursor.col -= utf_head_off(p, p + col); curwin->w_cursor.col -= utf_head_off(p, p + col);
curs_columns(false); // Recompute w_wrow and w_wcol curs_columns(curwin, false); // Recompute w_wrow and w_wcol
if (curwin->w_wcol < curwin->w_grid.Columns) { if (curwin->w_wcol < curwin->w_grid.Columns) {
edit_putchar('$', false); edit_putchar('$', false);
dollar_vcol = curwin->w_virtcol; 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_extra = match_ref;
edit_submode_highl = HLF_R; edit_submode_highl = HLF_R;
if (dollar_vcol >= 0) if (dollar_vcol >= 0)
curs_columns(FALSE); curs_columns(curwin, false);
} }
} }
} }
@@ -6158,7 +6158,7 @@ internal_format (
curwin->w_p_lbr = has_lbr; curwin->w_p_lbr = has_lbr;
if (!format_only && haveto_redraw) { if (!format_only && haveto_redraw) {
update_topline(); update_topline(curwin);
redraw_curbuf_later(VALID); redraw_curbuf_later(VALID);
} }
} }
@@ -6807,7 +6807,7 @@ cursor_up (
coladvance(curwin->w_curswant); coladvance(curwin->w_curswant);
if (upd_topline) { if (upd_topline) {
update_topline(); // make sure curwin->w_topline is valid update_topline(curwin); // make sure curwin->w_topline is valid
} }
return OK; return OK;
@@ -6858,7 +6858,7 @@ cursor_down (
coladvance(curwin->w_curswant); coladvance(curwin->w_curswant);
if (upd_topline) { if (upd_topline) {
update_topline(); // make sure curwin->w_topline is valid update_topline(curwin); // make sure curwin->w_topline is valid
} }
return OK; 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(); check_cursor_col();
update_topline(); update_topline(curwin);
} }
if (!is_curbuf) { 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) { if (name[0] == 'w' && dollar_lnum) {
pos.col = 0; pos.col = 0;
if (name[1] == '0') { // "w0": first visible line 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 // In silent Ex mode topline is zero, but that's not a valid line
// number; use one instead. // number; use one instead.
pos.lnum = curwin->w_topline > 0 ? curwin->w_topline : 1; pos.lnum = curwin->w_topline > 0 ? curwin->w_topline : 1;
return &pos; return &pos;
} else if (name[1] == '$') { // "w$": last visible line } else if (name[1] == '$') { // "w$": last visible line
validate_botline(); validate_botline(curwin);
// In silent Ex mode botline is zero, return zero then. // In silent Ex mode botline is zero, return zero then.
pos.lnum = curwin->w_botline > 0 ? curwin->w_botline - 1 : 0; pos.lnum = curwin->w_botline > 0 ? curwin->w_botline - 1 : 0;
return &pos; return &pos;

6
src/nvim/ex_cmds.c
View File

@@ -2705,7 +2705,7 @@ int do_ecmd(
if (topline == 0 && command == NULL) { if (topline == 0 && command == NULL) {
*so_ptr = 999; // force cursor to be vertically centered in the window *so_ptr = 999; // force cursor to be vertically centered in the window
} }
update_topline(); update_topline(curwin);
curwin->w_scbind_pos = curwin->w_topline; curwin->w_scbind_pos = curwin->w_topline;
*so_ptr = n; *so_ptr = n;
redraw_curbuf_later(NOT_VALID); // redraw this buffer later 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; + len_change;
highlight_match = TRUE; highlight_match = TRUE;
update_topline(); update_topline(curwin);
validate_cursor(); validate_cursor();
update_screen(SOME_VALID); update_screen(SOME_VALID);
highlight_match = false; highlight_match = false;
@@ -5733,7 +5733,7 @@ static buf_T *show_sub(exarg_T *eap, pos_T old_cusr,
redraw_later(curwin, SOME_VALID); redraw_later(curwin, SOME_VALID);
win_enter(save_curwin, false); // Return to original window win_enter(save_curwin, false); // Return to original window
update_topline(); update_topline(curwin);
// Update screen now. // Update screen now.
int save_rd = RedrawingDisabled; 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; RedrawingDisabled = 0;
p_lz = FALSE; p_lz = FALSE;
validate_cursor(); validate_cursor();
update_topline(); update_topline(curwin);
if (eap->forceit) { if (eap->forceit) {
redraw_all_later(NOT_VALID); redraw_all_later(NOT_VALID);
} }
@@ -8200,7 +8200,7 @@ static void ex_mark(exarg_T *eap)
void update_topline_cursor(void) void update_topline_cursor(void)
{ {
check_cursor(); /* put cursor on valid line */ check_cursor(); /* put cursor on valid line */
update_topline(); update_topline(curwin);
if (!curwin->w_p_wrap) if (!curwin->w_p_wrap)
validate_cursor(); validate_cursor();
update_curswant(); 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 // positioned in the same way as the actual search command
restore_viewstate(&s->old_viewstate); restore_viewstate(&s->old_viewstate);
changed_cline_bef_curs(); changed_cline_bef_curs();
update_topline(); update_topline(curwin);
if (found != 0) { if (found != 0) {
pos_T save_pos = curwin->w_cursor; 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); set_search_match(&s->match_end);
curwin->w_cursor = s->match_start; curwin->w_cursor = s->match_start;
changed_cline_bef_curs(); changed_cline_bef_curs();
update_topline(); update_topline(curwin);
validate_cursor(); validate_cursor();
highlight_match = true; highlight_match = true;
save_viewstate(&s->old_viewstate); save_viewstate(&s->old_viewstate);
@@ -2242,7 +2242,7 @@ static int command_line_changed(CommandLineState *s)
// Restore the window "view". // Restore the window "view".
curwin->w_cursor = s->is_state.save_cursor; curwin->w_cursor = s->is_state.save_cursor;
restore_viewstate(&s->is_state.old_viewstate); restore_viewstate(&s->is_state.old_viewstate);
update_topline(); update_topline(curwin);
redrawcmdline(); 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_topline = old_topline;
curwin->w_cursor = old_cursor; curwin->w_cursor = old_cursor;
check_cursor(); check_cursor();
update_topline(); update_topline(curwin);
keep_filetype = FALSE; keep_filetype = FALSE;
/* Update folds unless they are defined manually. */ /* 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 // When a startup script or session file setup for diff'ing and
// scrollbind, sync the scrollbind now. // scrollbind, sync the scrollbind now.
if (curwin->w_p_diff && curwin->w_p_scb) { if (curwin->w_p_diff && curwin->w_p_scb) {
update_topline(); update_topline(curwin);
check_scrollbind((linenr_T)0, 0L); check_scrollbind((linenr_T)0, 0L);
TIME_MSG("diff scrollbinding"); 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) void update_topline_redraw(void)
{ {
update_topline(); update_topline(curwin);
if (must_redraw) if (must_redraw)
update_screen(0); update_screen(0);
} }
@@ -137,28 +137,28 @@ void update_topline_redraw(void)
/* /*
* Update curwin->w_topline to move the cursor onto the screen. * 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; linenr_T old_topline;
int old_topfill; int old_topfill;
bool check_topline = false; bool check_topline = false;
bool check_botline = 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; long save_so = *so_ptr;
// 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 || curwin->w_height_inner == 0) { if (!default_grid.chars || wp->w_height_inner == 0) {
curwin->w_topline = curwin->w_cursor.lnum; wp->w_topline = wp->w_cursor.lnum;
curwin->w_botline = curwin->w_topline; wp->w_botline = wp->w_topline;
curwin->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP; wp->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
curwin->w_viewport_invalid = true; wp->w_viewport_invalid = true;
curwin->w_scbind_pos = 1; wp->w_scbind_pos = 1;
return; return;
} }
check_cursor_moved(curwin); check_cursor_moved(wp);
if (curwin->w_valid & VALID_TOPLINE) if (wp->w_valid & VALID_TOPLINE)
return; return;
// When dragging with the mouse, don't scroll that quickly // When dragging with the mouse, don't scroll that quickly
@@ -166,52 +166,52 @@ void update_topline(void)
*so_ptr = mouse_dragging - 1; *so_ptr = mouse_dragging - 1;
} }
old_topline = curwin->w_topline; old_topline = wp->w_topline;
old_topfill = curwin->w_topfill; old_topfill = wp->w_topfill;
// If the buffer is empty, always set topline to 1. // If the buffer is empty, always set topline to 1.
if (BUFEMPTY()) { // special case - file is empty if (BUFEMPTY()) { // special case - file is empty
if (curwin->w_topline != 1) { if (wp->w_topline != 1) {
redraw_later(curwin, NOT_VALID); redraw_later(wp, NOT_VALID);
} }
curwin->w_topline = 1; wp->w_topline = 1;
curwin->w_botline = 2; wp->w_botline = 2;
curwin->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP; wp->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
curwin->w_viewport_invalid = true; wp->w_viewport_invalid = true;
curwin->w_scbind_pos = 1; wp->w_scbind_pos = 1;
} }
/* /*
* If the cursor is above or near the top of the window, scroll the window * 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. * to show the line the cursor is in, with 'scrolloff' context.
*/ */
else { 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 above topline, scrolling is always needed.
* If the cursor is far below topline and there is no folding, * If the cursor is far below topline and there is no folding,
* scrolling down is never needed. */ * scrolling down is never needed. */
if (curwin->w_cursor.lnum < curwin->w_topline) if (wp->w_cursor.lnum < wp->w_topline)
check_topline = true; check_topline = true;
else if (check_top_offset()) else if (check_top_offset())
check_topline = true; check_topline = true;
} }
/* Check if there are more filler lines than allowed. */ /* Check if there are more filler lines than allowed. */
if (!check_topline && curwin->w_topfill > diff_check_fill(curwin, if (!check_topline && wp->w_topfill > diff_check_fill(wp,
curwin->w_topline)) wp->w_topline))
check_topline = true; check_topline = true;
if (check_topline) { if (check_topline) {
int halfheight = curwin->w_height_inner / 2 - 1; int halfheight = wp->w_height_inner / 2 - 1;
if (halfheight < 2) { if (halfheight < 2) {
halfheight = 2; halfheight = 2;
} }
long n; long n;
if (hasAnyFolding(curwin)) { if (hasAnyFolding(wp)) {
/* Count the number of logical lines between the cursor and /* Count the number of logical lines between the cursor and
* topline + p_so (approximation of how much will be * topline + p_so (approximation of how much will be
* scrolled). */ * scrolled). */
n = 0; n = 0;
for (linenr_T lnum = curwin->w_cursor.lnum; for (linenr_T lnum = wp->w_cursor.lnum;
lnum < curwin->w_topline + *so_ptr; lnum++) { lnum < wp->w_topline + *so_ptr; lnum++) {
n++; n++;
// 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 >= curbuf->b_ml.ml_line_count || n >= halfheight) { if (lnum >= curbuf->b_ml.ml_line_count || n >= halfheight) {
@@ -220,7 +220,7 @@ void update_topline(void)
(void)hasFolding(lnum, NULL, &lnum); (void)hasFolding(lnum, NULL, &lnum);
} }
} else { } 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 /* If we weren't very close to begin with, we scroll to put the
@@ -234,7 +234,7 @@ void update_topline(void)
} }
} else { } else {
/* Make sure topline is the first line of a fold. */ /* 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; check_botline = true;
} }
} }
@@ -248,35 +248,37 @@ void update_topline(void)
* for every small change. * for every small change.
*/ */
if (check_botline) { if (check_botline) {
if (!(curwin->w_valid & VALID_BOTLINE_AP)) if (!(wp->w_valid & VALID_BOTLINE_AP)) {
validate_botline(); validate_botline(wp);
}
if (curwin->w_botline <= curbuf->b_ml.ml_line_count) { assert(wp->w_buffer != 0);
if (curwin->w_cursor.lnum < curwin->w_botline) { if (wp->w_botline <= wp->w_buffer->b_ml.ml_line_count) {
if (((long)curwin->w_cursor.lnum if (wp->w_cursor.lnum < wp->w_botline) {
>= (long)curwin->w_botline - *so_ptr if (((long)wp->w_cursor.lnum
|| hasAnyFolding(curwin) >= (long)wp->w_botline - *so_ptr
|| hasAnyFolding(wp)
)) { )) {
lineoff_T loff; lineoff_T loff;
/* Cursor is (a few lines) above botline, check if there are /* Cursor is (a few lines) above botline, check if there are
* 'scrolloff' window lines below the cursor. If not, need to * 'scrolloff' window lines below the cursor. If not, need to
* scroll. */ * scroll. */
int n = curwin->w_empty_rows; int n = wp->w_empty_rows;
loff.lnum = curwin->w_cursor.lnum; loff.lnum = wp->w_cursor.lnum;
/* In a fold go to its last line. */ /* 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; loff.fill = 0;
n += curwin->w_filler_rows; n += wp->w_filler_rows;
loff.height = 0; loff.height = 0;
while (loff.lnum < curwin->w_botline while (loff.lnum < wp->w_botline
&& (loff.lnum + 1 < curwin->w_botline || loff.fill == 0) && (loff.lnum + 1 < wp->w_botline || loff.fill == 0)
) { ) {
n += loff.height; n += loff.height;
if (n >= *so_ptr) { if (n >= *so_ptr) {
break; break;
} }
botline_forw(&loff); botline_forw(wp, &loff);
} }
if (n >= *so_ptr) { if (n >= *so_ptr) {
// sufficient context, no need to scroll // sufficient context, no need to scroll
@@ -289,23 +291,23 @@ void update_topline(void)
} }
if (check_botline) { if (check_botline) {
long line_count = 0; long line_count = 0;
if (hasAnyFolding(curwin)) { if (hasAnyFolding(wp)) {
/* Count the number of logical lines between the cursor and /* Count the number of logical lines between the cursor and
* botline - p_so (approximation of how much will be * botline - p_so (approximation of how much will be
* scrolled). */ * scrolled). */
for (linenr_T lnum = curwin->w_cursor.lnum; for (linenr_T lnum = wp->w_cursor.lnum;
lnum >= curwin->w_botline - *so_ptr; lnum--) { lnum >= wp->w_botline - *so_ptr; lnum--) {
line_count++; line_count++;
// stop at end of file or when we know we are far off // stop at end of file or when we know we are far off
if (lnum <= 0 || line_count > curwin->w_height_inner + 1) { if (lnum <= 0 || line_count > wp->w_height_inner + 1) {
break; break;
} }
(void)hasFolding(lnum, &lnum, NULL); (void)hasFolding(lnum, &lnum, NULL);
} }
} else } else
line_count = curwin->w_cursor.lnum - curwin->w_botline line_count = wp->w_cursor.lnum - wp->w_botline
+ 1 + *so_ptr; + 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); scroll_cursor_bot(scrolljump_value(), false);
} else { } else {
scroll_cursor_halfway(false); scroll_cursor_halfway(false);
@@ -313,25 +315,25 @@ void update_topline(void)
} }
} }
} }
curwin->w_valid |= VALID_TOPLINE; wp->w_valid |= VALID_TOPLINE;
curwin->w_viewport_invalid = true; wp->w_viewport_invalid = true;
win_check_anchored_floats(curwin); win_check_anchored_floats(wp);
/* /*
* Need to redraw when topline changed. * Need to redraw when topline changed.
*/ */
if (curwin->w_topline != old_topline if (wp->w_topline != old_topline
|| curwin->w_topfill != old_topfill || wp->w_topfill != old_topfill
) { ) {
dollar_vcol = -1; dollar_vcol = -1;
if (curwin->w_skipcol != 0) { if (wp->w_skipcol != 0) {
curwin->w_skipcol = 0; wp->w_skipcol = 0;
redraw_later(curwin, NOT_VALID); redraw_later(wp, NOT_VALID);
} else { } else {
redraw_later(curwin, VALID); redraw_later(wp, VALID);
} }
// May need to set w_skipcol when cursor in w_topline. // 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(); validate_cursor();
} }
} }
@@ -346,7 +348,7 @@ void update_topline_win(win_T* win)
{ {
win_T *save_curwin; win_T *save_curwin;
switch_win(&save_curwin, NULL, win, NULL, true); switch_win(&save_curwin, NULL, win, NULL, true);
update_topline(); update_topline(curwin);
restore_win(save_curwin, NULL, true); 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. * 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)) if (!(wp->w_valid & VALID_BOTLINE)) {
comp_botline(curwin); comp_botline(wp);
}
} }
/* /*
@@ -540,7 +543,7 @@ void validate_cursor(void)
{ {
check_cursor_moved(curwin); check_cursor_moved(curwin);
if ((curwin->w_valid & (VALID_WCOL|VALID_WROW)) != (VALID_WCOL|VALID_WROW)) if ((curwin->w_valid & (VALID_WCOL|VALID_WROW)) != (VALID_WCOL|VALID_WROW))
curs_columns(true); curs_columns(curwin, true);
} }
/* /*
@@ -720,8 +723,10 @@ int curwin_col_off2(void)
// Compute curwin->w_wcol and curwin->w_virtcol. // Compute curwin->w_wcol and curwin->w_virtcol.
// Also updates curwin->w_wrow and curwin->w_cline_row. // Also updates curwin->w_wrow and curwin->w_cline_row.
// Also updates curwin->w_leftcol. // Also updates curwin->w_leftcol.
// @param may_scroll when true, may scroll horizontally
void curs_columns( void curs_columns(
int may_scroll /* when true, may scroll horizontally */ win_T *wp,
int may_scroll
) )
{ {
int n; int n;
@@ -729,72 +734,71 @@ void curs_columns(
colnr_T startcol; colnr_T startcol;
colnr_T endcol; colnr_T endcol;
colnr_T prev_skipcol; colnr_T prev_skipcol;
long so = get_scrolloff_value(curwin); long so = get_scrolloff_value(wp);
long siso = get_sidescrolloff_value(curwin); long siso = get_sidescrolloff_value(wp);
/* /*
* First make sure that w_topline is valid (after moving the cursor). * 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. // Next make sure that w_cline_row is valid.
if (!(curwin->w_valid & VALID_CROW)) { if (!(wp->w_valid & VALID_CROW)) {
curs_rows(curwin); curs_rows(wp);
} }
/* /*
* Compute the number of virtual columns. * 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 */ /* In a folded line the cursor is always in the first column */
startcol = curwin->w_virtcol = endcol = curwin->w_leftcol; startcol = wp->w_virtcol = endcol = wp->w_leftcol;
else } else {
getvvcol(curwin, &curwin->w_cursor, getvvcol(wp, &wp->w_cursor,
&startcol, &(curwin->w_virtcol), &endcol); &startcol, &(wp->w_virtcol), &endcol);
}
/* remove '$' from change command when cursor moves onto it */ /* remove '$' from change command when cursor moves onto it */
if (startcol > dollar_vcol) if (startcol > dollar_vcol)
dollar_vcol = -1; dollar_vcol = -1;
int extra = curwin_col_off(); int extra = win_col_off(wp);
curwin->w_wcol = curwin->w_virtcol + extra; wp->w_wcol = wp->w_virtcol + extra;
endcol += extra; endcol += extra;
/* // Now compute w_wrow, counting screen lines from w_cline_row.
* Now compute w_wrow, counting screen lines from w_cline_row. wp->w_wrow = wp->w_cline_row;
*/
curwin->w_wrow = curwin->w_cline_row;
int textwidth = curwin->w_width_inner - extra; int textwidth = wp->w_width_inner - extra;
if (textwidth <= 0) { if (textwidth <= 0) {
// No room for text, put cursor in last char of window. // No room for text, put cursor in last char of window.
curwin->w_wcol = curwin->w_width_inner - 1; wp->w_wcol = wp->w_width_inner - 1;
curwin->w_wrow = curwin->w_height_inner - 1; wp->w_wrow = wp->w_height_inner - 1;
} else if (curwin->w_p_wrap } else if (wp->w_p_wrap
&& curwin->w_width_inner != 0 && wp->w_width_inner != 0
) { ) {
width = textwidth + curwin_col_off2(); width = textwidth + win_col_off2(wp);
// long line wrapping, adjust curwin->w_wrow // long line wrapping, adjust wp->w_wrow
if (curwin->w_wcol >= curwin->w_width_inner) { if (wp->w_wcol >= wp->w_width_inner) {
// this same formula is used in validate_cursor_col() // this same formula is used in validate_cursor_col()
n = (curwin->w_wcol - curwin->w_width_inner) / width + 1; n = (wp->w_wcol - wp->w_width_inner) / width + 1;
curwin->w_wcol -= n * width; wp->w_wcol -= n * width;
curwin->w_wrow += n; wp->w_wrow += n;
/* When cursor wraps to first char of next line in Insert /* When cursor wraps to first char of next line in Insert
* mode, the 'showbreak' string isn't shown, backup to first * mode, the 'showbreak' string isn't shown, backup to first
* column */ * column */
if (*p_sbr && *get_cursor_pos_ptr() == NUL if (*p_sbr && *get_cursor_pos_ptr() == NUL
&& curwin->w_wcol == (int)vim_strsize(p_sbr)) && wp->w_wcol == (int)vim_strsize(p_sbr))
curwin->w_wcol = 0; 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. * 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 else if (may_scroll
&& !curwin->w_cline_folded && !wp->w_cline_folded
) { ) {
/* /*
* If Cursor is left of the screen, scroll rightwards. * If Cursor is left of the screen, scroll rightwards.
@@ -803,9 +807,9 @@ void curs_columns(
* extra * extra
*/ */
assert(siso <= INT_MAX); 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 = 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) { 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;
@@ -813,52 +817,52 @@ void curs_columns(
* middle of window. */ * middle of window. */
int new_leftcol; int new_leftcol;
if (p_ss == 0 || diff >= textwidth / 2 || off_right >= off_left) 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 { else {
if (diff < p_ss) { if (diff < p_ss) {
assert(p_ss <= INT_MAX); assert(p_ss <= INT_MAX);
diff = (int)p_ss; diff = (int)p_ss;
} }
if (off_left < 0) if (off_left < 0)
new_leftcol = curwin->w_leftcol - diff; new_leftcol = wp->w_leftcol - diff;
else else
new_leftcol = curwin->w_leftcol + diff; new_leftcol = wp->w_leftcol + diff;
} }
if (new_leftcol < 0) if (new_leftcol < 0)
new_leftcol = 0; new_leftcol = 0;
if (new_leftcol != (int)curwin->w_leftcol) { if (new_leftcol != (int)wp->w_leftcol) {
curwin->w_leftcol = new_leftcol; wp->w_leftcol = new_leftcol;
win_check_anchored_floats(curwin); win_check_anchored_floats(wp);
// screen has to be redrawn with new curwin->w_leftcol // screen has to be redrawn with new wp->w_leftcol
redraw_later(curwin, NOT_VALID); redraw_later(wp, NOT_VALID);
} }
} }
curwin->w_wcol -= curwin->w_leftcol; wp->w_wcol -= wp->w_leftcol;
} else if (curwin->w_wcol > (int)curwin->w_leftcol) } else if (wp->w_wcol > (int)wp->w_leftcol)
curwin->w_wcol -= curwin->w_leftcol; wp->w_wcol -= wp->w_leftcol;
else else
curwin->w_wcol = 0; wp->w_wcol = 0;
/* Skip over filler lines. At the top use w_topfill, there /* Skip over filler lines. At the top use w_topfill, there
* may be some filler lines above the window. */ * may be some filler lines above the window. */
if (curwin->w_cursor.lnum == curwin->w_topline) if (wp->w_cursor.lnum == wp->w_topline)
curwin->w_wrow += curwin->w_topfill; wp->w_wrow += wp->w_topfill;
else 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; int plines = 0;
if ((curwin->w_wrow >= curwin->w_height_inner if ((wp->w_wrow >= wp->w_height_inner
|| ((prev_skipcol > 0 || ((prev_skipcol > 0
|| curwin->w_wrow + so >= curwin->w_height_inner) || wp->w_wrow + so >= wp->w_height_inner)
&& (plines = && (plines =
plines_win_nofill(curwin, curwin->w_cursor.lnum, false)) - 1 plines_win_nofill(wp, wp->w_cursor.lnum, false)) - 1
>= curwin->w_height_inner)) >= wp->w_height_inner))
&& curwin->w_height_inner != 0 && wp->w_height_inner != 0
&& curwin->w_cursor.lnum == curwin->w_topline && wp->w_cursor.lnum == wp->w_topline
&& width > 0 && width > 0
&& curwin->w_width_inner != 0 && wp->w_width_inner != 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
@@ -867,87 +871,87 @@ void curs_columns(
* 2: Less than "p_so" lines below * 2: Less than "p_so" lines below
* 3: both of them */ * 3: both of them */
extra = 0; extra = 0;
if (curwin->w_skipcol + so * width > curwin->w_virtcol) { if (wp->w_skipcol + so * width > wp->w_virtcol) {
extra = 1; extra = 1;
} }
// Compute last display line of the buffer line that we want at the // Compute last display line of the buffer line that we want at the
// bottom of the window. // bottom of the window.
if (plines == 0) { if (plines == 0) {
plines = plines_win(curwin, curwin->w_cursor.lnum, false); plines = plines_win(wp, wp->w_cursor.lnum, false);
} }
plines--; plines--;
if (plines > curwin->w_wrow + so) { if (plines > wp->w_wrow + so) {
assert(so <= INT_MAX); assert(so <= INT_MAX);
n = curwin->w_wrow + (int)so; n = wp->w_wrow + (int)so;
} else { } else {
n = plines; 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; extra += 2;
} }
if (extra == 3 || plines < so * 2) { if (extra == 3 || plines < so * 2) {
// not enough room for 'scrolloff', put cursor in the middle // not enough room for 'scrolloff', put cursor in the middle
n = curwin->w_virtcol / width; n = wp->w_virtcol / width;
if (n > curwin->w_height_inner / 2) { if (n > wp->w_height_inner / 2) {
n -= curwin->w_height_inner / 2; n -= wp->w_height_inner / 2;
} else { } else {
n = 0; n = 0;
} }
// don't skip more than necessary // don't skip more than necessary
if (n > plines - curwin->w_height_inner + 1) { if (n > plines - wp->w_height_inner + 1) {
n = plines - curwin->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) { } else if (extra == 1) {
// less then 'scrolloff' lines above, decrease skipcol // less then 'scrolloff' lines above, decrease skipcol
assert(so <= INT_MAX); 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; + width - 1) / width;
if (extra > 0) { if (extra > 0) {
if ((colnr_T)(extra * width) > curwin->w_skipcol) if ((colnr_T)(extra * width) > wp->w_skipcol)
extra = curwin->w_skipcol / width; extra = wp->w_skipcol / width;
curwin->w_skipcol -= extra * width; wp->w_skipcol -= extra * width;
} }
} else if (extra == 2) { } else if (extra == 2) {
// less then 'scrolloff' lines below, increase skipcol // less then 'scrolloff' lines below, increase skipcol
endcol = (n - curwin->w_height_inner + 1) * width; endcol = (n - wp->w_height_inner + 1) * width;
while (endcol > curwin->w_virtcol) { while (endcol > wp->w_virtcol) {
endcol -= width; endcol -= width;
} }
if (endcol > curwin->w_skipcol) { if (endcol > wp->w_skipcol) {
curwin->w_skipcol = endcol; wp->w_skipcol = endcol;
} }
} }
curwin->w_wrow -= curwin->w_skipcol / width; wp->w_wrow -= wp->w_skipcol / width;
if (curwin->w_wrow >= curwin->w_height_inner) { if (wp->w_wrow >= wp->w_height_inner) {
// small window, make sure cursor is in it // small window, make sure cursor is in it
extra = curwin->w_wrow - curwin->w_height_inner + 1; extra = wp->w_wrow - wp->w_height_inner + 1;
curwin->w_skipcol += extra * width; wp->w_skipcol += extra * width;
curwin->w_wrow -= extra; wp->w_wrow -= extra;
} }
// extra could be either positive or negative // extra could be either positive or negative
extra = ((int)prev_skipcol - (int)curwin->w_skipcol) / width; extra = ((int)prev_skipcol - (int)wp->w_skipcol) / width;
win_scroll_lines(curwin, 0, extra); win_scroll_lines(wp, 0, extra);
} else { } else {
curwin->w_skipcol = 0; wp->w_skipcol = 0;
} }
if (prev_skipcol != curwin->w_skipcol) { if (prev_skipcol != wp->w_skipcol) {
redraw_later(curwin, NOT_VALID); redraw_later(wp, NOT_VALID);
} }
/* Redraw when w_virtcol changes and 'cursorcolumn' is set */ /* 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()) { && !pum_visible()) {
redraw_later(curwin, SOME_VALID); redraw_later(wp, SOME_VALID);
} }
// now w_leftcol is valid, avoid check_cursor_moved() thinking otherwise // 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" /// 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". * Returns the height of the added line in "lp->height".
* Lines below the last one are incredibly high. * 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. */ /* Add a filler line. */
++lp->fill; ++lp->fill;
lp->height = 1; lp->height = 1;
} else { } else {
++lp->lnum; ++lp->lnum;
lp->fill = 0; 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; 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 // Add a closed fold
lp->height = 1; lp->height = 1;
} else { } 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_topfill != old_topfill
) )
curwin->w_valid &= ~(VALID_WROW|VALID_CROW); curwin->w_valid &= ~(VALID_WROW|VALID_CROW);
} else } else {
validate_botline(); validate_botline(curwin);
}
/* The lines of the cursor line itself are always used. */ /* The lines of the cursor line itself are always used. */
used = plines_nofill(cln); 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) { if (boff.lnum < curbuf->b_ml.ml_line_count) {
/* Add one line below */ /* Add one line below */
botline_forw(&boff); botline_forw(curwin, &boff);
used += boff.height; used += boff.height;
if (used > curwin->w_height_inner) { if (used > curwin->w_height_inner) {
break; break;
@@ -1647,7 +1653,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
boff.lnum = curwin->w_topline - 1; boff.lnum = curwin->w_topline - 1;
int i; int i;
for (i = 0; i < scrolled && boff.lnum < curwin->w_botline; ) { for (i = 0; i < scrolled && boff.lnum < curwin->w_botline; ) {
botline_forw(&boff); botline_forw(curwin, &boff);
i += boff.height; i += boff.height;
++line_count; ++line_count;
} }
@@ -1701,7 +1707,7 @@ void scroll_cursor_halfway(int atend)
while (topline > 1) { while (topline > 1) {
if (below <= above) { /* add a line below the cursor first */ if (below <= above) { /* add a line below the cursor first */
if (boff.lnum < curbuf->b_ml.ml_line_count) { if (boff.lnum < curbuf->b_ml.ml_line_count) {
botline_forw(&boff); botline_forw(curwin, &boff);
used += boff.height; used += boff.height;
if (used > curwin->w_height_inner) { if (used > curwin->w_height_inner) {
break; break;
@@ -1764,7 +1770,7 @@ void cursor_correct(void)
below_wanted = max_off; below_wanted = max_off;
} }
} }
validate_botline(); validate_botline(curwin);
if (curwin->w_botline == curbuf->b_ml.ml_line_count + 1 if (curwin->w_botline == curbuf->b_ml.ml_line_count + 1
&& mouse_dragging == 0) { && mouse_dragging == 0) {
below_wanted = 0; below_wanted = 0;
@@ -1856,7 +1862,7 @@ int onepage(Direction dir, long count)
} }
for (; count > 0; --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 * 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 * 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 { } else {
/* Go two lines forward again. */ /* Go two lines forward again. */
topline_botline(&loff); topline_botline(&loff);
botline_forw(&loff); botline_forw(curwin, &loff);
botline_forw(&loff); botline_forw(curwin, &loff);
botline_topline(&loff); botline_topline(&loff);
/* We're at the wrong end of a fold now. */ /* 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 /* Always scroll at least one line. Avoid getting stuck on
* very long lines. */ * very long lines. */
@@ -2047,7 +2053,7 @@ static void get_scroll_overlap(lineoff_T *lp, int dir)
lineoff_T loff0 = *lp; lineoff_T loff0 = *lp;
if (dir > 0) if (dir > 0)
botline_forw(lp); botline_forw(curwin, lp);
else else
topline_back(lp); topline_back(lp);
int h2 = lp->height; int h2 = lp->height;
@@ -2058,7 +2064,7 @@ static void get_scroll_overlap(lineoff_T *lp, int dir)
lineoff_T loff1 = *lp; lineoff_T loff1 = *lp;
if (dir > 0) if (dir > 0)
botline_forw(lp); botline_forw(curwin, lp);
else else
topline_back(lp); topline_back(lp);
int h3 = lp->height; int h3 = lp->height;
@@ -2069,7 +2075,7 @@ static void get_scroll_overlap(lineoff_T *lp, int dir)
lineoff_T loff2 = *lp; lineoff_T loff2 = *lp;
if (dir > 0) if (dir > 0)
botline_forw(lp); botline_forw(curwin, lp);
else else
topline_back(lp); topline_back(lp);
int h4 = lp->height; 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 int n = curwin->w_p_scr <= curwin->w_height_inner ? (int)curwin->w_p_scr
: curwin->w_height_inner; : curwin->w_height_inner;
update_topline(); update_topline(curwin);
validate_botline(); validate_botline(curwin);
int room = curwin->w_empty_rows + curwin->w_filler_rows; int room = curwin->w_empty_rows + curwin->w_filler_rows;
if (flag) { if (flag) {
/* /*
@@ -2255,7 +2261,7 @@ void do_check_cursorbind(void)
// Only scroll when 'scrollbind' hasn't done this. // Only scroll when 'scrollbind' hasn't done this.
if (!curwin->w_p_scb) { if (!curwin->w_p_scb) {
update_topline(); update_topline(curwin);
} }
curwin->w_redr_status = true; 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 // Before redrawing, make sure w_topline is correct, and w_leftcol
// if lines don't wrap, and w_skipcol if lines wrap. // if lines don't wrap, and w_skipcol if lines wrap.
update_topline(); update_topline(curwin);
validate_cursor(); validate_cursor();
// If the cursor moves horizontally when 'concealcursor' is active, then the // 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()) { } else if (do_redraw || stuff_empty()) {
// Need to make sure w_topline and w_leftcol are correct before // Need to make sure w_topline and w_leftcol are correct before
// normal_check_window_scrolled() is called. // normal_check_window_scrolled() is called.
update_topline(); update_topline(curwin);
normal_check_cursor_moved(s); normal_check_cursor_moved(s);
normal_check_text_changed(s); normal_check_text_changed(s);
@@ -4254,7 +4254,7 @@ dozet:
case '+': case '+':
if (cap->count0 == 0) { if (cap->count0 == 0) {
/* No count given: put cursor at the line below screen */ /* 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) if (curwin->w_botline > curbuf->b_ml.ml_line_count)
curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count; curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
else else
@@ -5053,7 +5053,7 @@ static void nv_scroll(cmdarg_T *cap)
setpcmark(); setpcmark();
if (cap->cmdchar == 'L') { 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; curwin->w_cursor.lnum = curwin->w_botline - 1;
if (cap->count1 - 1 >= curwin->w_cursor.lnum) if (cap->count1 - 1 >= curwin->w_cursor.lnum)
curwin->w_cursor.lnum = 1; curwin->w_cursor.lnum = 1;
@@ -5074,7 +5074,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 -= diff_check_fill(curwin, curwin->w_topline) used -= diff_check_fill(curwin, curwin->w_topline)
- curwin->w_topfill; - curwin->w_topfill;
validate_botline(); // make sure w_empty_rows is valid validate_botline(curwin); // make sure w_empty_rows is valid
half = (curwin->w_height_inner - curwin->w_empty_rows + 1) / 2; half = (curwin->w_height_inner - curwin->w_empty_rows + 1) / 2;
for (n = 0; curwin->w_topline + n < curbuf->b_ml.ml_line_count; n++) { for (n = 0; curwin->w_topline + n < curbuf->b_ml.ml_line_count; n++) {
// Count half he number of filler lines to be "below this // Count half he number of filler lines to be "below this
@@ -6653,7 +6653,7 @@ static void nv_g_cmd(cmdarg_T *cap)
VIsual = curwin->w_cursor; VIsual = curwin->w_cursor;
curwin->w_cursor = tpos; curwin->w_cursor = tpos;
check_cursor(); check_cursor();
update_topline(); update_topline(curwin);
/* /*
* When called from normal "g" command: start Select mode when * When called from normal "g" command: start Select mode when
* 'selectmode' contains "cmd". When called for K_SELECT, always * '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++; no_u_sync++;
win_enter(curwin_save, true); win_enter(curwin_save, true);
no_u_sync--; no_u_sync--;
update_topline(); update_topline(curwin);
} }
// Update the screen before drawing the popup menu. // 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.lnum = lnum;
curwin->w_cursor.col = 0; curwin->w_cursor.col = 0;
check_cursor(); 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". // 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.col = 0;
curwin->w_cursor.coladd = 0; curwin->w_cursor.coladd = 0;
curwin->w_curswant = 0; curwin->w_curswant = 0;
update_topline(); // scroll to show the line update_topline(curwin); // scroll to show the line
redraw_later(curwin, VALID); redraw_later(curwin, VALID);
curwin->w_redr_status = true; // update ruler curwin->w_redr_status = true; // update ruler
curwin = old_curwin; 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); redrawWinline(curwin, curwin->w_cursor.lnum);
// Need to recompute cursor column, e.g., when starting Visual mode // Need to recompute cursor column, e.g., when starting Visual mode
// without concealing. */ // 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; const int new_wcol = wp->w_wcol;
recursive = true; recursive = true;
curwin->w_valid &= ~VALID_TOPLINE; 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 if (old_wcol != new_wcol
&& (wp->w_valid & (VALID_WCOL|VALID_WROW)) && (wp->w_valid & (VALID_WCOL|VALID_WROW))
@@ -7382,7 +7382,7 @@ void screen_resize(int width, int height)
cmdline_pum_display(false); cmdline_pum_display(false);
} }
} else { } else {
update_topline(); update_topline(curwin);
if (pum_drawn()) { if (pum_drawn()) {
// TODO(bfredl): ins_compl_show_pum wants to redraw the screen first. // 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 // 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 // Might need to scroll the old window before switching, e.g., when the
// cursor was moved. // cursor was moved.
update_topline(); update_topline(curwin);
// may have to copy the buffer options when 'cpo' contains 'S' // may have to copy the buffer options when 'cpo' contains 'S'
if (wp->w_buffer != curbuf) { if (wp->w_buffer != curbuf) {
@@ -5860,9 +5860,9 @@ void scroll_to_fraction(win_T *wp, int prev_height)
if (wp == curwin) { if (wp == curwin) {
if (get_scrolloff_value(wp)) { 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) { if (prev_height > 0) {
wp->w_prev_fraction_row = wp->w_wrow; 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); changed_line_abv_curs_win(wp);
invalidate_botline_win(wp); invalidate_botline_win(wp);
if (wp == curwin) { if (wp == curwin) {
update_topline(); update_topline(wp);
curs_columns(true); // validate w_wrow curs_columns(wp, true); // validate w_wrow
} }
redraw_later(wp, NOT_VALID); redraw_later(wp, NOT_VALID);
} }