akkartik/lines.love - Change I64IPGJXWRTGHHVAYJUBUIWFR4BY6NM5P7TLTV4JOD7K4BVYDECQC

avoid saving fragments in lines

Now we render lines one screen line at a time rather than one word at a time.

I can't port the source side just yet; I need to fix hyperlinks first..

Created by Kartik K. Agaram on April 1, 2023

I64IPGJXWRTGHHVAYJUBUIWFR4BY6NM5P7TLTV4JOD7K4BVYDECQC

Dependencies

In channels

main

Change contents

Replacement in text_tests.lua at line 1010 [7.2]
B:BD[5.26911] → [6.8877:8919]
```
  App.screen.check(y, 'mno ', 'screen:3')
```
[5.26911]
[7.10090]
```
  App.screen.check(y, 'mn', 'screen:3')
```
Insertion in text.lua at line 7 [10.1]
[8.214]
[9.42]
```
--?   print('text.draw', line_index, y)
```
Replacement in text.lua at line 13 [10.1]
B:BD[11.1768] → [12.53:76]
∅:D[13.92] → [11.1802:1818]
∅:D[9.106] → [11.1802:1818]
∅:D[14.1013] → [11.1802:1818]
B:BD[11.1802] → [11.1802:1818]
B:BD[11.1818] → [15.3:47]
```
  local x = State.left
  local pos = 1
  local screen_line_starting_pos = startpos
```
[11.1768]
[4.3]
```
  local final_screen_line_starting_pos = startpos  -- track value to return
```

Replacement in text.lua at line 15 [10.1]

∅:D[16.47] → [17.3860:3906]

∅:D[4.63] → [17.3860:3906]

∅:D[18.93] → [17.3860:3906]

B:BD[19.19] → [17.3860:3906]

B:BD[17.3906] → [20.3:29]

B:BD[20.29] → [3.3:103]

  for _, f in ipairs(line_cache.fragments) do
    App.color(Text_color)
    local frag_len = utf8.len(f)
--?     print('text.draw:', f, 'at', line_index,pos, 'after', x,y)

[4.63]

