akkartik/snap.love - Change G54H3YG2NEZPW2F6OYT5JPV7KSKVMNW5D3QT3FBCXTJHAQYTV5UAC

get rid of all bifold text

It's just uneconomic to maintain given how little I've used it. I have a bug right now and no time to port the bugfix to all the complexities of the B side.

I briefly considered tossing out the entire source editor. But I have been using it to browse logs across sessions. The live editor doesn't quite cover all my use cases just yet.

We now have duplication in the source editor only for:

syntax highlighting
hyperlinking [[WikiWords]]
ability to hide cursor (when showing file browser or Focus is in log browser)

Created by Kartik K. Agaram on March 17, 2023

G54H3YG2NEZPW2F6OYT5JPV7KSKVMNW5D3QT3FBCXTJHAQYTV5UAC

Dependencies

In channels

main

Change contents

Deletion in text.lua at line 159 [8.1]

∅:D[6.107] → [7.531:690]

∅:D[9.15258] → [7.531:690]

B:BD[7.531] → [7.531:690]

--?     print('=>', State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos, State.screen_bottom1.line, State.screen_bottom1.pos)

Deletion in source_text.lua at line 3 [10.83723]
B:BD[10.83813] → [10.83813:83875]
```
AB_padding = 20  -- space in pixels between A side and B side
```

Replacement in source_text.lua at line 5 [10.83723]

B:BD[10.83964] → [10.83964:84036]

B:BD[10.84036] → [3.7:82]

-- return the final y, and pos,posB of start of final screen line drawn
function Text.draw(State, line_index, y, startpos, startposB, hide_cursor)

[10.83964]

[10.84098]

-- return the final y, and position of start of final screen line drawn
function Text.draw(State, line_index, y, startpos, hide_cursor)

Replacement in source_text.lua at line 11 [10.83723]

B:BD[10.84244] → [10.84244:84630]

B:BD[10.84630] → [3.83:139]

∅:D[3.139] → [10.84669:85853]

B:BD[10.84669] → [10.84669:85853]

B:BD[10.86007] → [10.86007:86501]

B:BD[10.86501] → [3.140:194]

∅:D[3.194] → [10.86538:87305]

B:BD[10.86538] → [10.86538:87305]

  line_cache.startposB = startposB
  -- draw A side
  local overflows_screen, x, pos, screen_line_starting_pos
  if startpos then
    overflows_screen, x, y, pos, screen_line_starting_pos = Text.draw_wrapping_line(State, line_index, State.left, y, startpos)
    if overflows_screen then
      return y, screen_line_starting_pos
    end
    if Focus == 'edit' and State.cursor1.pos then
      if not hide_cursor and not State.search_term then
        if line_index == State.cursor1.line and State.cursor1.pos == pos then
          Text.draw_cursor(State, x, y)
        end
      end
    end
  else
    x = State.left
  end
  -- check for B side
--?   if line_index == 8 then print('checking for B side') end
  if line.dataB == nil then
    assert(y)
    assert(screen_line_starting_pos)
--?     if line_index == 8 then print('return 1') end
    return y, screen_line_starting_pos
  end
  if not State.expanded and not line.expanded then
    assert(y)
    assert(screen_line_starting_pos)
--?     if line_index == 8 then print('return 2') end
    button(State, 'expand', {x=x+AB_padding, y=y+2, w=App.width(State.em), h=State.line_height-4, color={1,1,1},
      icon = function(button_params)
               App.color(Fold_background_color)
               love.graphics.rectangle('fill', button_params.x, button_params.y, App.width(State.em), State.line_height-4, 2,2)
             end,
      onpress1 = function()
                   line.expanded = true
                 end,
    })
    return y, screen_line_starting_pos
  end
  -- draw B side
--?   if line_index == 8 then print('drawing B side') end
  App.color(Fold_color)
  if startposB then
    overflows_screen, x, y, pos, screen_line_starting_pos = Text.draw_wrapping_lineB(State, line_index, x,y, startposB)
  else
    overflows_screen, x, y, pos, screen_line_starting_pos = Text.draw_wrapping_lineB(State, line_index, x+AB_padding,y, 1)
  end
  if overflows_screen then
    return y, nil, screen_line_starting_pos
  end
--?   if line_index == 8 then print('a') end
  if Focus == 'edit' and State.cursor1.posB then
--?     if line_index == 8 then print('b') end
    if not hide_cursor and not State.search_term then
--?       if line_index == 8 then print('c', State.cursor1.line, State.cursor1.posB, line_index, pos) end
      if line_index == State.cursor1.line and State.cursor1.posB == pos then
        Text.draw_cursor(State, x, y)
      end
    end
  end
  return y, nil, screen_line_starting_pos
end
-- Given an array of fragments, draw the subset starting from pos to screen
-- starting from (x,y).
-- Return:
--  - whether we got to bottom of screen before end of line
--  - the final (x,y)
--  - the final pos
--  - starting pos of the final screen line drawn
function Text.draw_wrapping_line(State, line_index, x,y, startpos)
  local line = State.lines[line_index]
  local line_cache = State.line_cache[line_index]
--?   print('== line', line_index, '^'..line.data..'$')

[10.84244]

[10.87305]

  -- wrap long lines
  local x = State.left
  local pos = 1

Replacement in source_text.lua at line 34 [10.83723]

B:BD[10.88027] → [10.88027:88105]

          return --[[screen filled]] true, x,y, pos, screen_line_starting_pos

[10.88027]

[10.88105]

          return y, screen_line_starting_pos

Replacement in source_text.lua at line 59 [10.83723]

B:BD[10.88263] → [10.88263:88332]

      if State.cursor1.pos and line_index == State.cursor1.line then

[10.88263]

[10.88332]

      if line_index == State.cursor1.line then

Replacement in source_text.lua at line 77 [10.83723]

B:BD[10.89103] → [10.89103:90125]

B:BD[10.90125] → [11.20953:21138]

∅:D[11.21138] → [10.90125:91019]

B:BD[10.90125] → [10.90125:91019]

  return false, x,y, pos, screen_line_starting_pos
end
function Text.draw_wrapping_lineB(State, line_index, x,y, startpos)
  local line = State.lines[line_index]
  local line_cache = State.line_cache[line_index]
  local screen_line_starting_pos = startpos
  Text.compute_fragmentsB(State, line_index, x)
  local pos = 1
  for _, f in ipairs(line_cache.fragmentsB) do
    local frag, frag_text = f.data, f.text
    local frag_len = utf8.len(frag)
--?     print('text.draw:', frag, 'at', line_index,pos, 'after', x,y)
    if pos < startpos then
      -- render nothing
--?       print('skipping', frag)
    else
      -- render fragment
      local frag_width = App.width(frag_text)
      if x + frag_width > State.right then
        assert(x > State.left)  -- no overfull lines
        y = y + State.line_height
        if y + State.line_height > App.screen.height then
          return --[[screen filled]] true, x,y, pos, screen_line_starting_pos
        end
        screen_line_starting_pos = pos
        x = State.left
      end
      if State.selection1.line then
        local lo, hi = Text.clip_selection(State, line_index, pos, pos+frag_len)
        Text.draw_highlight(State, line, x,y, pos, lo,hi)
      end
      App.screen.draw(frag_text, x,y)
      -- render cursor if necessary
      if State.cursor1.posB and line_index == State.cursor1.line then
        if pos <= State.cursor1.posB and pos + frag_len > State.cursor1.posB then
          if State.search_term then
            if State.lines[State.cursor1.line].dataB:sub(State.cursor1.posB, State.cursor1.posB+utf8.len(State.search_term)-1) == State.search_term then
              local lo_px = Text.draw_highlight(State, line, x,y, pos, State.cursor1.posB, State.cursor1.posB+utf8.len(State.search_term))
              App.color(Fold_color)
              love.graphics.print(State.search_term, x+lo_px,y)
            end
          elseif Focus == 'edit' then
            Text.draw_cursor(State, x+Text.x(frag, State.cursor1.posB-pos+1), y)
            App.color(Fold_color)
          end
        end
      end
      x = x + frag_width

[10.89103]

