akkartik/pensieve.love - Change VPCPK52KMU4MZUXP4SUSJJDEHDR4C3KJ45HLMUQUK32FMY6OCQ4QC

no, the second experiment makes no sense

There can be many frames between a keypress and key release event.

I ran into this a couple of months ago.

keypress and textinput still happen on the same frame. Hmm. I should just track when an event actually does any work, and only plan_draw then. That way if keypress and textinput have disjoint cases of activation there'll be no duplication.

Created by Kartik K. Agaram on December 10, 2022

VPCPK52KMU4MZUXP4SUSJJDEHDR4C3KJ45HLMUQUK32FMY6OCQ4QC

Dependencies

In channels

main

Change contents

Deletion in run.lua at line 60 [4.178044]
B:BD[3.6202] → [2.17:45]
```
  Should_plan_draw = false
```

Deletion in run.lua at line 111 [4.178044]

B:BD[3.8023] → [2.46:223]


  -- 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

Replacement in run.lua at line 288 [4.178044]
B:BD[3.12677] → [2.224:252]
```
function plan_draw(options)
```
[3.12677]
[5.38]
```
function plan_draw()
```

Insertion in run.lua at line 312 [4.178044]

[3.13711]

          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

Replacement in run.lua at line 323 [4.178044]

B:BD[3.13725] → [2.253:337]

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

[3.13725]

[3.13809]

          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
      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 should_update_screen_top(column_index, pane_index, update_screen_top_in_cursor_pane) then

Replacement in run.lua at line 403 [4.178044]

B:BD[6.847] → [2.338:413]

function should_update_screen_top(column_index, pane_index, pane, options)

[6.847]

[3.15024]

function should_update_screen_top(column_index, pane_index, including_cursor_pane)

Replacement in run.lua at line 406 [4.178044]

B:BD[3.15138] → [2.414:746]

  -- 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

[3.15138]

[3.15470]

  return including_cursor_pane

Replacement in run.lua at line 791 [4.178044]
B:BD[3.27527] → [2.747:785]
```
              Should_plan_draw = true
```
[3.27527]
[3.27553]
```
              plan_draw()
```
Replacement in run.lua at line 810 [4.178044]
B:BD[3.28148] → [2.786:814]
```
    Should_plan_draw = true
```
[3.28148]
[3.28164]
```
    plan_draw()
```

Deletion in run.lua at line 835 [4.178044]

B:BD[4.183641] → [2.815:882]

  Should_plan_draw = false
  Should_ignore_editable_cursor = false

Replacement in run.lua at line 855 [4.178044]

B:BD[7.66] → [2.883:945]

          keychord_pressed_on_editable_pane(pane, chord, key)

[7.66]

[7.128]

          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

Insertion in run.lua at line 871 [4.178044]
[7.221]
[7.221]
```
          plan_draw()
```

Deletion in run.lua at line 873 [4.178044]

B:BD[7.233] → [2.946:1122]

        -- 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

Deletion in run.lua at line 1204 [4.178044]

B:BD[3.43287] → [2.1123:1715]

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

Replacement in run.lua at line 1214 [4.178044]

B:BD[3.44094] → [2.1716:1844]

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

[3.44094]

[3.44222]

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

Insertion in run.lua at line 1223 [4.178044]
[3.44774]
[3.44774]
```
  return update
```

Deletion in run.lua at line 1590 [4.178044]

B:BD[3.58646] → [2.1845:1951]

  if Should_plan_draw then
    plan_draw{ignore_editable_cursor_pane=Should_ignore_editable_cursor}
  end

Replacement in main.lua at line 229 [8.2]
∅:D[3.63901] → [4.190187:190224]
B:BD[9.3121] → [4.190187:190224]
```
function App.keyreleased(chord, key)
```
[3.63901]
[4.190224]
```
function App.keyreleased(key, scancode)
```

Replacement in main.lua at line 236 [8.2]

B:BD[4.190333] → [4.190333:190395]

    if run.key_released then run.key_released(chord, key) end

[4.190333]

[4.190395]

    if run.key_released then run.key_released(key, scancode) end

Replacement in main.lua at line 238 [8.2]

B:BD[4.190433] → [4.190433:190501]

    if source.key_released then source.key_released(chord, key) end

[4.190433]

[4.190501]

    if source.key_released then source.key_released(key, scancode) end