blob: 954a13714d6fffca75015925e52f2214b235f400 [file] [log] [blame]
Bram Moolenaaredf3f972016-08-29 22:49:24 +02001/* vi:set ts=8 sts=4 sw=4 noet:
Bram Moolenaar071d4272004-06-13 20:20:40 +00002 *
3 * VIM - Vi IMproved by Bram Moolenaar
4 *
5 * Do ":help uganda" in Vim to read copying and usage conditions.
6 * Do ":help credits" in Vim to see a list of people who contributed.
7 * See README.txt for an overview of the Vim source code.
8 */
9/*
10 * move.c: Functions for moving the cursor and scrolling text.
11 *
12 * There are two ways to move the cursor:
13 * 1. Move the cursor directly, the text is scrolled to keep the cursor in the
14 * window.
15 * 2. Scroll the text, the cursor is moved into the text visible in the
16 * window.
17 * The 'scrolloff' option makes this a bit complicated.
18 */
19
20#include "vim.h"
21
Bram Moolenaar92b8b2d2016-01-29 22:36:45 +010022static int scrolljump_value(void);
23static int check_top_offset(void);
24static void curs_rows(win_T *wp);
Bram Moolenaar071d4272004-06-13 20:20:40 +000025
26typedef struct
27{
Bram Moolenaar85a20022019-12-21 18:25:54 +010028 linenr_T lnum; // line number
Bram Moolenaar071d4272004-06-13 20:20:40 +000029#ifdef FEAT_DIFF
Bram Moolenaar85a20022019-12-21 18:25:54 +010030 int fill; // filler lines
Bram Moolenaar071d4272004-06-13 20:20:40 +000031#endif
Bram Moolenaar85a20022019-12-21 18:25:54 +010032 int height; // height of added line
Bram Moolenaar071d4272004-06-13 20:20:40 +000033} lineoff_T;
34
Bram Moolenaar92b8b2d2016-01-29 22:36:45 +010035static void topline_back(lineoff_T *lp);
36static void botline_forw(lineoff_T *lp);
Bram Moolenaar071d4272004-06-13 20:20:40 +000037
38/*
Bram Moolenaarf6196f42022-10-02 21:29:55 +010039 * Reduce "n" for the screen lines skipped with "wp->w_skipcol".
40 */
41 static int
42adjust_plines_for_skipcol(win_T *wp, int n)
43{
44 if (wp->w_skipcol == 0)
45 return n;
46
47 int off = 0;
48 int width = wp->w_width - win_col_off(wp);
49 if (wp->w_skipcol >= width)
50 {
51 ++off;
52 int skip = wp->w_skipcol - width;
Bram Moolenaarb6aab8f2022-10-03 20:01:16 +010053 width += win_col_off2(wp);
Bram Moolenaarf6196f42022-10-02 21:29:55 +010054 while (skip >= width)
55 {
56 ++off;
57 skip -= width;
58 }
59 }
60 wp->w_valid &= ~VALID_WROW;
61 return n - off;
62}
63
64/*
Bram Moolenaard5337ef2022-10-20 20:15:47 +010065 * Return how many lines "lnum" will take on the screen, taking into account
66 * whether it is the first line, whether w_skipcol is non-zero and limiting to
67 * the window height.
68 */
69 static int
70plines_correct_topline(win_T *wp, linenr_T lnum)
71{
72 int n;
73#ifdef FEAT_DIFF
74 if (lnum == wp->w_topline)
75 n = plines_win_nofill(wp, lnum, FALSE) + wp->w_topfill;
76 else
77#endif
78 n = plines_win(wp, lnum, FALSE);
79 if (lnum == wp->w_topline)
80 n = adjust_plines_for_skipcol(wp, n);
81 if (n > wp->w_height)
82 n = wp->w_height;
83 return n;
84}
85
86/*
Bram Moolenaar071d4272004-06-13 20:20:40 +000087 * Compute wp->w_botline for the current wp->w_topline. Can be called after
88 * wp->w_topline changed.
89 */
90 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +010091comp_botline(win_T *wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +000092{
93 int n;
94 linenr_T lnum;
95 int done;
96#ifdef FEAT_FOLDING
97 linenr_T last;
98 int folded;
99#endif
100
101 /*
102 * If w_cline_row is valid, start there.
103 * Otherwise have to start at w_topline.
104 */
105 check_cursor_moved(wp);
106 if (wp->w_valid & VALID_CROW)
107 {
108 lnum = wp->w_cursor.lnum;
109 done = wp->w_cline_row;
110 }
111 else
112 {
113 lnum = wp->w_topline;
114 done = 0;
115 }
116
117 for ( ; lnum <= wp->w_buffer->b_ml.ml_line_count; ++lnum)
118 {
119#ifdef FEAT_FOLDING
120 last = lnum;
121 folded = FALSE;
122 if (hasFoldingWin(wp, lnum, NULL, &last, TRUE, NULL))
123 {
124 n = 1;
125 folded = TRUE;
126 }
127 else
128#endif
Bram Moolenaarf6196f42022-10-02 21:29:55 +0100129 {
Bram Moolenaard5337ef2022-10-20 20:15:47 +0100130 n = plines_correct_topline(wp, lnum);
Bram Moolenaarf6196f42022-10-02 21:29:55 +0100131 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000132 if (
133#ifdef FEAT_FOLDING
134 lnum <= wp->w_cursor.lnum && last >= wp->w_cursor.lnum
135#else
136 lnum == wp->w_cursor.lnum
137#endif
138 )
139 {
140 wp->w_cline_row = done;
141 wp->w_cline_height = n;
142#ifdef FEAT_FOLDING
143 wp->w_cline_folded = folded;
144#endif
Bram Moolenaar3d6db142014-03-28 21:49:32 +0100145 redraw_for_cursorline(wp);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000146 wp->w_valid |= (VALID_CROW|VALID_CHEIGHT);
147 }
148 if (done + n > wp->w_height)
149 break;
150 done += n;
151#ifdef FEAT_FOLDING
152 lnum = last;
153#endif
154 }
155
Bram Moolenaar85a20022019-12-21 18:25:54 +0100156 // wp->w_botline is the line that is just below the window
Bram Moolenaar071d4272004-06-13 20:20:40 +0000157 wp->w_botline = lnum;
158 wp->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
159
160 set_empty_rows(wp, done);
161}
162
163/*
Bram Moolenaar3d6db142014-03-28 21:49:32 +0100164 * Redraw when w_cline_row changes and 'relativenumber' or 'cursorline' is
165 * set.
166 */
Bram Moolenaarbbb5f8d2019-01-31 13:22:32 +0100167 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100168redraw_for_cursorline(win_T *wp)
Bram Moolenaar3d6db142014-03-28 21:49:32 +0100169{
170 if ((wp->w_p_rnu
171#ifdef FEAT_SYN_HL
172 || wp->w_p_cul
173#endif
174 )
175 && (wp->w_valid & VALID_CROW) == 0
Bram Moolenaare2c453d2019-08-21 14:37:09 +0200176 && !pum_visible())
Bram Moolenaar90a99792018-09-12 21:52:18 +0200177 {
zeertzjqc20e46a2022-03-23 14:55:23 +0000178 // win_line() will redraw the number column and cursorline only.
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100179 redraw_win_later(wp, UPD_VALID);
Bram Moolenaar90a99792018-09-12 21:52:18 +0200180 }
Bram Moolenaar3d6db142014-03-28 21:49:32 +0100181}
182
zeertzjq3e559cd2022-03-27 19:26:55 +0100183#ifdef FEAT_SYN_HL
184/*
185 * Redraw when w_virtcol changes and 'cursorcolumn' is set or 'cursorlineopt'
186 * contains "screenline".
187 */
188 static void
189redraw_for_cursorcolumn(win_T *wp)
190{
191 if ((wp->w_valid & VALID_VIRTCOL) == 0 && !pum_visible())
192 {
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100193 // When 'cursorcolumn' is set need to redraw with UPD_SOME_VALID.
zeertzjq3e559cd2022-03-27 19:26:55 +0100194 if (wp->w_p_cuc)
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100195 redraw_win_later(wp, UPD_SOME_VALID);
196 // When 'cursorlineopt' contains "screenline" need to redraw with
197 // UPD_VALID.
zeertzjq3e559cd2022-03-27 19:26:55 +0100198 else if (wp->w_p_cul && (wp->w_p_culopt_flags & CULOPT_SCRLINE))
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100199 redraw_win_later(wp, UPD_VALID);
zeertzjq3e559cd2022-03-27 19:26:55 +0100200 }
201}
202#endif
203
Bram Moolenaar3d6db142014-03-28 21:49:32 +0100204/*
Yee Cheng Chin81ba26e2022-11-18 12:52:50 +0000205 * Calculates how much overlap the smoothscroll marker "<<<" overlaps with
206 * buffer text for curwin.
207 * Parameter "extra2" should be the padding on the 2nd line, not the first
208 * line.
209 * Returns the number of columns of overlap with buffer text, excluding the
210 * extra padding on the ledge.
211 */
212 static int
213smoothscroll_marker_overlap(int extra2)
214{
215#if defined(FEAT_LINEBREAK)
216 // We don't draw the <<< marker when in showbreak mode, thus no need to
217 // account for it. See wlv_screen_line().
218 if (*get_showbreak_value(curwin) != NUL)
219 return 0;
220#endif
221 return extra2 > 3 ? 0 : 3 - extra2;
222}
223
224/*
Bram Moolenaarf32fb932022-11-17 11:34:38 +0000225 * Set curwin->s_skipcol to zero and redraw later if needed.
226 */
227 static void
228reset_skipcol(void)
229{
230 if (curwin->w_skipcol != 0)
231 {
232 curwin->w_skipcol = 0;
233
234 // Should use the least expensive way that displays all that changed.
235 // UPD_NOT_VALID is too expensive, UPD_REDRAW_TOP does not redraw
236 // enough when the top line gets another screen line.
237 redraw_later(UPD_SOME_VALID);
238 }
239}
240
241/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000242 * Update curwin->w_topline and redraw if necessary.
243 * Used to update the screen before printing a message.
244 */
245 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100246update_topline_redraw(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000247{
248 update_topline();
249 if (must_redraw)
250 update_screen(0);
251}
252
253/*
254 * Update curwin->w_topline to move the cursor onto the screen.
255 */
256 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100257update_topline(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000258{
259 long line_count;
260 int halfheight;
261 int n;
262 linenr_T old_topline;
263#ifdef FEAT_DIFF
264 int old_topfill;
265#endif
266#ifdef FEAT_FOLDING
267 linenr_T lnum;
268#endif
269 int check_topline = FALSE;
270 int check_botline = FALSE;
Bram Moolenaar6ed545e2022-05-09 20:09:23 +0100271 long *so_ptr = curwin->w_p_so >= 0 ? &curwin->w_p_so : &p_so;
Bram Moolenaar375e3392019-01-31 18:26:10 +0100272 int save_so = *so_ptr;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000273
Luuk van Baal13ece2a2022-10-03 15:28:08 +0100274 // Cursor is updated instead when this is TRUE for 'splitkeep'.
275 if (skip_update_topline)
276 return;
277
Bram Moolenaar85a20022019-12-21 18:25:54 +0100278 // If there is no valid screen and when the window height is zero just use
279 // the cursor line.
Bram Moolenaard5d37532017-03-27 23:02:07 +0200280 if (!screen_valid(TRUE) || curwin->w_height == 0)
Bram Moolenaarcfc216e2014-09-23 18:37:56 +0200281 {
Bram Moolenaar3b6d57f2020-11-01 21:56:40 +0100282 check_cursor_lnum();
Bram Moolenaarcfc216e2014-09-23 18:37:56 +0200283 curwin->w_topline = curwin->w_cursor.lnum;
284 curwin->w_botline = curwin->w_topline;
Bram Moolenaarcfc216e2014-09-23 18:37:56 +0200285 curwin->w_scbind_pos = 1;
Bram Moolenaarcfc216e2014-09-23 18:37:56 +0200286 return;
287 }
288
Bram Moolenaar071d4272004-06-13 20:20:40 +0000289 check_cursor_moved(curwin);
290 if (curwin->w_valid & VALID_TOPLINE)
291 return;
292
Bram Moolenaar85a20022019-12-21 18:25:54 +0100293 // When dragging with the mouse, don't scroll that quickly
Bram Moolenaar9964e462007-05-05 17:54:07 +0000294 if (mouse_dragging > 0)
Bram Moolenaar375e3392019-01-31 18:26:10 +0100295 *so_ptr = mouse_dragging - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000296
297 old_topline = curwin->w_topline;
298#ifdef FEAT_DIFF
299 old_topfill = curwin->w_topfill;
300#endif
301
302 /*
303 * If the buffer is empty, always set topline to 1.
304 */
Bram Moolenaar85a20022019-12-21 18:25:54 +0100305 if (BUFEMPTY()) // special case - file is empty
Bram Moolenaar071d4272004-06-13 20:20:40 +0000306 {
307 if (curwin->w_topline != 1)
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100308 redraw_later(UPD_NOT_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000309 curwin->w_topline = 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000310 curwin->w_botline = 2;
311 curwin->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000312 curwin->w_scbind_pos = 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000313 }
314
315 /*
316 * If the cursor is above or near the top of the window, scroll the window
317 * to show the line the cursor is in, with 'scrolloff' context.
318 */
319 else
320 {
Bram Moolenaar46b54742022-10-06 15:46:49 +0100321 if (curwin->w_topline > 1 || curwin->w_skipcol > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000322 {
Bram Moolenaar85a20022019-12-21 18:25:54 +0100323 // If the cursor is above topline, scrolling is always needed.
324 // If the cursor is far below topline and there is no folding,
325 // scrolling down is never needed.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000326 if (curwin->w_cursor.lnum < curwin->w_topline)
327 check_topline = TRUE;
328 else if (check_top_offset())
329 check_topline = TRUE;
Bram Moolenaar46b54742022-10-06 15:46:49 +0100330 else if (curwin->w_cursor.lnum == curwin->w_topline)
331 {
332 colnr_T vcol;
333
Yee Cheng Chin81ba26e2022-11-18 12:52:50 +0000334 // Check that the cursor position is visible. Add columns for
335 // the smoothscroll marker "<<<" displayed in the top-left if
336 // needed.
Bram Moolenaar46b54742022-10-06 15:46:49 +0100337 getvvcol(curwin, &curwin->w_cursor, &vcol, NULL, NULL);
Yee Cheng Chin81ba26e2022-11-18 12:52:50 +0000338 int smoothscroll_overlap = smoothscroll_marker_overlap(
339 curwin_col_off() - curwin_col_off2());
340 if (curwin->w_skipcol + smoothscroll_overlap > vcol)
Bram Moolenaar46b54742022-10-06 15:46:49 +0100341 check_topline = TRUE;
342 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000343 }
344#ifdef FEAT_DIFF
Bram Moolenaar85a20022019-12-21 18:25:54 +0100345 // Check if there are more filler lines than allowed.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000346 if (!check_topline && curwin->w_topfill > diff_check_fill(curwin,
347 curwin->w_topline))
348 check_topline = TRUE;
349#endif
350
351 if (check_topline)
352 {
353 halfheight = curwin->w_height / 2 - 1;
354 if (halfheight < 2)
355 halfheight = 2;
356
357#ifdef FEAT_FOLDING
358 if (hasAnyFolding(curwin))
359 {
Bram Moolenaar85a20022019-12-21 18:25:54 +0100360 // Count the number of logical lines between the cursor and
361 // topline + scrolloff (approximation of how much will be
362 // scrolled).
Bram Moolenaar071d4272004-06-13 20:20:40 +0000363 n = 0;
364 for (lnum = curwin->w_cursor.lnum;
Bram Moolenaar85a20022019-12-21 18:25:54 +0100365 lnum < curwin->w_topline + *so_ptr; ++lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000366 {
367 ++n;
Bram Moolenaar85a20022019-12-21 18:25:54 +0100368 // stop at end of file or when we know we are far off
Bram Moolenaar071d4272004-06-13 20:20:40 +0000369 if (lnum >= curbuf->b_ml.ml_line_count || n >= halfheight)
370 break;
371 (void)hasFolding(lnum, NULL, &lnum);
372 }
373 }
374 else
375#endif
Bram Moolenaar375e3392019-01-31 18:26:10 +0100376 n = curwin->w_topline + *so_ptr - curwin->w_cursor.lnum;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000377
Bram Moolenaar85a20022019-12-21 18:25:54 +0100378 // If we weren't very close to begin with, we scroll to put the
379 // cursor in the middle of the window. Otherwise put the cursor
380 // near the top of the window.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000381 if (n >= halfheight)
382 scroll_cursor_halfway(FALSE);
383 else
384 {
Bram Moolenaar1e015462005-09-25 22:16:38 +0000385 scroll_cursor_top(scrolljump_value(), FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000386 check_botline = TRUE;
387 }
388 }
389
390 else
391 {
392#ifdef FEAT_FOLDING
Bram Moolenaar85a20022019-12-21 18:25:54 +0100393 // Make sure topline is the first line of a fold.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000394 (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
395#endif
396 check_botline = TRUE;
397 }
398 }
399
400 /*
401 * If the cursor is below the bottom of the window, scroll the window
402 * to put the cursor on the window.
403 * When w_botline is invalid, recompute it first, to avoid a redraw later.
404 * If w_botline was approximated, we might need a redraw later in a few
405 * cases, but we don't want to spend (a lot of) time recomputing w_botline
406 * for every small change.
407 */
408 if (check_botline)
409 {
410 if (!(curwin->w_valid & VALID_BOTLINE_AP))
411 validate_botline();
412
413 if (curwin->w_botline <= curbuf->b_ml.ml_line_count)
414 {
Bram Moolenaard4153d42008-11-15 15:06:17 +0000415 if (curwin->w_cursor.lnum < curwin->w_botline)
416 {
417 if (((long)curwin->w_cursor.lnum
Bram Moolenaar8088ae92022-06-20 11:38:17 +0100418 >= (long)curwin->w_botline - *so_ptr
Bram Moolenaar071d4272004-06-13 20:20:40 +0000419#ifdef FEAT_FOLDING
420 || hasAnyFolding(curwin)
421#endif
422 ))
Bram Moolenaard4153d42008-11-15 15:06:17 +0000423 {
Bram Moolenaar071d4272004-06-13 20:20:40 +0000424 lineoff_T loff;
425
Bram Moolenaar85a20022019-12-21 18:25:54 +0100426 // Cursor is (a few lines) above botline, check if there are
427 // 'scrolloff' window lines below the cursor. If not, need to
428 // scroll.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000429 n = curwin->w_empty_rows;
430 loff.lnum = curwin->w_cursor.lnum;
431#ifdef FEAT_FOLDING
Bram Moolenaar85a20022019-12-21 18:25:54 +0100432 // In a fold go to its last line.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000433 (void)hasFolding(loff.lnum, NULL, &loff.lnum);
434#endif
435#ifdef FEAT_DIFF
436 loff.fill = 0;
437 n += curwin->w_filler_rows;
438#endif
439 loff.height = 0;
440 while (loff.lnum < curwin->w_botline
441#ifdef FEAT_DIFF
442 && (loff.lnum + 1 < curwin->w_botline || loff.fill == 0)
443#endif
444 )
445 {
446 n += loff.height;
Bram Moolenaar375e3392019-01-31 18:26:10 +0100447 if (n >= *so_ptr)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000448 break;
449 botline_forw(&loff);
450 }
Bram Moolenaar375e3392019-01-31 18:26:10 +0100451 if (n >= *so_ptr)
Bram Moolenaar85a20022019-12-21 18:25:54 +0100452 // sufficient context, no need to scroll
Bram Moolenaar071d4272004-06-13 20:20:40 +0000453 check_botline = FALSE;
Bram Moolenaard4153d42008-11-15 15:06:17 +0000454 }
455 else
Bram Moolenaar85a20022019-12-21 18:25:54 +0100456 // sufficient context, no need to scroll
Bram Moolenaard4153d42008-11-15 15:06:17 +0000457 check_botline = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000458 }
459 if (check_botline)
460 {
461#ifdef FEAT_FOLDING
462 if (hasAnyFolding(curwin))
463 {
Bram Moolenaar85a20022019-12-21 18:25:54 +0100464 // Count the number of logical lines between the cursor and
465 // botline - scrolloff (approximation of how much will be
466 // scrolled).
Bram Moolenaar071d4272004-06-13 20:20:40 +0000467 line_count = 0;
468 for (lnum = curwin->w_cursor.lnum;
Bram Moolenaar85a20022019-12-21 18:25:54 +0100469 lnum >= curwin->w_botline - *so_ptr; --lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000470 {
471 ++line_count;
Bram Moolenaar85a20022019-12-21 18:25:54 +0100472 // stop at end of file or when we know we are far off
Bram Moolenaar071d4272004-06-13 20:20:40 +0000473 if (lnum <= 0 || line_count > curwin->w_height + 1)
474 break;
475 (void)hasFolding(lnum, &lnum, NULL);
476 }
477 }
478 else
479#endif
480 line_count = curwin->w_cursor.lnum - curwin->w_botline
Bram Moolenaar8088ae92022-06-20 11:38:17 +0100481 + 1 + *so_ptr;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000482 if (line_count <= curwin->w_height + 1)
Bram Moolenaar1e015462005-09-25 22:16:38 +0000483 scroll_cursor_bot(scrolljump_value(), FALSE);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000484 else
485 scroll_cursor_halfway(FALSE);
486 }
487 }
488 }
489 curwin->w_valid |= VALID_TOPLINE;
490
491 /*
492 * Need to redraw when topline changed.
493 */
494 if (curwin->w_topline != old_topline
495#ifdef FEAT_DIFF
496 || curwin->w_topfill != old_topfill
497#endif
498 )
499 {
Bram Moolenaar76b9b362012-02-04 23:35:00 +0100500 dollar_vcol = -1;
Bram Moolenaarf32fb932022-11-17 11:34:38 +0000501 redraw_later(UPD_VALID);
502 reset_skipcol();
503
Bram Moolenaar85a20022019-12-21 18:25:54 +0100504 // May need to set w_skipcol when cursor in w_topline.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000505 if (curwin->w_cursor.lnum == curwin->w_topline)
506 validate_cursor();
507 }
508
Bram Moolenaar375e3392019-01-31 18:26:10 +0100509 *so_ptr = save_so;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000510}
511
512/*
Bram Moolenaar1e015462005-09-25 22:16:38 +0000513 * Return the scrolljump value to use for the current window.
514 * When 'scrolljump' is positive use it as-is.
515 * When 'scrolljump' is negative use it as a percentage of the window height.
516 */
517 static int
Bram Moolenaar9b578142016-01-30 19:39:49 +0100518scrolljump_value(void)
Bram Moolenaar1e015462005-09-25 22:16:38 +0000519{
520 if (p_sj >= 0)
521 return (int)p_sj;
522 return (curwin->w_height * -p_sj) / 100;
523}
524
525/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000526 * Return TRUE when there are not 'scrolloff' lines above the cursor for the
527 * current window.
528 */
529 static int
Bram Moolenaar9b578142016-01-30 19:39:49 +0100530check_top_offset(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000531{
532 lineoff_T loff;
533 int n;
Bram Moolenaar6ed545e2022-05-09 20:09:23 +0100534 long so = get_scrolloff_value();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000535
Bram Moolenaar375e3392019-01-31 18:26:10 +0100536 if (curwin->w_cursor.lnum < curwin->w_topline + so
Bram Moolenaar071d4272004-06-13 20:20:40 +0000537#ifdef FEAT_FOLDING
538 || hasAnyFolding(curwin)
539#endif
540 )
541 {
542 loff.lnum = curwin->w_cursor.lnum;
543#ifdef FEAT_DIFF
544 loff.fill = 0;
Bram Moolenaar85a20022019-12-21 18:25:54 +0100545 n = curwin->w_topfill; // always have this context
Bram Moolenaar071d4272004-06-13 20:20:40 +0000546#else
547 n = 0;
548#endif
Bram Moolenaar85a20022019-12-21 18:25:54 +0100549 // Count the visible screen lines above the cursor line.
Bram Moolenaar375e3392019-01-31 18:26:10 +0100550 while (n < so)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000551 {
552 topline_back(&loff);
Bram Moolenaar85a20022019-12-21 18:25:54 +0100553 // Stop when included a line above the window.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000554 if (loff.lnum < curwin->w_topline
555#ifdef FEAT_DIFF
556 || (loff.lnum == curwin->w_topline && loff.fill > 0)
557#endif
558 )
559 break;
560 n += loff.height;
561 }
Bram Moolenaar375e3392019-01-31 18:26:10 +0100562 if (n < so)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000563 return TRUE;
564 }
565 return FALSE;
566}
567
Bram Moolenaare24b4ab2022-09-16 20:51:14 +0100568/*
569 * Update w_curswant.
570 */
571 void
572update_curswant_force(void)
573{
574 validate_virtcol();
575 curwin->w_curswant = curwin->w_virtcol
576#ifdef FEAT_PROP_POPUP
577 - curwin->w_virtcol_first_char
578#endif
579 ;
580 curwin->w_set_curswant = FALSE;
581}
582
583/*
584 * Update w_curswant if w_set_curswant is set.
585 */
Bram Moolenaar071d4272004-06-13 20:20:40 +0000586 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100587update_curswant(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000588{
589 if (curwin->w_set_curswant)
Bram Moolenaare24b4ab2022-09-16 20:51:14 +0100590 update_curswant_force();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000591}
592
593/*
594 * Check if the cursor has moved. Set the w_valid flag accordingly.
595 */
596 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100597check_cursor_moved(win_T *wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000598{
599 if (wp->w_cursor.lnum != wp->w_valid_cursor.lnum)
600 {
601 wp->w_valid &= ~(VALID_WROW|VALID_WCOL|VALID_VIRTCOL
Bram Moolenaara91cb982022-05-08 19:39:31 +0100602 |VALID_CHEIGHT|VALID_CROW|VALID_TOPLINE
603 |VALID_BOTLINE|VALID_BOTLINE_AP);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000604 wp->w_valid_cursor = wp->w_cursor;
605 wp->w_valid_leftcol = wp->w_leftcol;
Bram Moolenaar2fbabd22022-10-12 19:53:38 +0100606 wp->w_valid_skipcol = wp->w_skipcol;
607 }
608 else if (wp->w_skipcol != wp->w_valid_skipcol)
609 {
610 wp->w_valid &= ~(VALID_WROW|VALID_WCOL|VALID_VIRTCOL
611 |VALID_CHEIGHT|VALID_CROW
612 |VALID_BOTLINE|VALID_BOTLINE_AP);
613 wp->w_valid_cursor = wp->w_cursor;
614 wp->w_valid_leftcol = wp->w_leftcol;
615 wp->w_valid_skipcol = wp->w_skipcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000616 }
617 else if (wp->w_cursor.col != wp->w_valid_cursor.col
618 || wp->w_leftcol != wp->w_valid_leftcol
Bram Moolenaar29ddebe2019-01-26 17:28:26 +0100619 || wp->w_cursor.coladd != wp->w_valid_cursor.coladd)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000620 {
621 wp->w_valid &= ~(VALID_WROW|VALID_WCOL|VALID_VIRTCOL);
622 wp->w_valid_cursor.col = wp->w_cursor.col;
623 wp->w_valid_leftcol = wp->w_leftcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000624 wp->w_valid_cursor.coladd = wp->w_cursor.coladd;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000625 }
626}
627
628/*
629 * Call this function when some window settings have changed, which require
630 * the cursor position, botline and topline to be recomputed and the window to
631 * be redrawn. E.g, when changing the 'wrap' option or folding.
632 */
633 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100634changed_window_setting(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000635{
636 changed_window_setting_win(curwin);
637}
638
639 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100640changed_window_setting_win(win_T *wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000641{
642 wp->w_lines_valid = 0;
643 changed_line_abv_curs_win(wp);
644 wp->w_valid &= ~(VALID_BOTLINE|VALID_BOTLINE_AP|VALID_TOPLINE);
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100645 redraw_win_later(wp, UPD_NOT_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000646}
647
648/*
Bram Moolenaar89469d12022-12-02 20:46:26 +0000649 * Call changed_window_setting_win() for every window containing "buf".
650 */
651 void
652changed_window_setting_buf(buf_T *buf)
653{
654 tabpage_T *tp;
655 win_T *wp;
656
657 FOR_ALL_TAB_WINDOWS(tp, wp)
658 if (wp->w_buffer == buf)
659 changed_window_setting_win(wp);
660}
661
662/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000663 * Set wp->w_topline to a certain number.
664 */
665 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100666set_topline(win_T *wp, linenr_T lnum)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000667{
Bram Moolenaar04626c22021-09-01 16:02:07 +0200668#ifdef FEAT_DIFF
669 linenr_T prev_topline = wp->w_topline;
670#endif
671
Bram Moolenaar071d4272004-06-13 20:20:40 +0000672#ifdef FEAT_FOLDING
Bram Moolenaar85a20022019-12-21 18:25:54 +0100673 // go to first of folded lines
Bram Moolenaar071d4272004-06-13 20:20:40 +0000674 (void)hasFoldingWin(wp, lnum, &lnum, NULL, TRUE, NULL);
675#endif
Bram Moolenaar85a20022019-12-21 18:25:54 +0100676 // Approximate the value of w_botline
Bram Moolenaar071d4272004-06-13 20:20:40 +0000677 wp->w_botline += lnum - wp->w_topline;
Bram Moolenaar23999d72020-12-23 14:36:00 +0100678 if (wp->w_botline > wp->w_buffer->b_ml.ml_line_count + 1)
679 wp->w_botline = wp->w_buffer->b_ml.ml_line_count + 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000680 wp->w_topline = lnum;
Bram Moolenaard4153d42008-11-15 15:06:17 +0000681 wp->w_topline_was_set = TRUE;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000682#ifdef FEAT_DIFF
Bram Moolenaar04626c22021-09-01 16:02:07 +0200683 if (lnum != prev_topline)
684 // Keep the filler lines when the topline didn't change.
685 wp->w_topfill = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000686#endif
687 wp->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_TOPLINE);
Bram Moolenaar85a20022019-12-21 18:25:54 +0100688 // Don't set VALID_TOPLINE here, 'scrolloff' needs to be checked.
Bram Moolenaara4d158b2022-08-14 14:17:45 +0100689 redraw_later(UPD_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000690}
691
692/*
693 * Call this function when the length of the cursor line (in screen
694 * characters) has changed, and the change is before the cursor.
695 * Need to take care of w_botline separately!
696 */
697 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100698changed_cline_bef_curs(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000699{
700 curwin->w_valid &= ~(VALID_WROW|VALID_WCOL|VALID_VIRTCOL
701 |VALID_CHEIGHT|VALID_TOPLINE);
702}
703
704 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100705changed_cline_bef_curs_win(win_T *wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000706{
707 wp->w_valid &= ~(VALID_WROW|VALID_WCOL|VALID_VIRTCOL
708 |VALID_CHEIGHT|VALID_TOPLINE);
709}
710
Bram Moolenaar071d4272004-06-13 20:20:40 +0000711/*
712 * Call this function when the length of a line (in screen characters) above
713 * the cursor have changed.
714 * Need to take care of w_botline separately!
715 */
716 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100717changed_line_abv_curs(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000718{
719 curwin->w_valid &= ~(VALID_WROW|VALID_WCOL|VALID_VIRTCOL|VALID_CROW
720 |VALID_CHEIGHT|VALID_TOPLINE);
721}
722
723 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100724changed_line_abv_curs_win(win_T *wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000725{
726 wp->w_valid &= ~(VALID_WROW|VALID_WCOL|VALID_VIRTCOL|VALID_CROW
727 |VALID_CHEIGHT|VALID_TOPLINE);
728}
729
730/*
Bram Moolenaar326c5d32022-08-12 13:05:49 +0100731 * Display of line has changed for "buf", invalidate cursor position and
732 * w_botline.
733 */
734 void
735changed_line_display_buf(buf_T *buf)
736{
737 win_T *wp;
738
739 FOR_ALL_WINDOWS(wp)
740 if (wp->w_buffer == buf)
741 wp->w_valid &= ~(VALID_WROW|VALID_WCOL|VALID_VIRTCOL
742 |VALID_CROW|VALID_CHEIGHT
743 |VALID_TOPLINE|VALID_BOTLINE|VALID_BOTLINE_AP);
744}
745
746/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000747 * Make sure the value of curwin->w_botline is valid.
748 */
749 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100750validate_botline(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000751{
Bram Moolenaar23999d72020-12-23 14:36:00 +0100752 validate_botline_win(curwin);
753}
754
755/*
756 * Make sure the value of wp->w_botline is valid.
757 */
758 void
759validate_botline_win(win_T *wp)
760{
761 if (!(wp->w_valid & VALID_BOTLINE))
762 comp_botline(wp);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000763}
764
765/*
Bram Moolenaar071d4272004-06-13 20:20:40 +0000766 * Mark curwin->w_botline as invalid (because of some change in the buffer).
767 */
768 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100769invalidate_botline(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000770{
771 curwin->w_valid &= ~(VALID_BOTLINE|VALID_BOTLINE_AP);
772}
773
774 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100775invalidate_botline_win(win_T *wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000776{
777 wp->w_valid &= ~(VALID_BOTLINE|VALID_BOTLINE_AP);
778}
779
Bram Moolenaar071d4272004-06-13 20:20:40 +0000780 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100781approximate_botline_win(
782 win_T *wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000783{
784 wp->w_valid &= ~VALID_BOTLINE;
785}
786
Bram Moolenaar071d4272004-06-13 20:20:40 +0000787/*
788 * Return TRUE if curwin->w_wrow and curwin->w_wcol are valid.
789 */
790 int
Bram Moolenaar9b578142016-01-30 19:39:49 +0100791cursor_valid(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000792{
793 check_cursor_moved(curwin);
794 return ((curwin->w_valid & (VALID_WROW|VALID_WCOL)) ==
795 (VALID_WROW|VALID_WCOL));
796}
797
798/*
799 * Validate cursor position. Makes sure w_wrow and w_wcol are valid.
800 * w_topline must be valid, you may need to call update_topline() first!
801 */
802 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100803validate_cursor(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000804{
Bram Moolenaard4566c12022-09-24 21:06:39 +0100805 check_cursor_lnum();
Bram Moolenaar071d4272004-06-13 20:20:40 +0000806 check_cursor_moved(curwin);
807 if ((curwin->w_valid & (VALID_WCOL|VALID_WROW)) != (VALID_WCOL|VALID_WROW))
808 curs_columns(TRUE);
809}
810
811#if defined(FEAT_GUI) || defined(PROTO)
812/*
813 * validate w_cline_row.
814 */
815 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100816validate_cline_row(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000817{
818 /*
819 * First make sure that w_topline is valid (after moving the cursor).
820 */
821 update_topline();
822 check_cursor_moved(curwin);
823 if (!(curwin->w_valid & VALID_CROW))
Bram Moolenaar3f9be972014-12-13 21:09:57 +0100824 curs_rows(curwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000825}
826#endif
827
828/*
829 * Compute wp->w_cline_row and wp->w_cline_height, based on the current value
Bram Moolenaarfff2bee2010-05-15 13:56:02 +0200830 * of wp->w_topline.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000831 */
832 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100833curs_rows(win_T *wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000834{
835 linenr_T lnum;
836 int i;
837 int all_invalid;
838 int valid;
839#ifdef FEAT_FOLDING
840 long fold_count;
841#endif
842
Bram Moolenaar85a20022019-12-21 18:25:54 +0100843 // Check if wp->w_lines[].wl_size is invalid
Bram Moolenaar071d4272004-06-13 20:20:40 +0000844 all_invalid = (!redrawing()
845 || wp->w_lines_valid == 0
846 || wp->w_lines[0].wl_lnum > wp->w_topline);
847 i = 0;
848 wp->w_cline_row = 0;
849 for (lnum = wp->w_topline; lnum < wp->w_cursor.lnum; ++i)
850 {
851 valid = FALSE;
852 if (!all_invalid && i < wp->w_lines_valid)
853 {
854 if (wp->w_lines[i].wl_lnum < lnum || !wp->w_lines[i].wl_valid)
Bram Moolenaar85a20022019-12-21 18:25:54 +0100855 continue; // skip changed or deleted lines
Bram Moolenaar071d4272004-06-13 20:20:40 +0000856 if (wp->w_lines[i].wl_lnum == lnum)
857 {
858#ifdef FEAT_FOLDING
Bram Moolenaar85a20022019-12-21 18:25:54 +0100859 // Check for newly inserted lines below this row, in which
860 // case we need to check for folded lines.
Bram Moolenaar071d4272004-06-13 20:20:40 +0000861 if (!wp->w_buffer->b_mod_set
862 || wp->w_lines[i].wl_lastlnum < wp->w_cursor.lnum
863 || wp->w_buffer->b_mod_top
864 > wp->w_lines[i].wl_lastlnum + 1)
865#endif
866 valid = TRUE;
867 }
868 else if (wp->w_lines[i].wl_lnum > lnum)
Bram Moolenaar85a20022019-12-21 18:25:54 +0100869 --i; // hold at inserted lines
Bram Moolenaar071d4272004-06-13 20:20:40 +0000870 }
871 if (valid
872#ifdef FEAT_DIFF
873 && (lnum != wp->w_topline || !wp->w_p_diff)
874#endif
875 )
876 {
877#ifdef FEAT_FOLDING
878 lnum = wp->w_lines[i].wl_lastlnum + 1;
Bram Moolenaar85a20022019-12-21 18:25:54 +0100879 // Cursor inside folded lines, don't count this row
Bram Moolenaar071d4272004-06-13 20:20:40 +0000880 if (lnum > wp->w_cursor.lnum)
881 break;
882#else
883 ++lnum;
884#endif
885 wp->w_cline_row += wp->w_lines[i].wl_size;
886 }
887 else
888 {
889#ifdef FEAT_FOLDING
890 fold_count = foldedCount(wp, lnum, NULL);
891 if (fold_count)
892 {
893 lnum += fold_count;
894 if (lnum > wp->w_cursor.lnum)
895 break;
896 ++wp->w_cline_row;
897 }
898 else
899#endif
Bram Moolenaarf6196f42022-10-02 21:29:55 +0100900 {
Bram Moolenaard5337ef2022-10-20 20:15:47 +0100901 wp->w_cline_row += plines_correct_topline(wp, lnum);
902 ++lnum;
Bram Moolenaarf6196f42022-10-02 21:29:55 +0100903 }
Bram Moolenaar071d4272004-06-13 20:20:40 +0000904 }
905 }
906
907 check_cursor_moved(wp);
908 if (!(wp->w_valid & VALID_CHEIGHT))
909 {
910 if (all_invalid
911 || i == wp->w_lines_valid
912 || (i < wp->w_lines_valid
913 && (!wp->w_lines[i].wl_valid
914 || wp->w_lines[i].wl_lnum != wp->w_cursor.lnum)))
915 {
916#ifdef FEAT_DIFF
917 if (wp->w_cursor.lnum == wp->w_topline)
918 wp->w_cline_height = plines_win_nofill(wp, wp->w_cursor.lnum,
919 TRUE) + wp->w_topfill;
920 else
921#endif
922 wp->w_cline_height = plines_win(wp, wp->w_cursor.lnum, TRUE);
923#ifdef FEAT_FOLDING
924 wp->w_cline_folded = hasFoldingWin(wp, wp->w_cursor.lnum,
925 NULL, NULL, TRUE, NULL);
926#endif
927 }
928 else if (i > wp->w_lines_valid)
929 {
Bram Moolenaar85a20022019-12-21 18:25:54 +0100930 // a line that is too long to fit on the last screen line
Bram Moolenaar071d4272004-06-13 20:20:40 +0000931 wp->w_cline_height = 0;
932#ifdef FEAT_FOLDING
933 wp->w_cline_folded = hasFoldingWin(wp, wp->w_cursor.lnum,
934 NULL, NULL, TRUE, NULL);
935#endif
936 }
937 else
938 {
939 wp->w_cline_height = wp->w_lines[i].wl_size;
940#ifdef FEAT_FOLDING
941 wp->w_cline_folded = wp->w_lines[i].wl_folded;
942#endif
943 }
944 }
945
Bram Moolenaar3d6db142014-03-28 21:49:32 +0100946 redraw_for_cursorline(curwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +0000947 wp->w_valid |= VALID_CROW|VALID_CHEIGHT;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000948}
949
950/*
951 * Validate curwin->w_virtcol only.
952 */
953 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100954validate_virtcol(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000955{
956 validate_virtcol_win(curwin);
957}
958
959/*
960 * Validate wp->w_virtcol only.
961 */
962 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100963validate_virtcol_win(win_T *wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000964{
965 check_cursor_moved(wp);
966 if (!(wp->w_valid & VALID_VIRTCOL))
967 {
Bram Moolenaar04e0ed12022-09-10 20:00:56 +0100968#ifdef FEAT_PROP_POPUP
969 wp->w_virtcol_first_char = 0;
970#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +0000971 getvvcol(wp, &wp->w_cursor, NULL, &(wp->w_virtcol), NULL);
Bram Moolenaar2b48ad52006-03-12 21:56:11 +0000972#ifdef FEAT_SYN_HL
zeertzjq3e559cd2022-03-27 19:26:55 +0100973 redraw_for_cursorcolumn(wp);
Bram Moolenaar2b48ad52006-03-12 21:56:11 +0000974#endif
zeertzjq3e559cd2022-03-27 19:26:55 +0100975 wp->w_valid |= VALID_VIRTCOL;
Bram Moolenaar071d4272004-06-13 20:20:40 +0000976 }
977}
978
979/*
980 * Validate curwin->w_cline_height only.
981 */
Bram Moolenaar09dd2bb2019-12-14 18:42:15 +0100982 void
Bram Moolenaar9b578142016-01-30 19:39:49 +0100983validate_cheight(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +0000984{
985 check_cursor_moved(curwin);
986 if (!(curwin->w_valid & VALID_CHEIGHT))
987 {
988#ifdef FEAT_DIFF
989 if (curwin->w_cursor.lnum == curwin->w_topline)
990 curwin->w_cline_height = plines_nofill(curwin->w_cursor.lnum)
991 + curwin->w_topfill;
992 else
993#endif
994 curwin->w_cline_height = plines(curwin->w_cursor.lnum);
995#ifdef FEAT_FOLDING
996 curwin->w_cline_folded = hasFolding(curwin->w_cursor.lnum, NULL, NULL);
997#endif
998 curwin->w_valid |= VALID_CHEIGHT;
999 }
1000}
1001
1002/*
Bram Moolenaarc236c162008-07-13 17:41:49 +00001003 * Validate w_wcol and w_virtcol only.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001004 */
1005 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01001006validate_cursor_col(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001007{
1008 colnr_T off;
1009 colnr_T col;
Bram Moolenaar6427c602010-02-03 17:43:07 +01001010 int width;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001011
1012 validate_virtcol();
1013 if (!(curwin->w_valid & VALID_WCOL))
1014 {
1015 col = curwin->w_virtcol;
1016 off = curwin_col_off();
1017 col += off;
Bram Moolenaar02631462017-09-22 15:20:32 +02001018 width = curwin->w_width - off + curwin_col_off2();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001019
Bram Moolenaar85a20022019-12-21 18:25:54 +01001020 // long line wrapping, adjust curwin->w_wrow
Bram Moolenaarc236c162008-07-13 17:41:49 +00001021 if (curwin->w_p_wrap
Bram Moolenaar02631462017-09-22 15:20:32 +02001022 && col >= (colnr_T)curwin->w_width
Bram Moolenaar6427c602010-02-03 17:43:07 +01001023 && width > 0)
Bram Moolenaar85a20022019-12-21 18:25:54 +01001024 // use same formula as what is used in curs_columns()
Bram Moolenaar02631462017-09-22 15:20:32 +02001025 col -= ((col - curwin->w_width) / width + 1) * width;
Bram Moolenaarc236c162008-07-13 17:41:49 +00001026 if (col > (int)curwin->w_leftcol)
1027 col -= curwin->w_leftcol;
1028 else
1029 col = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001030 curwin->w_wcol = col;
Bram Moolenaarc236c162008-07-13 17:41:49 +00001031
Bram Moolenaar071d4272004-06-13 20:20:40 +00001032 curwin->w_valid |= VALID_WCOL;
Bram Moolenaar4792a672020-11-15 21:11:18 +01001033#ifdef FEAT_PROP_POPUP
Bram Moolenaar6a076442020-11-15 20:32:58 +01001034 curwin->w_flags &= ~WFLAG_WCOL_OFF_ADDED;
Bram Moolenaar4792a672020-11-15 21:11:18 +01001035#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001036 }
1037}
1038
1039/*
Bram Moolenaar64486672010-05-16 15:46:46 +02001040 * Compute offset of a window, occupied by absolute or relative line number,
1041 * fold column and sign column (these don't move when scrolling horizontally).
Bram Moolenaar071d4272004-06-13 20:20:40 +00001042 */
1043 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01001044win_col_off(win_T *wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001045{
Bram Moolenaar64486672010-05-16 15:46:46 +02001046 return (((wp->w_p_nu || wp->w_p_rnu) ? number_width(wp) + 1 : 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001047 + (cmdwin_type == 0 || wp != curwin ? 0 : 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001048#ifdef FEAT_FOLDING
1049 + wp->w_p_fdc
1050#endif
1051#ifdef FEAT_SIGNS
Bram Moolenaar95ec9d62016-08-12 18:29:59 +02001052 + (signcolumn_on(wp) ? 2 : 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001053#endif
1054 );
1055}
1056
1057 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01001058curwin_col_off(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001059{
1060 return win_col_off(curwin);
1061}
1062
1063/*
1064 * Return the difference in column offset for the second screen line of a
Bram Moolenaar6b2d4ff2022-10-03 14:06:02 +01001065 * wrapped line. It's positive if 'number' or 'relativenumber' is on and 'n'
1066 * is in 'cpoptions'.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001067 */
1068 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01001069win_col_off2(win_T *wp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001070{
Bram Moolenaar64486672010-05-16 15:46:46 +02001071 if ((wp->w_p_nu || wp->w_p_rnu) && vim_strchr(p_cpo, CPO_NUMCOL) != NULL)
Bram Moolenaar592e0a22004-07-03 16:05:59 +00001072 return number_width(wp) + 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001073 return 0;
1074}
1075
1076 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01001077curwin_col_off2(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001078{
1079 return win_col_off2(curwin);
1080}
1081
1082/*
Bram Moolenaarfc3abf42019-01-24 15:54:21 +01001083 * Compute curwin->w_wcol and curwin->w_virtcol.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001084 * Also updates curwin->w_wrow and curwin->w_cline_row.
1085 * Also updates curwin->w_leftcol.
1086 */
1087 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01001088curs_columns(
Bram Moolenaar85a20022019-12-21 18:25:54 +01001089 int may_scroll) // when TRUE, may scroll horizontally
Bram Moolenaar071d4272004-06-13 20:20:40 +00001090{
1091 int diff;
Bram Moolenaar85a20022019-12-21 18:25:54 +01001092 int extra; // offset for first screen line
Bram Moolenaar071d4272004-06-13 20:20:40 +00001093 int off_left, off_right;
1094 int n;
1095 int p_lines;
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001096 int width1; // text width for first screen line
1097 int width2 = 0; // text width for second and later screen line
Bram Moolenaar071d4272004-06-13 20:20:40 +00001098 int new_leftcol;
1099 colnr_T startcol;
1100 colnr_T endcol;
1101 colnr_T prev_skipcol;
Bram Moolenaar6ed545e2022-05-09 20:09:23 +01001102 long so = get_scrolloff_value();
1103 long siso = get_sidescrolloff_value();
Bram Moolenaar4b6172e2022-10-13 20:23:28 +01001104 int did_sub_skipcol = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001105
1106 /*
1107 * First make sure that w_topline is valid (after moving the cursor).
1108 */
Luuk van Baal13ece2a2022-10-03 15:28:08 +01001109 update_topline();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001110
1111 /*
1112 * Next make sure that w_cline_row is valid.
1113 */
1114 if (!(curwin->w_valid & VALID_CROW))
Bram Moolenaar3f9be972014-12-13 21:09:57 +01001115 curs_rows(curwin);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001116
Bram Moolenaar04e0ed12022-09-10 20:00:56 +01001117#ifdef FEAT_PROP_POPUP
1118 // will be set by getvvcol() but not reset
1119 curwin->w_virtcol_first_char = 0;
1120#endif
1121
Bram Moolenaar071d4272004-06-13 20:20:40 +00001122 /*
1123 * Compute the number of virtual columns.
1124 */
1125#ifdef FEAT_FOLDING
1126 if (curwin->w_cline_folded)
Bram Moolenaar85a20022019-12-21 18:25:54 +01001127 // In a folded line the cursor is always in the first column
Bram Moolenaar071d4272004-06-13 20:20:40 +00001128 startcol = curwin->w_virtcol = endcol = curwin->w_leftcol;
1129 else
1130#endif
1131 getvvcol(curwin, &curwin->w_cursor,
1132 &startcol, &(curwin->w_virtcol), &endcol);
1133
Bram Moolenaar85a20022019-12-21 18:25:54 +01001134 // remove '$' from change command when cursor moves onto it
Bram Moolenaar071d4272004-06-13 20:20:40 +00001135 if (startcol > dollar_vcol)
Bram Moolenaar76b9b362012-02-04 23:35:00 +01001136 dollar_vcol = -1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001137
1138 extra = curwin_col_off();
1139 curwin->w_wcol = curwin->w_virtcol + extra;
1140 endcol += extra;
1141
1142 /*
1143 * Now compute w_wrow, counting screen lines from w_cline_row.
1144 */
1145 curwin->w_wrow = curwin->w_cline_row;
1146
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001147 width1 = curwin->w_width - extra;
1148 if (width1 <= 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001149 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01001150 // No room for text, put cursor in last char of window.
Bram Moolenaar30441bb2021-07-08 13:19:31 +02001151 // If not wrapping, the last non-empty line.
Bram Moolenaar02631462017-09-22 15:20:32 +02001152 curwin->w_wcol = curwin->w_width - 1;
Bram Moolenaar30441bb2021-07-08 13:19:31 +02001153 if (curwin->w_p_wrap)
1154 curwin->w_wrow = curwin->w_height - 1;
1155 else
1156 curwin->w_wrow = curwin->w_height - 1 - curwin->w_empty_rows;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001157 }
Bram Moolenaar4033c552017-09-16 20:54:51 +02001158 else if (curwin->w_p_wrap && curwin->w_width != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001159 {
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001160 width2 = width1 + curwin_col_off2();
Bram Moolenaar071d4272004-06-13 20:20:40 +00001161
Bram Moolenaar2fbabd22022-10-12 19:53:38 +01001162 // skip columns that are not visible
1163 if (curwin->w_cursor.lnum == curwin->w_topline
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001164 && curwin->w_skipcol > 0
Bram Moolenaar2fbabd22022-10-12 19:53:38 +01001165 && curwin->w_wcol >= curwin->w_skipcol)
Bram Moolenaar4b6172e2022-10-13 20:23:28 +01001166 {
Yee Cheng Chin01ee52b2022-11-17 12:41:42 +00001167 // Deduct by multiples of width2. This allows the long line
1168 // wrapping formula below to correctly calculate the w_wcol value
1169 // when wrapping.
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001170 if (curwin->w_skipcol <= width1)
Yee Cheng Chin01ee52b2022-11-17 12:41:42 +00001171 curwin->w_wcol -= width2;
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001172 else
Yee Cheng Chin01ee52b2022-11-17 12:41:42 +00001173 curwin->w_wcol -= width2
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001174 * (((curwin->w_skipcol - width1) / width2) + 1);
Yee Cheng Chin01ee52b2022-11-17 12:41:42 +00001175
Bram Moolenaar4b6172e2022-10-13 20:23:28 +01001176 did_sub_skipcol = TRUE;
1177 }
Bram Moolenaar2fbabd22022-10-12 19:53:38 +01001178
Bram Moolenaar85a20022019-12-21 18:25:54 +01001179 // long line wrapping, adjust curwin->w_wrow
Bram Moolenaar02631462017-09-22 15:20:32 +02001180 if (curwin->w_wcol >= curwin->w_width)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001181 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01001182 // this same formula is used in validate_cursor_col()
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001183 n = (curwin->w_wcol - curwin->w_width) / width2 + 1;
1184 curwin->w_wcol -= n * width2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001185 curwin->w_wrow += n;
1186
1187#ifdef FEAT_LINEBREAK
Bram Moolenaar85a20022019-12-21 18:25:54 +01001188 // When cursor wraps to first char of next line in Insert
1189 // mode, the 'showbreak' string isn't shown, backup to first
1190 // column
Bram Moolenaar4b6172e2022-10-13 20:23:28 +01001191 char_u *sbr = get_showbreak_value(curwin);
Bram Moolenaaree857022019-11-09 23:26:40 +01001192 if (*sbr && *ml_get_cursor() == NUL
=?UTF-8?q?Dundar=20G=C3=B6c?=dfa5e462021-10-02 11:26:51 +01001193 && curwin->w_wcol == vim_strsize(sbr))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001194 curwin->w_wcol = 0;
1195#endif
1196 }
1197 }
1198
Bram Moolenaar85a20022019-12-21 18:25:54 +01001199 // No line wrapping: compute curwin->w_leftcol if scrolling is on and line
1200 // is not folded.
1201 // If scrolling is off, curwin->w_leftcol is assumed to be 0
Bram Moolenaar70b2a562012-01-10 22:26:17 +01001202 else if (may_scroll
Bram Moolenaar071d4272004-06-13 20:20:40 +00001203#ifdef FEAT_FOLDING
1204 && !curwin->w_cline_folded
1205#endif
1206 )
1207 {
Bram Moolenaarc9dc03f2022-09-12 17:51:07 +01001208#ifdef FEAT_PROP_POPUP
1209 if (curwin->w_virtcol_first_char > 0)
1210 {
1211 int cols = (curwin->w_width - extra);
1212 int rows = cols > 0 ? curwin->w_virtcol_first_char / cols : 1;
1213
1214 // each "above" text prop shifts the text one row down
1215 curwin->w_wrow += rows;
1216 curwin->w_wcol -= rows * cols;
1217 endcol -= rows * cols;
1218 curwin->w_cline_height = rows + 1;
1219 }
1220#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00001221 /*
1222 * If Cursor is left of the screen, scroll rightwards.
1223 * If Cursor is right of the screen, scroll leftwards
1224 * If we get closer to the edge than 'sidescrolloff', scroll a little
1225 * extra
1226 */
Bram Moolenaar375e3392019-01-31 18:26:10 +01001227 off_left = (int)startcol - (int)curwin->w_leftcol - siso;
Bram Moolenaar02631462017-09-22 15:20:32 +02001228 off_right = (int)endcol - (int)(curwin->w_leftcol + curwin->w_width
Bram Moolenaar375e3392019-01-31 18:26:10 +01001229 - siso) + 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001230 if (off_left < 0 || off_right > 0)
1231 {
1232 if (off_left < 0)
1233 diff = -off_left;
1234 else
1235 diff = off_right;
1236
Bram Moolenaar85a20022019-12-21 18:25:54 +01001237 // When far off or not enough room on either side, put cursor in
1238 // middle of window.
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001239 if (p_ss == 0 || diff >= width1 / 2 || off_right >= off_left)
1240 new_leftcol = curwin->w_wcol - extra - width1 / 2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001241 else
1242 {
1243 if (diff < p_ss)
1244 diff = p_ss;
1245 if (off_left < 0)
1246 new_leftcol = curwin->w_leftcol - diff;
1247 else
1248 new_leftcol = curwin->w_leftcol + diff;
1249 }
1250 if (new_leftcol < 0)
1251 new_leftcol = 0;
1252 if (new_leftcol != (int)curwin->w_leftcol)
1253 {
1254 curwin->w_leftcol = new_leftcol;
Bram Moolenaar85a20022019-12-21 18:25:54 +01001255 // screen has to be redrawn with new curwin->w_leftcol
Bram Moolenaara4d158b2022-08-14 14:17:45 +01001256 redraw_later(UPD_NOT_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001257 }
1258 }
1259 curwin->w_wcol -= curwin->w_leftcol;
1260 }
1261 else if (curwin->w_wcol > (int)curwin->w_leftcol)
1262 curwin->w_wcol -= curwin->w_leftcol;
1263 else
1264 curwin->w_wcol = 0;
1265
1266#ifdef FEAT_DIFF
Bram Moolenaar85a20022019-12-21 18:25:54 +01001267 // Skip over filler lines. At the top use w_topfill, there
1268 // may be some filler lines above the window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001269 if (curwin->w_cursor.lnum == curwin->w_topline)
1270 curwin->w_wrow += curwin->w_topfill;
1271 else
1272 curwin->w_wrow += diff_check_fill(curwin, curwin->w_cursor.lnum);
1273#endif
1274
1275 prev_skipcol = curwin->w_skipcol;
1276
1277 p_lines = 0;
Bram Moolenaar375e3392019-01-31 18:26:10 +01001278
Bram Moolenaar071d4272004-06-13 20:20:40 +00001279 if ((curwin->w_wrow >= curwin->w_height
1280 || ((prev_skipcol > 0
Bram Moolenaar375e3392019-01-31 18:26:10 +01001281 || curwin->w_wrow + so >= curwin->w_height)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001282 && (p_lines =
1283#ifdef FEAT_DIFF
1284 plines_win_nofill
1285#else
1286 plines_win
1287#endif
1288 (curwin, curwin->w_cursor.lnum, FALSE))
1289 - 1 >= curwin->w_height))
1290 && curwin->w_height != 0
1291 && curwin->w_cursor.lnum == curwin->w_topline
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001292 && width2 > 0
Bram Moolenaar4033c552017-09-16 20:54:51 +02001293 && curwin->w_width != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001294 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01001295 // Cursor past end of screen. Happens with a single line that does
1296 // not fit on screen. Find a skipcol to show the text around the
1297 // cursor. Avoid scrolling all the time. compute value of "extra":
1298 // 1: Less than 'scrolloff' lines above
1299 // 2: Less than 'scrolloff' lines below
1300 // 3: both of them
Bram Moolenaar071d4272004-06-13 20:20:40 +00001301 extra = 0;
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001302 if (curwin->w_skipcol + so * width2 > curwin->w_virtcol)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001303 extra = 1;
Bram Moolenaar85a20022019-12-21 18:25:54 +01001304 // Compute last display line of the buffer line that we want at the
1305 // bottom of the window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001306 if (p_lines == 0)
1307 p_lines = plines_win(curwin, curwin->w_cursor.lnum, FALSE);
1308 --p_lines;
Bram Moolenaar375e3392019-01-31 18:26:10 +01001309 if (p_lines > curwin->w_wrow + so)
1310 n = curwin->w_wrow + so;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001311 else
1312 n = p_lines;
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001313 if ((colnr_T)n >= curwin->w_height + curwin->w_skipcol / width2 - so)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001314 extra += 2;
1315
Bram Moolenaar4b6172e2022-10-13 20:23:28 +01001316 if (extra == 3 || curwin->w_height <= so * 2)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001317 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01001318 // not enough room for 'scrolloff', put cursor in the middle
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001319 n = curwin->w_virtcol / width2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001320 if (n > curwin->w_height / 2)
1321 n -= curwin->w_height / 2;
1322 else
1323 n = 0;
Bram Moolenaar85a20022019-12-21 18:25:54 +01001324 // don't skip more than necessary
Bram Moolenaar071d4272004-06-13 20:20:40 +00001325 if (n > p_lines - curwin->w_height + 1)
1326 n = p_lines - curwin->w_height + 1;
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001327 curwin->w_skipcol = n * width2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001328 }
1329 else if (extra == 1)
1330 {
Dominique Pelleaf4a61a2021-12-27 17:21:41 +00001331 // less than 'scrolloff' lines above, decrease skipcol
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001332 extra = (curwin->w_skipcol + so * width2 - curwin->w_virtcol
1333 + width2 - 1) / width2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001334 if (extra > 0)
1335 {
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001336 if ((colnr_T)(extra * width2) > curwin->w_skipcol)
1337 extra = curwin->w_skipcol / width2;
1338 curwin->w_skipcol -= extra * width2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001339 }
1340 }
1341 else if (extra == 2)
1342 {
Dominique Pelleaf4a61a2021-12-27 17:21:41 +00001343 // less than 'scrolloff' lines below, increase skipcol
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001344 endcol = (n - curwin->w_height + 1) * width2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001345 while (endcol > curwin->w_virtcol)
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001346 endcol -= width2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001347 if (endcol > curwin->w_skipcol)
1348 curwin->w_skipcol = endcol;
1349 }
1350
Bram Moolenaar4b6172e2022-10-13 20:23:28 +01001351 // adjust w_wrow for the changed w_skipcol
1352 if (did_sub_skipcol)
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001353 curwin->w_wrow -= (curwin->w_skipcol - prev_skipcol) / width2;
Bram Moolenaar4b6172e2022-10-13 20:23:28 +01001354 else
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001355 curwin->w_wrow -= curwin->w_skipcol / width2;
Bram Moolenaar4b6172e2022-10-13 20:23:28 +01001356
Bram Moolenaar071d4272004-06-13 20:20:40 +00001357 if (curwin->w_wrow >= curwin->w_height)
1358 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01001359 // small window, make sure cursor is in it
Bram Moolenaar071d4272004-06-13 20:20:40 +00001360 extra = curwin->w_wrow - curwin->w_height + 1;
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001361 curwin->w_skipcol += extra * width2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001362 curwin->w_wrow -= extra;
1363 }
1364
Bram Moolenaar856c5d22022-10-13 21:54:28 +01001365 extra = ((int)prev_skipcol - (int)curwin->w_skipcol) / width2;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001366 if (extra > 0)
1367 win_ins_lines(curwin, 0, extra, FALSE, FALSE);
1368 else if (extra < 0)
Bram Moolenaarcfce7172017-08-17 20:31:48 +02001369 win_del_lines(curwin, 0, -extra, FALSE, FALSE, 0);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001370 }
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001371 else if (!curwin->w_p_sms)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001372 curwin->w_skipcol = 0;
1373 if (prev_skipcol != curwin->w_skipcol)
Bram Moolenaarf32fb932022-11-17 11:34:38 +00001374 redraw_later(UPD_SOME_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001375
Bram Moolenaar2b48ad52006-03-12 21:56:11 +00001376#ifdef FEAT_SYN_HL
zeertzjq3e559cd2022-03-27 19:26:55 +01001377 redraw_for_cursorcolumn(curwin);
Bram Moolenaarb6798752014-03-27 12:11:48 +01001378#endif
Bram Moolenaare52e0c82020-02-28 22:20:10 +01001379#if defined(FEAT_PROP_POPUP) && defined(FEAT_TERMINAL)
1380 if (popup_is_popup(curwin) && curbuf->b_term != NULL)
1381 {
1382 curwin->w_wrow += popup_top_extra(curwin);
1383 curwin->w_wcol += popup_left_extra(curwin);
Bram Moolenaar6a076442020-11-15 20:32:58 +01001384 curwin->w_flags |= WFLAG_WCOL_OFF_ADDED + WFLAG_WROW_OFF_ADDED;
Bram Moolenaare52e0c82020-02-28 22:20:10 +01001385 }
Bram Moolenaar6a076442020-11-15 20:32:58 +01001386 else
1387 curwin->w_flags &= ~(WFLAG_WCOL_OFF_ADDED + WFLAG_WROW_OFF_ADDED);
Bram Moolenaare52e0c82020-02-28 22:20:10 +01001388#endif
Bram Moolenaar2b48ad52006-03-12 21:56:11 +00001389
Bram Moolenaar2fbabd22022-10-12 19:53:38 +01001390 // now w_leftcol and w_skipcol are valid, avoid check_cursor_moved()
1391 // thinking otherwise
Bram Moolenaar08f23632019-11-16 14:19:33 +01001392 curwin->w_valid_leftcol = curwin->w_leftcol;
Bram Moolenaar2fbabd22022-10-12 19:53:38 +01001393 curwin->w_valid_skipcol = curwin->w_skipcol;
Bram Moolenaar08f23632019-11-16 14:19:33 +01001394
Bram Moolenaar071d4272004-06-13 20:20:40 +00001395 curwin->w_valid |= VALID_WCOL|VALID_WROW|VALID_VIRTCOL;
1396}
1397
Bram Moolenaar05ad5ff2019-11-30 22:48:27 +01001398#if (defined(FEAT_EVAL) || defined(FEAT_PROP_POPUP)) || defined(PROTO)
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001399/*
1400 * Compute the screen position of text character at "pos" in window "wp"
1401 * The resulting values are one-based, zero when character is not visible.
1402 */
Bram Moolenaar12034e22019-08-25 22:25:02 +02001403 void
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001404textpos2screenpos(
1405 win_T *wp,
1406 pos_T *pos,
1407 int *rowp, // screen row
1408 int *scolp, // start screen column
1409 int *ccolp, // cursor screen column
1410 int *ecolp) // end screen column
1411{
1412 colnr_T scol = 0, ccol = 0, ecol = 0;
1413 int row = 0;
1414 int rowoff = 0;
1415 colnr_T coloff = 0;
1416
Bram Moolenaar189663b2021-07-21 18:04:56 +02001417 if (pos->lnum >= wp->w_topline && pos->lnum <= wp->w_botline)
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001418 {
Bram Moolenaar4556a2e2022-02-15 13:40:17 +00001419 colnr_T off;
1420 colnr_T col;
1421 int width;
1422 linenr_T lnum = pos->lnum;
1423#ifdef FEAT_FOLDING
1424 int is_folded;
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001425
Bram Moolenaar4556a2e2022-02-15 13:40:17 +00001426 is_folded = hasFoldingWin(wp, lnum, &lnum, NULL, TRUE, NULL);
1427#endif
1428 row = plines_m_win(wp, wp->w_topline, lnum - 1) + 1;
1429#ifdef FEAT_FOLDING
1430 if (is_folded)
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001431 {
Bram Moolenaar7924a172022-01-24 16:15:15 +00001432 row += W_WINROW(wp);
Bram Moolenaar4556a2e2022-02-15 13:40:17 +00001433 coloff = wp->w_wincol + 1;
Bram Moolenaar7924a172022-01-24 16:15:15 +00001434 }
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001435 else
Bram Moolenaar4556a2e2022-02-15 13:40:17 +00001436#endif
1437 {
1438 getvcol(wp, pos, &scol, &ccol, &ecol);
1439
1440 // similar to what is done in validate_cursor_col()
1441 col = scol;
1442 off = win_col_off(wp);
1443 col += off;
1444 width = wp->w_width - off + win_col_off2(wp);
1445
1446 // long line wrapping, adjust row
1447 if (wp->w_p_wrap
1448 && col >= (colnr_T)wp->w_width
1449 && width > 0)
1450 {
1451 // use same formula as what is used in curs_columns()
1452 rowoff = ((col - wp->w_width) / width + 1);
1453 col -= rowoff * width;
1454 }
1455 col -= wp->w_leftcol;
1456 if (col >= wp->w_width)
1457 col = -1;
1458 if (col >= 0 && row + rowoff <= wp->w_height)
1459 {
1460 coloff = col - scol + wp->w_wincol + 1;
1461 row += W_WINROW(wp);
1462 }
1463 else
1464 // character is left, right or below of the window
1465 row = rowoff = scol = ccol = ecol = 0;
1466 }
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001467 }
Bram Moolenaar7924a172022-01-24 16:15:15 +00001468 *rowp = row + rowoff;
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001469 *scolp = scol + coloff;
1470 *ccolp = ccol + coloff;
1471 *ecolp = ecol + coloff;
1472}
Bram Moolenaar12034e22019-08-25 22:25:02 +02001473#endif
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001474
Bram Moolenaar12034e22019-08-25 22:25:02 +02001475#if defined(FEAT_EVAL) || defined(PROTO)
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001476/*
1477 * "screenpos({winid}, {lnum}, {col})" function
1478 */
1479 void
1480f_screenpos(typval_T *argvars UNUSED, typval_T *rettv)
1481{
1482 dict_T *dict;
1483 win_T *wp;
1484 pos_T pos;
1485 int row = 0;
1486 int scol = 0, ccol = 0, ecol = 0;
1487
Bram Moolenaar93a10962022-06-16 11:42:09 +01001488 if (rettv_dict_alloc(rettv) == FAIL)
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001489 return;
1490 dict = rettv->vval.v_dict;
1491
Yegappan Lakshmanan4490ec42021-07-27 22:00:44 +02001492 if (in_vim9script()
1493 && (check_for_number_arg(argvars, 0) == FAIL
1494 || check_for_number_arg(argvars, 1) == FAIL
1495 || check_for_number_arg(argvars, 2) == FAIL))
1496 return;
1497
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001498 wp = find_win_by_nr_or_id(&argvars[0]);
1499 if (wp == NULL)
1500 return;
1501
1502 pos.lnum = tv_get_number(&argvars[1]);
Bram Moolenaar99d19432022-12-05 16:23:24 +00001503 if (pos.lnum > wp->w_buffer->b_ml.ml_line_count)
1504 {
1505 semsg(_(e_invalid_line_number_nr), pos.lnum);
1506 return;
1507 }
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001508 pos.col = tv_get_number(&argvars[2]) - 1;
1509 pos.coladd = 0;
1510 textpos2screenpos(wp, &pos, &row, &scol, &ccol, &ecol);
1511
1512 dict_add_number(dict, "row", row);
1513 dict_add_number(dict, "col", scol);
1514 dict_add_number(dict, "curscol", ccol);
1515 dict_add_number(dict, "endcol", ecol);
1516}
Bram Moolenaar5a6ec102022-05-27 21:58:00 +01001517
1518/*
1519 * "virtcol2col({winid}, {lnum}, {col})" function
1520 */
1521 void
1522f_virtcol2col(typval_T *argvars UNUSED, typval_T *rettv)
1523{
1524 win_T *wp;
1525 linenr_T lnum;
1526 int screencol;
1527 int error = FALSE;
1528
1529 rettv->vval.v_number = -1;
1530
1531 if (check_for_number_arg(argvars, 0) == FAIL
1532 || check_for_number_arg(argvars, 1) == FAIL
1533 || check_for_number_arg(argvars, 2) == FAIL)
1534 return;
1535
1536 wp = find_win_by_nr_or_id(&argvars[0]);
1537 if (wp == NULL)
1538 return;
1539
1540 lnum = tv_get_number_chk(&argvars[1], &error);
1541 if (error || lnum < 0 || lnum > wp->w_buffer->b_ml.ml_line_count)
1542 return;
1543
1544 screencol = tv_get_number_chk(&argvars[2], &error);
1545 if (error || screencol < 0)
1546 return;
1547
1548 rettv->vval.v_number = vcol2col(wp, lnum, screencol);
1549}
Bram Moolenaarb3d17a22019-07-07 18:28:14 +02001550#endif
1551
Bram Moolenaar071d4272004-06-13 20:20:40 +00001552/*
1553 * Scroll the current window down by "line_count" logical lines. "CTRL-Y"
1554 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001555 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01001556scrolldown(
1557 long line_count,
Bram Moolenaar85a20022019-12-21 18:25:54 +01001558 int byfold UNUSED) // TRUE: count a closed fold as one line
Bram Moolenaar071d4272004-06-13 20:20:40 +00001559{
Bram Moolenaar85a20022019-12-21 18:25:54 +01001560 long done = 0; // total # of physical lines done
Bram Moolenaar071d4272004-06-13 20:20:40 +00001561 int wrow;
1562 int moved = FALSE;
Bram Moolenaar1a58e1d2022-10-06 13:09:17 +01001563 int do_sms = curwin->w_p_wrap && curwin->w_p_sms;
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001564 int width1 = 0;
1565 int width2 = 0;
1566
Bram Moolenaar1a58e1d2022-10-06 13:09:17 +01001567 if (do_sms)
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001568 {
1569 width1 = curwin->w_width - curwin_col_off();
Bram Moolenaar6b2d4ff2022-10-03 14:06:02 +01001570 width2 = width1 + curwin_col_off2();
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001571 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001572
1573#ifdef FEAT_FOLDING
1574 linenr_T first;
1575
Bram Moolenaar85a20022019-12-21 18:25:54 +01001576 // Make sure w_topline is at the first of a sequence of folded lines.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001577 (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
1578#endif
Bram Moolenaar85a20022019-12-21 18:25:54 +01001579 validate_cursor(); // w_wrow needs to be valid
Bram Moolenaar1a58e1d2022-10-06 13:09:17 +01001580 for (int todo = line_count; todo > 0; --todo)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001581 {
1582#ifdef FEAT_DIFF
Bram Moolenaarfa316dd2009-11-03 15:23:14 +00001583 if (curwin->w_topfill < diff_check(curwin, curwin->w_topline)
1584 && curwin->w_topfill < curwin->w_height - 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001585 {
1586 ++curwin->w_topfill;
1587 ++done;
1588 }
1589 else
1590#endif
1591 {
Bram Moolenaar8df97482022-10-03 12:11:13 +01001592 // break when at the very top
1593 if (curwin->w_topline == 1
Bram Moolenaar1a58e1d2022-10-06 13:09:17 +01001594 && (!do_sms || curwin->w_skipcol < width1))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001595 break;
Bram Moolenaar1a58e1d2022-10-06 13:09:17 +01001596 if (do_sms && curwin->w_skipcol >= width1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001597 {
Bram Moolenaar8df97482022-10-03 12:11:13 +01001598 // scroll a screen line down
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001599 if (curwin->w_skipcol >= width1 + width2)
1600 curwin->w_skipcol -= width2;
1601 else
1602 curwin->w_skipcol -= width1;
1603 redraw_later(UPD_NOT_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00001604 ++done;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001605 }
1606 else
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001607 {
Bram Moolenaar8df97482022-10-03 12:11:13 +01001608 // scroll a text line down
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001609 --curwin->w_topline;
1610 curwin->w_skipcol = 0;
1611#ifdef FEAT_DIFF
1612 curwin->w_topfill = 0;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001613#endif
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001614#ifdef FEAT_FOLDING
1615 // A sequence of folded lines only counts for one logical line
1616 if (hasFolding(curwin->w_topline, &first, NULL))
1617 {
1618 ++done;
1619 if (!byfold)
Bram Moolenaar1a58e1d2022-10-06 13:09:17 +01001620 todo -= curwin->w_topline - first - 1;
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001621 curwin->w_botline -= curwin->w_topline - first;
1622 curwin->w_topline = first;
1623 }
1624 else
1625#endif
Bram Moolenaar1a58e1d2022-10-06 13:09:17 +01001626 if (do_sms)
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001627 {
1628 int size = win_linetabsize(curwin, curwin->w_topline,
1629 ml_get(curwin->w_topline), (colnr_T)MAXCOL);
1630 if (size > width1)
1631 {
1632 curwin->w_skipcol = width1;
1633 size -= width1;
1634 redraw_later(UPD_NOT_VALID);
1635 }
1636 while (size > width2)
1637 {
1638 curwin->w_skipcol += width2;
1639 size -= width2;
1640 }
1641 ++done;
1642 }
1643 else
1644 done += PLINES_NOFILL(curwin->w_topline);
1645 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001646 }
Bram Moolenaar85a20022019-12-21 18:25:54 +01001647 --curwin->w_botline; // approximate w_botline
Bram Moolenaar071d4272004-06-13 20:20:40 +00001648 invalidate_botline();
1649 }
Bram Moolenaar85a20022019-12-21 18:25:54 +01001650 curwin->w_wrow += done; // keep w_wrow updated
1651 curwin->w_cline_row += done; // keep w_cline_row updated
Bram Moolenaar071d4272004-06-13 20:20:40 +00001652
1653#ifdef FEAT_DIFF
1654 if (curwin->w_cursor.lnum == curwin->w_topline)
1655 curwin->w_cline_row = 0;
1656 check_topfill(curwin, TRUE);
1657#endif
1658
1659 /*
1660 * Compute the row number of the last row of the cursor line
1661 * and move the cursor onto the displayed part of the window.
1662 */
1663 wrow = curwin->w_wrow;
Bram Moolenaar4033c552017-09-16 20:54:51 +02001664 if (curwin->w_p_wrap && curwin->w_width != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001665 {
1666 validate_virtcol();
1667 validate_cheight();
1668 wrow += curwin->w_cline_height - 1 -
Bram Moolenaar02631462017-09-22 15:20:32 +02001669 curwin->w_virtcol / curwin->w_width;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001670 }
1671 while (wrow >= curwin->w_height && curwin->w_cursor.lnum > 1)
1672 {
1673#ifdef FEAT_FOLDING
1674 if (hasFolding(curwin->w_cursor.lnum, &first, NULL))
1675 {
1676 --wrow;
1677 if (first == 1)
1678 curwin->w_cursor.lnum = 1;
1679 else
1680 curwin->w_cursor.lnum = first - 1;
1681 }
1682 else
1683#endif
1684 wrow -= plines(curwin->w_cursor.lnum--);
1685 curwin->w_valid &=
1686 ~(VALID_WROW|VALID_WCOL|VALID_CHEIGHT|VALID_CROW|VALID_VIRTCOL);
1687 moved = TRUE;
1688 }
1689 if (moved)
1690 {
1691#ifdef FEAT_FOLDING
Bram Moolenaar85a20022019-12-21 18:25:54 +01001692 // Move cursor to first line of closed fold.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001693 foldAdjustCursor();
1694#endif
1695 coladvance(curwin->w_curswant);
1696 }
Bram Moolenaar8cf34592022-10-08 21:13:40 +01001697
1698 if (curwin->w_cursor.lnum == curwin->w_topline && do_sms)
1699 {
Bram Moolenaarc9121f72022-10-14 20:09:04 +01001700 long so = get_scrolloff_value();
Bram Moolenaar118c2352022-10-09 17:19:27 +01001701 int scrolloff_cols = so == 0 ? 0 : width1 + (so - 1) * width2;
1702
Bram Moolenaar8cf34592022-10-08 21:13:40 +01001703 // make sure the cursor is in the visible text
1704 validate_virtcol();
Bram Moolenaar118c2352022-10-09 17:19:27 +01001705 int col = curwin->w_virtcol - curwin->w_skipcol + scrolloff_cols;
Bram Moolenaar8cf34592022-10-08 21:13:40 +01001706 int row = 0;
1707 if (col >= width1)
1708 {
1709 col -= width1;
1710 ++row;
1711 }
1712 if (col > width2)
1713 {
1714 row += col / width2;
1715 col = col % width2;
1716 }
1717 if (row >= curwin->w_height)
Bram Moolenaar118c2352022-10-09 17:19:27 +01001718 {
1719 curwin->w_curswant = curwin->w_virtcol
1720 - (row - curwin->w_height + 1) * width2;
1721 coladvance(curwin->w_curswant);
1722 }
Bram Moolenaar8cf34592022-10-08 21:13:40 +01001723 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001724}
1725
1726/*
Bram Moolenaard5337ef2022-10-20 20:15:47 +01001727 * Return TRUE if scrollup() will scroll by screen line rather than text line.
1728 */
1729 static int
1730scrolling_screenlines(int byfold UNUSED)
1731{
1732 return (curwin->w_p_wrap && curwin->w_p_sms)
1733# ifdef FEAT_FOLDING
1734 || (byfold && hasAnyFolding(curwin))
1735# endif
1736# ifdef FEAT_DIFF
1737 || curwin->w_p_diff
1738# endif
1739 ;
1740}
1741
1742/*
Bram Moolenaar071d4272004-06-13 20:20:40 +00001743 * Scroll the current window up by "line_count" logical lines. "CTRL-E"
1744 */
Bram Moolenaar071d4272004-06-13 20:20:40 +00001745 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01001746scrollup(
1747 long line_count,
Bram Moolenaar85a20022019-12-21 18:25:54 +01001748 int byfold UNUSED) // TRUE: count a closed fold as one line
Bram Moolenaar071d4272004-06-13 20:20:40 +00001749{
Bram Moolenaar1a58e1d2022-10-06 13:09:17 +01001750 int do_sms = curwin->w_p_wrap && curwin->w_p_sms;
Bram Moolenaar071d4272004-06-13 20:20:40 +00001751
Bram Moolenaard5337ef2022-10-20 20:15:47 +01001752 if (scrolling_screenlines(byfold))
Bram Moolenaar071d4272004-06-13 20:20:40 +00001753 {
Bram Moolenaar6b2d4ff2022-10-03 14:06:02 +01001754 int width1 = curwin->w_width - curwin_col_off();
1755 int width2 = width1 + curwin_col_off2();
1756 int size = 0;
1757 linenr_T prev_topline = curwin->w_topline;
1758
Bram Moolenaar1a58e1d2022-10-06 13:09:17 +01001759 if (do_sms)
Bram Moolenaarc9121f72022-10-14 20:09:04 +01001760 size = linetabsize(curwin, curwin->w_topline);
Bram Moolenaar6b2d4ff2022-10-03 14:06:02 +01001761
1762 // diff mode: first consume "topfill"
1763 // 'smoothscroll': increase "w_skipcol" until it goes over the end of
1764 // the line, then advance to the next line.
1765 // folding: count each sequence of folded lines as one logical line.
1766 for (int todo = line_count; todo > 0; --todo)
Bram Moolenaar071d4272004-06-13 20:20:40 +00001767 {
1768# ifdef FEAT_DIFF
1769 if (curwin->w_topfill > 0)
1770 --curwin->w_topfill;
1771 else
1772# endif
1773 {
Bram Moolenaar6b2d4ff2022-10-03 14:06:02 +01001774 linenr_T lnum = curwin->w_topline;
1775
Bram Moolenaar071d4272004-06-13 20:20:40 +00001776# ifdef FEAT_FOLDING
1777 if (byfold)
Bram Moolenaar6b2d4ff2022-10-03 14:06:02 +01001778 // for a closed fold: go to the last line in the fold
Bram Moolenaar071d4272004-06-13 20:20:40 +00001779 (void)hasFolding(lnum, NULL, &lnum);
1780# endif
Bram Moolenaar8cf34592022-10-08 21:13:40 +01001781 if (lnum == curwin->w_topline && do_sms)
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001782 {
Bram Moolenaar6b2d4ff2022-10-03 14:06:02 +01001783 // 'smoothscroll': increase "w_skipcol" until it goes over
1784 // the end of the line, then advance to the next line.
1785 int add = curwin->w_skipcol > 0 ? width2 : width1;
1786 curwin->w_skipcol += add;
1787 if (curwin->w_skipcol >= size)
1788 {
1789 if (lnum == curbuf->b_ml.ml_line_count)
1790 {
1791 // at the last screen line, can't scroll further
1792 curwin->w_skipcol -= add;
1793 break;
1794 }
1795 ++lnum;
1796 }
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001797 }
Bram Moolenaar6b2d4ff2022-10-03 14:06:02 +01001798 else
1799 {
1800 if (lnum >= curbuf->b_ml.ml_line_count)
1801 break;
1802 ++lnum;
1803 }
1804
1805 if (lnum > curwin->w_topline)
1806 {
1807 // approximate w_botline
1808 curwin->w_botline += lnum - curwin->w_topline;
1809 curwin->w_topline = lnum;
1810# ifdef FEAT_DIFF
1811 curwin->w_topfill = diff_check_fill(curwin, lnum);
1812# endif
1813 curwin->w_skipcol = 0;
Bram Moolenaar1a58e1d2022-10-06 13:09:17 +01001814 if (todo > 1 && do_sms)
Bram Moolenaarc9121f72022-10-14 20:09:04 +01001815 size = linetabsize(curwin, curwin->w_topline);
Bram Moolenaar6b2d4ff2022-10-03 14:06:02 +01001816 }
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001817 }
1818 }
Bram Moolenaar6b2d4ff2022-10-03 14:06:02 +01001819
Bram Moolenaarf6196f42022-10-02 21:29:55 +01001820 if (curwin->w_topline == prev_topline)
1821 // need to redraw even though w_topline didn't change
1822 redraw_later(UPD_NOT_VALID);
1823 }
1824 else
Bram Moolenaar071d4272004-06-13 20:20:40 +00001825 {
1826 curwin->w_topline += line_count;
Bram Moolenaar85a20022019-12-21 18:25:54 +01001827 curwin->w_botline += line_count; // approximate w_botline
Bram Moolenaar071d4272004-06-13 20:20:40 +00001828 }
1829
1830 if (curwin->w_topline > curbuf->b_ml.ml_line_count)
1831 curwin->w_topline = curbuf->b_ml.ml_line_count;
1832 if (curwin->w_botline > curbuf->b_ml.ml_line_count + 1)
1833 curwin->w_botline = curbuf->b_ml.ml_line_count + 1;
1834
1835#ifdef FEAT_DIFF
1836 check_topfill(curwin, FALSE);
1837#endif
1838
1839#ifdef FEAT_FOLDING
1840 if (hasAnyFolding(curwin))
Bram Moolenaar85a20022019-12-21 18:25:54 +01001841 // Make sure w_topline is at the first of a sequence of folded lines.
Bram Moolenaar071d4272004-06-13 20:20:40 +00001842 (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
1843#endif
1844
1845 curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE);
1846 if (curwin->w_cursor.lnum < curwin->w_topline)
1847 {
1848 curwin->w_cursor.lnum = curwin->w_topline;
1849 curwin->w_valid &=
1850 ~(VALID_WROW|VALID_WCOL|VALID_CHEIGHT|VALID_CROW|VALID_VIRTCOL);
1851 coladvance(curwin->w_curswant);
1852 }
Bram Moolenaar8cf34592022-10-08 21:13:40 +01001853 if (curwin->w_cursor.lnum == curwin->w_topline
1854 && do_sms && curwin->w_skipcol > 0)
1855 {
Yee Cheng Chin81ba26e2022-11-18 12:52:50 +00001856 int col_off = curwin_col_off();
1857 int col_off2 = curwin_col_off2();
1858
1859 int width1 = curwin->w_width - col_off;
1860 int width2 = width1 + col_off2;
1861 int extra2 = col_off - col_off2;
Bram Moolenaarc9121f72022-10-14 20:09:04 +01001862 long so = get_scrolloff_value();
Bram Moolenaar118c2352022-10-09 17:19:27 +01001863 int scrolloff_cols = so == 0 ? 0 : width1 + (so - 1) * width2;
Bram Moolenaarc9121f72022-10-14 20:09:04 +01001864 int space_cols = (curwin->w_height - 1) * width2;
Bram Moolenaar118c2352022-10-09 17:19:27 +01001865
Yee Cheng Chin81ba26e2022-11-18 12:52:50 +00001866 // If we have non-zero scrolloff, just ignore the <<< marker as we are
1867 // going past it anyway.
1868 int smoothscroll_overlap = scrolloff_cols != 0 ? 0 :
1869 smoothscroll_marker_overlap(extra2);
1870
Bram Moolenaar118c2352022-10-09 17:19:27 +01001871 // Make sure the cursor is in a visible part of the line, taking
1872 // 'scrolloff' into account, but using screen lines.
Bram Moolenaarc9121f72022-10-14 20:09:04 +01001873 // If there are not enough screen lines put the cursor in the middle.
1874 if (scrolloff_cols > space_cols / 2)
1875 scrolloff_cols = space_cols / 2;
Bram Moolenaar8cf34592022-10-08 21:13:40 +01001876 validate_virtcol();
Yee Cheng Chin81ba26e2022-11-18 12:52:50 +00001877 if (curwin->w_virtcol < curwin->w_skipcol
1878 + smoothscroll_overlap + scrolloff_cols)
Bram Moolenaar8cf34592022-10-08 21:13:40 +01001879 {
Bram Moolenaar8cf34592022-10-08 21:13:40 +01001880 colnr_T col = curwin->w_virtcol;
1881
1882 if (col < width1)
1883 col += width1;
Yee Cheng Chin81ba26e2022-11-18 12:52:50 +00001884 while (col < curwin->w_skipcol
1885 + smoothscroll_overlap + scrolloff_cols)
Bram Moolenaar8cf34592022-10-08 21:13:40 +01001886 col += width2;
Bram Moolenaar118c2352022-10-09 17:19:27 +01001887 curwin->w_curswant = col;
1888 coladvance(curwin->w_curswant);
Bram Moolenaar2fbabd22022-10-12 19:53:38 +01001889
1890 // validate_virtcol() marked various things as valid, but after
1891 // moving the cursor they need to be recomputed
1892 curwin->w_valid &=
1893 ~(VALID_WROW|VALID_WCOL|VALID_CHEIGHT|VALID_CROW|VALID_VIRTCOL);
Bram Moolenaar8cf34592022-10-08 21:13:40 +01001894 }
1895 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00001896}
1897
Bram Moolenaar2fbabd22022-10-12 19:53:38 +01001898/*
1899 * Called after changing the cursor column: make sure that curwin->w_skipcol is
1900 * valid for 'smoothscroll'.
1901 */
1902 void
1903adjust_skipcol(void)
1904{
1905 if (!curwin->w_p_wrap
1906 || !curwin->w_p_sms
1907 || curwin->w_cursor.lnum != curwin->w_topline)
1908 return;
1909
1910 int width1 = curwin->w_width - curwin_col_off();
1911 int width2 = width1 + curwin_col_off2();
Bram Moolenaarc9121f72022-10-14 20:09:04 +01001912 long so = get_scrolloff_value();
Bram Moolenaar2fbabd22022-10-12 19:53:38 +01001913 int scrolloff_cols = so == 0 ? 0 : width1 + (so - 1) * width2;
1914 int scrolled = FALSE;
1915
Bram Moolenaard5337ef2022-10-20 20:15:47 +01001916 validate_cheight();
Bram Moolenaarb21b8e92022-12-03 18:35:07 +00001917 if (curwin->w_cline_height == curwin->w_height
1918 // w_cline_height may be capped at w_height, check there aren't
1919 // actually more lines.
1920 && plines_win(curwin, curwin->w_cursor.lnum, FALSE)
1921 <= curwin->w_height)
Bram Moolenaarc9121f72022-10-14 20:09:04 +01001922 {
1923 // the line just fits in the window, don't scroll
Bram Moolenaarf32fb932022-11-17 11:34:38 +00001924 reset_skipcol();
Bram Moolenaarc9121f72022-10-14 20:09:04 +01001925 return;
1926 }
1927
Bram Moolenaard5337ef2022-10-20 20:15:47 +01001928 validate_virtcol();
Bram Moolenaar2fbabd22022-10-12 19:53:38 +01001929 while (curwin->w_skipcol > 0
1930 && curwin->w_virtcol < curwin->w_skipcol + 3 + scrolloff_cols)
1931 {
1932 // scroll a screen line down
1933 if (curwin->w_skipcol >= width1 + width2)
1934 curwin->w_skipcol -= width2;
1935 else
1936 curwin->w_skipcol -= width1;
1937 redraw_later(UPD_NOT_VALID);
1938 scrolled = TRUE;
1939 validate_virtcol();
1940 }
1941 if (scrolled)
1942 return; // don't scroll in the other direction now
1943
1944 int col = curwin->w_virtcol - curwin->w_skipcol + scrolloff_cols;
1945 int row = 0;
1946 if (col >= width1)
1947 {
1948 col -= width1;
1949 ++row;
1950 }
1951 if (col > width2)
1952 {
1953 row += col / width2;
1954 col = col % width2;
1955 }
1956 if (row >= curwin->w_height)
1957 {
1958 if (curwin->w_skipcol == 0)
1959 {
1960 curwin->w_skipcol += width1;
1961 --row;
1962 }
1963 if (row >= curwin->w_height)
1964 curwin->w_skipcol += (row - curwin->w_height) * width2;
1965 redraw_later(UPD_NOT_VALID);
1966 }
1967}
1968
Bram Moolenaar071d4272004-06-13 20:20:40 +00001969#ifdef FEAT_DIFF
1970/*
1971 * Don't end up with too many filler lines in the window.
1972 */
1973 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01001974check_topfill(
1975 win_T *wp,
Bram Moolenaar85a20022019-12-21 18:25:54 +01001976 int down) // when TRUE scroll down when not enough space
Bram Moolenaar071d4272004-06-13 20:20:40 +00001977{
1978 int n;
1979
1980 if (wp->w_topfill > 0)
1981 {
1982 n = plines_win_nofill(wp, wp->w_topline, TRUE);
1983 if (wp->w_topfill + n > wp->w_height)
1984 {
1985 if (down && wp->w_topline > 1)
1986 {
1987 --wp->w_topline;
1988 wp->w_topfill = 0;
1989 }
1990 else
1991 {
1992 wp->w_topfill = wp->w_height - n;
1993 if (wp->w_topfill < 0)
1994 wp->w_topfill = 0;
1995 }
1996 }
1997 }
1998}
1999
2000/*
2001 * Use as many filler lines as possible for w_topline. Make sure w_topline
2002 * is still visible.
2003 */
2004 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002005max_topfill(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002006{
2007 int n;
2008
2009 n = plines_nofill(curwin->w_topline);
2010 if (n >= curwin->w_height)
2011 curwin->w_topfill = 0;
2012 else
2013 {
2014 curwin->w_topfill = diff_check_fill(curwin, curwin->w_topline);
2015 if (curwin->w_topfill + n > curwin->w_height)
2016 curwin->w_topfill = curwin->w_height - n;
2017 }
2018}
2019#endif
2020
Bram Moolenaar071d4272004-06-13 20:20:40 +00002021/*
2022 * Scroll the screen one line down, but don't do it if it would move the
2023 * cursor off the screen.
2024 */
2025 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002026scrolldown_clamp(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002027{
2028 int end_row;
2029#ifdef FEAT_DIFF
2030 int can_fill = (curwin->w_topfill
2031 < diff_check_fill(curwin, curwin->w_topline));
2032#endif
2033
2034 if (curwin->w_topline <= 1
2035#ifdef FEAT_DIFF
2036 && !can_fill
2037#endif
2038 )
2039 return;
2040
Bram Moolenaar85a20022019-12-21 18:25:54 +01002041 validate_cursor(); // w_wrow needs to be valid
Bram Moolenaar071d4272004-06-13 20:20:40 +00002042
2043 /*
2044 * Compute the row number of the last row of the cursor line
2045 * and make sure it doesn't go off the screen. Make sure the cursor
2046 * doesn't go past 'scrolloff' lines from the screen end.
2047 */
2048 end_row = curwin->w_wrow;
2049#ifdef FEAT_DIFF
2050 if (can_fill)
2051 ++end_row;
2052 else
2053 end_row += plines_nofill(curwin->w_topline - 1);
2054#else
2055 end_row += plines(curwin->w_topline - 1);
2056#endif
Bram Moolenaar4033c552017-09-16 20:54:51 +02002057 if (curwin->w_p_wrap && curwin->w_width != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002058 {
2059 validate_cheight();
2060 validate_virtcol();
2061 end_row += curwin->w_cline_height - 1 -
Bram Moolenaar02631462017-09-22 15:20:32 +02002062 curwin->w_virtcol / curwin->w_width;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002063 }
Bram Moolenaar375e3392019-01-31 18:26:10 +01002064 if (end_row < curwin->w_height - get_scrolloff_value())
Bram Moolenaar071d4272004-06-13 20:20:40 +00002065 {
2066#ifdef FEAT_DIFF
2067 if (can_fill)
2068 {
2069 ++curwin->w_topfill;
2070 check_topfill(curwin, TRUE);
2071 }
2072 else
2073 {
2074 --curwin->w_topline;
2075 curwin->w_topfill = 0;
2076 }
2077#else
2078 --curwin->w_topline;
2079#endif
2080#ifdef FEAT_FOLDING
Bram Moolenaarcde88542015-08-11 19:14:00 +02002081 (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002082#endif
Bram Moolenaar85a20022019-12-21 18:25:54 +01002083 --curwin->w_botline; // approximate w_botline
Bram Moolenaar071d4272004-06-13 20:20:40 +00002084 curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE);
2085 }
2086}
2087
2088/*
2089 * Scroll the screen one line up, but don't do it if it would move the cursor
2090 * off the screen.
2091 */
2092 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002093scrollup_clamp(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002094{
2095 int start_row;
2096
2097 if (curwin->w_topline == curbuf->b_ml.ml_line_count
2098#ifdef FEAT_DIFF
2099 && curwin->w_topfill == 0
2100#endif
2101 )
2102 return;
2103
Bram Moolenaar85a20022019-12-21 18:25:54 +01002104 validate_cursor(); // w_wrow needs to be valid
Bram Moolenaar071d4272004-06-13 20:20:40 +00002105
2106 /*
2107 * Compute the row number of the first row of the cursor line
2108 * and make sure it doesn't go off the screen. Make sure the cursor
2109 * doesn't go before 'scrolloff' lines from the screen start.
2110 */
2111#ifdef FEAT_DIFF
2112 start_row = curwin->w_wrow - plines_nofill(curwin->w_topline)
2113 - curwin->w_topfill;
2114#else
2115 start_row = curwin->w_wrow - plines(curwin->w_topline);
2116#endif
Bram Moolenaar4033c552017-09-16 20:54:51 +02002117 if (curwin->w_p_wrap && curwin->w_width != 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002118 {
2119 validate_virtcol();
Bram Moolenaar02631462017-09-22 15:20:32 +02002120 start_row -= curwin->w_virtcol / curwin->w_width;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002121 }
Bram Moolenaar375e3392019-01-31 18:26:10 +01002122 if (start_row >= get_scrolloff_value())
Bram Moolenaar071d4272004-06-13 20:20:40 +00002123 {
2124#ifdef FEAT_DIFF
2125 if (curwin->w_topfill > 0)
2126 --curwin->w_topfill;
2127 else
2128#endif
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002129 {
2130#ifdef FEAT_FOLDING
2131 (void)hasFolding(curwin->w_topline, NULL, &curwin->w_topline);
2132#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002133 ++curwin->w_topline;
Bram Moolenaar293ee4d2004-12-09 21:34:53 +00002134 }
Bram Moolenaar85a20022019-12-21 18:25:54 +01002135 ++curwin->w_botline; // approximate w_botline
Bram Moolenaar071d4272004-06-13 20:20:40 +00002136 curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE);
2137 }
2138}
Bram Moolenaar071d4272004-06-13 20:20:40 +00002139
2140/*
2141 * Add one line above "lp->lnum". This can be a filler line, a closed fold or
2142 * a (wrapped) text line. Uses and sets "lp->fill".
2143 * Returns the height of the added line in "lp->height".
Bram Moolenaarbacd9da2010-02-17 18:20:37 +01002144 * Lines above the first one are incredibly high: MAXCOL.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002145 */
2146 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002147topline_back(lineoff_T *lp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002148{
2149#ifdef FEAT_DIFF
2150 if (lp->fill < diff_check_fill(curwin, lp->lnum))
2151 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01002152 // Add a filler line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002153 ++lp->fill;
2154 lp->height = 1;
2155 }
2156 else
2157#endif
2158 {
2159 --lp->lnum;
2160#ifdef FEAT_DIFF
2161 lp->fill = 0;
2162#endif
2163 if (lp->lnum < 1)
2164 lp->height = MAXCOL;
2165 else
2166#ifdef FEAT_FOLDING
2167 if (hasFolding(lp->lnum, &lp->lnum, NULL))
Bram Moolenaar85a20022019-12-21 18:25:54 +01002168 // Add a closed fold
Bram Moolenaar071d4272004-06-13 20:20:40 +00002169 lp->height = 1;
2170 else
2171#endif
Bram Moolenaar43335ea2015-09-09 20:59:37 +02002172 lp->height = PLINES_NOFILL(lp->lnum);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002173 }
2174}
2175
2176/*
2177 * Add one line below "lp->lnum". This can be a filler line, a closed fold or
2178 * a (wrapped) text line. Uses and sets "lp->fill".
2179 * Returns the height of the added line in "lp->height".
2180 * Lines below the last one are incredibly high.
2181 */
2182 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002183botline_forw(lineoff_T *lp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002184{
2185#ifdef FEAT_DIFF
2186 if (lp->fill < diff_check_fill(curwin, lp->lnum + 1))
2187 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01002188 // Add a filler line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002189 ++lp->fill;
2190 lp->height = 1;
2191 }
2192 else
2193#endif
2194 {
2195 ++lp->lnum;
2196#ifdef FEAT_DIFF
2197 lp->fill = 0;
2198#endif
2199 if (lp->lnum > curbuf->b_ml.ml_line_count)
2200 lp->height = MAXCOL;
2201 else
2202#ifdef FEAT_FOLDING
2203 if (hasFolding(lp->lnum, NULL, &lp->lnum))
Bram Moolenaar85a20022019-12-21 18:25:54 +01002204 // Add a closed fold
Bram Moolenaar071d4272004-06-13 20:20:40 +00002205 lp->height = 1;
2206 else
2207#endif
Bram Moolenaar43335ea2015-09-09 20:59:37 +02002208 lp->height = PLINES_NOFILL(lp->lnum);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002209 }
2210}
2211
2212#ifdef FEAT_DIFF
2213/*
2214 * Switch from including filler lines below lp->lnum to including filler
2215 * lines above loff.lnum + 1. This keeps pointing to the same line.
2216 * When there are no filler lines nothing changes.
2217 */
2218 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002219botline_topline(lineoff_T *lp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002220{
2221 if (lp->fill > 0)
2222 {
2223 ++lp->lnum;
2224 lp->fill = diff_check_fill(curwin, lp->lnum) - lp->fill + 1;
2225 }
2226}
2227
2228/*
2229 * Switch from including filler lines above lp->lnum to including filler
2230 * lines below loff.lnum - 1. This keeps pointing to the same line.
2231 * When there are no filler lines nothing changes.
2232 */
2233 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002234topline_botline(lineoff_T *lp)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002235{
2236 if (lp->fill > 0)
2237 {
2238 lp->fill = diff_check_fill(curwin, lp->lnum) - lp->fill + 1;
2239 --lp->lnum;
2240 }
2241}
2242#endif
2243
2244/*
2245 * Recompute topline to put the cursor at the top of the window.
2246 * Scroll at least "min_scroll" lines.
2247 * If "always" is TRUE, always set topline (for "zt").
2248 */
2249 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002250scroll_cursor_top(int min_scroll, int always)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002251{
2252 int scrolled = 0;
2253 int extra = 0;
2254 int used;
2255 int i;
Bram Moolenaar85a20022019-12-21 18:25:54 +01002256 linenr_T top; // just above displayed lines
2257 linenr_T bot; // just below displayed lines
Bram Moolenaar071d4272004-06-13 20:20:40 +00002258 linenr_T old_topline = curwin->w_topline;
Bram Moolenaar46b54742022-10-06 15:46:49 +01002259 int old_skipcol = curwin->w_skipcol;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002260#ifdef FEAT_DIFF
2261 linenr_T old_topfill = curwin->w_topfill;
2262#endif
2263 linenr_T new_topline;
Bram Moolenaar375e3392019-01-31 18:26:10 +01002264 int off = get_scrolloff_value();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002265
Bram Moolenaar071d4272004-06-13 20:20:40 +00002266 if (mouse_dragging > 0)
2267 off = mouse_dragging - 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002268
2269 /*
2270 * Decrease topline until:
2271 * - it has become 1
2272 * - (part of) the cursor line is moved off the screen or
2273 * - moved at least 'scrolljump' lines and
2274 * - at least 'scrolloff' lines above and below the cursor
2275 */
2276 validate_cheight();
Bram Moolenaar85a20022019-12-21 18:25:54 +01002277 used = curwin->w_cline_height; // includes filler lines above
Bram Moolenaar071d4272004-06-13 20:20:40 +00002278 if (curwin->w_cursor.lnum < curwin->w_topline)
2279 scrolled = used;
2280
2281#ifdef FEAT_FOLDING
2282 if (hasFolding(curwin->w_cursor.lnum, &top, &bot))
2283 {
2284 --top;
2285 ++bot;
2286 }
2287 else
2288#endif
2289 {
2290 top = curwin->w_cursor.lnum - 1;
2291 bot = curwin->w_cursor.lnum + 1;
2292 }
2293 new_topline = top + 1;
2294
2295#ifdef FEAT_DIFF
Bram Moolenaar85a20022019-12-21 18:25:54 +01002296 // "used" already contains the number of filler lines above, don't add it
2297 // again.
2298 // Hide filler lines above cursor line by adding them to "extra".
Bram Moolenaara09a2c52015-09-08 17:31:59 +02002299 extra += diff_check_fill(curwin, curwin->w_cursor.lnum);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002300#endif
2301
2302 /*
2303 * Check if the lines from "top" to "bot" fit in the window. If they do,
2304 * set new_topline and advance "top" and "bot" to include more lines.
2305 */
2306 while (top > 0)
2307 {
2308#ifdef FEAT_FOLDING
2309 if (hasFolding(top, &top, NULL))
Bram Moolenaar85a20022019-12-21 18:25:54 +01002310 // count one logical line for a sequence of folded lines
Bram Moolenaar071d4272004-06-13 20:20:40 +00002311 i = 1;
2312 else
2313#endif
Bram Moolenaar43335ea2015-09-09 20:59:37 +02002314 i = PLINES_NOFILL(top);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002315 used += i;
2316 if (extra + i <= off && bot < curbuf->b_ml.ml_line_count)
2317 {
2318#ifdef FEAT_FOLDING
2319 if (hasFolding(bot, NULL, &bot))
Bram Moolenaar85a20022019-12-21 18:25:54 +01002320 // count one logical line for a sequence of folded lines
Bram Moolenaar071d4272004-06-13 20:20:40 +00002321 ++used;
2322 else
2323#endif
2324 used += plines(bot);
2325 }
2326 if (used > curwin->w_height)
2327 break;
2328 if (top < curwin->w_topline)
2329 scrolled += i;
2330
2331 /*
2332 * If scrolling is needed, scroll at least 'sj' lines.
2333 */
2334 if ((new_topline >= curwin->w_topline || scrolled > min_scroll)
2335 && extra >= off)
2336 break;
2337
2338 extra += i;
2339 new_topline = top;
2340 --top;
2341 ++bot;
2342 }
2343
2344 /*
2345 * If we don't have enough space, put cursor in the middle.
2346 * This makes sure we get the same position when using "k" and "j"
2347 * in a small window.
2348 */
2349 if (used > curwin->w_height)
2350 scroll_cursor_halfway(FALSE);
2351 else
2352 {
2353 /*
2354 * If "always" is FALSE, only adjust topline to a lower value, higher
Bram Moolenaar1b73edd2022-12-03 11:51:54 +00002355 * value may happen with wrapping lines.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002356 */
2357 if (new_topline < curwin->w_topline || always)
2358 curwin->w_topline = new_topline;
2359 if (curwin->w_topline > curwin->w_cursor.lnum)
2360 curwin->w_topline = curwin->w_cursor.lnum;
2361#ifdef FEAT_DIFF
2362 curwin->w_topfill = diff_check_fill(curwin, curwin->w_topline);
2363 if (curwin->w_topfill > 0 && extra > off)
2364 {
2365 curwin->w_topfill -= extra - off;
2366 if (curwin->w_topfill < 0)
2367 curwin->w_topfill = 0;
2368 }
2369 check_topfill(curwin, FALSE);
2370#endif
Bram Moolenaar46b54742022-10-06 15:46:49 +01002371 // TODO: if the line doesn't fit may optimize w_skipcol
Bram Moolenaar1b73edd2022-12-03 11:51:54 +00002372 if (curwin->w_topline == curwin->w_cursor.lnum
2373 && curwin->w_skipcol >= curwin->w_cursor.col)
Bram Moolenaarf32fb932022-11-17 11:34:38 +00002374 reset_skipcol();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002375 if (curwin->w_topline != old_topline
Bram Moolenaar46b54742022-10-06 15:46:49 +01002376 || curwin->w_skipcol != old_skipcol
Bram Moolenaar071d4272004-06-13 20:20:40 +00002377#ifdef FEAT_DIFF
2378 || curwin->w_topfill != old_topfill
2379#endif
2380 )
2381 curwin->w_valid &=
2382 ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
2383 curwin->w_valid |= VALID_TOPLINE;
2384 }
2385}
2386
2387/*
2388 * Set w_empty_rows and w_filler_rows for window "wp", having used up "used"
2389 * screen lines for text lines.
2390 */
2391 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002392set_empty_rows(win_T *wp, int used)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002393{
2394#ifdef FEAT_DIFF
2395 wp->w_filler_rows = 0;
2396#endif
2397 if (used == 0)
Bram Moolenaar85a20022019-12-21 18:25:54 +01002398 wp->w_empty_rows = 0; // single line that doesn't fit
Bram Moolenaar071d4272004-06-13 20:20:40 +00002399 else
2400 {
2401 wp->w_empty_rows = wp->w_height - used;
2402#ifdef FEAT_DIFF
2403 if (wp->w_botline <= wp->w_buffer->b_ml.ml_line_count)
2404 {
2405 wp->w_filler_rows = diff_check_fill(wp, wp->w_botline);
2406 if (wp->w_empty_rows > wp->w_filler_rows)
2407 wp->w_empty_rows -= wp->w_filler_rows;
2408 else
2409 {
2410 wp->w_filler_rows = wp->w_empty_rows;
2411 wp->w_empty_rows = 0;
2412 }
2413 }
2414#endif
2415 }
2416}
2417
2418/*
2419 * Recompute topline to put the cursor at the bottom of the window.
Bram Moolenaar8088ae92022-06-20 11:38:17 +01002420 * When scrolling scroll at least "min_scroll" lines.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002421 * If "set_topbot" is TRUE, set topline and botline first (for "zb").
2422 * This is messy stuff!!!
2423 */
2424 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002425scroll_cursor_bot(int min_scroll, int set_topbot)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002426{
2427 int used;
2428 int scrolled = 0;
Bram Moolenaar9bab7a02022-10-06 14:57:53 +01002429 int min_scrolled = 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002430 int extra = 0;
2431 int i;
2432 linenr_T line_count;
2433 linenr_T old_topline = curwin->w_topline;
2434 lineoff_T loff;
2435 lineoff_T boff;
2436#ifdef FEAT_DIFF
2437 int old_topfill = curwin->w_topfill;
2438 int fill_below_window;
2439#endif
2440 linenr_T old_botline = curwin->w_botline;
2441 linenr_T old_valid = curwin->w_valid;
2442 int old_empty_rows = curwin->w_empty_rows;
Bram Moolenaar85a20022019-12-21 18:25:54 +01002443 linenr_T cln; // Cursor Line Number
Bram Moolenaar6ed545e2022-05-09 20:09:23 +01002444 long so = get_scrolloff_value();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002445
2446 cln = curwin->w_cursor.lnum;
2447 if (set_topbot)
2448 {
2449 used = 0;
2450 curwin->w_botline = cln + 1;
2451#ifdef FEAT_DIFF
2452 loff.fill = 0;
2453#endif
2454 for (curwin->w_topline = curwin->w_botline;
2455 curwin->w_topline > 1;
2456 curwin->w_topline = loff.lnum)
2457 {
2458 loff.lnum = curwin->w_topline;
2459 topline_back(&loff);
Bram Moolenaarbacd9da2010-02-17 18:20:37 +01002460 if (loff.height == MAXCOL || used + loff.height > curwin->w_height)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002461 break;
2462 used += loff.height;
2463#ifdef FEAT_DIFF
2464 curwin->w_topfill = loff.fill;
2465#endif
2466 }
2467 set_empty_rows(curwin, used);
2468 curwin->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
2469 if (curwin->w_topline != old_topline
2470#ifdef FEAT_DIFF
2471 || curwin->w_topfill != old_topfill
2472#endif
2473 )
2474 curwin->w_valid &= ~(VALID_WROW|VALID_CROW);
2475 }
2476 else
2477 validate_botline();
2478
Bram Moolenaar85a20022019-12-21 18:25:54 +01002479 // The lines of the cursor line itself are always used.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002480#ifdef FEAT_DIFF
2481 used = plines_nofill(cln);
2482#else
2483 validate_cheight();
2484 used = curwin->w_cline_height;
2485#endif
2486
Yee Cheng Chin361895d2022-11-19 12:25:16 +00002487 // If the cursor is on or below botline, we will at least scroll by the
2488 // height of the cursor line, which is "used". Correct for empty lines,
2489 // which are really part of botline.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002490 if (cln >= curwin->w_botline)
2491 {
2492 scrolled = used;
2493 if (cln == curwin->w_botline)
2494 scrolled -= curwin->w_empty_rows;
Bram Moolenaar9bab7a02022-10-06 14:57:53 +01002495 min_scrolled = scrolled;
Yee Cheng Chin361895d2022-11-19 12:25:16 +00002496 if (curwin->w_p_sms && curwin->w_p_wrap)
2497 {
2498 // 'smoothscroll' and 'wrap' are set
2499 if (cln > curwin->w_botline)
2500 // add screen lines below w_botline
2501 for (linenr_T lnum = curwin->w_botline + 1; lnum <= cln; ++lnum)
2502 min_scrolled += PLINES_NOFILL(lnum);
2503
2504 // Calculate how many screen lines the current top line of window
2505 // occupies. If it is occupying more than the entire window, we
2506 // need to scroll the additional clipped lines to scroll past the
2507 // top line before we can move on to the other lines.
2508 int top_plines =
2509#ifdef FEAT_DIFF
2510 plines_win_nofill
2511#else
2512 plines_win
2513#endif
2514 (curwin, curwin->w_topline, FALSE);
2515 int skip_lines = 0;
2516 int width1 = curwin->w_width - curwin_col_off();
2517 int width2 = width1 + curwin_col_off2();
2518 // similar formula is used in curs_columns()
2519 if (curwin->w_skipcol > width1)
2520 skip_lines += (curwin->w_skipcol - width1) / width2 + 1;
2521 else if (curwin->w_skipcol > 0)
2522 skip_lines = 1;
2523
2524 top_plines -= skip_lines;
2525 if (top_plines > curwin->w_height)
2526 {
2527 scrolled += (top_plines - curwin->w_height);
2528 min_scrolled += (top_plines - curwin->w_height);
2529 }
2530 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002531 }
2532
2533 /*
2534 * Stop counting lines to scroll when
2535 * - hitting start of the file
2536 * - scrolled nothing or at least 'sj' lines
Bram Moolenaar375e3392019-01-31 18:26:10 +01002537 * - at least 'scrolloff' lines below the cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00002538 * - lines between botline and cursor have been counted
2539 */
2540#ifdef FEAT_FOLDING
2541 if (!hasFolding(curwin->w_cursor.lnum, &loff.lnum, &boff.lnum))
2542#endif
2543 {
2544 loff.lnum = cln;
2545 boff.lnum = cln;
2546 }
2547#ifdef FEAT_DIFF
2548 loff.fill = 0;
2549 boff.fill = 0;
2550 fill_below_window = diff_check_fill(curwin, curwin->w_botline)
2551 - curwin->w_filler_rows;
2552#endif
2553
2554 while (loff.lnum > 1)
2555 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01002556 // Stop when scrolled nothing or at least "min_scroll", found "extra"
2557 // context for 'scrolloff' and counted all lines below the window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002558 if ((((scrolled <= 0 || scrolled >= min_scroll)
Bram Moolenaara1cb1d12019-10-17 23:00:07 +02002559 && extra >= (mouse_dragging > 0 ? mouse_dragging - 1 : so))
Bram Moolenaar071d4272004-06-13 20:20:40 +00002560 || boff.lnum + 1 > curbuf->b_ml.ml_line_count)
2561 && loff.lnum <= curwin->w_botline
2562#ifdef FEAT_DIFF
2563 && (loff.lnum < curwin->w_botline
2564 || loff.fill >= fill_below_window)
2565#endif
2566 )
2567 break;
2568
Bram Moolenaar85a20022019-12-21 18:25:54 +01002569 // Add one line above
Bram Moolenaar071d4272004-06-13 20:20:40 +00002570 topline_back(&loff);
Bram Moolenaarbacd9da2010-02-17 18:20:37 +01002571 if (loff.height == MAXCOL)
2572 used = MAXCOL;
2573 else
2574 used += loff.height;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002575 if (used > curwin->w_height)
2576 break;
2577 if (loff.lnum >= curwin->w_botline
2578#ifdef FEAT_DIFF
2579 && (loff.lnum > curwin->w_botline
2580 || loff.fill <= fill_below_window)
2581#endif
2582 )
2583 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01002584 // Count screen lines that are below the window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002585 scrolled += loff.height;
2586 if (loff.lnum == curwin->w_botline
2587#ifdef FEAT_DIFF
Bram Moolenaar4e303c82018-11-24 14:27:44 +01002588 && loff.fill == 0
Bram Moolenaar071d4272004-06-13 20:20:40 +00002589#endif
2590 )
2591 scrolled -= curwin->w_empty_rows;
2592 }
2593
2594 if (boff.lnum < curbuf->b_ml.ml_line_count)
2595 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01002596 // Add one line below
Bram Moolenaar071d4272004-06-13 20:20:40 +00002597 botline_forw(&boff);
2598 used += boff.height;
2599 if (used > curwin->w_height)
2600 break;
Bram Moolenaara1cb1d12019-10-17 23:00:07 +02002601 if (extra < ( mouse_dragging > 0 ? mouse_dragging - 1 : so)
2602 || scrolled < min_scroll)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002603 {
2604 extra += boff.height;
2605 if (boff.lnum >= curwin->w_botline
2606#ifdef FEAT_DIFF
2607 || (boff.lnum + 1 == curwin->w_botline
2608 && boff.fill > curwin->w_filler_rows)
2609#endif
2610 )
2611 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01002612 // Count screen lines that are below the window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002613 scrolled += boff.height;
2614 if (boff.lnum == curwin->w_botline
2615#ifdef FEAT_DIFF
2616 && boff.fill == 0
2617#endif
2618 )
2619 scrolled -= curwin->w_empty_rows;
2620 }
2621 }
2622 }
2623 }
2624
Bram Moolenaar85a20022019-12-21 18:25:54 +01002625 // curwin->w_empty_rows is larger, no need to scroll
Bram Moolenaar071d4272004-06-13 20:20:40 +00002626 if (scrolled <= 0)
2627 line_count = 0;
Bram Moolenaar85a20022019-12-21 18:25:54 +01002628 // more than a screenfull, don't scroll but redraw
Bram Moolenaar071d4272004-06-13 20:20:40 +00002629 else if (used > curwin->w_height)
2630 line_count = used;
Bram Moolenaar85a20022019-12-21 18:25:54 +01002631 // scroll minimal number of lines
Bram Moolenaar071d4272004-06-13 20:20:40 +00002632 else
2633 {
2634 line_count = 0;
2635#ifdef FEAT_DIFF
2636 boff.fill = curwin->w_topfill;
2637#endif
2638 boff.lnum = curwin->w_topline - 1;
2639 for (i = 0; i < scrolled && boff.lnum < curwin->w_botline; )
2640 {
2641 botline_forw(&boff);
2642 i += boff.height;
2643 ++line_count;
2644 }
Bram Moolenaar85a20022019-12-21 18:25:54 +01002645 if (i < scrolled) // below curwin->w_botline, don't scroll
Bram Moolenaar071d4272004-06-13 20:20:40 +00002646 line_count = 9999;
2647 }
2648
2649 /*
2650 * Scroll up if the cursor is off the bottom of the screen a bit.
2651 * Otherwise put it at 1/2 of the screen.
2652 */
2653 if (line_count >= curwin->w_height && line_count > min_scroll)
2654 scroll_cursor_halfway(FALSE);
2655 else
Bram Moolenaar9bab7a02022-10-06 14:57:53 +01002656 {
Bram Moolenaard5337ef2022-10-20 20:15:47 +01002657 // With 'smoothscroll' scroll at least the height of the cursor line,
2658 // unless it would move the cursor.
2659 if (curwin->w_p_wrap && curwin->w_p_sms && line_count < min_scrolled
2660 && (curwin->w_cursor.lnum < curwin->w_topline
2661 || (curwin->w_virtcol - curwin->w_skipcol >=
2662 curwin->w_width - curwin_col_off())))
Bram Moolenaar9bab7a02022-10-06 14:57:53 +01002663 line_count = min_scrolled;
Bram Moolenaard5337ef2022-10-20 20:15:47 +01002664 if (line_count > 0)
2665 {
2666 if (scrolling_screenlines(TRUE))
2667 scrollup(scrolled, TRUE); // TODO
2668 else
2669 scrollup(line_count, TRUE);
2670 }
Bram Moolenaar9bab7a02022-10-06 14:57:53 +01002671 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002672
2673 /*
2674 * If topline didn't change we need to restore w_botline and w_empty_rows
2675 * (we changed them).
2676 * If topline did change, update_screen() will set botline.
2677 */
2678 if (curwin->w_topline == old_topline && set_topbot)
2679 {
2680 curwin->w_botline = old_botline;
2681 curwin->w_empty_rows = old_empty_rows;
2682 curwin->w_valid = old_valid;
2683 }
2684 curwin->w_valid |= VALID_TOPLINE;
2685}
2686
2687/*
2688 * Recompute topline to put the cursor halfway the window
2689 * If "atend" is TRUE, also put it halfway at the end of the file.
2690 */
2691 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002692scroll_cursor_halfway(int atend)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002693{
2694 int above = 0;
2695 linenr_T topline;
2696#ifdef FEAT_DIFF
2697 int topfill = 0;
2698#endif
2699 int below = 0;
2700 int used;
2701 lineoff_T loff;
2702 lineoff_T boff;
Bram Moolenaarb8e23052014-02-11 18:58:09 +01002703#ifdef FEAT_DIFF
Bram Moolenaar12a0f222014-02-11 15:47:46 +01002704 linenr_T old_topline = curwin->w_topline;
Bram Moolenaarb8e23052014-02-11 18:58:09 +01002705#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002706
Bram Moolenaar3697c9b2020-09-26 22:03:00 +02002707#ifdef FEAT_PROP_POPUP
2708 // if the width changed this needs to be updated first
2709 may_update_popup_position();
2710#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00002711 loff.lnum = boff.lnum = curwin->w_cursor.lnum;
2712#ifdef FEAT_FOLDING
2713 (void)hasFolding(loff.lnum, &loff.lnum, &boff.lnum);
2714#endif
2715#ifdef FEAT_DIFF
2716 used = plines_nofill(loff.lnum);
2717 loff.fill = 0;
2718 boff.fill = 0;
2719#else
2720 used = plines(loff.lnum);
2721#endif
2722 topline = loff.lnum;
2723 while (topline > 1)
2724 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01002725 if (below <= above) // add a line below the cursor first
Bram Moolenaar071d4272004-06-13 20:20:40 +00002726 {
2727 if (boff.lnum < curbuf->b_ml.ml_line_count)
2728 {
2729 botline_forw(&boff);
2730 used += boff.height;
2731 if (used > curwin->w_height)
2732 break;
2733 below += boff.height;
2734 }
2735 else
2736 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01002737 ++below; // count a "~" line
Bram Moolenaar071d4272004-06-13 20:20:40 +00002738 if (atend)
2739 ++used;
2740 }
2741 }
2742
Bram Moolenaar85a20022019-12-21 18:25:54 +01002743 if (below > above) // add a line above the cursor
Bram Moolenaar071d4272004-06-13 20:20:40 +00002744 {
2745 topline_back(&loff);
Bram Moolenaarbacd9da2010-02-17 18:20:37 +01002746 if (loff.height == MAXCOL)
2747 used = MAXCOL;
2748 else
2749 used += loff.height;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002750 if (used > curwin->w_height)
2751 break;
2752 above += loff.height;
2753 topline = loff.lnum;
2754#ifdef FEAT_DIFF
2755 topfill = loff.fill;
2756#endif
2757 }
2758 }
2759#ifdef FEAT_FOLDING
2760 if (!hasFolding(topline, &curwin->w_topline, NULL))
2761#endif
2762 curwin->w_topline = topline;
2763#ifdef FEAT_DIFF
2764 curwin->w_topfill = topfill;
Bram Moolenaar12a0f222014-02-11 15:47:46 +01002765 if (old_topline > curwin->w_topline + curwin->w_height)
2766 curwin->w_botfill = FALSE;
Bram Moolenaar071d4272004-06-13 20:20:40 +00002767 check_topfill(curwin, FALSE);
2768#endif
2769 curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
2770 curwin->w_valid |= VALID_TOPLINE;
2771}
2772
2773/*
2774 * Correct the cursor position so that it is in a part of the screen at least
Bram Moolenaar375e3392019-01-31 18:26:10 +01002775 * 'scrolloff' lines from the top and bottom, if possible.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002776 * If not possible, put it at the same position as scroll_cursor_halfway().
2777 * When called topline must be valid!
2778 */
2779 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01002780cursor_correct(void)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002781{
Bram Moolenaar85a20022019-12-21 18:25:54 +01002782 int above = 0; // screen lines above topline
Bram Moolenaar071d4272004-06-13 20:20:40 +00002783 linenr_T topline;
Bram Moolenaar85a20022019-12-21 18:25:54 +01002784 int below = 0; // screen lines below botline
Bram Moolenaar071d4272004-06-13 20:20:40 +00002785 linenr_T botline;
2786 int above_wanted, below_wanted;
Bram Moolenaar85a20022019-12-21 18:25:54 +01002787 linenr_T cln; // Cursor Line Number
Bram Moolenaar071d4272004-06-13 20:20:40 +00002788 int max_off;
Bram Moolenaar6ed545e2022-05-09 20:09:23 +01002789 long so = get_scrolloff_value();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002790
2791 /*
2792 * How many lines we would like to have above/below the cursor depends on
2793 * whether the first/last line of the file is on screen.
2794 */
Bram Moolenaar375e3392019-01-31 18:26:10 +01002795 above_wanted = so;
2796 below_wanted = so;
Bram Moolenaar9964e462007-05-05 17:54:07 +00002797 if (mouse_dragging > 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002798 {
2799 above_wanted = mouse_dragging - 1;
2800 below_wanted = mouse_dragging - 1;
2801 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00002802 if (curwin->w_topline == 1)
2803 {
2804 above_wanted = 0;
2805 max_off = curwin->w_height / 2;
2806 if (below_wanted > max_off)
2807 below_wanted = max_off;
2808 }
2809 validate_botline();
2810 if (curwin->w_botline == curbuf->b_ml.ml_line_count + 1
Bram Moolenaara1cb1d12019-10-17 23:00:07 +02002811 && mouse_dragging == 0)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002812 {
2813 below_wanted = 0;
2814 max_off = (curwin->w_height - 1) / 2;
2815 if (above_wanted > max_off)
2816 above_wanted = max_off;
2817 }
2818
2819 /*
2820 * If there are sufficient file-lines above and below the cursor, we can
2821 * return now.
2822 */
2823 cln = curwin->w_cursor.lnum;
2824 if (cln >= curwin->w_topline + above_wanted
2825 && cln < curwin->w_botline - below_wanted
2826#ifdef FEAT_FOLDING
2827 && !hasAnyFolding(curwin)
2828#endif
2829 )
2830 return;
2831
Bram Moolenaarc9121f72022-10-14 20:09:04 +01002832 if (curwin->w_p_sms && !curwin->w_p_wrap)
2833 {
2834 // 'smoothscroll is active
2835 if (curwin->w_cline_height == curwin->w_height)
2836 {
2837 // The cursor line just fits in the window, don't scroll.
Bram Moolenaarf32fb932022-11-17 11:34:38 +00002838 reset_skipcol();
Bram Moolenaarc9121f72022-10-14 20:09:04 +01002839 return;
2840 }
2841 // TODO: If the cursor line doesn't fit in the window then only adjust
2842 // w_skipcol.
2843 }
2844
Bram Moolenaar071d4272004-06-13 20:20:40 +00002845 /*
2846 * Narrow down the area where the cursor can be put by taking lines from
2847 * the top and the bottom until:
2848 * - the desired context lines are found
2849 * - the lines from the top is past the lines from the bottom
2850 */
2851 topline = curwin->w_topline;
2852 botline = curwin->w_botline - 1;
2853#ifdef FEAT_DIFF
Bram Moolenaar85a20022019-12-21 18:25:54 +01002854 // count filler lines as context
Bram Moolenaar071d4272004-06-13 20:20:40 +00002855 above = curwin->w_topfill;
2856 below = curwin->w_filler_rows;
2857#endif
2858 while ((above < above_wanted || below < below_wanted) && topline < botline)
2859 {
2860 if (below < below_wanted && (below <= above || above >= above_wanted))
2861 {
2862#ifdef FEAT_FOLDING
2863 if (hasFolding(botline, &botline, NULL))
2864 ++below;
2865 else
2866#endif
2867 below += plines(botline);
2868 --botline;
2869 }
2870 if (above < above_wanted && (above < below || below >= below_wanted))
2871 {
2872#ifdef FEAT_FOLDING
2873 if (hasFolding(topline, NULL, &topline))
2874 ++above;
2875 else
2876#endif
Bram Moolenaar43335ea2015-09-09 20:59:37 +02002877 above += PLINES_NOFILL(topline);
2878#ifdef FEAT_DIFF
Bram Moolenaar85a20022019-12-21 18:25:54 +01002879 // Count filler lines below this line as context.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002880 if (topline < botline)
2881 above += diff_check_fill(curwin, topline + 1);
2882#endif
2883 ++topline;
2884 }
2885 }
2886 if (topline == botline || botline == 0)
2887 curwin->w_cursor.lnum = topline;
2888 else if (topline > botline)
2889 curwin->w_cursor.lnum = botline;
2890 else
2891 {
2892 if (cln < topline && curwin->w_topline > 1)
2893 {
2894 curwin->w_cursor.lnum = topline;
2895 curwin->w_valid &=
2896 ~(VALID_WROW|VALID_WCOL|VALID_CHEIGHT|VALID_CROW);
2897 }
2898 if (cln > botline && curwin->w_botline <= curbuf->b_ml.ml_line_count)
2899 {
2900 curwin->w_cursor.lnum = botline;
2901 curwin->w_valid &=
2902 ~(VALID_WROW|VALID_WCOL|VALID_CHEIGHT|VALID_CROW);
2903 }
2904 }
2905 curwin->w_valid |= VALID_TOPLINE;
2906}
2907
Bram Moolenaar92b8b2d2016-01-29 22:36:45 +01002908static void get_scroll_overlap(lineoff_T *lp, int dir);
Bram Moolenaar071d4272004-06-13 20:20:40 +00002909
2910/*
Bram Moolenaar88456cd2022-11-18 22:14:09 +00002911 * Move screen "count" pages up ("dir" is BACKWARD) or down ("dir" is FORWARD)
2912 * and update the screen.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002913 *
Yee Cheng Chin81ba26e2022-11-18 12:52:50 +00002914 * Return FAIL for failure, OK otherwise.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002915 */
2916 int
Bram Moolenaar9b578142016-01-30 19:39:49 +01002917onepage(int dir, long count)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002918{
2919 long n;
2920 int retval = OK;
2921 lineoff_T loff;
2922 linenr_T old_topline = curwin->w_topline;
Bram Moolenaar6ed545e2022-05-09 20:09:23 +01002923 long so = get_scrolloff_value();
Bram Moolenaar071d4272004-06-13 20:20:40 +00002924
Bram Moolenaar85a20022019-12-21 18:25:54 +01002925 if (curbuf->b_ml.ml_line_count == 1) // nothing to do
Bram Moolenaar071d4272004-06-13 20:20:40 +00002926 {
2927 beep_flush();
2928 return FAIL;
2929 }
2930
2931 for ( ; count > 0; --count)
2932 {
2933 validate_botline();
2934 /*
2935 * It's an error to move a page up when the first line is already on
2936 * the screen. It's an error to move a page down when the last line
2937 * is on the screen and the topline is 'scrolloff' lines from the
2938 * last line.
2939 */
2940 if (dir == FORWARD
Bram Moolenaar375e3392019-01-31 18:26:10 +01002941 ? ((curwin->w_topline >= curbuf->b_ml.ml_line_count - so)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002942 && curwin->w_botline > curbuf->b_ml.ml_line_count)
2943 : (curwin->w_topline == 1
2944#ifdef FEAT_DIFF
2945 && curwin->w_topfill ==
2946 diff_check_fill(curwin, curwin->w_topline)
2947#endif
2948 ))
2949 {
2950 beep_flush();
2951 retval = FAIL;
2952 break;
2953 }
2954
2955#ifdef FEAT_DIFF
2956 loff.fill = 0;
2957#endif
2958 if (dir == FORWARD)
2959 {
Bram Moolenaara1f4cb92016-11-06 15:25:42 +01002960 if (ONE_WINDOW && p_window > 0 && p_window < Rows - 1)
Bram Moolenaar071d4272004-06-13 20:20:40 +00002961 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01002962 // Vi compatible scrolling
Bram Moolenaar4399ef42005-02-12 14:29:27 +00002963 if (p_window <= 2)
2964 ++curwin->w_topline;
2965 else
2966 curwin->w_topline += p_window - 2;
2967 if (curwin->w_topline > curbuf->b_ml.ml_line_count)
2968 curwin->w_topline = curbuf->b_ml.ml_line_count;
2969 curwin->w_cursor.lnum = curwin->w_topline;
2970 }
2971 else if (curwin->w_botline > curbuf->b_ml.ml_line_count)
2972 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01002973 // at end of file
Bram Moolenaar071d4272004-06-13 20:20:40 +00002974 curwin->w_topline = curbuf->b_ml.ml_line_count;
2975#ifdef FEAT_DIFF
2976 curwin->w_topfill = 0;
2977#endif
2978 curwin->w_valid &= ~(VALID_WROW|VALID_CROW);
2979 }
2980 else
2981 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01002982 // For the overlap, start with the line just below the window
2983 // and go upwards.
Bram Moolenaar071d4272004-06-13 20:20:40 +00002984 loff.lnum = curwin->w_botline;
2985#ifdef FEAT_DIFF
2986 loff.fill = diff_check_fill(curwin, loff.lnum)
2987 - curwin->w_filler_rows;
2988#endif
2989 get_scroll_overlap(&loff, -1);
2990 curwin->w_topline = loff.lnum;
2991#ifdef FEAT_DIFF
2992 curwin->w_topfill = loff.fill;
2993 check_topfill(curwin, FALSE);
2994#endif
2995 curwin->w_cursor.lnum = curwin->w_topline;
2996 curwin->w_valid &= ~(VALID_WCOL|VALID_CHEIGHT|VALID_WROW|
2997 VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
2998 }
2999 }
Bram Moolenaar85a20022019-12-21 18:25:54 +01003000 else // dir == BACKWARDS
Bram Moolenaar071d4272004-06-13 20:20:40 +00003001 {
3002#ifdef FEAT_DIFF
3003 if (curwin->w_topline == 1)
3004 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01003005 // Include max number of filler lines
Bram Moolenaar071d4272004-06-13 20:20:40 +00003006 max_topfill();
3007 continue;
3008 }
3009#endif
Bram Moolenaara1f4cb92016-11-06 15:25:42 +01003010 if (ONE_WINDOW && p_window > 0 && p_window < Rows - 1)
Bram Moolenaar4399ef42005-02-12 14:29:27 +00003011 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01003012 // Vi compatible scrolling (sort of)
Bram Moolenaar4399ef42005-02-12 14:29:27 +00003013 if (p_window <= 2)
3014 --curwin->w_topline;
3015 else
3016 curwin->w_topline -= p_window - 2;
3017 if (curwin->w_topline < 1)
3018 curwin->w_topline = 1;
3019 curwin->w_cursor.lnum = curwin->w_topline + p_window - 1;
3020 if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count)
3021 curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
3022 continue;
3023 }
3024
Bram Moolenaar85a20022019-12-21 18:25:54 +01003025 // Find the line at the top of the window that is going to be the
3026 // line at the bottom of the window. Make sure this results in
3027 // the same line as before doing CTRL-F.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003028 loff.lnum = curwin->w_topline - 1;
3029#ifdef FEAT_DIFF
3030 loff.fill = diff_check_fill(curwin, loff.lnum + 1)
3031 - curwin->w_topfill;
3032#endif
3033 get_scroll_overlap(&loff, 1);
3034
3035 if (loff.lnum >= curbuf->b_ml.ml_line_count)
3036 {
3037 loff.lnum = curbuf->b_ml.ml_line_count;
3038#ifdef FEAT_DIFF
3039 loff.fill = 0;
3040 }
3041 else
3042 {
3043 botline_topline(&loff);
3044#endif
3045 }
3046 curwin->w_cursor.lnum = loff.lnum;
3047
Bram Moolenaar85a20022019-12-21 18:25:54 +01003048 // Find the line just above the new topline to get the right line
3049 // at the bottom of the window.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003050 n = 0;
3051 while (n <= curwin->w_height && loff.lnum >= 1)
3052 {
3053 topline_back(&loff);
Bram Moolenaarbacd9da2010-02-17 18:20:37 +01003054 if (loff.height == MAXCOL)
3055 n = MAXCOL;
3056 else
3057 n += loff.height;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003058 }
Bram Moolenaar85a20022019-12-21 18:25:54 +01003059 if (loff.lnum < 1) // at begin of file
Bram Moolenaar071d4272004-06-13 20:20:40 +00003060 {
3061 curwin->w_topline = 1;
3062#ifdef FEAT_DIFF
3063 max_topfill();
3064#endif
3065 curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE);
3066 }
3067 else
3068 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01003069 // Go two lines forward again.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003070#ifdef FEAT_DIFF
3071 topline_botline(&loff);
3072#endif
3073 botline_forw(&loff);
3074 botline_forw(&loff);
3075#ifdef FEAT_DIFF
3076 botline_topline(&loff);
3077#endif
3078#ifdef FEAT_FOLDING
Bram Moolenaar85a20022019-12-21 18:25:54 +01003079 // We're at the wrong end of a fold now.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003080 (void)hasFolding(loff.lnum, &loff.lnum, NULL);
3081#endif
3082
Bram Moolenaar85a20022019-12-21 18:25:54 +01003083 // Always scroll at least one line. Avoid getting stuck on
3084 // very long lines.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003085 if (loff.lnum >= curwin->w_topline
3086#ifdef FEAT_DIFF
3087 && (loff.lnum > curwin->w_topline
3088 || loff.fill >= curwin->w_topfill)
3089#endif
3090 )
3091 {
3092#ifdef FEAT_DIFF
Bram Moolenaar85a20022019-12-21 18:25:54 +01003093 // First try using the maximum number of filler lines. If
3094 // that's not enough, backup one line.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003095 loff.fill = curwin->w_topfill;
3096 if (curwin->w_topfill < diff_check_fill(curwin,
3097 curwin->w_topline))
3098 max_topfill();
3099 if (curwin->w_topfill == loff.fill)
3100#endif
3101 {
3102 --curwin->w_topline;
3103#ifdef FEAT_DIFF
3104 curwin->w_topfill = 0;
3105#endif
3106 }
3107 comp_botline(curwin);
3108 curwin->w_cursor.lnum = curwin->w_botline - 1;
Bram Moolenaar3d6db142014-03-28 21:49:32 +01003109 curwin->w_valid &=
3110 ~(VALID_WCOL|VALID_CHEIGHT|VALID_WROW|VALID_CROW);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003111 }
3112 else
3113 {
3114 curwin->w_topline = loff.lnum;
3115#ifdef FEAT_DIFF
3116 curwin->w_topfill = loff.fill;
3117 check_topfill(curwin, FALSE);
3118#endif
3119 curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE);
3120 }
3121 }
3122 }
3123 }
3124#ifdef FEAT_FOLDING
3125 foldAdjustCursor();
3126#endif
3127 cursor_correct();
Bram Moolenaarbc54f3f2016-09-04 14:34:28 +02003128 check_cursor_col();
Bram Moolenaar7c626922005-02-07 22:01:03 +00003129 if (retval == OK)
3130 beginline(BL_SOL | BL_FIX);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003131 curwin->w_valid &= ~(VALID_WCOL|VALID_WROW|VALID_VIRTCOL);
3132
Bram Moolenaar907dad72018-07-10 15:07:15 +02003133 if (retval == OK && dir == FORWARD)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003134 {
Bram Moolenaar907dad72018-07-10 15:07:15 +02003135 // Avoid the screen jumping up and down when 'scrolloff' is non-zero.
3136 // But make sure we scroll at least one line (happens with mix of long
3137 // wrapping lines and non-wrapping line).
3138 if (check_top_offset())
Bram Moolenaar071d4272004-06-13 20:20:40 +00003139 {
Bram Moolenaar907dad72018-07-10 15:07:15 +02003140 scroll_cursor_top(1, FALSE);
3141 if (curwin->w_topline <= old_topline
3142 && old_topline < curbuf->b_ml.ml_line_count)
3143 {
3144 curwin->w_topline = old_topline + 1;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003145#ifdef FEAT_FOLDING
Bram Moolenaar907dad72018-07-10 15:07:15 +02003146 (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
3147#endif
3148 }
3149 }
3150#ifdef FEAT_FOLDING
3151 else if (curwin->w_botline > curbuf->b_ml.ml_line_count)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003152 (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
3153#endif
Bram Moolenaar071d4272004-06-13 20:20:40 +00003154 }
3155
Bram Moolenaara4d158b2022-08-14 14:17:45 +01003156 redraw_later(UPD_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003157 return retval;
3158}
3159
3160/*
3161 * Decide how much overlap to use for page-up or page-down scrolling.
3162 * This is symmetric, so that doing both keeps the same lines displayed.
3163 * Three lines are examined:
3164 *
3165 * before CTRL-F after CTRL-F / before CTRL-B
3166 * etc. l1
3167 * l1 last but one line ------------
3168 * l2 last text line l2 top text line
3169 * ------------- l3 second text line
3170 * l3 etc.
3171 */
3172 static void
Bram Moolenaar9b578142016-01-30 19:39:49 +01003173get_scroll_overlap(lineoff_T *lp, int dir)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003174{
3175 int h1, h2, h3, h4;
3176 int min_height = curwin->w_height - 2;
3177 lineoff_T loff0, loff1, loff2;
3178
3179#ifdef FEAT_DIFF
3180 if (lp->fill > 0)
3181 lp->height = 1;
3182 else
3183 lp->height = plines_nofill(lp->lnum);
3184#else
3185 lp->height = plines(lp->lnum);
3186#endif
3187 h1 = lp->height;
3188 if (h1 > min_height)
Bram Moolenaar85a20022019-12-21 18:25:54 +01003189 return; // no overlap
Bram Moolenaar071d4272004-06-13 20:20:40 +00003190
3191 loff0 = *lp;
3192 if (dir > 0)
3193 botline_forw(lp);
3194 else
3195 topline_back(lp);
3196 h2 = lp->height;
Bram Moolenaarf4f19562012-11-28 18:22:11 +01003197 if (h2 == MAXCOL || h2 + h1 > min_height)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003198 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01003199 *lp = loff0; // no overlap
Bram Moolenaar071d4272004-06-13 20:20:40 +00003200 return;
3201 }
3202
3203 loff1 = *lp;
3204 if (dir > 0)
3205 botline_forw(lp);
3206 else
3207 topline_back(lp);
3208 h3 = lp->height;
Bram Moolenaarf4f19562012-11-28 18:22:11 +01003209 if (h3 == MAXCOL || h3 + h2 > min_height)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003210 {
Bram Moolenaar85a20022019-12-21 18:25:54 +01003211 *lp = loff0; // no overlap
Bram Moolenaar071d4272004-06-13 20:20:40 +00003212 return;
3213 }
3214
3215 loff2 = *lp;
3216 if (dir > 0)
3217 botline_forw(lp);
3218 else
3219 topline_back(lp);
3220 h4 = lp->height;
Bram Moolenaarf4f19562012-11-28 18:22:11 +01003221 if (h4 == MAXCOL || h4 + h3 + h2 > min_height || h3 + h2 + h1 > min_height)
Bram Moolenaar85a20022019-12-21 18:25:54 +01003222 *lp = loff1; // 1 line overlap
Bram Moolenaar071d4272004-06-13 20:20:40 +00003223 else
Bram Moolenaar85a20022019-12-21 18:25:54 +01003224 *lp = loff2; // 2 lines overlap
Bram Moolenaar071d4272004-06-13 20:20:40 +00003225}
3226
Bram Moolenaar071d4272004-06-13 20:20:40 +00003227/*
3228 * Scroll 'scroll' lines up or down.
3229 */
3230 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01003231halfpage(int flag, linenr_T Prenum)
Bram Moolenaar071d4272004-06-13 20:20:40 +00003232{
3233 long scrolled = 0;
3234 int i;
3235 int n;
3236 int room;
3237
3238 if (Prenum)
3239 curwin->w_p_scr = (Prenum > curwin->w_height) ?
3240 curwin->w_height : Prenum;
3241 n = (curwin->w_p_scr <= curwin->w_height) ?
3242 curwin->w_p_scr : curwin->w_height;
3243
Bram Moolenaard5d37532017-03-27 23:02:07 +02003244 update_topline();
Bram Moolenaar071d4272004-06-13 20:20:40 +00003245 validate_botline();
3246 room = curwin->w_empty_rows;
3247#ifdef FEAT_DIFF
3248 room += curwin->w_filler_rows;
3249#endif
3250 if (flag)
3251 {
3252 /*
3253 * scroll the text up
3254 */
3255 while (n > 0 && curwin->w_botline <= curbuf->b_ml.ml_line_count)
3256 {
3257#ifdef FEAT_DIFF
3258 if (curwin->w_topfill > 0)
3259 {
3260 i = 1;
Bram Moolenaar8455c5e2020-07-14 21:22:30 +02003261 --n;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003262 --curwin->w_topfill;
3263 }
3264 else
3265#endif
3266 {
Bram Moolenaar43335ea2015-09-09 20:59:37 +02003267 i = PLINES_NOFILL(curwin->w_topline);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003268 n -= i;
3269 if (n < 0 && scrolled > 0)
3270 break;
3271#ifdef FEAT_FOLDING
3272 (void)hasFolding(curwin->w_topline, NULL, &curwin->w_topline);
3273#endif
3274 ++curwin->w_topline;
3275#ifdef FEAT_DIFF
3276 curwin->w_topfill = diff_check_fill(curwin, curwin->w_topline);
3277#endif
3278
Bram Moolenaar071d4272004-06-13 20:20:40 +00003279 if (curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
3280 {
3281 ++curwin->w_cursor.lnum;
3282 curwin->w_valid &=
3283 ~(VALID_VIRTCOL|VALID_CHEIGHT|VALID_WCOL);
3284 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003285 }
3286 curwin->w_valid &= ~(VALID_CROW|VALID_WROW);
3287 scrolled += i;
3288
3289 /*
3290 * Correct w_botline for changed w_topline.
3291 * Won't work when there are filler lines.
3292 */
3293#ifdef FEAT_DIFF
3294 if (curwin->w_p_diff)
3295 curwin->w_valid &= ~(VALID_BOTLINE|VALID_BOTLINE_AP);
3296 else
3297#endif
3298 {
3299 room += i;
3300 do
3301 {
3302 i = plines(curwin->w_botline);
3303 if (i > room)
3304 break;
3305#ifdef FEAT_FOLDING
3306 (void)hasFolding(curwin->w_botline, NULL,
3307 &curwin->w_botline);
3308#endif
3309 ++curwin->w_botline;
3310 room -= i;
3311 } while (curwin->w_botline <= curbuf->b_ml.ml_line_count);
3312 }
3313 }
3314
Bram Moolenaar071d4272004-06-13 20:20:40 +00003315 /*
3316 * When hit bottom of the file: move cursor down.
3317 */
3318 if (n > 0)
3319 {
3320# ifdef FEAT_FOLDING
3321 if (hasAnyFolding(curwin))
3322 {
3323 while (--n >= 0
3324 && curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count)
3325 {
3326 (void)hasFolding(curwin->w_cursor.lnum, NULL,
3327 &curwin->w_cursor.lnum);
3328 ++curwin->w_cursor.lnum;
3329 }
3330 }
3331 else
3332# endif
3333 curwin->w_cursor.lnum += n;
3334 check_cursor_lnum();
3335 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003336 }
3337 else
3338 {
3339 /*
3340 * scroll the text down
3341 */
3342 while (n > 0 && curwin->w_topline > 1)
3343 {
3344#ifdef FEAT_DIFF
3345 if (curwin->w_topfill < diff_check_fill(curwin, curwin->w_topline))
3346 {
3347 i = 1;
Bram Moolenaard00e0242019-03-20 21:42:20 +01003348 --n;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003349 ++curwin->w_topfill;
3350 }
3351 else
3352#endif
3353 {
Bram Moolenaar43335ea2015-09-09 20:59:37 +02003354 i = PLINES_NOFILL(curwin->w_topline - 1);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003355 n -= i;
3356 if (n < 0 && scrolled > 0)
3357 break;
3358 --curwin->w_topline;
3359#ifdef FEAT_FOLDING
3360 (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
3361#endif
3362#ifdef FEAT_DIFF
3363 curwin->w_topfill = 0;
3364#endif
3365 }
3366 curwin->w_valid &= ~(VALID_CROW|VALID_WROW|
3367 VALID_BOTLINE|VALID_BOTLINE_AP);
3368 scrolled += i;
Bram Moolenaar071d4272004-06-13 20:20:40 +00003369 if (curwin->w_cursor.lnum > 1)
3370 {
3371 --curwin->w_cursor.lnum;
3372 curwin->w_valid &= ~(VALID_VIRTCOL|VALID_CHEIGHT|VALID_WCOL);
3373 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003374 }
Bram Moolenaard00e0242019-03-20 21:42:20 +01003375
Bram Moolenaar071d4272004-06-13 20:20:40 +00003376 /*
3377 * When hit top of the file: move cursor up.
3378 */
3379 if (n > 0)
3380 {
3381 if (curwin->w_cursor.lnum <= (linenr_T)n)
3382 curwin->w_cursor.lnum = 1;
3383 else
3384# ifdef FEAT_FOLDING
3385 if (hasAnyFolding(curwin))
3386 {
3387 while (--n >= 0 && curwin->w_cursor.lnum > 1)
3388 {
3389 --curwin->w_cursor.lnum;
3390 (void)hasFolding(curwin->w_cursor.lnum,
3391 &curwin->w_cursor.lnum, NULL);
3392 }
3393 }
3394 else
3395# endif
3396 curwin->w_cursor.lnum -= n;
3397 }
Bram Moolenaar071d4272004-06-13 20:20:40 +00003398 }
3399# ifdef FEAT_FOLDING
Bram Moolenaar85a20022019-12-21 18:25:54 +01003400 // Move cursor to first line of closed fold.
Bram Moolenaar071d4272004-06-13 20:20:40 +00003401 foldAdjustCursor();
3402# endif
3403#ifdef FEAT_DIFF
3404 check_topfill(curwin, !flag);
3405#endif
3406 cursor_correct();
3407 beginline(BL_SOL | BL_FIX);
Bram Moolenaara4d158b2022-08-14 14:17:45 +01003408 redraw_later(UPD_VALID);
Bram Moolenaar071d4272004-06-13 20:20:40 +00003409}
Bram Moolenaar860cae12010-06-05 23:22:07 +02003410
Bram Moolenaar860cae12010-06-05 23:22:07 +02003411 void
Bram Moolenaar9b578142016-01-30 19:39:49 +01003412do_check_cursorbind(void)
Bram Moolenaar860cae12010-06-05 23:22:07 +02003413{
3414 linenr_T line = curwin->w_cursor.lnum;
Bram Moolenaar1ea69b72012-03-16 19:24:26 +01003415 colnr_T col = curwin->w_cursor.col;
Bram Moolenaar1ea69b72012-03-16 19:24:26 +01003416 colnr_T coladd = curwin->w_cursor.coladd;
Bram Moolenaar524780d2012-03-28 14:19:50 +02003417 colnr_T curswant = curwin->w_curswant;
3418 int set_curswant = curwin->w_set_curswant;
Bram Moolenaar860cae12010-06-05 23:22:07 +02003419 win_T *old_curwin = curwin;
3420 buf_T *old_curbuf = curbuf;
Bram Moolenaar61452852011-02-01 18:01:11 +01003421 int restart_edit_save;
Bram Moolenaar860cae12010-06-05 23:22:07 +02003422 int old_VIsual_select = VIsual_select;
3423 int old_VIsual_active = VIsual_active;
Bram Moolenaar860cae12010-06-05 23:22:07 +02003424
3425 /*
3426 * loop through the cursorbound windows
3427 */
Bram Moolenaar860cae12010-06-05 23:22:07 +02003428 VIsual_select = VIsual_active = 0;
Bram Moolenaar29323592016-07-24 22:04:11 +02003429 FOR_ALL_WINDOWS(curwin)
Bram Moolenaar860cae12010-06-05 23:22:07 +02003430 {
3431 curbuf = curwin->w_buffer;
Bram Moolenaar85a20022019-12-21 18:25:54 +01003432 // skip original window and windows with 'noscrollbind'
Bram Moolenaar860cae12010-06-05 23:22:07 +02003433 if (curwin != old_curwin && curwin->w_p_crb)
3434 {
3435# ifdef FEAT_DIFF
3436 if (curwin->w_p_diff)
Bram Moolenaar025e3e02016-10-18 14:50:18 +02003437 curwin->w_cursor.lnum =
3438 diff_get_corresponding_line(old_curbuf, line);
Bram Moolenaar860cae12010-06-05 23:22:07 +02003439 else
3440# endif
3441 curwin->w_cursor.lnum = line;
3442 curwin->w_cursor.col = col;
Bram Moolenaar1ea69b72012-03-16 19:24:26 +01003443 curwin->w_cursor.coladd = coladd;
Bram Moolenaar524780d2012-03-28 14:19:50 +02003444 curwin->w_curswant = curswant;
3445 curwin->w_set_curswant = set_curswant;
Bram Moolenaar860cae12010-06-05 23:22:07 +02003446
Bram Moolenaar85a20022019-12-21 18:25:54 +01003447 // Make sure the cursor is in a valid position. Temporarily set
3448 // "restart_edit" to allow the cursor to be beyond the EOL.
Bram Moolenaar61452852011-02-01 18:01:11 +01003449 restart_edit_save = restart_edit;
3450 restart_edit = TRUE;
Bram Moolenaar860cae12010-06-05 23:22:07 +02003451 check_cursor();
Bram Moolenaara315ce12022-06-24 12:38:57 +01003452
3453 // Avoid a scroll here for the cursor position, 'scrollbind' is
3454 // more important.
3455 if (!curwin->w_p_scb)
3456 validate_cursor();
3457
Bram Moolenaar61452852011-02-01 18:01:11 +01003458 restart_edit = restart_edit_save;
Bram Moolenaar85a20022019-12-21 18:25:54 +01003459 // Correct cursor for multi-byte character.
Bram Moolenaar860cae12010-06-05 23:22:07 +02003460 if (has_mbyte)
3461 mb_adjust_cursor();
Bram Moolenaara4d158b2022-08-14 14:17:45 +01003462 redraw_later(UPD_VALID);
Bram Moolenaarf3d419d2011-01-22 21:05:07 +01003463
Bram Moolenaar85a20022019-12-21 18:25:54 +01003464 // Only scroll when 'scrollbind' hasn't done this.
Bram Moolenaarf3d419d2011-01-22 21:05:07 +01003465 if (!curwin->w_p_scb)
3466 update_topline();
Bram Moolenaar860cae12010-06-05 23:22:07 +02003467 curwin->w_redr_status = TRUE;
Bram Moolenaar860cae12010-06-05 23:22:07 +02003468 }
3469 }
3470
3471 /*
3472 * reset current-window
3473 */
Bram Moolenaar860cae12010-06-05 23:22:07 +02003474 VIsual_select = old_VIsual_select;
3475 VIsual_active = old_VIsual_active;
Bram Moolenaar860cae12010-06-05 23:22:07 +02003476 curwin = old_curwin;
3477 curbuf = old_curbuf;
3478}