opensourcemirror
/
neovim
mirror of https://github.com/neovim/neovim.git
1
0
Fork 0
Code Issues Releases Wiki Activity

Merge pull request #28044 from luukvbaal/vim-9.1.0211 

vim-patch:9.1.{0211,0215}
This commit is contained in:
zeertzjq 2024-03-28 19:47:40 +08:00 committed by GitHub
parent 346a639028 2f638c0ac6
commit dde2cc65fd
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
13 changed files with 232 additions and 453 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
runtime/doc/options.txt
View File

@ -5693,8 +5693,8 @@ A jump table for the options with a short description can be found at |Q_op|.
highlighted with |hl-NonText|.
You may also want to add "lastline" to the 'display' option to show as
much of the last line as possible.
NOTE: only partly implemented, currently works with CTRL-E, CTRL-Y
and scrolling with the mouse.
NOTE: only partly implemented, currently works with CTRL-E, CTRL-Y,
CTRL-D, CTRL-U, CTRL-F, CTRL-B and scrolling with the mouse.
*'softtabstop'* *'sts'*
'softtabstop' 'sts' number (default 0)
@ -7164,8 +7164,8 @@ A jump table for the options with a short description can be found at |Q_op|.
will scroll 'window' minus two lines, with a minimum of one.
When 'window' is equal to 'lines' minus one CTRL-F and CTRL-B scroll
in a much smarter way, taking care of wrapping lines.
When resizing the Vim window, the value is smaller than 1 or more than
or equal to 'lines' it will be set to 'lines' minus 1.
When resizing the Vim window, and the value is smaller than 1 or more
than or equal to 'lines' it will be set to 'lines' minus 1.
Note: Do not confuse this with the height of the Vim window, use
'lines' for that.

8
runtime/lua/vim/_meta/options.lua generated
View File

@ -6075,8 +6075,8 @@ vim.go.sta = vim.go.smarttab
--- highlighted with `hl-NonText`.
--- You may also want to add "lastline" to the 'display' option to show as
--- much of the last line as possible.
--- NOTE: only partly implemented, currently works with CTRL-E, CTRL-Y
--- and scrolling with the mouse.
--- NOTE: only partly implemented, currently works with CTRL-E, CTRL-Y,
--- CTRL-D, CTRL-U, CTRL-F, CTRL-B and scrolling with the mouse.
---
--- @type boolean
vim.o.smoothscroll = false
@ -7861,8 +7861,8 @@ vim.wo.winbl = vim.wo.winblend
--- will scroll 'window' minus two lines, with a minimum of one.
--- When 'window' is equal to 'lines' minus one CTRL-F and CTRL-B scroll
--- in a much smarter way, taking care of wrapping lines.
--- When resizing the Vim window, the value is smaller than 1 or more than
--- or equal to 'lines' it will be set to 'lines' minus 1.
--- When resizing the Vim window, and the value is smaller than 1 or more
--- than or equal to 'lines' it will be set to 'lines' minus 1.
--- Note: Do not confuse this with the height of the Vim window, use
--- 'lines' for that.
---

4
src/nvim/edit.c
View File

