refactor: de-curwin-ify update_topline/curs_columns

2025-09-24 20:18:32 +00:00 · 2020-12-23 16:53:35 +01:00
parent 4d9520ec86
commit 45166313cc
13 changed files with 221 additions and 215 deletions
--- a/src/nvim/move.c
+++ b/src/nvim/move.c
@@ -129,7 +129,7 @@ void redraw_for_cursorline(win_T *wp)
 */
 void update_topline_redraw(void)
 {
-  update_topline();
+  update_topline(curwin);
  if (must_redraw)
    update_screen(0);
 }
@@ -137,28 +137,28 @@ void update_topline_redraw(void)
 /*
 * Update curwin->w_topline to move the cursor onto the screen.
 */
-void update_topline(void)
+void update_topline(win_T *wp)
 {
  linenr_T old_topline;
  int old_topfill;
  bool check_topline = false;
  bool check_botline = false;
-  long *so_ptr = curwin->w_p_so >= 0 ? &curwin->w_p_so : &p_so;
+  long *so_ptr = wp->w_p_so >= 0 ? &wp->w_p_so : &p_so;
  long save_so = *so_ptr;

  // If there is no valid screen and when the window height is zero just use
  // the cursor line.
-  if (!default_grid.chars || curwin->w_height_inner == 0) {
-    curwin->w_topline = curwin->w_cursor.lnum;
-    curwin->w_botline = curwin->w_topline;
-    curwin->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
-    curwin->w_viewport_invalid = true;
-    curwin->w_scbind_pos = 1;
+  if (!default_grid.chars || wp->w_height_inner == 0) {
+    wp->w_topline = wp->w_cursor.lnum;
+    wp->w_botline = wp->w_topline;
+    wp->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
+    wp->w_viewport_invalid = true;
+    wp->w_scbind_pos = 1;
    return;
  }

-  check_cursor_moved(curwin);
-  if (curwin->w_valid & VALID_TOPLINE)
+  check_cursor_moved(wp);
+  if (wp->w_valid & VALID_TOPLINE)
    return;

  // When dragging with the mouse, don't scroll that quickly
@@ -166,52 +166,52 @@ void update_topline(void)
    *so_ptr = mouse_dragging - 1;
  }

-  old_topline = curwin->w_topline;
-  old_topfill = curwin->w_topfill;
+  old_topline = wp->w_topline;
+  old_topfill = wp->w_topfill;

  // If the buffer is empty, always set topline to 1.
  if (BUFEMPTY()) {             // special case - file is empty
-    if (curwin->w_topline != 1) {
-      redraw_later(curwin, NOT_VALID);
+    if (wp->w_topline != 1) {
+      redraw_later(wp, NOT_VALID);
    }
-    curwin->w_topline = 1;
-    curwin->w_botline = 2;
-    curwin->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
-    curwin->w_viewport_invalid = true;
-    curwin->w_scbind_pos = 1;
+    wp->w_topline = 1;
+    wp->w_botline = 2;
+    wp->w_valid |= VALID_BOTLINE|VALID_BOTLINE_AP;
+    wp->w_viewport_invalid = true;
+    wp->w_scbind_pos = 1;
  }
  /*
   * If the cursor is above or near the top of the window, scroll the window
   * to show the line the cursor is in, with 'scrolloff' context.
   */
  else {
-    if (curwin->w_topline > 1) {
+    if (wp->w_topline > 1) {
      /* If the cursor is above topline, scrolling is always needed.
       * If the cursor is far below topline and there is no folding,
       * scrolling down is never needed. */
-      if (curwin->w_cursor.lnum < curwin->w_topline)
+      if (wp->w_cursor.lnum < wp->w_topline)
        check_topline = true;
      else if (check_top_offset())
        check_topline = true;
    }
    /* Check if there are more filler lines than allowed. */
-    if (!check_topline && curwin->w_topfill > diff_check_fill(curwin,
-            curwin->w_topline))
+    if (!check_topline && wp->w_topfill > diff_check_fill(wp,
+            wp->w_topline))
      check_topline = true;

    if (check_topline) {
-      int halfheight = curwin->w_height_inner / 2 - 1;
+      int halfheight = wp->w_height_inner / 2 - 1;
      if (halfheight < 2) {
        halfheight = 2;
      }
      long n;
-      if (hasAnyFolding(curwin)) {
+      if (hasAnyFolding(wp)) {
        /* Count the number of logical lines between the cursor and
         * topline + p_so (approximation of how much will be
         * scrolled). */
        n = 0;
-        for (linenr_T lnum = curwin->w_cursor.lnum;
-             lnum < curwin->w_topline + *so_ptr; lnum++) {
+        for (linenr_T lnum = wp->w_cursor.lnum;
+             lnum < wp->w_topline + *so_ptr; lnum++) {
          n++;
          // stop at end of file or when we know we are far off
          if (lnum >= curbuf->b_ml.ml_line_count || n >= halfheight) {
@@ -220,7 +220,7 @@ void update_topline(void)
          (void)hasFolding(lnum, NULL, &lnum);
        }
      } else {
-        n = curwin->w_topline + *so_ptr - curwin->w_cursor.lnum;
+        n = wp->w_topline + *so_ptr - wp->w_cursor.lnum;
      }

      /* If we weren't very close to begin with, we scroll to put the
@@ -234,7 +234,7 @@ void update_topline(void)
      }
    } else {
      /* Make sure topline is the first line of a fold. */
-      (void)hasFolding(curwin->w_topline, &curwin->w_topline, NULL);
+      (void)hasFolding(wp->w_topline, &wp->w_topline, NULL);
      check_botline = true;
    }
  }
@@ -248,35 +248,37 @@ void update_topline(void)
   * for every small change.
   */
  if (check_botline) {
-    if (!(curwin->w_valid & VALID_BOTLINE_AP))
-      validate_botline();
+    if (!(wp->w_valid & VALID_BOTLINE_AP)) {
+      validate_botline(wp);
+    }

-    if (curwin->w_botline <= curbuf->b_ml.ml_line_count) {
-      if (curwin->w_cursor.lnum < curwin->w_botline) {
-        if (((long)curwin->w_cursor.lnum
-             >= (long)curwin->w_botline - *so_ptr
-             || hasAnyFolding(curwin)
+    assert(wp->w_buffer != 0);
+    if (wp->w_botline <= wp->w_buffer->b_ml.ml_line_count) {
+      if (wp->w_cursor.lnum < wp->w_botline) {
+        if (((long)wp->w_cursor.lnum
+             >= (long)wp->w_botline - *so_ptr
+             || hasAnyFolding(wp)
             )) {
          lineoff_T loff;

          /* Cursor is (a few lines) above botline, check if there are
           * 'scrolloff' window lines below the cursor.  If not, need to
           * scroll. */
-          int n = curwin->w_empty_rows;
-          loff.lnum = curwin->w_cursor.lnum;
+          int n = wp->w_empty_rows;
+          loff.lnum = wp->w_cursor.lnum;
          /* In a fold go to its last line. */
-          (void)hasFolding(loff.lnum, NULL, &loff.lnum);
+          (void)hasFoldingWin(wp, loff.lnum, NULL, &loff.lnum, true, NULL);
          loff.fill = 0;
-          n += curwin->w_filler_rows;
+          n += wp->w_filler_rows;
          loff.height = 0;
-          while (loff.lnum < curwin->w_botline
-                 && (loff.lnum + 1 < curwin->w_botline || loff.fill == 0)
+          while (loff.lnum < wp->w_botline
+                 && (loff.lnum + 1 < wp->w_botline || loff.fill == 0)
                 ) {
            n += loff.height;
            if (n >= *so_ptr) {
              break;
            }
-            botline_forw(&loff);
+            botline_forw(wp, &loff);
          }
          if (n >= *so_ptr) {
            // sufficient context, no need to scroll
@@ -289,23 +291,23 @@ void update_topline(void)
      }
      if (check_botline) {
        long line_count = 0;
-        if (hasAnyFolding(curwin)) {
+        if (hasAnyFolding(wp)) {
          /* Count the number of logical lines between the cursor and
           * botline - p_so (approximation of how much will be
           * scrolled). */
-          for (linenr_T lnum = curwin->w_cursor.lnum;
-               lnum >= curwin->w_botline - *so_ptr; lnum--) {
+          for (linenr_T lnum = wp->w_cursor.lnum;
+               lnum >= wp->w_botline - *so_ptr; lnum--) {
            line_count++;
            // stop at end of file or when we know we are far off
-            if (lnum <= 0 || line_count > curwin->w_height_inner + 1) {
+            if (lnum <= 0 || line_count > wp->w_height_inner + 1) {
              break;
            }
            (void)hasFolding(lnum, &lnum, NULL);
          }
        } else
-          line_count = curwin->w_cursor.lnum - curwin->w_botline
+          line_count = wp->w_cursor.lnum - wp->w_botline
                       + 1 + *so_ptr;
-        if (line_count <= curwin->w_height_inner + 1) {
+        if (line_count <= wp->w_height_inner + 1) {
          scroll_cursor_bot(scrolljump_value(), false);
        } else {
          scroll_cursor_halfway(false);
@@ -313,25 +315,25 @@ void update_topline(void)
      }
    }
  }
-  curwin->w_valid |= VALID_TOPLINE;
-  curwin->w_viewport_invalid = true;
-  win_check_anchored_floats(curwin);
+  wp->w_valid |= VALID_TOPLINE;
+  wp->w_viewport_invalid = true;
+  win_check_anchored_floats(wp);

  /*
   * Need to redraw when topline changed.
   */
-  if (curwin->w_topline != old_topline
-      || curwin->w_topfill != old_topfill
+  if (wp->w_topline != old_topline
+      || wp->w_topfill != old_topfill
      ) {
    dollar_vcol = -1;
-    if (curwin->w_skipcol != 0) {
-      curwin->w_skipcol = 0;
-      redraw_later(curwin, NOT_VALID);
+    if (wp->w_skipcol != 0) {
+      wp->w_skipcol = 0;
+      redraw_later(wp, NOT_VALID);
    } else {
-      redraw_later(curwin, VALID);
+      redraw_later(wp, VALID);
    }
    // May need to set w_skipcol when cursor in w_topline.
-    if (curwin->w_cursor.lnum == curwin->w_topline) {
+    if (wp->w_cursor.lnum == wp->w_topline) {
      validate_cursor();
    }
  }
@@ -346,7 +348,7 @@ void update_topline_win(win_T* win)
 {
  win_T *save_curwin;
  switch_win(&save_curwin, NULL, win, NULL, true);
-  update_topline();
+  update_topline(curwin);
  restore_win(save_curwin, NULL, true);
 }

@@ -498,10 +500,11 @@ void changed_line_abv_curs_win(win_T *wp)
 /*
 * Make sure the value of curwin->w_botline is valid.
 */
-void validate_botline(void)
+void validate_botline(win_T *wp)
 {
-  if (!(curwin->w_valid & VALID_BOTLINE))
-    comp_botline(curwin);
+  if (!(wp->w_valid & VALID_BOTLINE)) {
+    comp_botline(wp);
+  }
 }

 /*
@@ -540,7 +543,7 @@ void validate_cursor(void)
 {
  check_cursor_moved(curwin);
  if ((curwin->w_valid & (VALID_WCOL|VALID_WROW)) != (VALID_WCOL|VALID_WROW))
-    curs_columns(true);
+    curs_columns(curwin, true);
 }

 /*
@@ -720,8 +723,10 @@ int curwin_col_off2(void)
 // Compute curwin->w_wcol and curwin->w_virtcol.
 // Also updates curwin->w_wrow and curwin->w_cline_row.
 // Also updates curwin->w_leftcol.
+// @param may_scroll when true, may scroll horizontally
 void curs_columns(
-    int may_scroll                 /* when true, may scroll horizontally */
+    win_T *wp,
+    int may_scroll
 )
 {
  int n;
@@ -729,72 +734,71 @@ void curs_columns(
  colnr_T startcol;
  colnr_T endcol;
  colnr_T prev_skipcol;
-  long so = get_scrolloff_value(curwin);
-  long siso = get_sidescrolloff_value(curwin);
+  long so = get_scrolloff_value(wp);
+  long siso = get_sidescrolloff_value(wp);

  /*
   * First make sure that w_topline is valid (after moving the cursor).
   */
-  update_topline();
+  update_topline(wp);

  // Next make sure that w_cline_row is valid.
-  if (!(curwin->w_valid & VALID_CROW)) {
-    curs_rows(curwin);
+  if (!(wp->w_valid & VALID_CROW)) {
+    curs_rows(wp);
  }

  /*
   * Compute the number of virtual columns.
   */
-  if (curwin->w_cline_folded)
+  if (wp->w_cline_folded) {
    /* In a folded line the cursor is always in the first column */
-    startcol = curwin->w_virtcol = endcol = curwin->w_leftcol;
-  else
-    getvvcol(curwin, &curwin->w_cursor,
-        &startcol, &(curwin->w_virtcol), &endcol);
+    startcol = wp->w_virtcol = endcol = wp->w_leftcol;
+  } else {
+    getvvcol(wp, &wp->w_cursor,
+        &startcol, &(wp->w_virtcol), &endcol);
+  }

  /* remove '$' from change command when cursor moves onto it */
  if (startcol > dollar_vcol)
    dollar_vcol = -1;

-  int extra = curwin_col_off();
-  curwin->w_wcol = curwin->w_virtcol + extra;
+  int extra = win_col_off(wp);
+  wp->w_wcol = wp->w_virtcol + extra;
  endcol += extra;

-  /*
-   * Now compute w_wrow, counting screen lines from w_cline_row.
-   */
-  curwin->w_wrow = curwin->w_cline_row;
+  // Now compute w_wrow, counting screen lines from w_cline_row.
+  wp->w_wrow = wp->w_cline_row;

-  int textwidth = curwin->w_width_inner - extra;
+  int textwidth = wp->w_width_inner - extra;
  if (textwidth <= 0) {
    // No room for text, put cursor in last char of window.
-    curwin->w_wcol = curwin->w_width_inner - 1;
-    curwin->w_wrow = curwin->w_height_inner - 1;
-  } else if (curwin->w_p_wrap
-             && curwin->w_width_inner != 0
+    wp->w_wcol = wp->w_width_inner - 1;
+    wp->w_wrow = wp->w_height_inner - 1;
+  } else if (wp->w_p_wrap
+             && wp->w_width_inner != 0
             ) {
-    width = textwidth + curwin_col_off2();
+    width = textwidth + win_col_off2(wp);

-    // long line wrapping, adjust curwin->w_wrow
-    if (curwin->w_wcol >= curwin->w_width_inner) {
+    // long line wrapping, adjust wp->w_wrow
+    if (wp->w_wcol >= wp->w_width_inner) {
      // this same formula is used in validate_cursor_col()
-      n = (curwin->w_wcol - curwin->w_width_inner) / width + 1;
-      curwin->w_wcol -= n * width;
-      curwin->w_wrow += n;
+      n = (wp->w_wcol - wp->w_width_inner) / width + 1;
+      wp->w_wcol -= n * width;
+      wp->w_wrow += n;

      /* When cursor wraps to first char of next line in Insert
       * mode, the 'showbreak' string isn't shown, backup to first
       * column */
      if (*p_sbr && *get_cursor_pos_ptr() == NUL
-          && curwin->w_wcol == (int)vim_strsize(p_sbr))
-        curwin->w_wcol = 0;
+          && wp->w_wcol == (int)vim_strsize(p_sbr))
+        wp->w_wcol = 0;
    }
  }
-  /* No line wrapping: compute curwin->w_leftcol if scrolling is on and line
+  /* No line wrapping: compute wp->w_leftcol if scrolling is on and line
   * is not folded.
-   * If scrolling is off, curwin->w_leftcol is assumed to be 0 */
+   * If scrolling is off, wp->w_leftcol is assumed to be 0 */
  else if (may_scroll
-           && !curwin->w_cline_folded
+           && !wp->w_cline_folded
           ) {
    /*
     * If Cursor is left of the screen, scroll rightwards.
@@ -803,9 +807,9 @@ void curs_columns(
     * extra
     */
    assert(siso <= INT_MAX);
-    int off_left = startcol - curwin->w_leftcol - (int)siso;
+    int off_left = startcol - wp->w_leftcol - (int)siso;
    int off_right =
-        endcol - curwin->w_leftcol - curwin->w_width_inner + (int)siso + 1;
+        endcol - wp->w_leftcol - wp->w_width_inner + (int)siso + 1;
    if (off_left < 0 || off_right > 0) {
      int diff = (off_left < 0) ? -off_left: off_right;

@@ -813,52 +817,52 @@ void curs_columns(
       * middle of window. */
      int new_leftcol;
      if (p_ss == 0 || diff >= textwidth / 2 || off_right >= off_left)
-        new_leftcol = curwin->w_wcol - extra - textwidth / 2;
+        new_leftcol = wp->w_wcol - extra - textwidth / 2;
      else {
        if (diff < p_ss) {
          assert(p_ss <= INT_MAX);
          diff = (int)p_ss;
        }
        if (off_left < 0)
-          new_leftcol = curwin->w_leftcol - diff;
+          new_leftcol = wp->w_leftcol - diff;
        else
-          new_leftcol = curwin->w_leftcol + diff;
+          new_leftcol = wp->w_leftcol + diff;
      }
      if (new_leftcol < 0)
        new_leftcol = 0;
-      if (new_leftcol != (int)curwin->w_leftcol) {
-        curwin->w_leftcol = new_leftcol;
-        win_check_anchored_floats(curwin);
-        // screen has to be redrawn with new curwin->w_leftcol
-        redraw_later(curwin, NOT_VALID);
+      if (new_leftcol != (int)wp->w_leftcol) {
+        wp->w_leftcol = new_leftcol;
+        win_check_anchored_floats(wp);
+        // screen has to be redrawn with new wp->w_leftcol
+        redraw_later(wp, NOT_VALID);
      }
    }
-    curwin->w_wcol -= curwin->w_leftcol;
-  } else if (curwin->w_wcol > (int)curwin->w_leftcol)
-    curwin->w_wcol -= curwin->w_leftcol;
+    wp->w_wcol -= wp->w_leftcol;
+  } else if (wp->w_wcol > (int)wp->w_leftcol)
+    wp->w_wcol -= wp->w_leftcol;
  else
-    curwin->w_wcol = 0;
+    wp->w_wcol = 0;

  /* Skip over filler lines.  At the top use w_topfill, there
   * may be some filler lines above the window. */
-  if (curwin->w_cursor.lnum == curwin->w_topline)
-    curwin->w_wrow += curwin->w_topfill;
+  if (wp->w_cursor.lnum == wp->w_topline)
+    wp->w_wrow += wp->w_topfill;
  else
-    curwin->w_wrow += diff_check_fill(curwin, curwin->w_cursor.lnum);
+    wp->w_wrow += diff_check_fill(wp, wp->w_cursor.lnum);

-  prev_skipcol = curwin->w_skipcol;
+  prev_skipcol = wp->w_skipcol;

  int plines = 0;
-  if ((curwin->w_wrow >= curwin->w_height_inner
+  if ((wp->w_wrow >= wp->w_height_inner
       || ((prev_skipcol > 0
-            || curwin->w_wrow + so >= curwin->w_height_inner)
+            || wp->w_wrow + so >= wp->w_height_inner)
           && (plines =
-               plines_win_nofill(curwin, curwin->w_cursor.lnum, false)) - 1
-           >= curwin->w_height_inner))
-      && curwin->w_height_inner != 0
-      && curwin->w_cursor.lnum == curwin->w_topline
+               plines_win_nofill(wp, wp->w_cursor.lnum, false)) - 1
+           >= wp->w_height_inner))
+      && wp->w_height_inner != 0
+      && wp->w_cursor.lnum == wp->w_topline
      && width > 0
-      && curwin->w_width_inner != 0
+      && wp->w_width_inner != 0
      ) {
    /* Cursor past end of screen.  Happens with a single line that does
     * not fit on screen.  Find a skipcol to show the text around the
@@ -867,87 +871,87 @@ void curs_columns(
     * 2: Less than "p_so" lines below
     * 3: both of them */
    extra = 0;
-    if (curwin->w_skipcol + so * width > curwin->w_virtcol) {
+    if (wp->w_skipcol + so * width > wp->w_virtcol) {
      extra = 1;
    }
    // Compute last display line of the buffer line that we want at the
    // bottom of the window.
    if (plines == 0) {
-      plines = plines_win(curwin, curwin->w_cursor.lnum, false);
+      plines = plines_win(wp, wp->w_cursor.lnum, false);
    }
    plines--;
-    if (plines > curwin->w_wrow + so) {
+    if (plines > wp->w_wrow + so) {
      assert(so <= INT_MAX);
-      n = curwin->w_wrow + (int)so;
+      n = wp->w_wrow + (int)so;
    } else {
      n = plines;
    }
-    if ((colnr_T)n >= curwin->w_height_inner + curwin->w_skipcol / width) {
+    if ((colnr_T)n >= wp->w_height_inner + wp->w_skipcol / width) {
      extra += 2;
    }

    if (extra == 3 || plines < so * 2) {
      // not enough room for 'scrolloff', put cursor in the middle
-      n = curwin->w_virtcol / width;
-      if (n > curwin->w_height_inner / 2) {
-        n -= curwin->w_height_inner / 2;
+      n = wp->w_virtcol / width;
+      if (n > wp->w_height_inner / 2) {
+        n -= wp->w_height_inner / 2;
      } else {
        n = 0;
      }
      // don't skip more than necessary
-      if (n > plines - curwin->w_height_inner + 1) {
-        n = plines - curwin->w_height_inner + 1;
+      if (n > plines - wp->w_height_inner + 1) {
+        n = plines - wp->w_height_inner + 1;
      }
-      curwin->w_skipcol = n * width;
+      wp->w_skipcol = n * width;
    } else if (extra == 1) {
      // less then 'scrolloff' lines above, decrease skipcol
      assert(so <= INT_MAX);
-      extra = (curwin->w_skipcol + (int)so * width - curwin->w_virtcol
+      extra = (wp->w_skipcol + (int)so * width - wp->w_virtcol
               + width - 1) / width;
      if (extra > 0) {
-        if ((colnr_T)(extra * width) > curwin->w_skipcol)
-          extra = curwin->w_skipcol / width;
-        curwin->w_skipcol -= extra * width;
+        if ((colnr_T)(extra * width) > wp->w_skipcol)
+          extra = wp->w_skipcol / width;
+        wp->w_skipcol -= extra * width;
      }
    } else if (extra == 2) {
      // less then 'scrolloff' lines below, increase skipcol
-      endcol = (n - curwin->w_height_inner + 1) * width;
-      while (endcol > curwin->w_virtcol) {
+      endcol = (n - wp->w_height_inner + 1) * width;
+      while (endcol > wp->w_virtcol) {
        endcol -= width;
      }
-      if (endcol > curwin->w_skipcol) {
-        curwin->w_skipcol = endcol;
+      if (endcol > wp->w_skipcol) {
+        wp->w_skipcol = endcol;
      }
    }

-    curwin->w_wrow -= curwin->w_skipcol / width;
-    if (curwin->w_wrow >= curwin->w_height_inner) {
+    wp->w_wrow -= wp->w_skipcol / width;
+    if (wp->w_wrow >= wp->w_height_inner) {
      // small window, make sure cursor is in it
-      extra = curwin->w_wrow - curwin->w_height_inner + 1;
-      curwin->w_skipcol += extra * width;
-      curwin->w_wrow -= extra;
+      extra = wp->w_wrow - wp->w_height_inner + 1;
+      wp->w_skipcol += extra * width;
+      wp->w_wrow -= extra;
    }

    // extra could be either positive or negative
-    extra = ((int)prev_skipcol - (int)curwin->w_skipcol) / width;
-    win_scroll_lines(curwin, 0, extra);
+    extra = ((int)prev_skipcol - (int)wp->w_skipcol) / width;
+    win_scroll_lines(wp, 0, extra);
  } else {
-    curwin->w_skipcol = 0;
+    wp->w_skipcol = 0;
  }
-  if (prev_skipcol != curwin->w_skipcol) {
-    redraw_later(curwin, NOT_VALID);
+  if (prev_skipcol != wp->w_skipcol) {
+    redraw_later(wp, NOT_VALID);
  }

  /* Redraw when w_virtcol changes and 'cursorcolumn' is set */
-  if (curwin->w_p_cuc && (curwin->w_valid & VALID_VIRTCOL) == 0
+  if (wp->w_p_cuc && (wp->w_valid & VALID_VIRTCOL) == 0
      && !pum_visible()) {
-    redraw_later(curwin, SOME_VALID);
+    redraw_later(wp, SOME_VALID);
  }

  // now w_leftcol is valid, avoid check_cursor_moved() thinking otherwise
-  curwin->w_valid_leftcol = curwin->w_leftcol;
+  wp->w_valid_leftcol = wp->w_leftcol;

-  curwin->w_valid |= VALID_WCOL|VALID_WROW|VALID_VIRTCOL;
+  wp->w_valid |= VALID_WCOL|VALID_WROW|VALID_VIRTCOL;
 }

 /// Compute the screen position of text character at "pos" in window "wp"
@@ -1315,22 +1319,23 @@ static void topline_back(lineoff_T *lp)
 * Returns the height of the added line in "lp->height".
 * Lines below the last one are incredibly high.
 */
-static void botline_forw(lineoff_T *lp)
+static void botline_forw(win_T *wp, lineoff_T *lp)
 {
-  if (lp->fill < diff_check_fill(curwin, lp->lnum + 1)) {
+  if (lp->fill < diff_check_fill(wp, lp->lnum + 1)) {
    /* Add a filler line. */
    ++lp->fill;
    lp->height = 1;
  } else {
    ++lp->lnum;
    lp->fill = 0;
-    if (lp->lnum > curbuf->b_ml.ml_line_count) {
+    assert(wp->w_buffer != 0);
+    if (lp->lnum > wp->w_buffer->b_ml.ml_line_count) {
      lp->height = MAXCOL;
-    } else if (hasFolding(lp->lnum, NULL, &lp->lnum)) {
+    } else if (hasFoldingWin(wp, lp->lnum, NULL, &lp->lnum, true, NULL)) {
      // Add a closed fold
      lp->height = 1;
    } else {
-      lp->height = plines_nofill(lp->lnum);
+      lp->height = plines_win_nofill(wp, lp->lnum, true);
    }
  }
 }
@@ -1542,8 +1547,9 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
        || curwin->w_topfill != old_topfill
        )
      curwin->w_valid &= ~(VALID_WROW|VALID_CROW);
-  } else
-    validate_botline();
+  } else {
+    validate_botline(curwin);
+  }

  /* The lines of the cursor line itself are always used. */
  used = plines_nofill(cln);
@@ -1610,7 +1616,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)

    if (boff.lnum < curbuf->b_ml.ml_line_count) {
      /* Add one line below */
-      botline_forw(&boff);
+      botline_forw(curwin, &boff);
      used += boff.height;
      if (used > curwin->w_height_inner) {
        break;
@@ -1647,7 +1653,7 @@ void scroll_cursor_bot(int min_scroll, int set_topbot)
    boff.lnum = curwin->w_topline - 1;
    int i;
    for (i = 0; i < scrolled && boff.lnum < curwin->w_botline; ) {
-      botline_forw(&boff);
+      botline_forw(curwin, &boff);
      i += boff.height;
      ++line_count;
    }
@@ -1701,7 +1707,7 @@ void scroll_cursor_halfway(int atend)
  while (topline > 1) {
    if (below <= above) {           /* add a line below the cursor first */
      if (boff.lnum < curbuf->b_ml.ml_line_count) {
-        botline_forw(&boff);
+        botline_forw(curwin, &boff);
        used += boff.height;
        if (used > curwin->w_height_inner) {
          break;
@@ -1764,7 +1770,7 @@ void cursor_correct(void)
      below_wanted = max_off;
    }
  }
-  validate_botline();
+  validate_botline(curwin);
  if (curwin->w_botline == curbuf->b_ml.ml_line_count + 1
      && mouse_dragging == 0) {
    below_wanted = 0;
@@ -1856,7 +1862,7 @@ int onepage(Direction dir, long count)
  }

  for (; count > 0; --count) {
-    validate_botline();
+    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
@@ -1958,11 +1964,11 @@ int onepage(Direction dir, long count)
      } else {
        /* Go two lines forward again. */
        topline_botline(&loff);
-        botline_forw(&loff);
-        botline_forw(&loff);
+        botline_forw(curwin, &loff);
+        botline_forw(curwin, &loff);
        botline_topline(&loff);
        /* We're at the wrong end of a fold now. */
-        (void)hasFolding(loff.lnum, &loff.lnum, NULL);
+        (void)hasFoldingWin(curwin, loff.lnum, &loff.lnum, NULL, true, NULL);

        /* Always scroll at least one line.  Avoid getting stuck on
         * very long lines. */
@@ -2047,7 +2053,7 @@ static void get_scroll_overlap(lineoff_T *lp, int dir)

  lineoff_T loff0 = *lp;
  if (dir > 0)
-    botline_forw(lp);
+    botline_forw(curwin, lp);
  else
    topline_back(lp);
  int h2 = lp->height;
@@ -2058,7 +2064,7 @@ static void get_scroll_overlap(lineoff_T *lp, int dir)

  lineoff_T loff1 = *lp;
  if (dir > 0)
-    botline_forw(lp);
+    botline_forw(curwin, lp);
  else
    topline_back(lp);
  int h3 = lp->height;
@@ -2069,7 +2075,7 @@ static void get_scroll_overlap(lineoff_T *lp, int dir)

  lineoff_T loff2 = *lp;
  if (dir > 0)
-    botline_forw(lp);
+    botline_forw(curwin, lp);
  else
    topline_back(lp);
  int h4 = lp->height;
@@ -2094,8 +2100,8 @@ void halfpage(bool flag, linenr_T Prenum)
  int n = curwin->w_p_scr <= curwin->w_height_inner ? (int)curwin->w_p_scr
                                              : curwin->w_height_inner;

-  update_topline();
-  validate_botline();
+  update_topline(curwin);
+  validate_botline(curwin);
  int room = curwin->w_empty_rows + curwin->w_filler_rows;
  if (flag) {
    /*
@@ -2255,7 +2261,7 @@ void do_check_cursorbind(void)

      // Only scroll when 'scrollbind' hasn't done this.
      if (!curwin->w_p_scb) {
-        update_topline();
+        update_topline(curwin);
      }
      curwin->w_redr_status = true;
    }