akkartik/pong.love - Change 6PCE7VUWEE5UVSE3ZZSQAMGUJDDHOBNO2MVD6POUWFP7UY7WOZHAC

delete all selection code for now

Too hard to think about selection alongside bifold text at the moment.

Created by Kartik K. Agaram on August 18, 2022

6PCE7VUWEE5UVSE3ZZSQAMGUJDDHOBNO2MVD6POUWFP7UY7WOZHAC

Dependencies

In channels

main

Change contents

Deletion in text_tests.lua at line 257 [10.2]

∅:D[8.164] → [9.7564:7687]

B:BD[9.7564] → [9.7564:7687]

  check_nil(Editor_state.selection1.line, 'F - test_click_with_mouse/selection is empty to avoid perturbing future edits')

Deletion in text_tests.lua at line 275 [10.2]

B:BD[11.810] → [11.810:949]

  check_nil(Editor_state.selection1.line, 'F - test_click_with_mouse_to_left_of_line/selection is empty to avoid perturbing future edits')

Deletion in text_tests.lua at line 294 [10.2]

∅:D[12.109] → [8.1064:1214]

∅:D[13.109] → [8.1064:1214]

B:BD[8.1064] → [8.1064:1214]

  check_nil(Editor_state.selection1.line, 'F - test_click_with_mouse_takes_margins_into_account/selection is empty to avoid perturbing future edits')

Deletion in text_tests.lua at line 383 [10.2]

∅:D[12.207] → [8.2039:2179]

∅:D[13.207] → [8.2039:2179]

B:BD[8.2039] → [8.2039:2179]

  check_nil(Editor_state.selection1.line, 'F - test_click_with_mouse_on_wrapping_line/selection is empty to avoid perturbing future edits')

Deletion in text_tests.lua at line 402 [10.2]

∅:D[12.332] → [8.3165:3332]

∅:D[13.332] → [8.3165:3332]

B:BD[8.3165] → [8.3165:3332]

  check_nil(Editor_state.selection1.line, 'F - test_click_with_mouse_on_wrapping_line_takes_margins_into_account/selection is empty to avoid perturbing future edits')

Deletion in text_tests.lua at line 558 [10.2]

∅:D[14.927] → [15.2:96]

∅:D[9.12765] → [15.2:96]

B:BD[16.1122] → [15.2:96]

B:BD[15.96] → [17.302:341]

B:BD[17.341] → [18.1506:1552]

∅:D[18.1552] → [9.12766:12811]

∅:D[19.4039] → [9.12766:12811]

B:BD[17.341] → [9.12766:12811]

B:BD[9.12811] → [20.1689:1721]

∅:D[20.1721] → [9.12897:13018]

B:BD[9.12897] → [9.12897:13018]

B:BD[9.13018] → [21.853:879]

∅:D[22.466] → [15.280:332]

∅:D[21.879] → [15.280:332]

B:BD[15.280] → [15.280:332]

B:BD[15.332] → [23.1548:1599]

∅:D[23.1599] → [15.368:401]

B:BD[15.368] → [15.368:401]

B:BD[15.401] → [24.2:46]

∅:D[24.46] → [15.429:482]

B:BD[15.429] → [15.429:482]

B:BD[15.482] → [9.13019:13335]

∅:D[9.13335] → [25.2:190]

B:BD[15.746] → [25.2:190]

B:BD[25.190] → [17.342:381]

B:BD[17.381] → [18.1553:1599]

∅:D[18.1599] → [9.13336:13377]

∅:D[19.4144] → [9.13336:13377]

B:BD[17.381] → [9.13336:13377]

B:BD[9.13377] → [20.1722:1754]

∅:D[20.1754] → [9.13463:13628]

B:BD[9.13463] → [9.13463:13628]

B:BD[9.13628] → [21.880:906]

∅:D[22.481] → [25.401:439]

∅:D[21.906] → [25.401:439]

B:BD[25.401] → [25.401:439]

B:BD[25.439] → [23.1600:1649]

∅:D[23.1649] → [25.473:516]

B:BD[25.473] → [25.473:516]

B:BD[25.516] → [9.13629:13730]

B:BD[9.13730] → [26.83:193]

