return extra2 > 3 ? 0 : 3 - extra2;
}
+/*
+ * Calculates the skipcol offset for window "wp" given how many
+ * physical lines we want to scroll down.
+ */
+ static int
+skipcol_from_plines(win_T *wp, int plines_off)
+{
+ int width1 = wp->w_width - win_col_off(wp);
+
+ int skipcol = 0;
+ if (plines_off > 0)
+ skipcol += width1;
+ if (plines_off > 1)
+ skipcol += (width1 + win_col_off2(wp)) * (plines_off - 1);
+ return skipcol;
+}
+
/*
* Set curwin->s_skipcol to zero and redraw later if needed.
*/
* Lines above the first one are incredibly high: MAXCOL.
*/
static void
-topline_back(lineoff_T *lp)
+topline_back_winheight(
+ lineoff_T *lp,
+ int winheight) // when TRUE limit to window height
{
#ifdef FEAT_DIFF
if (lp->fill < diff_check_fill(curwin, lp->lnum))
lp->height = 1;
else
#endif
- lp->height = PLINES_NOFILL(lp->lnum);
+ lp->height = PLINES_WIN_NOFILL(curwin, lp->lnum, winheight);
}
}
+ static void
+topline_back(lineoff_T *lp)
+{
+ topline_back_winheight(lp, TRUE);
+}
+
+
/*
* Add one line below "lp->lnum". This can be a filler line, a closed fold or
* a (wrapped) text line. Uses and sets "lp->fill".
else
#endif
i = PLINES_NOFILL(top);
+ if (top < curwin->w_topline)
+ scrolled += i;
+
+ // If scrolling is needed, scroll at least 'sj' lines.
+ if ((new_topline >= curwin->w_topline || scrolled > min_scroll)
+ && extra >= off)
+ break;
+
used += i;
if (extra + i <= off && bot < curbuf->b_ml.ml_line_count)
{
}
if (used > curwin->w_height)
break;
- if (top < curwin->w_topline)
- scrolled += i;
-
- /*
- * If scrolling is needed, scroll at least 'sj' lines.
- */
- if ((new_topline >= curwin->w_topline || scrolled > min_scroll)
- && extra >= off)
- break;
extra += i;
new_topline = top;
int i;
linenr_T line_count;
linenr_T old_topline = curwin->w_topline;
+ int old_skipcol = curwin->w_skipcol;
lineoff_T loff;
lineoff_T boff;
#ifdef FEAT_DIFF
cln = curwin->w_cursor.lnum;
if (set_topbot)
{
+ int set_skipcol = FALSE;
+
used = 0;
curwin->w_botline = cln + 1;
#ifdef FEAT_DIFF
curwin->w_topline = loff.lnum)
{
loff.lnum = curwin->w_topline;
- topline_back(&loff);
- if (loff.height == MAXCOL || used + loff.height > curwin->w_height)
+ topline_back_winheight(&loff, FALSE);
+ if (loff.height == MAXCOL)
break;
+ if (used + loff.height > curwin->w_height)
+ {
+ if (curwin->w_p_sms && curwin->w_p_wrap)
+ {
+ // 'smoothscroll' and 'wrap' are set. The above line is
+ // too long to show in its entirety, so we show just a part
+ // of it.
+ if (used < curwin->w_height)
+ {
+ int plines_offset = used + loff.height
+ - curwin->w_height;
+ used = curwin->w_height;
+#ifdef FEAT_DIFF
+ curwin->w_topfill = loff.fill;
+#endif
+ curwin->w_topline = loff.lnum;
+ curwin->w_skipcol = skipcol_from_plines(
+ curwin, plines_offset);
+ set_skipcol = TRUE;
+ }
+ }
+ break;
+ }
used += loff.height;
#ifdef FEAT_DIFF
curwin->w_topfill = loff.fill;
#ifdef FEAT_DIFF
|| curwin->w_topfill != old_topfill
#endif
- )
+ || set_skipcol
+ || curwin->w_skipcol != 0)
+ {
curwin->w_valid &= ~(VALID_WROW|VALID_CROW);
+ if (set_skipcol)
+ redraw_later(UPD_NOT_VALID);
+ else
+ reset_skipcol();
+ }
}
else
validate_botline();
* (we changed them).
* If topline did change, update_screen() will set botline.
*/
- if (curwin->w_topline == old_topline && set_topbot)
+ if (curwin->w_topline == old_topline
+ && curwin->w_skipcol == old_skipcol
+ && set_topbot)
{
curwin->w_botline = old_botline;
curwin->w_empty_rows = old_empty_rows;
{
int above = 0;
linenr_T topline;
+ colnr_T skipcol = 0;
+ int set_skipcol = FALSE;
#ifdef FEAT_DIFF
int topfill = 0;
#endif
used = plines(loff.lnum);
#endif
topline = loff.lnum;
+
+ int half_height = 0;
+ int smooth_scroll = FALSE;
+ if (curwin->w_p_sms && curwin->w_p_wrap)
+ {
+ // 'smoothscroll' and 'wrap' are set
+ smooth_scroll = TRUE;
+ half_height = (curwin->w_height - used) / 2;
+ used = 0;
+ }
+
while (topline > 1)
{
+ // If using smoothscroll, we can precisely scroll to the
+ // exact point where the cursor is halfway down the screen.
+ if (smooth_scroll)
+ {
+ topline_back_winheight(&loff, FALSE);
+ if (loff.height == MAXCOL)
+ break;
+ else
+ used += loff.height;
+ if (used > half_height)
+ {
+ if (used - loff.height < half_height)
+ {
+ int plines_offset = used - half_height;
+ loff.height -= plines_offset;
+ used = half_height;
+
+ topline = loff.lnum;
+#ifdef FEAT_DIFF
+ topfill = loff.fill;
+#endif
+ skipcol = skipcol_from_plines(curwin, plines_offset);
+ set_skipcol = TRUE;
+ }
+ break;
+ }
+ topline = loff.lnum;
+#ifdef FEAT_DIFF
+ topfill = loff.fill;
+#endif
+ continue;
+ }
+
+ // If not using smoothscroll, we have to iteratively find how many
+ // lines to scroll down to roughly fit the cursor.
+ // This may not be right in the middle if the lines' physical height >
+ // 1 (e.g. 'wrap' is on).
+
if (below <= above) // add a line below the cursor first
{
if (boff.lnum < curbuf->b_ml.ml_line_count)
#ifdef FEAT_FOLDING
if (!hasFolding(topline, &curwin->w_topline, NULL))
#endif
- curwin->w_topline = topline;
+ {
+ if (curwin->w_topline != topline
+ || set_skipcol
+ || curwin->w_skipcol != 0)
+ {
+ curwin->w_topline = topline;
+ if (set_skipcol)
+ {
+ curwin->w_skipcol = skipcol;
+ redraw_later(UPD_NOT_VALID);
+ }
+ else
+ reset_skipcol();
+ }
+ }
#ifdef FEAT_DIFF
curwin->w_topfill = topfill;
if (old_topline > curwin->w_topline + curwin->w_height)
call term_sendkeys(buf, "0j")
call VerifyScreenDump(buf, 'Test_smooth_long_10', {})
+ " Test zt/zz/zb that they work properly when a long line is above it
+ call term_sendkeys(buf, "zb")
+ call VerifyScreenDump(buf, 'Test_smooth_long_11', {})
+ call term_sendkeys(buf, "zz")
+ call VerifyScreenDump(buf, 'Test_smooth_long_12', {})
+ call term_sendkeys(buf, "zt")
+ call VerifyScreenDump(buf, 'Test_smooth_long_13', {})
+
" Repeat the step and move the cursor down again.
" This time, use a shorter long line that is barely long enough to span more
" than one window. Note that the cursor is at the bottom this time because
call term_sendkeys(buf, ":call setline(1, ['one', 'two', 'Line' .. (' with lots of text'->repeat(10)) .. ' end', 'four'])\<CR>")
call term_sendkeys(buf, "3Gzt")
call term_sendkeys(buf, "j")
- call VerifyScreenDump(buf, 'Test_smooth_long_11', {})
+ call VerifyScreenDump(buf, 'Test_smooth_long_14', {})
" Repeat the step but this time start it when the line is smooth-scrolled by
" one line. This tests that the offset calculation is still correct and
" screen.
call term_sendkeys(buf, "3Gzt")
call term_sendkeys(buf, "\<C-E>j")
- call VerifyScreenDump(buf, 'Test_smooth_long_12', {})
+ call VerifyScreenDump(buf, 'Test_smooth_long_15', {})
call StopVimInTerminal(buf)
endfunc