[15.48]

  assert(#line_cache.screen_line_starting_pos >= 1)
  for i=1,#line_cache.screen_line_starting_pos do
    local pos = line_cache.screen_line_starting_pos[i]

Insertion in text.lua at line 22 [10.1]

[21.138]

[22.3]

      final_screen_line_starting_pos = pos
      local f = Text.screen_line(line, line_cache, i)
--?       print('text.draw:', f, 'at', line_index,pos, 'after', x,y)
      local frag_len = utf8.len(f)

Deletion in text.lua at line 27 [10.1]
B:BD[22.28] → [3.136:174]
∅:D[23.46] → [21.138:234]
∅:D[22.74] → [21.138:234]
∅:D[3.174] → [21.138:234]
B:BD[21.138] → [21.138:234]
∅:D[21.234] → [24.405:497]
B:BD[24.405] → [24.405:497]
B:BD[25.499] → [25.499:556]
∅:D[26.104] → [27.255:294]
∅:D[28.108] → [27.255:294]
∅:D[29.272] → [27.255:294]
∅:D[25.556] → [27.255:294]
B:BD[27.255] → [27.255:294]
B:BD[25.648] → [21.235:258]
∅:D[30.110] → [31.119:129]
∅:D[32.127] → [31.119:129]
∅:D[21.258] → [31.119:129]
∅:D[33.266] → [31.119:129]
B:BD[31.119] → [31.119:129]
```
      local frag_width = App.width(f)
      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 y, screen_line_starting_pos
        end
        screen_line_starting_pos = pos
        x = State.left
      end
```

Replacement in text.lua at line 29 [10.1]

∅:D[12.405] → [34.97:155]

B:BD[34.97] → [34.97:155]

        Text.draw_highlight(State, line, x,y, pos, lo,hi)

[12.405]

[35.1056]

        Text.draw_highlight(State, line, State.left,y, pos, lo,hi)

Replacement in text.lua at line 31 [10.1]

B:BD[35.1066] → [3.175:206]

      App.screen.print(f, x,y)

[35.1066]

[21.259]

      App.color(Text_color)
      App.screen.print(f, State.left,y)

Replacement in text.lua at line 35 [10.1]

B:BD[21.342] → [21.342:422]

        if pos <= State.cursor1.pos and pos + frag_len > State.cursor1.pos then

[21.342]

[21.422]

        if pos <= State.cursor1.pos and pos + frag_len >= State.cursor1.pos then

Replacement in text.lua at line 38 [10.1]

B:BD[21.608] → [36.1429:1566]

              local lo_px = Text.draw_highlight(State, line, x,y, pos, State.cursor1.pos, State.cursor1.pos+utf8.len(State.search_term))

[21.608]

[21.738]

              local lo_px = Text.draw_highlight(State, line, State.left,y, pos, State.cursor1.pos, State.cursor1.pos+utf8.len(State.search_term))

Replacement in text.lua at line 40 [10.1]

B:BD[21.774] → [21.774:838]

              love.graphics.print(State.search_term, x+lo_px,y)

[21.774]

[21.838]

              love.graphics.print(State.search_term, State.left+lo_px,y)

Replacement in text.lua at line 43 [10.1]

B:BD[21.869] → [3.207:284]

            Text.draw_cursor(State, x+Text.x(f, State.cursor1.pos-pos+1), y)

[21.869]

[37.530]

            Text.draw_cursor(State, State.left+Text.x(f, State.cursor1.pos-pos+1), y)

Replacement in text.lua at line 47 [10.1]

B:BD[11.2604] → [21.950:975]

      x = x + frag_width

[11.2604]

      y = y + State.line_height
      if y >= App.screen.height then
        break
      end

Deletion in text.lua at line 52 [10.1]
B:BD[11.2635] → [11.2635:2660]
```
    pos = pos + frag_len
```

Replacement in text.lua at line 53 [10.1]

B:BD[38.37] → [24.1242:1387]

∅:D[24.1387] → [37.755:763]

B:BD[37.755] → [37.755:763]

  if State.search_term == nil then
    if line_index == State.cursor1.line and State.cursor1.pos == pos then
      Text.draw_cursor(State, x, y)
    end

[38.37]

[39.138]

  return y - State.line_height, final_screen_line_starting_pos
end
function Text.screen_line(line, line_cache, i)
  local pos = line_cache.screen_line_starting_pos[i]
  local offset = Text.offset(line.data, pos)
  if i >= #line_cache.screen_line_starting_pos then
    return line.data:sub(offset)

Replacement in text.lua at line 62 [10.1]

B:BD[32.310] → [27.295:332]

  return y, screen_line_starting_pos

[39.144]

[38.37]

  local endpos = line_cache.screen_line_starting_pos[i+1]-1
  local end_offset = Text.offset(line.data, endpos)
  return line.data:sub(offset, end_offset)

Deletion in text.lua at line 85 [10.1]
B:BD[40.268] → [40.268:309]
B:BD[40.309] → [16.48:92]
```
  -- duplicate some logic from Text.draw
  Text.compute_fragments(State, line_index)
```
Replacement in text.lua at line 86 [10.1]
B:BD[40.443] → [40.443:466]
```
  local x = State.left
```
[40.443]
[40.466]
```
  local x = 0
```
Deletion in text.lua at line 88 [10.1]
B:BD[40.482] → [40.482:528]
B:BD[40.571] → [40.571:594]
B:BD[40.594] → [3.285:321]
∅:D[23.88] → [40.638:792]
∅:D[3.321] → [40.638:792]
B:BD[40.638] → [40.638:792]
B:BD[40.792] → [3.322:350]
∅:D[41.304] → [40.853:859]
∅:D[3.350] → [40.853:859]
B:BD[40.853] → [40.853:859]
∅:D[42.51] → [43.256:260]
∅:D[44.687] → [43.256:260]
∅:D[40.859] → [43.256:260]
∅:D[24.1551] → [43.256:260]
∅:D[5.55726] → [43.256:260]
B:BD[43.256] → [43.256:260]
∅:D[43.260] → [38.41:42]
∅:D[11.2796] → [38.41:42]
B:BD[38.41] → [38.41:42]
B:BD[38.42] → [45.50:101]
∅:D[46.155] → [45.147:186]
B:BD[45.147] → [45.147:186]
B:BD[45.186] → [16.93:134]
∅:D[16.134] → [47.54:104]
B:BD[45.186] → [47.54:104]
B:BD[47.104] → [16.135:183]
∅:D[47.104] → [17.3962:3990]
∅:D[16.183] → [17.3962:3990]
B:BD[17.3962] → [17.3962:3990]
∅:D[17.3990] → [45.187:210]
B:BD[48.73] → [45.187:210]
```
  for _, f in ipairs(line_cache.fragments) do
    -- render fragment
    local frag_width = App.width(f)
    if x + frag_width > State.right then
      x = State.left
      table.insert(line_cache.screen_line_starting_pos, pos)
    end
    x = x + frag_width
    pos = pos + utf8.len(f)
  end
end
function Text.compute_fragments(State, line_index)
  local line = State.lines[line_index]
  if line.mode ~= 'text' then return end
  local line_cache = State.line_cache[line_index]
  if line_cache.fragments then
    return
  end
  line_cache.fragments = {}
  local x = State.left
```

Replacement in text.lua at line 91 [10.1]

∅:D[49.120] → [50.3:45]

B:BD[45.288] → [50.3:45]

B:BD[50.169] → [51.189:251]

    while x + frag_width > State.right do
      if (x-State.left) < 0.8 * (State.right-State.left) then

[23.128]

[50.234]

--?     print('-- frag:', frag, pos, x, frag_width, State.width)
    while x + frag_width > State.width do
--?       print('frag:', frag, pos, x, frag_width, State.width)
      if x < 0.8 * State.width then

Replacement in text.lua at line 97 [10.1]

B:BD[50.331] → [50.331:402]

B:BD[50.434] → [52.213:299]

        local bpos = Text.nearest_pos_less_than(frag, State.right - x)
        if bpos == 0 then break end  -- avoid infinite loop when window is too narrow

[50.331]

[50.509]

        local bpos = Text.nearest_pos_less_than(frag, State.width - x)
        -- everything works if bpos == 0, but is a little inefficient
        pos = pos + bpos

Deletion in text.lua at line 101 [10.1]

B:BD[50.676] → [50.676:729]

B:BD[50.800] → [23.129:174]

B:BD[50.935] → [50.935:982]

B:BD[50.982] → [3.351:401]

        local frag1 = string.sub(frag, 1, boffset-1)
        local frag1_width = App.width(frag1)
        assert(x + frag1_width <= State.right)
        table.insert(line_cache.fragments, frag1)

Insertion in text.lua at line 102 [10.1]

[50.1097]

[23.175]

--?         if bpos > 0 then
--?           print('after chop:', frag)
--?         end

Replacement in text.lua at line 107 [10.1]

B:BD[48.1377] → [50.1203:1237]

∅:D[50.1237] → [48.1377:1407]

B:BD[48.1377] → [48.1377:1407]

B:BD[48.1407] → [3.402:449]

      x = State.left  -- new line
    end
    if #frag > 0 then
      table.insert(line_cache.fragments, frag)

[48.1377]

[48.1549]

--?       print('screen line:', pos)
      table.insert(line_cache.screen_line_starting_pos, pos)
      x = 0  -- new screen line

Insertion in text.lua at line 112 [10.1]
[53.1627]
[48.1557]
```
    pos = pos + utf8.len(frag)
```
Deletion in text.lua at line 957 [10.1]
B:BD[54.462] → [47.1668:1715]
```
  State.line_cache[line_index].fragments = nil
```

Replacement in app.lua at line 376 [55.2]

B:BD[6.60904] → [2.1995:2057]

  local stack_trace = debug.traceback('', --[[stack frame]]4)

[6.60904]

[6.60966]

  local stack_trace = debug.traceback('', --[[stack frame]]5)

avoid saving fragments in lines

Dependencies

In channels

Change contents

Replacement in text_tests.lua at line 1010 [7.2]

Insertion in text.lua at line 7 [10.1]

Replacement in text.lua at line 13 [10.1]