end
function test_select_text()
  io.write('\ntest_select_text')
  -- display a line of text
  App.screen.init{width=75, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc def'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- select a letter
  App.fake_key_press('lshift')
  edit.run_after_keychord(Editor_state, 'S-right')
  App.fake_key_release('lshift')
  edit.key_released(Editor_state, 'lshift')
  -- selection persists even after shift is released
  check_eq(Editor_state.selection1.line, 1, 'F - test_select_text/selection:line')
  check_eq(Editor_state.selection1.pos, 1, 'F - test_select_text/selection:pos')
  check_eq(Editor_state.cursor1.line, 1, 'F - test_select_text/cursor:line')
  check_eq(Editor_state.cursor1.pos, 2, 'F - test_select_text/cursor:pos')
end
function test_cursor_movement_without_shift_resets_selection()
  io.write('\ntest_cursor_movement_without_shift_resets_selection')
  -- display a line of text with some part selected
  App.screen.init{width=75, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.selection1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- press an arrow key without shift
  edit.run_after_keychord(Editor_state, 'right')
  -- no change to data, selection is reset
  check_nil(Editor_state.selection1.line, 'F - test_cursor_movement_without_shift_resets_selection')
  check_eq(Editor_state.lines[1].data, 'abc', 'F - test_cursor_movement_without_shift_resets_selection/data')

Deletion in text_tests.lua at line 560 [10.2]

B:BD[16.1127] → [27.2:137]

B:BD[27.137] → [17.422:461]

B:BD[17.461] → [18.1600:1646]

∅:D[18.1646] → [9.13841:13882]

∅:D[19.4249] → [9.13841:13882]

B:BD[17.461] → [9.13841:13882]

B:BD[9.13882] → [20.1755:1787]

∅:D[20.1787] → [9.13968:14133]

B:BD[9.13968] → [9.13968:14133]

B:BD[9.14133] → [21.907:933]

∅:D[22.496] → [27.348:365]

∅:D[21.933] → [27.348:365]

B:BD[27.348] → [27.348:365]

B:BD[27.365] → [23.1650:1696]

∅:D[23.1696] → [27.396:452]

B:BD[27.396] → [27.396:452]

B:BD[27.452] → [26.194:275]

∅:D[28.231] → [29.2:172]

∅:D[26.275] → [29.2:172]

∅:D[9.14215] → [29.2:172]

B:BD[27.520] → [29.2:172]

B:BD[29.172] → [17.462:501]

B:BD[17.501] → [18.1647:1693]

∅:D[18.1693] → [9.14216:14257]

∅:D[19.4354] → [9.14216:14257]

B:BD[17.501] → [9.14216:14257]

B:BD[9.14257] → [20.1788:1820]

∅:D[20.1820] → [9.14343:14508]

B:BD[9.14343] → [9.14343:14508]

B:BD[9.14508] → [21.934:960]

∅:D[22.511] → [29.383:465]

∅:D[21.960] → [29.383:465]

B:BD[29.383] → [29.383:465]

B:BD[29.465] → [24.47:95]

B:BD[24.95] → [2.2:38]

∅:D[2.38] → [24.96:135]

B:BD[29.508] → [24.96:135]

∅:D[24.135] → [29.531:620]

B:BD[29.531] → [29.531:620]

B:BD[29.620] → [9.14509:14601]

B:BD[9.14601] → [26.276:377]

∅:D[28.328] → [30.2:149]

∅:D[26.377] → [30.2:149]

∅:D[29.787] → [30.2:149]

∅:D[9.14702] → [30.2:149]

B:BD[27.520] → [30.2:149]

B:BD[30.149] → [17.502:541]

B:BD[17.541] → [18.1694:1740]

∅:D[18.1740] → [9.14703:14744]

∅:D[19.4459] → [9.14703:14744]

B:BD[17.541] → [9.14703:14744]

B:BD[9.14744] → [20.1821:1853]

∅:D[20.1853] → [9.14830:14995]

B:BD[9.14830] → [9.14830:14995]

B:BD[9.14995] → [21.961:987]

∅:D[22.526] → [30.360:380]

∅:D[21.987] → [30.360:380]

B:BD[30.360] → [30.360:380]

B:BD[30.380] → [23.1697:1744]

∅:D[23.1744] → [30.412:550]

B:BD[30.412] → [30.412:550]

B:BD[30.550] → [9.14996:15076]

∅:D[9.15076] → [31.2:104]

B:BD[30.617] → [31.2:104]

B:BD[31.104] → [17.542:581]

B:BD[17.581] → [18.1741:1787]

∅:D[18.1787] → [9.15077:15118]

∅:D[19.4564] → [9.15077:15118]

B:BD[17.581] → [9.15077:15118]

B:BD[9.15118] → [20.1854:1886]

∅:D[20.1886] → [9.15204:15369]

B:BD[9.15204] → [9.15204:15369]

B:BD[9.15369] → [21.988:1014]

∅:D[22.541] → [31.315:332]

∅:D[21.1014] → [31.315:332]

B:BD[31.315] → [31.315:332]

B:BD[31.332] → [23.1745:1792]

∅:D[23.1792] → [31.364:451]

B:BD[31.364] → [31.364:451]

B:BD[31.451] → [26.378:444]

∅:D[28.390] → [31.504:641]

∅:D[26.444] → [31.504:641]

∅:D[9.15436] → [31.504:641]

B:BD[31.504] → [31.504:641]

B:BD[31.641] → [17.582:621]

B:BD[17.621] → [18.1788:1834]

∅:D[18.1834] → [9.15437:15485]

∅:D[19.4669] → [9.15437:15485]

B:BD[17.621] → [9.15437:15485]

B:BD[9.15485] → [20.1887:1919]

∅:D[20.1919] → [9.15571:15736]

B:BD[9.15571] → [9.15571:15736]

B:BD[9.15736] → [21.1015:1041]

∅:D[22.556] → [31.859:923]

∅:D[21.1041] → [31.859:923]

B:BD[31.859] → [31.859:923]

B:BD[31.923] → [23.1793:1840]

∅:D[23.1840] → [31.955:1068]

B:BD[31.955] → [31.955:1068]

B:BD[31.1068] → [26.445:531]

∅:D[28.472] → [27.520:525]

∅:D[26.531] → [27.520:525]

∅:D[30.617] → [27.520:525]

∅:D[31.1141] → [27.520:525]

∅:D[9.15823] → [27.520:525]

B:BD[27.520] → [27.520:525]

B:BD[27.525] → [32.2:164]

B:BD[32.164] → [18.1835:1881]

∅:D[18.1881] → [9.15824:15886]

∅:D[19.4774] → [9.15824:15886]

B:BD[32.164] → [9.15824:15886]

B:BD[9.15886] → [20.1920:1952]

∅:D[20.1952] → [9.15972:16093]

B:BD[9.15972] → [9.15972:16093]

B:BD[9.16093] → [21.1042:1068]

B:BD[21.1068] → [19.4775:4804]

∅:D[19.4804] → [32.363:452]

∅:D[9.16130] → [32.363:452]

B:BD[32.363] → [32.363:452]

B:BD[32.452] → [9.16131:16166]

∅:D[9.16166] → [32.474:563]

B:BD[32.474] → [32.474:563]

B:BD[32.563] → [9.16167:16202]

∅:D[9.16202] → [32.585:742]

B:BD[32.585] → [32.585:742]

B:BD[32.742] → [9.16203:16247]

∅:D[9.16247] → [32.773:795]

B:BD[32.773] → [32.773:795]

B:BD[32.795] → [23.1841:1894]

∅:D[23.1894] → [32.833:854]

B:BD[32.833] → [32.833:854]

B:BD[32.854] → [9.16248:16335]

B:BD[9.16335] → [26.532:625]

∅:D[28.561] → [32.1008:1013]

∅:D[26.625] → [32.1008:1013]

∅:D[9.16428] → [32.1008:1013]

B:BD[32.1008] → [32.1008:1013]

function test_edit_deletes_selection()
  io.write('\ntest_edit_deletes_selection')
  -- display a line of text with some part selected
  App.screen.init{width=75, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.selection1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- press a key
  edit.run_after_textinput(Editor_state, 'x')
  -- selected text is deleted and replaced with the key
  check_eq(Editor_state.lines[1].data, 'xbc', 'F - test_edit_deletes_selection')
end
function test_edit_with_shift_key_deletes_selection()
  io.write('\ntest_edit_with_shift_key_deletes_selection')
  -- display a line of text with some part selected
  App.screen.init{width=75, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.selection1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- mimic precise keypresses for a capital letter
  App.fake_key_press('lshift')
  edit.keychord_pressed(Editor_state, 'd', 'd')
  edit.textinput(Editor_state, 'D')
  edit.key_released(Editor_state, 'd')
  App.fake_key_release('lshift')
  -- selected text is deleted and replaced with the key
  check_nil(Editor_state.selection1.line, 'F - test_edit_with_shift_key_deletes_selection')
  check_eq(Editor_state.lines[1].data, 'Dbc', 'F - test_edit_with_shift_key_deletes_selection/data')
end
function test_copy_does_not_reset_selection()
  io.write('\ntest_copy_does_not_reset_selection')
  -- display a line of text with a selection
  App.screen.init{width=75, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.selection1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- copy selection
  edit.run_after_keychord(Editor_state, 'C-c')
  check_eq(App.clipboard, 'a', 'F - test_copy_does_not_reset_selection/clipboard')
  -- selection is reset since shift key is not pressed
  check(Editor_state.selection1.line, 'F - test_copy_does_not_reset_selection')
end
function test_cut()
  io.write('\ntest_cut')
  -- display a line of text with some part selected
  App.screen.init{width=75, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.selection1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- press a key
  edit.run_after_keychord(Editor_state, 'C-x')
  check_eq(App.clipboard, 'a', 'F - test_cut/clipboard')
  -- selected text is deleted
  check_eq(Editor_state.lines[1].data, 'bc', 'F - test_cut/data')
end
function test_paste_replaces_selection()
  io.write('\ntest_paste_replaces_selection')
  -- display a line of text with a selection
  App.screen.init{width=75, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  Editor_state.selection1 = {line=1, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- set clipboard
  App.clipboard = 'xyz'
  -- paste selection
  edit.run_after_keychord(Editor_state, 'C-v')
  -- selection is reset since shift key is not pressed
  -- selection includes the newline, so it's also deleted
  check_eq(Editor_state.lines[1].data, 'xyzdef', 'F - test_paste_replaces_selection')
end
function test_deleting_selection_may_scroll()
  io.write('\ntest_deleting_selection_may_scroll')
  -- display lines 2/3/4
  App.screen.init{width=120, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=3, pos=2}
  Editor_state.screen_top1 = {line=2, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  local y = Editor_state.top
  App.screen.check(y, 'def', 'F - test_deleting_selection_may_scroll/baseline/screen:1')
  y = y + Editor_state.line_height
  App.screen.check(y, 'ghi', 'F - test_deleting_selection_may_scroll/baseline/screen:2')
  y = y + Editor_state.line_height
  App.screen.check(y, 'jkl', 'F - test_deleting_selection_may_scroll/baseline/screen:3')
  -- set up a selection starting above the currently displayed page
  Editor_state.selection1 = {line=1, pos=2}
  -- delete selection
  edit.run_after_keychord(Editor_state, 'backspace')
  -- page scrolls up
  check_eq(Editor_state.screen_top1.line, 1, 'F - test_deleting_selection_may_scroll')
  check_eq(Editor_state.lines[1].data, 'ahi', 'F - test_deleting_selection_may_scroll/data')
end

Deletion in text_tests.lua at line 667 [10.2]
B:BD[9.19355] → [9.19355:19386]
```
  Editor_state.selection1 = {}
```

Replacement in text_tests.lua at line 668 [10.2]

∅:D[33.336] → [19.5639:5727]

B:BD[21.1232] → [19.5639:5727]

  edit.run_after_mouse_release(Editor_state, Editor_state.left+8,Editor_state.top+5, 1)

[33.336]

[9.19543]

  edit.run_after_mouse_press(Editor_state, Editor_state.left+8,Editor_state.top+5, 1)

Deletion in text_tests.lua at line 671 [10.2]

∅:D[12.420] → [9.19719:19903]

∅:D[13.420] → [9.19719:19903]

B:BD[9.19719] → [9.19719:19903]

∅:D[9.19903] → [34.179:308]

B:BD[34.179] → [34.179:308]

B:BD[34.308] → [18.2117:2163]

∅:D[18.2163] → [9.19904:19959]

∅:D[19.5832] → [9.19904:19959]

B:BD[34.308] → [9.19904:19959]

B:BD[9.19959] → [20.2118:2150]

∅:D[20.2150] → [9.20045:20197]

B:BD[9.20045] → [9.20045:20197]

B:BD[9.20197] → [33.337:432]

∅:D[33.432] → [35.2:40]

∅:D[22.732] → [35.2:40]

∅:D[21.1315] → [35.2:40]

∅:D[9.20267] → [35.2:40]

B:BD[34.581] → [35.2:40]

B:BD[35.40] → [19.5833:5919]

∅:D[36.141] → [35.107:144]

∅:D[37.260] → [35.107:144]

∅:D[38.339] → [35.107:144]

∅:D[23.2433] → [35.107:144]

∅:D[19.5919] → [35.107:144]

∅:D[9.20353] → [35.107:144]

B:BD[35.107] → [35.107:144]

B:BD[35.144] → [19.5920:6034]

∅:D[23.2562] → [9.20467:20562]

∅:D[19.6034] → [9.20467:20562]

B:BD[9.20467] → [9.20467:20562]

B:BD[9.20562] → [13.421:514]

∅:D[12.514] → [9.20655:20831]

∅:D[13.514] → [9.20655:20831]

B:BD[9.20655] → [9.20655:20831]

∅:D[39.152] → [35.538:687]

∅:D[9.20831] → [35.538:687]

B:BD[35.538] → [35.538:687]

B:BD[35.687] → [18.2164:2210]

∅:D[18.2210] → [9.20832:20887]

∅:D[19.6139] → [9.20832:20887]

B:BD[35.687] → [9.20832:20887]

B:BD[9.20887] → [20.2151:2183]

∅:D[20.2183] → [9.20973:21125]

B:BD[9.20973] → [9.20973:21125]

B:BD[9.21125] → [33.433:528]

∅:D[33.528] → [34.581:610]

∅:D[22.790] → [34.581:610]

∅:D[35.960] → [34.581:610]

∅:D[21.1398] → [34.581:610]

∅:D[9.21195] → [34.581:610]

B:BD[34.581] → [34.581:610]

B:BD[34.610] → [19.6140:6314]

∅:D[36.364] → [34.746:792]

∅:D[37.477] → [34.746:792]

∅:D[38.535] → [34.746:792]

∅:D[23.2765] → [34.746:792]

∅:D[19.6314] → [34.746:792]

∅:D[9.21368] → [34.746:792]

B:BD[34.746] → [34.746:792]

B:BD[34.792] → [36.365:396]

B:BD[36.396] → [19.6315:6516]

∅:D[37.626] → [36.548:581]

∅:D[38.670] → [36.548:581]

∅:D[23.2995] → [36.548:581]

∅:D[19.6516] → [36.548:581]

∅:D[9.21568] → [36.548:581]

B:BD[36.548] → [36.548:581]

B:BD[36.581] → [9.21569:21674]

B:BD[9.21674] → [13.515:618]

∅:D[12.618] → [9.21777:21973]

∅:D[13.618] → [9.21777:21973]

B:BD[9.21777] → [9.21777:21973]

∅:D[9.21973] → [40.2:173]

B:BD[39.323] → [40.2:173]

B:BD[40.173] → [18.2211:2257]

∅:D[18.2257] → [9.21974:22029]

∅:D[19.6621] → [9.21974:22029]

B:BD[40.173] → [9.21974:22029]

B:BD[9.22029] → [20.2184:2248]

∅:D[20.2248] → [9.22115:22267]

B:BD[9.22115] → [9.22115:22267]

B:BD[9.22267] → [33.529:624]

∅:D[33.624] → [40.446:475]

∅:D[22.848] → [40.446:475]

∅:D[21.1481] → [40.446:475]

∅:D[9.22337] → [40.446:475]

B:BD[40.446] → [40.446:475]

B:BD[40.475] → [19.6622:6796]

∅:D[36.720] → [40.611:663]

∅:D[37.761] → [40.611:663]

∅:D[38.791] → [40.611:663]

∅:D[23.3198] → [40.611:663]

∅:D[19.6796] → [40.611:663]

∅:D[9.22510] → [40.611:663]

B:BD[40.611] → [40.611:663]

B:BD[40.663] → [36.721:752]

B:BD[36.752] → [19.6797:6998]

∅:D[36.904] → [40.838:889]

∅:D[37.910] → [40.838:889]

∅:D[38.926] → [40.838:889]

∅:D[23.3428] → [40.838:889]

∅:D[19.6998] → [40.838:889]

∅:D[9.22710] → [40.838:889]

B:BD[40.838] → [40.838:889]

B:BD[40.889] → [36.905:936]

B:BD[36.936] → [19.6999:7199]

∅:D[37.1058] → [36.1087:1120]

∅:D[38.1060] → [36.1087:1120]

∅:D[23.3657] → [36.1087:1120]

∅:D[19.7199] → [36.1087:1120]

∅:D[9.22909] → [36.1087:1120]

B:BD[36.1087] → [36.1087:1120]

∅:D[36.1120] → [40.1090:1185]

B:BD[40.1090] → [40.1090:1185]

B:BD[40.1185] → [9.22910:23026]

B:BD[9.23026] → [13.619:733]

∅:D[12.733] → [9.23140:23250]

∅:D[13.733] → [9.23140:23250]

B:BD[9.23140] → [9.23140:23250]

B:BD[9.23250] → [13.734:842]

  check_nil(Editor_state.selection1.line, 'F - test_move_cursor_using_mouse/selection:line')
  check_nil(Editor_state.selection1.pos, 'F - test_move_cursor_using_mouse/selection:pos')
end
function test_select_text_using_mouse()
  io.write('\ntest_select_text_using_mouse')
  App.screen.init{width=50, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'xyz'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  Editor_state.selection1 = {}
  edit.draw(Editor_state)  -- populate line_cache.starty for each line Editor_state.line_cache
  -- press and hold on first location
  edit.run_after_mouse_press(Editor_state, Editor_state.left+8,Editor_state.top+5, 1)
  -- drag and release somewhere else
  edit.run_after_mouse_release(Editor_state, Editor_state.left+20,Editor_state.top+Editor_state.line_height+5, 1)
  check_eq(Editor_state.selection1.line, 1, 'F - test_select_text_using_mouse/selection:line')
  check_eq(Editor_state.selection1.pos, 2, 'F - test_select_text_using_mouse/selection:pos')
  check_eq(Editor_state.cursor1.line, 2, 'F - test_select_text_using_mouse/cursor:line')
  check_eq(Editor_state.cursor1.pos, 4, 'F - test_select_text_using_mouse/cursor:pos')
end
function test_select_text_using_mouse_and_shift()
  io.write('\ntest_select_text_using_mouse_and_shift')
  App.screen.init{width=50, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'xyz'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  Editor_state.selection1 = {}
  edit.draw(Editor_state)  -- populate line_cache.starty for each line Editor_state.line_cache
  -- click on first location
  edit.run_after_mouse_press(Editor_state, Editor_state.left+8,Editor_state.top+5, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+8,Editor_state.top+5, 1)
  -- hold down shift and click somewhere else
  App.fake_key_press('lshift')
  edit.run_after_mouse_press(Editor_state, Editor_state.left+20,Editor_state.top+5, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+20,Editor_state.top+Editor_state.line_height+5, 1)
  App.fake_key_release('lshift')
  check_eq(Editor_state.selection1.line, 1, 'F - test_select_text_using_mouse_and_shift/selection:line')
  check_eq(Editor_state.selection1.pos, 2, 'F - test_select_text_using_mouse_and_shift/selection:pos')
  check_eq(Editor_state.cursor1.line, 2, 'F - test_select_text_using_mouse_and_shift/cursor:line')
  check_eq(Editor_state.cursor1.pos, 4, 'F - test_select_text_using_mouse_and_shift/cursor:pos')
end
function test_select_text_repeatedly_using_mouse_and_shift()
  io.write('\ntest_select_text_repeatedly_using_mouse_and_shift')
  App.screen.init{width=50, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'xyz'}
  Text.redraw_all(Editor_state)
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  Editor_state.selection1 = {}
  edit.draw(Editor_state)  -- populate line_cache.starty for each line Editor_state.line_cache
  -- click on first location
  edit.run_after_mouse_press(Editor_state, Editor_state.left+8,Editor_state.top+5, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+8,Editor_state.top+5, 1)
  -- hold down shift and click on a second location
  App.fake_key_press('lshift')
  edit.run_after_mouse_press(Editor_state, Editor_state.left+20,Editor_state.top+5, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+20,Editor_state.top+Editor_state.line_height+5, 1)
  -- hold down shift and click at a third location
  App.fake_key_press('lshift')
  edit.run_after_mouse_press(Editor_state, Editor_state.left+20,Editor_state.top+5, 1)
  edit.run_after_mouse_release(Editor_state, Editor_state.left+8,Editor_state.top+Editor_state.line_height+5, 1)
  App.fake_key_release('lshift')
  -- selection is between first and third location. forget the second location, not the first.
  check_eq(Editor_state.selection1.line, 1, 'F - test_select_text_repeatedly_using_mouse_and_shift/selection:line')
  check_eq(Editor_state.selection1.pos, 2, 'F - test_select_text_repeatedly_using_mouse_and_shift/selection:pos')
  check_eq(Editor_state.cursor1.line, 2, 'F - test_select_text_repeatedly_using_mouse_and_shift/cursor:line')
  check_eq(Editor_state.cursor1.pos, 2, 'F - test_select_text_repeatedly_using_mouse_and_shift/cursor:pos')

Deletion in text_tests.lua at line 673 [10.2]

B:BD[10.6255] → [41.2:108]

B:BD[41.108] → [19.7200:7257]

B:BD[19.7257] → [18.2258:2304]

∅:D[18.2304] → [9.23423:23485]

∅:D[19.7361] → [9.23423:23485]

B:BD[9.23423] → [9.23423:23485]

B:BD[9.23485] → [20.2249:2281]

∅:D[20.2281] → [9.23571:23723]

B:BD[9.23571] → [9.23571:23723]

B:BD[9.23723] → [21.1482:1508]

∅:D[22.863] → [41.344:383]

∅:D[21.1508] → [41.344:383]

B:BD[41.344] → [41.344:383]

B:BD[41.383] → [23.3658:3705]

∅:D[23.3705] → [41.415:429]

B:BD[41.415] → [41.415:429]

B:BD[41.429] → [9.23724:23800]

∅:D[9.23800] → [41.492:497]

B:BD[41.492] → [41.492:497]

function test_cut_without_selection()
  io.write('\ntest_cut_without_selection')
  -- display a few lines
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  Editor_state.selection1 = {}
  edit.draw(Editor_state)
  -- try to cut without selecting text
  edit.run_after_keychord(Editor_state, 'C-x')
  -- no crash
  check_nil(Editor_state.selection1.line, 'F - test_cut_without_selection')
end

Replacement in text_tests.lua at line 1416 [10.2]

B:BD[10.33004] → [19.12469:12584]

  edit.run_after_mouse_release(Editor_state, Editor_state.left+8,Editor_state.top+Editor_state.line_height*2+5, 1)

[10.33004]

[10.33130]

  edit.run_after_mouse_press(Editor_state, Editor_state.left+8,Editor_state.top+Editor_state.line_height*2+5, 1)

Deletion in text_tests.lua at line 1493 [10.2]

B:BD[10.35926] → [10.35926:36235]

B:BD[10.36235] → [19.13330:13387]

B:BD[18.3806] → [18.3806:3852]

∅:D[18.3852] → [9.47317:47386]

∅:D[19.13595] → [9.47317:47386]

B:BD[9.47317] → [9.47317:47386]

B:BD[9.47386] → [20.3443:3475]

∅:D[20.3475] → [9.47472:47557]

B:BD[9.47472] → [9.47472:47557]

∅:D[9.47557] → [10.36424:36505]

B:BD[10.36424] → [10.36424:36505]

B:BD[10.36505] → [23.5519:5572]

B:BD[23.5572] → [26.909:996]

∅:D[28.912] → [10.36617:36661]

∅:D[26.996] → [10.36617:36661]

∅:D[9.47645] → [10.36617:36661]

B:BD[10.36617] → [10.36617:36661]

B:BD[10.36661] → [9.47646:47824]

∅:D[9.47824] → [10.36813:36839]

B:BD[10.36813] → [10.36813:36839]

B:BD[10.36839] → [9.47825:47914]

∅:D[9.47914] → [10.36915:37096]

B:BD[10.36915] → [10.36915:37096]

B:BD[10.37096] → [19.13596:13653]

B:BD[19.13653] → [18.3853:3899]

∅:D[18.3945] → [9.47979:48048]

∅:D[19.13861] → [9.47979:48048]

B:BD[9.47979] → [9.47979:48048]

B:BD[9.48048] → [20.3476:3508]

∅:D[20.3508] → [9.48134:48219]

B:BD[9.48134] → [9.48134:48219]

∅:D[9.48219] → [10.37285:37331]

B:BD[10.37285] → [10.37285:37331]

B:BD[10.37331] → [23.5573:5626]

B:BD[23.5626] → [26.997:1092]

∅:D[28.1003] → [10.37451:37491]

∅:D[26.1092] → [10.37451:37491]

∅:D[9.48315] → [10.37451:37491]

B:BD[10.37451] → [10.37451:37491]

B:BD[10.37491] → [9.48316:48510]

∅:D[9.48510] → [10.37659:37685]

B:BD[10.37659] → [10.37659:37685]

B:BD[10.37685] → [9.48511:48608]

∅:D[9.48608] → [10.37769:37944]

B:BD[10.37769] → [10.37769:37944]

B:BD[10.37944] → [19.13862:13919]

B:BD[19.13919] → [18.3946:3992]

∅:D[18.4038] → [9.48673:48742]

∅:D[19.14127] → [9.48673:48742]

B:BD[9.48673] → [9.48673:48742]

B:BD[9.48742] → [20.3509:3541]

∅:D[20.3541] → [9.48828:48913]

B:BD[9.48828] → [9.48828:48913]

∅:D[9.48913] → [10.38133:38224]

B:BD[10.38133] → [10.38133:38224]

B:BD[10.38224] → [23.5627:5680]

B:BD[23.5680] → [26.1093:1283]

∅:D[28.1184] → [10.38426:38468]

∅:D[26.1283] → [10.38426:38468]

∅:D[9.49104] → [10.38426:38468]

B:BD[10.38426] → [10.38426:38468]

B:BD[10.38468] → [9.49105:49293]

∅:D[9.49293] → [10.38630:38656]

B:BD[10.38630] → [10.38630:38656]

B:BD[10.38656] → [9.49294:49388]

∅:D[9.49388] → [10.38737:38875]

B:BD[10.38737] → [10.38737:38875]

B:BD[10.38875] → [19.14128:14185]

B:BD[19.14185] → [18.4039:4085]

∅:D[18.4131] → [9.49453:49522]

∅:D[19.14393] → [9.49453:49522]

B:BD[9.49453] → [9.49453:49522]

B:BD[9.49522] → [20.3542:3574]

∅:D[20.3574] → [9.49608:49693]

B:BD[9.49608] → [9.49608:49693]

∅:D[9.49693] → [10.39064:39134]

B:BD[10.39064] → [10.39064:39134]

B:BD[10.39134] → [23.5681:5734]

B:BD[23.5734] → [26.1284:1466]

∅:D[28.1357] → [10.39328:39370]

∅:D[26.1466] → [10.39328:39370]

∅:D[9.49876] → [10.39328:39370]

B:BD[10.39328] → [10.39328:39370]

B:BD[10.39370] → [9.49877:50059]

∅:D[9.50059] → [10.39526:39552]

B:BD[10.39526] → [10.39526:39552]

B:BD[10.39552] → [9.50060:50151]

∅:D[9.50151] → [10.39630:39774]

B:BD[10.39630] → [10.39630:39774]

B:BD[10.39774] → [19.14394:14451]

B:BD[19.14451] → [18.4132:4178]

∅:D[18.4224] → [9.50216:50285]

∅:D[19.14659] → [9.50216:50285]

B:BD[9.50216] → [9.50216:50285]

B:BD[9.50285] → [20.3575:3607]

∅:D[20.3607] → [9.50371:50456]

B:BD[9.50371] → [9.50371:50456]

∅:D[9.50456] → [10.39963:40038]

B:BD[10.39963] → [10.39963:40038]

B:BD[10.40038] → [23.5735:5788]

B:BD[23.5788] → [26.1467:1649]

∅:D[28.1530] → [10.40232:40274]

∅:D[26.1649] → [10.40232:40274]

∅:D[9.50639] → [10.40232:40274]

B:BD[10.40232] → [10.40232:40274]

B:BD[10.40274] → [9.50640:50822]

∅:D[9.50822] → [10.40430:40456]

B:BD[10.40430] → [10.40430:40456]

B:BD[10.40456] → [9.50823:50914]

∅:D[9.50914] → [10.40534:40539]

B:BD[10.40534] → [10.40534:40539]

-- some tests for operating over selections created using Shift- chords
-- we're just testing delete_selection, and it works the same for all keys
function test_backspace_over_selection()
  io.write('\ntest_backspace_over_selection')
  -- select just one character within a line with cursor before selection
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.selection1 = {line=1, pos=2}
  -- backspace deletes the selected character, even though it's after the cursor
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(Editor_state.lines[1].data, 'bc', "F - test_backspace_over_selection/data")
  -- cursor (remains) at start of selection
  check_eq(Editor_state.cursor1.line, 1, "F - test_backspace_over_selection/cursor:line")
  check_eq(Editor_state.cursor1.pos, 1, "F - test_backspace_over_selection/cursor:pos")
  -- selection is cleared
  check_nil(Editor_state.selection1.line, "F - test_backspace_over_selection/selection")
end
function test_backspace_over_selection_reverse()
  io.write('\ntest_backspace_over_selection_reverse')
  -- select just one character within a line with cursor after selection
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=2}
  Editor_state.selection1 = {line=1, pos=1}
  -- backspace deletes the selected character
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(Editor_state.lines[1].data, 'bc', "F - test_backspace_over_selection_reverse/data")
  -- cursor moves to start of selection
  check_eq(Editor_state.cursor1.line, 1, "F - test_backspace_over_selection_reverse/cursor:line")
  check_eq(Editor_state.cursor1.pos, 1, "F - test_backspace_over_selection_reverse/cursor:pos")
  -- selection is cleared
  check_nil(Editor_state.selection1.line, "F - test_backspace_over_selection_reverse/selection")
end
function test_backspace_over_multiple_lines()
  io.write('\ntest_backspace_over_multiple_lines')
  -- select just one character within a line with cursor after selection
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=2}
  Editor_state.selection1 = {line=4, pos=2}
  -- backspace deletes the region and joins the remaining portions of lines on either side
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(Editor_state.lines[1].data, 'akl', "F - test_backspace_over_multiple_lines/data:1")
  check_eq(Editor_state.lines[2].data, 'mno', "F - test_backspace_over_multiple_lines/data:2")
  -- cursor remains at start of selection
  check_eq(Editor_state.cursor1.line, 1, "F - test_backspace_over_multiple_lines/cursor:line")
  check_eq(Editor_state.cursor1.pos, 2, "F - test_backspace_over_multiple_lines/cursor:pos")
  -- selection is cleared
  check_nil(Editor_state.selection1.line, "F - test_backspace_over_multiple_lines/selection")
end
function test_backspace_to_end_of_line()
  io.write('\ntest_backspace_to_end_of_line')
  -- select region from cursor to end of line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=2}
  Editor_state.selection1 = {line=1, pos=4}
  -- backspace deletes rest of line without joining to any other line
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(Editor_state.lines[1].data, 'a', "F - test_backspace_to_start_of_line/data:1")
  check_eq(Editor_state.lines[2].data, 'def', "F - test_backspace_to_start_of_line/data:2")
  -- cursor remains at start of selection
  check_eq(Editor_state.cursor1.line, 1, "F - test_backspace_to_start_of_line/cursor:line")
  check_eq(Editor_state.cursor1.pos, 2, "F - test_backspace_to_start_of_line/cursor:pos")
  -- selection is cleared
  check_nil(Editor_state.selection1.line, "F - test_backspace_to_start_of_line/selection")
end
function test_backspace_to_start_of_line()
  io.write('\ntest_backspace_to_start_of_line')
  -- select region from cursor to start of line
  App.screen.init{width=Editor_state.left+30, height=60}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc', 'def', 'ghi', 'jkl', 'mno'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=2, pos=1}
  Editor_state.selection1 = {line=2, pos=3}
  -- backspace deletes beginning of line without joining to any other line
  edit.run_after_keychord(Editor_state, 'backspace')
  check_eq(Editor_state.lines[1].data, 'abc', "F - test_backspace_to_start_of_line/data:1")
  check_eq(Editor_state.lines[2].data, 'f', "F - test_backspace_to_start_of_line/data:2")
  -- cursor remains at start of selection
  check_eq(Editor_state.cursor1.line, 2, "F - test_backspace_to_start_of_line/cursor:line")
  check_eq(Editor_state.cursor1.pos, 1, "F - test_backspace_to_start_of_line/cursor:pos")
  -- selection is cleared
  check_nil(Editor_state.selection1.line, "F - test_backspace_to_start_of_line/selection")
end

Deletion in text_tests.lua at line 1507 [10.2]

B:BD[9.51358] → [9.51358:51546]

  check_nil(Editor_state.selection1.line, 'F - test_undo_insert_text/baseline/selection:line')
  check_nil(Editor_state.selection1.pos, 'F - test_undo_insert_text/baseline/selection:pos')

Deletion in text_tests.lua at line 1517 [10.2]

B:BD[9.51817] → [9.51817:51987]

  check_nil(Editor_state.selection1.line, 'F - test_undo_insert_text/selection:line')
  check_nil(Editor_state.selection1.pos, 'F - test_undo_insert_text/selection:pos')

Deletion in text_tests.lua at line 1538 [10.2]

B:BD[9.52534] → [9.52534:52722]

  check_nil(Editor_state.selection1.line, 'F - test_undo_delete_text/baseline/selection:line')
  check_nil(Editor_state.selection1.pos, 'F - test_undo_delete_text/baseline/selection:pos')

Deletion in text_tests.lua at line 1549 [10.2]

B:BD[9.52993] → [9.52993:53345]

  check_nil(Editor_state.selection1.line, 'F - test_undo_delete_text/selection:line')
  check_nil(Editor_state.selection1.pos, 'F - test_undo_delete_text/selection:pos')
--?   check_eq(Editor_state.selection1.line, 2, 'F - test_undo_delete_text/selection:line')
--?   check_eq(Editor_state.selection1.pos, 4, 'F - test_undo_delete_text/selection:pos')

Deletion in text_tests.lua at line 1557 [10.2]

B:BD[42.7] → [42.7:144]

B:BD[42.144] → [17.664:703]

B:BD[17.703] → [18.4319:4365]

∅:D[18.4365] → [9.53448:53489]

∅:D[19.15082] → [9.53448:53489]

B:BD[17.703] → [9.53448:53489]

B:BD[9.53489] → [20.3674:3706]

∅:D[20.3706] → [9.53575:53740]

B:BD[9.53575] → [9.53575:53740]

B:BD[9.53740] → [21.2292:2318]

∅:D[22.1313] → [42.355:381]

∅:D[21.2318] → [42.355:381]

B:BD[42.355] → [42.355:381]

B:BD[42.381] → [23.5986:6032]

B:BD[23.6032] → [26.1650:1741]

∅:D[28.1617] → [9.53832:53929]

∅:D[26.1741] → [9.53832:53929]

B:BD[9.53832] → [9.53832:53929]

∅:D[9.53929] → [42.574:584]

B:BD[42.574] → [42.574:584]

B:BD[42.584] → [23.6033:6127]

∅:D[43.34] → [42.616:643]

∅:D[23.6127] → [42.616:643]

B:BD[42.616] → [42.616:643]

B:BD[42.643] → [9.53930:54098]

∅:D[42.785] → [10.43796:43800]

∅:D[9.54098] → [10.43796:43800]

B:BD[10.43796] → [10.43796:43800]

B:BD[10.43800] → [44.2:3]

function test_undo_restores_selection()
  io.write('\ntest_undo_restores_selection')
  -- display a line of text with some part selected
  App.screen.init{width=75, height=80}
  Editor_state = edit.initialize_test_state()
  Editor_state.lines = load_array{'abc'}
  Text.redraw_all(Editor_state)
  Editor_state.cursor1 = {line=1, pos=1}
  Editor_state.selection1 = {line=1, pos=2}
  Editor_state.screen_top1 = {line=1, pos=1}
  Editor_state.screen_bottom1 = {}
  edit.draw(Editor_state)
  -- delete selected text
  edit.run_after_textinput(Editor_state, 'x')
  check_eq(Editor_state.lines[1].data, 'xbc', 'F - test_undo_restores_selection/baseline')
  check_nil(Editor_state.selection1.line, 'F - test_undo_restores_selection/baseline:selection')
  -- undo
  edit.run_after_keychord(Editor_state, 'C-z')
  edit.run_after_keychord(Editor_state, 'C-z')
  -- selection is restored
  check_eq(Editor_state.selection1.line, 1, 'F - test_undo_restores_selection/line')
  check_eq(Editor_state.selection1.pos, 2, 'F - test_undo_restores_selection/pos')
end

Deletion in text.lua at line 103 [45.1]

B:BD[3.1000] → [3.1000:1185]

      end
      if State.selection1.line then
        local lo, hi = Text.clip_selection(State, line_index, pos, pos+frag_len)
        Text.draw_highlight(State, line, x,y, pos, lo,hi)

Deletion in text.lua at line 151 [45.1]
∅:D[46.110] → [47.119:129]
∅:D[48.127] → [47.119:129]
∅:D[49.258] → [47.119:129]
∅:D[50.266] → [47.119:129]
B:BD[47.119] → [47.119:129]
B:BD[51.629] → [51.629:665]
B:BD[51.665] → [52.324:405]
∅:D[52.405] → [53.97:155]
B:BD[53.97] → [53.97:155]
```
      end
      if State.selection1.line then
        local lo, hi = Text.clip_selection(State, line_index, pos, pos+frag_len)
        Text.draw_highlight(State, line, x,y, pos, lo,hi)
```

Replacement in text.lua at line 346 [45.1]

B:BD[54.48] → [54.48:121]

--?   print('chord', chord, State.selection1.line, State.selection1.pos)

[54.48]

[55.1]

--?   print('chord', chord)

Deletion in text.lua at line 352 [45.1]
∅:D[56.469] → [54.166:192]
B:BD[57.27] → [54.166:192]
```
    State.selection1 = {}
```
Deletion in text.lua at line 369 [45.1]
B:BD[58.2081] → [54.1191:1225]
B:BD[54.1225] → [19.15514:15574]
∅:D[53.247] → [59.55:82]
∅:D[19.15574] → [59.55:82]
B:BD[54.1309] → [59.55:82]
∅:D[60.67] → [61.8453:8474]
∅:D[59.82] → [61.8453:8474]
∅:D[62.376] → [61.8453:8474]
∅:D[15.812] → [61.8453:8474]
∅:D[63.6820] → [61.8453:8474]
B:BD[61.8453] → [61.8453:8474]
```
    if State.selection1.line then
      Text.delete_selection(State, State.left, State.right)
      schedule_save(State)
      return
    end
```
Deletion in text.lua at line 406 [45.1]
B:BD[58.3066] → [54.2942:2976]
B:BD[54.2976] → [19.15732:15792]
∅:D[53.339] → [59.109:136]
∅:D[19.15792] → [59.109:136]
B:BD[54.3060] → [59.109:136]
∅:D[60.111] → [61.8533:8546]
∅:D[59.136] → [61.8533:8546]
∅:D[62.525] → [61.8533:8546]
∅:D[15.856] → [61.8533:8546]
∅:D[63.7038] → [61.8533:8546]
B:BD[61.8533] → [61.8533:8546]
B:BD[61.8546] → [64.1844:1852]
```
    if State.selection1.line then
      Text.delete_selection(State, State.left, State.right)
      schedule_save(State)
      return
    end
```
Deletion in text.lua at line 435 [45.1]
∅:D[56.587] → [54.4412:4438]
∅:D[19.15839] → [54.4412:4438]
B:BD[54.4412] → [54.4412:4438]
```
    State.selection1 = {}
```
Deletion in text.lua at line 437 [45.1]
∅:D[56.666] → [54.4510:4536]
∅:D[19.15887] → [54.4510:4536]
B:BD[54.4510] → [54.4510:4536]
```
    State.selection1 = {}
```
Deletion in text.lua at line 438 [45.1]
B:BD[61.8705] → [54.4537:4652]
∅:D[54.4652] → [61.8796:8804]
∅:D[9.62664] → [61.8796:8804]
B:BD[61.8796] → [61.8796:8804]
```
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
```
Deletion in text.lua at line 440 [45.1]
B:BD[61.8853] → [54.4724:4839]
∅:D[54.4839] → [61.8944:8952]
∅:D[9.62893] → [61.8944:8952]
B:BD[61.8944] → [61.8944:8952]
```
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
```
Deletion in text.lua at line 444 [45.1]
∅:D[56.906] → [54.4987:5013]
∅:D[19.16034] → [54.4987:5013]
B:BD[54.4987] → [54.4987:5013]
```
    State.selection1 = {}
```
Deletion in text.lua at line 446 [45.1]
∅:D[56.990] → [54.5090:5116]
∅:D[19.16087] → [54.5090:5116]
B:BD[54.5090] → [54.5090:5116]
```
    State.selection1 = {}
```
Deletion in text.lua at line 447 [45.1]
B:BD[61.9122] → [54.5117:5232]
∅:D[54.5232] → [61.9213:9221]
∅:D[9.63370] → [61.9213:9221]
B:BD[61.9213] → [61.9213:9221]
```
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
```
Deletion in text.lua at line 449 [45.1]
B:BD[61.9277] → [54.5309:5424]
∅:D[54.5424] → [61.9368:9376]
∅:D[9.63604] → [61.9368:9376]
B:BD[61.9368] → [61.9368:9376]
```
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
```
Deletion in text.lua at line 452 [45.1]
∅:D[56.1188] → [54.5502:5528]
B:BD[65.6016] → [54.5502:5528]
```
    State.selection1 = {}
```
Deletion in text.lua at line 454 [45.1]
∅:D[56.1273] → [54.5606:5632]
∅:D[19.16246] → [54.5606:5632]
B:BD[54.5606] → [54.5606:5632]
```
    State.selection1 = {}
```
Deletion in text.lua at line 455 [45.1]
B:BD[61.9549] → [54.5633:5748]
∅:D[54.5748] → [61.9640:9648]
∅:D[9.63998] → [61.9640:9648]
B:BD[61.9640] → [61.9640:9648]
```
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
```
Deletion in text.lua at line 457 [45.1]
B:BD[61.9699] → [54.5749:5864]
∅:D[54.5864] → [61.9790:9798]
∅:D[9.64142] → [61.9790:9798]
B:BD[61.9790] → [61.9790:9798]
```
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
```
Deletion in text.lua at line 460 [45.1]
∅:D[56.1465] → [54.6011:6037]
∅:D[19.16345] → [54.6011:6037]
B:BD[54.6011] → [54.6011:6037]
```
    State.selection1 = {}
```
Deletion in text.lua at line 462 [45.1]
∅:D[56.1543] → [54.6108:6134]
∅:D[19.16392] → [54.6108:6134]
B:BD[54.6108] → [54.6108:6134]
```
    State.selection1 = {}
```
Deletion in text.lua at line 463 [45.1]
B:BD[61.10019] → [54.6135:6250]
∅:D[54.6250] → [61.10110:10118]
∅:D[9.64612] → [61.10110:10118]
B:BD[61.10110] → [61.10110:10118]
```
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
```
Deletion in text.lua at line 465 [45.1]
B:BD[61.10164] → [54.6320:6435]
∅:D[54.6435] → [61.10255:10263]
∅:D[9.64839] → [61.10255:10263]
B:BD[61.10255] → [61.10255:10263]
```
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
```
Deletion in text.lua at line 468 [45.1]
∅:D[56.1777] → [54.6579:6605]
∅:D[19.16533] → [54.6579:6605]
B:BD[54.6579] → [54.6579:6605]
```
    State.selection1 = {}
```
Deletion in text.lua at line 470 [45.1]
∅:D[56.1859] → [54.6680:6706]
∅:D[19.16584] → [54.6680:6706]
B:BD[54.6680] → [54.6680:6706]
```
    State.selection1 = {}
```
Deletion in text.lua at line 471 [45.1]
B:BD[61.10435] → [54.6707:6822]
∅:D[54.6822] → [61.10526:10534]
∅:D[9.65310] → [61.10526:10534]
B:BD[61.10526] → [61.10526:10534]
```
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
```
Deletion in text.lua at line 473 [45.1]
B:BD[61.10588] → [54.6896:7011]
∅:D[54.7011] → [61.10679:10687]
∅:D[9.65541] → [61.10679:10687]
B:BD[61.10679] → [61.10679:10687]
```
    if State.selection1.line == nil then
      State.selection1 = {line=State.cursor1.line, pos=State.cursor1.pos}
    end
```
Deletion in text.lua at line 1145 [45.1]
∅:D[52.3710] → [66.5037:5077]
B:BD[66.5037] → [66.5037:5077]
```
--?   print('a', State.selection1.line)
```

Deletion in select.lua at line 2 [10.43980]

B:BD[10.44052] → [10.44052:44053]

B:BD[10.44053] → [53.342:426]

∅:D[53.426] → [10.44125:44321]

∅:D[9.78722] → [10.44125:44321]

B:BD[10.44125] → [10.44125:44321]

B:BD[10.44321] → [53.427:523]

∅:D[53.523] → [10.44405:44455]

∅:D[9.78833] → [10.44405:44455]

B:BD[10.44405] → [10.44405:44455]

B:BD[10.44455] → [52.3947:4007]

∅:D[52.4007] → [53.597:709]

B:BD[53.597] → [53.597:709]

B:BD[53.709] → [7.5:120]

∅:D[7.120] → [37.1185:1213]

B:BD[10.44671] → [37.1185:1213]

B:BD[37.1213] → [7.121:165]

∅:D[7.165] → [10.44737:44744]

∅:D[67.350] → [10.44737:44744]

∅:D[53.824] → [10.44737:44744]

∅:D[52.4046] → [10.44737:44744]

B:BD[10.44737] → [10.44737:44744]

B:BD[10.44744] → [7.166:244]

∅:D[7.244] → [10.44785:44791]

∅:D[53.878] → [10.44785:44791]

∅:D[9.79112] → [10.44785:44791]

B:BD[10.44785] → [10.44785:44791]

B:BD[10.44791] → [7.245:348]

∅:D[68.84] → [10.44813:44865]

∅:D[7.348] → [10.44813:44865]

B:BD[10.44813] → [10.44813:44865]

B:BD[10.44865] → [7.349:379]

∅:D[7.379] → [10.44952:45803]

B:BD[10.44952] → [10.44952:45803]

B:BD[10.45803] → [69.57:67]


-- Return any intersection of the region from State.selection1 to State.cursor1 (or
-- current mouse, if mouse is pressed; or recent mouse if mouse is pressed and
-- currently over a drawing) with the region between {line=line_index, pos=apos}
-- and {line=line_index, pos=bpos}.
-- apos must be less than bpos. However State.selection1 and State.cursor1 can be in any order.
-- Result: positions spos,epos between apos,bpos.
function Text.clip_selection(State, line_index, apos, bpos)
  if State.selection1.line == nil then return nil,nil end
  -- min,max = sorted(State.selection1,State.cursor1)
  local minl,minp,minpB = State.selection1.line,State.selection1.pos,State.selection1.posB
  local maxl,maxp,maxpB
  if App.mouse_down(1) then
    maxl,maxp,maxpB = Text.mouse_pos(State)
  else
    maxl,maxp,maxpB = State.cursor1.line,State.cursor1.pos,State.cursor1.posB
  end
  if Text.lt1({line=maxl, pos=maxp, posB=maxpB},
              {line=minl, pos=minp, posB=minpB}) then
    minl,maxl = maxl,minl
    minp,maxp = maxp,minp
    minpB,maxpB = maxpB,minpB
  end
  -- check if intervals are disjoint
  if line_index < minl then return nil,nil end
  if line_index > maxl then return nil,nil end
  if line_index == minl and bpos <= minp then return nil,nil end
  if line_index == maxl and apos >= maxp then return nil,nil end
  -- compare bounds more carefully (start inclusive, end exclusive)
  local a_ge = Text.le1({line=minl, pos=minp}, {line=line_index, pos=apos})
  local b_lt = Text.lt1({line=line_index, pos=bpos}, {line=maxl, pos=maxp})
--?   print(minl,line_index,maxl, '--', minp,apos,bpos,maxp, '--', a_ge,b_lt)
  if a_ge and b_lt then
    -- fully contained
    return apos,bpos
  elseif a_ge then
    assert(maxl == line_index)
    return apos,maxp
  elseif b_lt then
    assert(minl == line_index)
    return minp,bpos
  else
    assert(minl == maxl and minl == line_index)
    return minp,maxp
  end
end

Deletion in select.lua at line 27 [10.43980]
∅:D[70.309] → [10.45803:45876]
∅:D[69.999] → [10.45803:45876]
B:BD[10.45803] → [10.45803:45876]
B:BD[10.45876] → [52.4047:4078]
∅:D[67.388] → [10.45902:45938]
∅:D[53.1061] → [10.45902:45938]
∅:D[52.4078] → [10.45902:45938]
B:BD[10.45902] → [10.45902:45938]
B:BD[10.45938] → [53.1062:1135]
B:BD[53.1135] → [6.194:278]
∅:D[6.278] → [10.46046:46052]
∅:D[53.1194] → [10.46046:46052]
∅:D[9.79358] → [10.46046:46052]
B:BD[10.46046] → [10.46046:46052]
B:BD[10.46052] → [53.1195:1228]
B:BD[53.1228] → [6.279:352]
∅:D[6.352] → [10.46148:46163]
∅:D[67.463] → [10.46148:46163]
∅:D[53.1309] → [10.46148:46163]
∅:D[36.1343] → [10.46148:46163]
∅:D[52.4147] → [10.46148:46163]
B:BD[10.46148] → [10.46148:46163]
B:BD[10.46163] → [6.353:410]
∅:D[6.410] → [10.46219:46225]
∅:D[71.908] → [10.46219:46225]
∅:D[53.1378] → [10.46219:46225]
∅:D[9.79482] → [10.46219:46225]
B:BD[10.46219] → [10.46219:46225]
B:BD[10.46225] → [6.411:493]
∅:D[6.493] → [10.46270:46275]
∅:D[53.1436] → [10.46270:46275]
∅:D[9.79554] → [10.46270:46275]
B:BD[10.46270] → [10.46270:46275]
B:BD[10.46275] → [52.4148:4181]
∅:D[52.4181] → [53.1483:1531]
B:BD[53.1483] → [53.1483:1531]
B:BD[53.1531] → [28.7740:7858]
∅:D[28.7858] → [10.46481:46495]
B:BD[10.46481] → [10.46481:46495]
B:BD[10.46495] → [72.5:10]
B:BD[72.10] → [52.4293:4328]
∅:D[52.4328] → [53.1580:1669]
B:BD[53.1580] → [53.1580:1669]
B:BD[53.1669] → [52.4329:4360]
∅:D[67.583] → [72.100:116]
∅:D[53.1713] → [72.100:116]
∅:D[52.4360] → [72.100:116]
B:BD[72.100] → [72.100:116]
∅:D[72.116] → [10.46495:46500]
B:BD[10.46495] → [10.46495:46500]
B:BD[10.46500] → [52.4361:4399]
∅:D[52.4399] → [53.1765:1885]
B:BD[53.1765] → [53.1765:1885]
B:BD[53.1885] → [73.1894:1939]
B:BD[73.1939] → [52.4400:4444]
∅:D[52.4444] → [73.1940:2027]
B:BD[53.1943] → [73.1940:2027]
∅:D[53.2016] → [10.46735:46740]
∅:D[73.2027] → [10.46735:46740]
∅:D[9.79891] → [10.46735:46740]
B:BD[10.46735] → [10.46735:46740]
B:BD[10.46740] → [52.4445:4496]
∅:D[52.4496] → [53.2081:2305]
B:BD[53.2081] → [53.2081:2305]
∅:D[53.2305] → [10.46968:47135]
∅:D[9.80165] → [10.46968:47135]
B:BD[10.46968] → [10.46968:47135]
B:BD[10.47135] → [53.2306:2353]
B:BD[53.2353] → [71.909:949]
∅:D[71.949] → [53.2408:2509]
B:BD[53.2408] → [53.2408:2509]
B:BD[53.2509] → [5.366:441]
∅:D[5.441] → [32.1160:1166]
∅:D[74.512] → [32.1160:1166]
∅:D[75.1270] → [32.1160:1166]
∅:D[53.2592] → [32.1160:1166]
∅:D[52.4574] → [32.1160:1166]
∅:D[9.80515] → [32.1160:1166]
B:BD[32.1160] → [32.1160:1166]
B:BD[32.1166] → [53.2593:2617]
∅:D[53.2617] → [10.47231:47298]
∅:D[9.80547] → [10.47231:47298]
B:BD[10.47231] → [10.47231:47298]
B:BD[10.47298] → [76.564:608]
B:BD[76.608] → [26.6327:6453]
∅:D[77.1424] → [10.47487:47540]
∅:D[53.2782] → [10.47487:47540]
∅:D[26.6453] → [10.47487:47540]
∅:D[28.7975] → [10.47487:47540]
∅:D[9.80733] → [10.47487:47540]
B:BD[10.47487] → [10.47487:47540]
B:BD[10.47540] → [26.6454:6567]
∅:D[53.2896] → [10.47635:47674]
∅:D[26.6567] → [10.47635:47674]
∅:D[28.8074] → [10.47635:47674]
∅:D[9.80868] → [10.47635:47674]
B:BD[10.47635] → [10.47635:47674]
B:BD[10.47674] → [26.6568:6621]
∅:D[53.2950] → [10.47721:47747]
∅:D[26.6621] → [10.47721:47747]
∅:D[28.8123] → [10.47721:47747]
∅:D[9.80929] → [10.47721:47747]
B:BD[10.47721] → [10.47721:47747]
B:BD[10.47747] → [53.2951:2984]
B:BD[53.2984] → [78.1780:1818]
```
  end
end
-- inefficient for some reason, so don't do it on every frame
function Text.mouse_pos(State)
  local time = love.timer.getTime()
  if State.recent_mouse.time and State.recent_mouse.time > time-0.1 then
    return State.recent_mouse.line, State.recent_mouse.pos, State.recent_mouse.posB
  end
  State.recent_mouse.time = time
  local line,pos,posB = Text.to_pos(State, App.mouse_x(), App.mouse_y())
  if line then
    State.recent_mouse = {line=line, pos=pos, posB=posB}
  end
  return State.recent_mouse.line, State.recent_mouse.pos, State.recent_mouse.posB
end
function Text.to_pos(State, x,y)
  for line_index,line in ipairs(State.lines) do
    if Text.in_line(State, line_index, x,y) then
      return line_index, Text.to_pos_on_line(State, line_index, x,y)
    end
  end
end
function Text.cut_selection(State)
  if State.selection1.line == nil then return end
  local result = Text.selection(State)
  Text.delete_selection(State)
  return result
end
function Text.delete_selection(State)
  if State.selection1.line == nil then return end
  local minl,maxl = minmax(State.selection1.line, State.cursor1.line)
  local before = snapshot(State, minl, maxl)
  Text.delete_selection_without_undo(State)
  record_undo_event(State, {before=before, after=snapshot(State, State.cursor1.line)})
end
function Text.delete_selection_without_undo(State)
  if State.selection1.line == nil then return end
  -- min,max = sorted(State.selection1,State.cursor1)
  local minl,minp = State.selection1.line,State.selection1.pos
  local maxl,maxp = State.cursor1.line,State.cursor1.pos
  if minl > maxl then
    minl,maxl = maxl,minl
    minp,maxp = maxp,minp
  elseif minl == maxl then
    if minp > maxp then
      minp,maxp = maxp,minp
    end
  end
  -- update State.cursor1 and State.selection1
  State.cursor1 = {line=minl, pos=minp}
  if Text.lt1(State.cursor1, State.screen_top1) then
    State.screen_top1.line = State.cursor1.line
    State.screen_top1.pos = Text.pos_at_start_of_cursor_screen_line(State)
  end
  State.selection1 = {}
  -- delete everything between min (inclusive) and max (exclusive)
  Text.clear_screen_line_cache(State, minl)
  local min_offset = Text.offset(State.lines[minl].data, minp)
  local max_offset = Text.offset(State.lines[maxl].data, maxp)
  if minl == maxl then
--?     print('minl == maxl')
    State.lines[minl].data = State.lines[minl].data:sub(1, min_offset-1)..State.lines[minl].data:sub(max_offset)
    return
  end
  assert(minl < maxl)
  local rhs = State.lines[maxl].data:sub(max_offset)
  for i=maxl,minl+1,-1 do
    table.remove(State.lines, i)
    table.remove(State.line_cache, i)
```

Deletion in select.lua at line 28 [10.43980]

B:BD[10.47780] → [26.6622:6698]

  State.lines[minl].data = State.lines[minl].data:sub(1, min_offset-1)..rhs

Deletion in select.lua at line 29 [10.43980]
B:BD[10.47848] → [10.47848:47849]
B:BD[10.47849] → [53.3062:3317]
∅:D[53.3317] → [10.48057:48224]
∅:D[9.81335] → [10.48057:48224]
B:BD[10.48057] → [10.48057:48224]
B:BD[10.48224] → [26.6699:6825]
∅:D[77.1539] → [10.48338:48361]
∅:D[53.3444] → [10.48338:48361]
∅:D[26.6825] → [10.48338:48361]
∅:D[28.8307] → [10.48338:48361]
∅:D[9.81476] → [10.48338:48361]
B:BD[10.48338] → [10.48338:48361]
B:BD[10.48361] → [26.6826:6890]
∅:D[53.3509] → [10.48419:48447]
∅:D[26.6890] → [10.48419:48447]
∅:D[28.8367] → [10.48419:48447]
∅:D[9.81548] → [10.48419:48447]
B:BD[10.48419] → [10.48419:48447]
B:BD[10.48447] → [26.6891:6949]
∅:D[79.57] → [10.48503:48528]
∅:D[53.3568] → [10.48503:48528]
∅:D[26.6949] → [10.48503:48528]
∅:D[28.8421] → [10.48503:48528]
∅:D[9.81614] → [10.48503:48528]
B:BD[10.48503] → [10.48503:48528]
B:BD[10.48528] → [26.6950:6996]
∅:D[26.6996] → [10.48615:48621]
∅:D[28.8463] → [10.48615:48621]
B:BD[10.48615] → [10.48615:48621]
B:BD[10.48621] → [26.6997:7065]
∅:D[53.3728] → [79.163:199]
∅:D[26.7065] → [79.163:199]
∅:D[28.8527] → [79.163:199]
∅:D[9.81795] → [79.163:199]
B:BD[79.163] → [79.163:199]
B:BD[10.48805] → [10.48805:48809]
```
function Text.selection(State)
  if State.selection1.line == nil then return end
  -- min,max = sorted(State.selection1,State.cursor1)
  local minl,minp = State.selection1.line,State.selection1.pos
  local maxl,maxp = State.cursor1.line,State.cursor1.pos
  if minl > maxl then
    minl,maxl = maxl,minl
    minp,maxp = maxp,minp
  elseif minl == maxl then
    if minp > maxp then
      minp,maxp = maxp,minp
    end
  end
  local min_offset = Text.offset(State.lines[minl].data, minp)
  local max_offset = Text.offset(State.lines[maxl].data, maxp)
  if minl == maxl then
    return State.lines[minl].data:sub(min_offset, max_offset-1)
  end
  assert(minl < maxl)
  local result = {State.lines[minl].data:sub(min_offset)}
  for i=minl+1,maxl-1 do
    table.insert(result, State.lines[i].data)
  end
  table.insert(result, State.lines[maxl].data:sub(1, max_offset-1))
  return table.concat(result, '\n')
end
```

Deletion in edit.lua at line 50 [80.413]

∅:D[4.493] → [80.2846:2847]

∅:D[9.96721] → [80.2846:2847]

B:BD[80.2846] → [80.2846:2847]

B:BD[80.2847] → [9.96722:96999]


    selection1 = {},
    -- some extra state to compute selection between mouse press and release
    old_cursor1 = nil,
    old_selection1 = nil,
    mousepress_shift = nil,
    -- when selecting text, avoid recomputing some state on every single frame
    recent_mouse = {},

Deletion in edit.lua at line 135 [80.413]

B:BD[21.4581] → [81.530:619]

--?   print('press', State.selection1.line, State.selection1.pos, State.selection1.posB)

Deletion in edit.lua at line 139 [80.413]

B:BD[28.9966] → [28.9966:10607]

      -- delicate dance between cursor, selection and old cursor/selection
      -- scenarios:
      --  regular press+release: sets cursor, clears selection
      --  shift press+release:
      --    sets selection to old cursor if not set otherwise leaves it untouched
      --    sets cursor
      --  press and hold to start a selection: sets selection on press, cursor on release
      --  press and hold, then press shift: ignore shift
      --    i.e. mouse_released should never look at shift state
      State.old_cursor1 = State.cursor1
      State.old_selection1 = State.selection1
      State.mousepress_shift = App.shift_down()

Replacement in edit.lua at line 140 [80.413]

B:BD[6.569] → [6.569:632]

∅:D[6.632] → [81.620:717]

B:BD[28.10729] → [81.620:717]

      State.selection1 = {line=line_index, pos=pos, posB=posB}
--?       print('selection', State.selection1.line, State.selection1.pos, State.selection1.posB)

[6.569]

[28.10803]

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

Deletion in edit.lua at line 147 [80.413]

B:BD[21.5299] → [21.5299:5338]

∅:D[21.5338] → [80.8445:8468]

∅:D[9.101116] → [80.8445:8468]

B:BD[80.8445] → [80.8445:8468]

B:BD[80.8468] → [28.10816:10948]

B:BD[28.10948] → [6.633:761]

∅:D[6.761] → [81.718:803]

B:BD[28.11067] → [81.718:803]

∅:D[81.803] → [28.11132:11328]

B:BD[28.11132] → [28.11132:11328]

∅:D[28.11328] → [80.9594:9616]

B:BD[80.9594] → [80.9594:9616]

B:BD[80.9616] → [28.11329:11507]

∅:D[28.11507] → [80.9616:9624]

B:BD[80.9616] → [80.9616:9624]

∅:D[21.6276] → [80.9685:9691]

∅:D[9.102222] → [80.9685:9691]

B:BD[80.9685] → [80.9685:9691]

B:BD[80.9691] → [81.804:898]

  if State.search_term then return end
--?   print('release')
  for line_index,line in ipairs(State.lines) do
    if Text.in_line(State, line_index, x,y) then
--?       print('reset selection')
      local pos,posB = Text.to_pos_on_line(State, line_index, x, y)
      State.cursor1 = {line=line_index, pos=pos, posB=posB}
--?       print('cursor', State.cursor1.line, State.cursor1.pos, State.cursor1.posB)
      if State.mousepress_shift then
        if State.old_selection1.line == nil then
          State.selection1 = State.old_cursor1
        else
          State.selection1 = State.old_selection1
        end
      end
      State.old_cursor1, State.old_selection1, State.mousepress_shift = nil
      if eq(State.cursor1, State.selection1) then
        State.selection1 = {}
      end
      break
    end
  end
--?   print('selection:', State.selection1.line, State.selection1.pos, State.selection1.posB)

Deletion in edit.lua at line 162 [80.413]

B:BD[21.6800] → [21.6800:6831]

∅:D[21.6873] → [80.10522:10886]

∅:D[9.102812] → [80.10522:10886]

B:BD[80.10522] → [80.10522:10886]

B:BD[80.10886] → [19.22916:22974]

∅:D[53.3828] → [80.10956:10962]

∅:D[21.6956] → [80.10956:10962]

∅:D[19.22974] → [80.10956:10962]

∅:D[9.102909] → [80.10956:10962]

B:BD[80.10956] → [80.10956:10962]

  if State.selection1.line and
      -- printable character created using shift key => delete selection
      -- (we're not creating any ctrl-shift- or alt-shift- combinations using regular/printable keys)
      (not App.shift_down() or utf8.len(key) == 1) and
      chord ~= 'C-c' and chord ~= 'C-x' and chord ~= 'backspace' and backspace ~= 'delete' and not App.is_cursor_movement(chord) then
    Text.delete_selection(State, State.left, State.right)
  end

Deletion in edit.lua at line 220 [80.413]
B:BD[21.8038] → [21.8038:8087]
```
      State.selection1 = deepcopy(src.selection)
```
Deletion in edit.lua at line 233 [80.413]
B:BD[21.8320] → [21.8320:8369]
```
      State.selection1 = deepcopy(src.selection)
```

delete all selection code for now

Dependencies

In channels

Change contents

Deletion in text_tests.lua at line 257 [10.2]

Deletion in text_tests.lua at line 275 [10.2]

Deletion in text_tests.lua at line 294 [10.2]

Deletion in text_tests.lua at line 383 [10.2]

Deletion in text_tests.lua at line 402 [10.2]

Deletion in text_tests.lua at line 558 [10.2]

Deletion in text_tests.lua at line 560 [10.2]

Deletion in text_tests.lua at line 667 [10.2]

Replacement in text_tests.lua at line 668 [10.2]

Deletion in text_tests.lua at line 671 [10.2]

Deletion in text_tests.lua at line 673 [10.2]

Replacement in text_tests.lua at line 1416 [10.2]

Deletion in text_tests.lua at line 1493 [10.2]

Deletion in text_tests.lua at line 1507 [10.2]

Deletion in text_tests.lua at line 1517 [10.2]

Deletion in text_tests.lua at line 1538 [10.2]

Deletion in text_tests.lua at line 1549 [10.2]

Deletion in text_tests.lua at line 1557 [10.2]

Deletion in text.lua at line 103 [45.1]

Deletion in text.lua at line 151 [45.1]

Replacement in text.lua at line 346 [45.1]

Deletion in text.lua at line 352 [45.1]

Deletion in text.lua at line 369 [45.1]

Deletion in text.lua at line 406 [45.1]

Deletion in text.lua at line 435 [45.1]

Deletion in text.lua at line 437 [45.1]

Deletion in text.lua at line 438 [45.1]

Deletion in text.lua at line 440 [45.1]

Deletion in text.lua at line 444 [45.1]

Deletion in text.lua at line 446 [45.1]

Deletion in text.lua at line 447 [45.1]

Deletion in text.lua at line 449 [45.1]

Deletion in text.lua at line 452 [45.1]

Deletion in text.lua at line 454 [45.1]

Deletion in text.lua at line 455 [45.1]

Deletion in text.lua at line 457 [45.1]

Deletion in text.lua at line 460 [45.1]

Deletion in text.lua at line 462 [45.1]

Deletion in text.lua at line 463 [45.1]

Deletion in text.lua at line 465 [45.1]

Deletion in text.lua at line 468 [45.1]

Deletion in text.lua at line 470 [45.1]

Deletion in text.lua at line 471 [45.1]

Deletion in text.lua at line 473 [45.1]

Deletion in text.lua at line 1145 [45.1]

Deletion in select.lua at line 2 [10.43980]

Deletion in select.lua at line 27 [10.43980]