[10.91019]

  if Focus == 'edit' and not hide_cursor and State.search_term == nil then
    if line_index == State.cursor1.line and State.cursor1.pos == pos then
      Text.draw_cursor(State, x, y)

Deletion in source_text.lua at line 81 [10.83723]
B:BD[10.91027] → [10.91027:91052]
```
    pos = pos + frag_len
```
Replacement in source_text.lua at line 82 [10.83723]
B:BD[10.91058] → [10.91058:91109]
```
  return false, x,y, pos, screen_line_starting_pos
```
[10.91058]
[10.91109]
```
  return y, screen_line_starting_pos
```

Deletion in source_text.lua at line 167 [10.83723]

B:BD[10.94278] → [10.94278:97104]

function Text.populate_screen_line_starting_posB(State, line_index, x)
  local line = State.lines[line_index]
  local line_cache = State.line_cache[line_index]
  if line_cache.screen_line_starting_posB then
    return
  end
  -- duplicate some logic from Text.draw
  Text.compute_fragmentsB(State, line_index, x)
  line_cache.screen_line_starting_posB = {1}
  local pos = 1
  for _, f in ipairs(line_cache.fragmentsB) do
    local frag, frag_text = f.data, f.text
    -- render fragment
    local frag_width = App.width(frag_text)
    if x + frag_width > State.right then
      x = State.left
      table.insert(line_cache.screen_line_starting_posB, pos)
    end
    x = x + frag_width
    local frag_len = utf8.len(frag)
    pos = pos + frag_len
  end
end
function Text.compute_fragmentsB(State, line_index, x)
--?   print('compute_fragmentsB', line_index, 'between', x, State.right)
  local line = State.lines[line_index]
  local line_cache = State.line_cache[line_index]
  if line_cache.fragmentsB then
    return
  end
  line_cache.fragmentsB = {}
  -- try to wrap at word boundaries
  for frag in line.dataB:gmatch('%S*%s*') do
    local frag_text = App.newText(love.graphics.getFont(), frag)
    local frag_width = App.width(frag_text)
--?     print('x: '..tostring(x)..'; '..tostring(State.right-x)..'px to go')
    while x + frag_width > State.right do
--?       print(('checking whether to split fragment ^%s$ of width %d when rendering from %d'):format(frag, frag_width, x))
      if (x-State.left) < 0.8 * (State.right-State.left) then
--?         print('splitting')
        -- long word; chop it at some letter
        -- We're not going to reimplement TeX here.
        local bpos = Text.nearest_pos_less_than(frag, State.right - x)
--?         print('bpos', bpos)
        if bpos == 0 then break end  -- avoid infinite loop when window is too narrow
        local boffset = Text.offset(frag, bpos+1)  -- byte _after_ bpos
--?         print('space for '..tostring(bpos)..' graphemes, '..tostring(boffset-1)..' bytes')
        local frag1 = string.sub(frag, 1, boffset-1)
        local frag1_text = App.newText(love.graphics.getFont(), frag1)
        local frag1_width = App.width(frag1_text)
--?         print('extracting ^'..frag1..'$ of width '..tostring(frag1_width)..'px')
        assert(x + frag1_width <= State.right)
        table.insert(line_cache.fragmentsB, {data=frag1, text=frag1_text})
        frag = string.sub(frag, boffset)
        frag_text = App.newText(love.graphics.getFont(), frag)
        frag_width = App.width(frag_text)
      end
      x = State.left  -- new line
    end
    if #frag > 0 then
--?       print('inserting ^'..frag..'$ of width '..tostring(frag_width)..'px')
      table.insert(line_cache.fragmentsB, {data=frag, text=frag_text})
    end
    x = x + frag_width
  end
end

Replacement in source_text.lua at line 181 [10.83723]

B:BD[10.97835] → [10.97835:98660]

  if State.cursor1.pos then
    local byte_offset = Text.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
    State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_offset-1)..t..string.sub(State.lines[State.cursor1.line].data, byte_offset)
    Text.clear_screen_line_cache(State, State.cursor1.line)
    State.cursor1.pos = State.cursor1.pos+1
  else
    assert(State.cursor1.posB)
    local byte_offset = Text.offset(State.lines[State.cursor1.line].dataB, State.cursor1.posB)
    State.lines[State.cursor1.line].dataB = string.sub(State.lines[State.cursor1.line].dataB, 1, byte_offset-1)..t..string.sub(State.lines[State.cursor1.line].dataB, byte_offset)
    Text.clear_screen_line_cache(State, State.cursor1.line)
    State.cursor1.posB = State.cursor1.posB+1
  end

[10.97835]

[10.98660]

  local byte_offset = Text.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
  State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_offset-1)..t..string.sub(State.lines[State.cursor1.line].data, byte_offset)
  Text.clear_screen_line_cache(State, State.cursor1.line)
  State.cursor1.pos = State.cursor1.pos+1

Replacement in source_text.lua at line 219 [10.83723]
B:BD[10.100094] → [10.100094:100150]
```
    if State.cursor1.pos and State.cursor1.pos > 1 then
```
[10.100094]
[10.100150]
```
    if State.cursor1.pos > 1 then
```

Deletion in source_text.lua at line 230 [10.83723]

B:BD[10.100802] → [10.100802:101643]

      end
    elseif State.cursor1.posB then
      if State.cursor1.posB > 1 then
        before = snapshot(State, State.cursor1.line)
        local byte_start = utf8.offset(State.lines[State.cursor1.line].dataB, State.cursor1.posB-1)
        local byte_end = utf8.offset(State.lines[State.cursor1.line].dataB, State.cursor1.posB)
        if byte_start then
          if byte_end then
            State.lines[State.cursor1.line].dataB = string.sub(State.lines[State.cursor1.line].dataB, 1, byte_start-1)..string.sub(State.lines[State.cursor1.line].dataB, byte_end)
          else
            State.lines[State.cursor1.line].dataB = string.sub(State.lines[State.cursor1.line].dataB, 1, byte_start-1)
          end
          State.cursor1.posB = State.cursor1.posB-1
        end
      else
        -- refuse to delete past beginning of side B

Replacement in source_text.lua at line 266 [10.83723]

B:BD[10.103074] → [10.103074:103176]

    if State.cursor1.posB or State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line].data) then

[10.103074]

[10.103176]

    if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line].data) then

Replacement in source_text.lua at line 271 [10.83723]

B:BD[10.103317] → [10.103317:103419]

    if State.cursor1.pos and State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line].data) then

[10.103317]

[10.103419]

    if State.cursor1.pos <= utf8.len(State.lines[State.cursor1.line].data) then

Deletion in source_text.lua at line 282 [10.83723]

B:BD[10.104024] → [10.104024:104845]

    elseif State.cursor1.posB then
      if State.cursor1.posB <= utf8.len(State.lines[State.cursor1.line].dataB) then
        local byte_start = utf8.offset(State.lines[State.cursor1.line].dataB, State.cursor1.posB)
        local byte_end = utf8.offset(State.lines[State.cursor1.line].dataB, State.cursor1.posB+1)
        if byte_start then
          if byte_end then
            State.lines[State.cursor1.line].dataB = string.sub(State.lines[State.cursor1.line].dataB, 1, byte_start-1)..string.sub(State.lines[State.cursor1.line].dataB, byte_end)
          else
            State.lines[State.cursor1.line].dataB = string.sub(State.lines[State.cursor1.line].dataB, 1, byte_start-1)
          end
          -- no change to State.cursor1.pos
        end
      else
        -- refuse to delete past end of side B
      end

Deletion in source_text.lua at line 286 [10.83723]

B:BD[12.6171] → [12.6171:6298]

        -- delete side B on first line
        State.lines[State.cursor1.line].dataB = State.lines[State.cursor1.line+1].dataB

Replacement in source_text.lua at line 302 [10.83723]

B:BD[11.21621] → [11.21621:21720]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos, posB=State.cursor1.posB}

[11.21621]

[11.21720]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}

Replacement in source_text.lua at line 307 [10.83723]

B:BD[11.21770] → [11.21770:21869]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos, posB=State.cursor1.posB}

[11.21770]

[11.21869]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}

Replacement in source_text.lua at line 319 [10.83723]

B:BD[11.21973] → [11.21973:22072]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos, posB=State.cursor1.posB}

[11.21973]

