1 /* vi:set ts=8 sts=4 sw=4:
3 * VIM - Vi IMproved by Bram Moolenaar
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.
10 * move.c: Functions for moving the cursor and scrolling text.
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
15 * 2. Scroll the text, the cursor is moved into the text visible in the
17 * The 'scrolloff' option makes this a bit complicated.
22 static void comp_botline
__ARGS((win_T
*wp
));
23 static int scrolljump_value
__ARGS((void));
24 static int check_top_offset
__ARGS((void));
25 static void curs_rows
__ARGS((win_T
*wp
, int do_botline
));
26 static void validate_botline_win
__ARGS((win_T
*wp
));
27 static void validate_cheight
__ARGS((void));
31 linenr_T lnum
; /* line number */
33 int fill
; /* filler lines */
35 int height
; /* height of added line */
38 static void topline_back
__ARGS((lineoff_T
*lp
));
39 static void botline_forw
__ARGS((lineoff_T
*lp
));
41 static void botline_topline
__ARGS((lineoff_T
*lp
));
42 static void topline_botline
__ARGS((lineoff_T
*lp
));
43 static void max_topfill
__ARGS((void));
47 * Compute wp->w_botline for the current wp->w_topline. Can be called after
48 * wp->w_topline changed.
63 * If w_cline_row is valid, start there.
64 * Otherwise have to start at w_topline.
66 check_cursor_moved(wp
);
67 if (wp
->w_valid
& VALID_CROW
)
69 lnum
= wp
->w_cursor
.lnum
;
70 done
= wp
->w_cline_row
;
78 for ( ; lnum
<= wp
->w_buffer
->b_ml
.ml_line_count
; ++lnum
)
83 if (hasFoldingWin(wp
, lnum
, NULL
, &last
, TRUE
, NULL
))
91 if (lnum
== wp
->w_topline
)
92 n
= plines_win_nofill(wp
, lnum
, TRUE
) + wp
->w_topfill
;
95 n
= plines_win(wp
, lnum
, TRUE
);
98 lnum
<= wp
->w_cursor
.lnum
&& last
>= wp
->w_cursor
.lnum
100 lnum
== wp
->w_cursor
.lnum
104 wp
->w_cline_row
= done
;
105 wp
->w_cline_height
= n
;
107 wp
->w_cline_folded
= folded
;
109 wp
->w_valid
|= (VALID_CROW
|VALID_CHEIGHT
);
111 if (done
+ n
> wp
->w_height
)
119 /* wp->w_botline is the line that is just below the window */
120 wp
->w_botline
= lnum
;
121 wp
->w_valid
|= VALID_BOTLINE
|VALID_BOTLINE_AP
;
123 set_empty_rows(wp
, done
);
127 * Update curwin->w_topline and redraw if necessary.
128 * Used to update the screen before printing a message.
131 update_topline_redraw()
139 * Update curwin->w_topline to move the cursor onto the screen.
147 linenr_T old_topline
;
154 int check_topline
= FALSE
;
155 int check_botline
= FALSE
;
160 if (!screen_valid(TRUE
))
163 check_cursor_moved(curwin
);
164 if (curwin
->w_valid
& VALID_TOPLINE
)
168 /* When dragging with the mouse, don't scroll that quickly */
169 if (mouse_dragging
> 0)
170 p_so
= mouse_dragging
- 1;
173 old_topline
= curwin
->w_topline
;
175 old_topfill
= curwin
->w_topfill
;
179 * If the buffer is empty, always set topline to 1.
181 if (bufempty()) /* special case - file is empty */
183 if (curwin
->w_topline
!= 1)
184 redraw_later(NOT_VALID
);
185 curwin
->w_topline
= 1;
187 curwin
->w_topfill
= 0;
189 curwin
->w_botline
= 2;
190 curwin
->w_valid
|= VALID_BOTLINE
|VALID_BOTLINE_AP
;
191 #ifdef FEAT_SCROLLBIND
192 curwin
->w_scbind_pos
= 1;
197 * If the cursor is above or near the top of the window, scroll the window
198 * to show the line the cursor is in, with 'scrolloff' context.
202 if (curwin
->w_topline
> 1)
204 /* If the cursor is above topline, scrolling is always needed.
205 * If the cursor is far below topline and there is no folding,
206 * scrolling down is never needed. */
207 if (curwin
->w_cursor
.lnum
< curwin
->w_topline
)
208 check_topline
= TRUE
;
209 else if (check_top_offset())
210 check_topline
= TRUE
;
213 /* Check if there are more filler lines than allowed. */
214 if (!check_topline
&& curwin
->w_topfill
> diff_check_fill(curwin
,
216 check_topline
= TRUE
;
221 halfheight
= curwin
->w_height
/ 2 - 1;
226 if (hasAnyFolding(curwin
))
228 /* Count the number of logical lines between the cursor and
229 * topline + p_so (approximation of how much will be
232 for (lnum
= curwin
->w_cursor
.lnum
;
233 lnum
< curwin
->w_topline
+ p_so
; ++lnum
)
236 /* stop at end of file or when we know we are far off */
237 if (lnum
>= curbuf
->b_ml
.ml_line_count
|| n
>= halfheight
)
239 (void)hasFolding(lnum
, NULL
, &lnum
);
244 n
= curwin
->w_topline
+ p_so
- curwin
->w_cursor
.lnum
;
246 /* If we weren't very close to begin with, we scroll to put the
247 * cursor in the middle of the window. Otherwise put the cursor
248 * near the top of the window. */
250 scroll_cursor_halfway(FALSE
);
253 scroll_cursor_top(scrolljump_value(), FALSE
);
254 check_botline
= TRUE
;
261 /* Make sure topline is the first line of a fold. */
262 (void)hasFolding(curwin
->w_topline
, &curwin
->w_topline
, NULL
);
264 check_botline
= TRUE
;
269 * If the cursor is below the bottom of the window, scroll the window
270 * to put the cursor on the window.
271 * When w_botline is invalid, recompute it first, to avoid a redraw later.
272 * If w_botline was approximated, we might need a redraw later in a few
273 * cases, but we don't want to spend (a lot of) time recomputing w_botline
274 * for every small change.
278 if (!(curwin
->w_valid
& VALID_BOTLINE_AP
))
281 if (curwin
->w_botline
<= curbuf
->b_ml
.ml_line_count
)
283 if (curwin
->w_cursor
.lnum
< curwin
->w_botline
284 && ((long)curwin
->w_cursor
.lnum
285 >= (long)curwin
->w_botline
- p_so
287 || hasAnyFolding(curwin
)
293 /* Cursor is above botline, check if there are 'scrolloff'
294 * window lines below the cursor. If not, need to scroll. */
295 n
= curwin
->w_empty_rows
;
296 loff
.lnum
= curwin
->w_cursor
.lnum
;
298 /* In a fold go to its last line. */
299 (void)hasFolding(loff
.lnum
, NULL
, &loff
.lnum
);
303 n
+= curwin
->w_filler_rows
;
306 while (loff
.lnum
< curwin
->w_botline
308 && (loff
.lnum
+ 1 < curwin
->w_botline
|| loff
.fill
== 0)
318 /* sufficient context, no need to scroll */
319 check_botline
= FALSE
;
324 if (hasAnyFolding(curwin
))
326 /* Count the number of logical lines between the cursor and
327 * botline - p_so (approximation of how much will be
330 for (lnum
= curwin
->w_cursor
.lnum
;
331 lnum
>= curwin
->w_botline
- p_so
; --lnum
)
334 /* stop at end of file or when we know we are far off */
335 if (lnum
<= 0 || line_count
> curwin
->w_height
+ 1)
337 (void)hasFolding(lnum
, &lnum
, NULL
);
342 line_count
= curwin
->w_cursor
.lnum
- curwin
->w_botline
344 if (line_count
<= curwin
->w_height
+ 1)
345 scroll_cursor_bot(scrolljump_value(), FALSE
);
347 scroll_cursor_halfway(FALSE
);
351 curwin
->w_valid
|= VALID_TOPLINE
;
354 * Need to redraw when topline changed.
356 if (curwin
->w_topline
!= old_topline
358 || curwin
->w_topfill
!= old_topfill
363 if (curwin
->w_skipcol
!= 0)
365 curwin
->w_skipcol
= 0;
366 redraw_later(NOT_VALID
);
370 /* May need to set w_skipcol when cursor in w_topline. */
371 if (curwin
->w_cursor
.lnum
== curwin
->w_topline
)
381 * Return the scrolljump value to use for the current window.
382 * When 'scrolljump' is positive use it as-is.
383 * When 'scrolljump' is negative use it as a percentage of the window height.
390 return (curwin
->w_height
* -p_sj
) / 100;
394 * Return TRUE when there are not 'scrolloff' lines above the cursor for the
403 if (curwin
->w_cursor
.lnum
< curwin
->w_topline
+ p_so
405 || hasAnyFolding(curwin
)
409 loff
.lnum
= curwin
->w_cursor
.lnum
;
412 n
= curwin
->w_topfill
; /* always have this context */
416 /* Count the visible screen lines above the cursor line. */
420 /* Stop when included a line above the window. */
421 if (loff
.lnum
< curwin
->w_topline
423 || (loff
.lnum
== curwin
->w_topline
&& loff
.fill
> 0)
438 if (curwin
->w_set_curswant
)
441 curwin
->w_curswant
= curwin
->w_virtcol
;
442 curwin
->w_set_curswant
= FALSE
;
447 * Check if the cursor has moved. Set the w_valid flag accordingly.
450 check_cursor_moved(wp
)
453 if (wp
->w_cursor
.lnum
!= wp
->w_valid_cursor
.lnum
)
455 wp
->w_valid
&= ~(VALID_WROW
|VALID_WCOL
|VALID_VIRTCOL
456 |VALID_CHEIGHT
|VALID_CROW
|VALID_TOPLINE
);
457 wp
->w_valid_cursor
= wp
->w_cursor
;
458 wp
->w_valid_leftcol
= wp
->w_leftcol
;
460 else if (wp
->w_cursor
.col
!= wp
->w_valid_cursor
.col
461 || wp
->w_leftcol
!= wp
->w_valid_leftcol
462 #ifdef FEAT_VIRTUALEDIT
463 || wp
->w_cursor
.coladd
!= wp
->w_valid_cursor
.coladd
467 wp
->w_valid
&= ~(VALID_WROW
|VALID_WCOL
|VALID_VIRTCOL
);
468 wp
->w_valid_cursor
.col
= wp
->w_cursor
.col
;
469 wp
->w_valid_leftcol
= wp
->w_leftcol
;
470 #ifdef FEAT_VIRTUALEDIT
471 wp
->w_valid_cursor
.coladd
= wp
->w_cursor
.coladd
;
477 * Call this function when some window settings have changed, which require
478 * the cursor position, botline and topline to be recomputed and the window to
479 * be redrawn. E.g, when changing the 'wrap' option or folding.
482 changed_window_setting()
484 changed_window_setting_win(curwin
);
488 changed_window_setting_win(wp
)
491 wp
->w_lines_valid
= 0;
492 changed_line_abv_curs_win(wp
);
493 wp
->w_valid
&= ~(VALID_BOTLINE
|VALID_BOTLINE_AP
|VALID_TOPLINE
);
494 redraw_win_later(wp
, NOT_VALID
);
498 * Set wp->w_topline to a certain number.
501 set_topline(wp
, lnum
)
506 /* go to first of folded lines */
507 (void)hasFoldingWin(wp
, lnum
, &lnum
, NULL
, TRUE
, NULL
);
509 /* Approximate the value of w_botline */
510 wp
->w_botline
+= lnum
- wp
->w_topline
;
511 wp
->w_topline
= lnum
;
515 wp
->w_valid
&= ~(VALID_WROW
|VALID_CROW
|VALID_BOTLINE
|VALID_TOPLINE
);
516 /* Don't set VALID_TOPLINE here, 'scrolloff' needs to be checked. */
521 * Call this function when the length of the cursor line (in screen
522 * characters) has changed, and the change is before the cursor.
523 * Need to take care of w_botline separately!
526 changed_cline_bef_curs()
528 curwin
->w_valid
&= ~(VALID_WROW
|VALID_WCOL
|VALID_VIRTCOL
529 |VALID_CHEIGHT
|VALID_TOPLINE
);
533 changed_cline_bef_curs_win(wp
)
536 wp
->w_valid
&= ~(VALID_WROW
|VALID_WCOL
|VALID_VIRTCOL
537 |VALID_CHEIGHT
|VALID_TOPLINE
);
542 * Call this function when the length of the cursor line (in screen
543 * characters) has changed, and the position of the cursor doesn't change.
544 * Need to take care of w_botline separately!
547 changed_cline_aft_curs()
549 curwin
->w_valid
&= ~VALID_CHEIGHT
;
554 * Call this function when the length of a line (in screen characters) above
555 * the cursor have changed.
556 * Need to take care of w_botline separately!
559 changed_line_abv_curs()
561 curwin
->w_valid
&= ~(VALID_WROW
|VALID_WCOL
|VALID_VIRTCOL
|VALID_CROW
562 |VALID_CHEIGHT
|VALID_TOPLINE
);
566 changed_line_abv_curs_win(wp
)
569 wp
->w_valid
&= ~(VALID_WROW
|VALID_WCOL
|VALID_VIRTCOL
|VALID_CROW
570 |VALID_CHEIGHT
|VALID_TOPLINE
);
574 * Make sure the value of curwin->w_botline is valid.
579 if (!(curwin
->w_valid
& VALID_BOTLINE
))
580 comp_botline(curwin
);
584 * Make sure the value of wp->w_botline is valid.
587 validate_botline_win(wp
)
590 if (!(wp
->w_valid
& VALID_BOTLINE
))
595 * Mark curwin->w_botline as invalid (because of some change in the buffer).
600 curwin
->w_valid
&= ~(VALID_BOTLINE
|VALID_BOTLINE_AP
);
604 invalidate_botline_win(wp
)
607 wp
->w_valid
&= ~(VALID_BOTLINE
|VALID_BOTLINE_AP
);
610 #if 0 /* never used */
612 * Mark curwin->w_botline as approximated (because of some small change in the
616 approximate_botline()
618 curwin
->w_valid
&= ~VALID_BOTLINE
;
623 approximate_botline_win(wp
)
626 wp
->w_valid
&= ~VALID_BOTLINE
;
631 * Return TRUE if curwin->w_botline is valid.
636 return (curwin
->w_valid
& VALID_BOTLINE
);
642 * Return TRUE if curwin->w_botline is valid or approximated.
645 botline_approximated()
647 return (curwin
->w_valid
& VALID_BOTLINE_AP
);
652 * Return TRUE if curwin->w_wrow and curwin->w_wcol are valid.
657 check_cursor_moved(curwin
);
658 return ((curwin
->w_valid
& (VALID_WROW
|VALID_WCOL
)) ==
659 (VALID_WROW
|VALID_WCOL
));
663 * Validate cursor position. Makes sure w_wrow and w_wcol are valid.
664 * w_topline must be valid, you may need to call update_topline() first!
669 check_cursor_moved(curwin
);
670 if ((curwin
->w_valid
& (VALID_WCOL
|VALID_WROW
)) != (VALID_WCOL
|VALID_WROW
))
674 #if defined(FEAT_GUI) || defined(PROTO)
676 * validate w_cline_row.
682 * First make sure that w_topline is valid (after moving the cursor).
685 check_cursor_moved(curwin
);
686 if (!(curwin
->w_valid
& VALID_CROW
))
687 curs_rows(curwin
, FALSE
);
692 * Compute wp->w_cline_row and wp->w_cline_height, based on the current value
695 * Returns OK when cursor is in the window, FAIL when it isn't.
698 curs_rows(wp
, do_botline
)
700 int do_botline
; /* also compute w_botline */
710 /* Check if wp->w_lines[].wl_size is invalid */
711 all_invalid
= (!redrawing()
712 || wp
->w_lines_valid
== 0
713 || wp
->w_lines
[0].wl_lnum
> wp
->w_topline
);
716 for (lnum
= wp
->w_topline
; lnum
< wp
->w_cursor
.lnum
; ++i
)
719 if (!all_invalid
&& i
< wp
->w_lines_valid
)
721 if (wp
->w_lines
[i
].wl_lnum
< lnum
|| !wp
->w_lines
[i
].wl_valid
)
722 continue; /* skip changed or deleted lines */
723 if (wp
->w_lines
[i
].wl_lnum
== lnum
)
726 /* Check for newly inserted lines below this row, in which
727 * case we need to check for folded lines. */
728 if (!wp
->w_buffer
->b_mod_set
729 || wp
->w_lines
[i
].wl_lastlnum
< wp
->w_cursor
.lnum
730 || wp
->w_buffer
->b_mod_top
731 > wp
->w_lines
[i
].wl_lastlnum
+ 1)
735 else if (wp
->w_lines
[i
].wl_lnum
> lnum
)
736 --i
; /* hold at inserted lines */
740 && (lnum
!= wp
->w_topline
|| !wp
->w_p_diff
)
745 lnum
= wp
->w_lines
[i
].wl_lastlnum
+ 1;
746 /* Cursor inside folded lines, don't count this row */
747 if (lnum
> wp
->w_cursor
.lnum
)
752 wp
->w_cline_row
+= wp
->w_lines
[i
].wl_size
;
757 fold_count
= foldedCount(wp
, lnum
, NULL
);
761 if (lnum
> wp
->w_cursor
.lnum
)
768 if (lnum
== wp
->w_topline
)
769 wp
->w_cline_row
+= plines_win_nofill(wp
, lnum
++, TRUE
)
773 wp
->w_cline_row
+= plines_win(wp
, lnum
++, TRUE
);
777 check_cursor_moved(wp
);
778 if (!(wp
->w_valid
& VALID_CHEIGHT
))
781 || i
== wp
->w_lines_valid
782 || (i
< wp
->w_lines_valid
783 && (!wp
->w_lines
[i
].wl_valid
784 || wp
->w_lines
[i
].wl_lnum
!= wp
->w_cursor
.lnum
)))
787 if (wp
->w_cursor
.lnum
== wp
->w_topline
)
788 wp
->w_cline_height
= plines_win_nofill(wp
, wp
->w_cursor
.lnum
,
789 TRUE
) + wp
->w_topfill
;
792 wp
->w_cline_height
= plines_win(wp
, wp
->w_cursor
.lnum
, TRUE
);
794 wp
->w_cline_folded
= hasFoldingWin(wp
, wp
->w_cursor
.lnum
,
795 NULL
, NULL
, TRUE
, NULL
);
798 else if (i
> wp
->w_lines_valid
)
800 /* a line that is too long to fit on the last screen line */
801 wp
->w_cline_height
= 0;
803 wp
->w_cline_folded
= hasFoldingWin(wp
, wp
->w_cursor
.lnum
,
804 NULL
, NULL
, TRUE
, NULL
);
809 wp
->w_cline_height
= wp
->w_lines
[i
].wl_size
;
811 wp
->w_cline_folded
= wp
->w_lines
[i
].wl_folded
;
816 wp
->w_valid
|= VALID_CROW
|VALID_CHEIGHT
;
818 /* validate botline too, if update_screen doesn't do it */
819 if (do_botline
&& all_invalid
)
820 validate_botline_win(wp
);
824 * Validate curwin->w_virtcol only.
829 validate_virtcol_win(curwin
);
833 * Validate wp->w_virtcol only.
836 validate_virtcol_win(wp
)
839 check_cursor_moved(wp
);
840 if (!(wp
->w_valid
& VALID_VIRTCOL
))
842 getvvcol(wp
, &wp
->w_cursor
, NULL
, &(wp
->w_virtcol
), NULL
);
843 wp
->w_valid
|= VALID_VIRTCOL
;
846 # ifdef FEAT_INS_EXPAND
850 redraw_win_later(wp
, SOME_VALID
);
856 * Validate curwin->w_cline_height only.
861 check_cursor_moved(curwin
);
862 if (!(curwin
->w_valid
& VALID_CHEIGHT
))
865 if (curwin
->w_cursor
.lnum
== curwin
->w_topline
)
866 curwin
->w_cline_height
= plines_nofill(curwin
->w_cursor
.lnum
)
870 curwin
->w_cline_height
= plines(curwin
->w_cursor
.lnum
);
872 curwin
->w_cline_folded
= hasFolding(curwin
->w_cursor
.lnum
, NULL
, NULL
);
874 curwin
->w_valid
|= VALID_CHEIGHT
;
879 * Validate w_wcol and w_virtcol only.
882 validate_cursor_col()
888 if (!(curwin
->w_valid
& VALID_WCOL
))
890 col
= curwin
->w_virtcol
;
891 off
= curwin_col_off();
894 /* long line wrapping, adjust curwin->w_wrow */
896 && col
>= (colnr_T
)W_WIDTH(curwin
)
897 && W_WIDTH(curwin
) - off
+ curwin_col_off2() > 0)
899 col
-= W_WIDTH(curwin
);
900 col
= col
% (W_WIDTH(curwin
) - off
+ curwin_col_off2());
902 if (col
> (int)curwin
->w_leftcol
)
903 col
-= curwin
->w_leftcol
;
906 curwin
->w_wcol
= col
;
908 curwin
->w_valid
|= VALID_WCOL
;
913 * Compute offset of a window, occupied by line number, fold column and sign
914 * column (these don't move when scrolling horizontally).
920 return ((wp
->w_p_nu
? number_width(wp
) + 1 : 0)
922 + (cmdwin_type
== 0 || wp
!= curwin
? 0 : 1)
929 # ifdef FEAT_NETBEANS_INTG
930 /* always show glyph gutter in netbeans */
933 wp
->w_buffer
->b_signlist
!= NULL
? 2 : 0)
941 return win_col_off(curwin
);
945 * Return the difference in column offset for the second screen line of a
946 * wrapped line. It's 8 if 'number' is on and 'n' is in 'cpoptions'.
952 if (wp
->w_p_nu
&& vim_strchr(p_cpo
, CPO_NUMCOL
) != NULL
)
953 return number_width(wp
) + 1;
960 return win_col_off2(curwin
);
964 * compute curwin->w_wcol and curwin->w_virtcol.
965 * Also updates curwin->w_wrow and curwin->w_cline_row.
966 * Also updates curwin->w_leftcol.
970 int scroll
; /* when TRUE, may scroll horizontally */
973 int extra
; /* offset for first screen line */
974 int off_left
, off_right
;
982 colnr_T prev_skipcol
;
985 * First make sure that w_topline is valid (after moving the cursor).
990 * Next make sure that w_cline_row is valid.
992 if (!(curwin
->w_valid
& VALID_CROW
))
993 curs_rows(curwin
, FALSE
);
996 * Compute the number of virtual columns.
999 if (curwin
->w_cline_folded
)
1000 /* In a folded line the cursor is always in the first column */
1001 startcol
= curwin
->w_virtcol
= endcol
= curwin
->w_leftcol
;
1004 getvvcol(curwin
, &curwin
->w_cursor
,
1005 &startcol
, &(curwin
->w_virtcol
), &endcol
);
1007 /* remove '$' from change command when cursor moves onto it */
1008 if (startcol
> dollar_vcol
)
1011 extra
= curwin_col_off();
1012 curwin
->w_wcol
= curwin
->w_virtcol
+ extra
;
1016 * Now compute w_wrow, counting screen lines from w_cline_row.
1018 curwin
->w_wrow
= curwin
->w_cline_row
;
1020 textwidth
= W_WIDTH(curwin
) - extra
;
1023 /* No room for text, put cursor in last char of window. */
1024 curwin
->w_wcol
= W_WIDTH(curwin
) - 1;
1025 curwin
->w_wrow
= curwin
->w_height
- 1;
1027 else if (curwin
->w_p_wrap
1028 #ifdef FEAT_VERTSPLIT
1029 && curwin
->w_width
!= 0
1033 width
= textwidth
+ curwin_col_off2();
1035 /* long line wrapping, adjust curwin->w_wrow */
1036 if (curwin
->w_wcol
>= W_WIDTH(curwin
))
1038 n
= (curwin
->w_wcol
- W_WIDTH(curwin
)) / width
+ 1;
1039 curwin
->w_wcol
-= n
* width
;
1040 curwin
->w_wrow
+= n
;
1042 #ifdef FEAT_LINEBREAK
1043 /* When cursor wraps to first char of next line in Insert
1044 * mode, the 'showbreak' string isn't shown, backup to first
1046 if (*p_sbr
&& *ml_get_cursor() == NUL
1047 && curwin
->w_wcol
== (int)vim_strsize(p_sbr
))
1053 /* No line wrapping: compute curwin->w_leftcol if scrolling is on and line
1055 * If scrolling is off, curwin->w_leftcol is assumed to be 0 */
1058 && !curwin
->w_cline_folded
1063 * If Cursor is left of the screen, scroll rightwards.
1064 * If Cursor is right of the screen, scroll leftwards
1065 * If we get closer to the edge than 'sidescrolloff', scroll a little
1068 off_left
= (int)startcol
- (int)curwin
->w_leftcol
- p_siso
;
1069 off_right
= (int)endcol
- (int)(curwin
->w_leftcol
+ W_WIDTH(curwin
)
1071 if (off_left
< 0 || off_right
> 0)
1078 /* When far off or not enough room on either side, put cursor in
1079 * middle of window. */
1080 if (p_ss
== 0 || diff
>= textwidth
/ 2 || off_right
>= off_left
)
1081 new_leftcol
= curwin
->w_wcol
- extra
- textwidth
/ 2;
1087 new_leftcol
= curwin
->w_leftcol
- diff
;
1089 new_leftcol
= curwin
->w_leftcol
+ diff
;
1091 if (new_leftcol
< 0)
1093 if (new_leftcol
!= (int)curwin
->w_leftcol
)
1095 curwin
->w_leftcol
= new_leftcol
;
1096 /* screen has to be redrawn with new curwin->w_leftcol */
1097 redraw_later(NOT_VALID
);
1100 curwin
->w_wcol
-= curwin
->w_leftcol
;
1102 else if (curwin
->w_wcol
> (int)curwin
->w_leftcol
)
1103 curwin
->w_wcol
-= curwin
->w_leftcol
;
1108 /* Skip over filler lines. At the top use w_topfill, there
1109 * may be some filler lines above the window. */
1110 if (curwin
->w_cursor
.lnum
== curwin
->w_topline
)
1111 curwin
->w_wrow
+= curwin
->w_topfill
;
1113 curwin
->w_wrow
+= diff_check_fill(curwin
, curwin
->w_cursor
.lnum
);
1116 prev_skipcol
= curwin
->w_skipcol
;
1119 if ((curwin
->w_wrow
>= curwin
->w_height
1120 || ((prev_skipcol
> 0
1121 || curwin
->w_wrow
+ p_so
>= curwin
->w_height
)
1128 (curwin
, curwin
->w_cursor
.lnum
, FALSE
))
1129 - 1 >= curwin
->w_height
))
1130 && curwin
->w_height
!= 0
1131 && curwin
->w_cursor
.lnum
== curwin
->w_topline
1133 #ifdef FEAT_VERTSPLIT
1134 && curwin
->w_width
!= 0
1138 /* Cursor past end of screen. Happens with a single line that does
1139 * not fit on screen. Find a skipcol to show the text around the
1140 * cursor. Avoid scrolling all the time. compute value of "extra":
1141 * 1: Less than "p_so" lines above
1142 * 2: Less than "p_so" lines below
1143 * 3: both of them */
1145 if (curwin
->w_skipcol
+ p_so
* width
> curwin
->w_virtcol
)
1147 /* Compute last display line of the buffer line that we want at the
1148 * bottom of the window. */
1150 p_lines
= plines_win(curwin
, curwin
->w_cursor
.lnum
, FALSE
);
1152 if (p_lines
> curwin
->w_wrow
+ p_so
)
1153 n
= curwin
->w_wrow
+ p_so
;
1156 if ((colnr_T
)n
>= curwin
->w_height
+ curwin
->w_skipcol
/ width
)
1159 if (extra
== 3 || p_lines
< p_so
* 2)
1161 /* not enough room for 'scrolloff', put cursor in the middle */
1162 n
= curwin
->w_virtcol
/ width
;
1163 if (n
> curwin
->w_height
/ 2)
1164 n
-= curwin
->w_height
/ 2;
1167 /* don't skip more than necessary */
1168 if (n
> p_lines
- curwin
->w_height
+ 1)
1169 n
= p_lines
- curwin
->w_height
+ 1;
1170 curwin
->w_skipcol
= n
* width
;
1172 else if (extra
== 1)
1174 /* less then 'scrolloff' lines above, decrease skipcol */
1175 extra
= (curwin
->w_skipcol
+ p_so
* width
- curwin
->w_virtcol
1176 + width
- 1) / width
;
1179 if ((colnr_T
)(extra
* width
) > curwin
->w_skipcol
)
1180 extra
= curwin
->w_skipcol
/ width
;
1181 curwin
->w_skipcol
-= extra
* width
;
1184 else if (extra
== 2)
1186 /* less then 'scrolloff' lines below, increase skipcol */
1187 endcol
= (n
- curwin
->w_height
+ 1) * width
;
1188 while (endcol
> curwin
->w_virtcol
)
1190 if (endcol
> curwin
->w_skipcol
)
1191 curwin
->w_skipcol
= endcol
;
1194 curwin
->w_wrow
-= curwin
->w_skipcol
/ width
;
1195 if (curwin
->w_wrow
>= curwin
->w_height
)
1197 /* small window, make sure cursor is in it */
1198 extra
= curwin
->w_wrow
- curwin
->w_height
+ 1;
1199 curwin
->w_skipcol
+= extra
* width
;
1200 curwin
->w_wrow
-= extra
;
1203 extra
= ((int)prev_skipcol
- (int)curwin
->w_skipcol
) / width
;
1205 win_ins_lines(curwin
, 0, extra
, FALSE
, FALSE
);
1207 win_del_lines(curwin
, 0, -extra
, FALSE
, FALSE
);
1210 curwin
->w_skipcol
= 0;
1211 if (prev_skipcol
!= curwin
->w_skipcol
)
1212 redraw_later(NOT_VALID
);
1215 /* Redraw when w_virtcol changes and 'cursorcolumn' is set, or when w_row
1216 * changes and 'cursorline' is set. */
1217 if (((curwin
->w_p_cuc
&& (curwin
->w_valid
& VALID_VIRTCOL
) == 0)
1218 || (curwin
->w_p_cul
&& (curwin
->w_valid
& VALID_WROW
) == 0))
1219 # ifdef FEAT_INS_EXPAND
1223 redraw_later(SOME_VALID
);
1226 curwin
->w_valid
|= VALID_WCOL
|VALID_WROW
|VALID_VIRTCOL
;
1230 * Scroll the current window down by "line_count" logical lines. "CTRL-Y"
1234 scrolldown(line_count
, byfold
)
1236 int byfold
; /* TRUE: count a closed fold as one line */
1238 long done
= 0; /* total # of physical lines done */
1245 /* Make sure w_topline is at the first of a sequence of folded lines. */
1246 (void)hasFolding(curwin
->w_topline
, &curwin
->w_topline
, NULL
);
1248 validate_cursor(); /* w_wrow needs to be valid */
1249 while (line_count
-- > 0)
1252 if (curwin
->w_topfill
< diff_check(curwin
, curwin
->w_topline
))
1254 ++curwin
->w_topfill
;
1260 if (curwin
->w_topline
== 1)
1262 --curwin
->w_topline
;
1264 curwin
->w_topfill
= 0;
1267 /* A sequence of folded lines only counts for one logical line */
1268 if (hasFolding(curwin
->w_topline
, &first
, NULL
))
1272 line_count
-= curwin
->w_topline
- first
- 1;
1273 curwin
->w_botline
-= curwin
->w_topline
- first
;
1274 curwin
->w_topline
= first
;
1279 done
+= plines_nofill(curwin
->w_topline
);
1281 done
+= plines(curwin
->w_topline
);
1284 --curwin
->w_botline
; /* approximate w_botline */
1285 invalidate_botline();
1287 curwin
->w_wrow
+= done
; /* keep w_wrow updated */
1288 curwin
->w_cline_row
+= done
; /* keep w_cline_row updated */
1291 if (curwin
->w_cursor
.lnum
== curwin
->w_topline
)
1292 curwin
->w_cline_row
= 0;
1293 check_topfill(curwin
, TRUE
);
1297 * Compute the row number of the last row of the cursor line
1298 * and move the cursor onto the displayed part of the window.
1300 wrow
= curwin
->w_wrow
;
1301 if (curwin
->w_p_wrap
1302 #ifdef FEAT_VERTSPLIT
1303 && curwin
->w_width
!= 0
1309 wrow
+= curwin
->w_cline_height
- 1 -
1310 curwin
->w_virtcol
/ W_WIDTH(curwin
);
1312 while (wrow
>= curwin
->w_height
&& curwin
->w_cursor
.lnum
> 1)
1315 if (hasFolding(curwin
->w_cursor
.lnum
, &first
, NULL
))
1319 curwin
->w_cursor
.lnum
= 1;
1321 curwin
->w_cursor
.lnum
= first
- 1;
1325 wrow
-= plines(curwin
->w_cursor
.lnum
--);
1327 ~(VALID_WROW
|VALID_WCOL
|VALID_CHEIGHT
|VALID_CROW
|VALID_VIRTCOL
);
1333 /* Move cursor to first line of closed fold. */
1336 coladvance(curwin
->w_curswant
);
1341 * Scroll the current window up by "line_count" logical lines. "CTRL-E"
1345 scrollup(line_count
, byfold
)
1347 int byfold
; /* TRUE: count a closed fold as one line */
1349 #if defined(FEAT_FOLDING) || defined(FEAT_DIFF)
1353 # ifdef FEAT_FOLDING
1354 (byfold
&& hasAnyFolding(curwin
))
1364 /* count each sequence of folded lines as one logical line */
1365 lnum
= curwin
->w_topline
;
1366 while (line_count
--)
1369 if (curwin
->w_topfill
> 0)
1370 --curwin
->w_topfill
;
1374 # ifdef FEAT_FOLDING
1376 (void)hasFolding(lnum
, NULL
, &lnum
);
1378 if (lnum
>= curbuf
->b_ml
.ml_line_count
)
1382 curwin
->w_topfill
= diff_check_fill(curwin
, lnum
);
1386 /* approximate w_botline */
1387 curwin
->w_botline
+= lnum
- curwin
->w_topline
;
1388 curwin
->w_topline
= lnum
;
1393 curwin
->w_topline
+= line_count
;
1394 curwin
->w_botline
+= line_count
; /* approximate w_botline */
1397 if (curwin
->w_topline
> curbuf
->b_ml
.ml_line_count
)
1398 curwin
->w_topline
= curbuf
->b_ml
.ml_line_count
;
1399 if (curwin
->w_botline
> curbuf
->b_ml
.ml_line_count
+ 1)
1400 curwin
->w_botline
= curbuf
->b_ml
.ml_line_count
+ 1;
1403 check_topfill(curwin
, FALSE
);
1407 if (hasAnyFolding(curwin
))
1408 /* Make sure w_topline is at the first of a sequence of folded lines. */
1409 (void)hasFolding(curwin
->w_topline
, &curwin
->w_topline
, NULL
);
1412 curwin
->w_valid
&= ~(VALID_WROW
|VALID_CROW
|VALID_BOTLINE
);
1413 if (curwin
->w_cursor
.lnum
< curwin
->w_topline
)
1415 curwin
->w_cursor
.lnum
= curwin
->w_topline
;
1417 ~(VALID_WROW
|VALID_WCOL
|VALID_CHEIGHT
|VALID_CROW
|VALID_VIRTCOL
);
1418 coladvance(curwin
->w_curswant
);
1424 * Don't end up with too many filler lines in the window.
1427 check_topfill(wp
, down
)
1429 int down
; /* when TRUE scroll down when not enough space */
1433 if (wp
->w_topfill
> 0)
1435 n
= plines_win_nofill(wp
, wp
->w_topline
, TRUE
);
1436 if (wp
->w_topfill
+ n
> wp
->w_height
)
1438 if (down
&& wp
->w_topline
> 1)
1445 wp
->w_topfill
= wp
->w_height
- n
;
1446 if (wp
->w_topfill
< 0)
1454 * Use as many filler lines as possible for w_topline. Make sure w_topline
1462 n
= plines_nofill(curwin
->w_topline
);
1463 if (n
>= curwin
->w_height
)
1464 curwin
->w_topfill
= 0;
1467 curwin
->w_topfill
= diff_check_fill(curwin
, curwin
->w_topline
);
1468 if (curwin
->w_topfill
+ n
> curwin
->w_height
)
1469 curwin
->w_topfill
= curwin
->w_height
- n
;
1474 #if defined(FEAT_INS_EXPAND) || defined(PROTO)
1476 * Scroll the screen one line down, but don't do it if it would move the
1477 * cursor off the screen.
1484 int can_fill
= (curwin
->w_topfill
1485 < diff_check_fill(curwin
, curwin
->w_topline
));
1488 if (curwin
->w_topline
<= 1
1495 validate_cursor(); /* w_wrow needs to be valid */
1498 * Compute the row number of the last row of the cursor line
1499 * and make sure it doesn't go off the screen. Make sure the cursor
1500 * doesn't go past 'scrolloff' lines from the screen end.
1502 end_row
= curwin
->w_wrow
;
1507 end_row
+= plines_nofill(curwin
->w_topline
- 1);
1509 end_row
+= plines(curwin
->w_topline
- 1);
1511 if (curwin
->w_p_wrap
1512 #ifdef FEAT_VERTSPLIT
1513 && curwin
->w_width
!= 0
1519 end_row
+= curwin
->w_cline_height
- 1 -
1520 curwin
->w_virtcol
/ W_WIDTH(curwin
);
1522 if (end_row
< curwin
->w_height
- p_so
)
1527 ++curwin
->w_topfill
;
1528 check_topfill(curwin
, TRUE
);
1532 --curwin
->w_topline
;
1533 curwin
->w_topfill
= 0;
1536 --curwin
->w_topline
;
1539 hasFolding(curwin
->w_topline
, &curwin
->w_topline
, NULL
);
1541 --curwin
->w_botline
; /* approximate w_botline */
1542 curwin
->w_valid
&= ~(VALID_WROW
|VALID_CROW
|VALID_BOTLINE
);
1547 * Scroll the screen one line up, but don't do it if it would move the cursor
1555 if (curwin
->w_topline
== curbuf
->b_ml
.ml_line_count
1557 && curwin
->w_topfill
== 0
1562 validate_cursor(); /* w_wrow needs to be valid */
1565 * Compute the row number of the first row of the cursor line
1566 * and make sure it doesn't go off the screen. Make sure the cursor
1567 * doesn't go before 'scrolloff' lines from the screen start.
1570 start_row
= curwin
->w_wrow
- plines_nofill(curwin
->w_topline
)
1571 - curwin
->w_topfill
;
1573 start_row
= curwin
->w_wrow
- plines(curwin
->w_topline
);
1575 if (curwin
->w_p_wrap
1576 #ifdef FEAT_VERTSPLIT
1577 && curwin
->w_width
!= 0
1582 start_row
-= curwin
->w_virtcol
/ W_WIDTH(curwin
);
1584 if (start_row
>= p_so
)
1587 if (curwin
->w_topfill
> 0)
1588 --curwin
->w_topfill
;
1593 (void)hasFolding(curwin
->w_topline
, NULL
, &curwin
->w_topline
);
1595 ++curwin
->w_topline
;
1597 ++curwin
->w_botline
; /* approximate w_botline */
1598 curwin
->w_valid
&= ~(VALID_WROW
|VALID_CROW
|VALID_BOTLINE
);
1601 #endif /* FEAT_INS_EXPAND */
1604 * Add one line above "lp->lnum". This can be a filler line, a closed fold or
1605 * a (wrapped) text line. Uses and sets "lp->fill".
1606 * Returns the height of the added line in "lp->height".
1607 * Lines above the first one are incredibly high.
1614 if (lp
->fill
< diff_check_fill(curwin
, lp
->lnum
))
1616 /* Add a filler line. */
1628 lp
->height
= MAXCOL
;
1631 if (hasFolding(lp
->lnum
, &lp
->lnum
, NULL
))
1632 /* Add a closed fold */
1638 lp
->height
= plines_nofill(lp
->lnum
);
1640 lp
->height
= plines(lp
->lnum
);
1647 * Add one line below "lp->lnum". This can be a filler line, a closed fold or
1648 * a (wrapped) text line. Uses and sets "lp->fill".
1649 * Returns the height of the added line in "lp->height".
1650 * Lines below the last one are incredibly high.
1657 if (lp
->fill
< diff_check_fill(curwin
, lp
->lnum
+ 1))
1659 /* Add a filler line. */
1670 if (lp
->lnum
> curbuf
->b_ml
.ml_line_count
)
1671 lp
->height
= MAXCOL
;
1674 if (hasFolding(lp
->lnum
, NULL
, &lp
->lnum
))
1675 /* Add a closed fold */
1681 lp
->height
= plines_nofill(lp
->lnum
);
1683 lp
->height
= plines(lp
->lnum
);
1691 * Switch from including filler lines below lp->lnum to including filler
1692 * lines above loff.lnum + 1. This keeps pointing to the same line.
1693 * When there are no filler lines nothing changes.
1702 lp
->fill
= diff_check_fill(curwin
, lp
->lnum
) - lp
->fill
+ 1;
1707 * Switch from including filler lines above lp->lnum to including filler
1708 * lines below loff.lnum - 1. This keeps pointing to the same line.
1709 * When there are no filler lines nothing changes.
1717 lp
->fill
= diff_check_fill(curwin
, lp
->lnum
) - lp
->fill
+ 1;
1724 * Recompute topline to put the cursor at the top of the window.
1725 * Scroll at least "min_scroll" lines.
1726 * If "always" is TRUE, always set topline (for "zt").
1729 scroll_cursor_top(min_scroll
, always
)
1737 linenr_T top
; /* just above displayed lines */
1738 linenr_T bot
; /* just below displayed lines */
1739 linenr_T old_topline
= curwin
->w_topline
;
1741 linenr_T old_topfill
= curwin
->w_topfill
;
1743 linenr_T new_topline
;
1747 if (mouse_dragging
> 0)
1748 off
= mouse_dragging
- 1;
1752 * Decrease topline until:
1754 * - (part of) the cursor line is moved off the screen or
1755 * - moved at least 'scrolljump' lines and
1756 * - at least 'scrolloff' lines above and below the cursor
1759 used
= curwin
->w_cline_height
;
1760 if (curwin
->w_cursor
.lnum
< curwin
->w_topline
)
1764 if (hasFolding(curwin
->w_cursor
.lnum
, &top
, &bot
))
1772 top
= curwin
->w_cursor
.lnum
- 1;
1773 bot
= curwin
->w_cursor
.lnum
+ 1;
1775 new_topline
= top
+ 1;
1778 /* count filler lines of the cursor window as context */
1779 i
= diff_check_fill(curwin
, curwin
->w_cursor
.lnum
);
1785 * Check if the lines from "top" to "bot" fit in the window. If they do,
1786 * set new_topline and advance "top" and "bot" to include more lines.
1791 if (hasFolding(top
, &top
, NULL
))
1792 /* count one logical line for a sequence of folded lines */
1798 if (extra
+ i
<= off
&& bot
< curbuf
->b_ml
.ml_line_count
)
1801 if (hasFolding(bot
, NULL
, &bot
))
1802 /* count one logical line for a sequence of folded lines */
1806 used
+= plines(bot
);
1808 if (used
> curwin
->w_height
)
1810 if (top
< curwin
->w_topline
)
1814 * If scrolling is needed, scroll at least 'sj' lines.
1816 if ((new_topline
>= curwin
->w_topline
|| scrolled
> min_scroll
)
1827 * If we don't have enough space, put cursor in the middle.
1828 * This makes sure we get the same position when using "k" and "j"
1829 * in a small window.
1831 if (used
> curwin
->w_height
)
1832 scroll_cursor_halfway(FALSE
);
1836 * If "always" is FALSE, only adjust topline to a lower value, higher
1837 * value may happen with wrapping lines
1839 if (new_topline
< curwin
->w_topline
|| always
)
1840 curwin
->w_topline
= new_topline
;
1841 if (curwin
->w_topline
> curwin
->w_cursor
.lnum
)
1842 curwin
->w_topline
= curwin
->w_cursor
.lnum
;
1844 curwin
->w_topfill
= diff_check_fill(curwin
, curwin
->w_topline
);
1845 if (curwin
->w_topfill
> 0 && extra
> off
)
1847 curwin
->w_topfill
-= extra
- off
;
1848 if (curwin
->w_topfill
< 0)
1849 curwin
->w_topfill
= 0;
1851 check_topfill(curwin
, FALSE
);
1853 if (curwin
->w_topline
!= old_topline
1855 || curwin
->w_topfill
!= old_topfill
1859 ~(VALID_WROW
|VALID_CROW
|VALID_BOTLINE
|VALID_BOTLINE_AP
);
1860 curwin
->w_valid
|= VALID_TOPLINE
;
1865 * Set w_empty_rows and w_filler_rows for window "wp", having used up "used"
1866 * screen lines for text lines.
1869 set_empty_rows(wp
, used
)
1874 wp
->w_filler_rows
= 0;
1877 wp
->w_empty_rows
= 0; /* single line that doesn't fit */
1880 wp
->w_empty_rows
= wp
->w_height
- used
;
1882 if (wp
->w_botline
<= wp
->w_buffer
->b_ml
.ml_line_count
)
1884 wp
->w_filler_rows
= diff_check_fill(wp
, wp
->w_botline
);
1885 if (wp
->w_empty_rows
> wp
->w_filler_rows
)
1886 wp
->w_empty_rows
-= wp
->w_filler_rows
;
1889 wp
->w_filler_rows
= wp
->w_empty_rows
;
1890 wp
->w_empty_rows
= 0;
1898 * Recompute topline to put the cursor at the bottom of the window.
1899 * Scroll at least "min_scroll" lines.
1900 * If "set_topbot" is TRUE, set topline and botline first (for "zb").
1901 * This is messy stuff!!!
1904 scroll_cursor_bot(min_scroll
, set_topbot
)
1912 linenr_T line_count
;
1913 linenr_T old_topline
= curwin
->w_topline
;
1917 int old_topfill
= curwin
->w_topfill
;
1918 int fill_below_window
;
1920 linenr_T old_botline
= curwin
->w_botline
;
1921 linenr_T old_valid
= curwin
->w_valid
;
1922 int old_empty_rows
= curwin
->w_empty_rows
;
1923 linenr_T cln
; /* Cursor Line Number */
1925 cln
= curwin
->w_cursor
.lnum
;
1929 curwin
->w_botline
= cln
+ 1;
1933 for (curwin
->w_topline
= curwin
->w_botline
;
1934 curwin
->w_topline
> 1;
1935 curwin
->w_topline
= loff
.lnum
)
1937 loff
.lnum
= curwin
->w_topline
;
1938 topline_back(&loff
);
1939 if (used
+ loff
.height
> curwin
->w_height
)
1941 used
+= loff
.height
;
1943 curwin
->w_topfill
= loff
.fill
;
1946 set_empty_rows(curwin
, used
);
1947 curwin
->w_valid
|= VALID_BOTLINE
|VALID_BOTLINE_AP
;
1948 if (curwin
->w_topline
!= old_topline
1950 || curwin
->w_topfill
!= old_topfill
1953 curwin
->w_valid
&= ~(VALID_WROW
|VALID_CROW
);
1958 /* The lines of the cursor line itself are always used. */
1960 used
= plines_nofill(cln
);
1963 used
= curwin
->w_cline_height
;
1966 /* If the cursor is below botline, we will at least scroll by the height
1967 * of the cursor line. Correct for empty lines, which are really part of
1969 if (cln
>= curwin
->w_botline
)
1972 if (cln
== curwin
->w_botline
)
1973 scrolled
-= curwin
->w_empty_rows
;
1977 * Stop counting lines to scroll when
1978 * - hitting start of the file
1979 * - scrolled nothing or at least 'sj' lines
1980 * - at least 'so' lines below the cursor
1981 * - lines between botline and cursor have been counted
1984 if (!hasFolding(curwin
->w_cursor
.lnum
, &loff
.lnum
, &boff
.lnum
))
1993 fill_below_window
= diff_check_fill(curwin
, curwin
->w_botline
)
1994 - curwin
->w_filler_rows
;
1997 while (loff
.lnum
> 1)
1999 /* Stop when scrolled nothing or at least "min_scroll", found "extra"
2000 * context for 'scrolloff' and counted all lines below the window. */
2001 if ((((scrolled
<= 0 || scrolled
>= min_scroll
)
2004 mouse_dragging
> 0 ? mouse_dragging
- 1 :
2007 || boff
.lnum
+ 1 > curbuf
->b_ml
.ml_line_count
)
2008 && loff
.lnum
<= curwin
->w_botline
2010 && (loff
.lnum
< curwin
->w_botline
2011 || loff
.fill
>= fill_below_window
)
2016 /* Add one line above */
2017 topline_back(&loff
);
2018 used
+= loff
.height
;
2019 if (used
> curwin
->w_height
)
2021 if (loff
.lnum
>= curwin
->w_botline
2023 && (loff
.lnum
> curwin
->w_botline
2024 || loff
.fill
<= fill_below_window
)
2028 /* Count screen lines that are below the window. */
2029 scrolled
+= loff
.height
;
2030 if (loff
.lnum
== curwin
->w_botline
2035 scrolled
-= curwin
->w_empty_rows
;
2038 if (boff
.lnum
< curbuf
->b_ml
.ml_line_count
)
2040 /* Add one line below */
2041 botline_forw(&boff
);
2042 used
+= boff
.height
;
2043 if (used
> curwin
->w_height
)
2047 mouse_dragging
> 0 ? mouse_dragging
- 1 :
2049 p_so
) || scrolled
< min_scroll
)
2051 extra
+= boff
.height
;
2052 if (boff
.lnum
>= curwin
->w_botline
2054 || (boff
.lnum
+ 1 == curwin
->w_botline
2055 && boff
.fill
> curwin
->w_filler_rows
)
2059 /* Count screen lines that are below the window. */
2060 scrolled
+= boff
.height
;
2061 if (boff
.lnum
== curwin
->w_botline
2066 scrolled
-= curwin
->w_empty_rows
;
2072 /* curwin->w_empty_rows is larger, no need to scroll */
2075 /* more than a screenfull, don't scroll but redraw */
2076 else if (used
> curwin
->w_height
)
2078 /* scroll minimal number of lines */
2083 boff
.fill
= curwin
->w_topfill
;
2085 boff
.lnum
= curwin
->w_topline
- 1;
2086 for (i
= 0; i
< scrolled
&& boff
.lnum
< curwin
->w_botline
; )
2088 botline_forw(&boff
);
2092 if (i
< scrolled
) /* below curwin->w_botline, don't scroll */
2097 * Scroll up if the cursor is off the bottom of the screen a bit.
2098 * Otherwise put it at 1/2 of the screen.
2100 if (line_count
>= curwin
->w_height
&& line_count
> min_scroll
)
2101 scroll_cursor_halfway(FALSE
);
2103 scrollup(line_count
, TRUE
);
2106 * If topline didn't change we need to restore w_botline and w_empty_rows
2107 * (we changed them).
2108 * If topline did change, update_screen() will set botline.
2110 if (curwin
->w_topline
== old_topline
&& set_topbot
)
2112 curwin
->w_botline
= old_botline
;
2113 curwin
->w_empty_rows
= old_empty_rows
;
2114 curwin
->w_valid
= old_valid
;
2116 curwin
->w_valid
|= VALID_TOPLINE
;
2120 * Recompute topline to put the cursor halfway the window
2121 * If "atend" is TRUE, also put it halfway at the end of the file.
2124 scroll_cursor_halfway(atend
)
2137 loff
.lnum
= boff
.lnum
= curwin
->w_cursor
.lnum
;
2139 (void)hasFolding(loff
.lnum
, &loff
.lnum
, &boff
.lnum
);
2142 used
= plines_nofill(loff
.lnum
);
2146 used
= plines(loff
.lnum
);
2148 topline
= loff
.lnum
;
2151 if (below
<= above
) /* add a line below the cursor first */
2153 if (boff
.lnum
< curbuf
->b_ml
.ml_line_count
)
2155 botline_forw(&boff
);
2156 used
+= boff
.height
;
2157 if (used
> curwin
->w_height
)
2159 below
+= boff
.height
;
2163 ++below
; /* count a "~" line */
2169 if (below
> above
) /* add a line above the cursor */
2171 topline_back(&loff
);
2172 used
+= loff
.height
;
2173 if (used
> curwin
->w_height
)
2175 above
+= loff
.height
;
2176 topline
= loff
.lnum
;
2178 topfill
= loff
.fill
;
2183 if (!hasFolding(topline
, &curwin
->w_topline
, NULL
))
2185 curwin
->w_topline
= topline
;
2187 curwin
->w_topfill
= topfill
;
2188 check_topfill(curwin
, FALSE
);
2190 curwin
->w_valid
&= ~(VALID_WROW
|VALID_CROW
|VALID_BOTLINE
|VALID_BOTLINE_AP
);
2191 curwin
->w_valid
|= VALID_TOPLINE
;
2195 * Correct the cursor position so that it is in a part of the screen at least
2196 * 'so' lines from the top and bottom, if possible.
2197 * If not possible, put it at the same position as scroll_cursor_halfway().
2198 * When called topline must be valid!
2203 int above
= 0; /* screen lines above topline */
2205 int below
= 0; /* screen lines below botline */
2207 int above_wanted
, below_wanted
;
2208 linenr_T cln
; /* Cursor Line Number */
2212 * How many lines we would like to have above/below the cursor depends on
2213 * whether the first/last line of the file is on screen.
2215 above_wanted
= p_so
;
2216 below_wanted
= p_so
;
2218 if (mouse_dragging
> 0)
2220 above_wanted
= mouse_dragging
- 1;
2221 below_wanted
= mouse_dragging
- 1;
2224 if (curwin
->w_topline
== 1)
2227 max_off
= curwin
->w_height
/ 2;
2228 if (below_wanted
> max_off
)
2229 below_wanted
= max_off
;
2232 if (curwin
->w_botline
== curbuf
->b_ml
.ml_line_count
+ 1
2234 && mouse_dragging
== 0
2239 max_off
= (curwin
->w_height
- 1) / 2;
2240 if (above_wanted
> max_off
)
2241 above_wanted
= max_off
;
2245 * If there are sufficient file-lines above and below the cursor, we can
2248 cln
= curwin
->w_cursor
.lnum
;
2249 if (cln
>= curwin
->w_topline
+ above_wanted
2250 && cln
< curwin
->w_botline
- below_wanted
2252 && !hasAnyFolding(curwin
)
2258 * Narrow down the area where the cursor can be put by taking lines from
2259 * the top and the bottom until:
2260 * - the desired context lines are found
2261 * - the lines from the top is past the lines from the bottom
2263 topline
= curwin
->w_topline
;
2264 botline
= curwin
->w_botline
- 1;
2266 /* count filler lines as context */
2267 above
= curwin
->w_topfill
;
2268 below
= curwin
->w_filler_rows
;
2270 while ((above
< above_wanted
|| below
< below_wanted
) && topline
< botline
)
2272 if (below
< below_wanted
&& (below
<= above
|| above
>= above_wanted
))
2275 if (hasFolding(botline
, &botline
, NULL
))
2279 below
+= plines(botline
);
2282 if (above
< above_wanted
&& (above
< below
|| below
>= below_wanted
))
2285 if (hasFolding(topline
, NULL
, &topline
))
2290 above
+= plines(topline
);
2292 above
+= plines_nofill(topline
);
2294 /* Count filler lines below this line as context. */
2295 if (topline
< botline
)
2296 above
+= diff_check_fill(curwin
, topline
+ 1);
2301 if (topline
== botline
|| botline
== 0)
2302 curwin
->w_cursor
.lnum
= topline
;
2303 else if (topline
> botline
)
2304 curwin
->w_cursor
.lnum
= botline
;
2307 if (cln
< topline
&& curwin
->w_topline
> 1)
2309 curwin
->w_cursor
.lnum
= topline
;
2311 ~(VALID_WROW
|VALID_WCOL
|VALID_CHEIGHT
|VALID_CROW
);
2313 if (cln
> botline
&& curwin
->w_botline
<= curbuf
->b_ml
.ml_line_count
)
2315 curwin
->w_cursor
.lnum
= botline
;
2317 ~(VALID_WROW
|VALID_WCOL
|VALID_CHEIGHT
|VALID_CROW
);
2320 curwin
->w_valid
|= VALID_TOPLINE
;
2323 static void get_scroll_overlap
__ARGS((lineoff_T
*lp
, int dir
));
2326 * move screen 'count' pages up or down and update screen
2328 * return FAIL for failure, OK otherwise
2338 linenr_T old_topline
= curwin
->w_topline
;
2340 if (curbuf
->b_ml
.ml_line_count
== 1) /* nothing to do */
2346 for ( ; count
> 0; --count
)
2350 * It's an error to move a page up when the first line is already on
2351 * the screen. It's an error to move a page down when the last line
2352 * is on the screen and the topline is 'scrolloff' lines from the
2356 ? ((curwin
->w_topline
>= curbuf
->b_ml
.ml_line_count
- p_so
)
2357 && curwin
->w_botline
> curbuf
->b_ml
.ml_line_count
)
2358 : (curwin
->w_topline
== 1
2360 && curwin
->w_topfill
==
2361 diff_check_fill(curwin
, curwin
->w_topline
)
2375 if (firstwin
== lastwin
&& p_window
> 0 && p_window
< Rows
- 1)
2377 /* Vi compatible scrolling */
2379 ++curwin
->w_topline
;
2381 curwin
->w_topline
+= p_window
- 2;
2382 if (curwin
->w_topline
> curbuf
->b_ml
.ml_line_count
)
2383 curwin
->w_topline
= curbuf
->b_ml
.ml_line_count
;
2384 curwin
->w_cursor
.lnum
= curwin
->w_topline
;
2386 else if (curwin
->w_botline
> curbuf
->b_ml
.ml_line_count
)
2388 /* at end of file */
2389 curwin
->w_topline
= curbuf
->b_ml
.ml_line_count
;
2391 curwin
->w_topfill
= 0;
2393 curwin
->w_valid
&= ~(VALID_WROW
|VALID_CROW
);
2397 /* For the overlap, start with the line just below the window
2398 * and go upwards. */
2399 loff
.lnum
= curwin
->w_botline
;
2401 loff
.fill
= diff_check_fill(curwin
, loff
.lnum
)
2402 - curwin
->w_filler_rows
;
2404 get_scroll_overlap(&loff
, -1);
2405 curwin
->w_topline
= loff
.lnum
;
2407 curwin
->w_topfill
= loff
.fill
;
2408 check_topfill(curwin
, FALSE
);
2410 curwin
->w_cursor
.lnum
= curwin
->w_topline
;
2411 curwin
->w_valid
&= ~(VALID_WCOL
|VALID_CHEIGHT
|VALID_WROW
|
2412 VALID_CROW
|VALID_BOTLINE
|VALID_BOTLINE_AP
);
2415 else /* dir == BACKWARDS */
2418 if (curwin
->w_topline
== 1)
2420 /* Include max number of filler lines */
2425 if (firstwin
== lastwin
&& p_window
> 0 && p_window
< Rows
- 1)
2427 /* Vi compatible scrolling (sort of) */
2429 --curwin
->w_topline
;
2431 curwin
->w_topline
-= p_window
- 2;
2432 if (curwin
->w_topline
< 1)
2433 curwin
->w_topline
= 1;
2434 curwin
->w_cursor
.lnum
= curwin
->w_topline
+ p_window
- 1;
2435 if (curwin
->w_cursor
.lnum
> curbuf
->b_ml
.ml_line_count
)
2436 curwin
->w_cursor
.lnum
= curbuf
->b_ml
.ml_line_count
;
2440 /* Find the line at the top of the window that is going to be the
2441 * line at the bottom of the window. Make sure this results in
2442 * the same line as before doing CTRL-F. */
2443 loff
.lnum
= curwin
->w_topline
- 1;
2445 loff
.fill
= diff_check_fill(curwin
, loff
.lnum
+ 1)
2446 - curwin
->w_topfill
;
2448 get_scroll_overlap(&loff
, 1);
2450 if (loff
.lnum
>= curbuf
->b_ml
.ml_line_count
)
2452 loff
.lnum
= curbuf
->b_ml
.ml_line_count
;
2458 botline_topline(&loff
);
2461 curwin
->w_cursor
.lnum
= loff
.lnum
;
2463 /* Find the line just above the new topline to get the right line
2464 * at the bottom of the window. */
2466 while (n
<= curwin
->w_height
&& loff
.lnum
>= 1)
2468 topline_back(&loff
);
2471 if (n
<= curwin
->w_height
) /* at begin of file */
2473 curwin
->w_topline
= 1;
2477 curwin
->w_valid
&= ~(VALID_WROW
|VALID_CROW
|VALID_BOTLINE
);
2481 /* Go two lines forward again. */
2483 topline_botline(&loff
);
2485 botline_forw(&loff
);
2486 botline_forw(&loff
);
2488 botline_topline(&loff
);
2491 /* We're at the wrong end of a fold now. */
2492 (void)hasFolding(loff
.lnum
, &loff
.lnum
, NULL
);
2495 /* Always scroll at least one line. Avoid getting stuck on
2496 * very long lines. */
2497 if (loff
.lnum
>= curwin
->w_topline
2499 && (loff
.lnum
> curwin
->w_topline
2500 || loff
.fill
>= curwin
->w_topfill
)
2505 /* First try using the maximum number of filler lines. If
2506 * that's not enough, backup one line. */
2507 loff
.fill
= curwin
->w_topfill
;
2508 if (curwin
->w_topfill
< diff_check_fill(curwin
,
2511 if (curwin
->w_topfill
== loff
.fill
)
2514 --curwin
->w_topline
;
2516 curwin
->w_topfill
= 0;
2519 comp_botline(curwin
);
2520 curwin
->w_cursor
.lnum
= curwin
->w_botline
- 1;
2521 curwin
->w_valid
&= ~(VALID_WCOL
|VALID_CHEIGHT
|
2522 VALID_WROW
|VALID_CROW
);
2526 curwin
->w_topline
= loff
.lnum
;
2528 curwin
->w_topfill
= loff
.fill
;
2529 check_topfill(curwin
, FALSE
);
2531 curwin
->w_valid
&= ~(VALID_WROW
|VALID_CROW
|VALID_BOTLINE
);
2541 beginline(BL_SOL
| BL_FIX
);
2542 curwin
->w_valid
&= ~(VALID_WCOL
|VALID_WROW
|VALID_VIRTCOL
);
2545 * Avoid the screen jumping up and down when 'scrolloff' is non-zero.
2546 * But make sure we scroll at least one line (happens with mix of long
2547 * wrapping lines and non-wrapping line).
2549 if (retval
== OK
&& dir
== FORWARD
&& check_top_offset())
2551 scroll_cursor_top(1, FALSE
);
2552 if (curwin
->w_topline
<= old_topline
2553 && old_topline
< curbuf
->b_ml
.ml_line_count
)
2555 curwin
->w_topline
= old_topline
+ 1;
2557 (void)hasFolding(curwin
->w_topline
, &curwin
->w_topline
, NULL
);
2562 redraw_later(VALID
);
2567 * Decide how much overlap to use for page-up or page-down scrolling.
2568 * This is symmetric, so that doing both keeps the same lines displayed.
2569 * Three lines are examined:
2571 * before CTRL-F after CTRL-F / before CTRL-B
2573 * l1 last but one line ------------
2574 * l2 last text line l2 top text line
2575 * ------------- l3 second text line
2579 get_scroll_overlap(lp
, dir
)
2584 int min_height
= curwin
->w_height
- 2;
2585 lineoff_T loff0
, loff1
, loff2
;
2591 lp
->height
= plines_nofill(lp
->lnum
);
2593 lp
->height
= plines(lp
->lnum
);
2596 if (h1
> min_height
)
2597 return; /* no overlap */
2605 if (h2
+ h1
> min_height
)
2607 *lp
= loff0
; /* no overlap */
2617 if (h3
+ h2
> min_height
)
2619 *lp
= loff0
; /* no overlap */
2629 if (h4
+ h3
+ h2
> min_height
|| h3
+ h2
+ h1
> min_height
)
2630 *lp
= loff1
; /* 1 line overlap */
2632 *lp
= loff2
; /* 2 lines overlap */
2636 /* #define KEEP_SCREEN_LINE */
2638 * Scroll 'scroll' lines up or down.
2641 halfpage(flag
, Prenum
)
2651 curwin
->w_p_scr
= (Prenum
> curwin
->w_height
) ?
2652 curwin
->w_height
: Prenum
;
2653 n
= (curwin
->w_p_scr
<= curwin
->w_height
) ?
2654 curwin
->w_p_scr
: curwin
->w_height
;
2657 room
= curwin
->w_empty_rows
;
2659 room
+= curwin
->w_filler_rows
;
2664 * scroll the text up
2666 while (n
> 0 && curwin
->w_botline
<= curbuf
->b_ml
.ml_line_count
)
2669 if (curwin
->w_topfill
> 0)
2672 if (--n
< 0 && scrolled
> 0)
2674 --curwin
->w_topfill
;
2680 i
= plines_nofill(curwin
->w_topline
);
2682 i
= plines(curwin
->w_topline
);
2685 if (n
< 0 && scrolled
> 0)
2688 (void)hasFolding(curwin
->w_topline
, NULL
, &curwin
->w_topline
);
2690 ++curwin
->w_topline
;
2692 curwin
->w_topfill
= diff_check_fill(curwin
, curwin
->w_topline
);
2695 #ifndef KEEP_SCREEN_LINE
2696 if (curwin
->w_cursor
.lnum
< curbuf
->b_ml
.ml_line_count
)
2698 ++curwin
->w_cursor
.lnum
;
2700 ~(VALID_VIRTCOL
|VALID_CHEIGHT
|VALID_WCOL
);
2704 curwin
->w_valid
&= ~(VALID_CROW
|VALID_WROW
);
2708 * Correct w_botline for changed w_topline.
2709 * Won't work when there are filler lines.
2712 if (curwin
->w_p_diff
)
2713 curwin
->w_valid
&= ~(VALID_BOTLINE
|VALID_BOTLINE_AP
);
2720 i
= plines(curwin
->w_botline
);
2724 (void)hasFolding(curwin
->w_botline
, NULL
,
2725 &curwin
->w_botline
);
2727 ++curwin
->w_botline
;
2729 } while (curwin
->w_botline
<= curbuf
->b_ml
.ml_line_count
);
2733 #ifndef KEEP_SCREEN_LINE
2735 * When hit bottom of the file: move cursor down.
2739 # ifdef FEAT_FOLDING
2740 if (hasAnyFolding(curwin
))
2743 && curwin
->w_cursor
.lnum
< curbuf
->b_ml
.ml_line_count
)
2745 (void)hasFolding(curwin
->w_cursor
.lnum
, NULL
,
2746 &curwin
->w_cursor
.lnum
);
2747 ++curwin
->w_cursor
.lnum
;
2752 curwin
->w_cursor
.lnum
+= n
;
2753 check_cursor_lnum();
2756 /* try to put the cursor in the same screen line */
2757 while ((curwin
->w_cursor
.lnum
< curwin
->w_topline
|| scrolled
> 0)
2758 && curwin
->w_cursor
.lnum
< curwin
->w_botline
- 1)
2760 scrolled
-= plines(curwin
->w_cursor
.lnum
);
2761 if (scrolled
< 0 && curwin
->w_cursor
.lnum
>= curwin
->w_topline
)
2763 # ifdef FEAT_FOLDING
2764 (void)hasFolding(curwin
->w_cursor
.lnum
, NULL
,
2765 &curwin
->w_cursor
.lnum
);
2767 ++curwin
->w_cursor
.lnum
;
2774 * scroll the text down
2776 while (n
> 0 && curwin
->w_topline
> 1)
2779 if (curwin
->w_topfill
< diff_check_fill(curwin
, curwin
->w_topline
))
2782 if (--n
< 0 && scrolled
> 0)
2784 ++curwin
->w_topfill
;
2790 i
= plines_nofill(curwin
->w_topline
- 1);
2792 i
= plines(curwin
->w_topline
- 1);
2795 if (n
< 0 && scrolled
> 0)
2797 --curwin
->w_topline
;
2799 (void)hasFolding(curwin
->w_topline
, &curwin
->w_topline
, NULL
);
2802 curwin
->w_topfill
= 0;
2805 curwin
->w_valid
&= ~(VALID_CROW
|VALID_WROW
|
2806 VALID_BOTLINE
|VALID_BOTLINE_AP
);
2808 #ifndef KEEP_SCREEN_LINE
2809 if (curwin
->w_cursor
.lnum
> 1)
2811 --curwin
->w_cursor
.lnum
;
2812 curwin
->w_valid
&= ~(VALID_VIRTCOL
|VALID_CHEIGHT
|VALID_WCOL
);
2816 #ifndef KEEP_SCREEN_LINE
2818 * When hit top of the file: move cursor up.
2822 if (curwin
->w_cursor
.lnum
<= (linenr_T
)n
)
2823 curwin
->w_cursor
.lnum
= 1;
2825 # ifdef FEAT_FOLDING
2826 if (hasAnyFolding(curwin
))
2828 while (--n
>= 0 && curwin
->w_cursor
.lnum
> 1)
2830 --curwin
->w_cursor
.lnum
;
2831 (void)hasFolding(curwin
->w_cursor
.lnum
,
2832 &curwin
->w_cursor
.lnum
, NULL
);
2837 curwin
->w_cursor
.lnum
-= n
;
2840 /* try to put the cursor in the same screen line */
2841 scrolled
+= n
; /* move cursor when topline is 1 */
2842 while (curwin
->w_cursor
.lnum
> curwin
->w_topline
2843 && (scrolled
> 0 || curwin
->w_cursor
.lnum
>= curwin
->w_botline
))
2845 scrolled
-= plines(curwin
->w_cursor
.lnum
- 1);
2846 if (scrolled
< 0 && curwin
->w_cursor
.lnum
< curwin
->w_botline
)
2848 --curwin
->w_cursor
.lnum
;
2849 # ifdef FEAT_FOLDING
2855 # ifdef FEAT_FOLDING
2856 /* Move cursor to first line of closed fold. */
2860 check_topfill(curwin
, !flag
);
2863 beginline(BL_SOL
| BL_FIX
);
2864 redraw_later(VALID
);