2022-06-03 22:14:53 +01:00
-- text editor, particularly text drawing, horizontal wrap, vertical scrolling
2022-05-18 04:29:08 +01:00
Text = { }
2022-07-17 18:06:39 +01:00
-- draw a line starting from startpos to screen at y between State.left and State.right
2024-06-11 14:58:07 +01:00
-- return y for the next line
2022-07-17 18:06:39 +01:00
function Text . draw ( State , line_index , y , startpos )
2023-04-02 04:03:43 +01:00
--? print('text.draw', line_index, y)
2022-07-17 15:58:51 +01:00
local line = State.lines [ line_index ]
2022-07-21 00:34:09 +01:00
local line_cache = State.line_cache [ line_index ]
2022-07-18 05:05:01 +01:00
line_cache.startpos = startpos
2022-05-20 01:29:14 +01:00
-- wrap long lines
2023-04-02 01:05:57 +01:00
Text.populate_screen_line_starting_pos ( State , line_index )
2023-11-18 19:30:57 +00:00
assert ( # line_cache.screen_line_starting_pos >= 1 , ' line cache missing screen line info ' )
2023-04-02 04:03:43 +01:00
for i = 1 , # line_cache.screen_line_starting_pos do
local pos = line_cache.screen_line_starting_pos [ i ]
2022-08-15 23:45:02 +01:00
if pos < startpos then
2022-07-20 14:53:58 +01:00
-- render nothing
else
2023-04-09 06:44:13 +01:00
local screen_line = Text.screen_line ( line , line_cache , i )
--? print('text.draw:', screen_line, 'at', line_index,pos, 'after', x,y)
local frag_len = utf8.len ( screen_line )
2023-07-31 16:56:20 +01:00
-- render any highlights
2022-07-13 00:08:24 +01:00
if State.selection1 . line then
2022-07-13 04:59:24 +01:00
local lo , hi = Text.clip_selection ( State , line_index , pos , pos + frag_len )
2023-04-02 04:03:43 +01:00
Text.draw_highlight ( State , line , State.left , y , pos , lo , hi )
2022-05-29 16:12:47 +01:00
end
2022-07-20 14:53:58 +01:00
if line_index == State.cursor1 . line then
2023-07-31 16:21:38 +01:00
-- render search highlight or cursor
2023-07-31 16:24:15 +01:00
if State.search_term then
2023-07-31 17:15:48 +01:00
local data = State.lines [ State.cursor1 . line ] . data
local cursor_offset = Text.offset ( data , State.cursor1 . pos )
if data : sub ( cursor_offset , cursor_offset +# State.search_term - 1 ) == State.search_term then
local save_selection = State.selection1
State.selection1 = { line = line_index , pos = State.cursor1 . pos + utf8.len ( State.search_term ) }
local lo , hi = Text.clip_selection ( State , line_index , pos , pos + frag_len )
Text.draw_highlight ( State , line , State.left , y , pos , lo , hi )
State.selection1 = save_selection
2023-07-31 16:24:15 +01:00
end
else
2023-07-31 16:29:11 +01:00
if pos <= State.cursor1 . pos and pos + frag_len > State.cursor1 . pos then
2024-01-12 13:23:06 +00:00
Text.draw_cursor ( State , State.left + Text.x ( State.font , screen_line , State.cursor1 . pos - pos + 1 ) , y )
2023-07-31 16:29:11 +01:00
elseif pos + frag_len == State.cursor1 . pos then
-- Show cursor at end of line.
-- This place also catches end of wrapping screen lines. That doesn't seem worth distinguishing.
-- It seems useful to see a cursor whether your eye is on the left or right margin.
2024-01-12 13:23:06 +00:00
Text.draw_cursor ( State , State.left + Text.x ( State.font , screen_line , State.cursor1 . pos - pos + 1 ) , y )
2022-06-03 06:53:34 +01:00
end
end
2022-05-20 01:29:14 +01:00
end
2023-07-31 16:56:20 +01:00
-- render fragment
App.color ( Text_color )
App.screen . print ( screen_line , State.left , y )
2023-04-02 04:03:43 +01:00
y = y + State.line_height
if y >= App.screen . height then
break
end
2022-05-20 01:29:14 +01:00
end
end
2024-06-11 14:58:07 +01:00
return y
2023-04-02 04:03:43 +01:00
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 )
2022-05-20 06:35:26 +01:00
end
2023-04-02 04:03:43 +01:00
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 )
2022-05-18 04:29:08 +01:00
end
2022-05-29 16:12:47 +01:00
2022-07-13 00:08:24 +01:00
function Text . draw_cursor ( State , x , y )
2022-06-09 21:45:52 +01:00
-- blink every 0.5s
if math.floor ( Cursor_time * 2 ) % 2 == 0 then
2022-07-12 07:03:27 +01:00
App.color ( Cursor_color )
2022-07-13 00:08:24 +01:00
love.graphics . rectangle ( ' fill ' , x , y , 3 , State.line_height )
2022-06-09 21:45:52 +01:00
end
2022-07-13 00:08:24 +01:00
State.cursor_x = x
State.cursor_y = y + State.line_height
2022-05-20 13:40:42 +01:00
end
2022-08-16 00:07:32 +01:00
function Text . populate_screen_line_starting_pos ( 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.screen_line_starting_pos then
return
end
line_cache.screen_line_starting_pos = { 1 }
2023-04-02 04:03:43 +01:00
local x = 0
2022-08-16 00:07:32 +01:00
local pos = 1
2022-05-20 06:58:04 +01:00
-- try to wrap at word boundaries
for frag in line.data : gmatch ( ' %S*%s* ' ) do
2024-01-12 13:23:06 +00:00
local frag_width = State.font : getWidth ( frag )
2023-04-02 04:03:43 +01:00
--? 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
2022-07-20 15:02:45 +01:00
-- long word; chop it at some letter
-- We're not going to reimplement TeX here.
2024-01-12 13:23:06 +00:00
local bpos = Text.nearest_pos_less_than ( State.font , frag , State.width - x )
2023-11-25 03:19:29 +00:00
if x == 0 and bpos == 0 then
assert ( false , ( " Infinite loop while line-wrapping. Editor is %dpx wide; window is %dpx wide " ) : format ( State.width , App.screen . width ) )
end
2023-04-02 04:03:43 +01:00
pos = pos + bpos
2022-07-20 15:02:45 +01:00
local boffset = Text.offset ( frag , bpos + 1 ) -- byte _after_ bpos
frag = string.sub ( frag , boffset )
2023-04-02 04:03:43 +01:00
--? if bpos > 0 then
--? print('after chop:', frag)
--? end
2024-01-12 13:23:06 +00:00
frag_width = State.font : getWidth ( frag )
2022-05-20 06:58:04 +01:00
end
2023-04-02 04:03:43 +01:00
--? print('screen line:', pos)
table.insert ( line_cache.screen_line_starting_pos , pos )
x = 0 -- new screen line
2022-05-20 06:58:04 +01:00
end
2022-05-28 17:02:15 +01:00
x = x + frag_width
2023-04-02 04:03:43 +01:00
pos = pos + utf8.len ( frag )
2022-05-20 06:58:04 +01:00
end
end
2022-12-24 01:16:19 +00:00
function Text . text_input ( State , t )
2022-06-14 17:05:02 +01:00
if App.mouse_down ( 1 ) then return end
2023-11-25 23:20:55 +00:00
if App.any_modifier_down ( ) then
if App.key_down ( t ) then
-- The modifiers didn't change the key. Handle it in keychord_pressed.
return
else
-- Key mutated by the keyboard layout. Continue below.
end
end
2022-07-13 00:55:32 +01:00
local before = snapshot ( State , State.cursor1 . line )
2024-06-11 14:58:07 +01:00
--? print(State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos)
2022-07-13 00:39:42 +01:00
Text.insert_at_cursor ( State , t )
2022-08-17 17:40:44 +01:00
if State.cursor_y > App.screen . height - State.line_height then
2022-07-17 17:10:33 +01:00
Text.populate_screen_line_starting_pos ( State , State.cursor1 . line )
2022-07-13 02:29:00 +01:00
Text.snap_cursor_to_bottom_of_screen ( State , State.left , State.right )
2022-06-10 19:29:01 +01:00
end
2022-07-13 00:55:32 +01:00
record_undo_event ( State , { before = before , after = snapshot ( State , State.cursor1 . line ) } )
2022-05-19 04:22:57 +01:00
end
2022-07-13 00:39:42 +01:00
function Text . insert_at_cursor ( State , t )
2023-11-18 19:30:57 +00:00
assert ( State.lines [ State.cursor1 . line ] . mode == ' text ' , ' line is not text ' )
2022-07-13 00:39:42 +01:00
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 )
2022-07-17 16:18:48 +01:00
Text.clear_screen_line_cache ( State , State.cursor1 . line )
2022-07-13 00:39:42 +01:00
State.cursor1 . pos = State.cursor1 . pos + 1
2022-05-18 06:36:10 +01:00
end
2022-12-24 01:16:19 +00:00
-- Don't handle any keys here that would trigger text_input above.
function Text . keychord_press ( State , chord )
2022-07-13 00:23:28 +01:00
--? print('chord', chord, State.selection1.line, State.selection1.pos)
2022-05-29 06:27:47 +01:00
--== shortcuts that mutate text
2022-05-18 06:36:10 +01:00
if chord == ' return ' then
2022-07-13 00:23:28 +01:00
local before_line = State.cursor1 . line
2022-07-13 00:55:32 +01:00
local before = snapshot ( State , before_line )
2022-07-13 00:39:42 +01:00
Text.insert_return ( State )
2022-07-13 00:23:28 +01:00
State.selection1 = { }
2022-08-17 17:40:44 +01:00
if State.cursor_y > App.screen . height - State.line_height then
2022-07-13 02:29:00 +01:00
Text.snap_cursor_to_bottom_of_screen ( State , State.left , State.right )
2022-06-10 19:21:41 +01:00
end
2022-07-13 00:30:41 +01:00
schedule_save ( State )
2022-07-13 00:55:32 +01:00
record_undo_event ( State , { before = before , after = snapshot ( State , before_line , State.cursor1 . line ) } )
2022-05-19 04:22:57 +01:00
elseif chord == ' tab ' then
2022-07-13 00:55:32 +01:00
local before = snapshot ( State , State.cursor1 . line )
2024-06-11 14:58:07 +01:00
--? print(State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos)
2022-07-13 00:39:42 +01:00
Text.insert_at_cursor ( State , ' \t ' )
2022-08-17 17:40:44 +01:00
if State.cursor_y > App.screen . height - State.line_height then
2022-07-17 17:10:33 +01:00
Text.populate_screen_line_starting_pos ( State , State.cursor1 . line )
2022-07-13 02:29:00 +01:00
Text.snap_cursor_to_bottom_of_screen ( State , State.left , State.right )
2024-06-11 14:58:07 +01:00
--? print('=>', State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos)
2022-06-10 19:29:01 +01:00
end
2022-07-13 00:30:41 +01:00
schedule_save ( State )
2022-07-13 00:55:32 +01:00
record_undo_event ( State , { before = before , after = snapshot ( State , State.cursor1 . line ) } )
2022-05-18 06:36:10 +01:00
elseif chord == ' backspace ' then
2022-07-13 00:23:28 +01:00
if State.selection1 . line then
2022-07-13 02:29:00 +01:00
Text.delete_selection ( State , State.left , State.right )
2022-07-13 00:30:41 +01:00
schedule_save ( State )
2022-05-29 16:12:47 +01:00
return
end
2022-06-03 01:46:30 +01:00
local before
2022-07-13 00:23:28 +01:00
if State.cursor1 . pos > 1 then
2022-07-13 00:55:32 +01:00
before = snapshot ( State , State.cursor1 . line )
2022-07-13 00:23:28 +01:00
local byte_start = utf8.offset ( State.lines [ State.cursor1 . line ] . data , State.cursor1 . pos - 1 )
local byte_end = utf8.offset ( State.lines [ State.cursor1 . line ] . data , State.cursor1 . pos )
2022-05-18 06:36:10 +01:00
if byte_start then
if byte_end then
2022-07-13 00:23:28 +01:00
State.lines [ State.cursor1 . line ] . data = string.sub ( State.lines [ State.cursor1 . line ] . data , 1 , byte_start - 1 ) .. string.sub ( State.lines [ State.cursor1 . line ] . data , byte_end )
2022-05-18 06:36:10 +01:00
else
2022-07-13 00:23:28 +01:00
State.lines [ State.cursor1 . line ] . data = string.sub ( State.lines [ State.cursor1 . line ] . data , 1 , byte_start - 1 )
2022-05-18 06:36:10 +01:00
end
2022-07-13 00:23:28 +01:00
State.cursor1 . pos = State.cursor1 . pos - 1
2022-05-18 06:36:10 +01:00
end
2022-07-13 00:23:28 +01:00
elseif State.cursor1 . line > 1 then
2022-07-13 00:55:32 +01:00
before = snapshot ( State , State.cursor1 . line - 1 , State.cursor1 . line )
2022-07-13 00:23:28 +01:00
if State.lines [ State.cursor1 . line - 1 ] . mode == ' drawing ' then
table.remove ( State.lines , State.cursor1 . line - 1 )
2022-07-21 00:34:09 +01:00
table.remove ( State.line_cache , State.cursor1 . line - 1 )
2022-05-18 06:36:10 +01:00
else
-- join lines
2022-07-13 00:23:28 +01:00
State.cursor1 . pos = utf8.len ( State.lines [ State.cursor1 . line - 1 ] . data ) + 1
State.lines [ State.cursor1 . line - 1 ] . data = State.lines [ State.cursor1 . line - 1 ] . data .. State.lines [ State.cursor1 . line ] . data
table.remove ( State.lines , State.cursor1 . line )
2022-07-21 00:34:09 +01:00
table.remove ( State.line_cache , State.cursor1 . line )
2022-05-18 06:36:10 +01:00
end
2022-07-13 00:23:28 +01:00
State.cursor1 . line = State.cursor1 . line - 1
2022-05-18 06:36:10 +01:00
end
2022-08-11 06:38:10 +01:00
if State.screen_top1 . line > # State.lines then
Text.populate_screen_line_starting_pos ( State , # State.lines )
local line_cache = State.line_cache [ # State.line_cache ]
State.screen_top1 = { line =# State.lines , pos = line_cache.screen_line_starting_pos [ # line_cache.screen_line_starting_pos ] }
elseif Text.lt1 ( State.cursor1 , State.screen_top1 ) then
2023-03-18 04:52:35 +00:00
State.screen_top1 = {
line = State.cursor1 . line ,
pos = Text.pos_at_start_of_screen_line ( State , State.cursor1 ) ,
}
2022-07-13 01:24:01 +01:00
Text.redraw_all ( State ) -- if we're scrolling, reclaim all fragments to avoid memory leaks
2022-05-28 17:41:02 +01:00
end
2022-07-17 16:18:48 +01:00
Text.clear_screen_line_cache ( State , State.cursor1 . line )
2023-11-18 19:30:57 +00:00
assert ( Text.le1 ( State.screen_top1 , State.cursor1 ) , ( ' screen_top (line=%d,pos=%d) is below cursor (line=%d,pos=%d) ' ) : format ( State.screen_top1 . line , State.screen_top1 . pos , State.cursor1 . line , State.cursor1 . pos ) )
2022-07-13 00:30:41 +01:00
schedule_save ( State )
2022-07-13 00:55:32 +01:00
record_undo_event ( State , { before = before , after = snapshot ( State , State.cursor1 . line ) } )
2022-05-18 06:36:10 +01:00
elseif chord == ' delete ' then
2022-07-13 00:23:28 +01:00
if State.selection1 . line then
2022-07-13 02:29:00 +01:00
Text.delete_selection ( State , State.left , State.right )
2022-07-13 00:30:41 +01:00
schedule_save ( State )
2022-05-29 16:12:47 +01:00
return
end
2022-06-03 01:46:30 +01:00
local before
2022-07-13 00:23:28 +01:00
if State.cursor1 . pos <= utf8.len ( State.lines [ State.cursor1 . line ] . data ) then
2022-07-13 00:55:32 +01:00
before = snapshot ( State , State.cursor1 . line )
2022-06-03 01:46:30 +01:00
else
2022-07-13 00:55:32 +01:00
before = snapshot ( State , State.cursor1 . line , State.cursor1 . line + 1 )
2022-06-03 01:46:30 +01:00
end
2022-07-13 00:23:28 +01:00
if State.cursor1 . pos <= utf8.len ( State.lines [ State.cursor1 . line ] . data ) then
local byte_start = utf8.offset ( State.lines [ State.cursor1 . line ] . data , State.cursor1 . pos )
local byte_end = utf8.offset ( State.lines [ State.cursor1 . line ] . data , State.cursor1 . pos + 1 )
2022-05-18 06:36:10 +01:00
if byte_start then
if byte_end then
2022-07-13 00:23:28 +01:00
State.lines [ State.cursor1 . line ] . data = string.sub ( State.lines [ State.cursor1 . line ] . data , 1 , byte_start - 1 ) .. string.sub ( State.lines [ State.cursor1 . line ] . data , byte_end )
2022-05-18 06:36:10 +01:00
else
2022-07-13 00:23:28 +01:00
State.lines [ State.cursor1 . line ] . data = string.sub ( State.lines [ State.cursor1 . line ] . data , 1 , byte_start - 1 )
2022-05-18 06:36:10 +01:00
end
2022-07-13 00:23:28 +01:00
-- no change to State.cursor1.pos
2022-05-18 06:36:10 +01:00
end
2022-07-13 00:23:28 +01:00
elseif State.cursor1 . line < # State.lines then
2022-07-18 05:05:01 +01:00
if State.lines [ State.cursor1 . line + 1 ] . mode == ' text ' then
2022-05-18 06:36:10 +01:00
-- join lines
2022-07-13 00:23:28 +01:00
State.lines [ State.cursor1 . line ] . data = State.lines [ State.cursor1 . line ] . data .. State.lines [ State.cursor1 . line + 1 ] . data
2022-05-18 06:36:10 +01:00
end
2022-07-18 05:05:01 +01:00
table.remove ( State.lines , State.cursor1 . line + 1 )
2022-07-21 00:34:09 +01:00
table.remove ( State.line_cache , State.cursor1 . line + 1 )
2022-05-18 06:36:10 +01:00
end
2022-07-17 16:18:48 +01:00
Text.clear_screen_line_cache ( State , State.cursor1 . line )
2022-07-13 00:30:41 +01:00
schedule_save ( State )
2022-07-13 00:55:32 +01:00
record_undo_event ( State , { before = before , after = snapshot ( State , State.cursor1 . line ) } )
2022-05-29 06:27:47 +01:00
--== shortcuts that move the cursor
elseif chord == ' left ' then
2022-08-18 20:09:50 +01:00
Text.left ( State )
2022-07-13 00:23:28 +01:00
State.selection1 = { }
2022-06-20 19:35:27 +01:00
elseif chord == ' right ' then
2022-08-18 20:09:50 +01:00
Text.right ( State )
2022-07-13 00:23:28 +01:00
State.selection1 = { }
2022-05-29 16:12:47 +01:00
elseif chord == ' S-left ' then
2022-07-13 00:23:28 +01:00
if State.selection1 . line == nil then
State.selection1 = { line = State.cursor1 . line , pos = State.cursor1 . pos }
2022-05-29 16:12:47 +01:00
end
2022-08-18 20:09:50 +01:00
Text.left ( State )
2022-05-29 16:12:47 +01:00
elseif chord == ' S-right ' then
2022-07-13 00:23:28 +01:00
if State.selection1 . line == nil then
State.selection1 = { line = State.cursor1 . line , pos = State.cursor1 . pos }
2022-05-29 16:12:47 +01:00
end
2022-08-18 20:09:50 +01:00
Text.right ( State )
2022-05-29 06:27:47 +01:00
-- C- hotkeys reserved for drawings, so we'll use M-
elseif chord == ' M-left ' then
2022-08-18 20:09:50 +01:00
Text.word_left ( State )
2022-07-13 00:23:28 +01:00
State.selection1 = { }
2022-06-20 19:35:27 +01:00
elseif chord == ' M-right ' then
2022-08-18 20:09:50 +01:00
Text.word_right ( State )
2022-07-13 00:23:28 +01:00
State.selection1 = { }
2022-05-29 16:12:47 +01:00
elseif chord == ' M-S-left ' then
2022-07-13 00:23:28 +01:00
if State.selection1 . line == nil then
State.selection1 = { line = State.cursor1 . line , pos = State.cursor1 . pos }
2022-05-29 16:12:47 +01:00
end
2022-08-18 20:09:50 +01:00
Text.word_left ( State )
2022-05-29 16:12:47 +01:00
elseif chord == ' M-S-right ' then
2022-07-13 00:23:28 +01:00
if State.selection1 . line == nil then
State.selection1 = { line = State.cursor1 . line , pos = State.cursor1 . pos }
2022-05-29 16:12:47 +01:00
end
2022-08-18 20:09:50 +01:00
Text.word_right ( State )
2022-05-29 06:27:47 +01:00
elseif chord == ' home ' then
2022-07-13 00:39:42 +01:00
Text.start_of_line ( State )
2022-07-13 00:23:28 +01:00
State.selection1 = { }
2022-06-20 19:35:27 +01:00
elseif chord == ' end ' then
2022-08-18 20:09:50 +01:00
Text.end_of_line ( State )
2022-07-13 00:23:28 +01:00
State.selection1 = { }
2022-05-29 16:12:47 +01:00
elseif chord == ' S-home ' then
2022-07-13 00:23:28 +01:00
if State.selection1 . line == nil then
State.selection1 = { line = State.cursor1 . line , pos = State.cursor1 . pos }
2022-05-29 16:12:47 +01:00
end
2022-07-13 00:39:42 +01:00
Text.start_of_line ( State )
2022-05-29 16:12:47 +01:00
elseif chord == ' S-end ' then
2022-07-13 00:23:28 +01:00
if State.selection1 . line == nil then
State.selection1 = { line = State.cursor1 . line , pos = State.cursor1 . pos }
2022-05-29 16:12:47 +01:00
end
2022-08-18 20:09:50 +01:00
Text.end_of_line ( State )
2022-05-18 06:36:10 +01:00
elseif chord == ' up ' then
2022-08-18 20:09:50 +01:00
Text.up ( State )
2022-07-13 00:23:28 +01:00
State.selection1 = { }
2022-06-20 19:35:27 +01:00
elseif chord == ' down ' then
2022-08-18 20:09:50 +01:00
Text.down ( State )
2022-07-13 00:23:28 +01:00
State.selection1 = { }
2022-05-29 16:12:47 +01:00
elseif chord == ' S-up ' then
2022-07-13 00:23:28 +01:00
if State.selection1 . line == nil then
State.selection1 = { line = State.cursor1 . line , pos = State.cursor1 . pos }
2022-05-29 16:12:47 +01:00
end
2022-08-18 20:09:50 +01:00
Text.up ( State )
2022-05-29 16:12:47 +01:00
elseif chord == ' S-down ' then
2022-07-13 00:23:28 +01:00
if State.selection1 . line == nil then
State.selection1 = { line = State.cursor1 . line , pos = State.cursor1 . pos }
2022-05-29 16:12:47 +01:00
end
2022-08-18 20:09:50 +01:00
Text.down ( State )
2022-05-29 06:42:11 +01:00
elseif chord == ' pageup ' then
2022-08-18 20:09:50 +01:00
Text.pageup ( State )
2022-07-13 00:23:28 +01:00
State.selection1 = { }
2022-06-20 19:35:27 +01:00
elseif chord == ' pagedown ' then
2022-08-18 20:09:50 +01:00
Text.pagedown ( State )
2022-07-13 00:23:28 +01:00
State.selection1 = { }
2022-05-29 16:12:47 +01:00
elseif chord == ' S-pageup ' then
2022-07-13 00:23:28 +01:00
if State.selection1 . line == nil then
State.selection1 = { line = State.cursor1 . line , pos = State.cursor1 . pos }
2022-05-29 16:12:47 +01:00
end
2022-08-18 20:09:50 +01:00
Text.pageup ( State )
2022-05-29 16:12:47 +01:00
elseif chord == ' S-pagedown ' then
2022-07-13 00:23:28 +01:00
if State.selection1 . line == nil then
State.selection1 = { line = State.cursor1 . line , pos = State.cursor1 . pos }
2022-05-29 16:12:47 +01:00
end
2022-08-18 20:09:50 +01:00
Text.pagedown ( State )
2022-05-29 06:36:05 +01:00
end
end
2022-07-13 00:39:42 +01:00
function Text . insert_return ( State )
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 ) } )
2022-07-21 00:34:09 +01:00
table.insert ( State.line_cache , State.cursor1 . line + 1 , { } )
2022-07-13 00:39:42 +01:00
State.lines [ State.cursor1 . line ] . data = string.sub ( State.lines [ State.cursor1 . line ] . data , 1 , byte_offset - 1 )
2022-07-17 16:18:48 +01:00
Text.clear_screen_line_cache ( State , State.cursor1 . line )
2022-09-05 19:28:03 +01:00
State.cursor1 = { line = State.cursor1 . line + 1 , pos = 1 }
2022-06-03 02:35:18 +01:00
end
2022-07-13 04:59:24 +01:00
function Text . pageup ( State )
2024-06-11 14:58:07 +01:00
State.screen_top1 = Text.previous_screen_top1 ( State )
State.cursor1 = { line = State.screen_top1 . line , pos = State.screen_top1 . pos }
Text.move_cursor_down_to_next_text_line_while_scrolling_again_if_necessary ( State )
Text.redraw_all ( State ) -- if we're scrolling, reclaim all fragments to avoid memory leaks
end
2024-06-11 18:37:58 +01:00
-- return the top y coordinate of a given line_index,
-- or nil if no part of it is on screen
function Text . starty ( State , line_index )
-- duplicate some logic from love.draw
-- does not modify State (except to populate line_cache)
if line_index < State.screen_top1 . line then return end
local loc2 = Text.to2 ( State , State.screen_top1 )
local y = State.top
while true do
if State.lines [ loc2.line ] . mode == ' drawing ' then
y = y + Drawing_padding_top
end
if loc2.line == line_index then return y end
if State.lines [ loc2.line ] . mode == ' text ' then
y = y + State.line_height
elseif State.lines [ loc2.line ] . mode == ' drawing ' then
y = y + Drawing.pixels ( State.lines [ loc2.line ] . h , State.width ) + Drawing_padding_bottom
end
if y + State.line_height > App.screen . height then break end
local next_loc2 = Text.next_screen_line ( State , loc2 )
if Text.eq2 ( next_loc2 , loc2 ) then break end -- end of file
loc2 = next_loc2
end
end
2024-06-11 14:58:07 +01:00
function Text . previous_screen_top1 ( State )
2022-05-29 06:45:53 +01:00
-- duplicate some logic from love.draw
2024-06-11 14:58:07 +01:00
-- does not modify State (except to populate line_cache)
local loc2 = Text.to2 ( State , State.screen_top1 )
2022-07-13 00:39:42 +01:00
local y = App.screen . height - State.line_height
2022-07-13 02:29:00 +01:00
while y >= State.top do
2024-06-11 14:58:07 +01:00
if loc2.line == 1 and loc2.screen_line == 1 and loc2.screen_pos == 1 then break end
if State.lines [ loc2.line ] . mode == ' text ' then
2022-07-13 00:39:42 +01:00
y = y - State.line_height
2024-06-11 14:58:07 +01:00
elseif State.lines [ loc2.line ] . mode == ' drawing ' then
y = y - Drawing_padding_height - Drawing.pixels ( State.lines [ loc2.line ] . h , State.width )
2022-05-29 06:45:53 +01:00
end
2024-06-11 14:58:07 +01:00
loc2 = Text.previous_screen_line ( State , loc2 )
2022-05-29 06:45:53 +01:00
end
2024-06-11 14:58:07 +01:00
return Text.to1 ( State , loc2 )
2022-05-29 06:45:53 +01:00
end
2022-07-13 04:59:24 +01:00
function Text . pagedown ( State )
2024-06-11 14:58:07 +01:00
State.screen_top1 = Text.screen_bottom1 ( State )
2022-09-05 19:28:03 +01:00
State.cursor1 = { line = State.screen_top1 . line , pos = State.screen_top1 . pos }
2022-07-13 04:59:24 +01:00
Text.move_cursor_down_to_next_text_line_while_scrolling_again_if_necessary ( State )
2022-07-13 01:24:01 +01:00
Text.redraw_all ( State ) -- if we're scrolling, reclaim all fragments to avoid memory leaks
2024-06-11 14:58:07 +01:00
end
-- return the location of the start of the bottom-most line on screen
function Text . screen_bottom1 ( State )
-- duplicate some logic from love.draw
-- does not modify State (except to populate line_cache)
local loc2 = Text.to2 ( State , State.screen_top1 )
local y = State.top
while true do
if State.lines [ loc2.line ] . mode == ' text ' then
y = y + State.line_height
elseif State.lines [ loc2.line ] . mode == ' drawing ' then
y = y + Drawing_padding_height + Drawing.pixels ( State.lines [ loc2.line ] . h , State.width )
end
if y + State.line_height > App.screen . height then break end
local next_loc2 = Text.next_screen_line ( State , loc2 )
if Text.eq2 ( next_loc2 , loc2 ) then break end
loc2 = next_loc2
end
return Text.to1 ( State , loc2 )
2022-05-29 06:45:53 +01:00
end
2022-07-13 04:59:24 +01:00
function Text . up ( State )
2023-11-18 19:30:57 +00:00
assert ( State.lines [ State.cursor1 . line ] . mode == ' text ' , ' line is not text ' )
2022-07-13 00:39:42 +01:00
--? print('up', State.cursor1.line, State.cursor1.pos, State.screen_top1.line, State.screen_top1.pos)
2022-08-18 18:22:48 +01:00
local screen_line_starting_pos , screen_line_index = Text.pos_at_start_of_screen_line ( State , State.cursor1 )
2022-05-29 06:36:05 +01:00
if screen_line_starting_pos == 1 then
--? print('cursor is at first screen line of its line')
-- line is done; skip to previous text line
2022-07-13 00:39:42 +01:00
local new_cursor_line = State.cursor1 . line
2022-05-29 06:36:05 +01:00
while new_cursor_line > 1 do
new_cursor_line = new_cursor_line - 1
2022-07-13 00:39:42 +01:00
if State.lines [ new_cursor_line ] . mode == ' text ' then
2022-05-29 06:36:05 +01:00
--? print('found previous text line')
2023-02-01 06:39:04 +00:00
State.cursor1 = { line = new_cursor_line , pos = nil }
2022-07-17 17:10:33 +01:00
Text.populate_screen_line_starting_pos ( State , State.cursor1 . line )
2022-05-29 06:36:05 +01:00
-- previous text line found, pick its final screen line
--? print('has multiple screen lines')
2022-07-21 00:34:09 +01:00
local screen_line_starting_pos = State.line_cache [ State.cursor1 . line ] . screen_line_starting_pos
2022-05-29 06:36:05 +01:00
--? print(#screen_line_starting_pos)
screen_line_starting_pos = screen_line_starting_pos [ # screen_line_starting_pos ]
2022-07-13 00:39:42 +01:00
local screen_line_starting_byte_offset = Text.offset ( State.lines [ State.cursor1 . line ] . data , screen_line_starting_pos )
local s = string.sub ( State.lines [ State.cursor1 . line ] . data , screen_line_starting_byte_offset )
2024-01-12 13:23:06 +00:00
State.cursor1 . pos = screen_line_starting_pos + Text.nearest_cursor_pos ( State.font , s , State.cursor_x , State.left ) - 1
2022-05-29 06:36:05 +01:00
break
2022-05-18 06:36:10 +01:00
end
2022-05-29 06:36:05 +01:00
end
else
-- move up one screen line in current line
2023-11-18 19:30:57 +00:00
assert ( screen_line_index > 1 , ' bumped up against top screen line in line ' )
2022-08-18 21:37:14 +01:00
local new_screen_line_starting_pos = State.line_cache [ State.cursor1 . line ] . screen_line_starting_pos [ screen_line_index - 1 ]
2022-07-13 00:39:42 +01:00
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 )
2024-01-12 13:23:06 +00:00
State.cursor1 . pos = new_screen_line_starting_pos + Text.nearest_cursor_pos ( State.font , s , State.cursor_x , State.left ) - 1
2022-07-13 00:39:42 +01:00
--? print('cursor pos is now '..tostring(State.cursor1.pos))
2022-05-29 06:36:05 +01:00
end
2022-08-18 21:04:04 +01:00
if Text.lt1 ( State.cursor1 , State.screen_top1 ) then
2023-03-18 04:52:35 +00:00
State.screen_top1 = {
line = State.cursor1 . line ,
pos = Text.pos_at_start_of_screen_line ( State , State.cursor1 ) ,
}
Text.redraw_all ( State ) -- if we're scrolling, reclaim all fragments to avoid memory leaks
2022-08-18 21:04:04 +01:00
end
2022-05-29 06:36:05 +01:00
end
2022-07-13 04:59:24 +01:00
function Text . down ( State )
2023-11-18 19:30:57 +00:00
assert ( State.lines [ State.cursor1 . line ] . mode == ' text ' , ' line is not text ' )
2024-06-11 14:58:07 +01:00
--? print('down', State.cursor1.line, State.cursor1.pos, State.screen_top1.line, State.screen_top1.pos)
2023-11-18 19:30:57 +00:00
assert ( State.cursor1 . pos , ' cursor has no pos ' )
2022-07-13 04:59:24 +01:00
if Text.cursor_at_final_screen_line ( State ) then
2022-05-29 06:36:05 +01:00
-- line is done, skip to next text line
--? print('cursor at final screen line of its line')
2022-07-13 00:39:42 +01:00
local new_cursor_line = State.cursor1 . line
while new_cursor_line < # State.lines do
2022-05-29 06:36:05 +01:00
new_cursor_line = new_cursor_line + 1
2022-07-13 00:39:42 +01:00
if State.lines [ new_cursor_line ] . mode == ' text ' then
2022-09-05 19:28:03 +01:00
State.cursor1 = {
line = new_cursor_line ,
2024-01-12 13:23:06 +00:00
pos = Text.nearest_cursor_pos ( State.font , State.lines [ new_cursor_line ] . data , State.cursor_x , State.left ) ,
2022-09-05 19:28:03 +01:00
}
2022-07-13 00:39:42 +01:00
--? print(State.cursor1.pos)
2022-05-29 06:36:05 +01:00
break
2022-05-24 23:01:09 +01:00
end
2022-05-19 01:22:04 +01:00
end
2024-06-11 14:58:07 +01:00
local screen_bottom1 = Text.screen_bottom1 ( State )
--? print('down 2', State.cursor1.line, State.cursor1.pos, State.screen_top1.line, State.screen_top1.pos, screen_bottom1.line, screen_bottom1.pos)
if State.cursor1 . line > screen_bottom1.line then
2022-07-13 00:39:42 +01:00
--? print('screen top before:', State.screen_top1.line, State.screen_top1.pos)
2022-05-29 06:36:05 +01:00
--? print('scroll up preserving cursor')
2022-07-13 04:59:24 +01:00
Text.snap_cursor_to_bottom_of_screen ( State )
2022-07-13 00:39:42 +01:00
--? print('screen top after:', State.screen_top1.line, State.screen_top1.pos)
2022-05-29 06:36:05 +01:00
end
else
-- move down one screen line in current line
2024-06-11 14:58:07 +01:00
local screen_bottom1 = Text.screen_bottom1 ( State )
local scroll_down = Text.le1 ( screen_bottom1 , State.cursor1 )
2022-05-29 06:36:05 +01:00
--? print('cursor is NOT at final screen line of its line')
2022-08-18 18:22:48 +01:00
local screen_line_starting_pos , screen_line_index = Text.pos_at_start_of_screen_line ( State , State.cursor1 )
2022-09-05 19:28:03 +01:00
Text.populate_screen_line_starting_pos ( State , State.cursor1 . line )
2022-08-18 21:37:14 +01:00
local new_screen_line_starting_pos = State.line_cache [ State.cursor1 . line ] . screen_line_starting_pos [ screen_line_index + 1 ]
2022-05-29 06:36:05 +01:00
--? print('switching pos of screen line at cursor from '..tostring(screen_line_starting_pos)..' to '..tostring(new_screen_line_starting_pos))
2022-07-13 00:39:42 +01:00
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 )
2024-01-12 13:23:06 +00:00
State.cursor1 . pos = new_screen_line_starting_pos + Text.nearest_cursor_pos ( State.font , s , State.cursor_x , State.left ) - 1
2022-07-13 00:39:42 +01:00
--? print('cursor pos is now', State.cursor1.line, State.cursor1.pos)
2022-06-05 15:59:44 +01:00
if scroll_down then
2022-05-29 06:36:05 +01:00
--? print('scroll up preserving cursor')
2022-07-13 04:59:24 +01:00
Text.snap_cursor_to_bottom_of_screen ( State )
2022-07-13 00:39:42 +01:00
--? print('screen top after:', State.screen_top1.line, State.screen_top1.pos)
2022-05-29 06:36:05 +01:00
end
end
2024-06-11 14:58:07 +01:00
--? print('=>', State.cursor1.line, State.cursor1.pos, State.screen_top1.line, State.screen_top1.pos)
2022-05-29 06:36:05 +01:00
end
2022-07-13 00:39:42 +01:00
function Text . start_of_line ( State )
State.cursor1 . pos = 1
if Text.lt1 ( State.cursor1 , State.screen_top1 ) then
State.screen_top1 = { line = State.cursor1 . line , pos = State.cursor1 . pos } -- copy
2022-06-29 02:48:59 +01:00
end
end
2022-07-13 04:59:24 +01:00
function Text . end_of_line ( State )
2022-07-13 00:39:42 +01:00
State.cursor1 . pos = utf8.len ( State.lines [ State.cursor1 . line ] . data ) + 1
2022-08-17 17:36:17 +01:00
if Text.cursor_out_of_screen ( State ) then
2022-07-13 04:59:24 +01:00
Text.snap_cursor_to_bottom_of_screen ( State )
2022-06-29 02:48:59 +01:00
end
end
2022-07-13 04:59:24 +01:00
function Text . word_left ( State )
2022-07-12 03:18:54 +01:00
-- skip some whitespace
2022-05-29 06:36:05 +01:00
while true do
2022-07-13 00:39:42 +01:00
if State.cursor1 . pos == 1 then
2022-07-12 03:18:54 +01:00
break
end
2022-07-13 00:39:42 +01:00
if Text.match ( State.lines [ State.cursor1 . line ] . data , State.cursor1 . pos - 1 , ' %S ' ) then
2022-07-12 03:18:54 +01:00
break
end
2022-07-13 04:59:24 +01:00
Text.left ( State )
2022-07-12 03:18:54 +01:00
end
-- skip some non-whitespace
while true do
2022-07-13 04:59:24 +01:00
Text.left ( State )
2022-07-13 00:39:42 +01:00
if State.cursor1 . pos == 1 then
2022-07-12 03:18:54 +01:00
break
end
2023-11-18 19:30:57 +00:00
assert ( State.cursor1 . pos > 1 , ' bumped up against start of line ' )
2022-07-13 00:39:42 +01:00
if Text.match ( State.lines [ State.cursor1 . line ] . data , State.cursor1 . pos - 1 , ' %s ' ) then
2022-05-29 06:36:05 +01:00
break
end
end
end
2022-07-13 04:59:24 +01:00
function Text . word_right ( State )
2022-07-12 03:18:54 +01:00
-- skip some whitespace
2022-05-29 06:36:05 +01:00
while true do
2022-07-13 00:39:42 +01:00
if State.cursor1 . pos > utf8.len ( State.lines [ State.cursor1 . line ] . data ) then
2022-07-12 03:18:54 +01:00
break
end
2022-07-13 00:39:42 +01:00
if Text.match ( State.lines [ State.cursor1 . line ] . data , State.cursor1 . pos , ' %S ' ) then
2022-07-12 03:18:54 +01:00
break
end
2022-07-13 01:10:11 +01:00
Text.right_without_scroll ( State )
2022-07-12 03:18:54 +01:00
end
while true do
2022-07-13 01:10:11 +01:00
Text.right_without_scroll ( State )
2022-07-13 00:39:42 +01:00
if State.cursor1 . pos > utf8.len ( State.lines [ State.cursor1 . line ] . data ) then
2022-07-12 03:18:54 +01:00
break
end
2022-07-13 00:39:42 +01:00
if Text.match ( State.lines [ State.cursor1 . line ] . data , State.cursor1 . pos , ' %s ' ) then
2022-05-29 06:36:05 +01:00
break
end
2022-05-18 06:36:10 +01:00
end
2022-08-17 17:36:17 +01:00
if Text.cursor_out_of_screen ( State ) then
2022-07-13 04:59:24 +01:00
Text.snap_cursor_to_bottom_of_screen ( State )
2022-07-05 19:27:41 +01:00
end
2022-05-18 06:36:10 +01:00
end
2022-07-12 02:56:19 +01:00
function Text . match ( s , pos , pat )
local start_offset = Text.offset ( s , pos )
local end_offset = Text.offset ( s , pos + 1 )
2023-11-18 19:30:57 +00:00
assert ( end_offset > start_offset , ( ' end_offset %d not > start_offset %d ' ) : format ( end_offset , start_offset ) )
2022-07-12 02:56:19 +01:00
local curr = s : sub ( start_offset , end_offset - 1 )
return curr : match ( pat )
end
2022-07-13 04:59:24 +01:00
function Text . left ( State )
2023-11-18 19:30:57 +00:00
assert ( State.lines [ State.cursor1 . line ] . mode == ' text ' , ' line is not text ' )
2022-07-13 01:10:11 +01:00
if State.cursor1 . pos > 1 then
State.cursor1 . pos = State.cursor1 . pos - 1
2022-05-25 23:25:10 +01:00
else
2022-07-13 01:10:11 +01:00
local new_cursor_line = State.cursor1 . line
2022-05-25 23:25:10 +01:00
while new_cursor_line > 1 do
new_cursor_line = new_cursor_line - 1
2022-07-13 01:10:11 +01:00
if State.lines [ new_cursor_line ] . mode == ' text ' then
2022-09-05 19:28:03 +01:00
State.cursor1 = {
line = new_cursor_line ,
pos = utf8.len ( State.lines [ new_cursor_line ] . data ) + 1 ,
}
2022-05-25 23:25:10 +01:00
break
end
end
2022-06-29 02:48:59 +01:00
end
2022-07-13 01:10:11 +01:00
if Text.lt1 ( State.cursor1 , State.screen_top1 ) then
2023-03-18 04:52:35 +00:00
State.screen_top1 = {
line = State.cursor1 . line ,
pos = Text.pos_at_start_of_screen_line ( State , State.cursor1 ) ,
}
Text.redraw_all ( State ) -- if we're scrolling, reclaim all fragments to avoid memory leaks
2022-05-25 23:25:10 +01:00
end
end
2022-07-13 04:59:24 +01:00
function Text . right ( State )
2022-07-13 01:10:11 +01:00
Text.right_without_scroll ( State )
2022-08-17 17:36:17 +01:00
if Text.cursor_out_of_screen ( State ) then
2022-07-13 04:59:24 +01:00
Text.snap_cursor_to_bottom_of_screen ( State )
2022-07-05 19:27:41 +01:00
end
end
2022-07-13 01:10:11 +01:00
function Text . right_without_scroll ( State )
2023-11-18 19:30:57 +00:00
assert ( State.lines [ State.cursor1 . line ] . mode == ' text ' , ' line is not text ' )
2022-07-13 01:10:11 +01:00
if State.cursor1 . pos <= utf8.len ( State.lines [ State.cursor1 . line ] . data ) then
State.cursor1 . pos = State.cursor1 . pos + 1
2022-05-25 23:25:10 +01:00
else
2022-07-13 01:10:11 +01:00
local new_cursor_line = State.cursor1 . line
while new_cursor_line <= # State.lines - 1 do
2022-05-25 23:25:10 +01:00
new_cursor_line = new_cursor_line + 1
2022-07-13 01:10:11 +01:00
if State.lines [ new_cursor_line ] . mode == ' text ' then
2022-09-05 19:28:03 +01:00
State.cursor1 = { line = new_cursor_line , pos = 1 }
2022-05-25 23:25:10 +01:00
break
end
end
2022-06-29 02:48:59 +01:00
end
2022-05-25 23:25:10 +01:00
end
2023-06-04 20:20:24 +01:00
-- result: pos, index of screen line
2022-08-18 18:22:48 +01:00
function Text . pos_at_start_of_screen_line ( State , loc1 )
Text.populate_screen_line_starting_pos ( State , loc1.line )
local line_cache = State.line_cache [ loc1.line ]
for i =# line_cache.screen_line_starting_pos , 1 , - 1 do
local spos = line_cache.screen_line_starting_pos [ i ]
if spos <= loc1.pos then
2022-08-17 17:10:52 +01:00
return spos , i
2022-05-21 00:41:21 +01:00
end
end
2023-11-18 19:30:57 +00:00
assert ( false , ( ' invalid pos %d ' ) : format ( loc1.pos ) )
2022-05-21 00:41:21 +01:00
end
2023-06-04 20:20:24 +01:00
function Text . pos_at_end_of_screen_line ( State , loc1 )
fix a crash involving mouse and drawings
Thanks Alex Schroeder for reporting this crash. The scenario:
* Edit a file like say this repo's Readme.
* The second line is empty and there's a '+' to insert a drawing.
Click on that.
* Resize the window so just the first line of text and the drawing are
visible.
* Close the window.
* Reopen lines.love, it will reopen the same file.
* Click on the left margin to the left of the drawing.
Before this commit these steps yielded the following crash:
Error: bad argument #1 to 'len' (string expected, got nil)
text.lua:626: in function 'pos_at_end_of_screen_line'
edit.lua:298: in function 'mouse_press'
There were two distinct problems here:
1. State.screen_bottom1 is not required to point to a text line, it
could just as well be a drawing. I have been sloppy in handling that.
2. The bug was partially masked (the need to close and reopen the
window) by a second bug: inserting a drawing was not invalidating the
cache I save of starty coordinates for each line. (I've inserted and
deleted starty invalidations a few times in the past, but it looks
like I'd never had one in this particular location edit.draw before.)
How did these issues get missed for years?
- Even though I use lines.love on a daily basis, it turns out I don't
actually create line drawings all that often.
- When I do, I'm still living in files that are mostly text with only
an occasional drawing.
- I keep my windows fairly large.
Between these 3 patterns, the odds of running into a drawing as the
first or bottom-most line on the screen were fairly small. And then I
had to interact with it. I suspect I tend to interact with drawings
after centering them vertically.
---
Bug #1 in particular has some interesting past history.
* Near the start of the project, when I implemented line-wrapping I
started saving screen_bottom, the bottom-most line displayed on
screen. I did this so I could scroll down easily just by assigning
`screen_top = screen_bottom`. (On the other hand, scrolling up still
required some work. I should perhaps get rid of it and just compute
scrolls from scratch each time.)
* Also near the start of the project, I supported selecting text by a
complex state machine spanning keypress, mouse press and mouse
release:
mouse click (press and immediate release) moves cursor
mouse drag (press and much later release) creates selection
shift-click selects from current cursor to click location
shift-movement creates/grows a selection
* On 2023-06-01, inscript reported a bug. Opening a window with just a
little bit of text (lots of unused space in the window), selecting all
the text and then clicking below all the text would crash the editor.
To fix this I added code at the bottom of edit.mouse_press which
computed the final visible line+pos location and used that in the
cursor-move/text-selection state machine. It did this computation
based on.. screen_bottom. But I didn't notice that screen_bottom could
be a drawing (which has no pos). This commit's bug/regression was
created.
* On 2023-09-20, Matt Wynne encountered a crash which got me to realize
I need code at the bottom of edit.mouse_release symmetric to the code
at the bottom of edit.mouse_press. I still didn't notice that
screen_bottom could be a drawing.
So in fixing inscript's bug report, I introduced (at least) 2
regressions, because I either had no idea or quickly forgot that
screen_bottom could point at a drawing.
While I created regressions, the underlying mental bug feels new. I just
never focused on the fact that screen_bottom could point at a drawing.
This past history makes me suspicious of my mouse_press/mouse_release
code. I think I'm going to get rid of screen_bottom entirely as a
concept. I'll still have to be careful though about the remaining
locations and which of them are allowed to point at drawings:
- cursor and selection are not allowed to point at drawings
- screen_top and screen_bottom are allowed to point at drawings
I sometimes copy between these 4 location variables. Auditing shows no
gaps where cursor could ever end up pointing at a drawing. It's just
when I started using screen_bottom for a whole new purpose (in
the mouse_press/release state machine) that I went wrong.
I should also try getting rid of starty entirely. Is it _really_ needed
for a responsive editor? I think I introduced it back when I didn't know
what I was doing with LÖVE and was profligately creating text objects
willy-nilly just to compute widths.
Getting rid of these two fairly global bits of mutable state will
hopefully make lines much more robust when the next person tries it out
in 6 months :-/ X-(
Thanks everyone for the conversation around this bug:
https://merveilles.town/@akkartik/112567862542495637
---
Bug #2 has some complexity as well, and might lead to some follow-on
cleanup.
When I click on the button to insert a new drawing, the mouse_release
hook triggers and moves the cursor below the new drawing. This is
desirable, but I'd never noticed this happy accident. It stops working
when I invalidate starty for all lines (which gets recomputed and cached
for all visible lines on every frame).
Fixing this caused a couple of unit tests start crashing for 2 reasons
that required their own minor fixes:
- My emulated mouse press and release didn't have an intervening
frame and so mouse_release no longer receives starty. Now I've added
a call to edit.draw() between press and release.
This might actually bite someone for real someday, if they're
running on a slow computer or something like that. I've tried to
click really fast but I can't seem to put mouse_press and release in
the same frame (assuming 30 frames per second)
- My tests' window dimensions often violate my constraint that the
screen always have one line of text for showing the cursor. They're
unrealistically small or have a really wide aspect ratio (width 2x
of height). I suspect lines.love will itself crash in those
situations, but hopefully they're unrealistic. Hmm, I wonder what
would happen if someone maximized in a 16:9 screen, that's almost
2x.. Anyways, I've cleaned a couple of tests up, but might need to
fix up others at some point. I'd have to rejigger all my brittle
line-wrapping tests if I modify the screen width :-/ X-(
2024-06-09 21:17:55 +01:00
assert ( State.lines [ loc1.line ] . mode == ' text ' )
2023-06-04 20:20:24 +01:00
Text.populate_screen_line_starting_pos ( State , loc1.line )
local line_cache = State.line_cache [ loc1.line ]
local most_recent_final_pos = utf8.len ( State.lines [ loc1.line ] . data ) + 1
for i =# line_cache.screen_line_starting_pos , 1 , - 1 do
local spos = line_cache.screen_line_starting_pos [ i ]
if spos <= loc1.pos then
return most_recent_final_pos
end
most_recent_final_pos = spos - 1
end
2023-11-18 19:30:57 +00:00
assert ( false , ( ' invalid pos %d ' ) : format ( loc1.pos ) )
2023-06-04 20:20:24 +01:00
end
fix a crash involving mouse and drawings
Thanks Alex Schroeder for reporting this crash. The scenario:
* Edit a file like say this repo's Readme.
* The second line is empty and there's a '+' to insert a drawing.
Click on that.
* Resize the window so just the first line of text and the drawing are
visible.
* Close the window.
* Reopen lines.love, it will reopen the same file.
* Click on the left margin to the left of the drawing.
Before this commit these steps yielded the following crash:
Error: bad argument #1 to 'len' (string expected, got nil)
text.lua:626: in function 'pos_at_end_of_screen_line'
edit.lua:298: in function 'mouse_press'
There were two distinct problems here:
1. State.screen_bottom1 is not required to point to a text line, it
could just as well be a drawing. I have been sloppy in handling that.
2. The bug was partially masked (the need to close and reopen the
window) by a second bug: inserting a drawing was not invalidating the
cache I save of starty coordinates for each line. (I've inserted and
deleted starty invalidations a few times in the past, but it looks
like I'd never had one in this particular location edit.draw before.)
How did these issues get missed for years?
- Even though I use lines.love on a daily basis, it turns out I don't
actually create line drawings all that often.
- When I do, I'm still living in files that are mostly text with only
an occasional drawing.
- I keep my windows fairly large.
Between these 3 patterns, the odds of running into a drawing as the
first or bottom-most line on the screen were fairly small. And then I
had to interact with it. I suspect I tend to interact with drawings
after centering them vertically.
---
Bug #1 in particular has some interesting past history.
* Near the start of the project, when I implemented line-wrapping I
started saving screen_bottom, the bottom-most line displayed on
screen. I did this so I could scroll down easily just by assigning
`screen_top = screen_bottom`. (On the other hand, scrolling up still
required some work. I should perhaps get rid of it and just compute
scrolls from scratch each time.)
* Also near the start of the project, I supported selecting text by a
complex state machine spanning keypress, mouse press and mouse
release:
mouse click (press and immediate release) moves cursor
mouse drag (press and much later release) creates selection
shift-click selects from current cursor to click location
shift-movement creates/grows a selection
* On 2023-06-01, inscript reported a bug. Opening a window with just a
little bit of text (lots of unused space in the window), selecting all
the text and then clicking below all the text would crash the editor.
To fix this I added code at the bottom of edit.mouse_press which
computed the final visible line+pos location and used that in the
cursor-move/text-selection state machine. It did this computation
based on.. screen_bottom. But I didn't notice that screen_bottom could
be a drawing (which has no pos). This commit's bug/regression was
created.
* On 2023-09-20, Matt Wynne encountered a crash which got me to realize
I need code at the bottom of edit.mouse_release symmetric to the code
at the bottom of edit.mouse_press. I still didn't notice that
screen_bottom could be a drawing.
So in fixing inscript's bug report, I introduced (at least) 2
regressions, because I either had no idea or quickly forgot that
screen_bottom could point at a drawing.
While I created regressions, the underlying mental bug feels new. I just
never focused on the fact that screen_bottom could point at a drawing.
This past history makes me suspicious of my mouse_press/mouse_release
code. I think I'm going to get rid of screen_bottom entirely as a
concept. I'll still have to be careful though about the remaining
locations and which of them are allowed to point at drawings:
- cursor and selection are not allowed to point at drawings
- screen_top and screen_bottom are allowed to point at drawings
I sometimes copy between these 4 location variables. Auditing shows no
gaps where cursor could ever end up pointing at a drawing. It's just
when I started using screen_bottom for a whole new purpose (in
the mouse_press/release state machine) that I went wrong.
I should also try getting rid of starty entirely. Is it _really_ needed
for a responsive editor? I think I introduced it back when I didn't know
what I was doing with LÖVE and was profligately creating text objects
willy-nilly just to compute widths.
Getting rid of these two fairly global bits of mutable state will
hopefully make lines much more robust when the next person tries it out
in 6 months :-/ X-(
Thanks everyone for the conversation around this bug:
https://merveilles.town/@akkartik/112567862542495637
---
Bug #2 has some complexity as well, and might lead to some follow-on
cleanup.
When I click on the button to insert a new drawing, the mouse_release
hook triggers and moves the cursor below the new drawing. This is
desirable, but I'd never noticed this happy accident. It stops working
when I invalidate starty for all lines (which gets recomputed and cached
for all visible lines on every frame).
Fixing this caused a couple of unit tests start crashing for 2 reasons
that required their own minor fixes:
- My emulated mouse press and release didn't have an intervening
frame and so mouse_release no longer receives starty. Now I've added
a call to edit.draw() between press and release.
This might actually bite someone for real someday, if they're
running on a slow computer or something like that. I've tried to
click really fast but I can't seem to put mouse_press and release in
the same frame (assuming 30 frames per second)
- My tests' window dimensions often violate my constraint that the
screen always have one line of text for showing the cursor. They're
unrealistically small or have a really wide aspect ratio (width 2x
of height). I suspect lines.love will itself crash in those
situations, but hopefully they're unrealistic. Hmm, I wonder what
would happen if someone maximized in a 16:9 screen, that's almost
2x.. Anyways, I've cleaned a couple of tests up, but might need to
fix up others at some point. I'd have to rejigger all my brittle
line-wrapping tests if I modify the screen width :-/ X-(
2024-06-09 21:17:55 +01:00
function Text . final_text_loc_on_screen ( State )
2024-06-11 14:58:07 +01:00
local screen_bottom1 = Text.screen_bottom1 ( State )
if State.lines [ screen_bottom1.line ] . mode == ' text ' then
fix a crash involving mouse and drawings
Thanks Alex Schroeder for reporting this crash. The scenario:
* Edit a file like say this repo's Readme.
* The second line is empty and there's a '+' to insert a drawing.
Click on that.
* Resize the window so just the first line of text and the drawing are
visible.
* Close the window.
* Reopen lines.love, it will reopen the same file.
* Click on the left margin to the left of the drawing.
Before this commit these steps yielded the following crash:
Error: bad argument #1 to 'len' (string expected, got nil)
text.lua:626: in function 'pos_at_end_of_screen_line'
edit.lua:298: in function 'mouse_press'
There were two distinct problems here:
1. State.screen_bottom1 is not required to point to a text line, it
could just as well be a drawing. I have been sloppy in handling that.
2. The bug was partially masked (the need to close and reopen the
window) by a second bug: inserting a drawing was not invalidating the
cache I save of starty coordinates for each line. (I've inserted and
deleted starty invalidations a few times in the past, but it looks
like I'd never had one in this particular location edit.draw before.)
How did these issues get missed for years?
- Even though I use lines.love on a daily basis, it turns out I don't
actually create line drawings all that often.
- When I do, I'm still living in files that are mostly text with only
an occasional drawing.
- I keep my windows fairly large.
Between these 3 patterns, the odds of running into a drawing as the
first or bottom-most line on the screen were fairly small. And then I
had to interact with it. I suspect I tend to interact with drawings
after centering them vertically.
---
Bug #1 in particular has some interesting past history.
* Near the start of the project, when I implemented line-wrapping I
started saving screen_bottom, the bottom-most line displayed on
screen. I did this so I could scroll down easily just by assigning
`screen_top = screen_bottom`. (On the other hand, scrolling up still
required some work. I should perhaps get rid of it and just compute
scrolls from scratch each time.)
* Also near the start of the project, I supported selecting text by a
complex state machine spanning keypress, mouse press and mouse
release:
mouse click (press and immediate release) moves cursor
mouse drag (press and much later release) creates selection
shift-click selects from current cursor to click location
shift-movement creates/grows a selection
* On 2023-06-01, inscript reported a bug. Opening a window with just a
little bit of text (lots of unused space in the window), selecting all
the text and then clicking below all the text would crash the editor.
To fix this I added code at the bottom of edit.mouse_press which
computed the final visible line+pos location and used that in the
cursor-move/text-selection state machine. It did this computation
based on.. screen_bottom. But I didn't notice that screen_bottom could
be a drawing (which has no pos). This commit's bug/regression was
created.
* On 2023-09-20, Matt Wynne encountered a crash which got me to realize
I need code at the bottom of edit.mouse_release symmetric to the code
at the bottom of edit.mouse_press. I still didn't notice that
screen_bottom could be a drawing.
So in fixing inscript's bug report, I introduced (at least) 2
regressions, because I either had no idea or quickly forgot that
screen_bottom could point at a drawing.
While I created regressions, the underlying mental bug feels new. I just
never focused on the fact that screen_bottom could point at a drawing.
This past history makes me suspicious of my mouse_press/mouse_release
code. I think I'm going to get rid of screen_bottom entirely as a
concept. I'll still have to be careful though about the remaining
locations and which of them are allowed to point at drawings:
- cursor and selection are not allowed to point at drawings
- screen_top and screen_bottom are allowed to point at drawings
I sometimes copy between these 4 location variables. Auditing shows no
gaps where cursor could ever end up pointing at a drawing. It's just
when I started using screen_bottom for a whole new purpose (in
the mouse_press/release state machine) that I went wrong.
I should also try getting rid of starty entirely. Is it _really_ needed
for a responsive editor? I think I introduced it back when I didn't know
what I was doing with LÖVE and was profligately creating text objects
willy-nilly just to compute widths.
Getting rid of these two fairly global bits of mutable state will
hopefully make lines much more robust when the next person tries it out
in 6 months :-/ X-(
Thanks everyone for the conversation around this bug:
https://merveilles.town/@akkartik/112567862542495637
---
Bug #2 has some complexity as well, and might lead to some follow-on
cleanup.
When I click on the button to insert a new drawing, the mouse_release
hook triggers and moves the cursor below the new drawing. This is
desirable, but I'd never noticed this happy accident. It stops working
when I invalidate starty for all lines (which gets recomputed and cached
for all visible lines on every frame).
Fixing this caused a couple of unit tests start crashing for 2 reasons
that required their own minor fixes:
- My emulated mouse press and release didn't have an intervening
frame and so mouse_release no longer receives starty. Now I've added
a call to edit.draw() between press and release.
This might actually bite someone for real someday, if they're
running on a slow computer or something like that. I've tried to
click really fast but I can't seem to put mouse_press and release in
the same frame (assuming 30 frames per second)
- My tests' window dimensions often violate my constraint that the
screen always have one line of text for showing the cursor. They're
unrealistically small or have a really wide aspect ratio (width 2x
of height). I suspect lines.love will itself crash in those
situations, but hopefully they're unrealistic. Hmm, I wonder what
would happen if someone maximized in a 16:9 screen, that's almost
2x.. Anyways, I've cleaned a couple of tests up, but might need to
fix up others at some point. I'd have to rejigger all my brittle
line-wrapping tests if I modify the screen width :-/ X-(
2024-06-09 21:17:55 +01:00
return {
2024-06-11 14:58:07 +01:00
line = screen_bottom1.line ,
pos = Text.pos_at_end_of_screen_line ( State , screen_bottom1 ) ,
fix a crash involving mouse and drawings
Thanks Alex Schroeder for reporting this crash. The scenario:
* Edit a file like say this repo's Readme.
* The second line is empty and there's a '+' to insert a drawing.
Click on that.
* Resize the window so just the first line of text and the drawing are
visible.
* Close the window.
* Reopen lines.love, it will reopen the same file.
* Click on the left margin to the left of the drawing.
Before this commit these steps yielded the following crash:
Error: bad argument #1 to 'len' (string expected, got nil)
text.lua:626: in function 'pos_at_end_of_screen_line'
edit.lua:298: in function 'mouse_press'
There were two distinct problems here:
1. State.screen_bottom1 is not required to point to a text line, it
could just as well be a drawing. I have been sloppy in handling that.
2. The bug was partially masked (the need to close and reopen the
window) by a second bug: inserting a drawing was not invalidating the
cache I save of starty coordinates for each line. (I've inserted and
deleted starty invalidations a few times in the past, but it looks
like I'd never had one in this particular location edit.draw before.)
How did these issues get missed for years?
- Even though I use lines.love on a daily basis, it turns out I don't
actually create line drawings all that often.
- When I do, I'm still living in files that are mostly text with only
an occasional drawing.
- I keep my windows fairly large.
Between these 3 patterns, the odds of running into a drawing as the
first or bottom-most line on the screen were fairly small. And then I
had to interact with it. I suspect I tend to interact with drawings
after centering them vertically.
---
Bug #1 in particular has some interesting past history.
* Near the start of the project, when I implemented line-wrapping I
started saving screen_bottom, the bottom-most line displayed on
screen. I did this so I could scroll down easily just by assigning
`screen_top = screen_bottom`. (On the other hand, scrolling up still
required some work. I should perhaps get rid of it and just compute
scrolls from scratch each time.)
* Also near the start of the project, I supported selecting text by a
complex state machine spanning keypress, mouse press and mouse
release:
mouse click (press and immediate release) moves cursor
mouse drag (press and much later release) creates selection
shift-click selects from current cursor to click location
shift-movement creates/grows a selection
* On 2023-06-01, inscript reported a bug. Opening a window with just a
little bit of text (lots of unused space in the window), selecting all
the text and then clicking below all the text would crash the editor.
To fix this I added code at the bottom of edit.mouse_press which
computed the final visible line+pos location and used that in the
cursor-move/text-selection state machine. It did this computation
based on.. screen_bottom. But I didn't notice that screen_bottom could
be a drawing (which has no pos). This commit's bug/regression was
created.
* On 2023-09-20, Matt Wynne encountered a crash which got me to realize
I need code at the bottom of edit.mouse_release symmetric to the code
at the bottom of edit.mouse_press. I still didn't notice that
screen_bottom could be a drawing.
So in fixing inscript's bug report, I introduced (at least) 2
regressions, because I either had no idea or quickly forgot that
screen_bottom could point at a drawing.
While I created regressions, the underlying mental bug feels new. I just
never focused on the fact that screen_bottom could point at a drawing.
This past history makes me suspicious of my mouse_press/mouse_release
code. I think I'm going to get rid of screen_bottom entirely as a
concept. I'll still have to be careful though about the remaining
locations and which of them are allowed to point at drawings:
- cursor and selection are not allowed to point at drawings
- screen_top and screen_bottom are allowed to point at drawings
I sometimes copy between these 4 location variables. Auditing shows no
gaps where cursor could ever end up pointing at a drawing. It's just
when I started using screen_bottom for a whole new purpose (in
the mouse_press/release state machine) that I went wrong.
I should also try getting rid of starty entirely. Is it _really_ needed
for a responsive editor? I think I introduced it back when I didn't know
what I was doing with LÖVE and was profligately creating text objects
willy-nilly just to compute widths.
Getting rid of these two fairly global bits of mutable state will
hopefully make lines much more robust when the next person tries it out
in 6 months :-/ X-(
Thanks everyone for the conversation around this bug:
https://merveilles.town/@akkartik/112567862542495637
---
Bug #2 has some complexity as well, and might lead to some follow-on
cleanup.
When I click on the button to insert a new drawing, the mouse_release
hook triggers and moves the cursor below the new drawing. This is
desirable, but I'd never noticed this happy accident. It stops working
when I invalidate starty for all lines (which gets recomputed and cached
for all visible lines on every frame).
Fixing this caused a couple of unit tests start crashing for 2 reasons
that required their own minor fixes:
- My emulated mouse press and release didn't have an intervening
frame and so mouse_release no longer receives starty. Now I've added
a call to edit.draw() between press and release.
This might actually bite someone for real someday, if they're
running on a slow computer or something like that. I've tried to
click really fast but I can't seem to put mouse_press and release in
the same frame (assuming 30 frames per second)
- My tests' window dimensions often violate my constraint that the
screen always have one line of text for showing the cursor. They're
unrealistically small or have a really wide aspect ratio (width 2x
of height). I suspect lines.love will itself crash in those
situations, but hopefully they're unrealistic. Hmm, I wonder what
would happen if someone maximized in a 16:9 screen, that's almost
2x.. Anyways, I've cleaned a couple of tests up, but might need to
fix up others at some point. I'd have to rejigger all my brittle
line-wrapping tests if I modify the screen width :-/ X-(
2024-06-09 21:17:55 +01:00
}
end
2024-06-11 14:58:07 +01:00
local loc2 = Text.to2 ( State , screen_bottom1 )
fix a crash involving mouse and drawings
Thanks Alex Schroeder for reporting this crash. The scenario:
* Edit a file like say this repo's Readme.
* The second line is empty and there's a '+' to insert a drawing.
Click on that.
* Resize the window so just the first line of text and the drawing are
visible.
* Close the window.
* Reopen lines.love, it will reopen the same file.
* Click on the left margin to the left of the drawing.
Before this commit these steps yielded the following crash:
Error: bad argument #1 to 'len' (string expected, got nil)
text.lua:626: in function 'pos_at_end_of_screen_line'
edit.lua:298: in function 'mouse_press'
There were two distinct problems here:
1. State.screen_bottom1 is not required to point to a text line, it
could just as well be a drawing. I have been sloppy in handling that.
2. The bug was partially masked (the need to close and reopen the
window) by a second bug: inserting a drawing was not invalidating the
cache I save of starty coordinates for each line. (I've inserted and
deleted starty invalidations a few times in the past, but it looks
like I'd never had one in this particular location edit.draw before.)
How did these issues get missed for years?
- Even though I use lines.love on a daily basis, it turns out I don't
actually create line drawings all that often.
- When I do, I'm still living in files that are mostly text with only
an occasional drawing.
- I keep my windows fairly large.
Between these 3 patterns, the odds of running into a drawing as the
first or bottom-most line on the screen were fairly small. And then I
had to interact with it. I suspect I tend to interact with drawings
after centering them vertically.
---
Bug #1 in particular has some interesting past history.
* Near the start of the project, when I implemented line-wrapping I
started saving screen_bottom, the bottom-most line displayed on
screen. I did this so I could scroll down easily just by assigning
`screen_top = screen_bottom`. (On the other hand, scrolling up still
required some work. I should perhaps get rid of it and just compute
scrolls from scratch each time.)
* Also near the start of the project, I supported selecting text by a
complex state machine spanning keypress, mouse press and mouse
release:
mouse click (press and immediate release) moves cursor
mouse drag (press and much later release) creates selection
shift-click selects from current cursor to click location
shift-movement creates/grows a selection
* On 2023-06-01, inscript reported a bug. Opening a window with just a
little bit of text (lots of unused space in the window), selecting all
the text and then clicking below all the text would crash the editor.
To fix this I added code at the bottom of edit.mouse_press which
computed the final visible line+pos location and used that in the
cursor-move/text-selection state machine. It did this computation
based on.. screen_bottom. But I didn't notice that screen_bottom could
be a drawing (which has no pos). This commit's bug/regression was
created.
* On 2023-09-20, Matt Wynne encountered a crash which got me to realize
I need code at the bottom of edit.mouse_release symmetric to the code
at the bottom of edit.mouse_press. I still didn't notice that
screen_bottom could be a drawing.
So in fixing inscript's bug report, I introduced (at least) 2
regressions, because I either had no idea or quickly forgot that
screen_bottom could point at a drawing.
While I created regressions, the underlying mental bug feels new. I just
never focused on the fact that screen_bottom could point at a drawing.
This past history makes me suspicious of my mouse_press/mouse_release
code. I think I'm going to get rid of screen_bottom entirely as a
concept. I'll still have to be careful though about the remaining
locations and which of them are allowed to point at drawings:
- cursor and selection are not allowed to point at drawings
- screen_top and screen_bottom are allowed to point at drawings
I sometimes copy between these 4 location variables. Auditing shows no
gaps where cursor could ever end up pointing at a drawing. It's just
when I started using screen_bottom for a whole new purpose (in
the mouse_press/release state machine) that I went wrong.
I should also try getting rid of starty entirely. Is it _really_ needed
for a responsive editor? I think I introduced it back when I didn't know
what I was doing with LÖVE and was profligately creating text objects
willy-nilly just to compute widths.
Getting rid of these two fairly global bits of mutable state will
hopefully make lines much more robust when the next person tries it out
in 6 months :-/ X-(
Thanks everyone for the conversation around this bug:
https://merveilles.town/@akkartik/112567862542495637
---
Bug #2 has some complexity as well, and might lead to some follow-on
cleanup.
When I click on the button to insert a new drawing, the mouse_release
hook triggers and moves the cursor below the new drawing. This is
desirable, but I'd never noticed this happy accident. It stops working
when I invalidate starty for all lines (which gets recomputed and cached
for all visible lines on every frame).
Fixing this caused a couple of unit tests start crashing for 2 reasons
that required their own minor fixes:
- My emulated mouse press and release didn't have an intervening
frame and so mouse_release no longer receives starty. Now I've added
a call to edit.draw() between press and release.
This might actually bite someone for real someday, if they're
running on a slow computer or something like that. I've tried to
click really fast but I can't seem to put mouse_press and release in
the same frame (assuming 30 frames per second)
- My tests' window dimensions often violate my constraint that the
screen always have one line of text for showing the cursor. They're
unrealistically small or have a really wide aspect ratio (width 2x
of height). I suspect lines.love will itself crash in those
situations, but hopefully they're unrealistic. Hmm, I wonder what
would happen if someone maximized in a 16:9 screen, that's almost
2x.. Anyways, I've cleaned a couple of tests up, but might need to
fix up others at some point. I'd have to rejigger all my brittle
line-wrapping tests if I modify the screen width :-/ X-(
2024-06-09 21:17:55 +01:00
while true do
if State.lines [ loc2.line ] . mode == ' text ' then break end
assert ( loc2.line > 1 or loc2.screen_line > 1 and loc2.screen_pos > 1 ) -- elsewhere we're making sure there's always at least one text line on screen
loc2 = Text.previous_screen_line ( State , loc2 )
end
local result = Text.to1 ( State , loc2 )
result.pos = Text.pos_at_end_of_screen_line ( State , result )
return result
end
2022-07-13 04:59:24 +01:00
function Text . cursor_at_final_screen_line ( State )
2022-07-17 17:10:33 +01:00
Text.populate_screen_line_starting_pos ( State , State.cursor1 . line )
2022-07-21 00:34:09 +01:00
local screen_lines = State.line_cache [ State.cursor1 . line ] . screen_line_starting_pos
2022-07-13 01:24:01 +01:00
--? print(screen_lines[#screen_lines], State.cursor1.pos)
return screen_lines [ # screen_lines ] <= State.cursor1 . pos
2022-05-21 04:33:30 +01:00
end
2022-07-13 04:59:24 +01:00
function Text . move_cursor_down_to_next_text_line_while_scrolling_again_if_necessary ( State )
2022-07-13 02:29:00 +01:00
local y = State.top
2022-07-13 01:24:01 +01:00
while State.cursor1 . line <= # State.lines do
if State.lines [ State.cursor1 . line ] . mode == ' text ' then
2022-05-19 02:19:27 +01:00
break
end
2022-07-13 01:24:01 +01:00
--? print('cursor skips', State.cursor1.line)
2022-07-16 16:48:02 +01:00
y = y + Drawing_padding_height + Drawing.pixels ( State.lines [ State.cursor1 . line ] . h , State.width )
2022-07-13 01:24:01 +01:00
State.cursor1 . line = State.cursor1 . line + 1
2022-05-19 02:19:27 +01:00
end
2023-04-20 05:53:11 +01:00
if State.cursor1 . pos == nil then
State.cursor1 . pos = 1
end
2022-05-19 02:19:27 +01:00
-- hack: insert a text line at bottom of file if necessary
2022-07-13 01:24:01 +01:00
if State.cursor1 . line > # State.lines then
2023-11-18 19:30:57 +00:00
assert ( State.cursor1 . line == # State.lines + 1 , ' tried to ensure bottom line of file is text, but failed ' )
2022-07-13 01:24:01 +01:00
table.insert ( State.lines , { mode = ' text ' , data = ' ' } )
2022-07-21 00:34:09 +01:00
table.insert ( State.line_cache , { } )
2022-05-19 02:19:27 +01:00
end
2022-07-13 01:24:01 +01:00
--? print(y, App.screen.height, App.screen.height-State.line_height)
if y > App.screen . height - State.line_height then
2022-05-23 23:38:42 +01:00
--? print('scroll up')
2022-07-13 04:59:24 +01:00
Text.snap_cursor_to_bottom_of_screen ( State )
2022-05-19 02:19:27 +01:00
end
end
2022-07-13 01:24:01 +01:00
-- should never modify State.cursor1
2022-07-13 04:59:24 +01:00
function Text . snap_cursor_to_bottom_of_screen ( State )
2022-09-05 19:28:03 +01:00
--? print('to2:', State.cursor1.line, State.cursor1.pos)
2022-07-13 04:59:24 +01:00
local top2 = Text.to2 ( State , State.cursor1 )
2022-09-05 19:28:03 +01:00
--? print('to2: =>', top2.line, top2.screen_line, top2.screen_pos)
-- slide to start of screen line
2022-06-05 17:50:19 +01:00
top2.screen_pos = 1 -- start of screen line
2024-06-11 14:58:07 +01:00
--? print('snap', State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos)
2022-07-13 01:24:01 +01:00
--? print('cursor pos '..tostring(State.cursor1.pos)..' is on the #'..tostring(top2.screen_line)..' screen line down')
local y = App.screen . height - State.line_height
2022-05-21 06:43:09 +01:00
-- duplicate some logic from love.draw
2022-05-19 02:19:27 +01:00
while true do
2022-05-22 07:02:04 +01:00
--? print(y, 'top2:', top2.line, top2.screen_line, top2.screen_pos)
if top2.line == 1 and top2.screen_line == 1 then break end
2022-07-13 01:24:01 +01:00
if top2.screen_line > 1 or State.lines [ top2.line - 1 ] . mode == ' text ' then
local h = State.line_height
2022-07-13 02:29:00 +01:00
if y - h < State.top then
2022-05-22 07:02:04 +01:00
break
end
y = y - h
2022-05-21 06:43:09 +01:00
else
2023-11-18 19:30:57 +00:00
assert ( top2.line > 1 , ' tried to snap cursor to buttom of screen but failed ' )
assert ( State.lines [ top2.line - 1 ] . mode == ' drawing ' , " expected a drawing but it's not " )
2022-05-22 07:02:04 +01:00
-- We currently can't draw partial drawings, so either skip it entirely
-- or not at all.
2022-07-16 16:48:02 +01:00
local h = Drawing_padding_height + Drawing.pixels ( State.lines [ top2.line - 1 ] . h , State.width )
2022-07-13 02:29:00 +01:00
if y - h < State.top then
2022-05-22 07:02:04 +01:00
break
end
--? print('skipping drawing of height', h)
y = y - h
2022-05-19 02:19:27 +01:00
end
2022-07-13 04:59:24 +01:00
top2 = Text.previous_screen_line ( State , top2 )
2022-05-19 02:19:27 +01:00
end
2022-05-22 07:02:04 +01:00
--? print('top2 finally:', top2.line, top2.screen_line, top2.screen_pos)
2022-07-13 01:24:01 +01:00
State.screen_top1 = Text.to1 ( State , top2 )
--? print('top1 finally:', State.screen_top1.line, State.screen_top1.pos)
2024-06-11 14:58:07 +01:00
--? print('snap =>', State.screen_top1.line, State.screen_top1.pos, State.cursor1.line, State.cursor1.pos)
2022-07-13 01:24:01 +01:00
Text.redraw_all ( State ) -- if we're scrolling, reclaim all fragments to avoid memory leaks
2022-05-19 02:19:27 +01:00
end
2022-07-17 17:05:50 +01:00
function Text . in_line ( State , line_index , x , y )
local line = State.lines [ line_index ]
2022-07-21 00:34:09 +01:00
local line_cache = State.line_cache [ line_index ]
2024-06-11 18:37:58 +01:00
local starty = Text.starty ( State , line_index )
if starty == nil then return false end -- outside current page
if y < starty then return false end
2022-07-17 17:10:33 +01:00
Text.populate_screen_line_starting_pos ( State , line_index )
2024-06-11 18:37:58 +01:00
return y < starty + State.line_height * ( # line_cache.screen_line_starting_pos - Text.screen_line_index ( line_cache.screen_line_starting_pos , line_cache.startpos ) + 1 )
2022-05-18 06:53:09 +01:00
end
2022-06-03 21:22:03 +01:00
-- convert mx,my in pixels to schema-1 coordinates
2022-07-17 17:19:53 +01:00
function Text . to_pos_on_line ( State , line_index , mx , my )
local line = State.lines [ line_index ]
2022-07-21 00:34:09 +01:00
local line_cache = State.line_cache [ line_index ]
2024-06-11 18:37:58 +01:00
local starty = Text.starty ( State , line_index )
assert ( my >= starty , ' failed to map y pixel to line ' )
2022-05-20 06:07:12 +01:00
-- duplicate some logic from Text.draw
2024-06-11 18:37:58 +01:00
local y = starty
2022-07-18 05:05:01 +01:00
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 ]
2022-07-01 02:00:09 +01:00
local screen_line_starting_byte_offset = Text.offset ( line.data , screen_line_starting_pos )
2022-06-14 16:15:51 +01:00
--? print('iter', y, screen_line_index, screen_line_starting_pos, string.sub(line.data, screen_line_starting_byte_offset))
2022-07-13 01:24:01 +01:00
local nexty = y + State.line_height
2022-05-20 06:07:12 +01:00
if my < nexty then
2022-05-20 06:26:15 +01:00
-- 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.)
2022-07-18 06:15:49 +01:00
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
2022-06-14 01:23:21 +01:00
--? print('past end of non-final line; return')
2024-02-08 10:23:56 +00:00
return line_cache.screen_line_starting_pos [ screen_line_index + 1 ]
2022-05-20 06:26:15 +01:00
end
2022-06-14 01:23:21 +01:00
local s = string.sub ( line.data , screen_line_starting_byte_offset )
2024-01-12 13:23:06 +00:00
--? print('return', mx, Text.nearest_cursor_pos(State.font, s, mx, State.left), '=>', screen_line_starting_pos + Text.nearest_cursor_pos(State.font, s, mx, State.left) - 1)
return screen_line_starting_pos + Text.nearest_cursor_pos ( State.font , s , mx , State.left ) - 1
2022-05-20 06:07:12 +01:00
end
y = nexty
end
2023-11-18 19:30:57 +00:00
assert ( false , ' failed to map y pixel to line ' )
2022-05-18 06:53:09 +01:00
end
2022-07-17 17:37:50 +01:00
function Text . screen_line_width ( State , line_index , i )
local line = State.lines [ line_index ]
2022-07-21 00:34:09 +01:00
local line_cache = State.line_cache [ line_index ]
2022-07-18 05:05:01 +01:00
local start_pos = line_cache.screen_line_starting_pos [ i ]
2022-06-29 17:30:23 +01:00
local start_offset = Text.offset ( line.data , start_pos )
local screen_line
2022-07-18 05:05:01 +01:00
if i < # line_cache.screen_line_starting_pos then
local past_end_pos = line_cache.screen_line_starting_pos [ i + 1 ]
2022-06-29 17:30:23 +01:00
local past_end_offset = Text.offset ( line.data , past_end_pos )
screen_line = string.sub ( line.data , start_offset , past_end_offset - 1 )
else
screen_line = string.sub ( line.data , start_pos )
end
2024-01-12 13:23:06 +00:00
return State.font : getWidth ( screen_line )
2022-06-29 17:30:23 +01:00
end
2022-07-17 17:21:57 +01:00
function Text . screen_line_index ( screen_line_starting_pos , pos )
for i = # screen_line_starting_pos , 1 , - 1 do
if screen_line_starting_pos [ i ] <= pos then
2022-07-01 02:00:09 +01:00
return i
end
end
end
2022-07-09 00:11:30 +01:00
-- convert x pixel coordinate to pos
-- oblivious to wrapping
2022-07-20 15:50:33 +01:00
-- result: 1 to len+1
2024-01-12 13:23:06 +00:00
function Text . nearest_cursor_pos ( font , line , x , left )
2022-07-29 22:38:45 +01:00
if x < left then
2022-05-18 04:29:08 +01:00
return 1
end
2022-05-20 01:46:02 +01:00
local len = utf8.len ( line )
2024-01-12 13:23:06 +00:00
local max_x = left + Text.x ( font , line , len + 1 )
2022-05-18 04:29:08 +01:00
if x > max_x then
2022-05-20 01:46:02 +01:00
return len + 1
2022-05-18 04:29:08 +01:00
end
2022-07-08 22:18:23 +01:00
local leftpos , rightpos = 1 , len + 1
2022-05-24 22:34:50 +01:00
--? print('-- nearest', x)
2022-05-20 05:52:38 +01:00
while true do
2022-07-08 22:18:23 +01:00
--? print('nearest', x, '^'..line..'$', leftpos, rightpos)
if leftpos == rightpos then
return leftpos
2022-05-24 22:34:50 +01:00
end
2022-07-08 22:18:23 +01:00
local curr = math.floor ( ( leftpos + rightpos ) / 2 )
2024-01-12 13:23:06 +00:00
local currxmin = left + Text.x ( font , line , curr )
local currxmax = left + Text.x ( font , line , curr + 1 )
2022-07-08 22:18:23 +01:00
--? print('nearest', x, leftpos, rightpos, curr, currxmin, currxmax)
2022-05-18 04:29:08 +01:00
if currxmin <= x and x < currxmax then
2022-05-25 23:08:37 +01:00
if x - currxmin < currxmax - x then
return curr
else
return curr + 1
end
2022-05-18 04:29:08 +01:00
end
2022-07-08 22:18:23 +01:00
if leftpos >= rightpos - 1 then
return rightpos
2022-05-20 05:52:38 +01:00
end
2022-05-18 04:29:08 +01:00
if currxmin > x then
2022-07-08 22:18:23 +01:00
rightpos = curr
2022-05-18 04:29:08 +01:00
else
2022-07-08 22:18:23 +01:00
leftpos = curr
2022-05-18 04:29:08 +01:00
end
end
2023-11-18 19:30:57 +00:00
assert ( false , ' failed to map x pixel to pos ' )
2022-05-18 04:29:08 +01:00
end
2022-07-20 00:49:08 +01:00
-- return the nearest index of line (in utf8 code points) which lies entirely
-- within x pixels of the left margin
2022-07-20 15:50:33 +01:00
-- result: 0 to len+1
2024-01-12 13:23:06 +00:00
function Text . nearest_pos_less_than ( font , line , x )
2022-07-20 15:00:39 +01:00
--? print('', '-- nearest_pos_less_than', line, x)
2022-05-23 23:22:16 +01:00
local len = utf8.len ( line )
2024-01-12 13:23:06 +00:00
local max_x = Text.x_after ( font , line , len )
2022-05-23 23:22:16 +01:00
if x > max_x then
return len + 1
end
2022-07-20 15:08:28 +01:00
local left , right = 0 , len + 1
2022-05-23 23:22:16 +01:00
while true do
local curr = math.floor ( ( left + right ) / 2 )
2024-01-12 13:23:06 +00:00
local currxmin = Text.x_after ( font , line , curr + 1 )
local currxmax = Text.x_after ( font , line , curr + 2 )
2022-07-20 15:00:39 +01:00
--? print('', x, left, right, curr, currxmin, currxmax)
2022-05-23 23:22:16 +01:00
if currxmin <= x and x < currxmax then
return curr
end
if left >= right - 1 then
return left
end
if currxmin > x then
right = curr
else
left = curr
end
end
2023-11-18 19:30:57 +00:00
assert ( false , ' failed to map x pixel to pos ' )
2022-05-23 23:22:16 +01:00
end
2024-01-12 13:23:06 +00:00
function Text . x_after ( font , s , pos )
2023-12-26 19:19:23 +00:00
local len = utf8.len ( s )
local offset = Text.offset ( s , math.min ( pos + 1 , len + 1 ) )
2022-07-20 00:49:08 +01:00
local s_before = s : sub ( 1 , offset - 1 )
--? print('^'..s_before..'$')
2024-01-12 13:23:06 +00:00
return font : getWidth ( s_before )
2022-07-20 00:49:08 +01:00
end
2024-01-12 13:23:06 +00:00
function Text . x ( font , s , pos )
2022-07-20 17:11:29 +01:00
local offset = Text.offset ( s , pos )
local s_before = s : sub ( 1 , offset - 1 )
2024-01-12 13:23:06 +00:00
return font : getWidth ( s_before )
2022-07-20 17:11:29 +01:00
end
2022-08-12 03:34:18 +01:00
function Text . to2 ( State , loc1 )
if State.lines [ loc1.line ] . mode == ' drawing ' then
return { line = loc1.line , screen_line = 1 , screen_pos = 1 }
end
2022-09-05 19:28:03 +01:00
local result = { line = loc1.line }
2022-08-18 17:51:43 +01:00
local line_cache = State.line_cache [ loc1.line ]
2022-08-12 03:34:18 +01:00
Text.populate_screen_line_starting_pos ( State , loc1.line )
2022-08-18 17:51:43 +01:00
for i =# line_cache.screen_line_starting_pos , 1 , - 1 do
local spos = line_cache.screen_line_starting_pos [ i ]
2022-08-12 03:34:18 +01:00
if spos <= loc1.pos then
2022-06-10 22:52:49 +01:00
result.screen_line = i
2022-08-12 03:34:18 +01:00
result.screen_pos = loc1.pos - spos + 1
2022-06-10 22:52:49 +01:00
break
2022-05-22 00:24:07 +01:00
end
end
2023-11-18 19:30:57 +00:00
assert ( result.screen_pos , ' failed to convert schema-1 coordinate to schema-2 ' )
2022-05-22 00:24:07 +01:00
return result
end
2022-08-12 03:34:18 +01:00
function Text . to1 ( State , loc2 )
local result = { line = loc2.line , pos = loc2.screen_pos }
if loc2.screen_line > 1 then
result.pos = State.line_cache [ loc2.line ] . screen_line_starting_pos [ loc2.screen_line ] + loc2.screen_pos - 1
2022-05-22 00:24:07 +01:00
end
return result
end
2022-06-03 16:11:18 +01:00
function Text . eq1 ( a , b )
return a.line == b.line and a.pos == b.pos
end
2022-05-29 07:11:53 +01:00
function Text . lt1 ( a , b )
if a.line < b.line then
return true
end
if a.line > b.line then
return false
end
return a.pos < b.pos
end
function Text . le1 ( a , b )
if a.line < b.line then
return true
end
if a.line > b.line then
return false
end
return a.pos <= b.pos
end
2024-06-11 14:58:07 +01:00
function Text . eq2 ( a , b )
return a.line == b.line and a.screen_line == b.screen_line and a.screen_pos == b.screen_pos
end
2022-06-19 17:03:09 +01:00
function Text . offset ( s , pos1 )
if pos1 == 1 then return 1 end
local result = utf8.offset ( s , pos1 )
if result == nil then
2023-12-09 17:22:45 +00:00
assert ( false , ( ' Text.offset(%d) called on a string of length %d (byte size %d); this is likely a failure to handle utf8 \n \n ^%s$ \n ' ) : format ( pos1 , utf8.len ( s ) , # s , s ) )
2022-06-19 17:03:09 +01:00
end
return result
end
2022-08-12 03:34:18 +01:00
function Text . previous_screen_line ( State , loc2 )
if loc2.screen_line > 1 then
return { line = loc2.line , screen_line = loc2.screen_line - 1 , screen_pos = 1 }
elseif loc2.line == 1 then
return loc2
elseif State.lines [ loc2.line - 1 ] . mode == ' drawing ' then
return { line = loc2.line - 1 , screen_line = 1 , screen_pos = 1 }
2022-05-22 07:02:04 +01:00
else
2022-08-12 03:34:18 +01:00
local l = State.lines [ loc2.line - 1 ]
Text.populate_screen_line_starting_pos ( State , loc2.line - 1 )
return { line = loc2.line - 1 , screen_line =# State.line_cache [ loc2.line - 1 ] . screen_line_starting_pos , screen_pos = 1 }
2022-05-22 07:02:04 +01:00
end
end
2024-06-11 14:58:07 +01:00
function Text . next_screen_line ( State , loc2 )
if State.lines [ loc2.line ] . mode == ' drawing ' then
return { line = loc2.line + 1 , screen_line = 1 , screen_pos = 1 }
end
Text.populate_screen_line_starting_pos ( State , loc2.line )
if loc2.screen_line >= # State.line_cache [ loc2.line ] . screen_line_starting_pos then
if loc2.line < # State.lines then
return { line = loc2.line + 1 , screen_line = 1 , screen_pos = 1 }
else
return loc2
end
else
return { line = loc2.line , screen_line = loc2.screen_line + 1 , screen_pos = 1 }
end
end
2022-07-13 01:24:01 +01:00
-- resize helper
2022-07-13 04:59:24 +01:00
function Text . tweak_screen_top_and_cursor ( State )
2022-07-13 01:24:01 +01:00
if State.screen_top1 . pos == 1 then return end
2022-07-17 17:10:33 +01:00
Text.populate_screen_line_starting_pos ( State , State.screen_top1 . line )
2022-07-13 01:24:01 +01:00
local line = State.lines [ State.screen_top1 . line ]
2022-07-21 00:34:09 +01:00
local line_cache = State.line_cache [ State.screen_top1 . line ]
2022-07-18 05:05:01 +01:00
for i = 2 , # line_cache.screen_line_starting_pos do
local pos = line_cache.screen_line_starting_pos [ i ]
2022-07-13 01:24:01 +01:00
if pos == State.screen_top1 . pos then
2022-07-01 18:30:52 +01:00
break
end
2022-07-13 01:24:01 +01:00
if pos > State.screen_top1 . pos then
2022-07-01 18:30:52 +01:00
-- make sure screen top is at start of a screen line
2022-07-18 05:05:01 +01:00
local prev = line_cache.screen_line_starting_pos [ i - 1 ]
2022-07-13 01:24:01 +01:00
if State.screen_top1 . pos - prev < pos - State.screen_top1 . pos then
State.screen_top1 . pos = prev
2022-07-01 18:30:52 +01:00
else
2022-07-13 01:24:01 +01:00
State.screen_top1 . pos = pos
2022-07-01 18:30:52 +01:00
end
break
end
end
-- make sure cursor is on screen
2024-06-11 14:58:07 +01:00
local screen_bottom1 = Text.screen_bottom1 ( State )
2022-07-13 01:24:01 +01:00
if Text.lt1 ( State.cursor1 , State.screen_top1 ) then
State.cursor1 = { line = State.screen_top1 . line , pos = State.screen_top1 . pos }
2024-06-11 14:58:07 +01:00
elseif State.cursor1 . line >= screen_bottom1.line then
2022-08-17 17:36:17 +01:00
if Text.cursor_out_of_screen ( State ) then
2024-06-11 14:58:07 +01:00
State.cursor1 = Text.final_text_loc_on_screen ( State )
2022-07-01 18:30:52 +01:00
end
end
end
2022-07-05 19:24:08 +01:00
-- slightly expensive since it redraws the screen
2022-08-17 17:36:17 +01:00
function Text . cursor_out_of_screen ( State )
2023-04-03 01:24:02 +01:00
edit.draw ( State )
2022-08-17 17:36:17 +01:00
return State.cursor_y == nil
2022-07-05 19:24:08 +01:00
end
2022-07-13 01:24:01 +01:00
function Text . redraw_all ( State )
2022-06-10 22:52:49 +01:00
--? print('clearing fragments')
2023-11-25 03:16:33 +00:00
-- Perform some early sanity checking here, in hopes that we correctly call
-- this whenever we change editor state.
if State.right <= State.left then
assert ( false , ( ' Right margin %d must be to the right of the left margin %d ' ) : format ( State.right , State.left ) )
end
2022-07-21 00:34:09 +01:00
State.line_cache = { }
2022-07-18 05:05:01 +01:00
for i = 1 , # State.lines do
2022-07-21 00:34:09 +01:00
State.line_cache [ i ] = { }
2022-06-03 07:36:07 +01:00
end
end
2022-07-17 16:18:48 +01:00
function Text . clear_screen_line_cache ( State , line_index )
2022-07-21 00:34:09 +01:00
State.line_cache [ line_index ] . screen_line_starting_pos = nil
2022-06-23 19:09:49 +01:00
end
2022-08-23 23:06:18 +01:00
function trim ( s )
return s : gsub ( ' ^%s+ ' , ' ' ) : gsub ( ' %s+$ ' , ' ' )
end
function ltrim ( s )
return s : gsub ( ' ^%s+ ' , ' ' )
end
function rtrim ( s )
return s : gsub ( ' %s+$ ' , ' ' )
end
2023-01-13 17:10:48 +00:00
function starts_with ( s , prefix )
if # s < # prefix then
return false
end
for i = 1 , # prefix do
if s : sub ( i , i ) ~= prefix : sub ( i , i ) then
return false
end
end
return true
end
function ends_with ( s , suffix )
if # s < # suffix then
return false
end
for i = 0 , # suffix - 1 do
if s : sub ( # s - i , # s - i ) ~= suffix : sub ( # suffix - i , # suffix - i ) then
return false
end
end
return true
end