[11.22072]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}

Replacement in source_text.lua at line 324 [10.83723]

B:BD[11.22122] → [11.22122:22221]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos, posB=State.cursor1.posB}

[11.22122]

[11.22221]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}

Replacement in source_text.lua at line 335 [10.83723]

B:BD[11.22325] → [11.22325:22424]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos, posB=State.cursor1.posB}

[11.22325]

[11.22424]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}

Replacement in source_text.lua at line 340 [10.83723]

B:BD[11.22474] → [11.22474:22573]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos, posB=State.cursor1.posB}

[11.22474]

[11.22573]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}

Replacement in source_text.lua at line 351 [10.83723]

B:BD[11.22677] → [11.22677:22776]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos, posB=State.cursor1.posB}

[11.22677]

[11.22776]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}

Replacement in source_text.lua at line 356 [10.83723]

B:BD[11.22826] → [11.22826:22925]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos, posB=State.cursor1.posB}

[11.22826]

[11.22925]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}

Replacement in source_text.lua at line 367 [10.83723]

B:BD[11.23029] → [11.23029:23128]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos, posB=State.cursor1.posB}

[11.23029]

[11.23128]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}

Replacement in source_text.lua at line 372 [10.83723]

B:BD[11.23178] → [11.23178:23277]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos, posB=State.cursor1.posB}

[11.23178]

[11.23277]

      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}

Replacement in source_text.lua at line 379 [10.83723]

B:BD[10.106716] → [10.106716:106902]

B:BD[10.106902] → [12.6309:6489]

∅:D[12.6489] → [10.107069:107466]

B:BD[10.107069] → [10.107069:107466]

  if State.cursor1.pos then
    -- when inserting a newline, move any B side to the new line
    local byte_offset = Text.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
    table.insert(State.lines, State.cursor1.line+1, {mode='text', data=string.sub(State.lines[State.cursor1.line].data, byte_offset), dataB=State.lines[State.cursor1.line].dataB})
    table.insert(State.line_cache, State.cursor1.line+1, {})
    State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_offset-1)
    State.lines[State.cursor1.line].dataB = nil
    Text.clear_screen_line_cache(State, State.cursor1.line)
    State.cursor1 = {line=State.cursor1.line+1, pos=1}
  else
    -- disable enter when cursor is on the B side
  end

[10.106716]

[10.107466]

  local byte_offset = Text.offset(State.lines[State.cursor1.line].data, State.cursor1.pos)
  table.insert(State.lines, State.cursor1.line+1, {mode='text', data=string.sub(State.lines[State.cursor1.line].data, byte_offset)})
  table.insert(State.line_cache, State.cursor1.line+1, {})
  State.lines[State.cursor1.line].data = string.sub(State.lines[State.cursor1.line].data, 1, byte_offset-1)
  Text.clear_screen_line_cache(State, State.cursor1.line)
  State.cursor1 = {line=State.cursor1.line+1, pos=1}

Replacement in source_text.lua at line 395 [10.83723]

B:BD[10.107782] → [10.107782:107889]

    if State.screen_top1.line == 1 and State.screen_top1.pos and State.screen_top1.pos == 1 then break end

[10.107782]

[12.6490]

    if State.screen_top1.line == 1 and State.screen_top1.pos == 1 then break end

Replacement in source_text.lua at line 404 [10.83723]

B:BD[10.108019] → [10.108019:108123]

  State.cursor1 = {line=State.screen_top1.line, pos=State.screen_top1.pos, posB=State.screen_top1.posB}

[10.108019]

[10.108123]

  State.cursor1 = {line=State.screen_top1.line, pos=State.screen_top1.pos}

Insertion in source_text.lua at line 412 [10.83723]

[10.108390]

  -- If a line/paragraph gets to a page boundary, I often want to scroll
  -- before I get to the bottom.
  -- However, only do this if it makes forward progress.

Insertion in source_text.lua at line 416 [10.83723]

[10.108443]

  if bot2.screen_line > 1 then
    bot2.screen_line = math.max(bot2.screen_line-10, 1)
  end

Replacement in source_text.lua at line 423 [10.83723]

B:BD[10.108572] → [12.6770:6889]

    State.screen_top1 = {line=State.screen_bottom1.line, pos=State.screen_bottom1.pos, posB=State.screen_bottom1.posB}

[10.108572]

[10.108659]

    State.screen_top1 = {line=State.screen_bottom1.line, pos=State.screen_bottom1.pos}

Replacement in source_text.lua at line 426 [10.83723]

B:BD[10.108742] → [10.108742:108846]

  State.cursor1 = {line=State.screen_top1.line, pos=State.screen_top1.pos, posB=State.screen_top1.posB}

[10.108742]

[10.108846]

  State.cursor1 = {line=State.screen_top1.line, pos=State.screen_top1.pos}

Deletion in source_text.lua at line 435 [10.83723]
∅:D[12.6947] → [10.109127:109238]
B:BD[10.109127] → [10.109127:109238]
```
  if State.cursor1.pos then
    Text.upA(State)
  else
    Text.upB(State)
  end
end
function Text.upA(State)
```

Deletion in source_text.lua at line 474 [10.83723]

B:BD[10.111326] → [10.111326:111628]

B:BD[10.111628] → [12.8020:8200]

B:BD[12.8200] → [5.4513:4570]

∅:D[5.4570] → [12.8262:8919]

B:BD[12.8262] → [12.8262:8919]

∅:D[12.8919] → [10.112363:114810]

B:BD[10.112363] → [10.112363:114810]