@ -4192,7 +4192,7 @@ static void ins_pageup(void)
}
pos_T tpos = curwin->w_cursor;
if (onepage(BACKWARD, 1) == OK) {
if (pagescroll(BACKWARD, 1, false) == OK) {
start_arrow(&tpos);
can_cindent = true;
} else {
@ -4237,7 +4237,7 @@ static void ins_pagedown(void)
}
pos_T tpos = curwin->w_cursor;
if (onepage(FORWARD, 1) == OK) {
if (pagescroll(FORWARD, 1, false) == OK) {
start_arrow(&tpos);
can_cindent = true;
} else {

2
src/nvim/mouse.c
View File

@ -1024,7 +1024,7 @@ void do_mousescroll(cmdarg_T *cap)
// Vertical scrolling
if ((State & MODE_NORMAL) && shift_or_ctrl) {
// whole page up or down
onepage(cap->arg ? FORWARD : BACKWARD, 1);
pagescroll(cap->arg ? FORWARD : BACKWARD, 1, false);
} else {
if (shift_or_ctrl) {
// whole page up or down

494
src/nvim/move.c
View File

@ -36,6 +36,7 @@
#include "nvim/message.h"
#include "nvim/mouse.h"
#include "nvim/move.h"
#include "nvim/normal.h"
#include "nvim/option.h"
#include "nvim/option_vars.h"
#include "nvim/plines.h"
@ -1552,21 +1553,6 @@ void check_topfill(win_T *wp, bool down)
win_check_anchored_floats(wp);
}
// Use as many filler lines as possible for w_topline. Make sure w_topline
// is still visible.
static void max_topfill(void)
{
int n = plines_win_nofill(curwin, curwin->w_topline, true);
if (n >= curwin->w_height_inner) {
curwin->w_topfill = 0;
} else {
curwin->w_topfill = win_get_fill(curwin, curwin->w_topline);
if (curwin->w_topfill + n > curwin->w_height_inner) {
curwin->w_topfill = curwin->w_height_inner - n;
}
}
}
// Scroll the screen one line down, but don't do it if it would move the
// cursor off the screen.
void scrolldown_clamp(void)
@ -1697,28 +1683,6 @@ static void botline_forw(win_T *wp, lineoff_T *lp)
}
}
// Switch from including filler lines below lp->lnum to including filler
// lines above loff.lnum + 1. This keeps pointing to the same line.
// When there are no filler lines nothing changes.
static void botline_topline(lineoff_T *lp)
{
if (lp->fill > 0) {
lp->lnum++;
lp->fill = win_get_fill(curwin, lp->lnum) - lp->fill + 1;
}
}
// Switch from including filler lines above lp->lnum to including filler
// lines below loff.lnum - 1. This keeps pointing to the same line.
// When there are no filler lines nothing changes.
static void topline_botline(lineoff_T *lp)
{
if (lp->fill > 0) {
lp->fill = win_get_fill(curwin, lp->lnum) - lp->fill + 1;
lp->lnum--;
}
}
// Recompute topline to put the cursor at the top of the window.
// Scroll at least "min_scroll" lines.
// If "always" is true, always set topline (for "zt").
@ -2314,371 +2278,127 @@ void cursor_correct(win_T *wp)
wp->w_viewport_invalid = true;
}
/// Decide how much overlap to use for page-up or page-down scrolling.
/// This is symmetric, so that doing both keeps the same lines displayed.
/// Three lines are examined:
///
/// before CTRL-F after CTRL-F / before CTRL-B
/// etc. l1
/// l1 last but one line ------------
/// l2 last text line l2 top text line
/// ------------- l3 second text line
/// l3 etc.
static int get_scroll_overlap(Direction dir)
{
lineoff_T loff;
int min_height = curwin->w_height_inner - 2;
validate_botline(curwin);
if (dir == FORWARD && curwin->w_botline > curbuf->b_ml.ml_line_count) {
return min_height + 2; // no overlap, still handle 'smoothscroll'
}
loff.lnum = dir == FORWARD ? curwin->w_botline : curwin->w_topline - 1;
loff.fill = win_get_fill(curwin, loff.lnum + dir == BACKWARD)
- (dir == FORWARD ? curwin->w_filler_rows : curwin->w_topfill);
loff.height = loff.fill > 0 ? 1 : plines_win_nofill(curwin, loff.lnum, true);
int h1 = loff.height;
if (h1 > min_height) {
return min_height + 2; // no overlap
}
if (dir == FORWARD) {
topline_back(curwin, &loff);
} else {
botline_forw(curwin, &loff);
}
int h2 = loff.height;
if (h2 == MAXCOL || h2 + h1 > min_height) {
return min_height + 2; // no overlap
}
if (dir == FORWARD) {
topline_back(curwin, &loff);
} else {
botline_forw(curwin, &loff);
}
int h3 = loff.height;
if (h3 == MAXCOL || h3 + h2 > min_height) {
return min_height + 2; // no overlap
}
if (dir == FORWARD) {
topline_back(curwin, &loff);
} else {
botline_forw(curwin, &loff);
}
int h4 = loff.height;
if (h4 == MAXCOL || h4 + h3 + h2 > min_height || h3 + h2 + h1 > min_height) {
return min_height + 1; // 1 line overlap
} else {
return min_height; // 2 lines overlap
}
}
/// Move screen "count" pages up ("dir" is BACKWARD) or down ("dir" is FORWARD)
/// and update the screen.
///
/// @return FAIL for failure, OK otherwise.
int onepage(Direction dir, int count)
int pagescroll(Direction dir, int count, bool half)
{
int retval = OK;
lineoff_T loff;
linenr_T old_topline = curwin->w_topline;
int so = get_scrolloff_value(curwin);
int prev_topfill = curwin->w_topfill;
linenr_T prev_topline = curwin->w_topline;
colnr_T prev_skipcol = curwin->w_skipcol;
if (curbuf->b_ml.ml_line_count == 1) { // nothing to do
beep_flush();
return FAIL;
}
for (; count > 0; count--) {
validate_botline(curwin);
// It's an error to move a page up when the first line is already on
// the screen. It's an error to move a page down when the last line
// is on the screen and the topline is 'scrolloff' lines from the
// last line.
if (dir == FORWARD
? ((curwin->w_topline >= curbuf->b_ml.ml_line_count - so)
&& curwin->w_botline > curbuf->b_ml.ml_line_count)
: (curwin->w_topline == 1
&& curwin->w_topfill == win_get_fill(curwin, curwin->w_topline))) {
beep_flush();
retval = FAIL;
break;
if (half) {
// Scroll [count], 'scroll' or current window height lines.
if (count) {
curwin->w_p_scr = MIN(curwin->w_height_inner, count);
}
loff.fill = 0;
if (dir == FORWARD) {
if (ONE_WINDOW && p_window > 0 && p_window < Rows - 1) {
// Vi compatible scrolling
if (p_window <= 2) {
curwin->w_topline++;
} else {
curwin->w_topline += (linenr_T)p_window - 2;
}
if (curwin->w_topline > curbuf->b_ml.ml_line_count) {
curwin->w_topline = curbuf->b_ml.ml_line_count;
}
curwin->w_cursor.lnum = curwin->w_topline;
} else if (curwin->w_botline > curbuf->b_ml.ml_line_count) {
// at end of file
curwin->w_topline = curbuf->b_ml.ml_line_count;
curwin->w_topfill = 0;
curwin->w_valid &= ~(VALID_WROW|VALID_CROW);
} else {
// For the overlap, start with the line just below the window
// and go upwards.
loff.lnum = curwin->w_botline;
loff.fill = win_get_fill(curwin, loff.lnum)
- curwin->w_filler_rows;
get_scroll_overlap(&loff, -1);
curwin->w_topline = loff.lnum;
curwin->w_topfill = loff.fill;
check_topfill(curwin, false);
curwin->w_cursor.lnum = curwin->w_topline;
curwin->w_valid &= ~(VALID_WCOL|VALID_CHEIGHT|VALID_WROW|
VALID_CROW|VALID_BOTLINE|VALID_BOTLINE_AP);
}
} else { // dir == BACKWARDS
if (curwin->w_topline == 1) {
// Include max number of filler lines
max_topfill();
continue;
}
if (ONE_WINDOW && p_window > 0 && p_window < Rows - 1) {
// Vi compatible scrolling (sort of)
if (p_window <= 2) {
curwin->w_topline--;
} else {
curwin->w_topline -= (linenr_T)p_window - 2;
}
if (curwin->w_topline < 1) {
curwin->w_topline = 1;
}
curwin->w_cursor.lnum = curwin->w_topline + (linenr_T)p_window - 1;
if (curwin->w_cursor.lnum > curbuf->b_ml.ml_line_count) {
curwin->w_cursor.lnum = curbuf->b_ml.ml_line_count;
}
continue;
}
// Find the line at the top of the window that is going to be the
// line at the bottom of the window. Make sure this results in
// the same line as before doing CTRL-F.
loff.lnum = curwin->w_topline - 1;
loff.fill = win_get_fill(curwin, loff.lnum + 1) - curwin->w_topfill;
get_scroll_overlap(&loff, 1);
if (loff.lnum >= curbuf->b_ml.ml_line_count) {
loff.lnum = curbuf->b_ml.ml_line_count;
loff.fill = 0;
} else {
botline_topline(&loff);
}
curwin->w_cursor.lnum = loff.lnum;
// Find the line just above the new topline to get the right line
// at the bottom of the window.
int n = 0;
while (n <= curwin->w_height_inner && loff.lnum >= 1) {
topline_back(curwin, &loff);
if (loff.height == MAXCOL) {
n = MAXCOL;
} else {
n += loff.height;
}
}
if (loff.lnum < 1) { // at begin of file
curwin->w_topline = 1;
max_topfill();
curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE);
} else {
// Go two lines forward again.
topline_botline(&loff);
botline_forw(curwin, &loff);
botline_forw(curwin, &loff);
botline_topline(&loff);
// We're at the wrong end of a fold now.
hasFolding(curwin, loff.lnum, &loff.lnum, NULL);
// Always scroll at least one line. Avoid getting stuck on
// very long lines.
if (loff.lnum >= curwin->w_topline
&& (loff.lnum > curwin->w_topline
|| loff.fill >= curwin->w_topfill)) {
// First try using the maximum number of filler lines. If
// that's not enough, backup one line.
loff.fill = curwin->w_topfill;
if (curwin->w_topfill < win_get_fill(curwin, curwin->w_topline)) {
max_topfill();
}
if (curwin->w_topfill == loff.fill) {
curwin->w_topline--;
curwin->w_topfill = 0;
curwin->w_valid &= ~(VALID_WROW|VALID_CROW);
}
comp_botline(curwin);
curwin->w_cursor.lnum = curwin->w_botline - 1;
curwin->w_valid &= ~(VALID_WCOL|VALID_CHEIGHT|VALID_WROW|VALID_CROW);
} else {
curwin->w_topline = loff.lnum;
curwin->w_topfill = loff.fill;
check_topfill(curwin, false);
curwin->w_valid &= ~(VALID_WROW|VALID_CROW|VALID_BOTLINE);
}
}
}
}
foldAdjustCursor(curwin);
cursor_correct(curwin);
check_cursor_col(curwin);
if (retval == OK) {
beginline(BL_SOL | BL_FIX);
}
curwin->w_valid &= ~(VALID_WCOL|VALID_WROW|VALID_VIRTCOL);
if (retval == OK && dir == FORWARD) {
// Avoid the screen jumping up and down when 'scrolloff' is non-zero.
// But make sure we scroll at least one line (happens with mix of long
// wrapping lines and non-wrapping line).
if (check_top_offset()) {
scroll_cursor_top(curwin, 1, false);
if (curwin->w_topline <= old_topline
&& old_topline < curbuf->b_ml.ml_line_count) {
curwin->w_topline = old_topline + 1;
hasFolding(curwin, curwin->w_topline, &curwin->w_topline, NULL);
}
} else if (curwin->w_botline > curbuf->b_ml.ml_line_count) {
hasFolding(curwin, curwin->w_topline, &curwin->w_topline, NULL);
}
}
redraw_later(curwin, UPD_VALID);
return retval;
}
// Decide how much overlap to use for page-up or page-down scrolling.
// This is symmetric, so that doing both keeps the same lines displayed.
// Three lines are examined:
//
// before CTRL-F after CTRL-F / before CTRL-B
// etc. l1
// l1 last but one line ------------
// l2 last text line l2 top text line
// ------------- l3 second text line
// l3 etc.
static void get_scroll_overlap(lineoff_T *lp, int dir)
{
int min_height = curwin->w_height_inner - 2;
if (lp->fill > 0) {
lp->height = 1;
count = MIN(curwin->w_height_inner, (int)curwin->w_p_scr);
} else {
lp->height = plines_win_nofill(curwin, lp->lnum, true);
// Scroll 'window' or current window height lines.
count *= ((ONE_WINDOW && p_window > 0 && p_window < Rows - 1)
? (int)p_window - 2 : get_scroll_overlap(dir));
}
int h1 = lp->height;
if (h1 > min_height) {
return; // no overlap
}
lineoff_T loff0 = *lp;
if (dir > 0) {
botline_forw(curwin, lp);
if (curwin->w_p_sms) {
scroll_redraw(dir == FORWARD, count);
} else {
topline_back(curwin, lp);
}
int h2 = lp->height;
if (h2 == MAXCOL || h2 + h1 > min_height) {
*lp = loff0; // no overlap
return;
}
// Scroll at least one full line without 'smoothscroll'.
count -= plines_win_nofill(curwin, curwin->w_topline, false);
scroll_redraw(dir == FORWARD, 1);
lineoff_T loff1 = *lp;
if (dir > 0) {
botline_forw(curwin, lp);
} else {
topline_back(curwin, lp);
}
int h3 = lp->height;
if (h3 == MAXCOL || h3 + h2 > min_height) {
*lp = loff0; // no overlap
return;
}
lineoff_T loff2 = *lp;
if (dir > 0) {
botline_forw(curwin, lp);
} else {
topline_back(curwin, lp);
}
int h4 = lp->height;
if (h4 == MAXCOL || h4 + h3 + h2 > min_height || h3 + h2 + h1 > min_height) {
*lp = loff1; // 1 line overlap
} else {
*lp = loff2; // 2 lines overlap
}
}
// Scroll 'scroll' lines up or down.
void halfpage(bool flag, linenr_T Prenum)
{
int scrolled = 0;
int i;
if (Prenum) {
curwin->w_p_scr = (Prenum > curwin->w_height_inner) ? curwin->w_height_inner
: Prenum;
}
assert(curwin->w_p_scr <= INT_MAX);
int n = curwin->w_p_scr <= curwin->w_height_inner ? (int)curwin->w_p_scr
: curwin->w_height_inner;
update_topline(curwin);
validate_botline(curwin);
int room = curwin->w_empty_rows + curwin->w_filler_rows;
if (flag) {
// scroll the text up
while (n > 0 && curwin->w_botline <= curbuf->b_ml.ml_line_count) {
if (curwin->w_topfill > 0) {
i = 1;
n--;
curwin->w_topfill--;
} else {
i = plines_win_nofill(curwin, curwin->w_topline, true);
n -= i;
if (n < 0 && scrolled > 0) {
break;
}
hasFolding(curwin, curwin->w_topline, NULL, &curwin->w_topline);
curwin->w_topline++;
curwin->w_topfill = win_get_fill(curwin, curwin->w_topline);
if (curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
curwin->w_cursor.lnum++;
curwin->w_valid &=
~(VALID_VIRTCOL|VALID_CHEIGHT|VALID_WCOL);
}
}
curwin->w_valid &= ~(VALID_CROW|VALID_WROW);
scrolled += i;
// Correct w_botline for changed w_topline.
// Won't work when there are filler lines.
if (win_may_fill(curwin)) {
curwin->w_valid &= ~(VALID_BOTLINE|VALID_BOTLINE_AP);
} else {
room += i;
do {
i = plines_win(curwin, curwin->w_botline, true);
if (i > room) {
break;
}
hasFolding(curwin, curwin->w_botline, NULL, &curwin->w_botline);
curwin->w_botline++;
room -= i;
} while (curwin->w_botline <= curbuf->b_ml.ml_line_count);
}
}
// When hit bottom of the file: move cursor down.
if (n > 0) {
if (hasAnyFolding(curwin)) {
while (--n >= 0
&& curwin->w_cursor.lnum < curbuf->b_ml.ml_line_count) {
hasFolding(curwin, curwin->w_cursor.lnum, NULL,
&curwin->w_cursor.lnum);
curwin->w_cursor.lnum++;
}
} else {
curwin->w_cursor.lnum += n;
}
check_cursor_lnum(curwin);
}
} else {
// scroll the text down
while (n > 0 && curwin->w_topline > 1) {
if (curwin->w_topfill < win_get_fill(curwin, curwin->w_topline)) {
i = 1;
n--;
curwin->w_topfill++;
} else {
i = plines_win_nofill(curwin, curwin->w_topline - 1, true);
n -= i;
if (n < 0 && scrolled > 0) {
break;
}
curwin->w_topline--;
hasFolding(curwin, curwin->w_topline, &curwin->w_topline, NULL);
curwin->w_topfill = 0;
}
curwin->w_valid &= ~(VALID_CROW|VALID_WROW|
VALID_BOTLINE|VALID_BOTLINE_AP);
scrolled += i;
if (curwin->w_cursor.lnum > 1) {
curwin->w_cursor.lnum--;
curwin->w_valid &= ~(VALID_VIRTCOL|VALID_CHEIGHT|VALID_WCOL);
}
}
// When hit top of the file: move cursor up.
if (n > 0) {
if (curwin->w_cursor.lnum <= (linenr_T)n) {
curwin->w_cursor.lnum = 1;
} else if (hasAnyFolding(curwin)) {
while (--n >= 0 && curwin->w_cursor.lnum > 1) {
curwin->w_cursor.lnum--;
hasFolding(curwin, curwin->w_cursor.lnum,
&curwin->w_cursor.lnum, NULL);
}
} else {
curwin->w_cursor.lnum -= n;
}
// Temporarily set 'smoothscroll' so that scrolling count lines
// does not skip over parts of the buffer with wrapped lines.
curwin->w_p_sms = true;
if (count > 0) {
scroll_redraw(dir == FORWARD, count);
}
curwin->w_p_sms = false;
}
// Move cursor to first line of closed fold.
foldAdjustCursor(curwin);
check_topfill(curwin, !flag);
cursor_correct(curwin);
beginline(BL_SOL | BL_FIX);
redraw_later(curwin, UPD_VALID);
int nochange = curwin->w_topline == prev_topline
&& curwin->w_topfill == prev_topfill
&& curwin->w_skipcol == prev_skipcol;
// Error if the viewport did not change and the cursor is already
// at the boundary.
if (nochange) {
int prev_cursor = curwin->w_cursor.lnum;
curwin->w_cursor.lnum += (count + 1) * (dir == FORWARD ? 1 : -1);
check_cursor(curwin);
if (curwin->w_cursor.lnum == prev_cursor) {
beep_flush();
}
} else if (!curwin->w_p_sms || curwin->w_skipcol == prev_skipcol) {
beginline(BL_SOL | BL_FIX);
}
return nochange;
}
void do_check_cursorbind(void)

10
src/nvim/normal.c
View File

@ -2258,7 +2258,7 @@ static void nv_page(cmdarg_T *cap)
goto_tabpage(cap->count0);
}
} else {
onepage(cap->arg, cap->count1);
pagescroll(cap->arg, cap->count1, false);
}
}
@ -6394,12 +6394,8 @@ static void nv_at(cmdarg_T *cap)
/// Handle the CTRL-U and CTRL-D commands.
static void nv_halfpage(cmdarg_T *cap)
{
if ((cap->cmdchar == Ctrl_U && curwin->w_cursor.lnum == 1)
|| (cap->cmdchar == Ctrl_D
&& curwin->w_cursor.lnum == curbuf->b_ml.ml_line_count)) {
clearopbeep(cap->oap);
} else if (!checkclearop(cap->oap)) {
halfpage(cap->cmdchar == Ctrl_D, cap->count0);
if (!checkclearop(cap->oap)) {
pagescroll(cap->cmdchar == Ctrl_D, cap->count0, true);
}
}

8
src/nvim/options.lua
View File

@ -7663,8 +7663,8 @@ return {
highlighted with |hl-NonText|.
You may also want to add "lastline" to the 'display' option to show as
much of the last line as possible.
NOTE: only partly implemented, currently works with CTRL-E, CTRL-Y
and scrolling with the mouse.
NOTE: only partly implemented, currently works with CTRL-E, CTRL-Y,
CTRL-D, CTRL-U, CTRL-F, CTRL-B and scrolling with the mouse.
]=],
full_name = 'smoothscroll',
pv_name = 'p_sms',
@ -9806,8 +9806,8 @@ return {
will scroll 'window' minus two lines, with a minimum of one.
When 'window' is equal to 'lines' minus one CTRL-F and CTRL-B scroll
in a much smarter way, taking care of wrapping lines.
When resizing the Vim window, the value is smaller than 1 or more than
or equal to 'lines' it will be set to 'lines' minus 1.
When resizing the Vim window, and the value is smaller than 1 or more
than or equal to 'lines' it will be set to 'lines' minus 1.
Note: Do not confuse this with the height of the Vim window, use
'lines' for that.
]=],

