aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/nvim/edit.c21
-rw-r--r--src/nvim/eval.c6
-rw-r--r--src/nvim/ex_cmds.c6
-rw-r--r--src/nvim/ex_docmd.c11
-rw-r--r--src/nvim/ex_getln.c6
-rw-r--r--src/nvim/fileio.c4
-rw-r--r--src/nvim/main.c2
-rw-r--r--src/nvim/move.c552
-rw-r--r--src/nvim/normal.c38
-rw-r--r--src/nvim/option.c8
-rw-r--r--src/nvim/popupmnu.c2
-rw-r--r--src/nvim/quickfix.c4
-rw-r--r--src/nvim/screen.c6
-rw-r--r--src/nvim/window.c12
14 files changed, 346 insertions, 332 deletions
diff --git a/src/nvim/edit.c b/src/nvim/edit.c
index 45bd84261d..ec424c12da 100644
--- a/src/nvim/edit.c
+++ b/src/nvim/edit.c
@@ -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
@@ -594,7 +594,7 @@ static int insert_check(VimState *state)
if (curwin->w_wcol < s->mincol - curbuf->b_p_ts
&& curwin->w_wrow == curwin->w_winrow
- + curwin->w_height_inner - 1 - get_scrolloff_value()
+ + curwin->w_height_inner - 1 - get_scrolloff_value(curwin)
&& (curwin->w_cursor.lnum != curwin->w_topline
|| curwin->w_topfill > 0)) {
if (curwin->w_topfill > 0) {
@@ -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;
@@ -5327,8 +5327,9 @@ static int ins_complete(int c, bool enable_pum)
compl_curr_match->cp_number);
edit_submode_extra = match_ref;
edit_submode_highl = HLF_R;
- if (dollar_vcol >= 0)
- curs_columns(FALSE);
+ if (dollar_vcol >= 0) {
+ curs_columns(curwin, false);
+ }
}
}
}
@@ -6158,7 +6159,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 +6808,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 +6859,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;
diff --git a/src/nvim/eval.c b/src/nvim/eval.c
index a7a860ba72..cc707c0c84 100644
--- a/src/nvim/eval.c
+++ b/src/nvim/eval.c
@@ -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;
diff --git a/src/nvim/ex_cmds.c b/src/nvim/ex_cmds.c
index b23209e1b6..2a96db6a8c 100644
--- a/src/nvim/ex_cmds.c
+++ b/src/nvim/ex_cmds.c
@@ -2706,7 +2706,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
@@ -3705,7 +3705,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;
@@ -5740,7 +5740,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;
diff --git a/src/nvim/ex_docmd.c b/src/nvim/ex_docmd.c
index a5eccc12b9..63e5c1c9ed 100644
--- a/src/nvim/ex_docmd.c
+++ b/src/nvim/ex_docmd.c
@@ -7362,7 +7362,7 @@ static void ex_syncbind(exarg_T *eap)
topline = curwin->w_topline;
FOR_ALL_WINDOWS_IN_TAB(wp, curtab) {
if (wp->w_p_scb && wp->w_buffer) {
- y = wp->w_buffer->b_ml.ml_line_count - get_scrolloff_value();
+ y = wp->w_buffer->b_ml.ml_line_count - get_scrolloff_value(curwin);
if (topline > y) {
topline = y;
}
@@ -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);
}
@@ -8199,10 +8199,11 @@ static void ex_mark(exarg_T *eap)
*/
void update_topline_cursor(void)
{
- check_cursor(); /* put cursor on valid line */
- update_topline();
- if (!curwin->w_p_wrap)
+ check_cursor(); // put cursor on valid line
+ update_topline(curwin);
+ if (!curwin->w_p_wrap) {
validate_cursor();
+ }
update_curswant();
}
diff --git a/src/nvim/ex_getln.c b/src/nvim/ex_getln.c
index 129cb323ea..24fc60e60a 100644
--- a/src/nvim/ex_getln.c
+++ b/src/nvim/ex_getln.c
@@ -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();
diff --git a/src/nvim/fileio.c b/src/nvim/fileio.c
index 3a84b5d41c..936a9d1397 100644
--- a/src/nvim/fileio.c
+++ b/src/nvim/fileio.c
@@ -5105,8 +5105,8 @@ void buf_reload(buf_T *buf, int orig_mode)
curwin->w_topline = old_topline;
curwin->w_cursor = old_cursor;
check_cursor();
- update_topline();
- keep_filetype = FALSE;
+ update_topline(curwin);
+ keep_filetype = false;
/* Update folds unless they are defined manually. */
FOR_ALL_TAB_WINDOWS(tp, wp) {
diff --git a/src/nvim/main.c b/src/nvim/main.c
index 41ae78e996..8bf745966e 100644
--- a/src/nvim/main.c
+++ b/src/nvim/main.c
@@ -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");
}
diff --git a/src/nvim/move.c b/src/nvim/move.c
index fdcf6bb189..a6afdc27d9 100644
--- a/src/nvim/move.c
+++ b/src/nvim/move.c
@@ -129,98 +129,99 @@ void redraw_for_cursorline(win_T *wp)
*/
void update_topline_redraw(void)
{
- update_topline();
- if (must_redraw)
+ update_topline(curwin);
+ if (must_redraw) {
update_screen(0);
+ }
}
/*
* 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
if (mouse_dragging > 0) {
*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;
- }
- /*
- * 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 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)
+ 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;
+ } else {
+ // 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.
+ 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 (wp->w_cursor.lnum < wp->w_topline) {
check_topline = true;
- else if (check_top_offset())
+ } 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))
+ // Check if there are more filler lines than allowed.
+ 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)) {
- /* Count the number of logical lines between the cursor and
- * topline + p_so (approximation of how much will be
- * scrolled). */
+ 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) {
+ assert(wp->w_buffer != 0);
+ if (lnum >= wp->w_buffer->b_ml.ml_line_count || n >= halfheight) {
break;
}
- (void)hasFolding(lnum, NULL, &lnum);
+ (void)hasFoldingWin(wp, lnum, NULL, &lnum, true, NULL);
}
} 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
@@ -233,8 +234,8 @@ void update_topline(void)
check_botline = true;
}
} else {
- /* Make sure topline is the first line of a fold. */
- (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
+ // Make sure topline is the first line of a fold.
+ (void)hasFoldingWin(wp, wp->w_topline, &wp->w_topline, NULL, true, NULL);
check_botline = true;
}
}
@@ -248,35 +249,36 @@ void update_topline(void)
* for every small change.
*/
if (check_botline) {
- if (!(curwin->w_valid & VALID_BOTLINE_AP))
- validate_botline();
-
- 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)
- )) {
+ if (!(wp->w_valid & VALID_BOTLINE_AP)) {
+ validate_botline(wp);
+ }
+
+ 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;
- /* In a fold go to its last line. */
- (void)hasFolding(loff.lnum, NULL, &loff.lnum);
+ int n = wp->w_empty_rows;
+ loff.lnum = wp->w_cursor.lnum;
+ // In a fold go to its last line.
+ (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)) {
- /* 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--) {
+ 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 = 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
- + 1 + *so_ptr;
- if (line_count <= curwin->w_height_inner + 1) {
+ } else {
+ line_count = wp->w_cursor.lnum - wp->w_botline + 1 + *so_ptr;
+ }
+ 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);
}
@@ -368,7 +370,7 @@ static int scrolljump_value(void)
*/
static bool check_top_offset(void)
{
- long so = get_scrolloff_value();
+ long so = get_scrolloff_value(curwin);
if (curwin->w_cursor.lnum < curwin->w_topline + so
|| hasAnyFolding(curwin)
) {
@@ -378,7 +380,7 @@ static bool check_top_offset(void)
int n = curwin->w_topfill; // always have this context
// Count the visible screen lines above the cursor line.
while (n < so) {
- topline_back(&loff);
+ topline_back(curwin, &loff);
// Stop when included a line above the window.
if (loff.lnum < curwin->w_topline
|| (loff.lnum == curwin->w_topline && loff.fill > 0)
@@ -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);
+ }
}
/*
@@ -539,8 +542,9 @@ int cursor_valid(void)
void validate_cursor(void)
{
check_cursor_moved(curwin);
- if ((curwin->w_valid & (VALID_WCOL|VALID_WROW)) != (VALID_WCOL|VALID_WROW))
- curs_columns(true);
+ if ((curwin->w_valid & (VALID_WCOL|VALID_WROW)) != (VALID_WCOL|VALID_WROW)) {
+ curs_columns(curwin, true);
+ }
}
/*
@@ -720,8 +724,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,136 +735,136 @@ void curs_columns(
colnr_T startcol;
colnr_T endcol;
colnr_T prev_skipcol;
- long so = get_scrolloff_value();
- long siso = get_sidescrolloff_value();
+ 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)
- /* 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);
+ if (wp->w_cline_folded) {
+ // In a folded line the cursor is always in the first column
+ 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
- * is not folded.
- * If scrolling is off, curwin->w_leftcol is assumed to be 0 */
- else if (may_scroll
- && !curwin->w_cline_folded
- ) {
- /*
- * If Cursor is left of the screen, scroll rightwards.
- * If Cursor is right of the screen, scroll leftwards
- * If we get closer to the edge than 'sidescrolloff', scroll a little
- * extra
- */
+ } else if (may_scroll
+ && !wp->w_cline_folded
+ ) {
+ // No line wrapping: compute wp->w_leftcol if scrolling is on and line
+ // is not folded.
+ // If scrolling is off, wp->w_leftcol is assumed to be 0
+
+ // If Cursor is left of the screen, scroll rightwards.
+ // If Cursor is right of the screen, scroll leftwards
+ // If we get closer to the edge than 'sidescrolloff', scroll a little
+ // 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;
/* When far off or not enough room on either side, put cursor in
* 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;
- else {
+ if (p_ss == 0 || diff >= textwidth / 2 || off_right >= off_left) {
+ 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;
- else
- new_leftcol = curwin->w_leftcol + diff;
+ if (off_left < 0) {
+ new_leftcol = wp->w_leftcol - diff;
+ } else {
+ 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;
- else
- curwin->w_wcol = 0;
+ wp->w_wcol -= wp->w_leftcol;
+ } else if (wp->w_wcol > (int)wp->w_leftcol) {
+ wp->w_wcol -= wp->w_leftcol;
+ } else {
+ 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;
- else
- curwin->w_wrow += diff_check_fill(curwin, curwin->w_cursor.lnum);
+ if (wp->w_cursor.lnum == wp->w_topline) {
+ wp->w_wrow += wp->w_topfill;
+ } else {
+ 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 +873,88 @@ 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
+ // Redraw when w_virtcol changes and 'cursorcolumn' is set
+ 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"
@@ -1231,7 +1238,7 @@ void scrolldown_clamp(void)
end_row += curwin->w_cline_height - 1 -
curwin->w_virtcol / curwin->w_width_inner;
}
- if (end_row < curwin->w_height_inner - get_scrolloff_value()) {
+ if (end_row < curwin->w_height_inner - get_scrolloff_value(curwin)) {
if (can_fill) {
++curwin->w_topfill;
check_topfill(curwin, true);
@@ -1271,7 +1278,7 @@ void scrollup_clamp(void)
validate_virtcol();
start_row -= curwin->w_virtcol / curwin->w_width_inner;
}
- if (start_row >= get_scrolloff_value()) {
+ if (start_row >= get_scrolloff_value(curwin)) {
if (curwin->w_topfill > 0) {
curwin->w_topfill--;
} else {
@@ -1289,22 +1296,22 @@ void scrollup_clamp(void)
* Returns the height of the added line in "lp->height".
* Lines above the first one are incredibly high: MAXCOL.
*/
-static void topline_back(lineoff_T *lp)
+static void topline_back(win_T *wp, lineoff_T *lp)
{
- if (lp->fill < diff_check_fill(curwin, lp->lnum)) {
- /* Add a filler line. */
- ++lp->fill;
+ if (lp->fill < diff_check_fill(wp, lp->lnum)) {
+ // Add a filler line
+ lp->fill++;
lp->height = 1;
} else {
--lp->lnum;
lp->fill = 0;
- if (lp->lnum < 1)
+ if (lp->lnum < 1) {
lp->height = MAXCOL;
- else if (hasFolding(lp->lnum, &lp->lnum, NULL))
- /* Add a closed fold */
+ } else if (hasFolding(lp->lnum, &lp->lnum, NULL)) {
+ // Add a closed fold
lp->height = 1;
- else {
- lp->height = plines_nofill(lp->lnum);
+ } else {
+ lp->height = plines_win_nofill(wp, lp->lnum, true);
}
}
}
@@ -1315,22 +1322,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)) {
- /* Add a filler line. */
- ++lp->fill;
+ 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);
}
}
}
@@ -1374,7 +1382,7 @@ void scroll_cursor_top(int min_scroll, int always)
linenr_T old_topline = curwin->w_topline;
linenr_T old_topfill = curwin->w_topfill;
linenr_T new_topline;
- int off = (int)get_scrolloff_value();
+ int off = (int)get_scrolloff_value(curwin);
if (mouse_dragging > 0)
off = mouse_dragging - 1;
@@ -1518,7 +1526,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
int old_valid = curwin->w_valid;
int old_empty_rows = curwin->w_empty_rows;
linenr_T cln = curwin->w_cursor.lnum; // Cursor Line Number
- long so = get_scrolloff_value();
+ long so = get_scrolloff_value(curwin);
if (set_topbot) {
used = 0;
@@ -1528,7 +1536,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
curwin->w_topline > 1;
curwin->w_topline = loff.lnum) {
loff.lnum = curwin->w_topline;
- topline_back(&loff);
+ topline_back(curwin, &loff);
if (loff.height == MAXCOL
|| used + loff.height > curwin->w_height_inner) {
break;
@@ -1542,8 +1550,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);
@@ -1586,8 +1595,8 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
break;
}
- /* Add one line above */
- topline_back(&loff);
+ // Add one line above
+ topline_back(curwin, &loff);
if (loff.height == MAXCOL) {
used = MAXCOL;
} else {
@@ -1609,8 +1618,8 @@ 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);
+ // Add one line below
+ botline_forw(curwin, &boff);
used += boff.height;
if (used > curwin->w_height_inner) {
break;
@@ -1647,7 +1656,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 +1710,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;
@@ -1714,12 +1723,13 @@ void scroll_cursor_halfway(int atend)
}
}
- if (below > above) { /* add a line above the cursor */
- topline_back(&loff);
- if (loff.height == MAXCOL)
+ if (below > above) { // add a line above the cursor
+ topline_back(curwin, &loff);
+ if (loff.height == MAXCOL) {
used = MAXCOL;
- else
+ } else {
used += loff.height;
+ }
if (used > curwin->w_height_inner) {
break;
}
@@ -1751,8 +1761,8 @@ void cursor_correct(void)
* How many lines we would like to have above/below the cursor depends on
* whether the first/last line of the file is on screen.
*/
- int above_wanted = (int)get_scrolloff_value();
- int below_wanted = (int)get_scrolloff_value();
+ int above_wanted = (int)get_scrolloff_value(curwin);
+ int below_wanted = (int)get_scrolloff_value(curwin);
if (mouse_dragging > 0) {
above_wanted = mouse_dragging - 1;
below_wanted = mouse_dragging - 1;
@@ -1764,7 +1774,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;
@@ -1848,21 +1858,19 @@ int onepage(Direction dir, long count)
int retval = OK;
lineoff_T loff;
linenr_T old_topline = curwin->w_topline;
- long so = get_scrolloff_value();
+ long so = get_scrolloff_value(curwin);
if (curbuf->b_ml.ml_line_count == 1) { /* nothing to do */
beep_flush();
return FAIL;
}
- for (; count > 0; --count) {
- validate_botline();
- /*
- * 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
- * is on the screen and the topline is 'scrolloff' lines from the
- * last line.
- */
+ for (; count > 0; count--) {
+ 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
+ // is on the screen and the topline is 'scrolloff' lines from the
+ // last line.
if (dir == FORWARD
? ((curwin->w_topline >= curbuf->b_ml.ml_line_count - so)
&& curwin->w_botline > curbuf->b_ml.ml_line_count)
@@ -1945,11 +1953,12 @@ int onepage(Direction dir, long count)
* at the bottom of the window. */
n = 0;
while (n <= curwin->w_height_inner && loff.lnum >= 1) {
- topline_back(&loff);
- if (loff.height == MAXCOL)
+ topline_back(curwin, &loff);
+ if (loff.height == MAXCOL) {
n = MAXCOL;
- else
+ } else {
n += loff.height;
+ }
}
if (loff.lnum < 1) { /* at begin of file */
curwin->w_topline = 1;
@@ -1958,11 +1967,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);
+ // We're at the wrong end of a fold now.
+ (void)hasFoldingWin(curwin, loff.lnum, &loff.lnum, NULL, true, NULL);
/* Always scroll at least one line. Avoid getting stuck on
* very long lines. */
@@ -2046,10 +2055,11 @@ static void get_scroll_overlap(lineoff_T *lp, int dir)
return; /* no overlap */
lineoff_T loff0 = *lp;
- if (dir > 0)
- botline_forw(lp);
- else
- topline_back(lp);
+ if (dir > 0) {
+ botline_forw(curwin, lp);
+ } else {
+ topline_back(curwin, lp);
+ }
int h2 = lp->height;
if (h2 == MAXCOL || h2 + h1 > min_height) {
*lp = loff0; /* no overlap */
@@ -2057,10 +2067,11 @@ static void get_scroll_overlap(lineoff_T *lp, int dir)
}
lineoff_T loff1 = *lp;
- if (dir > 0)
- botline_forw(lp);
- else
- topline_back(lp);
+ if (dir > 0) {
+ botline_forw(curwin, lp);
+ } else {
+ topline_back(curwin, lp);
+ }
int h3 = lp->height;
if (h3 == MAXCOL || h3 + h2 > min_height) {
*lp = loff0; /* no overlap */
@@ -2068,10 +2079,11 @@ static void get_scroll_overlap(lineoff_T *lp, int dir)
}
lineoff_T loff2 = *lp;
- if (dir > 0)
- botline_forw(lp);
- else
- topline_back(lp);
+ if (dir > 0) {
+ botline_forw(curwin, lp);
+ } else {
+ topline_back(curwin, lp);
+ }
int h4 = lp->height;
if (h4 == MAXCOL || h4 + h3 + h2 > min_height || h3 + h2 + h1 > min_height)
*lp = loff1; /* 1 line overlap */
@@ -2094,8 +2106,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 +2267,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;
}
diff --git a/src/nvim/normal.c b/src/nvim/normal.c
index 4b81a22f55..a2060b91f7 100644
--- a/src/nvim/normal.c
+++ b/src/nvim/normal.c
@@ -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);
@@ -2629,7 +2629,7 @@ do_mouse (
/* Set global flag that we are extending the Visual area with mouse
* dragging; temporarily minimize 'scrolloff'. */
- if (VIsual_active && is_drag && get_scrolloff_value()) {
+ if (VIsual_active && is_drag && get_scrolloff_value(curwin)) {
// In the very first line, allow scrolling one line
if (mouse_row == 0) {
mouse_dragging = 2;
@@ -4136,7 +4136,7 @@ void scroll_redraw(int up, long count)
scrollup(count, true) :
scrolldown(count, true);
- if (get_scrolloff_value()) {
+ if (get_scrolloff_value(curwin)) {
// Adjust the cursor position for 'scrolloff'. Mark w_topline as
// valid, otherwise the screen jumps back at the end of the file.
cursor_correct();
@@ -4186,7 +4186,7 @@ static void nv_zet(cmdarg_T *cap)
int old_fen = curwin->w_p_fen;
bool undo = false;
- int l_p_siso = (int)get_sidescrolloff_value();
+ int l_p_siso = (int)get_sidescrolloff_value(curwin);
assert(l_p_siso <= INT_MAX);
if (ascii_isdigit(nchar)) {
@@ -4254,12 +4254,13 @@ dozet:
/* "z+", "z<CR>" and "zt": put cursor at top of screen */
case '+':
if (cap->count0 == 0) {
- /* No count given: put cursor at the line below screen */
- validate_botline(); /* make sure w_botline is valid */
- if (curwin->w_botline > curbuf->b_ml.ml_line_count)
+ // No count given: put cursor at the line below screen
+ 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
+ } else {
curwin->w_cursor.lnum = curwin->w_botline;
+ }
}
FALLTHROUGH;
case NL:
@@ -5054,7 +5055,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;
@@ -5075,7 +5076,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
@@ -6654,16 +6655,15 @@ static void nv_g_cmd(cmdarg_T *cap)
VIsual = curwin->w_cursor;
curwin->w_cursor = tpos;
check_cursor();
- update_topline();
- /*
- * When called from normal "g" command: start Select mode when
- * 'selectmode' contains "cmd". When called for K_SELECT, always
- * start Select mode.
- */
- if (cap->arg)
+ update_topline(curwin);
+ // When called from normal "g" command: start Select mode when
+ // 'selectmode' contains "cmd". When called for K_SELECT, always
+ // start Select mode.
+ if (cap->arg) {
VIsual_select = true;
- else
+ } else {
may_start_select('c');
+ }
setmouse();
redraw_curbuf_later(INVERTED);
showmode();
diff --git a/src/nvim/option.c b/src/nvim/option.c
index bac289a959..f41c0761cc 100644
--- a/src/nvim/option.c
+++ b/src/nvim/option.c
@@ -7159,20 +7159,20 @@ dict_T *get_winbuf_options(const int bufopt)
/// Return the effective 'scrolloff' value for the current window, using the
/// global value when appropriate.
-long get_scrolloff_value(void)
+long get_scrolloff_value(win_T *wp)
{
// Disallow scrolloff in terminal-mode. #11915
if (State & TERM_FOCUS) {
return 0;
}
- return curwin->w_p_so < 0 ? p_so : curwin->w_p_so;
+ return wp->w_p_so < 0 ? p_so : wp->w_p_so;
}
/// Return the effective 'sidescrolloff' value for the current window, using the
/// global value when appropriate.
-long get_sidescrolloff_value(void)
+long get_sidescrolloff_value(win_T *wp)
{
- return curwin->w_p_siso < 0 ? p_siso : curwin->w_p_siso;
+ return wp->w_p_siso < 0 ? p_siso : wp->w_p_siso;
}
Dictionary get_vimoption(String name, Error *err)
diff --git a/src/nvim/popupmnu.c b/src/nvim/popupmnu.c
index 551a650045..aef7ffa397 100644
--- a/src/nvim/popupmnu.c
+++ b/src/nvim/popupmnu.c
@@ -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.
diff --git a/src/nvim/quickfix.c b/src/nvim/quickfix.c
index 9b8cc9ba31..aeac6e4905 100644
--- a/src/nvim/quickfix.c
+++ b/src/nvim/quickfix.c
@@ -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;
diff --git a/src/nvim/screen.c b/src/nvim/screen.c
index 2eeeebb88d..afabbe6afc 100644
--- a/src/nvim/screen.c
+++ b/src/nvim/screen.c
@@ -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))
@@ -7380,7 +7380,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
diff --git a/src/nvim/window.c b/src/nvim/window.c
index ad1e1f8f02..6ecfd9ab64 100644
--- a/src/nvim/window.c
+++ b/src/nvim/window.c
@@ -4540,7 +4540,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) {
@@ -5873,10 +5873,10 @@ void scroll_to_fraction(win_T *wp, int prev_height)
}
if (wp == curwin) {
- if (get_scrolloff_value()) {
- update_topline();
+ if (get_scrolloff_value(wp)) {
+ 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;
@@ -5932,8 +5932,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);
}
generated by cgit (git 2.34.1) at 2025-04-29 17:18:46 +0000