IntenseFinance/neovim
3
0
Fork 0
mirror of https://github.com/neovim/neovim.git synced 2025-02-25 18:55:25 -06:00
Code Issues Packages Projects Releases Wiki Activity

Scope variables in move.c

Browse Source
This commit is contained in:
Nicolas Cornu 2015-09-08 13:51:36 +02:00
parent 600bb285f6
commit 23acaf8940
1 changed files with 102 additions and 157 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

259
src/nvim/move.c
View File

@ -54,11 +54,8 @@ typedef struct {
*/ */
static void comp_botline(win_T *wp) static void comp_botline(win_T *wp)
{ {
int n;
linenr_T lnum; linenr_T lnum;
int done; int done;
linenr_T last;
bool folded;
/* /*
* If w_cline_row is valid, start there. * If w_cline_row is valid, start there.
@ -74,18 +71,17 @@ static void comp_botline(win_T *wp)
} }
for (; lnum <= wp->w_buffer->b_ml.ml_line_count; ++lnum) { for (; lnum <= wp->w_buffer->b_ml.ml_line_count; ++lnum) {
last = lnum; int n;
folded = false; linenr_T last = lnum;
if (hasFoldingWin(wp, lnum, NULL, &last, true, NULL)) { bool folded = hasFoldingWin(wp, lnum, NULL, &last, true, NULL);
if (folded) {
n = 1; n = 1;
folded = true; } else if (lnum == wp->w_topline) {
} else if (lnum == wp->w_topline)
n = plines_win_nofill(wp, lnum, true) + wp->w_topfill; n = plines_win_nofill(wp, lnum, true) + wp->w_topfill;
else } else {
n = plines_win(wp, lnum, true); n = plines_win(wp, lnum, true);
if ( }
lnum <= wp->w_cursor.lnum && last >= wp->w_cursor.lnum if (lnum <= wp->w_cursor.lnum && last >= wp->w_cursor.lnum) {
) {
wp->w_cline_row = done; wp->w_cline_row = done;
wp->w_cline_height = n; wp->w_cline_height = n;
wp->w_cline_folded = folded; wp->w_cline_folded = folded;
@ -134,12 +130,8 @@ void update_topline_redraw(void)
*/ */
void update_topline(void) void update_topline(void)
{ {
long line_count;
int halfheight;
long n;
linenr_T old_topline; linenr_T old_topline;
int old_topfill; int old_topfill;
linenr_T lnum;
bool check_topline = false; bool check_topline = false;
bool check_botline = false; bool check_botline = false;
long save_so = p_so; long save_so = p_so;
@ -198,16 +190,16 @@ void update_topline(void)
check_topline = true; check_topline = true;
if (check_topline) { if (check_topline) {
halfheight = curwin->w_height / 2 - 1; int halfheight = curwin->w_height / 2 - 1;
if (halfheight < 2) if (halfheight < 2)
halfheight = 2; halfheight = 2;
long n;
if (hasAnyFolding(curwin)) { if (hasAnyFolding(curwin)) {
/* Count the number of logical lines between the cursor and /* Count the number of logical lines between the cursor and
* topline + p_so (approximation of how much will be * topline + p_so (approximation of how much will be
* scrolled). */ * scrolled). */
n = 0; n = 0;
for (lnum = curwin->w_cursor.lnum; for (linenr_T lnum = curwin->w_cursor.lnum;
lnum < curwin->w_topline + p_so; ++lnum) { lnum < curwin->w_topline + p_so; ++lnum) {
++n; ++n;
/* stop at end of file or when we know we are far off */ /* stop at end of file or when we know we are far off */
@ -221,9 +213,9 @@ void update_topline(void)
/* If we weren't very close to begin with, we scroll to put the /* If we weren't very close to begin with, we scroll to put the
* cursor in the middle of the window. Otherwise put the cursor * cursor in the middle of the window. Otherwise put the cursor
* near the top of the window. */ * near the top of the window. */
if (n >= halfheight) if (n >= halfheight) {
scroll_cursor_halfway(false); scroll_cursor_halfway(false);
else { } else {
scroll_cursor_top(scrolljump_value(), false); scroll_cursor_top(scrolljump_value(), false);
check_botline = true; check_botline = true;
} }
@ -257,7 +249,7 @@ void update_topline(void)
/* Cursor is (a few lines) above botline, check if there are /* Cursor is (a few lines) above botline, check if there are
* 'scrolloff' window lines below the cursor. If not, need to * 'scrolloff' window lines below the cursor. If not, need to
* scroll. */ * scroll. */
n = curwin->w_empty_rows; int n = curwin->w_empty_rows;
loff.lnum = curwin->w_cursor.lnum; loff.lnum = curwin->w_cursor.lnum;
/* In a fold go to its last line. */ /* In a fold go to its last line. */
(void)hasFolding(loff.lnum, NULL, &loff.lnum); (void)hasFolding(loff.lnum, NULL, &loff.lnum);
@ -275,17 +267,18 @@ void update_topline(void)
if (n >= p_so) if (n >= p_so)
/* sufficient context, no need to scroll */ /* sufficient context, no need to scroll */
check_botline = false; check_botline = false;
} else } else {
/* sufficient context, no need to scroll */ /* sufficient context, no need to scroll */
check_botline = false; check_botline = false;
}
} }
if (check_botline) { if (check_botline) {
long line_count = 0;
if (hasAnyFolding(curwin)) { if (hasAnyFolding(curwin)) {
/* Count the number of logical lines between the cursor and /* Count the number of logical lines between the cursor and
* botline - p_so (approximation of how much will be * botline - p_so (approximation of how much will be
* scrolled). */ * scrolled). */
line_count = 0; for (linenr_T lnum = curwin->w_cursor.lnum;
for (lnum = curwin->w_cursor.lnum;
lnum >= curwin->w_botline - p_so; --lnum) { lnum >= curwin->w_botline - p_so; --lnum) {
++line_count; ++line_count;
/* stop at end of file or when we know we are far off */ /* stop at end of file or when we know we are far off */
@ -354,15 +347,13 @@ static int scrolljump_value(void)
*/ */
static bool check_top_offset(void) static bool check_top_offset(void)
{ {
lineoff_T loff;
int n;
if (curwin->w_cursor.lnum < curwin->w_topline + p_so if (curwin->w_cursor.lnum < curwin->w_topline + p_so
|| hasAnyFolding(curwin) || hasAnyFolding(curwin)
) { ) {
lineoff_T loff;
loff.lnum = curwin->w_cursor.lnum; loff.lnum = curwin->w_cursor.lnum;
loff.fill = 0; loff.fill = 0;
n = curwin->w_topfill; /* always have this context */ int n = curwin->w_topfill; /* always have this context */
/* Count the visible screen lines above the cursor line. */ /* Count the visible screen lines above the cursor line. */
while (n < p_so) { while (n < p_so) {
topline_back(&loff); topline_back(&loff);
@ -532,20 +523,14 @@ void validate_cursor(void)
*/ */
static void curs_rows(win_T *wp) static void curs_rows(win_T *wp)
{ {
linenr_T lnum;
int i;
int all_invalid;
bool valid;
long fold_count;
/* Check if wp->w_lines[].wl_size is invalid */ /* Check if wp->w_lines[].wl_size is invalid */
all_invalid = (!redrawing() int all_invalid = (!redrawing()
|| wp->w_lines_valid == 0 || wp->w_lines_valid == 0
|| wp->w_lines[0].wl_lnum > wp->w_topline); || wp->w_lines[0].wl_lnum > wp->w_topline);
i = 0; int i = 0;
wp->w_cline_row = 0; wp->w_cline_row = 0;
for (lnum = wp->w_topline; lnum < wp->w_cursor.lnum; ++i) { for (linenr_T lnum = wp->w_topline; lnum < wp->w_cursor.lnum; ++i) {
valid = false; bool valid = false;
if (!all_invalid && i < wp->w_lines_valid) { if (!all_invalid && i < wp->w_lines_valid) {
if (wp->w_lines[i].wl_lnum < lnum || !wp->w_lines[i].wl_valid) if (wp->w_lines[i].wl_lnum < lnum || !wp->w_lines[i].wl_valid)
continue; /* skip changed or deleted lines */ continue; /* skip changed or deleted lines */
@ -557,8 +542,9 @@ static void curs_rows(win_T *wp)
|| wp->w_buffer->b_mod_top || wp->w_buffer->b_mod_top
> wp->w_lines[i].wl_lastlnum + 1) > wp->w_lines[i].wl_lastlnum + 1)
valid = true; valid = true;
} else if (wp->w_lines[i].wl_lnum > lnum) } else if (wp->w_lines[i].wl_lnum > lnum) {
--i; /* hold at inserted lines */ --i; /* hold at inserted lines */
}
} }
if (valid if (valid
&& (lnum != wp->w_topline || !wp->w_p_diff) && (lnum != wp->w_topline || !wp->w_p_diff)
@ -569,17 +555,18 @@ static void curs_rows(win_T *wp)
break; break;
wp->w_cline_row += wp->w_lines[i].wl_size; wp->w_cline_row += wp->w_lines[i].wl_size;
} else { } else {
fold_count = foldedCount(wp, lnum, NULL); long fold_count = foldedCount(wp, lnum, NULL);
if (fold_count) { if (fold_count) {
lnum += fold_count; lnum += fold_count;
if (lnum > wp->w_cursor.lnum) if (lnum > wp->w_cursor.lnum)
break; break;
++wp->w_cline_row; ++wp->w_cline_row;
} else if (lnum == wp->w_topline) } else if (lnum == wp->w_topline) {
wp->w_cline_row += plines_win_nofill(wp, lnum++, true) wp->w_cline_row += plines_win_nofill(wp, lnum++, true)
+ wp->w_topfill; + wp->w_topfill;
else } else {
wp->w_cline_row += plines_win(wp, lnum++, true); wp->w_cline_row += plines_win(wp, lnum++, true);
}
} }
} }
@ -658,16 +645,12 @@ static void validate_cheight(void)
*/ */
void validate_cursor_col(void) void validate_cursor_col(void)
{ {
colnr_T off;
colnr_T col;
int width;
validate_virtcol(); validate_virtcol();
if (!(curwin->w_valid & VALID_WCOL)) { if (!(curwin->w_valid & VALID_WCOL)) {
col = curwin->w_virtcol; colnr_T col = curwin->w_virtcol;
off = curwin_col_off(); colnr_T off = curwin_col_off();
col += off; col += off;
width = curwin->w_width - off + curwin_col_off2(); int width = curwin->w_width - off + curwin_col_off2();
/* long line wrapping, adjust curwin->w_wrow */ /* long line wrapping, adjust curwin->w_wrow */
if (curwin->w_p_wrap if (curwin->w_p_wrap
@ -725,19 +708,12 @@ int curwin_col_off2(void)
* Also updates curwin->w_wrow and curwin->w_cline_row. * Also updates curwin->w_wrow and curwin->w_cline_row.
* Also updates curwin->w_leftcol. * Also updates curwin->w_leftcol.
*/ */
void void curs_columns(
curs_columns (
int may_scroll /* when true, may scroll horizontally */ int may_scroll /* when true, may scroll horizontally */
) )
{ {
int diff;
int extra; /* offset for first screen line */
int off_left, off_right;
int n; int n;
int p_lines;
int width = 0; int width = 0;
int textwidth;
int new_leftcol;
colnr_T startcol; colnr_T startcol;
colnr_T endcol; colnr_T endcol;
colnr_T prev_skipcol; colnr_T prev_skipcol;
@ -766,7 +742,7 @@ curs_columns (
if (startcol > dollar_vcol) if (startcol > dollar_vcol)
dollar_vcol = -1; dollar_vcol = -1;
extra = curwin_col_off(); int extra = curwin_col_off();
curwin->w_wcol = curwin->w_virtcol + extra; curwin->w_wcol = curwin->w_virtcol + extra;
endcol += extra; endcol += extra;
@ -775,7 +751,7 @@ curs_columns (
*/ */
curwin->w_wrow = curwin->w_cline_row; curwin->w_wrow = curwin->w_cline_row;
textwidth = curwin->w_width - extra; int textwidth = curwin->w_width - extra;
if (textwidth <= 0) { if (textwidth <= 0) {
/* No room for text, put cursor in last char of window. */ /* No room for text, put cursor in last char of window. */
curwin->w_wcol = curwin->w_width - 1; curwin->w_wcol = curwin->w_width - 1;
@ -813,16 +789,15 @@ curs_columns (
* extra * extra
*/ */
assert(p_siso <= INT_MAX); assert(p_siso <= INT_MAX);
off_left = startcol - curwin->w_leftcol - (int)p_siso; int off_left = startcol - curwin->w_leftcol - (int)p_siso;
off_right = endcol - curwin->w_leftcol - curwin->w_width + (int)p_siso + 1; int off_right =
endcol - curwin->w_leftcol - curwin->w_width + (int)p_siso + 1;
if (off_left < 0 || off_right > 0) { if (off_left < 0 || off_right > 0) {
if (off_left < 0) int diff = (off_left < 0) ? -off_left: off_right;
diff = -off_left;
else
diff = off_right;
/* When far off or not enough room on either side, put cursor in /* When far off or not enough room on either side, put cursor in
* middle of window. */ * middle of window. */
int new_leftcol;
if (p_ss == 0 || diff >= textwidth / 2 || off_right >= off_left) if (p_ss == 0 || diff >= textwidth / 2 || off_right >= off_left)
new_leftcol = curwin->w_wcol - extra - textwidth / 2; new_leftcol = curwin->w_wcol - extra - textwidth / 2;
else { else {
@ -858,7 +833,7 @@ curs_columns (
prev_skipcol = curwin->w_skipcol; prev_skipcol = curwin->w_skipcol;
p_lines = 0; int p_lines = 0;
if ((curwin->w_wrow >= curwin->w_height if ((curwin->w_wrow >= curwin->w_height
|| ((prev_skipcol > 0 || ((prev_skipcol > 0
|| curwin->w_wrow + p_so >= curwin->w_height) || curwin->w_wrow + p_so >= curwin->w_height)
@ -933,12 +908,14 @@ curs_columns (
} }
extra = ((int)prev_skipcol - (int)curwin->w_skipcol) / width; extra = ((int)prev_skipcol - (int)curwin->w_skipcol) / width;
if (extra > 0) if (extra > 0) {
win_ins_lines(curwin, 0, extra, false, false); win_ins_lines(curwin, 0, extra, false, false);
else if (extra < 0) } else if (extra < 0) {
win_del_lines(curwin, 0, -extra, false, false); win_del_lines(curwin, 0, -extra, false, false);
} else }
} else {
curwin->w_skipcol = 0; curwin->w_skipcol = 0;
}
if (prev_skipcol != curwin->w_skipcol) if (prev_skipcol != curwin->w_skipcol)
redraw_later(NOT_VALID); redraw_later(NOT_VALID);
@ -961,10 +938,6 @@ scrolldown (
) )
{ {
int done = 0; /* total # of physical lines done */ int done = 0; /* total # of physical lines done */
int wrow;
bool moved = false;
linenr_T first;
/* Make sure w_topline is at the first of a sequence of folded lines. */ /* Make sure w_topline is at the first of a sequence of folded lines. */
(void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL); (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
@ -980,6 +953,7 @@ scrolldown (
--curwin->w_topline; --curwin->w_topline;
curwin->w_topfill = 0; curwin->w_topfill = 0;
/* A sequence of folded lines only counts for one logical line */ /* A sequence of folded lines only counts for one logical line */
linenr_T first;
if (hasFolding(curwin->w_topline, &first, NULL)) { if (hasFolding(curwin->w_topline, &first, NULL)) {
++done; ++done;
if (!byfold) if (!byfold)
@ -1003,7 +977,7 @@ scrolldown (
* Compute the row number of the last row of the cursor line * Compute the row number of the last row of the cursor line
* and move the cursor onto the displayed part of the window. * and move the cursor onto the displayed part of the window.
*/ */
wrow = curwin->w_wrow; int wrow = curwin->w_wrow;
if (curwin->w_p_wrap if (curwin->w_p_wrap
&& curwin->w_width != 0 && curwin->w_width != 0
) { ) {
@ -1012,7 +986,9 @@ scrolldown (
wrow += curwin->w_cline_height - 1 - wrow += curwin->w_cline_height - 1 -
curwin->w_virtcol / curwin->w_width; curwin->w_virtcol / curwin->w_width;
} }
bool moved = false;
while (wrow >= curwin->w_height && curwin->w_cursor.lnum > 1) { while (wrow >= curwin->w_height && curwin->w_cursor.lnum > 1) {
linenr_T first;
if (hasFolding(curwin->w_cursor.lnum, &first, NULL)) { if (hasFolding(curwin->w_cursor.lnum, &first, NULL)) {
--wrow; --wrow;
if (first == 1) if (first == 1)
@ -1041,15 +1017,13 @@ scrollup (
int byfold /* true: count a closed fold as one line */ int byfold /* true: count a closed fold as one line */
) )
{ {
linenr_T lnum;
if ( if (
(byfold && hasAnyFolding(curwin)) (byfold && hasAnyFolding(curwin))
|| ||
curwin->w_p_diff curwin->w_p_diff
) { ) {
/* count each sequence of folded lines as one logical line */ /* count each sequence of folded lines as one logical line */
lnum = curwin->w_topline; linenr_T lnum = curwin->w_topline;
while (line_count--) { while (line_count--) {
if (curwin->w_topfill > 0) if (curwin->w_topfill > 0)
--curwin->w_topfill; --curwin->w_topfill;
@ -1099,10 +1073,8 @@ check_topfill (
bool down /* when true scroll down when not enough space */ bool down /* when true scroll down when not enough space */
) )
{ {
int n;
if (wp->w_topfill > 0) { if (wp->w_topfill > 0) {
n = plines_win_nofill(wp, wp->w_topline, true); int n = plines_win_nofill(wp, wp->w_topline, true);
if (wp->w_topfill + n > wp->w_height) { if (wp->w_topfill + n > wp->w_height) {
if (down && wp->w_topline > 1) { if (down && wp->w_topline > 1) {
--wp->w_topline; --wp->w_topline;
@ -1122,9 +1094,7 @@ check_topfill (
*/ */
static void max_topfill(void) static void max_topfill(void)
{ {
int n; int n = plines_nofill(curwin->w_topline);
n = plines_nofill(curwin->w_topline);
if (n >= curwin->w_height) if (n >= curwin->w_height)
curwin->w_topfill = 0; curwin->w_topfill = 0;
else { else {
@ -1140,7 +1110,6 @@ static void max_topfill(void)
*/ */
void scrolldown_clamp(void) void scrolldown_clamp(void)
{ {
int end_row;
int can_fill = (curwin->w_topfill int can_fill = (curwin->w_topfill
< diff_check_fill(curwin, curwin->w_topline)); < diff_check_fill(curwin, curwin->w_topline));
@ -1156,7 +1125,7 @@ void scrolldown_clamp(void)
* and make sure it doesn't go off the screen. Make sure the cursor * and make sure it doesn't go off the screen. Make sure the cursor
* doesn't go past 'scrolloff' lines from the screen end. * doesn't go past 'scrolloff' lines from the screen end.
*/ */
end_row = curwin->w_wrow; int end_row = curwin->w_wrow;
if (can_fill) if (can_fill)
++end_row; ++end_row;
else else
@ -1189,8 +1158,6 @@ void scrolldown_clamp(void)
*/ */
void scrollup_clamp(void) void scrollup_clamp(void)
{ {
int start_row;
if (curwin->w_topline == curbuf->b_ml.ml_line_count if (curwin->w_topline == curbuf->b_ml.ml_line_count
&& curwin->w_topfill == 0 && curwin->w_topfill == 0
) )
@ -1203,7 +1170,7 @@ void scrollup_clamp(void)
* and make sure it doesn't go off the screen. Make sure the cursor * and make sure it doesn't go off the screen. Make sure the cursor
* doesn't go before 'scrolloff' lines from the screen start. * doesn't go before 'scrolloff' lines from the screen start.
*/ */
start_row = curwin->w_wrow - plines_nofill(curwin->w_topline) int start_row = curwin->w_wrow - plines_nofill(curwin->w_topline)
- curwin->w_topfill; - curwin->w_topfill;
if (curwin->w_p_wrap if (curwin->w_p_wrap
&& curwin->w_width != 0 && curwin->w_width != 0
@ -1309,9 +1276,6 @@ static void topline_botline(lineoff_T *lp)
void scroll_cursor_top(int min_scroll, int always) void scroll_cursor_top(int min_scroll, int always)
{ {
int scrolled = 0; int scrolled = 0;
int extra = 0;
int used;
int i;
linenr_T top; /* just above displayed lines */ linenr_T top; /* just above displayed lines */
linenr_T bot; /* just below displayed lines */ linenr_T bot; /* just below displayed lines */
linenr_T old_topline = curwin->w_topline; linenr_T old_topline = curwin->w_topline;
@ -1331,7 +1295,7 @@ void scroll_cursor_top(int min_scroll, int always)
* - at least 'scrolloff' lines above and below the cursor * - at least 'scrolloff' lines above and below the cursor
*/ */
validate_cheight(); validate_cheight();
used = curwin->w_cline_height; int used = curwin->w_cline_height;
if (curwin->w_cursor.lnum < curwin->w_topline) if (curwin->w_cursor.lnum < curwin->w_topline)
scrolled = used; scrolled = used;
@ -1345,20 +1309,15 @@ void scroll_cursor_top(int min_scroll, int always)
new_topline = top + 1; new_topline = top + 1;
/* count filler lines of the cursor window as context */ /* count filler lines of the cursor window as context */
i = diff_check_fill(curwin, curwin->w_cursor.lnum); int extra = diff_check_fill(curwin, curwin->w_cursor.lnum);
used += i; used += extra;
extra += i;
/* /*
* Check if the lines from "top" to "bot" fit in the window. If they do, * Check if the lines from "top" to "bot" fit in the window. If they do,
* set new_topline and advance "top" and "bot" to include more lines. * set new_topline and advance "top" and "bot" to include more lines.
*/ */
while (top > 0) { while (top > 0) {
if (hasFolding(top, &top, NULL)) int i = (hasFolding(top, &top, NULL)) ? 1 : plines(top);
/* count one logical line for a sequence of folded lines */
i = 1;
else
i = plines(top);
used += i; used += i;
if (extra + i <= off && bot < curbuf->b_ml.ml_line_count) { if (extra + i <= off && bot < curbuf->b_ml.ml_line_count) {
if (hasFolding(bot, NULL, &bot)) if (hasFolding(bot, NULL, &bot))
@ -1390,9 +1349,9 @@ void scroll_cursor_top(int min_scroll, int always)
* This makes sure we get the same position when using "k" and "j" * This makes sure we get the same position when using "k" and "j"
* in a small window. * in a small window.
*/ */
if (used > curwin->w_height) if (used > curwin->w_height) {
scroll_cursor_halfway(false); scroll_cursor_halfway(false);
else { } else {
/* /*
* If "always" is false, only adjust topline to a lower value, higher * If "always" is false, only adjust topline to a lower value, higher
* value may happen with wrapping lines * value may happen with wrapping lines
@ -1451,19 +1410,16 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
int used; int used;
int scrolled = 0; int scrolled = 0;
int extra = 0; int extra = 0;
int i;
linenr_T line_count;
linenr_T old_topline = curwin->w_topline;
lineoff_T loff; lineoff_T loff;
lineoff_T boff; lineoff_T boff;
int old_topfill = curwin->w_topfill;
int fill_below_window; int fill_below_window;
linenr_T old_botline = curwin->w_botline; linenr_T old_topline = curwin->w_topline;
int old_valid = curwin->w_valid; int old_topfill = curwin->w_topfill;
int old_empty_rows = curwin->w_empty_rows; linenr_T old_botline = curwin->w_botline;
linenr_T cln; /* Cursor Line Number */ int old_valid = curwin->w_valid;
int old_empty_rows = curwin->w_empty_rows;
linenr_T cln = curwin->w_cursor.lnum; /* Cursor Line Number */
cln = curwin->w_cursor.lnum;
if (set_topbot) { if (set_topbot) {
used = 0; used = 0;
curwin->w_botline = cln + 1; curwin->w_botline = cln + 1;
@ -1574,6 +1530,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
} }
} }
linenr_T line_count;
/* curwin->w_empty_rows is larger, no need to scroll */ /* curwin->w_empty_rows is larger, no need to scroll */
if (scrolled <= 0) if (scrolled <= 0)
line_count = 0; line_count = 0;
@ -1585,6 +1542,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
line_count = 0; line_count = 0;
boff.fill = curwin->w_topfill; boff.fill = curwin->w_topfill;
boff.lnum = curwin->w_topline - 1; boff.lnum = curwin->w_topline - 1;
int i;
for (i = 0; i < scrolled && boff.lnum < curwin->w_botline; ) { for (i = 0; i < scrolled && boff.lnum < curwin->w_botline; ) {
botline_forw(&boff); botline_forw(&boff);
i += boff.height; i += boff.height;
@ -1623,20 +1581,18 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
void scroll_cursor_halfway(int atend) void scroll_cursor_halfway(int atend)
{ {
int above = 0; int above = 0;
linenr_T topline;
int topfill = 0; int topfill = 0;
int below = 0; int below = 0;
int used;
lineoff_T loff; lineoff_T loff;
lineoff_T boff; lineoff_T boff;
linenr_T old_topline = curwin->w_topline; linenr_T old_topline = curwin->w_topline;
loff.lnum = boff.lnum = curwin->w_cursor.lnum; loff.lnum = boff.lnum = curwin->w_cursor.lnum;
(void)hasFolding(loff.lnum, &loff.lnum, &boff.lnum); (void)hasFolding(loff.lnum, &loff.lnum, &boff.lnum);
used = plines_nofill(loff.lnum); int used = plines_nofill(loff.lnum);
loff.fill = 0; loff.fill = 0;
boff.fill = 0; boff.fill = 0;
topline = loff.lnum; linenr_T topline = loff.lnum;
while (topline > 1) { while (topline > 1) {
if (below <= above) { /* add a line below the cursor first */ if (below <= above) { /* add a line below the cursor first */
if (boff.lnum < curbuf->b_ml.ml_line_count) { if (boff.lnum < curbuf->b_ml.ml_line_count) {
@ -1683,28 +1639,20 @@ void scroll_cursor_halfway(int atend)
*/ */
void cursor_correct(void) void cursor_correct(void)
{ {
int above = 0; /* screen lines above topline */
linenr_T topline;
int below = 0; /* screen lines below botline */
linenr_T botline;
int above_wanted, below_wanted;
linenr_T cln; /* Cursor Line Number */
int max_off;
/* /*
* How many lines we would like to have above/below the cursor depends on * How many lines we would like to have above/below the cursor depends on
* whether the first/last line of the file is on screen. * whether the first/last line of the file is on screen.
*/ */
assert(p_so <= INT_MAX); assert(p_so <= INT_MAX);
above_wanted = (int)p_so; int above_wanted = (int)p_so;
below_wanted = (int)p_so; int below_wanted = (int)p_so;
if (mouse_dragging > 0) { if (mouse_dragging > 0) {
above_wanted = mouse_dragging - 1; above_wanted = mouse_dragging - 1;
below_wanted = mouse_dragging - 1; below_wanted = mouse_dragging - 1;
} }
if (curwin->w_topline == 1) { if (curwin->w_topline == 1) {
above_wanted = 0; above_wanted = 0;
max_off = curwin->w_height / 2; int max_off = curwin->w_height / 2;
if (below_wanted > max_off) if (below_wanted > max_off)
below_wanted = max_off; below_wanted = max_off;
} }
@ -1713,7 +1661,7 @@ void cursor_correct(void)
&& mouse_dragging == 0 && mouse_dragging == 0
) { ) {
below_wanted = 0; below_wanted = 0;
max_off = (curwin->w_height - 1) / 2; int max_off = (curwin->w_height - 1) / 2;
if (above_wanted > max_off) if (above_wanted > max_off)
above_wanted = max_off; above_wanted = max_off;
} }
@ -1722,7 +1670,7 @@ void cursor_correct(void)
* If there are sufficient file-lines above and below the cursor, we can * If there are sufficient file-lines above and below the cursor, we can
* return now. * return now.
*/ */
cln = curwin->w_cursor.lnum; linenr_T cln = curwin->w_cursor.lnum; /* Cursor Line Number */
if (cln >= curwin->w_topline + above_wanted if (cln >= curwin->w_topline + above_wanted
&& cln < curwin->w_botline - below_wanted && cln < curwin->w_botline - below_wanted
&& !hasAnyFolding(curwin) && !hasAnyFolding(curwin)
@ -1735,11 +1683,11 @@ void cursor_correct(void)
* - the desired context lines are found * - the desired context lines are found
* - the lines from the top is past the lines from the bottom * - the lines from the top is past the lines from the bottom
*/ */
topline = curwin->w_topline; linenr_T topline = curwin->w_topline;
botline = curwin->w_botline - 1; linenr_T botline = curwin->w_botline - 1;
/* count filler lines as context */ /* count filler lines as context */
above = curwin->w_topfill; int above = curwin->w_topfill; /* screen lines above topline */
below = curwin->w_filler_rows; int below = curwin->w_filler_rows; /* screen lines below botline */
while ((above < above_wanted || below < below_wanted) && topline < botline) { while ((above < above_wanted || below < below_wanted) && topline < botline) {
if (below < below_wanted && (below <= above || above >= above_wanted)) { if (below < below_wanted && (below <= above || above >= above_wanted)) {
if (hasFolding(botline, &botline, NULL)) if (hasFolding(botline, &botline, NULL))
@ -1973,46 +1921,44 @@ int onepage(int dir, long count)
*/ */
static void get_scroll_overlap(lineoff_T *lp, int dir) static void get_scroll_overlap(lineoff_T *lp, int dir)
{ {
int h1, h2, h3, h4;
int min_height = curwin->w_height - 2; int min_height = curwin->w_height - 2;
lineoff_T loff0, loff1, loff2;
if (lp->fill > 0) if (lp->fill > 0)
lp->height = 1; lp->height = 1;
else else
lp->height = plines_nofill(lp->lnum); lp->height = plines_nofill(lp->lnum);
h1 = lp->height; int h1 = lp->height;
if (h1 > min_height) if (h1 > min_height)
return; /* no overlap */ return; /* no overlap */
loff0 = *lp; lineoff_T loff0 = *lp;
if (dir > 0) if (dir > 0)
botline_forw(lp); botline_forw(lp);
else else
topline_back(lp); topline_back(lp);
h2 = lp->height; int h2 = lp->height;
if (h2 == MAXCOL || h2 + h1 > min_height) { if (h2 == MAXCOL || h2 + h1 > min_height) {
*lp = loff0; /* no overlap */ *lp = loff0; /* no overlap */
return; return;
} }
loff1 = *lp; lineoff_T loff1 = *lp;
if (dir > 0) if (dir > 0)
botline_forw(lp); botline_forw(lp);
else else
topline_back(lp); topline_back(lp);
h3 = lp->height; int h3 = lp->height;
if (h3 == MAXCOL || h3 + h2 > min_height) { if (h3 == MAXCOL || h3 + h2 > min_height) {
*lp = loff0; /* no overlap */ *lp = loff0; /* no overlap */
return; return;
} }
loff2 = *lp; lineoff_T loff2 = *lp;
if (dir > 0) if (dir > 0)
botline_forw(lp); botline_forw(lp);
else else
topline_back(lp); topline_back(lp);
h4 = lp->height; int h4 = lp->height;
if (h4 == MAXCOL || h4 + h3 + h2 > min_height || h3 + h2 + h1 > min_height) if (h4 == MAXCOL || h4 + h3 + h2 > min_height || h3 + h2 + h1 > min_height)
*lp = loff1; /* 1 line overlap */ *lp = loff1; /* 1 line overlap */
else else
@ -2028,7 +1974,6 @@ void halfpage(bool flag, linenr_T Prenum)
{ {
long scrolled = 0; long scrolled = 0;
int i; int i;
int room;
if (Prenum) if (Prenum)
curwin->w_p_scr = (Prenum > curwin->w_height) ? curwin->w_p_scr = (Prenum > curwin->w_height) ?
@ -2038,8 +1983,7 @@ void halfpage(bool flag, linenr_T Prenum)
: curwin->w_height; : curwin->w_height;
validate_botline(); validate_botline();
room = curwin->w_empty_rows; int room = curwin->w_empty_rows + curwin->w_filler_rows;
room += curwin->w_filler_rows;
if (flag) { if (flag) {
/* /*
* scroll the text up * scroll the text up
@ -2186,14 +2130,13 @@ void halfpage(bool flag, linenr_T Prenum)
void do_check_cursorbind(void) void do_check_cursorbind(void)
{ {
linenr_T line = curwin->w_cursor.lnum; linenr_T line = curwin->w_cursor.lnum;
colnr_T col = curwin->w_cursor.col; colnr_T col = curwin->w_cursor.col;
colnr_T coladd = curwin->w_cursor.coladd; colnr_T coladd = curwin->w_cursor.coladd;
colnr_T curswant = curwin->w_curswant; colnr_T curswant = curwin->w_curswant;
int set_curswant = curwin->w_set_curswant; int set_curswant = curwin->w_set_curswant;
win_T *old_curwin = curwin; win_T *old_curwin = curwin;
buf_T *old_curbuf = curbuf; buf_T *old_curbuf = curbuf;
int restart_edit_save;
int old_VIsual_select = VIsual_select; int old_VIsual_select = VIsual_select;
int old_VIsual_active = VIsual_active; int old_VIsual_active = VIsual_active;
@ -2220,10 +2163,12 @@ void do_check_cursorbind(void)
/* Make sure the cursor is in a valid position. Temporarily set /* Make sure the cursor is in a valid position. Temporarily set
* "restart_edit" to allow the cursor to be beyond the EOL. */ * "restart_edit" to allow the cursor to be beyond the EOL. */
restart_edit_save = restart_edit; {
restart_edit = true; int restart_edit_save = restart_edit;
check_cursor(); restart_edit = true;
restart_edit = restart_edit_save; check_cursor();
restart_edit = restart_edit_save;
}
/* Correct cursor for multi-byte character. */ /* Correct cursor for multi-byte character. */
if (has_mbyte) if (has_mbyte)
mb_adjust_cursor(); mb_adjust_cursor();