function Text.upB(State)
  local line_cache = State.line_cache[State.cursor1.line]
  local screen_line_starting_posB, screen_line_indexB = Text.pos_at_start_of_screen_lineB(State, State.cursor1)
  assert(screen_line_indexB >= 1)
  if screen_line_indexB == 1 then
    -- move to A side of previous line
    local new_cursor_line = State.cursor1.line
    while new_cursor_line > 1 do
      new_cursor_line = new_cursor_line-1
      if State.lines[new_cursor_line].mode == 'text' then
        State.cursor1 = {line=new_cursor_line, posB=nil}
        Text.populate_screen_line_starting_pos(State, State.cursor1.line)
        local prev_line_cache = State.line_cache[State.cursor1.line]
        local prev_screen_line_starting_pos = prev_line_cache.screen_line_starting_pos[#prev_line_cache.screen_line_starting_pos]
        local prev_screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line].data, prev_screen_line_starting_pos)
        local s = string.sub(State.lines[State.cursor1.line].data, prev_screen_line_starting_byte_offset)
        State.cursor1.pos = prev_screen_line_starting_pos + Text.nearest_cursor_pos(s, State.cursor_x, State.left) - 1
        break
      end
    end
  elseif screen_line_indexB == 2 then
    -- all-B screen-line to potentially A+B screen-line
    local xA = Margin_left + Text.screen_line_width(State, State.cursor1.line, #line_cache.screen_line_starting_pos) + AB_padding
    if State.cursor_x < xA then
      State.cursor1.posB = nil
      Text.populate_screen_line_starting_pos(State, State.cursor1.line)
      local new_screen_line_starting_pos = line_cache.screen_line_starting_pos[#line_cache.screen_line_starting_pos]
      local new_screen_line_starting_byte_offset = Text.offset(State.lines[State.cursor1.line].data, new_screen_line_starting_pos)
      local s = string.sub(State.lines[State.cursor1.line].data, new_screen_line_starting_byte_offset)
      State.cursor1.pos = new_screen_line_starting_pos + Text.nearest_cursor_pos(s, State.cursor_x, State.left) - 1
    else
      Text.populate_screen_line_starting_posB(State, State.cursor1.line)
      local new_screen_line_starting_posB = line_cache.screen_line_starting_posB[screen_line_indexB-1]
      local new_screen_line_starting_byte_offsetB = Text.offset(State.lines[State.cursor1.line].dataB, new_screen_line_starting_posB)
      local s = string.sub(State.lines[State.cursor1.line].dataB, new_screen_line_starting_byte_offsetB)
      State.cursor1.posB = new_screen_line_starting_posB + Text.nearest_cursor_pos(s, State.cursor_x-xA, State.left) - 1
    end
  else
    assert(screen_line_indexB > 2)
    -- all-B screen-line to all-B screen-line
    Text.populate_screen_line_starting_posB(State, State.cursor1.line)
    local new_screen_line_starting_posB = line_cache.screen_line_starting_posB[screen_line_indexB-1]
    local new_screen_line_starting_byte_offsetB = Text.offset(State.lines[State.cursor1.line].dataB, new_screen_line_starting_posB)
    local s = string.sub(State.lines[State.cursor1.line].dataB, new_screen_line_starting_byte_offsetB)
    State.cursor1.posB = new_screen_line_starting_posB + Text.nearest_cursor_pos(s, State.cursor_x, State.left) - 1
  end
  if Text.lt1(State.cursor1, State.screen_top1) then
    local top2 = Text.to2(State, State.screen_top1)
    top2 = Text.previous_screen_line(State, top2)
    State.screen_top1 = Text.to1(State, top2)
  end
end
-- cursor on final screen line (A or B side) => goes to next screen line on A side
-- cursor on A side => move down one screen line (A side) in current line
-- cursor on B side => move down one screen line (B side) in current line

Replacement in source_text.lua at line 498 [10.83723]

B:BD[10.115743] → [10.115743:115833]

  elseif State.cursor1.pos then
    -- move down one screen line (A side) in current line

[10.115743]

[10.115833]

  else
    -- move down one screen line in current line

Deletion in source_text.lua at line 514 [10.83723]

B:BD[10.117041] → [10.117041:117227]

    end
  else
    -- move down one screen line (B side) in current line
    local scroll_down = false
    if Text.le1(State.screen_bottom1, State.cursor1) then
      scroll_down = true

Deletion in source_text.lua at line 515 [10.83723]

B:BD[10.117235] → [10.117235:118175]

    local cursor_line = State.lines[State.cursor1.line]
    local cursor_line_cache = State.line_cache[State.cursor1.line]
    local cursor2 = Text.to2(State, State.cursor1)
    assert(cursor2.screen_lineB < #cursor_line_cache.screen_line_starting_posB)
    local screen_line_starting_posB, screen_line_indexB = Text.pos_at_start_of_screen_lineB(State, State.cursor1)
    Text.populate_screen_line_starting_posB(State, State.cursor1.line)
    local new_screen_line_starting_posB = cursor_line_cache.screen_line_starting_posB[screen_line_indexB+1]
    local new_screen_line_starting_byte_offsetB = Text.offset(cursor_line.dataB, new_screen_line_starting_posB)
    local s = string.sub(cursor_line.dataB, new_screen_line_starting_byte_offsetB)
    State.cursor1.posB = new_screen_line_starting_posB + Text.nearest_cursor_pos(s, State.cursor_x, State.left) - 1
    if scroll_down then
      Text.snap_cursor_to_bottom_of_screen(State)
    end

Replacement in source_text.lua at line 520 [10.83723]

B:BD[10.118378] → [10.118378:118472]

  if State.cursor1.pos then
    State.cursor1.pos = 1
  else
    State.cursor1.posB = 1
  end

[10.118378]

[10.118472]

  State.cursor1.pos = 1

Replacement in source_text.lua at line 522 [10.83723]

B:BD[10.118525] → [12.9405:9512]

    State.screen_top1 = {line=State.cursor1.line, pos=State.cursor1.pos, posB=State.cursor1.posB}  -- copy

[10.118525]

[10.118591]

    State.screen_top1 = {line=State.cursor1.line, pos=State.cursor1.pos}  -- copy

Replacement in source_text.lua at line 527 [10.83723]

B:BD[10.118635] → [10.118635:118828]

  if State.cursor1.pos then
    State.cursor1.pos = utf8.len(State.lines[State.cursor1.line].data) + 1
  else
    State.cursor1.posB = utf8.len(State.lines[State.cursor1.line].dataB) + 1
  end

[10.118635]

[10.118828]

  State.cursor1.pos = utf8.len(State.lines[State.cursor1.line].data) + 1

Replacement in source_text.lua at line 534 [10.83723]

B:BD[10.118961] → [10.118961:119794]

  -- we can cross the fold, so check side A/B one level down
  Text.skip_whitespace_left(State)
  Text.left(State)
  Text.skip_non_whitespace_left(State)
end
function Text.word_right(State)
  -- we can cross the fold, so check side A/B one level down
  Text.skip_whitespace_right(State)
  Text.right(State)
  Text.skip_non_whitespace_right(State)
  if Text.cursor_out_of_screen(State) then
    Text.snap_cursor_to_bottom_of_screen(State)
  end
end
function Text.skip_whitespace_left(State)
  if State.cursor1.pos then
    Text.skip_whitespace_leftA(State)
  else
    Text.skip_whitespace_leftB(State)
  end
end
function Text.skip_non_whitespace_left(State)
  if State.cursor1.pos then
    Text.skip_non_whitespace_leftA(State)
  else
    Text.skip_non_whitespace_leftB(State)
  end
end
function Text.skip_whitespace_leftA(State)

[10.118961]

[10.119794]

  -- skip some whitespace

Replacement in source_text.lua at line 544 [10.83723]
B:BD[10.120000] → [10.120000:120048]
```
end
function Text.skip_whitespace_leftB(State)
```
[10.120000]
[10.120048]
```
  -- skip some non-whitespace
```

Deletion in source_text.lua at line 546 [10.83723]

B:BD[10.120064] → [10.120064:120230]

    if State.cursor1.posB == 1 then
      break
    end
    if Text.match(State.lines[State.cursor1.line].dataB, State.cursor1.posB-1, '%S') then
      break
    end

Deletion in source_text.lua at line 547 [10.83723]
B:BD[10.120251] → [10.120251:120325]
```
  end
end
function Text.skip_non_whitespace_leftA(State)
  while true do
```

Deletion in source_text.lua at line 552 [10.83723]

B:BD[10.120502] → [10.120502:120653]

      break
    end
    Text.left(State)
  end
end
function Text.skip_non_whitespace_leftB(State)
  while true do
    if State.cursor1.posB == 1 then

Deletion in source_text.lua at line 554 [10.83723]

B:BD[10.120673] → [10.120673:121185]

    assert(State.cursor1.posB > 1)
    if Text.match(State.lines[State.cursor1.line].dataB, State.cursor1.posB-1, '%s') then
      break
    end
    Text.left(State)
  end
end
function Text.skip_whitespace_right(State)
  if State.cursor1.pos then
    Text.skip_whitespace_rightA(State)
  else
    Text.skip_whitespace_rightB(State)
  end
end
function Text.skip_non_whitespace_right(State)
  if State.cursor1.pos then
    Text.skip_non_whitespace_rightA(State)
  else
    Text.skip_non_whitespace_rightB(State)

Replacement in source_text.lua at line 557 [10.83723]
B:BD[10.121196] → [10.121196:121240]
```
function Text.skip_whitespace_rightA(State)
```
[10.121196]
[10.121240]
```
function Text.word_right(State)
  -- skip some whitespace
```
Deletion in source_text.lua at line 568 [10.83723]
B:BD[10.121504] → [10.121504:121553]
```
end
function Text.skip_whitespace_rightB(State)
```

Deletion in source_text.lua at line 569 [10.83723]

B:BD[10.121569] → [10.121569:121778]

    if State.cursor1.posB > utf8.len(State.lines[State.cursor1.line].dataB) then
      break
    end
    if Text.match(State.lines[State.cursor1.line].dataB, State.cursor1.posB, '%S') then
      break
    end

Deletion in source_text.lua at line 570 [10.83723]
B:BD[10.121815] → [10.121815:121890]
```
  end
end
function Text.skip_non_whitespace_rightA(State)
  while true do
```
Deletion in source_text.lua at line 576 [10.83723]
B:BD[10.122095] → [10.122095:122132]
```
    Text.right_without_scroll(State)
```

Replacement in source_text.lua at line 577 [10.83723]

B:BD[10.122138] → [10.122138:122453]

end
function Text.skip_non_whitespace_rightB(State)
  while true do
    if State.cursor1.posB > utf8.len(State.lines[State.cursor1.line].dataB) then
      break
    end
    if Text.match(State.lines[State.cursor1.line].dataB, State.cursor1.posB, '%s') then
      break
    end
    Text.right_without_scroll(State)

[10.122138]

[10.122453]

  if Text.cursor_out_of_screen(State) then
    Text.snap_cursor_to_bottom_of_screen(State)

Replacement in source_text.lua at line 592 [10.83723]

B:BD[10.122747] → [10.122747:122864]

  if State.cursor1.pos then
    Text.leftA(State)
  else
    Text.leftB(State)
  end
end
function Text.leftA(State)

[10.122747]

[10.122864]

  assert(State.lines[State.cursor1.line].mode == 'text')

Deletion in source_text.lua at line 615 [10.83723]

B:BD[10.123324] → [10.123324:123792]

function Text.leftB(State)
  if State.cursor1.posB > 1 then
    State.cursor1.posB = State.cursor1.posB-1
  else
    -- overflow back into A side
    State.cursor1.posB = nil
    State.cursor1.pos = utf8.len(State.lines[State.cursor1.line].data) + 1
  end
  if Text.lt1(State.cursor1, State.screen_top1) then
    local top2 = Text.to2(State, State.screen_top1)
    top2 = Text.previous_screen_line(State, top2)
    State.screen_top1 = Text.to1(State, top2)
  end
end

Deletion in source_text.lua at line 624 [10.83723]

∅:D[12.9925] → [10.123998:124163]

B:BD[10.123998] → [10.123998:124163]

  if State.cursor1.pos then
    Text.right_without_scrollA(State)
  else
    Text.right_without_scrollB(State)
  end
end
function Text.right_without_scrollA(State)

Deletion in source_text.lua at line 638 [10.83723]

B:BD[10.124402] → [10.124402:124571]

B:BD[10.124571] → [12.10214:10221]

∅:D[12.10221] → [10.124622:124655]

B:BD[10.124622] → [10.124622:124655]

B:BD[10.124655] → [12.10222:10502]

∅:D[12.10502] → [10.124710:124721]

B:BD[10.124710] → [10.124710:124721]

function Text.right_without_scrollB(State)
  if State.cursor1.posB <= utf8.len(State.lines[State.cursor1.line].dataB) then
    State.cursor1.posB = State.cursor1.posB+1
  else
    -- overflow back into A side
    local new_cursor_line = State.cursor1.line
    while new_cursor_line <= #State.lines-1 do
      new_cursor_line = new_cursor_line+1
      if State.lines[new_cursor_line].mode == 'text' then
        State.cursor1 = {line=new_cursor_line, pos=1}
        break
      end
    end
  end
end

Deletion in source_text.lua at line 650 [10.83723]

B:BD[10.125077] → [10.125077:125621]

function Text.pos_at_start_of_screen_lineB(State, loc1)
  Text.populate_screen_line_starting_pos(State, loc1.line)
  local line_cache = State.line_cache[loc1.line]
  local x = Margin_left + Text.screen_line_width(State, loc1.line, #line_cache.screen_line_starting_pos) + AB_padding
  Text.populate_screen_line_starting_posB(State, loc1.line, x)
  for i=#line_cache.screen_line_starting_posB,1,-1 do
    local sposB = line_cache.screen_line_starting_posB[i]
    if sposB <= loc1.posB then
      return sposB,i
    end
  end
  assert(false)
end

Deletion in source_text.lua at line 652 [10.83723]
B:BD[10.125738] → [10.125738:125785]
```
  local line = State.lines[State.cursor1.line]
```

Replacement in source_text.lua at line 654 [10.83723]

B:BD[10.125930] → [10.125930:126622]

  if (not State.expanded and not line.expanded) or
      line.dataB == nil then
    return screen_lines[#screen_lines] <= State.cursor1.pos
  end
  if State.cursor1.pos then
    -- ignore B side
    return screen_lines[#screen_lines] <= State.cursor1.pos
  end
  assert(State.cursor1.posB)
  local line_cache = State.line_cache[State.cursor1.line]
  local x = Margin_left + Text.screen_line_width(State, State.cursor1.line, #line_cache.screen_line_starting_pos) + AB_padding
  Text.populate_screen_line_starting_posB(State, State.cursor1.line, x)
  local screen_lines = State.line_cache[State.cursor1.line].screen_line_starting_posB
  return screen_lines[#screen_lines] <= State.cursor1.posB

[10.125930]

[10.126622]

  return screen_lines[#screen_lines] <= State.cursor1.pos

Replacement in source_text.lua at line 682 [10.83723]

B:BD[10.126954] → [10.126954:127033]

--?   print('to2:', State.cursor1.line, State.cursor1.pos, State.cursor1.posB)

[10.126954]

[10.127033]

--?   print('to2:', State.cursor1.line, State.cursor1.pos)

Replacement in source_text.lua at line 684 [10.83723]

B:BD[10.127079] → [10.127079:127185]

--?   print('to2: =>', top2.line, top2.screen_line, top2.screen_pos, top2.screen_lineB, top2.screen_posB)

[10.127079]

[10.127185]

--?   print('to2: =>', top2.line, top2.screen_line, top2.screen_pos)

Replacement in source_text.lua at line 686 [10.83723]

B:BD[10.127220] → [10.127220:127567]

  if top2.screen_pos then
    top2.screen_pos = 1
  else
    assert(top2.screen_posB)
    top2.screen_posB = 1
  end
--?   print('snap', State.screen_top1.line, State.screen_top1.pos, State.screen_top1.posB, State.cursor1.line, State.cursor1.pos, State.cursor1.posB, State.screen_bottom1.line, State.screen_bottom1.pos, State.screen_bottom1.posB)

[10.127220]

[10.127567]

  top2.screen_pos = 1  -- start of screen line
--?   print('snap', State.screen_top1.line, State.screen_top1.pos, State.screen_top1.posB, State.cursor1.line, State.cursor1.pos, State.screen_bottom1.line, State.screen_bottom1.pos)

Replacement in source_text.lua at line 692 [10.83723]

B:BD[10.127795] → [10.127795:127933]

--?     print(y, 'top2:', State.lines[top2.line].data, top2.line, top2.screen_line, top2.screen_pos, top2.screen_lineB, top2.screen_posB)

[10.127795]

[10.127933]

--?     print(y, 'top2:', top2.line, top2.screen_line, top2.screen_pos)

Replacement in source_text.lua at line 717 [10.83723]

B:BD[10.128343] → [10.128343:128576]

--?   print('snap =>', State.screen_top1.line, State.screen_top1.pos, State.screen_top1.posB, State.cursor1.line, State.cursor1.pos, State.cursor1.posB, State.screen_bottom1.line, State.screen_bottom1.pos, State.screen_bottom1.posB)

[10.128343]

[10.128576]

--?   print('snap =>', State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos, State.screen_bottom1.line, State.screen_bottom1.pos)

Replacement in source_text.lua at line 726 [10.83723]

B:BD[10.128948] → [10.128948:130218]

  local num_screen_lines = 0
  if line_cache.startpos then
    Text.populate_screen_line_starting_pos(State, line_index)
    num_screen_lines = num_screen_lines + #line_cache.screen_line_starting_pos - Text.screen_line_index(line_cache.screen_line_starting_pos, line_cache.startpos) + 1
  end
--?   print('#screenlines after A', num_screen_lines)
  if line.dataB and (State.expanded or line.expanded) then
    local x = Margin_left + Text.screen_line_width(State, line_index, #line_cache.screen_line_starting_pos) + AB_padding
    Text.populate_screen_line_starting_posB(State, line_index, x)
--?     print('B:', x, #line_cache.screen_line_starting_posB)
    if line_cache.startposB then
      num_screen_lines = num_screen_lines + #line_cache.screen_line_starting_posB - Text.screen_line_indexB(line_cache.screen_line_starting_posB, line_cache.startposB)  -- no +1; first screen line of B side overlaps with A side
    else
      num_screen_lines = num_screen_lines + #line_cache.screen_line_starting_posB - Text.screen_line_indexB(line_cache.screen_line_starting_posB, 1)  -- no +1; first screen line of B side overlaps with A side
    end
  end
--?   print('#screenlines after B', num_screen_lines)
  return y < line_cache.starty + State.line_height*num_screen_lines

[10.128948]

[10.130218]

  Text.populate_screen_line_starting_pos(State, line_index)
  return y < line_cache.starty + State.line_height*(#line_cache.screen_line_starting_pos - Text.screen_line_index(line_cache.screen_line_starting_pos, line_cache.startpos) + 1)

Deletion in source_text.lua at line 731 [10.83723]

B:BD[10.130274] → [10.130274:130740]

-- returns: pos, posB
-- scenarios:
--   line without B side
--   line with B side collapsed
--   line with B side expanded
--   line starting rendering in A side (startpos ~= nil)
--   line starting rendering in B side (startposB ~= nil)
--   my on final screen line of A side
--     mx to right of A side with no B side
--     mx to right of A side but left of B side
--     mx to right of B side
-- preconditions:
--  startpos xor startposB
--  expanded -> dataB

Replacement in source_text.lua at line 737 [10.83723]

B:BD[10.130990] → [10.130990:134318]

--?   print('click', line_index, my, 'with line starting at', y, #line_cache.screen_line_starting_pos)  -- , #line_cache.screen_line_starting_posB)
  if line_cache.startpos then
    local start_screen_line_index = Text.screen_line_index(line_cache.screen_line_starting_pos, line_cache.startpos)
    for screen_line_index = start_screen_line_index,#line_cache.screen_line_starting_pos do
      local screen_line_starting_pos = line_cache.screen_line_starting_pos[screen_line_index]
      local screen_line_starting_byte_offset = Text.offset(line.data, screen_line_starting_pos)
--?       print('iter', y, screen_line_index, screen_line_starting_pos, string.sub(line.data, screen_line_starting_byte_offset))
      local nexty = y + State.line_height
      if my < nexty then
        -- On all wrapped screen lines but the final one, clicks past end of
        -- line position cursor on final character of screen line.
        -- (The final screen line positions past end of screen line as always.)
        if screen_line_index < #line_cache.screen_line_starting_pos and mx > State.left + Text.screen_line_width(State, line_index, screen_line_index) then
--?           print('past end of non-final line; return')
          return line_cache.screen_line_starting_pos[screen_line_index+1]-1
        end
        local s = string.sub(line.data, screen_line_starting_byte_offset)
--?         print('return', mx, Text.nearest_cursor_pos(s, mx, State.left), '=>', screen_line_starting_pos + Text.nearest_cursor_pos(s, mx, State.left) - 1)
        local screen_line_posA = Text.nearest_cursor_pos(s, mx, State.left)
        if line.dataB == nil then
          -- no B side
          return screen_line_starting_pos + screen_line_posA - 1
        end
        if not State.expanded and not line.expanded then
          -- B side is not expanded
          return screen_line_starting_pos + screen_line_posA - 1
        end
        local lenA = utf8.len(s)
        if screen_line_posA < lenA then
          -- mx is within A side
          return screen_line_starting_pos + screen_line_posA - 1
        end
        local max_xA = State.left+Text.x(s, lenA+1)
        if mx < max_xA + AB_padding then
          -- mx is in the space between A and B side
          return screen_line_starting_pos + screen_line_posA - 1
        end
        mx = mx - max_xA - AB_padding
        local screen_line_posB = Text.nearest_cursor_pos(line.dataB, mx, --[[no left margin]] 0)
        return nil, screen_line_posB
      end
      y = nexty
    end
  end
  -- look in screen lines composed entirely of the B side
  assert(State.expanded or line.expanded)
  local start_screen_line_indexB
  if line_cache.startposB then
    start_screen_line_indexB = Text.screen_line_indexB(line_cache.screen_line_starting_posB, line_cache.startposB)
  else
    start_screen_line_indexB = 2  -- skip the first line of side B, which we checked above
  end
  for screen_line_indexB = start_screen_line_indexB,#line_cache.screen_line_starting_posB do
    local screen_line_starting_posB = line_cache.screen_line_starting_posB[screen_line_indexB]
    local screen_line_starting_byte_offsetB = Text.offset(line.dataB, screen_line_starting_posB)
--?     print('iter2', y, screen_line_indexB, screen_line_starting_posB, string.sub(line.dataB, screen_line_starting_byte_offsetB))

[10.130990]

[10.134318]

  local start_screen_line_index = Text.screen_line_index(line_cache.screen_line_starting_pos, line_cache.startpos)
  for screen_line_index = start_screen_line_index,#line_cache.screen_line_starting_pos do
    local screen_line_starting_pos = line_cache.screen_line_starting_pos[screen_line_index]
    local screen_line_starting_byte_offset = Text.offset(line.data, screen_line_starting_pos)
--?     print('iter', y, screen_line_index, screen_line_starting_pos, string.sub(line.data, screen_line_starting_byte_offset))

Replacement in source_text.lua at line 747 [10.83723]

B:BD[10.134599] → [10.134599:134859]

--?       print('aa', mx, State.left, Text.screen_line_widthB(State, line_index, screen_line_indexB))
      if screen_line_indexB < #line_cache.screen_line_starting_posB and mx > State.left + Text.screen_line_widthB(State, line_index, screen_line_indexB) then

[10.134599]

[10.134859]

      if screen_line_index < #line_cache.screen_line_starting_pos and mx > State.left + Text.screen_line_width(State, line_index, screen_line_index) then

Replacement in source_text.lua at line 749 [10.83723]

B:BD[10.134915] → [10.134915:134996]

        return nil, line_cache.screen_line_starting_posB[screen_line_indexB+1]-1

[10.134915]

[10.134996]

        return line_cache.screen_line_starting_pos[screen_line_index+1]-1

Replacement in source_text.lua at line 751 [10.83723]

B:BD[10.135006] → [10.135006:135329]

      local s = string.sub(line.dataB, screen_line_starting_byte_offsetB)
--?       print('return', mx, Text.nearest_cursor_pos(s, mx, State.left), '=>', screen_line_starting_posB + Text.nearest_cursor_pos(s, mx, State.left) - 1)
      return nil, screen_line_starting_posB + Text.nearest_cursor_pos(s, mx, State.left) - 1

[10.135006]

[10.135329]

      local s = string.sub(line.data, screen_line_starting_byte_offset)
--?       print('return', mx, Text.nearest_cursor_pos(s, mx, State.left), '=>', screen_line_starting_pos + Text.nearest_cursor_pos(s, mx, State.left) - 1)
      return screen_line_starting_pos + Text.nearest_cursor_pos(s, mx, State.left) - 1

Deletion in source_text.lua at line 777 [10.83723]

B:BD[10.136095] → [10.136095:137079]

function Text.screen_line_widthB(State, line_index, i)
  local line = State.lines[line_index]
  local line_cache = State.line_cache[line_index]
  local start_posB = line_cache.screen_line_starting_posB[i]
  local start_offsetB = Text.offset(line.dataB, start_posB)
  local screen_line
  if i < #line_cache.screen_line_starting_posB then
--?     print('non-final', i)
    local past_end_posB = line_cache.screen_line_starting_posB[i+1]
    local past_end_offsetB = Text.offset(line.dataB, past_end_posB)
--?     print('between', start_offsetB, past_end_offsetB)
    screen_line = string.sub(line.dataB, start_offsetB, past_end_offsetB-1)
  else
--?     print('final', i)
--?     print('after', start_offsetB)
    screen_line = string.sub(line.dataB, start_offsetB)
  end
  local screen_line_text = App.newText(love.graphics.getFont(), screen_line)
--?   local result = App.width(screen_line_text)
--?   print('=>', result)
--?   return result
  return App.width(screen_line_text)
end

Deletion in source_text.lua at line 785 [10.83723]

B:BD[10.137267] → [10.137267:137538]

function Text.screen_line_indexB(screen_line_starting_posB, posB)
  if posB == nil then
    return 0
  end
  assert(screen_line_starting_posB)
  for i = #screen_line_starting_posB,1,-1 do
    if screen_line_starting_posB[i] <= posB then
      return i
    end
  end
end

Deletion in source_text.lua at line 877 [10.83723]

∅:D[12.11942] → [10.139891:140028]

B:BD[10.139891] → [10.139891:140028]

  if loc1.pos then
    return Text.to2A(State, loc1)
  else
    return Text.to2B(State, loc1)
  end
end
function Text.to2A(State, loc1)

Deletion in source_text.lua at line 889 [10.83723]

B:BD[10.140437] → [10.140437:141090]

  return result
end
function Text.to2B(State, loc1)
  local result = {line=loc1.line}
  local line_cache = State.line_cache[loc1.line]
  Text.populate_screen_line_starting_pos(State, loc1.line)
  local x = Margin_left + Text.screen_line_width(State, loc1.line, #line_cache.screen_line_starting_pos) + AB_padding
  Text.populate_screen_line_starting_posB(State, loc1.line, x)
  for i=#line_cache.screen_line_starting_posB,1,-1 do
    local sposB = line_cache.screen_line_starting_posB[i]
    if sposB <= loc1.posB then
      result.screen_lineB = i
      result.screen_posB = loc1.posB - sposB + 1
      break
    end
  end
  assert(result.screen_posB)

Deletion in source_text.lua at line 893 [10.83723]

B:BD[10.141142] → [10.141142:141286]

  if loc2.screen_pos then
    return Text.to1A(State, loc2)
  else
    return Text.to1B(State, loc2)
  end
end
function Text.to1A(State, loc2)

Replacement in source_text.lua at line 900 [10.83723]

B:BD[10.141509] → [10.141509:141766]

function Text.to1B(State, loc2)
  local result = {line=loc2.line, posB=loc2.screen_posB}
  if loc2.screen_lineB > 1 then
    result.posB = State.line_cache[loc2.line].screen_line_starting_posB[loc2.screen_lineB] + loc2.screen_posB - 1
  end
  return result

[10.141509]

[10.141766]

function Text.eq1(a, b)
  return a.line == b.line and a.pos == b.pos

Replacement in source_text.lua at line 911 [10.83723]

B:BD[10.141892] → [10.141892:141943]

  -- A side < B side
  if a.pos and not b.pos then

[10.141892]

[10.141943]

  return a.pos < b.pos
end
function Text.le1(a, b)
  if a.line < b.line then

Replacement in source_text.lua at line 918 [10.83723]
B:BD[10.141965] → [10.141965:141995]
```
  if not a.pos and b.pos then
```
[10.141965]
[10.141995]
```
  if a.line > b.line then
```

Replacement in source_text.lua at line 921 [10.83723]

B:BD[10.142018] → [10.142018:142099]

  if a.pos then
    return a.pos < b.pos
  else
    return a.posB < b.posB
  end

[10.142018]

[10.142099]

  return a.pos <= b.pos

Deletion in source_text.lua at line 924 [10.83723]
B:BD[10.142104] → [10.142104:142169]
```
function Text.le1(a, b)
  return eq(a, b) or Text.lt1(a, b)
end
```

Deletion in source_text.lua at line 935 [10.83723]

B:BD[10.142409] → [10.142409:142604]

  if loc2.screen_pos then
    return Text.previous_screen_lineA(State, loc2)
  else
    return Text.previous_screen_lineB(State, loc2)
  end
end
function Text.previous_screen_lineA(State, loc2)

Insertion in source_text.lua at line 939 [10.83723]

[10.142792]

  elseif State.lines[loc2.line-1].mode == 'drawing' then
    return {line=loc2.line-1, screen_line=1, screen_pos=1}

Insertion in source_text.lua at line 942 [10.83723]
[10.142799]
[10.142799]
```
    local l = State.lines[loc2.line-1]
```

Replacement in source_text.lua at line 944 [10.83723]

B:BD[10.142862] → [10.142862:144205]

    if State.lines[loc2.line-1].dataB == nil or
        (not State.expanded and not State.lines[loc2.line-1].expanded) then
--?       print('c1', loc2.line-1, State.lines[loc2.line-1].data, '==', State.lines[loc2.line-1].dataB, State.line_cache[loc2.line-1].fragmentsB)
      return {line=loc2.line-1, screen_line=#State.line_cache[loc2.line-1].screen_line_starting_pos, screen_pos=1}
    end
    -- try to switch to B
    local prev_line_cache = State.line_cache[loc2.line-1]
    local x = Margin_left + Text.screen_line_width(State, loc2.line-1, #prev_line_cache.screen_line_starting_pos) + AB_padding
    Text.populate_screen_line_starting_posB(State, loc2.line-1, x)
    local screen_line_starting_posB = State.line_cache[loc2.line-1].screen_line_starting_posB
--?     print('c', loc2.line-1, State.lines[loc2.line-1].data, '==', State.lines[loc2.line-1].dataB, '==', #screen_line_starting_posB, 'starting from x', x)
    if #screen_line_starting_posB > 1 then
--?       print('c2')
      return {line=loc2.line-1, screen_lineB=#State.line_cache[loc2.line-1].screen_line_starting_posB, screen_posB=1}
    else
--?       print('c3')
      -- if there's only one screen line, assume it overlaps with A, so remain in A
      return {line=loc2.line-1, screen_line=#State.line_cache[loc2.line-1].screen_line_starting_pos, screen_pos=1}
    end

[10.142862]

[10.144205]

    return {line=loc2.line-1, screen_line=#State.line_cache[loc2.line-1].screen_line_starting_pos, screen_pos=1}

Deletion in source_text.lua at line 948 [10.83723]

B:BD[10.144216] → [10.144216:144658]

function Text.previous_screen_lineB(State, loc2)
  if loc2.screen_lineB > 2 then  -- first screen line of B side overlaps with A side
    return {line=loc2.line, screen_lineB=loc2.screen_lineB-1, screen_posB=1}
  else
    -- switch to A side
    -- TODO: handle case where fold lands precisely at end of a new screen-line
    return {line=loc2.line, screen_line=#State.line_cache[loc2.line].screen_line_starting_pos, screen_pos=1}
  end
end

Replacement in source_text.lua at line 977 [10.83723]

B:BD[10.145797] → [10.145797:145985]

      local pos,posB = Text.to_pos_on_line(State, State.screen_bottom1.line, State.right-5, App.screen.height-5)
      State.cursor1 = {line=State.screen_bottom1.line, pos=pos, posB=posB}

[10.145797]

[10.145985]

      State.cursor1 = {
          line=State.screen_bottom1.line,
          pos=Text.to_pos_on_line(State, State.screen_bottom1.line, State.right-5, App.screen.height-5),
      }

Deletion in source_text.lua at line 1017 [10.83723]
B:BD[10.146715] → [10.146715:146763]
```
  State.line_cache[line_index].fragmentsB = nil
```
Deletion in source_text.lua at line 1018 [10.83723]
B:BD[10.146825] → [10.146825:146888]
```
  State.line_cache[line_index].screen_line_starting_posB = nil
```
Deletion in source_edit.lua at line 13 [10.152440]
∅:D[12.18192] → [10.152673:152746]
B:BD[10.152673] → [10.152673:152746]
```
Fold_color = {r=0, g=0.6, b=0}
Fold_background_color = {r=0, g=0.7, b=0}
```

Replacement in source_edit.lua at line 29 [10.152440]

B:BD[10.152987] → [12.18407:18530]

    -- a line is either bifold text or a drawing
    -- a line of bifold text consists of an A side and an optional B side

[10.152987]

[12.18530]

    -- a line is either text or a drawing
    -- a text is a table with:

Deletion in source_edit.lua at line 33 [10.152440]
B:BD[12.18578] → [12.18578:18645]
```
    --    string dataB,
    --    expanded: whether to show B side
```

Replacement in source_edit.lua at line 49 [10.152440]

B:BD[12.19494] → [12.19494:19576]

    lines = {{mode='text', data='', dataB=nil, expanded=nil}},  -- array of lines

[12.19494]

[10.153197]

    lines = {{mode='text', data=''}},  -- array of lines

Deletion in source_edit.lua at line 64 [10.152440]
B:BD[10.154135] → [10.154135:154216]
```
    -- Positions (and screen line indexes) can be in either the A or the B side.
```

Replacement in source_edit.lua at line 70 [10.152440]

B:BD[10.154462] → [10.154462:154730]

    screen_top1 = {line=1, pos=1, posB=nil},  -- position of start of screen line at top of screen
    cursor1 = {line=1, pos=1, posB=nil},  -- position of cursor
    screen_bottom1 = {line=1, pos=1, posB=nil},  -- position of start of screen line at bottom of screen

[10.154462]

[11.30094]

    screen_top1 = {line=1, pos=1},  -- position of start of screen line at top of screen
    cursor1 = {line=1, pos=1},  -- position of cursor
    screen_bottom1 = {line=1, pos=1},  -- position of start of screen line at bottom of screen

Replacement in source_edit.lua at line 152 [10.152440]

B:BD[10.155530] → [10.155530:155670]

    print(State.screen_top1.line, State.screen_top1.pos, State.screen_top1.posB, State.cursor1.line, State.cursor1.pos, State.cursor1.posB)

[10.155530]

[10.155670]

    print(State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos)

Replacement in source_edit.lua at line 161 [10.152440]
B:BD[10.155884] → [12.19889:19944]
```
--?     print('draw:', y, line_index, line, line.mode)
```
[10.155884]
[10.155928]
```
--?     print('draw:', y, line_index, line)
```

Replacement in source_edit.lua at line 163 [10.152440]

B:BD[10.155992] → [10.155992:156056]

    State.screen_bottom1 = {line=line_index, pos=nil, posB=nil}

[10.155992]

[12.19945]

    State.screen_bottom1 = {line=line_index, pos=nil}

Replacement in source_edit.lua at line 165 [10.152440]
∅:D[12.19977] → [10.156056:156098]
B:BD[10.156056] → [10.156056:156098]
B:BD[10.156098] → [12.19978:20019]
```
--?     print('text.draw', y, line_index)
      local startpos, startposB = 1, nil
```
[12.19977]
[12.20019]
```
--?       print('text.draw', y, line_index)
      local startpos = 1
```

Replacement in source_edit.lua at line 168 [10.152440]

B:BD[12.20070] → [12.20070:20236]

        if State.screen_top1.pos then
          startpos = State.screen_top1.pos
        else
          startpos, startposB = nil, State.screen_top1.posB
        end

[12.20070]

[12.20236]

        startpos = State.screen_top1.pos

Replacement in source_edit.lua at line 186 [10.152440]

B:BD[10.156342] → [3.239:368]

      y, State.screen_bottom1.pos, State.screen_bottom1.posB = Text.draw(State, line_index, y, startpos, startposB, hide_cursor)

[10.156342]

[12.21213]

      y, State.screen_bottom1.pos = Text.draw(State, line_index, y, startpos, hide_cursor)

Replacement in source_edit.lua at line 249 [10.152440]

∅:D[11.31038] → [12.21646:21781]

B:BD[12.21646] → [12.21646:21781]

B:BD[12.21781] → [11.31039:31203]

        local pos,posB = Text.to_pos_on_line(State, line_index, x, y)
  --?       print(x,y, 'setting cursor:', line_index, pos, posB)
        State.selection1 = {line=line_index, pos=pos, posB=posB}
--?         print('selection', State.selection1.line, State.selection1.pos, State.selection1.posB)

[11.31038]

[12.21843]

        State.selection1 = {
            line=line_index,
            pos=Text.to_pos_on_line(State, line_index, x, y),
        }
--?         print('selection', State.selection1.line, State.selection1.pos)

Replacement in source_edit.lua at line 284 [10.152440]

B:BD[11.31387] → [11.31387:31612]

          local pos,posB = Text.to_pos_on_line(State, line_index, x, y)
          State.cursor1 = {line=line_index, pos=pos, posB=posB}
--?           print('cursor', State.cursor1.line, State.cursor1.pos, State.cursor1.posB)

[11.31387]

[11.31612]

          State.cursor1 = {
              line=line_index,
              pos=Text.to_pos_on_line(State, line_index, x, y),
          }
--?           print('cursor', State.cursor1.line, State.cursor1.pos)

Replacement in source_edit.lua at line 357 [10.152440]

B:BD[10.158906] → [10.158906:159057]

      if State.cursor1.pos then
        State.cursor1.pos = State.cursor1.pos+1
      else
        State.cursor1.posB = State.cursor1.posB+1
      end

[10.158906]

[10.159057]

      State.cursor1.pos = State.cursor1.pos+1

Replacement in source_edit.lua at line 366 [10.152440]

B:BD[10.159254] → [10.159254:159446]

      cursor={line=State.cursor1.line, pos=State.cursor1.pos, posB=State.cursor1.posB},
      screen_top={line=State.screen_top1.line, pos=State.screen_top1.pos, posB=State.screen_top1.posB},

[10.159254]

[10.159446]

      cursor={line=State.cursor1.line, pos=State.cursor1.pos},
      screen_top={line=State.screen_top1.line, pos=State.screen_top1.pos},

Deletion in source_edit.lua at line 370 [10.152440]

B:BD[10.159489] → [10.159489:159506]

B:BD[10.159506] → [2.11:40]

∅:D[2.40] → [10.159535:159775]

B:BD[10.159535] → [10.159535:159775]

B:BD[10.159775] → [2.41:70]

∅:D[2.70] → [10.159804:160392]

∅:D[12.23031] → [10.159804:160392]

B:BD[10.159804] → [10.159804:160392]

  -- bifold text
  elseif chord == 'M-b' then
    State.expanded = not State.expanded
    Text.redraw_all(State)
    if not State.expanded then
      for _,line in ipairs(State.lines) do
        line.expanded = nil
      end
      edit.eradicate_locations_after_the_fold(State)
    end
  elseif chord == 'M-d' then
    if State.cursor1.posB == nil then
      local before = snapshot(State, State.cursor1.line)
      if State.lines[State.cursor1.line].dataB == nil then
        State.lines[State.cursor1.line].dataB = ''
      end
      State.lines[State.cursor1.line].expanded = true
      State.cursor1.pos = nil
      State.cursor1.posB = 1
      if Text.cursor_out_of_screen(State) then
        Text.snap_cursor_to_bottom_of_screen(State, State.left, State.right)
      end
      schedule_save(State)
      record_undo_event(State, {before=before, after=snapshot(State, State.cursor1.line)})
    end

Replacement in source_edit.lua at line 417 [10.152440]

B:BD[4.233] → [4.233:331]

    State.cursor1 = {line=#State.lines, pos=utf8.len(State.lines[#State.lines].data)+1, posB=nil}

[4.233]

[10.161829]

    State.cursor1 = {line=#State.lines, pos=utf8.len(State.lines[#State.lines].data)+1}

Deletion in source_edit.lua at line 492 [10.152440]

B:BD[10.163286] → [10.163286:163849]

function edit.eradicate_locations_after_the_fold(State)
  -- eradicate side B from any locations we track
  if State.cursor1.posB then
    State.cursor1.posB = nil
    State.cursor1.pos = utf8.len(State.lines[State.cursor1.line].data)
    State.cursor1.pos = Text.pos_at_start_of_screen_line(State, State.cursor1)
  end
  if State.screen_top1.posB then
    State.screen_top1.posB = nil
    State.screen_top1.pos = utf8.len(State.lines[State.screen_top1.line].data)
    State.screen_top1.pos = Text.pos_at_start_of_screen_line(State, State.screen_top1)
  end
end

Replacement in source.lua at line 78 [10.165766]
B:BD[10.167321] → [10.167321:167372]
```
-- environment for a mutable file of bifolded text
```
[10.167321]
[10.167372]
```
-- environment for a mutable file
```

Deletion in source.lua at line 92 [10.165766]

B:BD[10.167894] → [10.167894:168053]

  -- We currently start out with side B collapsed.
  -- Other options:
  --  * save all expanded state by line
  --  * expand all if any location is in side B

Deletion in source.lua at line 98 [10.165766]
B:BD[10.168275] → [10.168275:168331]
```
  edit.eradicate_locations_after_the_fold(Editor_state)
```
Deletion in source.lua at line 251 [10.165766]
B:BD[10.173453] → [10.173453:173488]
```
  -- convert any bifold files here
```

Deletion in source.lua at line 253 [10.165766]

B:BD[10.173493] → [10.173493:173700]

function source.convert_bifold_text(infilename, outfilename)
  local contents = love.filesystem.read(infilename)
  contents = contents:gsub('\u{1e}', ';')
  love.filesystem.write(outfilename, contents)
end