2
test/functional/legacy/matchparen_spec.lua
View File

@ -19,7 +19,7 @@ describe('matchparen', function()
call cursor(5, 1)
]])
feed('V<c-d><c-d>')
feed('V<c-d><c-d>3j')
screen:expect([[
{17:{} |
{17:}} |

2
test/functional/legacy/scroll_opt_spec.lua
View File

@ -740,7 +740,7 @@ describe('smoothscroll', function()
|
]])
exec("call setline(92, 'a'->repeat(100))")
feed('<C-B>G')
feed('<C-L><C-B>G')
-- cursor is not placed below window
screen:expect([[
{1:<<<}aaaaaaaaaaaaaaaaa |

40
test/old/testdir/test_diffmode.vim
View File

@ -1632,34 +1632,38 @@ endfunc
func Test_diff_scroll_many_filler()
20new
vnew
call setline(1, ['^^^', '^^^', '$$$', '$$$'])
call setline(1, range(1, 40))
diffthis
setlocal scrolloff=0
wincmd p
call setline(1, ['^^^', '^^^'] + repeat(['###'], 41) + ['$$$', '$$$'])
call setline(1, range(1, 20)->reverse() + ['###']->repeat(41) + range(21, 40)->reverse())
diffthis
setlocal scrolloff=0
wincmd p
redraw
" Note: need a redraw after each scroll, otherwise the test always passes.
normal! G
redraw
call assert_equal(3, winsaveview().topline)
call assert_equal(18, winsaveview().topfill)
exe "normal! \<C-B>"
redraw
call assert_equal(3, winsaveview().topline)
call assert_equal(19, winsaveview().topfill)
exe "normal! \<C-B>"
redraw
call assert_equal(2, winsaveview().topline)
call assert_equal(0, winsaveview().topfill)
exe "normal! \<C-B>"
redraw
call assert_equal(1, winsaveview().topline)
call assert_equal(0, winsaveview().topfill)
for _ in range(2)
normal! G
redraw
call assert_equal(40, winsaveview().topline)
call assert_equal(19, winsaveview().topfill)
exe "normal! \<C-B>"
redraw
call assert_equal(22, winsaveview().topline)
call assert_equal(0, winsaveview().topfill)
exe "normal! \<C-B>"
redraw
call assert_equal(4, winsaveview().topline)
call assert_equal(0, winsaveview().topfill)
exe "normal! \<C-B>"
redraw
call assert_equal(1, winsaveview().topline)
call assert_equal(0, winsaveview().topfill)
set smoothscroll
endfor
set smoothscroll&
bwipe!
bwipe!
endfunc

16
test/old/testdir/test_edit.vim
View File

@ -1318,9 +1318,9 @@ func Test_edit_PAGEUP_PAGEDOWN()
call feedkeys("A\<PageUp>\<esc>", 'tnix')
call assert_equal([0, 13, 1, 0], getpos('.'))
call feedkeys("A\<PageUp>\<esc>", 'tnix')
call assert_equal([0, 5, 1, 0], getpos('.'))
call assert_equal([0, 10, 1, 0], getpos('.'))
call feedkeys("A\<PageUp>\<esc>", 'tnix')
call assert_equal([0, 5, 11, 0], getpos('.'))
call assert_equal([0, 2, 11, 0], getpos('.'))
" <S-Up> is the same as <PageUp>
" <S-Down> is the same as <PageDown>
call cursor(1, 1)
@ -1341,9 +1341,9 @@ func Test_edit_PAGEUP_PAGEDOWN()
call feedkeys("A\<S-Up>\<esc>", 'tnix')
call assert_equal([0, 13, 1, 0], getpos('.'))
call feedkeys("A\<S-Up>\<esc>", 'tnix')
call assert_equal([0, 5, 1, 0], getpos('.'))
call assert_equal([0, 10, 1, 0], getpos('.'))
call feedkeys("A\<S-Up>\<esc>", 'tnix')
call assert_equal([0, 5, 11, 0], getpos('.'))
call assert_equal([0, 2, 11, 0], getpos('.'))
set nostartofline
call cursor(30, 11)
norm! zt
@ -1354,9 +1354,9 @@ func Test_edit_PAGEUP_PAGEDOWN()
call feedkeys("A\<PageUp>\<esc>", 'tnix')
call assert_equal([0, 13, 11, 0], getpos('.'))
call feedkeys("A\<PageUp>\<esc>", 'tnix')
call assert_equal([0, 5, 11, 0], getpos('.'))
call assert_equal([0, 10, 11, 0], getpos('.'))
call feedkeys("A\<PageUp>\<esc>", 'tnix')
call assert_equal([0, 5, 11, 0], getpos('.'))
call assert_equal([0, 2, 11, 0], getpos('.'))
call cursor(1, 1)
call feedkeys("A\<PageDown>\<esc>", 'tnix')
call assert_equal([0, 9, 11, 0], getpos('.'))
@ -1379,9 +1379,9 @@ func Test_edit_PAGEUP_PAGEDOWN()
call feedkeys("A\<S-Up>\<esc>", 'tnix')
call assert_equal([0, 13, 11, 0], getpos('.'))
call feedkeys("A\<S-Up>\<esc>", 'tnix')
call assert_equal([0, 5, 11, 0], getpos('.'))
call assert_equal([0, 10, 11, 0], getpos('.'))
call feedkeys("A\<S-Up>\<esc>", 'tnix')
call assert_equal([0, 5, 11, 0], getpos('.'))
call assert_equal([0, 2, 11, 0], getpos('.'))
call cursor(1, 1)
call feedkeys("A\<S-Down>\<esc>", 'tnix')
call assert_equal([0, 9, 11, 0], getpos('.'))

46
test/old/testdir/test_normal.vim
View File

@ -131,7 +131,7 @@ func Test_normal01_keymodel()
call assert_equal([0, 1, 1, 0], getpos("'<"))
call assert_equal([0, 3, 1, 0], getpos("'>"))
call feedkeys("Gz\<CR>8|\<S-PageUp>y", 'xt')
call assert_equal([0, 2, 1, 0], getpos("'<"))
call assert_equal([0, 3, 1, 0], getpos("'<"))
call assert_equal([0, 3, 8, 0], getpos("'>"))
" Test for <S-C-Home> and <S-C-End>
call cursor(2, 12)
@ -915,12 +915,10 @@ func Test_normal14_page()
set scrolloff=0
100
exe "norm! $\<c-b>"
call assert_equal('92', getline('.'))
call assert_equal([0, 92, 1, 0, 1], getcurpos())
100
set nostartofline
exe "norm! $\<c-b>"
call assert_equal('92', getline('.'))
call assert_equal([0, 92, 2, 0, v:maxcol], getcurpos())
" cleanup
set startofline
@ -1285,9 +1283,13 @@ func Test_vert_scroll_cmds()
exe "normal \<C-D>"
call assert_equal(46, line('.'))
exe "normal \<C-U>"
call assert_equal(36, line('.'))
call assert_equal(36, line('w0'))
call assert_equal(46, line('.'))
exe "normal \<C-U>"
call assert_equal(10, line('.'))
call assert_equal(1, line('w0'))
call assert_equal(40, line('.'))
exe "normal \<C-U>"
call assert_equal(30, line('.'))
exe "normal \<C-U>"
call assert_equal(1, line('.'))
set scroll&
@ -1308,9 +1310,8 @@ func Test_vert_scroll_cmds()
call assert_equal(50, line('.'))
call assert_equal(100, line('w$'))
normal z.
let lnum = winline()
exe "normal \<C-D>"
call assert_equal(lnum, winline())
call assert_equal(1, winline())
call assert_equal(50, line('.'))
normal zt
exe "normal \<C-D>"
@ -3079,7 +3080,8 @@ func Test_normal42_halfpage()
call assert_equal(2, &scroll)
set scroll=5
exe "norm! \<c-u>"
call assert_equal('3', getline('.'))
call assert_equal('3', getline('w0'))
call assert_equal('8', getline('.'))
1
set scrolloff=5
exe "norm! \<c-d>"
@ -3826,7 +3828,7 @@ func Test_normal_vert_scroll_longline()
call assert_equal(1, winline())
exe "normal \<C-B>"
call assert_equal(10, line('.'))
call assert_equal(3, winline())
call assert_equal(10, winline())
exe "normal \<C-B>\<C-B>"
call assert_equal(5, line('.'))
call assert_equal(5, winline())
@ -4182,20 +4184,34 @@ func Test_normal34_zet_large()
norm! z9765405999999999999
endfunc
" Test for { and } paragraph movements in a single line
func Test_brace_single_line()
let text =<< trim [DATA]
foobar one two three
[DATA]
" Test for { and } paragraph movements and Ctrl-B in buffer with a single line
func Test_single_line_scroll()
CheckFeature textprop
new
call setline(1, text)
call setline(1, ['foobar one two three'])
let vt = 'virt_above'
call prop_type_add(vt, {'highlight': 'IncSearch'})
call prop_add(1, 0, {'type': vt, 'text': '---', 'text_align': 'above'})
1
norm! 0}
call assert_equal([0, 1, 20, 0], getpos('.'))
norm! {
call assert_equal([0, 1, 1, 0], getpos('.'))
" Ctrl-B/Ctrl-U scroll up with hidden "above" virtual text.
set smoothscroll
exe "normal \<C-E>"
call assert_notequal(0, winsaveview().skipcol)
exe "normal \<C-B>"
call assert_equal(0, winsaveview().skipcol)
exe "normal \<C-E>"
call assert_notequal(0, winsaveview().skipcol)
exe "normal \<C-U>"
call assert_equal(0, winsaveview().skipcol)
set smoothscroll&
bw!
endfunc

45
test/old/testdir/test_scroll_opt.vim
View File

@ -832,7 +832,7 @@ func Test_smoothscroll_eob()
call VerifyScreenDump(buf, 'Test_smooth_eob_1', {})
" cursor is not placed below window
call term_sendkeys(buf, ":call setline(92, 'a'->repeat(100))\<CR>\<C-B>G")
call term_sendkeys(buf, ":call setline(92, 'a'->repeat(100))\<CR>\<C-L>\<C-B>G")
call VerifyScreenDump(buf, 'Test_smooth_eob_2', {})
call StopVimInTerminal(buf)
@ -1001,4 +1001,47 @@ func Test_smoothscroll_textoff_small_winwidth()
set smoothscroll& number&
endfunc
func Test_smoothscroll_page()
set smoothscroll
10split | 40vsplit
call setline(1, 'abcde '->repeat(150))
exe "norm! \<C-F>"
call assert_equal(400, winsaveview().skipcol)
exe "norm! \<C-F>"
call assert_equal(800, winsaveview().skipcol)
exe "norm! \<C-F>"
call assert_equal(880, winsaveview().skipcol)
exe "norm! \<C-B>"
call assert_equal(480, winsaveview().skipcol)
exe "norm! \<C-B>"
call assert_equal(80, winsaveview().skipcol)
exe "norm! \<C-B>"
call assert_equal(0, winsaveview().skipcol)
exe "norm! \<C-D>"
call assert_equal(200, winsaveview().skipcol)
exe "norm! \<C-D>"
call assert_equal(400, winsaveview().skipcol)
exe "norm! \<C-D>"
call assert_equal(600, winsaveview().skipcol)
exe "norm! \<C-D>"
call assert_equal(800, winsaveview().skipcol)
exe "norm! \<C-D>"
call assert_equal(880, winsaveview().skipcol)
exe "norm! \<C-U>"
call assert_equal(680, winsaveview().skipcol)
exe "norm! \<C-U>"
call assert_equal(480, winsaveview().skipcol)
exe "norm! \<C-U>"
call assert_equal(280, winsaveview().skipcol)
exe "norm! \<C-U>"
call assert_equal(80, winsaveview().skipcol)
exe "norm! \<C-U>"
call assert_equal(0, winsaveview().skipcol)
set smoothscroll&
endfunc
" vim: shiftwidth=2 sts=2 expandtab