Should_plan_draw = false

  -- This little bit of state ensures we don't mess with a pane's screen_top
  -- if it was just used to update the viewport.
  Editable_cursor_pane_updated_screen_top = false

function plan_draw()

function plan_draw(options)

      local sy = Padding_vertical
      for pane_index, pane in ipairs(column) do
        if sy > Display_settings.y + App.screen.height - Header_height then
          break
        end
--?         print('bounds:', column_index, pane_index, sx,sy)
        if should_show_pane(pane, sy) then
          table.insert(Panes_to_draw, pane)
          -- stash some short-lived variables
          pane.column_index = column_index
          pane.pane_index = pane_index
          local y_offset = 0
          local body_sy = sy
          if column[pane_index].title then
            body_sy = body_sy + 5+Line_height+5
          end
          if body_sy < Display_settings.y then
            pane.screen_top1, y_offset = schema1_of_y(pane, Display_settings.y - body_sy)
          else
            pane.screen_top1 = {line=1, pos=1}
          end
          if body_sy < Display_settings.y then
            pane.top = Margin_above
          else
            pane.top = body_sy - Display_settings.y + Margin_above
          end
          pane.top = Header_height + pane.top - y_offset
--?           print('bounds: =>', pane.top)
          pane.left = sx - Display_settings.x
          pane.right = pane.left + Display_settings.column_width
          pane.width = pane.right - pane.left
        else
          -- clear bounds to catch issues early
          pane.top = nil
--?           print('bounds: =>', pane.top)
        end
        sy = sy + Margin_above + height(pane) + Margin_below + Padding_vertical
      end
    else
      -- clear bounds to catch issues early
      for _, pane in ipairs(column) do
        pane.top = nil
      end
    end
    sx = sx + Margin_right + Display_settings.column_width + Padding_horizontal + Margin_left
  end
end
-- keep the structure of this function sync'd with refresh_pane_height
function plan_draw_maybe_updating_screen_top_in_cursor_pane(update_screen_top_in_cursor_pane)
--?   print('update pane bounds')
--?   print(#Surface, 'columns;', num_panes(), 'panes')
  Panes_to_draw = {}
  local sx = Padding_horizontal + Margin_left
  for column_index, column in ipairs(Surface) do
    if should_show_column(sx) then

          if should_update_screen_top(column_index, pane_index, update_screen_top_in_cursor_pane) then

          if should_update_screen_top(column_index, pane_index, pane, options) then

function should_update_screen_top(column_index, pane_index, including_cursor_pane)

function should_update_screen_top(column_index, pane_index, pane, options)

  return including_cursor_pane

  -- update the cursor pane either if it's not editable, or
  -- if it was explicitly requested
  if not pane.editable then return true end
  if options == nil then return true end
  if not options.ignore_editable_cursor_pane then return true end
  if not Editable_cursor_pane_updated_screen_top then return true end
  return false

              plan_draw()

              Should_plan_draw = true

    plan_draw()

    Should_plan_draw = true

  Should_plan_draw = false
  Should_ignore_editable_cursor = false

          if chord == 'C-e' then
            command.exit_editing()
          elseif pane.cursor_x == nil then
            -- ignore if cursor is not visible on screen
            assert(pane.cursor_y == nil)
            panning_keychord_pressed(chord, key)
            plan_draw()
          else
            local old_top = {line=pane.screen_top1.line, pos=pane.screen_top1.pos}
            edit.keychord_pressed(pane, chord, key)
            local cursor_pane_updated_screen_top = maybe_update_screen_top_of_cursor_pane(pane, old_top)
            pane._height = nil
            plan_draw_maybe_updating_screen_top_in_cursor_pane(not cursor_pane_updated_screen_top)
          end

          keychord_pressed_on_editable_pane(pane, chord, key)

          plan_draw()

        -- editable cursor pane will have already updated its screen_top, so don't clobber it here
        Should_plan_draw = true
        Should_ignore_editable_cursor = true

function keychord_pressed_on_editable_pane(pane, chord, key)
  if chord == 'C-e' then
    command.exit_editing()
  elseif pane.cursor_x == nil then
    -- ignore if cursor is not visible on screen
    assert(pane.cursor_y == nil)
    panning_keychord_pressed(chord, key)
  else
--?     print(('%s pressed in editor pane'):format(chord))
--?     print(pane.cursor_x, pane.cursor_y)
    local old_top = {line=pane.screen_top1.line, pos=pane.screen_top1.pos}
    edit.keychord_pressed(pane, chord, key)
    maybe_update_screen_top_of_cursor_pane(pane, old_top)
    pane._height = nil
  end
end

  local update = not eq(old_top, pane.screen_top1)
  if update then

  Editable_cursor_pane_updated_screen_top = not eq(old_top, pane.screen_top1)
  if Editable_cursor_pane_updated_screen_top then

  return update

  if Should_plan_draw then
    plan_draw{ignore_editable_cursor_pane=Should_ignore_editable_cursor}
  end